void test_empty()
{
IntVec v;
CYBOZU_TEST_EQUAL((int)v.size(), 0);
CYBOZU_TEST_ASSERT(v.empty());
for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) {
printf("%d\n", i->val());
}
v.push_back(3, 1);
CYBOZU_TEST_EQUAL((int)v.size(), 1);
CYBOZU_TEST_ASSERT(!v.empty());
for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) {
CYBOZU_TEST_EQUAL(i->pos(), (size_t)3);
CYBOZU_TEST_EQUAL(i->val(), 1);
}
v.push_back(4, 2);
CYBOZU_TEST_EQUAL((int)v.size(), 2);
int j = 0;
for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) {
CYBOZU_TEST_EQUAL(i->pos(), size_t(j + 3));
CYBOZU_TEST_EQUAL(i->val(), j + 1);
j++;
}
v.clear();
CYBOZU_TEST_EQUAL((int)v.size(), 0);
CYBOZU_TEST_ASSERT(v.empty());
IntVec v1, v2;
for (int i = 0; i < 3; i++) {
v1.push_back(i, i);
v2.push_back(i, i);
}
CYBOZU_TEST_ASSERT(v1 == v2);
v2.push_back(10, 10);
CYBOZU_TEST_ASSERT(v1 != v2);
}
double maxExpectation(int M, vector <int> day, vector <int> win, vector <int> gain) {
Max = M;
IIVec Days;
int i;
for (i = 0; i < (int)day.size(); ++i) {
if (win[i] > 0 && gain[i] > 0) {
Days.push_back(II(day[i], i));
}
}
sort(Days.begin(), Days.end());
_day.clear();
_win.clear();
_gain.clear();
memset(memo, 0, sizeof(memo));
for (i = 0; i < (int)Days.size(); ++i) {
_day.push_back(Days[i].first);
_win.push_back(win[Days[i].second] * 0.01);
_gain.push_back(gain[Days[i].second]);
}
if (Days.size() <= 0 || M <= _day[0]) {
return M;
}
return rec(0, M - _day[0]);
}
IntVec PrimeSwing::GetMultiplies( int _number, PrimeSieve& _sieve )
{
IntVec multiplies;
int sqrtN = static_cast<int>( sqrt( static_cast<double>(_number) ) );
int maxIdx = _sieve.GetPrimeIndex( sqrtN, 2, _sieve.GetNumberOfPrimes() );
for ( int i = 1; i < maxIdx; ++i )
{
int prime = _sieve.GetPrime(i);
int q = _number, p = 1;
while ((q /= prime) > 0)
if ((q & 1) == 1)
p *= prime;
if (p > 1)
multiplies.push_back(p);
}
int minIdx = maxIdx;
maxIdx = _sieve.GetPrimeIndex( _number / 3, minIdx, _sieve.GetNumberOfPrimes() );
for (int i = minIdx; i < maxIdx; ++i)
{
int prime = _sieve.GetPrime(i);
if (((_number / prime) & 1) == 1)
multiplies.push_back(prime);
}
return multiplies;
}
void ASMs1D::getBoundaryNodes (int lIndex, IntVec& glbNodes, int) const
{
if (!curv) return; // silently ignore empty patches
size_t iel = lIndex == 1 ? 0 : nel-1;
if (MLGE[iel] > 0)
{
if (lIndex == 1)
glbNodes.push_back(MLGN[MNPC[iel].front()]);
else if (lIndex == 2)
glbNodes.push_back(MLGN[MNPC[iel][curv->order()-1]]);
}
}
bool SIMoutput::writeGlvV (const Vector& vec, const char* fieldName,
int iStep, int& nBlock, int idBlock) const
{
if (vec.empty())
return true;
else if (!myVtf)
return false;
Matrix field;
Vector lovec;
IntVec vID;
int geomID = myGeomID;
for (size_t i = 0; i < myModel.size(); i++)
{
if (myModel[i]->empty()) continue; // skip empty patches
if (msgLevel > 1)
IFEM::cout <<"Writing vector field for patch "<< i+1 << std::endl;
myModel[i]->extractNodeVec(vec,lovec);
if (!myModel[i]->evalSolution(field,lovec,opt.nViz))
return false;
if (!myVtf->writeVres(field,++nBlock,++geomID,this->getNoSpaceDim()))
return false;
else
vID.push_back(nBlock);
}
return myVtf->writeVblk(vID,fieldName,idBlock,iStep);
}
void CEditableObject::GetBoneWorldTransform(u32 bone_idx, float t, CSMotion* motion, Fmatrix& matrix)
{
VERIFY(bone_idx<m_Bones.size());
int idx = bone_idx;
matrix.identity();
IntVec lst;
do{ lst.push_back(idx); }while((idx=m_Bones[idx]->Parent()?m_Bones[idx]->Parent()->SelfID:-1)>-1);
for (int i=lst.size()-1; i>=0; i--){
idx = lst[i];
Flags8 flags = motion->GetMotionFlags(idx);
Fvector T,R;
Fmatrix rot, mat;
motion->_Evaluate(idx,t,T,R);
if (flags.is(st_BoneMotion::flWorldOrient)){
rot.setXYZi(R.x,R.y,R.z);
mat.identity();
mat.c.set(T);
mat.mulA_43(matrix);
mat.i.set(rot.i);
mat.j.set(rot.j);
mat.k.set(rot.k);
}else{
mat.setXYZi(R.x,R.y,R.z);
mat.c.set(T);
mat.mulA_43(matrix);
}
matrix.set(mat);
}
}
bool SIMoutput::writeGlvE (const Vector& vec, int iStep, int& nBlock,
const char* name)
{
if (!myVtf)
return false;
Matrix infield(1,vec.size());
infield.fillRow(1,vec.ptr());
Matrix field;
int geomID = myGeomID;
IntVec sID;
for (size_t i = 0; i < myModel.size(); i++)
{
if (myModel[i]->empty()) continue; // skip empty patches
if (msgLevel > 1)
IFEM::cout <<"Writing element field "<< name
<<" for patch "<< i+1 << std::endl;
myModel[i]->extractElmRes(infield,field);
if (!myVtf->writeEres(field.getRow(1),++nBlock,++geomID))
return false;
sID.push_back(nBlock);
}
int idBlock = 300;
if (!myVtf->writeSblk(sID,name,++idBlock,iStep,true))
return false;
return true;
}
void ASMs3DLag::generateThreadGroups (char lIndex, bool)
{
if (threadGroupsFace.find(lIndex) != threadGroupsFace.end()) return;
const int p1 = svol->order(0);
const int p2 = svol->order(1);
const int p3 = svol->order(2);
const int n1 = (nx-1)/(p1-1);
const int n2 = (ny-1)/(p2-1);
const int n3 = (nz-1)/(p3-1);
// Find elements that are on the boundary face 'lIndex'
IntVec map; map.reserve(this->getNoBoundaryElms(lIndex,2));
int d1, d2, iel = 0;
for (int i3 = 1; i3 <= n3; i3++)
for (int i2 = 1; i2 <= n2; i2++)
for (int i1 = 1; i1 <= n1; i1++, iel++)
switch (lIndex)
{
case 1: if (i1 == 1) map.push_back(iel); break;
case 2: if (i1 == n1) map.push_back(iel); break;
case 3: if (i2 == 1) map.push_back(iel); break;
case 4: if (i2 == n2) map.push_back(iel); break;
case 5: if (i3 == 1) map.push_back(iel); break;
case 6: if (i3 == n3) map.push_back(iel); break;
}
switch (lIndex)
{
case 1:
case 2:
d1 = n2;
d2 = n3;
break;
case 3:
case 4:
d1 = n1;
d2 = n3;
break;
default:
d1 = n1;
d2 = n2;
}
threadGroupsFace[lIndex].calcGroups(d1,d2,1);
threadGroupsFace[lIndex].applyMap(map);
}
void add_train( string item, int label, MatVec & images, IntVec & labels )
{
Mat img = load(item);
if ( img.empty() ) return ;
images.push_back(img);
labels.push_back(label);
}
IntVec SpeckleyElements::prepareGhostIndices(int ownIndex)
{
IntVec indexArray;
numGhostElements = 0;
for (int i=0; i<numElements; i++) {
indexArray.push_back(i);
}
return indexArray;
}
void read_test(const string & fn, int label, IntVec & labels, StrVec & items, int maxiter)
{
ifstream pos(fn.c_str());
int i = 0;
while ( ! pos.eof() )
{
string item;
pos >> item;
if ( item.empty() ) break;
i++;
if ( i % 2 == 0 )
continue;
if ( i / 2 > maxiter )
break;
labels.push_back(label);
items.push_back(item);
}
}
bool SIMoutput::writeGlvM (const Mode& mode, bool freq, int& nBlock)
{
if (mode.eigVec.empty())
return true;
else if (!myVtf)
return false;
if (msgLevel > 1)
IFEM::cout <<"Writing eigenvector for Mode "<< mode.eigNo << std::endl;
Vector displ;
Matrix field;
IntVec vID;
int geomID = myGeomID;
for (size_t i = 0; i < myModel.size(); i++)
{
if (myModel[i]->empty()) continue; // skip empty patches
if (myModel.size() > 1 && msgLevel > 1)
IFEM::cout <<"."<< std::flush;
geomID++;
myModel[i]->extractNodeVec(mode.eigVec,displ);
if (!myModel[i]->evalSolution(field,displ,opt.nViz))
return false;
if (!myVtf->writeVres(field,++nBlock,geomID))
return false;
else
vID.push_back(nBlock);
}
if (myModel.size() > 1 && msgLevel > 1)
IFEM::cout << std::endl;
int idBlock = 10;
if (!myVtf->writeDblk(vID,"Mode Shape",idBlock,mode.eigNo))
return false;
return myVtf->writeState(mode.eigNo, freq ? "Frequency %g" : "Eigenvalue %g",
mode.eigVal, 1);
}
bool ASMstruct::addXNodes (unsigned short int dim, size_t nXn, IntVec& nodes)
{
if (dim != ndim-1)
{
std::cerr <<" *** ASMstruct::addXNodes: Invalid boundary dimension "<< dim
<<", only "<< (int)ndim-1 <<" is allowed."<< std::endl;
return false;
}
else if (!geo || shareFE == 'F')
return false; // logic error
else if (MNPC.size() == nel && MLGE.size() == nel)
{
// Extend the element number and element topology arrays to double size,
// to account for extra-ordinary elements associated with contact surfaces
myMLGE.resize(2*nel,0);
myMNPC.resize(2*nel);
}
else if (MLGE.size() != 2*nel || MNPC.size() != 2*nel)
{
// Already added interface elements, currently not allowed
std::cerr <<" *** ASMstruct::addXNodes: Already have interface elements."
<< std::endl;
return false;
}
// Add nXn extra-ordinary nodes to the list of global node numbers
for (size_t i = 0; i < nXn; i++)
{
if (nodes.size() == i)
nodes.push_back(++gNod);
myMLGN.push_back(nodes[i]);
}
return true;
}
bool SIMoutput::writeGlvF (const RealFunc& f, const char* fname,
int iStep, int& nBlock, int idBlock, double time)
{
if (!myVtf) return false;
IntVec sID;
int geomID = myGeomID;
for (size_t i = 0; i < myModel.size(); i++)
{
if (myModel[i]->empty()) continue; // skip empty patches
if (msgLevel > 1)
IFEM::cout <<"Writing function "<< fname
<<" for patch "<< i+1 << std::endl;
if (!myVtf->writeNfunc(f,time,++nBlock,++geomID))
return false;
else
sID.push_back(nBlock);
}
return myVtf->writeSblk(sID,fname,idBlock,iStep);
}
bool SIMoutput::dumpVector (const Vector& vsol, const char* fname,
utl::LogStream& os, std::streamsize precision) const
{
if (vsol.empty() || myPoints.empty())
return true;
size_t i, j, k;
Matrix sol1;
Vector lsol;
for (i = 0; i < myModel.size(); i++)
{
if (myModel[i]->empty()) continue; // skip empty patches
std::vector<ResPtPair>::const_iterator pit;
ResPointVec::const_iterator p;
std::array<RealArray,3> params;
IntVec points;
// Find all evaluation points within this patch, if any
for (j = 0, pit = myPoints.begin(); pit != myPoints.end(); ++pit)
for (p = pit->second.begin(); p != pit->second.end(); j++, ++p)
if (this->getLocalPatchIndex(p->patch) == (int)(i+1))
if (opt.discretization >= ASM::Spline)
{
points.push_back(p->inod > 0 ? p->inod : -(j+1));
for (k = 0; k < myModel[i]->getNoParamDim(); k++)
params[k].push_back(p->u[k]);
}
else if (p->inod > 0)
points.push_back(p->inod);
if (points.empty()) continue; // no points in this patch
// Evaluate/extracto nodal solution variables
myModel[i]->extractNodeVec(vsol,lsol);
if (opt.discretization >= ASM::Spline)
{
if (!myModel[i]->evalSolution(sol1,lsol,params.data(),false))
return false;
}
else
{
if (!myModel[i]->getSolution(sol1,lsol,points))
return false;
}
// Formatted output, use scientific notation with fixed field width
std::streamsize flWidth = 8 + precision;
std::streamsize oldPrec = os.precision(precision);
std::ios::fmtflags oldF = os.flags(std::ios::scientific | std::ios::right);
for (j = 0; j < points.size(); j++)
{
if (points[j] < 0)
os <<" Point #"<< -points[j];
else
{
points[j] = myModel[i]->getNodeID(points[j]);
os <<" Node #"<< points[j];
}
os <<":\t"<< fname <<" =";
for (k = 1; k <= sol1.rows(); k++)
os << std::setw(flWidth) << utl::trunc(sol1(k,j+1));
os << std::endl;
}
os.precision(oldPrec);
os.flags(oldF);
}
return true;
}
void test_intersect()
{
DoubleVec dv;
IntVec iv;
const struct {
unsigned int pos;
double val;
} dTbl[] = {
{ 5, 3.14 }, { 10, 2 }, { 12, 1.4 }, { 100, 2.3 }, { 1000, 4 },
};
const struct {
unsigned int pos;
int val;
} iTbl[] = {
{ 2, 4 }, { 5, 2 }, { 100, 4 }, { 101, 3}, { 999, 4 }, { 1000, 1 }, { 2000, 3 },
};
const struct {
unsigned int pos;
double d;
int i;
} interTbl[] = {
{ 5, 3.14, 2 }, { 100, 2.3, 4 }, { 1000, 4, 1 }
};
for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(dTbl); i++) {
dv.push_back(dTbl[i].pos, dTbl[i].val);
}
for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(iTbl); i++) {
iv.push_back(iTbl[i].pos, iTbl[i].val);
}
int j = 0;
for (typename DoubleVec::const_iterator i = dv.begin(), ie = dv.end(); i != ie; ++i) {
CYBOZU_TEST_EQUAL(i->pos(), dTbl[j].pos);
CYBOZU_TEST_EQUAL(i->val(), dTbl[j].val);
j++;
}
j = 0;
for (typename IntVec::const_iterator i = iv.begin(), ie = iv.end(); i != ie; ++i) {
CYBOZU_TEST_EQUAL(i->pos(), iTbl[j].pos);
CYBOZU_TEST_EQUAL(i->val(), iTbl[j].val);
j++;
}
int sum = 0;
for (typename IntVec::const_iterator i = iv.begin(), ie = iv.end(); i != ie; ++i) {
sum += i->val() * i->val();
}
CYBOZU_TEST_EQUAL(sum, 71);
typedef cybozu::nlp::Intersection<DoubleVec, IntVec> InterSection;
InterSection inter(dv, iv);
j = 0;
for (typename InterSection::const_iterator i = inter.begin(), ie = inter.end(); i != ie; ++i) {
CYBOZU_TEST_EQUAL(i->pos(), interTbl[j].pos);
CYBOZU_TEST_EQUAL(i->val1(), interTbl[j].d);
CYBOZU_TEST_EQUAL(i->val2(), interTbl[j].i);
j++;
}
}
bool ASMu3Dmx::assembleL2matrices (SparseMatrix& A, StdVector& B,
const IntegrandBase& integrand,
bool continuous) const
{
const int p1 = projBasis->order(0);
const int p2 = projBasis->order(1);
const int p3 = projBasis->order(2);
// Get Gaussian quadrature points
const int ng1 = continuous ? nGauss : p1 - 1;
const int ng2 = continuous ? nGauss : p2 - 1;
const int ng3 = continuous ? nGauss : p3 - 1;
const double* xg = GaussQuadrature::getCoord(ng1);
const double* yg = GaussQuadrature::getCoord(ng2);
const double* zg = GaussQuadrature::getCoord(ng3);
const double* wg = continuous ? GaussQuadrature::getWeight(nGauss) : nullptr;
if (!xg || !yg || !zg) return false;
if (continuous && !wg) return false;
size_t nnod = this->getNoProjectionNodes();
double dV = 0.0;
Vectors phi(2);
Matrices dNdu(2);
Matrix sField, Xnod, Jac;
std::vector<Go::BasisDerivs> spl1(2);
std::vector<Go::BasisPts> spl0(2);
// === Assembly loop over all elements in the patch ==========================
LR::LRSplineVolume* geoVol;
if (m_basis[geoBasis-1]->nBasisFunctions() == projBasis->nBasisFunctions())
geoVol = m_basis[geoBasis-1].get();
else
geoVol = projBasis.get();
for (const LR::Element* el1 : geoVol->getAllElements())
{
double uh = (el1->umin()+el1->umax())/2.0;
double vh = (el1->vmin()+el1->vmax())/2.0;
double wh = (el1->wmin()+el1->wmax())/2.0;
std::vector<size_t> els;
els.push_back(projBasis->getElementContaining(uh, vh, wh) + 1);
els.push_back(m_basis[geoBasis-1]->getElementContaining(uh, vh, wh) + 1);
if (continuous)
{
// Set up control point (nodal) coordinates for current element
if (!this->getElementCoordinates(Xnod,els[1]))
return false;
else if ((dV = 0.25*this->getParametricVolume(els[1])) < 0.0)
return false; // topology error (probably logic error)
}
// Compute parameter values of the Gauss points over this element
RealArray gpar[3], unstrGpar[3];
this->getGaussPointParameters(gpar[0],0,ng1,els[1],xg);
this->getGaussPointParameters(gpar[1],1,ng2,els[1],yg);
this->getGaussPointParameters(gpar[2],2,ng3,els[1],zg);
// convert to unstructred mesh representation
expandTensorGrid(gpar, unstrGpar);
// Evaluate the secondary solution at all integration points
if (!this->evalSolution(sField,integrand,unstrGpar))
return false;
// set up basis function size (for extractBasis subroutine)
const LR::Element* elm = projBasis->getElement(els[0]-1);
phi[0].resize(elm->nBasisFunctions());
phi[1].resize(el1->nBasisFunctions());
IntVec lmnpc;
if (projBasis != m_basis[0]) {
lmnpc.reserve(phi[0].size());
for (const LR::Basisfunction* f : elm->support())
lmnpc.push_back(f->getId());
}
const IntVec& mnpc = projBasis == m_basis[0] ? MNPC[els[1]-1] : lmnpc;
// --- Integration loop over all Gauss points in each direction ----------
Matrix eA(phi[0].size(), phi[0].size());
Vectors eB(sField.rows(), Vector(phi[0].size()));
int ip = 0;
for (int k = 0; k < ng3; k++)
for (int j = 0; j < ng2; j++)
for (int i = 0; i < ng1; i++, ip++)
{
if (continuous)
{
projBasis->computeBasis(gpar[0][i], gpar[1][j], gpar[2][k],
spl1[0], els[0]-1);
SplineUtils::extractBasis(spl1[0],phi[0],dNdu[0]);
m_basis[geoBasis-1]->computeBasis(gpar[0][i], gpar[1][j], gpar[2][k],
spl1[1], els[1]-1);
SplineUtils::extractBasis(spl1[1], phi[1], dNdu[1]);
}
else
{
projBasis->computeBasis(gpar[0][i], gpar[1][j], gpar[2][k],
spl0[0], els[0]-1);
phi[0] = spl0[0].basisValues;
}
// Compute the Jacobian inverse and derivatives
double dJw = 1.0;
if (continuous)
{
dJw = dV*wg[i]*wg[j]*wg[k]*utl::Jacobian(Jac,dNdu[1],Xnod,dNdu[1],false);
if (dJw == 0.0) continue; // skip singular points
}
// Integrate the mass matrix
eA.outer_product(phi[0], phi[0], true, dJw);
// Integrate the rhs vector B
for (size_t r = 1; r <= sField.rows(); r++)
eB[r-1].add(phi[0],sField(r,ip+1)*dJw);
}
for (size_t i = 0; i < eA.rows(); ++i) {
for (size_t j = 0; j < eA.cols(); ++j)
A(mnpc[i]+1, mnpc[j]+1) += eA(i+1,j+1);
int jp = mnpc[i]+1;
for (size_t r = 0; r < sField.rows(); r++, jp += nnod)
B(jp) += eB[r](1+i);
}
}
return true;
}
bool ASMs3Dmx::assembleL2matrices (SparseMatrix& A, StdVector& B,
const IntegrandBase& integrand,
bool continuous) const
{
const size_t nnod = projBasis->numCoefs(0) *
projBasis->numCoefs(1) *
projBasis->numCoefs(2);
const int p1 = svol->order(0);
const int p2 = svol->order(1);
const int p3 = svol->order(2);
const int p11 = projBasis->order(0);
const int p21 = projBasis->order(1);
const int p31 = projBasis->order(2);
const int n1 = svol->numCoefs(0);
const int n2 = svol->numCoefs(1);
const int n3 = svol->numCoefs(2);
const int nel1 = n1 - p1 + 1;
const int nel2 = n2 - p2 + 1;
const int nel3 = n3 - p3 + 1;
// Get Gaussian quadrature point coordinates (and weights if continuous)
const int ng1 = continuous ? nGauss : p1 - 1;
const int ng2 = continuous ? nGauss : p2 - 1;
const int ng3 = continuous ? nGauss : p3 - 1;
const double* xg = GaussQuadrature::getCoord(ng1);
const double* yg = GaussQuadrature::getCoord(ng2);
const double* zg = GaussQuadrature::getCoord(ng3);
const double* wg = continuous ? GaussQuadrature::getWeight(nGauss) : 0;
if (!xg || !yg || !zg) return false;
if (continuous && !wg) return false;
// Compute parameter values of the Gauss points over the whole patch
Matrix gp;
std::array<RealArray,3> gpar;
gpar[0] = this->getGaussPointParameters(gp,0,ng1,xg);
gpar[1] = this->getGaussPointParameters(gp,1,ng2,yg);
gpar[2] = this->getGaussPointParameters(gp,2,ng3,zg);
// Evaluate basis functions at all integration points
std::vector<Go::BasisPts> spl0;
std::array<std::vector<Go::BasisDerivs>,2> spl1;
if (continuous) {
projBasis->computeBasisGrid(gpar[0],gpar[1],gpar[2],spl1[0]);
svol->computeBasisGrid(gpar[0],gpar[1],gpar[2],spl1[1]);
} else
projBasis->computeBasisGrid(gpar[0],gpar[1],gpar[2],spl0);
// Evaluate the secondary solution at all integration points
Matrix sField;
if (!this->evalSolution(sField,integrand,gpar.data()))
{
std::cerr <<" *** ASMs3D::assembleL2matrices: Failed for patch "<< idx+1
<<" nPoints="<< gpar[0].size()*gpar[1].size()*gpar[2].size()
<< std::endl;
return false;
}
double dV = 1.0;
std::array<Vector,2> phi;
phi[0].resize(p11*p21*p31);
phi[1].resize(p1*p2*p3);
std::array<Matrix,2> dNdu;
Matrix Xnod, J;
// === Assembly loop over all elements in the patch ==========================
int iel = 0;
for (int i3 = 0; i3 < nel3; i3++)
for (int i2 = 0; i2 < nel2; i2++)
for (int i1 = 0; i1 < nel1; i1++, iel++)
{
if (MLGE[iel] < 1) continue; // zero-volume element
if (continuous)
{
// Set up control point (nodal) coordinates for current element
if (!this->getElementCoordinates(Xnod,1+iel))
return false;
else if ((dV = 0.125*this->getParametricVolume(1+iel)) < 0.0)
return false; // topology error (probably logic error)
}
int ip = ((i3*ng2*nel2 + i2)*ng1*nel1 + i1)*ng3;
IntVec lmnpc;
if (projBasis != m_basis[0]) {
lmnpc.reserve(phi[0].size());
int nuv = projBasis->numCoefs(0)*projBasis->numCoefs(1);
int widx = (spl1[0][ip].left_idx[2]-p31+1)*nuv;
for (int k = 0; k < p31; ++k, widx += nuv) {
int vidx = (spl1[0][ip].left_idx[1]-p21+1)*projBasis->numCoefs(0);
for (int j = 0; j < p21; ++j, vidx += projBasis->numCoefs(0))
for (int i = 0; i < p11; ++i)
if (continuous)
lmnpc.push_back(spl1[0][ip].left_idx[0]-p11+1+i+vidx+widx);
else
lmnpc.push_back(spl0[ip].left_idx[0]-p11+1+i+vidx+widx);
}
}
const IntVec& mnpc = projBasis == m_basis[0] ? MNPC[iel] : lmnpc;
// --- Integration loop over all Gauss points in each direction --------
Matrix eA(p11*p21*p31, p11*p21*p31);
Vectors eB(sField.rows(), Vector(p11*p21*p31));
for (int k = 0; k < ng3; k++, ip += ng2*(nel2-1)*ng1*nel1)
for (int j = 0; j < ng2; j++, ip += ng1*(nel1-1))
for (int i = 0; i < ng1; i++, ip++)
{
if (continuous) {
SplineUtils::extractBasis(spl1[0][ip],phi[0],dNdu[0]);
SplineUtils::extractBasis(spl1[1][ip],phi[1],dNdu[1]);
} else
phi[0] = spl0[ip].basisValues;
// Compute the Jacobian inverse and derivatives
double dJw = dV;
if (continuous)
{
dJw *= wg[i]*wg[j]*wg[k]*utl::Jacobian(J,dNdu[1],Xnod,dNdu[1],false);
if (dJw == 0.0) continue; // skip singular points
}
// Integrate the mass matrix
eA.outer_product(phi[0], phi[0], true, dJw);
// Integrate the rhs vector B
for (size_t r = 1; r <= sField.rows(); r++)
eB[r-1].add(phi[0],sField(r,ip+1)*dJw);
}
for (int i = 0; i < p11*p21*p31; ++i) {
for (int j = 0; j < p11*p21*p31; ++j)
A(mnpc[i]+1, mnpc[j]+1) += eA(i+1, j+1);
int jp = mnpc[i]+1;
for (size_t r = 0; r < sField.rows(); r++, jp += nnod)
B(jp) += eB[r](1+i);
}
}
return true;
}
void* RegisterInitControl::createIntVec(unsigned long long val)
{
IntVec* vec = new IntVec;
vec->push_back(val);
return vec;
}
bool SIMoutput::dumpResults (const Vector& psol, double time,
utl::LogStream& os, const ResPointVec& gPoints,
bool formatted, std::streamsize precision) const
{
if (gPoints.empty())
return true;
size_t i, j, k;
Matrix sol1, sol2;
Vector reactionFS;
const Vector* reactionForces = myEqSys->getReactions();
for (i = 0; i < myModel.size(); i++)
{
if (myModel[i]->empty()) continue; // skip empty patches
ResPointVec::const_iterator p;
std::array<RealArray,3> params;
IntVec points;
// Find all evaluation points within this patch, if any
for (j = 0, p = gPoints.begin(); p != gPoints.end(); j++, p++)
if (this->getLocalPatchIndex(p->patch) == (int)(i+1))
if (opt.discretization >= ASM::Spline)
{
points.push_back(p->inod > 0 ? p->inod : -(j+1));
for (k = 0; k < myModel[i]->getNoParamDim(); k++)
params[k].push_back(p->u[k]);
}
else if (p->inod > 0)
points.push_back(p->inod);
if (points.empty()) continue; // no points in this patch
myModel[i]->extractNodeVec(psol,myProblem->getSolution());
if (opt.discretization >= ASM::Spline)
{
// Evaluate the primary solution variables
if (!myModel[i]->evalSolution(sol1,myProblem->getSolution(),
params.data(),false))
return false;
// Evaluate the secondary solution variables
LocalSystem::patch = i;
if (myProblem->getNoFields(2) > 0)
{
const_cast<SIMoutput*>(this)->setPatchMaterial(i+1);
if (!myModel[i]->evalSolution(sol2,*myProblem,params.data(),false))
return false;
}
}
else
// Extract nodal primary solution variables
if (!myModel[i]->getSolution(sol1,myProblem->getSolution(),points))
return false;
// Formatted output, use scientific notation with fixed field width
std::streamsize flWidth = 8 + precision;
std::streamsize oldPrec = os.precision(precision);
std::ios::fmtflags oldF = os.flags(std::ios::scientific | std::ios::right);
for (j = 0; j < points.size(); j++)
{
if (!formatted)
os << time <<" ";
else if (points[j] < 0)
os <<" Point #"<< -points[j] <<":\tsol1 =";
else
{
points[j] = myModel[i]->getNodeID(points[j]);
os <<" Node #"<< points[j] <<":\tsol1 =";
}
for (k = 1; k <= sol1.rows(); k++)
os << std::setw(flWidth) << utl::trunc(sol1(k,j+1));
if (opt.discretization >= ASM::Spline)
{
if (formatted && sol2.rows() > 0)
os <<"\n\t\tsol2 =";
for (k = 1; k <= sol2.rows(); k++)
os << std::setw(flWidth) << utl::trunc(sol2(k,j+1));
}
if (reactionForces && points[j] > 0)
// Print nodal reaction forces for nodes with prescribed DOFs
if (mySam->getNodalReactions(points[j],*reactionForces,reactionFS))
{
if (formatted)
os <<"\n\t\treac =";
for (k = 0; k < reactionFS.size(); k++)
os << std::setw(flWidth) << utl::trunc(reactionFS[k]);
}
os << std::endl;
}
os.precision(oldPrec);
os.flags(oldF);
}
return true;
}
////////////////////////////////////////////////////////////////////////////////////////
// CreateStrips()
//
// Generates actual strips from the list-in-strip-order.
//
void NvStripifier::CreateStrips(const NvStripInfoVec& allStrips, IntVec& stripIndices,
const bool bStitchStrips, unsigned int& numSeparateStrips,
const bool bRestart, const unsigned int restartVal)
{
assert(numSeparateStrips == 0);
NvFaceInfo tLastFace(0, 0, 0);
NvFaceInfo tPrevStripLastFace(0, 0, 0);
size_t nStripCount = allStrips.size();
//we infer the cw/ccw ordering depending on the number of indices
//this is screwed up by the fact that we insert -1s to denote changing strips
//this is to account for that
int accountForNegatives = 0;
for (size_t i = 0; i < nStripCount; i++)
{
NvStripInfo *strip = allStrips[i];
int nStripFaceCount = strip->m_faces.size();
assert(nStripFaceCount > 0);
// Handle the first face in the strip
{
NvFaceInfo tFirstFace(strip->m_faces[0]->m_v0, strip->m_faces[0]->m_v1, strip->m_faces[0]->m_v2);
// If there is a second face, reorder vertices such that the
// unique vertex is first
if (nStripFaceCount > 1)
{
int nUnique = NvStripifier::GetUniqueVertexInB(strip->m_faces[1], &tFirstFace);
if (nUnique == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v1);
}
else if (nUnique == tFirstFace.m_v2)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v2);
}
// If there is a third face, reorder vertices such that the
// shared vertex is last
if (nStripFaceCount > 2)
{
if(IsDegenerate(strip->m_faces[1]))
{
int pivot = strip->m_faces[1]->m_v1;
if(tFirstFace.m_v1 == pivot)
{
SWAP(tFirstFace.m_v1, tFirstFace.m_v2);
}
}
else
{
int nShared0, nShared1;
GetSharedVertices(strip->m_faces[2], &tFirstFace, &nShared0, &nShared1);
if ( (nShared0 == tFirstFace.m_v1) && (nShared1 == -1) )
{
SWAP(tFirstFace.m_v1, tFirstFace.m_v2);
}
}
}
}
if( (i == 0) || !bStitchStrips || bRestart)
{
if(!IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
stripIndices.push_back(tFirstFace.m_v0);
}
else
{
// Double tap the first in the new strip
stripIndices.push_back(tFirstFace.m_v0);
// Check CW/CCW ordering
if (NextIsCW(stripIndices.size() - accountForNegatives) != IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
{
stripIndices.push_back(tFirstFace.m_v0);
}
}
stripIndices.push_back(tFirstFace.m_v0);
stripIndices.push_back(tFirstFace.m_v1);
stripIndices.push_back(tFirstFace.m_v2);
// Update last face info
tLastFace = tFirstFace;
}
for (int j = 1; j < nStripFaceCount; j++)
{
int nUnique = GetUniqueVertexInB(&tLastFace, strip->m_faces[j]);
if (nUnique != -1)
{
stripIndices.push_back(nUnique);
// Update last face info
tLastFace.m_v0 = tLastFace.m_v1;
tLastFace.m_v1 = tLastFace.m_v2;
tLastFace.m_v2 = nUnique;
}
else
{
//we've hit a degenerate
stripIndices.push_back(strip->m_faces[j]->m_v2);
tLastFace.m_v0 = strip->m_faces[j]->m_v0;//tLastFace.m_v1;
tLastFace.m_v1 = strip->m_faces[j]->m_v1;//tLastFace.m_v2;
tLastFace.m_v2 = strip->m_faces[j]->m_v2;//tLastFace.m_v1;
}
}
// Double tap between strips.
if (bStitchStrips && !bRestart)
{
if (i != nStripCount - 1)
stripIndices.push_back(tLastFace.m_v2);
}
else if (bRestart)
{
stripIndices.push_back(restartVal);
}
else
{
//-1 index indicates next strip
stripIndices.push_back(-1);
accountForNegatives++;
numSeparateStrips++;
}
// Update last face info
tLastFace.m_v0 = tLastFace.m_v1;
tLastFace.m_v1 = tLastFace.m_v2;
tLastFace.m_v2 = tLastFace.m_v2;
}
if(bStitchStrips || bRestart)
numSeparateStrips = 1;
}
void ConvexDecomp(const pcl::PointCloud<pcl::PointXYZ>::ConstPtr& cloud, const Eigen::MatrixXf& dirs, float thresh,
/*optional outputs: */ std::vector<IntVec>* indices, std::vector< IntVec >* hull_indices)
{
int k_neighbs = 5;
pcl::KdTreeFLANN<pcl::PointXYZ>::Ptr tree(new pcl::KdTreeFLANN<pcl::PointXYZ>(true));
tree->setEpsilon(0);
tree->setInputCloud(cloud);
int n_pts = cloud->size();
int n_dirs = dirs.rows();
DEBUG_PRINT("npts, ndirs %i %i\n", n_pts, n_dirs);
MatrixXf dirs4(n_dirs, 4);
dirs4.leftCols(3) = dirs;
dirs4.col(3).setZero();
MatrixXf pt2supports = Map< const Matrix<float, Dynamic, Dynamic, RowMajor > >(reinterpret_cast<const float*>(cloud->points.data()), n_pts, 4) * dirs4.transpose();
const int UNLABELED = -1;
IntVec pt2label(n_pts, UNLABELED);
IntSet alldirs;
for(int i = 0; i < n_dirs; ++i) alldirs.insert(i);
int i_seed = 0;
int i_label = 0;
// each loop cycle, add a new cluster
while(true)
{
// find first unlabeled point
while(true)
{
if(i_seed == n_pts) return;
if(pt2label[i_seed] == UNLABELED) break;
++i_seed;
}
pt2label[i_seed] = i_label;
map<int, IntSet> pt2dirs;
pt2dirs[i_seed] = alldirs;
vector<SupInfo> dir2supinfo(n_dirs);
for(int i_dir = 0; i_dir < n_dirs; ++i_dir)
{
float seedsup = pt2supports(i_seed, i_dir);
dir2supinfo[i_dir].inds.push_back(i_seed);
dir2supinfo[i_dir].sups.push_back(seedsup);
dir2supinfo[i_dir].best = seedsup;
}
DEBUG_PRINT("seed: %i\n", i_seed);
IntSet exclude_frontier;
exclude_frontier.insert(i_seed);
queue<int> frontier;
BOOST_FOREACH(const int & i_nb, getNeighbors(*tree, i_seed, k_neighbs, 2 * thresh))
{
if(pt2label[i_nb] == UNLABELED && exclude_frontier.find(i_nb) == exclude_frontier.end())
{
DEBUG_PRINT("adding %i to frontier\n", i_nb);
frontier.push(i_nb);
exclude_frontier.insert(i_nb);
}
}
while(!frontier.empty())
{
#if 0 // for serious debugging
vector<int> clu;
BOOST_FOREACH(Int2IntSet::value_type & pt_dir, pt2dirs)
{
clu.push_back(pt_dir.first);
}
MatrixXd sup_pd(clu.size(), n_dirs);
for(int i = 0; i < clu.size(); ++i)
{
for(int i_dir = 0; i_dir < n_dirs; ++i_dir)
{
sup_pd(i, i_dir) = pt2supports(clu[i], i_dir);
}
}
for(int i_dir = 0; i_dir < n_dirs; ++i_dir)
{
IntSet nearext;
for(int i = 0; i < clu.size(); ++i)
{
if(sup_pd.col(i_dir).maxCoeff() - sup_pd(i, i_dir) < thresh)
{
nearext.insert(clu[i]);
}
}
assert(toSet(dir2supinfo[i_dir].inds) == nearext);
}
printf("ok!\n");
#endif
int i_cur = frontier.front();
frontier.pop();
// printf("cur: %i\n", i_cur);
DEBUG_PRINT("pt2dirs %s", Str(pt2dirs).c_str());
bool reject = false;
Int2Int pt2decrement;
for(int i_dir = 0; i_dir < n_dirs; ++i_dir)
{
float cursup = pt2supports(i_cur, i_dir);
SupInfo& si = dir2supinfo[i_dir];
if(cursup > si.best)
{
for(int i = 0; i < si.inds.size(); ++i)
{
float sup = si.sups[i];
int i_pt = si.inds[i];
if(cursup - sup > thresh)
{
pt2decrement[i_pt] = pt2decrement[i_pt] + 1;
DEBUG_PRINT("decrementing %i (dir %i)\n", i_pt, i_dir);
}
}
}
}
DEBUG_PRINT("pt2dec: %s", Str(pt2decrement).c_str());
BOOST_FOREACH(const Int2Int::value_type & pt_dec, pt2decrement)
{
if(pt_dec.second == pt2dirs[pt_dec.first].size())
{
reject = true;
break;
}
}
DEBUG_PRINT("reject? %i\n", reject);
if(!reject)
{
pt2label[i_cur] = i_label;
pt2dirs[i_cur] = IntSet();
for(int i_dir = 0; i_dir < n_dirs; ++i_dir)
{
float cursup = pt2supports(i_cur, i_dir);
if(cursup > dir2supinfo[i_dir].best - thresh) pt2dirs[i_cur].insert(i_dir);
}
for(int i_dir = 0; i_dir < n_dirs; ++i_dir)
{
float cursup = pt2supports(i_cur, i_dir);
SupInfo& si = dir2supinfo[i_dir];
if(cursup > si.best)
{
IntVec filtinds;
FloatVec filtsups;
for(int i = 0; i < si.inds.size(); ++i)
{
float sup = si.sups[i];
int i_pt = si.inds[i];
if(cursup - sup > thresh)
{
pt2dirs[i_pt].erase(i_dir);
}
else
{
filtinds.push_back(i_pt);
filtsups.push_back(sup);
}
}
si.inds = filtinds;
si.sups = filtsups;
si.inds.push_back(i_cur);
si.sups.push_back(cursup);
si.best = cursup;
}
else if(cursup > si.best - thresh)
{
si.inds.push_back(i_cur);
si.sups.push_back(cursup);
}
}
BOOST_FOREACH(const int & i_nb, getNeighbors(*tree, i_cur, k_neighbs, 2 * thresh))
{
if(pt2label[i_nb] == UNLABELED && exclude_frontier.find(i_nb) == exclude_frontier.end())
{
DEBUG_PRINT("adding %i to frontier\n", i_nb);
frontier.push(i_nb);
exclude_frontier.insert(i_nb);
}
}
} // if !reject
else
{
}
} // while frontier nonempty
if(indices != NULL)
