static void
propdict_foreach( const char* key, xmmsv_t *pair, void* userdata )
{
Xmms::PropDict::ForEachFunc* func =
static_cast< Xmms::PropDict::ForEachFunc* >( userdata );
Xmms::PropDict::ForEachData fedata( key, func );
xmmsv_dict_foreach( pair, &propdict_foreach_inner,
static_cast< void* >( &fedata ) );
}
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_FEI_Impl::test2()
{
fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_));
fei::SharedPtr<FiniteElementData> fedata(new FEData(comm_));
fei::SharedPtr<LibraryWrapper> wrapper(new LibraryWrapper(fedata));
fei::SharedPtr<fei::FEI_Impl> fei(new fei::FEI_Impl(wrapper, comm_, 0));
std::string param0("name test1");
FEI_OSTRINGSTREAM osstr;
osstr << "debugOutput ";
if (path_.empty()) osstr << ".";
else osstr << path_;
std::string param1 = osstr.str();
int numParams = 2;
char** params = new char*[numParams];
params[0] = const_cast<char*>(param0.c_str());
params[1] = const_cast<char*>(param1.c_str());
//call the parameters function a couple of times to test the fei's internal
//method for merging string lists when parameters is called more than once.
CHK_ERR( fei->parameters(1, ¶ms[0]) );
CHK_ERR( fei->parameters(1, ¶ms[1]) );
CHK_ERR( fei->parameters(2, params) );
delete [] params;
CHK_ERR( fei->setIDLists(1, &(testdata->ids[0]),
1, &(testdata->ids[0])) );
CHK_ERR( fei->initFields(testdata->fieldIDs.size(),
&(testdata->fieldSizes[0]),
&(testdata->fieldIDs[0])) );
int numNodesPerElem = testdata->ids.size();
std::vector<int> numFieldsPerNode(numNodesPerElem, 1);
std::vector<int*>nodalFieldIDs(numNodesPerElem, &(testdata->fieldIDs[0]));
CHK_ERR( fei->initElemBlock(0, //blockID
1, //numElements
numNodesPerElem,
&numFieldsPerNode[0],
&nodalFieldIDs[0],
0, //numElemDofFieldsPerElement
NULL, //elemDofFieldIDs
0)); //interleaveStrategy
CHK_ERR( fei->initElem(0, //blockID
0, //elemID
&(testdata->ids[0])) );
std::vector<int*> sharingProcs2D(testdata->sharedIDs.size());
int i, offset = 0;
for(i=0; i<(int)testdata->numSharingProcsPerID.size(); ++i) {
sharingProcs2D[i] = &(testdata->sharingProcs[offset]);
offset += testdata->numSharingProcsPerID[i];
}
if (testdata->sharedIDs.size() > 0) {
CHK_ERR( fei->initSharedNodes(testdata->sharedIDs.size(),
&(testdata->sharedIDs[0]),
&(testdata->numSharingProcsPerID[0]),
&sharingProcs2D[0]) );
}
CHK_ERR( fei->initComplete() );
std::vector<double> rhsData(testdata->ids.size(), 1.0);
double one = 1.0;
CHK_ERR( fei->setMatScalars(1, &(testdata->ids[0]), &one) );
CHK_ERR( fei->setRHSScalars(1, &(testdata->ids[0]), &one) );
CHK_ERR( fei->setCurrentMatrix(testdata->ids[0]) );
CHK_ERR( fei->setCurrentRHS(testdata->ids[0]) );
int ii;
int numBCNodes = 2;
GlobalID* BCNodeIDs = &(testdata->ids[0]);
int BCFieldID = testdata->fieldIDs[0];
double* values = new double[numBCNodes];
int* offsetsIntoField = new int[numBCNodes];
for(ii=0; ii<numBCNodes; ++ii) {
values[ii] = 1.0;
offsetsIntoField[ii] = 0;
}
CHK_ERR( fei->loadNodeBCs(numBCNodes, BCNodeIDs, BCFieldID,
offsetsIntoField, values) );
delete [] values;
delete [] offsetsIntoField;
CHK_ERR( fei->loadComplete() );
int numActiveNodes = 0;
CHK_ERR( fei->getNumLocalNodes(numActiveNodes) );
if (numActiveNodes != (int)testdata->ids.size()) {
ERReturn(-1);
}
GlobalID* localNodes = new GlobalID[numActiveNodes];
CHK_ERR( fei->getLocalNodeIDList(numActiveNodes, localNodes, numActiveNodes) );
int totalFieldSize = 0;
for(ii=0; ii<(int)testdata->fieldSizes.size(); ++ii) {
totalFieldSize += testdata->fieldSizes[ii];
}
double* soln = new double[numActiveNodes*totalFieldSize];
int* offsets = new int[numActiveNodes+1];
CHK_ERR( fei->getNodalSolution(numActiveNodes, localNodes,
offsets, soln) );
delete [] offsets;
delete [] soln;
delete [] localNodes;
CHK_ERR( fei->resetInitialGuess() );
int fieldSize = 0;
CHK_ERR( fei->getFieldSize(testdata->fieldIDs[0], fieldSize) );
double initTime, loadTime, solveTime, solnReturnTime;
CHK_ERR( fei->cumulative_cpu_times(initTime, loadTime, solveTime,
solnReturnTime) );
return(0);
}
