Пример #1
0
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, &param) );

  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);
}
Пример #2
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, &param) );
  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);
}