//==============================================================================
int load_elem_data(fei::MatrixGraph* matrixGraph,
fei::Matrix* mat, fei::Vector* rhs,
PoissonData& poissonData)
{
GlobalID elemBlockID = poissonData.getElemBlockID();
int numLocalElements = poissonData.getNumLocalElements();
GlobalID* elemIDs = poissonData.getLocalElementIDs();
int numIndices = matrixGraph->getConnectivityNumIndices(elemBlockID);
std::vector<int> indicesArray(numIndices);
int* indicesPtr = &indicesArray[0];
for(int elem=0; elem<numLocalElements; elem++) {
double** elemStiffness = poissonData.getElemStiffness(elemIDs[elem]);
int checkNumIndices = 0;
CHK_ERR( matrixGraph->getConnectivityIndices(elemBlockID, elemIDs[elem],
numIndices, indicesPtr,
checkNumIndices) );
if (checkNumIndices != numIndices) return(-1);
CHK_ERR( mat->sumIn(elemBlockID, elemIDs[elem],
elemStiffness));
double* elemLoad = poissonData.getElemLoad(elemIDs[elem]);
CHK_ERR( rhs->sumIn(numIndices, indicesPtr, elemLoad));
}
return(0);
}
static HdMeshTopology
_GenerateCapsuleMeshTopology()
{
int numCounts = _slices * (_stacks + 2 * _hemisphereStacks);
int numIndices = 4 * _slices * _stacks // cylinder quads
+ 4 * 2 * _slices * (_hemisphereStacks-1) // hemisphere quads
+ 3 * 2 * _slices; // end cap tris
VtIntArray countsArray(numCounts);
int * counts = countsArray.data();
VtIntArray indicesArray(numIndices);
int * indices = indicesArray.data();
// populate face counts and face indices
int face = 0, index = 0, p = 0;
// base hemisphere end cap triangles
int base = p++;
for (int i=0; i<_slices; ++i) {
counts[face++] = 3;
indices[index++] = p + (i+1)%_slices;
indices[index++] = p + i;
indices[index++] = base;
}
// middle and hemisphere quads
for (int i=0; i<_stacks+2*(_hemisphereStacks-1); ++i) {
for (int j=0; j<_slices; ++j) {
float x0 = 0;
float x1 = x0 + _slices;
float y0 = j;
float y1 = (j + 1) % _slices;
counts[face++] = 4;
indices[index++] = p + x0 + y0;
indices[index++] = p + x0 + y1;
indices[index++] = p + x1 + y1;
indices[index++] = p + x1 + y0;
}
p += _slices;
}
// top hemisphere end cap triangles
int top = p + _slices;
for (int i=0; i<_slices; ++i) {
counts[face++] = 3;
indices[index++] = p + i;
indices[index++] = p + (i+1)%_slices;
indices[index++] = top;
}
TF_VERIFY(face == numCounts && index == numIndices);
return HdMeshTopology(PxOsdOpenSubdivTokens->catmark,
HdTokens->rightHanded,
countsArray, indicesArray);
}
static HdMeshTopology
_GenerateConeMeshTopology()
{
int numCounts = _slices * _stacks + _slices;
int numIndices = 4 * _slices * _stacks // cone quads
+ 3 * _slices; // end cap triangles
VtIntArray countsArray(numCounts);
int * counts = countsArray.data();
VtIntArray indicesArray(numIndices);
int * indices = indicesArray.data();
// populate face counts and face indices
int face = 0, index = 0, p = 0;
// base end cap triangles
int base = p++;
for (int i=0; i<_slices; ++i) {
counts[face++] = 3;
indices[index++] = p + (i+1)%_slices;
indices[index++] = p + i;
indices[index++] = base;
}
p += _slices;
// cone quads
for (int i=0; i<_stacks; ++i) {
for (int j=0; j<_slices; ++j) {
float x0 = 0;
float x1 = x0 + _slices;
float y0 = j;
float y1 = (j + 1) % _slices;
counts[face++] = 4;
indices[index++] = p + x0 + y0;
indices[index++] = p + x0 + y1;
indices[index++] = p + x1 + y1;
indices[index++] = p + x1 + y0;
}
p += _slices;
}
TF_VERIFY(face == numCounts and index == numIndices);
return HdMeshTopology(PxOsdOpenSubdivTokens->catmark,
HdTokens->rightHanded,
countsArray, indicesArray);
}
int test_Matrix::test3()
{
#ifdef HAVE_FEI_FETI
testData* testdata = new testData(localProc_, numProcs_);
std::vector<int>& idTypes = testdata->idTypes;
std::vector<int>& ids = testdata->ids;
fei::SharedPtr<FiniteElementData> fedata(new FETI_DP_FiniteElementData(comm_));
std::string paramstr("debugOutput .");
char* param = const_cast<char*>(paramstr.c_str());
CHK_ERR( fedata->parameters(1, ¶m) );
fei::SharedPtr<fei::Factory> factory(new snl_fei::Factory(fedata, idTypes[0]));
fei::SharedPtr<fei::VectorSpace> vectorSpacePtr =
test_VectorSpace::create_VectorSpace(comm_,
testdata, localProc_, numProcs_,
false, false, "U_FEMat", factory);
fei::SharedPtr<fei::MatrixGraph> matrixGraphPtr =
test_MatrixGraph::create_MatrixGraph(testdata, localProc_, numProcs_,
false, false, "U_FEMat", vectorSpacePtr,
factory);
CHK_ERR( matrixGraphPtr->initComplete() );
fei::SharedPtr<fei::Vector> vec_fed = factory->createVector(vectorSpacePtr);
fei::SharedPtr<fei::Matrix> mat_fed = factory->createMatrix(matrixGraphPtr);
fei::Matrix_Impl<FiniteElementData>* smat2 =
dynamic_cast<fei::Matrix_Impl<FiniteElementData>*>(mat_fed.get());
if (smat2 == NULL) {
ERReturn(-1);
}
int blockID=0;
int numIndices = matrixGraphPtr->getConnectivityNumIndices(blockID);
std::vector<int> indicesArray(numIndices);
int* indicesPtr = &indicesArray[0];
int checkNumIndices = 0;
CHK_ERR( matrixGraphPtr->getConnectivityIndices(blockID, 0,
numIndices, indicesPtr,
checkNumIndices) );
std::vector<double> data(ids.size(), 1.0);
double* dptr = &data[0];
std::vector<double*> coefPtrs(ids.size(), dptr);
CHK_ERR( mat_fed->sumIn(blockID, 0, &coefPtrs[0]) );
CHK_ERR( vec_fed->sumIn(blockID, 0, &data[0]) );
CHK_ERR( mat_fed->gatherFromOverlap() );
CHK_ERR( fedata->loadComplete() );
delete testdata;
MPI_Barrier(comm_);
#endif //HAVE_FEI_FETI
return(0);
}
int test_LinearSystem::test2()
{
#ifdef HAVE_FEI_AZTECOO
fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_));
std::vector<int>& fieldIDs = testdata->fieldIDs;
std::vector<int>& idTypes = testdata->idTypes;
std::vector<int>& ids = testdata->ids;
fei::SharedPtr<LinearSystemCore> az_lsc(new fei_trilinos::Aztec_LinSysCore(comm_));
char* param = new char[64];
sprintf(param,"debugOutput .");
CHK_ERR( az_lsc->parameters(1, ¶m) );
delete [] param;
fei::SharedPtr<fei::Factory> factory(new snl_fei::Factory(comm_, az_lsc));
fei::SharedPtr<fei::VectorSpace> vectorSpacePtr =
test_VectorSpace::create_VectorSpace(comm_,
testdata.get(), localProc_, numProcs_,
false, false, "U_LS2", factory);
fei::SharedPtr<fei::MatrixGraph> matrixGraphPtr =
test_MatrixGraph::create_MatrixGraph(testdata.get(), localProc_, numProcs_,
false, false, "U_LS2", vectorSpacePtr,
factory, path_);
std::vector<int> crIDTypes(2);
std::vector<int> crFieldIDs(2);
crIDTypes[0] = idTypes[0]; crIDTypes[1] = idTypes[0];
crFieldIDs[0] = fieldIDs[0]; crFieldIDs[1] = fieldIDs[0];
CHK_ERR( matrixGraphPtr->initLagrangeConstraint(0, idTypes[1],
2, //numIDs
&crIDTypes[0],
&(ids[1]),
&crFieldIDs[0]) );
CHK_ERR( matrixGraphPtr->initComplete() );
fei::SharedPtr<fei::Vector> vec_lsc = factory->createVector(vectorSpacePtr);
fei::SharedPtr<fei::Vector> vec_lsc2 = factory->createVector(vectorSpacePtr, true);
fei::SharedPtr<fei::Matrix> mat_lsc = factory->createMatrix(matrixGraphPtr);
fei::SharedPtr<fei::LinearSystem> linsys = factory->createLinearSystem(matrixGraphPtr);
linsys->setMatrix(mat_lsc);
linsys->setSolutionVector(vec_lsc2);
linsys->setRHS(vec_lsc);
int blockID=0;
int numIndices = matrixGraphPtr->getConnectivityNumIndices(blockID);
std::vector<int> indicesArray(numIndices);
int* indicesPtr = &indicesArray[0];
int checkNumIndices = 0;
CHK_ERR( matrixGraphPtr->getConnectivityIndices(blockID, 0,
numIndices, indicesPtr,
checkNumIndices) );
std::vector<double> data(ids.size(), 1.0);
double* dptr = &data[0];
std::vector<double*> coefPtrs(ids.size());
std::vector<double> crdata(2);
crdata[0] = 1.0;
crdata[1] = -1.0;
for(unsigned ii=0; ii<ids.size(); ++ii) coefPtrs[ii] = dptr;
CHK_ERR( mat_lsc->sumIn(numIndices, indicesPtr, numIndices, indicesPtr,
&coefPtrs[0]) );
CHK_ERR( vec_lsc->sumInFieldData(fieldIDs[0], idTypes[0],
ids.size(), &ids[0],
&data[0]) );
CHK_ERR( linsys->loadLagrangeConstraint(0, &crdata[0], 0.0) );
CHK_ERR( mat_lsc->gatherFromOverlap() );
CHK_ERR( az_lsc->matrixLoadComplete() );
CHK_ERR( linsys->loadComplete() );
std::vector<int> crindices;
linsys->getConstrainedEqns(crindices);
if (crindices.size() != 2) {
ERReturn(-7);
}
CHK_ERR( az_lsc->writeSystem("U_LS2") );
MPI_Barrier(comm_);
#endif
return(0);
}
