TEUCHOS_UNIT_TEST(tUniqueGlobalIndexer_Utilities,ArrayToFieldVector)
{
typedef Intrepid::FieldContainer<int> IntFieldContainer;
// build global (or serial communicator)
#ifdef HAVE_MPI
RCP<Epetra_Comm> eComm = rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
RCP<Epetra_Comm> eComm = rcp(new Epetra_SerialComm());
#endif
int myRank = eComm->MyPID();
int numProcs = eComm->NumProc();
TEUCHOS_ASSERT(numProcs==2);
RCP<panzer::UniqueGlobalIndexer<short,int> > globalIndexer
= rcp(new panzer::unit_test::UniqueGlobalIndexer(myRank,numProcs));
panzer::ArrayToFieldVector<short,int,KokkosClassic::DefaultNode::DefaultNodeType> atfv(globalIndexer);
std::map<std::string,IntFieldContainer> dataU, dataT;
fillFieldContainer(globalIndexer->getFieldNum("U"),"block_0",*globalIndexer,dataU["block_0"]);
fillFieldContainer(globalIndexer->getFieldNum("U"),"block_1",*globalIndexer,dataU["block_1"]);
fillFieldContainer(globalIndexer->getFieldNum("T"),"block_0",*globalIndexer,dataT["block_0"]);
Teuchos::RCP<Tpetra::MultiVector<int,int,int> > reducedUDataVector = atfv.getDataVector<int>("U",dataU);
Teuchos::RCP<Tpetra::MultiVector<int,int,int> > reducedTDataVector = atfv.getDataVector<int>("T",dataT);
std::vector<int> fields_u(reducedUDataVector->getLocalLength());
std::vector<int> fields_t(reducedTDataVector->getLocalLength());
reducedUDataVector->getVector(0)->get1dCopy(Teuchos::arrayViewFromVector(fields_u));
reducedTDataVector->getVector(0)->get1dCopy(Teuchos::arrayViewFromVector(fields_t));
if(myRank==0) {
TEST_EQUALITY(reducedUDataVector->getLocalLength(),6);
TEST_EQUALITY(reducedTDataVector->getLocalLength(),5);
TEST_EQUALITY(fields_u[0], 6);
TEST_EQUALITY(fields_u[1], 0);
TEST_EQUALITY(fields_u[2], 2);
TEST_EQUALITY(fields_u[3], 8);
TEST_EQUALITY(fields_u[4],10);
TEST_EQUALITY(fields_u[5],13);
TEST_EQUALITY(fields_t[0], 7);
TEST_EQUALITY(fields_t[1], 1);
TEST_EQUALITY(fields_t[2], 3);
TEST_EQUALITY(fields_t[3], 9);
TEST_EQUALITY(fields_t[4],11);
}
else if(myRank==1) {
TEST_EQUALITY(reducedUDataVector->getLocalLength(),4);
TEST_EQUALITY(reducedTDataVector->getLocalLength(),1);
TEST_EQUALITY(fields_u[0], 4);
TEST_EQUALITY(fields_u[1],12);
TEST_EQUALITY(fields_u[2],15);
TEST_EQUALITY(fields_u[3],14);
TEST_EQUALITY(fields_t[0], 5);
}
else
TEUCHOS_ASSERT(false);
}
//----------------------------------------------------------------------------
Teuchos::RCP<AAdapt::AbstractAdapter>
AAdapt::AdaptationFactory::createAdapter() {
using Teuchos::rcp;
Teuchos::RCP<AAdapt::AbstractAdapter> strategy;
std::string& method = adapt_params_->get("Method", "");
#if defined(ALBANY_STK)
if(method == "Copy Remesh") {
strategy = rcp(new AAdapt::CopyRemesh(adapt_params_,
param_lib_,
state_mgr_,
commT_));
}
#if defined(ALBANY_LCM) && defined(ALBANY_BGL)
else if(method == "Topmod") {
strategy = rcp(new AAdapt::TopologyMod(adapt_params_,
param_lib_,
state_mgr_,
commT_));
}
#endif
#if defined(ALBANY_LCM) && defined(LCM_SPECULATIVE)
else if(method == "Random") {
strategy = rcp(new AAdapt::RandomFracture(adapt_params_,
param_lib_,
state_mgr_,
commT_));
}
#endif
#endif
#if 0
#if defined(ALBANY_LCM) && defined(ALBANY_STK_PERCEPT)
else if(method == "Unif Size") {
strategy = rcp(new AAdapt::STKAdapt<AAdapt::STKUnifRefineField>(adapt_params_,
param_lib_,
state_mgr_,
epetra_comm_));
}
#endif
#endif
#if defined(ALBANY_STK)
else
#endif
TEUCHOS_TEST_FOR_EXCEPTION(true,
Teuchos::Exceptions::InvalidParameter,
std::endl <<
"Error! Unknown adaptivity method requested:"
<< method <<
" !" << std::endl
<< "Supplied parameter list is " <<
std::endl << *adapt_params_);
return strategy;
}
int main(int argc, char *argv[]) {
//
int MyPID = 0;
#ifdef EPETRA_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
MyPID = Comm.MyPID();
#else
Epetra_SerialComm Comm;
#endif
//
typedef double ST;
typedef Teuchos::ScalarTraits<ST> SCT;
typedef SCT::magnitudeType MT;
typedef Epetra_MultiVector MV;
typedef Epetra_Operator OP;
typedef Belos::MultiVecTraits<ST,MV> MVT;
typedef Belos::OperatorTraits<ST,MV,OP> OPT;
using Teuchos::ParameterList;
using Teuchos::RCP;
using Teuchos::rcp;
bool verbose = false, debug = false, proc_verbose = false;
int frequency = -1; // frequency of status test output.
int blocksize = 1; // blocksize
int numrhs = 1; // number of right-hand sides to solve for
int maxiters = -1; // maximum number of iterations allowed per linear system
int maxsubspace = 50; // maximum number of blocks the solver can use for the subspace
int maxrestarts = 15; // number of restarts allowed
std::string filename("orsirr1.hb");
MT tol = 1.0e-5; // relative residual tolerance
Teuchos::CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nondebug",&debug,"Print debugging information from solver.");
cmdp.setOption("frequency",&frequency,"Solvers frequency for printing residuals (#iters).");
cmdp.setOption("filename",&filename,"Filename for test matrix. Acceptable file extensions: *.hb,*.mtx,*.triU,*.triS");
cmdp.setOption("tol",&tol,"Relative residual tolerance used by GMRES solver.");
cmdp.setOption("num-rhs",&numrhs,"Number of right-hand sides to be solved for.");
cmdp.setOption("block-size",&blocksize,"Block size used by GMRES.");
cmdp.setOption("max-iters",&maxiters,"Maximum number of iterations per linear system (-1 = adapted to problem/block size).");
cmdp.setOption("max-subspace",&maxsubspace,"Maximum number of blocks the solver can use for the subspace.");
cmdp.setOption("max-restarts",&maxrestarts,"Maximum number of restarts allowed for GMRES solver.");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
return -1;
}
if (!verbose)
frequency = -1; // reset frequency if test is not verbose
//
// Get the problem
//
RCP<Epetra_Map> Map;
RCP<Epetra_CrsMatrix> A;
RCP<Epetra_MultiVector> B, X;
RCP<Epetra_Vector> vecB, vecX;
EpetraExt::readEpetraLinearSystem(filename, Comm, &A, &Map, &vecX, &vecB);
A->OptimizeStorage();
proc_verbose = verbose && (MyPID==0); /* Only print on the zero processor */
// Check to see if the number of right-hand sides is the same as requested.
if (numrhs>1) {
X = rcp( new Epetra_MultiVector( *Map, numrhs ) );
B = rcp( new Epetra_MultiVector( *Map, numrhs ) );
X->Seed();
X->Random();
OPT::Apply( *A, *X, *B );
X->PutScalar( 0.0 );
}
else {
X = Teuchos::rcp_implicit_cast<Epetra_MultiVector>(vecX);
B = Teuchos::rcp_implicit_cast<Epetra_MultiVector>(vecB);
}
//
// ********Other information used by block solver***********
// *****************(can be user specified)******************
//
const int NumGlobalElements = B->GlobalLength();
if (maxiters == -1)
maxiters = NumGlobalElements/blocksize - 1; // maximum number of iterations to run
//
ParameterList belosList;
belosList.set( "Num Blocks", maxsubspace); // Maximum number of blocks in Krylov factorization
belosList.set( "Block Size", blocksize ); // Blocksize to be used by iterative solver
belosList.set( "Maximum Iterations", maxiters ); // Maximum number of iterations allowed
belosList.set( "Maximum Restarts", maxrestarts ); // Maximum number of restarts allowed
belosList.set( "Convergence Tolerance", tol ); // Relative convergence tolerance requested
int verbosity = Belos::Errors + Belos::Warnings;
if (verbose) {
verbosity += Belos::TimingDetails + Belos::StatusTestDetails;
if (frequency > 0)
belosList.set( "Output Frequency", frequency );
}
if (debug) {
verbosity += Belos::Debug;
}
belosList.set( "Verbosity", verbosity );
//
// Construct an unpreconditioned linear problem instance.
//
Belos::LinearProblem<double,MV,OP> problem( A, X, B );
bool set = problem.setProblem();
if (set == false) {
if (proc_verbose)
std::cout << std::endl << "ERROR: Belos::LinearProblem failed to set up correctly!" << std::endl;
return -1;
}
//
// *******************************************************************
// *************Start the block Gmres iteration*************************
// *******************************************************************
//
Belos::OutputManager<double> My_OM();
// Create an iterative solver manager.
RCP< Belos::SolverManager<double,MV,OP> > newSolver
= rcp( new Belos::BlockGmresSolMgr<double,MV,OP>(rcp(&problem,false), rcp(&belosList,false)));
//
// **********Print out information about problem*******************
//
if (proc_verbose) {
std::cout << std::endl << std::endl;
std::cout << "Dimension of matrix: " << NumGlobalElements << std::endl;
std::cout << "Number of right-hand sides: " << numrhs << std::endl;
std::cout << "Block size used by solver: " << blocksize << std::endl;
std::cout << "Max number of restarts allowed: " << maxrestarts << std::endl;
std::cout << "Max number of Gmres iterations per linear system: " << maxiters << std::endl;
std::cout << "Relative residual tolerance: " << tol << std::endl;
std::cout << std::endl;
}
//
// Perform solve
//
Belos::ReturnType ret = newSolver->solve();
//
// Get the number of iterations for this solve.
//
int numIters = newSolver->getNumIters();
if (proc_verbose)
std::cout << "Number of iterations performed for this solve: " << numIters << std::endl;
//
// Compute actual residuals.
//
bool badRes = false;
std::vector<double> actual_resids( numrhs );
std::vector<double> rhs_norm( numrhs );
Epetra_MultiVector resid(*Map, numrhs);
OPT::Apply( *A, *X, resid );
MVT::MvAddMv( -1.0, resid, 1.0, *B, resid );
MVT::MvNorm( resid, actual_resids );
MVT::MvNorm( *B, rhs_norm );
if (proc_verbose) {
std::cout<< "---------- Actual Residuals (normalized) ----------"<<std::endl<<std::endl;
for ( int i=0; i<numrhs; i++) {
double actRes = actual_resids[i]/rhs_norm[i];
std::cout<<"Problem "<<i<<" : \t"<< actRes <<std::endl;
if (actRes > tol) badRes = true;
}
}
#ifdef EPETRA_MPI
MPI_Finalize();
#endif
if (ret!=Belos::Converged || badRes) {
if (proc_verbose)
std::cout << std::endl << "ERROR: Belos did not converge!" << std::endl;
return -1;
}
//
// Default return value
//
if (proc_verbose)
std::cout << std::endl << "SUCCESS: Belos converged!" << std::endl;
return 0;
//
}
/*! \brief Create a mesh of approximately the desired size.
*
* We want 3 dimensions close to equal in length.
*/
const RCP<tMVector_t> getMeshCoordinates(
const RCP<const Teuchos::Comm<int> > & comm,
zgno_t numGlobalCoords)
{
int rank = comm->getRank();
int nprocs = comm->getSize();
double k = log(numGlobalCoords) / 3;
double xdimf = exp(k) + 0.5;
ssize_t xdim = static_cast<ssize_t>(floor(xdimf));
ssize_t ydim = xdim;
ssize_t zdim = numGlobalCoords / (xdim*ydim);
ssize_t num=xdim*ydim*zdim;
ssize_t diff = numGlobalCoords - num;
ssize_t newdiff = 0;
while (diff > 0){
if (zdim > xdim && zdim > ydim){
zdim++;
newdiff = diff - (xdim*ydim);
if (newdiff < 0)
if (diff < -newdiff)
zdim--;
}
else if (ydim > xdim && ydim > zdim){
ydim++;
newdiff = diff - (xdim*zdim);
if (newdiff < 0)
if (diff < -newdiff)
ydim--;
}
else{
xdim++;
newdiff = diff - (ydim*zdim);
if (newdiff < 0)
if (diff < -newdiff)
xdim--;
}
diff = newdiff;
}
num=xdim*ydim*zdim;
diff = numGlobalCoords - num;
if (diff < 0)
diff /= -numGlobalCoords;
else
diff /= numGlobalCoords;
if (rank == 0){
if (diff > .01)
cout << "Warning: Difference " << diff*100 << " percent" << endl;
cout << "Mesh size: " << xdim << "x" << ydim << "x" <<
zdim << ", " << num << " vertices." << endl;
}
// Divide coordinates.
ssize_t numLocalCoords = num / nprocs;
ssize_t leftOver = num % nprocs;
ssize_t gid0 = 0;
if (rank <= leftOver)
gid0 = zgno_t(rank) * (numLocalCoords+1);
else
gid0 = (leftOver * (numLocalCoords+1)) +
((zgno_t(rank) - leftOver) * numLocalCoords);
if (rank < leftOver)
numLocalCoords++;
ssize_t gid1 = gid0 + numLocalCoords;
zgno_t *ids = new zgno_t [numLocalCoords];
if (!ids)
throw bad_alloc();
ArrayRCP<zgno_t> idArray(ids, 0, numLocalCoords, true);
for (ssize_t i=gid0; i < gid1; i++)
*ids++ = zgno_t(i);
RCP<const tMap_t> idMap = rcp(
new tMap_t(num, idArray.view(0, numLocalCoords), 0, comm));
// Create a Tpetra::MultiVector of coordinates.
zscalar_t *x = new zscalar_t [numLocalCoords*3];
if (!x)
throw bad_alloc();
ArrayRCP<zscalar_t> coordArray(x, 0, numLocalCoords*3, true);
zscalar_t *y = x + numLocalCoords;
zscalar_t *z = y + numLocalCoords;
zgno_t xStart = 0;
zgno_t yStart = 0;
zgno_t xyPlane = xdim*ydim;
zgno_t zStart = gid0 / xyPlane;
zgno_t rem = gid0 % xyPlane;
if (rem > 0){
yStart = rem / xdim;
xStart = rem % xdim;
}
zlno_t next = 0;
for (zscalar_t zval=zStart; next < numLocalCoords && zval < zdim; zval++){
for (zscalar_t yval=yStart; next < numLocalCoords && yval < ydim; yval++){
for (zscalar_t xval=xStart; next < numLocalCoords && xval < xdim; xval++){
x[next] = xval;
y[next] = yval;
z[next] = zval;
next++;
}
xStart = 0;
}
yStart = 0;
}
ArrayView<const zscalar_t> xArray(x, numLocalCoords);
ArrayView<const zscalar_t> yArray(y, numLocalCoords);
ArrayView<const zscalar_t> zArray(z, numLocalCoords);
ArrayRCP<ArrayView<const zscalar_t> > coordinates =
arcp(new ArrayView<const zscalar_t> [3], 0, 3);
coordinates[0] = xArray;
coordinates[1] = yArray;
coordinates[2] = zArray;
ArrayRCP<const ArrayView<const zscalar_t> > constCoords =
coordinates.getConst();
RCP<tMVector_t> meshCoords = rcp(new tMVector_t(
idMap, constCoords.view(0,3), 3));
return meshCoords;
}
bool run_composite_linear_ops_tests(
const Teuchos::RCP<const Teuchos::Comm<Thyra::Ordinal> > comm,
const int n,
const bool useSpmd,
const typename Teuchos::ScalarTraits<Scalar>::magnitudeType &tol,
const bool dumpAll,
Teuchos::FancyOStream *out_arg
)
{
using Teuchos::as;
typedef Teuchos::ScalarTraits<Scalar> ST;
typedef typename ST::magnitudeType ScalarMag;
typedef Teuchos::ScalarTraits<ScalarMag> STM;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::null;
using Teuchos::rcp_const_cast;
using Teuchos::rcp_dynamic_cast;
using Teuchos::dyn_cast;
using Teuchos::OSTab;
using Thyra::relErr;
using Thyra::passfail;
RCP<Teuchos::FancyOStream>
out = rcp(new Teuchos::FancyOStream(rcp(out_arg,false)));
const Teuchos::EVerbosityLevel
verbLevel = dumpAll?Teuchos::VERB_EXTREME:Teuchos::VERB_HIGH;
if (nonnull(out)) *out
<< "\n*** Entering run_composite_linear_ops_tests<"<<ST::name()<<">(...) ...\n";
bool success = true, result;
const ScalarMag warning_tol = ScalarMag(1e-2)*tol, error_tol = tol;
Thyra::LinearOpTester<Scalar> linearOpTester;
linearOpTester.linear_properties_warning_tol(warning_tol);
linearOpTester.linear_properties_error_tol(error_tol);
linearOpTester.adjoint_warning_tol(warning_tol);
linearOpTester.adjoint_error_tol(error_tol);
linearOpTester.dump_all(dumpAll);
Thyra::LinearOpTester<Scalar> symLinearOpTester(linearOpTester);
symLinearOpTester.check_for_symmetry(true);
symLinearOpTester.symmetry_warning_tol(STM::squareroot(warning_tol));
symLinearOpTester.symmetry_error_tol(STM::squareroot(error_tol));
RCP<const Thyra::VectorSpaceBase<Scalar> > space;
if(useSpmd) space = Thyra::defaultSpmdVectorSpace<Scalar>(comm,n,-1);
else space = Thyra::defaultSpmdVectorSpace<Scalar>(n);
if (nonnull(out)) *out
<< "\nUsing a basic vector space described as " << describe(*space,verbLevel) << " ...\n";
if (nonnull(out)) *out << "\nCreating random n x (n/2) multi-vector origA ...\n";
RCP<Thyra::MultiVectorBase<Scalar> >
mvOrigA = createMembers(space,n/2,"origA");
Thyra::seed_randomize<Scalar>(0);
//RTOpPack::show_spmd_apply_op_dump = true;
Thyra::randomize( as<Scalar>(as<Scalar>(-1)*ST::one()), as<Scalar>(as<Scalar>(+1)*ST::one()),
mvOrigA.ptr() );
RCP<const Thyra::LinearOpBase<Scalar> >
origA = mvOrigA;
if (nonnull(out)) *out << "\norigA =\n" << describe(*origA,verbLevel);
//RTOpPack::show_spmd_apply_op_dump = false;
if (nonnull(out)) *out << "\nTesting origA ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*origA, out.ptr());
if(!result) success = false;
if (nonnull(out)) *out
<< "\nCreating implicit scaled linear operator A1 = scale(0.5,origA) ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A1 = scale(as<Scalar>(0.5),origA);
if (nonnull(out)) *out << "\nA1 =\n" << describe(*A1,verbLevel);
if (nonnull(out)) *out << "\nTesting A1 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A1,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nTesting that A1.getOp() == origA ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(
*dyn_cast<const Thyra::DefaultScaledAdjointLinearOp<Scalar> >(*A1).getOp(),
*origA,out.ptr());
if(!result) success = false;
{
if (nonnull(out)) *out
<< "\nUnwrapping origA to get non-persisting pointer to origA_1, scalar and transp ...\n";
Scalar scalar;
Thyra::EOpTransp transp;
const Thyra::LinearOpBase<Scalar> *origA_1 = NULL;
unwrap( *origA, &scalar, &transp, &origA_1 );
TEUCHOS_TEST_FOR_EXCEPT( origA_1 == NULL );
if (nonnull(out)) *out << "\nscalar = " << scalar << " == 1 ? ";
result = (scalar == ST::one());
if(!result) success = false;
if (nonnull(out)) *out << passfail(result) << std::endl;
if (nonnull(out)) *out << "\ntransp = " << toString(transp) << " == NOTRANS ? ";
result = (transp == Thyra::NOTRANS);
if(!result) success = false;
if (nonnull(out)) *out << passfail(result) << std::endl;
if (nonnull(out)) *out << "\nTesting that origA_1 == origA ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(*origA_1,*origA,out.ptr());
if(!result) success = false;
}
{
if (nonnull(out)) *out << "\nUnwrapping A1 to get non-persisting pointer to origA_2 ...\n";
Scalar scalar;
Thyra::EOpTransp transp;
const Thyra::LinearOpBase<Scalar> *origA_2 = NULL;
unwrap( *A1, &scalar, &transp, &origA_2 );
TEUCHOS_TEST_FOR_EXCEPT( origA_2 == NULL );
if (nonnull(out)) *out << "\nscalar = " << scalar << " == 0.5 ? ";
result = (scalar == as<Scalar>(0.5));
if(!result) success = false;
if (nonnull(out)) *out << passfail(result) << std::endl;
if (nonnull(out)) *out << "\ntransp = " << toString(transp) << " == NOTRANS ? ";
result = (transp == Thyra::NOTRANS);
if(!result) success = false;
if (nonnull(out)) *out << passfail(result) << std::endl;
if (nonnull(out)) *out << "\nTesting that origA_2 == origA ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(*origA_2,*origA,out.ptr());
if(!result) success = false;
}
if (nonnull(out)) *out << "\nCreating implicit scaled linear operator A2 = adjoint(A1) ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A2 = adjoint(A1);
if (nonnull(out)) *out << "\nA2 =\n" << describe(*A2,verbLevel);
if (nonnull(out)) *out << "\nTesting A2 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A2,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nTesting that A2.getOp() == A1 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(*dyn_cast<const Thyra::DefaultScaledAdjointLinearOp<Scalar> >(*A2).getOp(),*A1,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating implicit scaled, adjoined linear operator A3 = adjoint(scale(2.0,(A2)) ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A3 = adjoint(scale(as<Scalar>(2.0),A2));
if (nonnull(out)) *out << "\nA3 =\n" << describe(*A3,verbLevel);
if (nonnull(out)) *out << "\nTesting A3 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A3,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nTesting that A3 == origA ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(*A3,*origA,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCalling all of the rest of the functions for non-const just to test them ...\n";
RCP<Thyra::LinearOpBase<Scalar> >
A4 = nonconstScale(
as<Scalar>(0.25)
,nonconstAdjoint(
nonconstTranspose(
nonconstAdjoint(
nonconstScaleAndAdjoint(
as<Scalar>(4.0)
,Thyra::TRANS
,Teuchos::rcp_const_cast<Thyra::LinearOpBase<Scalar> >(origA)
)
)
)
)
);
if(!ST::isComplex) A4 = nonconstTranspose(nonconstAdjoint(A4)); // Should result in CONJ
if (nonnull(out)) *out << "\nA4 =\n" << describe(*A4,verbLevel);
if (nonnull(out)) *out << "\nTesting A4 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A4,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCalling all of the rest of the functions for const just to test them ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A5 = scale(
as<Scalar>(0.25)
,adjoint(
transpose(
adjoint(
scaleAndAdjoint(
as<Scalar>(4.0)
,Thyra::TRANS
,origA
)
)
)
)
);
if(!ST::isComplex) A5 = transpose(adjoint(A5)); // Should result in CONJ
if (nonnull(out)) *out << "\nA5 =\n" << describe(*A5,verbLevel);
if (nonnull(out)) *out << "\nTesting A5 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A5,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a multiplied operator A6 = origA^H*A1 ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A6 = multiply(adjoint(origA),A1);
if (nonnull(out)) *out << "\nA6 =\n" << describe(*A6,verbLevel);
if (nonnull(out)) *out << "\nTesting A6 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A6,out.ptr());
if(!result) success = false;
// Note that testing the symmetry above helps to check the transpose mode
// against the non-transpose mode!
#ifdef TEUCHOS_DEBUG
if (nonnull(out)) *out << "\nCreating an invalid multiplied operator A6b = origA*origA (should throw an exception) ...\n\n";
try {
RCP<const Thyra::LinearOpBase<Scalar> >
A6b = multiply(origA,origA);
result = true;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,out.get()?*out:std::cerr,result)
if (nonnull(out))
*out << "\nCaught expected exception : " << (result?"failed\n":"passed\n");
if(result) success = false;
#endif // TEUCHOS_DEBUG
if (nonnull(out)) *out << "\nCreating a non-const multiplied operator A7 = origA^H*A1 ...\n";
RCP<Thyra::LinearOpBase<Scalar> >
A7 = nonconstMultiply(
rcp_const_cast<Thyra::LinearOpBase<Scalar> >(adjoint(origA))
,rcp_const_cast<Thyra::LinearOpBase<Scalar> >(A1)
);
if (nonnull(out)) *out << "\nA7 =\n" << describe(*A7,verbLevel);
if (nonnull(out)) *out << "\nTesting A7 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A7,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating an added operator A8 = origA + A1 ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A8 = add(origA,A1);
if (nonnull(out)) *out << "\nA8 =\n" << describe(*A8,verbLevel);
if (nonnull(out)) *out << "\nTesting A8 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A8,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a symmetric subtracted operator A8b = A6 + adjoint(origA)*origA ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A8b = subtract(A6,multiply(adjoint(origA),origA));
if (nonnull(out)) *out << "\nA8b =\n" << describe(*A8b,verbLevel);
if (nonnull(out)) *out << "\nTesting A8b ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A8b,out.ptr());
if(!result) success = false;
#ifdef TEUCHOS_DEBUG
if (nonnull(out)) *out << "\nCreating an invalid added operator A8c = origA + adjoint(origA) (should throw an exception) ...\n\n";
try {
RCP<const Thyra::LinearOpBase<Scalar> >
A8c = add(origA,adjoint(origA));
result = true;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,out.get()?*out:std::cerr,result)
if (nonnull(out))
*out << "\nCaught expected exception : " << (result?"failed\n":"passed\n");
if(result) success = false;
#endif // TEUCHOS_DEBUG
RCP<const Thyra::LinearOpBase<Scalar> >
nullOp = null;
if (nonnull(out)) *out << "\nCreating a blocked 2x2 linear operator A9 = [ A6, A1^H; A1, null ] ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A9 = Thyra::block2x2<Scalar>(
A6, adjoint(A1)
,A1, nullOp
);
if (nonnull(out)) *out << "\nA9 =\n" << describe(*A9,verbLevel);
if (nonnull(out)) *out << "\nTesting A9 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A9,out.ptr());
if(!result) success = false;
// Note that testing the symmetry above helps to check the transpose mode
// against the non-transpose mode!
if (nonnull(out)) *out << "\nCreating a blocked 2x2 linear operator A9_a = [ A6, A1^H; A1, null ] using pre-formed range and domain product spaces ...\n";
RCP<Thyra::PhysicallyBlockedLinearOpBase<Scalar> >
A9_a = rcp(new Thyra::DefaultBlockedLinearOp<Scalar>());
A9_a->beginBlockFill(
rcp_dynamic_cast<const Thyra::BlockedLinearOpBase<Scalar> >(A9,true)->productRange()
,rcp_dynamic_cast<const Thyra::BlockedLinearOpBase<Scalar> >(A9,true)->productDomain()
);
A9_a->setBlock(0,0,A6);
A9_a->setBlock(0,1,adjoint(A1));
A9_a->setBlock(1,0,A1);
A9_a->endBlockFill();
if (nonnull(out)) *out << "\nA9_a =\n" << describe(*A9_a,verbLevel);
if (nonnull(out)) *out << "\nTesting A9_a ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A9_a,out.ptr());
if(!result) success = false;
// Note that testing the symmetry above helps to check the transpose mode
// against the non-transpose mode!
if (nonnull(out)) *out << "\nComparing A9 == A9_a ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(*A9,*A9_a,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a blocked 2x2 linear operator A9_b = [ A6, A1^H; A1, null ] using flexible fill ...\n";
RCP<Thyra::PhysicallyBlockedLinearOpBase<Scalar> >
A9_b = rcp(new Thyra::DefaultBlockedLinearOp<Scalar>());
A9_b->beginBlockFill();
A9_b->setBlock(0,0,A6);
A9_b->setBlock(0,1,adjoint(A1));
A9_b->setBlock(1,0,A1);
A9_b->endBlockFill();
if (nonnull(out)) *out << "\nA9_b =\n" << describe(*A9_b,verbLevel);
if (nonnull(out)) *out << "\nTesting A9_b ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A9_b,out.ptr());
if(!result) success = false;
// Note that testing the symmetry above helps to check the transpose mode
// against the non-transpose mode!
if (nonnull(out)) *out << "\nComparing A9 == A9_b ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(*A9,*A9_b,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a blocked 2x2 linear operator A9a = [ null, A1^H; A1, null ] ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A9a = Thyra::block2x2<Scalar>(
nullOp, adjoint(A1),
A1, nullOp
);
if (nonnull(out)) *out << "\nA9a =\n" << describe(*A9a,verbLevel);
if (nonnull(out)) *out << "\nTesting A9a ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A9a,out.ptr());
if(!result) success = false;
// Note that testing the symmetry above helps to check the transpose mode
// against the non-transpose mode!
#ifdef TEUCHOS_DEBUG
if (nonnull(out)) *out << "\nCreating an invalid blocked 2x2 operator A9b = [ A6, A1^H; A1, A1 ] (should throw an exception) ...\n\n";
try {
RCP<const Thyra::LinearOpBase<Scalar> >
A9b = Thyra::block2x2<Scalar>(
A6, adjoint(A1),
A1, A1
);
result = true;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,out.get()?*out:std::cerr,result)
if (nonnull(out))
*out << "\nCaught expected exception : " << (result?"failed\n":"passed\n");
if(result) success = false;
#endif // TEUCHOS_DEBUG
#ifdef TEUCHOS_DEBUG
if (nonnull(out)) *out << "\nCreating an invalid blocked 2x2 operator A9c = [ A1, A1 ; null, null ] (should throw an exception) ...\n\n";
try {
RCP<const Thyra::LinearOpBase<Scalar> >
A9c = Thyra::block2x2<Scalar>(
A1, A1,
nullOp, nullOp
);
result = true;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,out.get()?*out:std::cerr,result)
if (nonnull(out))
*out << "\nCaught expected exception : " << (result?"failed\n":"passed\n");
if(result) success = false;
#endif // TEUCHOS_DEBUG
#ifdef TEUCHOS_DEBUG
if (nonnull(out)) *out << "\nCreating an invalid blocked 2x2 operator A9d = [ A1, null; A1, null ] (should throw an exception) ...\n\n";
try {
RCP<const Thyra::LinearOpBase<Scalar> >
A9d = Thyra::block2x2<Scalar>(
A1, nullOp,
A1, nullOp
);
result = true;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,out.get()?*out:std::cerr,result)
if (nonnull(out))
*out << "\nCaught expected exception : " << (result?"failed\n":"passed\n");
if(result) success = false;
#endif // TEUCHOS_DEBUG
if (nonnull(out)) *out << "\nCreating a blocked 2x1 linear operator A10 = [ A6; A1 ] ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A10 = Thyra::block2x1<Scalar>(
A6,
A1
);
if (nonnull(out)) *out << "\nA10 =\n" << describe(*A10,verbLevel);
if (nonnull(out)) *out << "\nTesting A10 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A10,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a blocked 1x2 linear operator A11 = [ A9, A10 ] ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A11 = Thyra::block1x2<Scalar>( A9, A10 );
if (nonnull(out)) *out << "\nA11 =\n" << describe(*A11,verbLevel);
if (nonnull(out)) *out << "\nTesting A11 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A11,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a zero linear operator A12 = 0 (range and domain spaces of origA) ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A12 = Thyra::zero(origA->range(),origA->domain());
if (nonnull(out)) *out << "\nA12 =\n" << describe(*A12,verbLevel);
if (nonnull(out)) *out << "\nTesting A12 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.check(*A12,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a blocked 2x2 linear operator A13 = [ zero, A1^H; A1, zero ] ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A13 = Thyra::block2x2<Scalar>(
Thyra::zero(A1->domain(),A1->domain()), adjoint(A1),
A1, Thyra::zero(A1->range(),A1->range())
);
if (nonnull(out)) *out << "\nA13 =\n" << describe(*A13,verbLevel);
if (nonnull(out)) *out << "\nComparing A9a == A13 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = linearOpTester.compare(*A9a,*A13,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\nCreating a zero linear operator A14 = I (range space of origA) ...\n";
RCP<const Thyra::LinearOpBase<Scalar> >
A14 = Thyra::identity(origA->range());
if (nonnull(out)) *out << "\nA14 =\n" << describe(*A14,verbLevel);
if (nonnull(out)) *out << "\nTesting A14 ...\n";
Thyra::seed_randomize<Scalar>(0);
result = symLinearOpTester.check(*A14,out.ptr());
if(!result) success = false;
if (nonnull(out)) *out << "\n*** Leaving run_composite_linear_ops_tests<"<<ST::name()<<">(...) ...\n";
return success;
} // end run_composite_linear_ops_tests() [Doxygen looks for this!]
void
Albany::ResponseFactory::
createResponseFunction(
const std::string& name,
Teuchos::ParameterList& responseParams,
Teuchos::Array< Teuchos::RCP<AbstractResponseFunction> >& responses) const
{
using std::string;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using Teuchos::Array;
RCP<const Epetra_Comm> comm = app->getComm();
if (name == "Solution Average") {
responses.push_back(rcp(new Albany::SolutionAverageResponseFunction(comm)));
}
else if (name == "Solution Two Norm") {
responses.push_back(rcp(new Albany::SolutionTwoNormResponseFunction(comm)));
}
else if (name == "Solution Values") {
responses.push_back(rcp(new Albany::SolutionValuesResponseFunction(app, responseParams)));
}
else if (name == "Solution Max Value") {
int eq = responseParams.get("Equation", 0);
int neq = responseParams.get("Num Equations", 1);
bool inor = responseParams.get("Interleaved Ordering", true);
responses.push_back(
rcp(new Albany::SolutionMaxValueResponseFunction(comm, neq, eq, inor)));
}
else if (name == "Solution Two Norm File") {
responses.push_back(
rcp(new Albany::SolutionFileResponseFunction<Albany::NormTwo>(comm)));
}
else if (name == "Solution Inf Norm File") {
responses.push_back(
rcp(new Albany::SolutionFileResponseFunction<Albany::NormInf>(comm)));
}
else if (name == "Aggregated") {
int num_aggregate_responses = responseParams.get<int>("Number");
Array< RCP<AbstractResponseFunction> > aggregated_responses;
Array< RCP<ScalarResponseFunction> > scalar_responses;
for (int i=0; i<num_aggregate_responses; i++) {
std::string id = Albany::strint("Response",i);
std::string name = responseParams.get<std::string>(id);
std::string sublist_name = Albany::strint("ResponseParams",i);
createResponseFunction(name, responseParams.sublist(sublist_name),
aggregated_responses);
}
scalar_responses.resize(aggregated_responses.size());
for (int i=0; i<aggregated_responses.size(); i++) {
TEUCHOS_TEST_FOR_EXCEPTION(
aggregated_responses[i]->isScalarResponse() != true, std::logic_error,
"Response function " << i << " is not a scalar response function." <<
std::endl <<
"The aggregated response can only aggregate scalar response " <<
"functions!");
scalar_responses[i] =
Teuchos::rcp_dynamic_cast<ScalarResponseFunction>(
aggregated_responses[i]);
}
responses.push_back(
rcp(new Albany::AggregateScalarResponseFunction(comm, scalar_responses)));
}
else if (name == "Field Integral" ||
name == "Field Value" ||
name == "Field Average" ||
name == "Surface Velocity Mismatch" ||
name == "Center Of Mass" ||
name == "Save Field" ||
name == "Region Boundary" ||
name == "Element Size Field" ||
name == "IP to Nodal Field" ||
name == "Save Nodal Fields" ||
name == "PHAL Field Integral") {
responseParams.set("Name", name);
for (int i=0; i<meshSpecs.size(); i++) {
responses.push_back(
rcp(new Albany::FieldManagerScalarResponseFunction(
app, prob, meshSpecs[i], stateMgr, responseParams)));
}
}
else if (name == "Solution") {
responses.push_back(
rcp(new Albany::SolutionResponseFunction(app, responseParams)));
}
else if (name == "KL") {
Array< RCP<AbstractResponseFunction> > base_responses;
std::string name = responseParams.get<std::string>("Response");
createResponseFunction(name, responseParams.sublist("ResponseParams"),
base_responses);
for (int i=0; i<base_responses.size(); i++)
responses.push_back(
rcp(new Albany::KLResponseFunction(base_responses[i], responseParams)));
}
#ifdef ALBANY_QCAD
else if (name == "Saddle Value") {
responseParams.set("Name", name);
for (int i=0; i<meshSpecs.size(); i++) {
responses.push_back(
rcp(new QCAD::SaddleValueResponseFunction(
app, prob, meshSpecs[i], stateMgr, responseParams)));
}
}
#endif
else {
TEUCHOS_TEST_FOR_EXCEPTION(
true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error! Unknown response function " << name <<
"!" << std::endl << "Supplied parameter list is " <<
std::endl << responseParams);
}
}
int Ifpack_SORa::Compute(){
if(!IsInitialized_) Initialize();
Epetra_Map *RowMap=const_cast<Epetra_Map*>(&A_->RowMatrixRowMap());
Epetra_Vector Adiag(*RowMap);
Epetra_CrsMatrix *Askew2=0, *Aherm2=0,*W=0;
int *rowptr_s,*colind_s,*rowptr_h,*colind_h;
double *vals_s,*vals_h;
bool RowMatrixMode=(Acrs_==Teuchos::null);
// Label
sprintf(Label_, "IFPACK SORa (alpha=%5.2f gamma=%5.2f)",Alpha_,Gamma_);
if(RowMatrixMode){
if(!A_->Comm().MyPID()) cout<<"SORa: RowMatrix mode enabled"<<endl;
// RowMatrix mode, build Acrs_ the hard way.
Epetra_RowMatrix *Arow=&*A_;
Epetra_Map *ColMap=const_cast<Epetra_Map*>(&A_->RowMatrixColMap());
int Nmax=A_->MaxNumEntries();
int length;
vector<int> indices(Nmax);
vector<double> values(Nmax);
Epetra_CrsMatrix *Acrs=new Epetra_CrsMatrix(Copy,*RowMap,Nmax);
for(int i=0;i<Arow->NumMyRows();i++){
Arow->ExtractMyRowCopy(i,Nmax,length,&values[0],&indices[0]);
for(int j=0;j<length;j++)
indices[j]=ColMap->GID(indices[j]);
Acrs->InsertGlobalValues(RowMap->GID(i),length,&values[0],&indices[0]);
}
Acrs->FillComplete(A_->OperatorDomainMap(),A_->OperatorRangeMap());
Acrs_=rcp(Acrs,true);
}
// Create Askew2
// Note: Here I let EpetraExt do the thinking for me. Since it gets all the maps correct for the E + F^T stencil.
// There are probably more efficient ways to do this but this method has the bonus of allowing code reuse.
IFPACK_CHK_ERR(EpetraExt::MatrixMatrix::Add(*Acrs_,false,1,*Acrs_,true,-1,Askew2));
Askew2->FillComplete();
// Create Aherm2
IFPACK_CHK_ERR(EpetraExt::MatrixMatrix::Add(*Acrs_,false,1,*Acrs_,true,1,Aherm2));
Aherm2->FillComplete();
int nnz2=Askew2->NumMyNonzeros();
int N=Askew2->NumMyRows();
// Grab pointers
IFPACK_CHK_ERR(Askew2->ExtractCrsDataPointers(rowptr_s,colind_s,vals_s));
IFPACK_CHK_ERR(Aherm2->ExtractCrsDataPointers(rowptr_h,colind_h,vals_h));
// Sanity checking: Make sure the sparsity patterns are the same
#define SANITY_CHECK
#ifdef SANITY_CHECK
for(int i=0;i<N;i++)
if(rowptr_s[i]!=rowptr_h[i]) IFPACK_CHK_ERR(-2);
for(int i=0;i<nnz2;i++)
if(colind_s[i]!=colind_h[i]) IFPACK_CHK_ERR(-3);
#endif
// Dirichlet Detection & Nuking of Aherm2 and Askew2
// Note: Relies on Aherm2/Askew2 having identical sparsity patterns (see sanity check above)
if(HaveOAZBoundaries_){
int numBCRows;
int* dirRows=FindLocalDiricheltRowsFromOnesAndZeros(*Acrs_,numBCRows);
Epetra_IntVector* dirCols=FindLocalDirichletColumnsFromRows(dirRows,numBCRows,*Aherm2);
Apply_BCsToMatrixRowsAndColumns(dirRows,numBCRows,*dirCols,*Aherm2);
Apply_BCsToMatrixRowsAndColumns(dirRows,numBCRows,*dirCols,*Askew2);
delete [] dirRows;
delete dirCols;
}
// Grab diagonal of A
A_->ExtractDiagonalCopy(Adiag);
// Allocate the diagonal for W
Epetra_Vector *Wdiag = new Epetra_Vector(*RowMap);
// Build the W matrix (lower triangle only)
// Note: Relies on EpetraExt giving me identical sparsity patterns for both Askew2 and Aherm2 (see sanity check above)
int maxentries=Askew2->MaxNumEntries();
int* gids=new int [maxentries];
double* newvals=new double[maxentries];
W=new Epetra_CrsMatrix(Copy,*RowMap,0);
for(int i=0;i<N;i++){
// Build the - (1+alpha)/2 E - (1-alpha)/2 F part of the W matrix
int rowgid=Acrs_->GRID(i);
double c_data=0.0;
double ipdamp=0.0;
int idx=0;
for(int j=rowptr_s[i];j<rowptr_s[i+1];j++){
int colgid=Askew2->GCID(colind_s[j]);
c_data+=fabs(vals_s[j]);
if(rowgid>colgid){
// Rely on the fact that off-diagonal entries are always numbered last, dropping the entry entirely.
if(colind_s[j] < N) {
gids[idx]=colgid;
newvals[idx]=vals_h[j]/2 + Alpha_ * vals_s[j]/2;
idx++;
}
else{
ipdamp+=fabs(vals_h[j]/2 + Alpha_ * vals_s[j]/2);
}
}
}
if(idx>0)
IFPACK_CHK_ERR(W->InsertGlobalValues(rowgid,idx,newvals,gids));
// Do the diagonal
double w_val= c_data*Alpha_*Gamma_/4 + Adiag[Acrs_->LRID(rowgid)];
if(UseInterprocDamping_) w_val+=ipdamp;
W->InsertGlobalValues(rowgid,1,&w_val,&rowgid);
IFPACK_CHK_ERR(Wdiag->ReplaceGlobalValues(1,&w_val,&rowgid));
}
W->FillComplete(A_->OperatorDomainMap(),A_->OperatorRangeMap());
W_=rcp(W);
Wdiag_=rcp(Wdiag);
// Mark as computed
IsComputed_=true;
// Global damping, if wanted
if(UseGlobalDamping_) {
PowerMethod(10,LambdaMax_);
if(!A_->Comm().MyPID()) printf("SORa: Global damping parameter = %6.4e (lmax=%6.4e)\n",GetOmega(),LambdaMax_);
}
// Cleanup
delete [] gids;
delete [] newvals;
delete Aherm2;
delete Askew2;
if(RowMatrixMode) {
Acrs_=Teuchos::null;
}
// Counters
NumCompute_++;
ComputeTime_ += Time_.ElapsedTime();
return 0;
}
int main(int argc, char *argv[]) {
int status=0; // 0 = pass, failures are incremented
// Initialize MPI and timer
int Proc=0;
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
double total_time = -MPI_Wtime();
(void) MPI_Comm_rank(MPI_COMM_WORLD, &Proc);
MPI_Comm appComm = MPI_COMM_WORLD;
#else
int appComm=0;
#endif
using Teuchos::RCP;
using Teuchos::rcp;
// Command-line argument for input file
//char* defaultfile="input_1.xml";
try {
RCP<EpetraExt::ModelEvaluator> Model = rcp(new MockModelEval_A(appComm));
// Set input arguments to evalModel call
EpetraExt::ModelEvaluator::InArgs inArgs = Model->createInArgs();
RCP<Epetra_Vector> x = rcp(new Epetra_Vector(*(Model->get_x_init())));
inArgs.set_x(x);
int num_p = inArgs.Np(); // Number of *vectors* of parameters
RCP<Epetra_Vector> p1;
if (num_p > 0) {
p1 = rcp(new Epetra_Vector(*(Model->get_p_init(0))));
inArgs.set_p(0,p1);
}
int numParams = p1->MyLength(); // Number of parameters in p1 vector
// Set output arguments to evalModel call
EpetraExt::ModelEvaluator::OutArgs outArgs = Model->createOutArgs();
RCP<Epetra_Vector> f = rcp(new Epetra_Vector(x->Map()));
outArgs.set_f(f);
int num_g = outArgs.Ng(); // Number of *vectors* of responses
RCP<Epetra_Vector> g1;
if (num_g > 0) {
g1 = rcp(new Epetra_Vector(*(Model->get_g_map(0))));
outArgs.set_g(0,g1);
}
RCP<Epetra_Operator> W_op = Model->create_W();
outArgs.set_W(W_op);
RCP<Epetra_MultiVector> dfdp = rcp(new Epetra_MultiVector(
*(Model->get_x_map()), numParams));
outArgs.set_DfDp(0, dfdp);
RCP<Epetra_MultiVector> dgdp = rcp(new Epetra_MultiVector(g1->Map(), numParams));
outArgs.set_DgDp(0, 0, dgdp);
RCP<Epetra_MultiVector> dgdx = rcp(new Epetra_MultiVector(x->Map(), g1->MyLength()));
outArgs.set_DgDx(0, dgdx);
// Now, evaluate the model!
Model->evalModel(inArgs, outArgs);
// Print out everything
if (Proc == 0)
cout << "Finished Model Evaluation: Printing everything {Exact in brackets}"
<< "\n-----------------------------------------------------------------"
<< std::setprecision(9) << endl;
x->Print(cout << "\nSolution vector! {3,3,3,3}\n");
if (num_p>0) p1->Print(cout << "\nParameters! {1,1}\n");
f->Print(cout << "\nResidual! {8,5,0,-7}\n");
if (num_g>0) g1->Print(cout << "\nResponses! {2}\n");
RCP<Epetra_CrsMatrix> W = Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(W_op, true);
W->Print(cout << "\nJacobian! {6 on diags}\n");
dfdp->Print(cout << "\nDfDp sensitivity MultiVector! {-1,0,0,0}{0,-4,-6,-8}\n");
dgdp->Print(cout << "\nDgDp response sensitivity MultiVector!{2,2}\n");
dgdx->Print(cout << "\nDgDx^T response gradient MultiVector! {-2,-2,-2,-2}\n");
if (Proc == 0)
cout <<
"\n-----------------------------------------------------------------\n";
}
catch (std::exception& e) {
cout << e.what() << endl;
status = 10;
}
catch (string& s) {
cout << s << endl;
status = 20;
}
catch (char *s) {
cout << s << endl;
status = 30;
}
catch (...) {
cout << "Caught unknown exception!" << endl;
status = 40;
}
#ifdef HAVE_MPI
total_time += MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
if (Proc==0) cout << "\n\nTOTAL TIME "
<< total_time << endl;
MPI_Finalize() ;
#endif
if (Proc==0) {
if (status==0)
cout << "TEST PASSED" << endl;
else
cout << "TEST Failed" << endl;
}
return status;
}
TEUCHOS_UNIT_TEST(initial_condition_control, control)
{
using Teuchos::RCP;
using Teuchos::rcp;
Teuchos::RCP<const Epetra_Comm> comm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
// setup mesh
/////////////////////////////////////////////
RCP<panzer_stk_classic::STK_Interface> mesh;
{
RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
pl->set<int>("X Elements",2);
pl->set<int>("Y Elements",2);
pl->set<int>("X Blocks",2);
pl->set<int>("Y Blocks",1);
panzer_stk_classic::SquareQuadMeshFactory mesh_factory;
mesh_factory.setParameterList(pl);
mesh = mesh_factory.buildMesh(MPI_COMM_WORLD);
mesh->writeToExodus("test.exo");
}
RCP<const shards::CellTopology> ct = mesh->getCellTopology("eblock-0_0");
panzer::CellData cellData(4,ct);
RCP<panzer::IntegrationRule> int_rule = rcp(new panzer::IntegrationRule(2,cellData));
ICFieldDescriptor densDesc;
densDesc.fieldName = "DENSITY";
densDesc.basisName = "Const";
densDesc.basisOrder = 0;
ICFieldDescriptor condDesc;
condDesc.fieldName = "CONDUCTIVITY";
condDesc.basisName = "HGrad";
condDesc.basisOrder = 1;
RCP<panzer::PureBasis> const_basis = rcp(new panzer::PureBasis(densDesc.basisName,densDesc.basisOrder,cellData));
RCP<panzer::PureBasis> hgrad_basis = rcp(new panzer::PureBasis(condDesc.basisName,condDesc.basisOrder,cellData));
RCP<const panzer::FieldPattern> constFP = rcp(new panzer::Intrepid2FieldPattern(const_basis->getIntrepid2Basis()));
RCP<const panzer::FieldPattern> hgradFP = rcp(new panzer::Intrepid2FieldPattern(hgrad_basis->getIntrepid2Basis()));
// setup DOF manager
/////////////////////////////////////////////
RCP<panzer::ConnManager<int,int> > conn_manager
= Teuchos::rcp(new panzer_stk_classic::STKConnManager<int>(mesh));
RCP<panzer::DOFManager<int,int> > dofManager
= rcp(new panzer::DOFManager<int,int>(conn_manager,MPI_COMM_WORLD));
dofManager->addField(densDesc.fieldName, constFP);
dofManager->addField(condDesc.fieldName, hgradFP);
dofManager->buildGlobalUnknowns();
Teuchos::RCP<panzer::EpetraLinearObjFactory<panzer::Traits,int> > elof
= Teuchos::rcp(new panzer::EpetraLinearObjFactory<panzer::Traits,int>(comm.getConst(),dofManager));
Teuchos::RCP<panzer::LinearObjFactory<panzer::Traits> > lof = elof;
// setup worksets
/////////////////////////////////////////////
std::map<std::string,panzer::WorksetNeeds> needs;
needs["eblock-0_0"].cellData = cellData;
needs["eblock-0_0"].int_rules.push_back(int_rule);
needs["eblock-0_0"].bases = { const_basis, hgrad_basis};
needs["eblock-0_0"].rep_field_name = { densDesc.fieldName, condDesc.fieldName};
needs["eblock-1_0"].cellData = cellData;
needs["eblock-1_0"].int_rules.push_back(int_rule);
needs["eblock-1_0"].bases = { const_basis, hgrad_basis};
needs["eblock-1_0"].rep_field_name = { densDesc.fieldName, condDesc.fieldName};
Teuchos::RCP<panzer_stk_classic::WorksetFactory> wkstFactory
= Teuchos::rcp(new panzer_stk_classic::WorksetFactory(mesh)); // build STK workset factory
Teuchos::RCP<panzer::WorksetContainer> wkstContainer // attach it to a workset container (uses lazy evaluation)
= Teuchos::rcp(new panzer::WorksetContainer(wkstFactory,needs));
// setup field manager builder
/////////////////////////////////////////////
// Add in the application specific closure model factory
panzer::ClosureModelFactory_TemplateManager<panzer::Traits> cm_factory;
user_app::STKModelFactory_TemplateBuilder cm_builder;
cm_factory.buildObjects(cm_builder);
Teuchos::ParameterList user_data("User Data");
Teuchos::ParameterList ic_closure_models("Initial Conditions");
ic_closure_models.sublist("eblock-0_0").sublist(densDesc.fieldName).set<double>("Value",3.0);
ic_closure_models.sublist("eblock-0_0").sublist(condDesc.fieldName).set<double>("Value",9.0);
ic_closure_models.sublist("eblock-1_0").sublist(densDesc.fieldName).set<double>("Value",3.0);
ic_closure_models.sublist("eblock-1_0").sublist(condDesc.fieldName).set<double>("Value",9.0);
std::map<std::string,Teuchos::RCP<const shards::CellTopology> > block_ids_to_cell_topo;
block_ids_to_cell_topo["eblock-0_0"] = mesh->getCellTopology("eblock-0_0");
block_ids_to_cell_topo["eblock-1_0"] = mesh->getCellTopology("eblock-1_0");
std::map<std::string,std::vector<ICFieldDescriptor> > block_ids_to_fields;
block_ids_to_fields["eblock-0_0"] = {densDesc,condDesc};
block_ids_to_fields["eblock-1_0"] = {densDesc,condDesc};
int workset_size = 4;
Teuchos::RCP<panzer::LinearObjContainer> loc = lof->buildLinearObjContainer();
lof->initializeContainer(panzer::LinearObjContainer::X,*loc);
Teuchos::RCP<panzer::EpetraLinearObjContainer> eloc = Teuchos::rcp_dynamic_cast<EpetraLinearObjContainer>(loc);
Teuchos::RCP<Thyra::VectorBase<double> > vec = eloc->get_x_th();
// this is the Function under test
panzer::setupControlInitialCondition(block_ids_to_cell_topo,
block_ids_to_fields,
*wkstContainer,
*lof,cm_factory,ic_closure_models,user_data,
workset_size,
0.0, // t0
vec);
Teuchos::RCP<Epetra_Vector> x = eloc->get_x();
out << x->GlobalLength() << " " << x->MyLength() << std::endl;
for (int i=0; i < x->MyLength(); ++i) {
double v = (*x)[i];
TEST_ASSERT(v==3.0 || v==9.0);
}
}
// =============================================================================
int main (int argc, char *argv[])
{
Teuchos::GlobalMPISession(&argc, &argv, NULL);
// Create a communicator for Epetra objects
#ifdef HAVE_MPI
Epetra_MpiComm eComm(MPI_COMM_WORLD);
#else
Epetra_SerialComm eComm();
#endif
const RCP<Teuchos::FancyOStream> out =
Teuchos::VerboseObjectBase::getDefaultOStream();
bool success = true;
try {
// ===========================================================================
// handle command line arguments
Teuchos::CommandLineProcessor My_CLP;
My_CLP.setDocString("Linear solver testbed for the 1D Poisson matrix.\n");
std::string action("matvec");
My_CLP.setOption("action",
&action,
"Which action to perform with the operator (matvec, solve_cg, solve_minres, solve_gmres)"
);
std::string solver("cg");
// My_CLP.setOption("solver", &solver, "Krylov subspace method (cg, minres, gmres)");
// Operator op = JAC;
// Operator allOpts[] = {JAC, KEO, KEOREG, POISSON1D};
// std::string allOptNames[] = {"jac", "keo", "keoreg", "poisson1d"};
// My_CLP.setOption("operator", &op, 4, allOpts, allOptNames);
bool verbose = true;
My_CLP.setOption("verbose", "quiet",
&verbose,
"Print messages and results.");
int frequency = 10;
My_CLP.setOption("frequency",
&frequency,
"Solvers frequency for printing residuals (#iters).");
// Make sure this value is large enough to keep the cores busy for a while.
int n = 1000;
My_CLP.setOption("size",
&n,
"Size of the equation system (default: 1000).");
// print warning for unrecognized arguments
My_CLP.recogniseAllOptions(true);
My_CLP.throwExceptions(false);
// finally, parse the command line
TEUCHOS_ASSERT_EQUALITY(My_CLP.parse (argc, argv),
Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL
);
// =========================================================================
// Construct Epetra matrix.
RCP<Teuchos::Time> matrixConstructTime =
Teuchos::TimeMonitor::getNewTimer("Epetra matrix construction");
RCP<Epetra_CrsMatrix> A;
{
Teuchos::TimeMonitor tm(*matrixConstructTime);
A = contructEpetraMatrix(n, eComm);
}
// A->Print(std::cout);
// create initial guess and right-hand side
RCP<Epetra_Vector> x =
rcp(new Epetra_Vector(A->OperatorDomainMap()));
RCP<Epetra_MultiVector> b =
rcp(new Epetra_Vector(A->OperatorRangeMap()));
// b->Random();
TEUCHOS_ASSERT_EQUALITY(0, b->PutScalar(1.0));
if (action.compare("matvec") == 0) {
TEUCHOS_ASSERT_EQUALITY(0, x->PutScalar(1.0));
RCP<Teuchos::Time> mvTime = Teuchos::TimeMonitor::getNewTimer("Epetra operator apply");
{
Teuchos::TimeMonitor tm(*mvTime);
// Don't TEUCHOS_ASSERT_EQUALITY() here for speed.
A->Apply(*x, *b);
}
// print timing data
Teuchos::TimeMonitor::summarize();
} else {
// -----------------------------------------------------------------------
// Belos part
Teuchos::ParameterList belosList;
// Relative convergence tolerance requested
belosList.set("Convergence Tolerance", 1.0e-12);
if (verbose) {
belosList.set("Verbosity",
Belos::Errors +
Belos::Warnings +
Belos::IterationDetails +
Belos::FinalSummary +
Belos::Debug +
Belos::TimingDetails +
Belos::StatusTestDetails
);
if (frequency > 0)
belosList.set("Output Frequency", frequency);
} else {
belosList.set("Verbosity", Belos::Errors + Belos::Warnings);
}
// Belos::General, Belos::Brief
belosList.set("Output Style", static_cast<int>(Belos::Brief));
belosList.set("Maximum Iterations", 1000);
// Construct an unpreconditioned linear problem instance.
Belos::LinearProblem<double, MV, OP> problem(A, x, b);
bool set = problem.setProblem();
TEUCHOS_TEST_FOR_EXCEPTION(
!set,
std::logic_error,
"ERROR: Belos::LinearProblem failed to set up correctly!"
);
// -----------------------------------------------------------------------
// Create an iterative solver manager.
RCP<Belos::SolverManager<double, MV, OP> > newSolver;
if (action.compare("solve_cg") == 0) {
belosList.set("Assert Positive Definiteness", false);
newSolver =
rcp(new Belos::PseudoBlockCGSolMgr<double, MV, OP>(
rcp(&problem, false),
rcp(&belosList, false)
));
} else if (action.compare("solve_minres") == 0) {
newSolver =
rcp(new Belos::MinresSolMgr<double, MV, OP>(
rcp(&problem, false),
rcp(&belosList, false)
));
} else if (action.compare("solve_gmres") == 0) {
newSolver =
rcp(new Belos::PseudoBlockGmresSolMgr<double, MV, OP>(
rcp(&problem, false),
rcp(&belosList, false)
));
} else {
TEUCHOS_TEST_FOR_EXCEPT_MSG(true, "Unknown solver type \"" << solver << "\".");
}
// Perform solve
RCP<Teuchos::Time> solveTime =
Teuchos::TimeMonitor::getNewTimer("Linear system solve");
{
Teuchos::TimeMonitor tm(*solveTime);
Belos::ReturnType ret = newSolver->solve();
success = ret == Belos::Converged;
}
// *out << newSolver->getNumIters() << std::endl;
// // Compute actual residuals.
// bool badRes = false;
// Teuchos::Array<double> actual_resids(1);
// Teuchos::Array<double> rhs_norm(1);
// Epetra_Vector resid(keoMatrix->OperatorRangeMap());
// OPT::Apply(*keoMatrix, *x, resid);
// MVT::MvAddMv(-1.0, resid, 1.0, *b, resid);
// MVT::MvNorm(resid, actual_resids);
// MVT::MvNorm(*b, rhs_norm);
// if (proc_verbose) {
// std::cout<< "---------- Actual Residuals (normalized) ----------" <<std::endl<<std::endl;
// for (int i=0; i<1; i++) {
// double actRes = actual_resids[i]/rhs_norm[i];
// std::cout << "Problem " << i << " : \t" << actRes << std::endl;
// if (actRes > 1.0e-10) badRes = true;
// }
// }
}
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true, *out, success);
return success ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char *argv[])
{
#ifndef HAVE_TPETRA_COMPLEX_DOUBLE
# error "Anasazi: This test requires Scalar = std::complex<double> to be enabled in Tpetra."
#else
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::tuple;
using std::cout;
using std::endl;
typedef std::complex<double> ST;
typedef Teuchos::ScalarTraits<ST> SCT;
typedef SCT::magnitudeType MT;
typedef Tpetra::MultiVector<ST> MV;
typedef MV::global_ordinal_type GO;
typedef Tpetra::Operator<ST> OP;
typedef Anasazi::MultiVecTraits<ST,MV> MVT;
typedef Anasazi::OperatorTraits<ST,MV,OP> OPT;
Teuchos::GlobalMPISession mpisess (&argc, &argv, &std::cout);
bool success = false;
const ST ONE = SCT::one ();
int info = 0;
RCP<const Teuchos::Comm<int> > comm =
Tpetra::DefaultPlatform::getDefaultPlatform ().getComm ();
const int MyPID = comm->getRank ();
bool verbose = false;
bool debug = false;
bool insitu = false;
bool herm = false;
std::string which("LM");
std::string filename;
int nev = 4;
int blockSize = 4;
MT tol = 1.0e-6;
Teuchos::CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nodebug",&debug,"Print debugging information.");
cmdp.setOption("insitu","exsitu",&insitu,"Perform in situ restarting.");
cmdp.setOption("sort",&which,"Targetted eigenvalues (SM or LM).");
cmdp.setOption("herm","nonherm",&herm,"Solve Hermitian or non-Hermitian problem.");
cmdp.setOption("filename",&filename,"Filename for Harwell-Boeing test matrix (assumes non-Hermitian unless specified otherwise).");
cmdp.setOption("nev",&nev,"Number of eigenvalues to compute.");
cmdp.setOption("blockSize",&blockSize,"Block size for the algorithm.");
cmdp.setOption("tol",&tol,"Tolerance for convergence.");
if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
return -1;
}
if (debug) verbose = true;
if (filename == "") {
// get default based on herm
if (herm) {
filename = "mhd1280b.cua";
}
else {
filename = "mhd1280a.cua";
}
}
if (MyPID == 0) {
cout << Anasazi::Anasazi_Version() << endl << endl;
}
// Get the data from the HB file
int dim,dim2,nnz;
int rnnzmax;
double *dvals;
int *colptr,*rowind;
nnz = -1;
if (MyPID == 0) {
info = readHB_newmat_double(filename.c_str(),&dim,&dim2,&nnz,&colptr,&rowind,&dvals);
// find maximum NNZ over all rows
vector<int> rnnz(dim,0);
for (int *ri=rowind; ri<rowind+nnz; ++ri) {
++rnnz[*ri-1];
}
rnnzmax = *std::max_element(rnnz.begin(),rnnz.end());
}
else {
// address uninitialized data warnings
dvals = NULL;
colptr = NULL;
rowind = NULL;
}
Teuchos::broadcast(*comm,0,&info);
Teuchos::broadcast(*comm,0,&nnz);
Teuchos::broadcast(*comm,0,&dim);
Teuchos::broadcast(*comm,0,&rnnzmax);
if (info == 0 || nnz < 0) {
if (MyPID == 0) {
cout << "Error reading '" << filename << "'" << endl
<< "End Result: TEST FAILED" << endl;
}
return -1;
}
// create map
RCP<const Map<> > map = rcp (new Map<> (dim, 0, comm));
RCP<CrsMatrix<ST> > K = rcp (new CrsMatrix<ST> (map, rnnzmax));
if (MyPID == 0) {
// Convert interleaved doubles to complex values
// HB format is compressed column. CrsMatrix is compressed row.
const double *dptr = dvals;
const int *rptr = rowind;
for (int c=0; c<dim; ++c) {
for (int colnnz=0; colnnz < colptr[c+1]-colptr[c]; ++colnnz) {
K->insertGlobalValues (static_cast<GO> (*rptr++ - 1), tuple<GO> (c), tuple (ST (dptr[0], dptr[1])));
dptr += 2;
}
}
}
if (MyPID == 0) {
// Clean up.
free( dvals );
free( colptr );
free( rowind );
}
K->fillComplete();
// cout << *K << endl;
// Create initial vectors
RCP<MV> ivec = rcp( new MV(map,blockSize) );
ivec->randomize ();
// Create eigenproblem
RCP<Anasazi::BasicEigenproblem<ST,MV,OP> > problem =
rcp( new Anasazi::BasicEigenproblem<ST,MV,OP>(K,ivec) );
//
// Inform the eigenproblem that the operator K is symmetric
problem->setHermitian(herm);
//
// Set the number of eigenvalues requested
problem->setNEV( nev );
//
// Inform the eigenproblem that you are done passing it information
bool boolret = problem->setProblem();
if (boolret != true) {
if (MyPID == 0) {
cout << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << endl
<< "End Result: TEST FAILED" << endl;
}
return -1;
}
// Set verbosity level
int verbosity = Anasazi::Errors + Anasazi::Warnings + Anasazi::FinalSummary + Anasazi::TimingDetails;
if (verbose) {
verbosity += Anasazi::IterationDetails;
}
if (debug) {
verbosity += Anasazi::Debug;
}
// Eigensolver parameters
int numBlocks = 8;
int maxRestarts = 10;
//
// Create parameter list to pass into the solver manager
Teuchos::ParameterList MyPL;
MyPL.set( "Verbosity", verbosity );
MyPL.set( "Which", which );
MyPL.set( "Block Size", blockSize );
MyPL.set( "Num Blocks", numBlocks );
MyPL.set( "Maximum Restarts", maxRestarts );
MyPL.set( "Convergence Tolerance", tol );
MyPL.set( "In Situ Restarting", insitu );
//
// Create the solver manager
Anasazi::BlockKrylovSchurSolMgr<ST,MV,OP> MySolverMgr(problem, MyPL);
// Solve the problem to the specified tolerances or length
Anasazi::ReturnType returnCode = MySolverMgr.solve();
success = (returnCode == Anasazi::Converged);
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<ST,MV> sol = problem->getSolution();
RCP<MV> evecs = sol.Evecs;
int numev = sol.numVecs;
if (numev > 0) {
std::ostringstream os;
os.setf(std::ios::scientific, std::ios::floatfield);
os.precision(6);
// Compute the direct residual
std::vector<MT> normV( numev );
Teuchos::SerialDenseMatrix<int,ST> T (numev, numev);
for (int i=0; i<numev; i++) {
T(i,i) = ST(sol.Evals[i].realpart,sol.Evals[i].imagpart);
}
RCP<MV> Kvecs = MVT::Clone( *evecs, numev );
OPT::Apply( *K, *evecs, *Kvecs );
MVT::MvTimesMatAddMv( -ONE, *evecs, T, ONE, *Kvecs );
MVT::MvNorm( *Kvecs, normV );
os << "Direct residual norms computed in BlockKrylovSchurComplex_test.exe" << endl
<< std::setw(20) << "Eigenvalue" << std::setw(20) << "Residual " << endl
<< "----------------------------------------" << endl;
for (int i=0; i<numev; i++) {
if ( SCT::magnitude(T(i,i)) != SCT::zero() ) {
normV[i] = SCT::magnitude(normV[i]/T(i,i));
}
os << std::setw(20) << T(i,i) << std::setw(20) << normV[i] << endl;
success = (normV[i] < tol);
}
if (MyPID==0) {
cout << endl << os.str() << endl;
}
}
if (MyPID==0) {
if (success)
cout << "End Result: TEST PASSED" << endl;
else
cout << "End Result: TEST FAILED" << endl;
}
return ( success ? EXIT_SUCCESS : EXIT_FAILURE );
#endif // HAVE_TPETRA_COMPLEX_DOUBLE
}
void IncSVDPOD::Initialize( const Teuchos::RCP< Teuchos::ParameterList >& params,
const Teuchos::RCP< const Epetra_MultiVector >& ss,
const Teuchos::RCP< RBGen::FileIOHandler< Epetra_Operator > >& fileio ) {
using Teuchos::rcp;
// Get the "Reduced Basis Method" sublist.
Teuchos::ParameterList rbmethod_params = params->sublist( "Reduced Basis Method" );
// Get the maximum basis size
maxBasisSize_ = rbmethod_params.get<int>("Max Basis Size");
TEUCHOS_TEST_FOR_EXCEPTION(maxBasisSize_ < 2,std::invalid_argument,"\"Max Basis Size\" must be at least 2.");
// Get a filter
filter_ = rbmethod_params.get<Teuchos::RCP<Filter<double> > >("Filter",Teuchos::null);
if (filter_ == Teuchos::null) {
int k = rbmethod_params.get("Rank",(int)5);
filter_ = rcp( new RangeFilter<double>(LARGEST,k,k) );
}
// Get convergence tolerance
tol_ = rbmethod_params.get<double>("Convergence Tolerance",tol_);
// Get debugging flag
debug_ = rbmethod_params.get<bool>("IncSVD Debug",debug_);
// Get verbosity level
verbLevel_ = rbmethod_params.get<int>("IncSVD Verbosity Level",verbLevel_);
// Get an Anasazi orthomanager
if (rbmethod_params.isType<
Teuchos::RCP< Anasazi::OrthoManager<double,Epetra_MultiVector> >
>("Ortho Manager")
)
{
ortho_ = rbmethod_params.get<
Teuchos::RCP<Anasazi::OrthoManager<double,Epetra_MultiVector> >
>("Ortho Manager");
TEUCHOS_TEST_FOR_EXCEPTION(ortho_ == Teuchos::null,std::invalid_argument,"User specified null ortho manager.");
}
else {
std::string omstr = rbmethod_params.get("Ortho Manager","DGKS");
if (omstr == "SVQB") {
ortho_ = rcp( new Anasazi::SVQBOrthoManager<double,Epetra_MultiVector,Epetra_Operator>() );
}
else { // if omstr == "DGKS"
ortho_ = rcp( new Anasazi::BasicOrthoManager<double,Epetra_MultiVector,Epetra_Operator>() );
}
}
// Lmin,Lmax,Kstart
lmin_ = rbmethod_params.get("Min Update Size",1);
TEUCHOS_TEST_FOR_EXCEPTION(lmin_ < 1 || lmin_ >= maxBasisSize_,std::invalid_argument,
"Method requires 1 <= min update size < max basis size.");
lmax_ = rbmethod_params.get("Max Update Size",maxBasisSize_);
TEUCHOS_TEST_FOR_EXCEPTION(lmin_ > lmax_,std::invalid_argument,"Max update size must be >= min update size.");
startRank_ = rbmethod_params.get("Start Rank",lmin_);
TEUCHOS_TEST_FOR_EXCEPTION(startRank_ < 1 || startRank_ > maxBasisSize_,std::invalid_argument,
"Starting rank must be in [1,maxBasisSize_)");
// MaxNumPasses
maxNumPasses_ = rbmethod_params.get("Maximum Number Passes",maxNumPasses_);
TEUCHOS_TEST_FOR_EXCEPTION(maxNumPasses_ != -1 && maxNumPasses_ <= 0, std::invalid_argument,
"Maximum number passes must be -1 or > 0.");
// Save the pointer to the snapshot matrix
TEUCHOS_TEST_FOR_EXCEPTION(ss == Teuchos::null,std::invalid_argument,"Input snapshot matrix cannot be null.");
A_ = ss;
// MaxNumCols
maxNumCols_ = A_->NumVectors();
maxNumCols_ = rbmethod_params.get("Maximum Number Columns",maxNumCols_);
TEUCHOS_TEST_FOR_EXCEPTION(maxNumCols_ < A_->NumVectors(), std::invalid_argument,
"Maximum number of columns must be at least as many as in the initializing data set.");
// V locally replicated or globally distributed
// this must be true for now
// Vlocal_ = rbmethod_params.get("V Local",Vlocal_);
// Allocate space for the factorization
sigma_.reserve( maxBasisSize_ );
U_ = Teuchos::null;
V_ = Teuchos::null;
U_ = rcp( new Epetra_MultiVector(ss->Map(),maxBasisSize_,false) );
if (Vlocal_) {
Epetra_LocalMap lclmap(maxNumCols_,0,ss->Comm());
V_ = rcp( new Epetra_MultiVector(lclmap,maxBasisSize_,false) );
}
else {
Epetra_Map gblmap(maxNumCols_,0,ss->Comm());
V_ = rcp( new Epetra_MultiVector(gblmap,maxBasisSize_,false) );
}
B_ = rcp( new Epetra_SerialDenseMatrix(maxBasisSize_,maxBasisSize_) );
resNorms_.reserve(maxBasisSize_);
// clear counters
numProc_ = 0;
curNumPasses_ = 0;
// we are now initialized, albeit with null rank
isInitialized_ = true;
}
TEUCHOS_UNIT_TEST(tUniqueGlobalIndexer_Utilities,GhostedFieldVector)
{
// build global (or serial communicator)
#ifdef HAVE_MPI
RCP<Epetra_Comm> eComm = rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
RCP<Epetra_Comm> eComm = rcp(new Epetra_SerialComm());
#endif
int myRank = eComm->MyPID();
int numProcs = eComm->NumProc();
TEUCHOS_ASSERT(numProcs==2);
RCP<panzer::UniqueGlobalIndexer<short,int> > globalIndexer
= rcp(new panzer::unit_test::UniqueGlobalIndexer(myRank,numProcs));
std::vector<int> ghostedFields;
std::vector<int> sharedIndices;
globalIndexer->getOwnedAndSharedIndices(sharedIndices);
panzer::buildGhostedFieldVector(*globalIndexer,ghostedFields);
TEST_EQUALITY(ghostedFields.size(),sharedIndices.size());
TEST_COMPARE(*std::min_element(ghostedFields.begin(),ghostedFields.end()),>,-1);
std::stringstream ss;
ss << "Field Numbers = ";
for(std::size_t i=0;i<ghostedFields.size();i++)
ss << sharedIndices[i] << ":" << ghostedFields[i] << " ";
out << std::endl;
out << ss.str() << std::endl;
if(myRank==0) {
TEST_EQUALITY(ghostedFields[0], 0);
TEST_EQUALITY(ghostedFields[1], 1);
TEST_EQUALITY(ghostedFields[2], 0);
TEST_EQUALITY(ghostedFields[3], 1);
TEST_EQUALITY(ghostedFields[4], 0);
TEST_EQUALITY(ghostedFields[5], 1);
TEST_EQUALITY(ghostedFields[6], 0);
TEST_EQUALITY(ghostedFields[7], 1);
TEST_EQUALITY(ghostedFields[8], 0);
TEST_EQUALITY(ghostedFields[9], 1);
TEST_EQUALITY(ghostedFields[10],0);
TEST_EQUALITY(ghostedFields[11],0);
TEST_EQUALITY(ghostedFields[12],0);
TEST_EQUALITY(ghostedFields[13],1);
}
else if(myRank==1) {
TEST_EQUALITY(ghostedFields[0], 0);
TEST_EQUALITY(ghostedFields[1], 1);
TEST_EQUALITY(ghostedFields[2], 0);
TEST_EQUALITY(ghostedFields[3], 1);
TEST_EQUALITY(ghostedFields[4], 0);
TEST_EQUALITY(ghostedFields[5], 1);
TEST_EQUALITY(ghostedFields[6], 0);
TEST_EQUALITY(ghostedFields[7], 1);
TEST_EQUALITY(ghostedFields[8], 0);
TEST_EQUALITY(ghostedFields[9], 0);
TEST_EQUALITY(ghostedFields[10],0);
TEST_EQUALITY(ghostedFields[11],0);
}
else
TEUCHOS_ASSERT(false);
}
TEUCHOS_UNIT_TEST(tUniqueGlobalIndexer_Utilities,ArrayToFieldVector_multicol)
{
typedef Intrepid::FieldContainer<int> IntFieldContainer;
// build global (or serial communicator)
#ifdef HAVE_MPI
RCP<Epetra_Comm> eComm = rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
RCP<Epetra_Comm> eComm = rcp(new Epetra_SerialComm());
#endif
int myRank = eComm->MyPID();
int numProcs = eComm->NumProc();
TEUCHOS_ASSERT(numProcs==2);
RCP<panzer::UniqueGlobalIndexer<short,int> > globalIndexer
= rcp(new panzer::unit_test::UniqueGlobalIndexer(myRank,numProcs));
panzer::ArrayToFieldVector<short,int,KokkosClassic::DefaultNode::DefaultNodeType> atfv(globalIndexer);
Teuchos::RCP<const Tpetra::Map<int,int> > uMap = atfv.getFieldMap("U"); // these will be tested below!
Teuchos::RCP<const Tpetra::Map<int,int> > tMap = atfv.getFieldMap("T");
std::map<std::string,IntFieldContainer> dataU, dataT;
std::size_t numCols = 5;
fillFieldContainer(globalIndexer->getFieldNum("U"),"block_0",*globalIndexer,dataU["block_0"],numCols);
fillFieldContainer(globalIndexer->getFieldNum("U"),"block_1",*globalIndexer,dataU["block_1"],numCols);
fillFieldContainer(globalIndexer->getFieldNum("T"),"block_0",*globalIndexer,dataT["block_0"],numCols);
Teuchos::RCP<Tpetra::MultiVector<int,int,int> > reducedUDataVector = atfv.getDataVector<int>("U",dataU);
Teuchos::RCP<Tpetra::MultiVector<int,int,int> > reducedTDataVector = atfv.getDataVector<int>("T",dataT);
TEST_EQUALITY(reducedUDataVector->getNumVectors(),numCols);
TEST_EQUALITY(reducedTDataVector->getNumVectors(),numCols);
for(std::size_t c=0;c<numCols;c++) {
std::vector<int> fields_u(reducedUDataVector->getLocalLength());
std::vector<int> fields_t(reducedTDataVector->getLocalLength());
reducedUDataVector->getVector(c)->get1dCopy(Teuchos::arrayViewFromVector(fields_u));
reducedTDataVector->getVector(c)->get1dCopy(Teuchos::arrayViewFromVector(fields_t));
if(myRank==0) {
TEST_EQUALITY(reducedUDataVector->getLocalLength(),6);
TEST_EQUALITY(reducedTDataVector->getLocalLength(),5);
TEST_EQUALITY(fields_u[0], 6+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[1], 0+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[2], 2+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[3], 8+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[4],10+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[5],13+Teuchos::as<int>(c));
TEST_EQUALITY(fields_t[0], 7+Teuchos::as<int>(c));
TEST_EQUALITY(fields_t[1], 1+Teuchos::as<int>(c));
TEST_EQUALITY(fields_t[2], 3+Teuchos::as<int>(c));
TEST_EQUALITY(fields_t[3], 9+Teuchos::as<int>(c));
TEST_EQUALITY(fields_t[4],11+Teuchos::as<int>(c));
}
else if(myRank==1) {
TEST_EQUALITY(reducedUDataVector->getLocalLength(),4);
TEST_EQUALITY(reducedTDataVector->getLocalLength(),1);
TEST_EQUALITY(fields_u[0], 4+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[1],12+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[2],15+Teuchos::as<int>(c));
TEST_EQUALITY(fields_u[3],14+Teuchos::as<int>(c));
TEST_EQUALITY(fields_t[0], 5+Teuchos::as<int>(c));
}
else
TEUCHOS_ASSERT(false);
}
if(myRank==0) {
TEST_EQUALITY(uMap->getNodeNumElements(),6);
TEST_EQUALITY(uMap->getGlobalElement(0),6);
TEST_EQUALITY(uMap->getGlobalElement(1),0);
TEST_EQUALITY(uMap->getGlobalElement(2),2);
TEST_EQUALITY(uMap->getGlobalElement(3),8);
TEST_EQUALITY(uMap->getGlobalElement(4),10);
TEST_EQUALITY(uMap->getGlobalElement(5),13);
TEST_EQUALITY(tMap->getNodeNumElements(),5);
TEST_EQUALITY(tMap->getGlobalElement(0),7);
TEST_EQUALITY(tMap->getGlobalElement(1),1);
TEST_EQUALITY(tMap->getGlobalElement(2),3);
TEST_EQUALITY(tMap->getGlobalElement(3),9);
TEST_EQUALITY(tMap->getGlobalElement(4),11);
}
else if(myRank==1) {
TEST_EQUALITY(uMap->getNodeNumElements(),4);
TEST_EQUALITY(uMap->getGlobalElement(0),4);
TEST_EQUALITY(uMap->getGlobalElement(1),12);
TEST_EQUALITY(uMap->getGlobalElement(2),15);
TEST_EQUALITY(uMap->getGlobalElement(3),14);
TEST_EQUALITY(tMap->getNodeNumElements(),1);
TEST_EQUALITY(tMap->getGlobalElement(0),5);
}
else
TEUCHOS_ASSERT(false);
}
int main(int argc, char* argv[])
{
info("Desired number of eigenvalues: %d.", NUMBER_OF_EIGENVALUES);
// Load the mesh.
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
// Perform initial mesh refinements (optional).
for (int i = 0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Enter boundary markers.
BCTypes bc_types;
bc_types.add_bc_dirichlet(BDY_ALL);
// Enter Dirichlet boundary values.
BCValues bc_values;
bc_values.add_zero(BDY_ALL);
// Create an H1 space with default shapeset.
H1Space space(&mesh, &bc_types, &bc_values, P_INIT);
int ndof = Space::get_num_dofs(&space);
info("ndof: %d.", ndof);
// Initialize the weak formulation for the left hand side, i.e., H.
WeakForm wf_left, wf_right;
wf_left.add_matrix_form(callback(bilinear_form_left));
wf_right.add_matrix_form(callback(bilinear_form_right));
// Initialize matrices.
RCP<SparseMatrix> matrix_left = rcp(new CSCMatrix());
RCP<SparseMatrix> matrix_right = rcp(new CSCMatrix());
// Assemble the matrices.
bool is_linear = true;
DiscreteProblem dp_left(&wf_left, &space, is_linear);
dp_left.assemble(matrix_left.get());
DiscreteProblem dp_right(&wf_right, &space, is_linear);
dp_right.assemble(matrix_right.get());
EigenSolver es(matrix_left, matrix_right);
info("Calling Pysparse...");
es.solve(NUMBER_OF_EIGENVALUES, TARGET_VALUE, TOL, MAX_ITER);
info("Pysparse finished.");
es.print_eigenvalues();
// Initializing solution vector, solution and ScalarView.
double* coeff_vec;
Solution sln;
ScalarView view("Solution", new WinGeom(0, 0, 440, 350));
// Reading solution vectors and visualizing.
double* eigenval = new double[NUMBER_OF_EIGENVALUES];
int neig = es.get_n_eigs();
if (neig != NUMBER_OF_EIGENVALUES) error("Mismatched number of eigenvectors in the eigensolver output file.");
for (int ieig = 0; ieig < neig; ieig++) {
eigenval[ieig] = es.get_eigenvalue(ieig);
int n;
es.get_eigenvector(ieig, &coeff_vec, &n);
// Convert coefficient vector into a Solution.
Solution::vector_to_solution(coeff_vec, &space, &sln);
// Visualize the solution.
char title[100];
sprintf(title, "Solution %d, val = %g", ieig, eigenval[ieig]);
view.set_title(title);
view.show(&sln);
// Wait for keypress.
View::wait(HERMES_WAIT_KEYPRESS);
}
return 0;
};
//
// Constructor
//
MyOp(const GlobalOrdinal n, const RCP< const Teuchos::Comm<int> > comm)
{
//
// Construct a map for our block row distribution
//
opMap_ = rcp( new Map(n, 0, comm) );
//
// Get the rank of this process and the number of processes
// We're going to have to do something special with the first and last processes
//
myRank_ = comm->getRank();
numProcs_ = comm->getSize();
//
// Get the local number of rows
//
LocalOrdinal nlocal = opMap_->getNodeNumElements();
//
// Define the distribution that you need for the matvec.
// When you define this for your own operator, it is helpful to draw pictures
// on a sheet of paper to keep track of who needs to receive which elements.
// Here, each process needs to receive one element from each of its neighbors.
//
// All processes but the first will receive one entry from the
// previous process.
if (myRank_ > 0) {
nlocal++;
}
// All processes but the last will receive one entry from the next
// process.
if (myRank_ < numProcs_-1) {
nlocal++;
}
// Construct a list of columns where this process has nonzero elements.
// For our tridiagonal matrix, this is firstRowItOwns-1:lastRowItOwns+1.
std::vector<GlobalOrdinal> indices;
indices.reserve (nlocal);
// The first process is a special case...
if (myRank_ > 0) {
indices.push_back (opMap_->getMinGlobalIndex () - 1);
}
for (GlobalOrdinal i = opMap_->getMinGlobalIndex ();
i <= opMap_->getMaxGlobalIndex (); ++i) {
indices.push_back (i);
}
// So is the last process...
if (myRank_ < numProcs_-1) {
indices.push_back (opMap_->getMaxGlobalIndex () + 1);
}
// Wrap our vector in an array view, which is like a raw pointer.
Teuchos::ArrayView<const GlobalOrdinal> elementList (indices);
// Make a Map for handling the redistribution. There will be some
// redundancies (i.e., some of the entries will be owned by
// multiple MPI processes).
GlobalOrdinal numGlobalElements = n + 2*(numProcs_-1);
redistMap_ = rcp (new Map (numGlobalElements, elementList, 0, comm));
// Make an Import object that describes how data will be
// redistributed. It takes a Map describing who owns what
// originally, and a Map that describes who you WANT to own what.
importer_= rcp (new Import (opMap_, redistMap_));
}
bool run( const Teuchos::RCP<const Teuchos::Comm<int> > & comm ,
const CMD & cmd)
{
typedef typename Kokkos::Compat::KokkosDeviceWrapperNode<Device> NodeType;
bool success = true;
try {
const int comm_rank = comm->getRank();
// Create Tpetra Node -- do this first as it initializes host/device
Teuchos::RCP<NodeType> node = createKokkosNode<NodeType>( cmd , *comm );
// Set up stochastic discretization
using Teuchos::Array;
using Teuchos::RCP;
using Teuchos::rcp;
typedef Stokhos::OneDOrthogPolyBasis<int,double> one_d_basis;
typedef Stokhos::LegendreBasis<int,double> legendre_basis;
typedef Stokhos::LexographicLess< Stokhos::MultiIndex<int> > order_type;
typedef Stokhos::TotalOrderBasis<int,double,order_type> product_basis;
typedef Stokhos::Sparse3Tensor<int,double> Cijk;
const int dim = cmd.CMD_USE_UQ_DIM;
const int order = cmd.CMD_USE_UQ_ORDER ;
Array< RCP<const one_d_basis> > bases(dim);
for (int i=0; i<dim; i++)
bases[i] = rcp(new legendre_basis(order, true));
RCP<const product_basis> basis = rcp(new product_basis(bases));
RCP<Cijk> cijk = basis->computeTripleProductTensor();
typedef Stokhos::DynamicStorage<int,double,Device> Storage;
typedef Sacado::UQ::PCE<Storage> Scalar;
typename Scalar::cijk_type kokkos_cijk =
Stokhos::create_product_tensor<Device>(*basis, *cijk);
Kokkos::setGlobalCijkTensor(kokkos_cijk);
// typedef Stokhos::TensorProductQuadrature<int,double> quadrature;
// RCP<const quadrature> quad = rcp(new quadrature(basis));
// const int num_quad_points = quad->size();
// const Array<double>& quad_weights = quad->getQuadWeights();
// const Array< Array<double> >& quad_points = quad->getQuadPoints();
// const Array< Array<double> >& quad_values = quad->getBasisAtQuadPoints();
// Print output headers
const std::vector< size_t > widths =
print_headers( std::cout , cmd , comm_rank );
using Kokkos::Example::FENL::TrivialManufacturedSolution;
using Kokkos::Example::FENL::ElementComputationKLCoefficient;
using Kokkos::Example::BoxElemPart;
using Kokkos::Example::FENL::fenl;
using Kokkos::Example::FENL::Perf;
const double bc_lower_value = 1 ;
const double bc_upper_value = 2 ;
const TrivialManufacturedSolution manufactured_solution;
int nelem[3] = { cmd.CMD_USE_FIXTURE_X ,
cmd.CMD_USE_FIXTURE_Y ,
cmd.CMD_USE_FIXTURE_Z };
// Create KL diffusion coefficient
const double kl_mean = cmd.CMD_USE_MEAN;
const double kl_variance = cmd.CMD_USE_VAR;
const double kl_correlation = cmd.CMD_USE_COR;
typedef ElementComputationKLCoefficient< Scalar, double, Device > KL;
KL diffusion_coefficient( kl_mean, kl_variance, kl_correlation, dim );
typedef typename KL::RandomVariableView RV;
typedef typename RV::HostMirror HRV;
RV rv = diffusion_coefficient.getRandomVariables();
HRV hrv = Kokkos::create_mirror_view(rv);
// Set random variables
// ith random variable \xi_i = \psi_I(\xi) / \psi_I(1.0)
// where I is determined by the basis ordering (since the component basis
// functions have unit two-norm, \psi_I(1.0) might not be 1.0). We compute
// this by finding the index of the multivariate term that is first order in
// the ith slot, all other orders 0
Teuchos::Array<double> point(dim, 1.0);
Teuchos::Array<double> basis_vals(basis->size());
basis->evaluateBases(point, basis_vals);
for (int i=0; i<dim; ++i) {
Stokhos::MultiIndex<int> term(dim, 0);
term[i] = 1;
int index = basis->index(term);
hrv(i).fastAccessCoeff(index) = 1.0 / basis_vals[index];
}
Kokkos::deep_copy( rv, hrv );
// Compute stochastic response using stochastic Galerkin method
Scalar response = 0;
Perf perf;
if ( cmd.CMD_USE_FIXTURE_QUADRATIC )
perf = fenl< Scalar , Device , BoxElemPart::ElemQuadratic >
( comm , node , cmd.CMD_PRINT , cmd.CMD_USE_TRIALS ,
cmd.CMD_USE_ATOMIC , cmd.CMD_USE_BELOS , cmd.CMD_USE_MUELU ,
cmd.CMD_USE_MEANBASED ,
nelem , diffusion_coefficient , manufactured_solution ,
bc_lower_value , bc_upper_value ,
false , response);
else
perf = fenl< Scalar , Device , BoxElemPart::ElemLinear >
( comm , node , cmd.CMD_PRINT , cmd.CMD_USE_TRIALS ,
cmd.CMD_USE_ATOMIC , cmd.CMD_USE_BELOS , cmd.CMD_USE_MUELU ,
cmd.CMD_USE_MEANBASED ,
nelem , diffusion_coefficient , manufactured_solution ,
bc_lower_value , bc_upper_value ,
false , response);
// std::cout << "newton count = " << perf.newton_iter_count
// << " cg count = " << perf.cg_iter_count << std::endl;
int pce_size = basis->size();
perf.uq_count = pce_size;
perf.newton_iter_count *= pce_size;
perf.cg_iter_count *= pce_size;
perf.map_ratio *= pce_size;
perf.fill_node_set *= pce_size;
perf.scan_node_count *= pce_size;
perf.fill_graph_entries *= pce_size;
perf.sort_graph_entries *= pce_size;
perf.fill_element_graph *= pce_size;
// Compute response mean, variance
perf.response_mean = response.mean();
perf.response_std_dev = response.standard_deviation();
//std::cout << std::endl << response << std::endl;
if ( 0 == comm_rank ) {
print_perf_value( std::cout , cmd , widths , perf );
}
if ( cmd.CMD_SUMMARIZE ) {
Teuchos::TimeMonitor::report (comm.ptr (), std::cout);
}
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true, std::cerr, success);
return success;
}
// Compute Y = alpha Op X + beta Y.
//
// TraceMin will never use alpha ~= 1 or beta ~= 0,
// so we have ignored those options for simplicity.
void
apply (const TMV& X,
TMV& Y,
Teuchos::ETransp mode = Teuchos::NO_TRANS,
Scalar alpha = Teuchos::ScalarTraits<Scalar>::one (),
Scalar beta = Teuchos::ScalarTraits<Scalar>::zero ()) const
{
typedef Teuchos::ScalarTraits<Scalar> SCT;
//
// Let's make sure alpha is 1 and beta is 0...
// This will throw an exception if that is not the case.
//
TEUCHOS_TEST_FOR_EXCEPTION(
alpha != SCT::one() || beta != SCT::zero(), std::logic_error,
"MyOp::apply was given alpha != 1 or beta != 0. It does not currently "
"implement either of those two cases.");
// Get the number of local rows
const LocalOrdinal nlocRows = X.getLocalLength();
// Get the number of vectors
const int numVecs = X.getNumVectors();
// Make a multivector for holding the redistributed data
RCP<TMV> redistData = rcp(new TMV(redistMap_, numVecs));
// Redistribute the data.
// This will do all the necessary communication for you.
// All processes now own enough data to do the matvec.
redistData->doImport(X, *importer_, Tpetra::INSERT);
// Perform the matvec with the data we now locally own
//
// For each column...
for (int c = 0; c < numVecs; ++c) {
// Get a view of the desired column
Teuchos::ArrayRCP<Scalar> colView = redistData->getDataNonConst (c);
int offset;
// Y[0,c] = -colView[0] + 2*colView[1] - colView[2] (using local indices)
if (myRank_ > 0) {
Y.replaceLocalValue (0, c, -colView[0] + 2*colView[1] - colView[2]);
offset = 0;
}
// Y[0,c] = 2*colView[1] - colView[2] (using local indices)
else {
Y.replaceLocalValue(0, c, 2*colView[0] - colView[1]);
offset = 1;
}
// Y[r,c] = -colView[r-offset] + 2*colView[r+1-offset] - colView[r+2-offset]
for(LocalOrdinal r=1; r<nlocRows-1; r++) {
Y.replaceLocalValue(r, c, -colView[r-offset] + 2*colView[r+1-offset] - colView[r+2-offset]);
}
// Y[nlocRows-1,c] = -colView[nlocRows-1-offset] + 2*colView[nlocRows-offset] - colView[nlocRows+1-offset]
if (myRank_ < numProcs_-1) {
Y.replaceLocalValue(nlocRows-1, c, -colView[nlocRows-1-offset] + 2*colView[nlocRows-offset] - colView[nlocRows+1-offset]);
}
// Y[nlocRows-1,c] = -colView[nlocRows-1-offset] + 2*colView[nlocRows-offset]
else {
Y.replaceLocalValue(nlocRows-1, c, -colView[nlocRows-1-offset] + 2*colView[nlocRows-offset]);
}
}
}
int main(int argc, char *argv[]) {
#include <MueLu_UseShortNames.hpp>
using Teuchos::RCP; // reference count pointers
using Teuchos::rcp;
using Teuchos::TimeMonitor;
// =========================================================================
// MPI initialization using Teuchos
// =========================================================================
Teuchos::GlobalMPISession mpiSession(&argc, &argv, NULL);
RCP< const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
int MyPID = comm->getRank();
int NumProc = comm->getSize();
const Teuchos::RCP<Epetra_Comm> epComm = Teuchos::rcp_const_cast<Epetra_Comm>(Xpetra::toEpetra(comm));
// =========================================================================
// Convenient definitions
// =========================================================================
//SC zero = Teuchos::ScalarTraits<SC>::zero(), one = Teuchos::ScalarTraits<SC>::one();
// Instead of checking each time for rank, create a rank 0 stream
RCP<Teuchos::FancyOStream> fancy = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
Teuchos::FancyOStream& fancyout = *fancy;
fancyout.setOutputToRootOnly(0);
// =========================================================================
// Parameters initialization
// =========================================================================
Teuchos::CommandLineProcessor clp(false);
GO nx = 100, ny = 100;
clp.setOption("nx", &nx, "mesh size in x direction");
clp.setOption("ny", &ny, "mesh size in y direction");
std::string xmlFileName = "xml/s3a.xml"; clp.setOption("xml", &xmlFileName, "read parameters from a file. Otherwise, this example uses by default 'tutorial1a.xml'");
int mgridSweeps = 1; clp.setOption("mgridSweeps", &mgridSweeps, "number of multigrid sweeps within Multigrid solver.");
std::string printTimings = "no"; clp.setOption("timings", &printTimings, "print timings to screen [yes/no]");
double tol = 1e-12; clp.setOption("tol", &tol, "solver convergence tolerance");
switch (clp.parse(argc,argv)) {
case Teuchos::CommandLineProcessor::PARSE_HELP_PRINTED: return EXIT_SUCCESS; break;
case Teuchos::CommandLineProcessor::PARSE_ERROR:
case Teuchos::CommandLineProcessor::PARSE_UNRECOGNIZED_OPTION: return EXIT_FAILURE; break;
case Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL: break;
}
// =========================================================================
// Problem construction
// =========================================================================
RCP<TimeMonitor> globalTimeMonitor = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: S - Global Time"))), tm;
comm->barrier();
tm = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 1 - Matrix Build")));
Teuchos::ParameterList GaleriList;
GaleriList.set("nx", nx);
GaleriList.set("ny", ny);
GaleriList.set("mx", epComm->NumProc());
GaleriList.set("my", 1);
GaleriList.set("lx", 1.0); // length of x-axis
GaleriList.set("ly", 1.0); // length of y-axis
GaleriList.set("diff", 1e-5);
GaleriList.set("conv", 1.0);
// create map
Teuchos::RCP<Epetra_Map> epMap = Teuchos::rcp(Galeri::CreateMap("Cartesian2D", *epComm, GaleriList));
// create coordinates
Teuchos::RCP<Epetra_MultiVector> epCoord = Teuchos::rcp(Galeri::CreateCartesianCoordinates("2D", epMap.get(), GaleriList));
// create matrix
Teuchos::RCP<Epetra_CrsMatrix> epA = Teuchos::rcp(Galeri::CreateCrsMatrix("Recirc2D", epMap.get(), GaleriList));
// Epetra -> Xpetra
Teuchos::RCP<CrsMatrix> exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrix(epA));
Teuchos::RCP<CrsMatrixWrap> exAWrap = Teuchos::rcp(new CrsMatrixWrap(exA));
RCP<Matrix> A = Teuchos::rcp_dynamic_cast<Matrix>(exAWrap);
int numPDEs = 1;
A->SetFixedBlockSize(numPDEs);
// set rhs and solution vector
RCP<Epetra_Vector> B = Teuchos::rcp(new Epetra_Vector(*epMap));
RCP<Epetra_Vector> X = Teuchos::rcp(new Epetra_Vector(*epMap));
B->PutScalar(1.0);
X->PutScalar(0.0);
// Epetra -> Xpetra
RCP<Vector> xB = Teuchos::rcp(new Xpetra::EpetraVector(B));
RCP<Vector> xX = Teuchos::rcp(new Xpetra::EpetraVector(X));
xX->setSeed(100);
xX->randomize();
// build null space vector
RCP<const Map> map = A->getRowMap();
RCP<MultiVector> nullspace = MultiVectorFactory::Build(map, numPDEs);
for (int i=0; i<numPDEs; ++i) {
Teuchos::ArrayRCP<Scalar> nsValues = nullspace->getDataNonConst(i);
int numBlocks = nsValues.size() / numPDEs;
for (int j=0; j< numBlocks; ++j) {
nsValues[j*numPDEs + i] = 1.0;
}
}
comm->barrier();
tm = Teuchos::null;
fancyout << "========================================================\nGaleri complete.\n========================================================" << std::endl;
// =========================================================================
// Preconditioner construction
// =========================================================================
comm->barrier();
tm = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 1.5 - MueLu read XML")));
ParameterListInterpreter mueLuFactory(xmlFileName, *comm);
comm->barrier();
tm = Teuchos::null;
tm = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 2 - MueLu Setup")));
RCP<Hierarchy> H = mueLuFactory.CreateHierarchy();
H->GetLevel(0)->Set("A", A);
H->GetLevel(0)->Set("Nullspace", nullspace);
mueLuFactory.SetupHierarchy(*H);
comm->barrier();
tm = Teuchos::null;
// =========================================================================
// System solution (Ax = b)
// =========================================================================
//
// generate exact solution using a direct solver
//
RCP<Epetra_Vector> exactLsgVec = rcp(new Epetra_Vector(X->Map()));
{
fancyout << "========================================================\nCalculate exact solution." << std::endl;
tm = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 3 - direct solve")));
exactLsgVec->PutScalar(0.0);
exactLsgVec->Update(1.0,*X,1.0);
Epetra_LinearProblem epetraProblem(epA.get(), exactLsgVec.get(), B.get());
Amesos amesosFactory;
RCP<Amesos_BaseSolver> rcp_directSolver = Teuchos::rcp(amesosFactory.Create("Amesos_Klu", epetraProblem));
rcp_directSolver->SymbolicFactorization();
rcp_directSolver->NumericFactorization();
rcp_directSolver->Solve();
comm->barrier();
tm = Teuchos::null;
}
//
// Solve Ax = b using AMG as a preconditioner in AztecOO
//
RCP<Epetra_Vector> precLsgVec = rcp(new Epetra_Vector(X->Map()));
{
fancyout << "========================================================\nUse multigrid hierarchy as preconditioner within CG." << std::endl;
tm = rcp(new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 4 - AMG as preconditioner")));
precLsgVec->PutScalar(0.0);
precLsgVec->Update(1.0,*X,1.0);
Epetra_LinearProblem epetraProblem(epA.get(), precLsgVec.get(), B.get());
AztecOO aztecSolver(epetraProblem);
aztecSolver.SetAztecOption(AZ_solver, AZ_gmres);
MueLu::EpetraOperator aztecPrec(H);
aztecSolver.SetPrecOperator(&aztecPrec);
int maxIts = 50;
aztecSolver.Iterate(maxIts, tol);
comm->barrier();
tm = Teuchos::null;
}
//////////////////
// use multigrid hierarchy as solver
RCP<Vector> mgridLsgVec = VectorFactory::Build(map);
mgridLsgVec->putScalar(0.0);
{
fancyout << "========================================================\nUse multigrid hierarchy as solver." << std::endl;
tm = rcp (new TimeMonitor(*TimeMonitor::getNewTimer("ScalingTest: 5 - Multigrid Solve")));
mgridLsgVec->update(1.0,*xX,1.0);
H->IsPreconditioner(false);
H->Iterate(*xB, mgridSweeps, *mgridLsgVec);
comm->barrier();
tm = Teuchos::null;
}
//////////////////
fancyout << "========================================================\nExport results.\n========================================================" << std::endl;
std::ofstream myfile;
std::stringstream ss; ss << "example" << MyPID << ".txt";
myfile.open (ss.str().c_str());
//////////////////
// loop over all procs
for (int iproc=0; iproc < NumProc; iproc++) {
if (MyPID==iproc) {
int NumVectors1 = 2;
int NumMyElements1 = epCoord->Map(). NumMyElements();
int MaxElementSize1 = epCoord->Map().MaxElementSize();
int * FirstPointInElementList1 = NULL;
if (MaxElementSize1!=1) FirstPointInElementList1 = epCoord->Map().FirstPointInElementList();
double ** A_Pointers = epCoord->Pointers();
if (MyPID==0) {
myfile.width(8);
myfile << "# MyPID"; myfile << " ";
myfile.width(12);
if (MaxElementSize1==1)
myfile << "GID ";
else
myfile << " GID/Point";
for (int j = 0; j < NumVectors1 ; j++)
{
myfile.width(20);
myfile << "Value ";
}
myfile << std::endl;
}
for (int i=0; i < NumMyElements1; i++) {
for (int ii=0; ii< epCoord->Map().ElementSize(i); ii++) {
int iii;
myfile.width(10);
myfile << MyPID; myfile << " ";
myfile.width(10);
if (MaxElementSize1==1) {
if(epCoord->Map().GlobalIndicesInt())
{
int * MyGlobalElements1 = epCoord->Map().MyGlobalElements();
myfile << MyGlobalElements1[i] << " ";
}
iii = i;
}
else {
if(epCoord->Map().GlobalIndicesInt())
{
int * MyGlobalElements1 = epCoord->Map().MyGlobalElements();
myfile << MyGlobalElements1[i]<< "/" << ii << " ";
}
iii = FirstPointInElementList1[i]+ii;
}
for (int j = 0; j < NumVectors1 ; j++)
{
myfile.width(20);
myfile << A_Pointers[j][iii];
}
myfile.precision(18); // set high precision for output
// add solution vector entry
myfile.width(25); myfile << (*exactLsgVec)[iii];
// add preconditioned solution vector entry
myfile.width(25); myfile << (*precLsgVec)[iii];
Teuchos::ArrayRCP<SC> mgridLsgVecData = mgridLsgVec->getDataNonConst(0);
myfile.width(25); myfile << mgridLsgVecData[iii];
myfile.precision(6); // set default precision
myfile << std::endl;
}
} // end loop over all lines on current proc
myfile << std::flush;
// syncronize procs
comm->barrier();
comm->barrier();
comm->barrier();
} // end myProc
}
////////////
myfile.close();
comm->barrier();
tm = Teuchos::null;
globalTimeMonitor = Teuchos::null;
if (printTimings == "yes") {
TimeMonitor::summarize(A->getRowMap()->getComm().ptr(), std::cout, false, true, false, Teuchos::Union);
}
return 0;
} //main
int main(int argc, char *argv[]) {
typedef Anasazi::MultiVecTraits<Scalar, TMV> MVT;
typedef Anasazi::OperatorTraits<Scalar, TMV, TOP> OPT;
//
// Initialize the MPI session
//
Teuchos::oblackholestream blackhole;
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &blackhole);
//
// Get the default communicator
//
RCP<const Teuchos::Comm<int> > comm =
Tpetra::DefaultPlatform::getDefaultPlatform ().getComm ();
const int myRank = comm->getRank ();
//
// Get parameters from command-line processor
//
Scalar tol = 1e-5;
GlobalOrdinal n = 50;
int nev = 4;
bool verbose = true;
std::string saddleSolType = "Projected Krylov";
std::string which = "SM";
Teuchos::CommandLineProcessor cmdp (false, true);
cmdp.setOption("which",&which, "Which eigenpairs we seek. Options: SM, LM.");
cmdp.setOption ("saddleSolType", &saddleSolType, "Saddle Solver Type. "
"Options: Projected Krylov, Schur Complement, Block Diagonal "
"Preconditioned Minres.");
if(cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
return -1;
}
//
// Construct the operator.
// Note that the operator does not have to be an explicitly stored matrix.
// Here, we are using our user-defined operator.
//
RCP<MyOp> K = rcp(new MyOp(n, comm));
//
// ************************************
// Start the TraceMin-Davidson iteration
// ************************************
//
// Variables used for the TraceMin-Davidson Method
//
int verbosity;
if(verbose)
verbosity = Anasazi::TimingDetails + Anasazi::IterationDetails + Anasazi::Debug + Anasazi::FinalSummary;
else
verbosity = Anasazi::TimingDetails;
//
// Create parameter list to pass into solver
//
Teuchos::ParameterList MyPL;
MyPL.set( "Verbosity", verbosity ); // How much information should the solver print?
MyPL.set( "Saddle Solver Type", saddleSolType); // Use projected minres to solve the saddle point problem
MyPL.set( "Block Size", 2*nev ); // Add blockSize vectors to the basis per iteration
MyPL.set( "Convergence Tolerance", tol); // How small do the residuals have to be?
MyPL.set("Which", which);
MyPL.set("When To Shift", "Never");
//
// Create an Epetra_MultiVector for an initial vector to start the solver.
// Note: This needs to have the same number of columns as the blocksize.
// We are giving it random entries.
//
RCP<TMV> ivec = rcp( new TMV(K->getDomainMap(), nev) );
MVT::MvRandom( *ivec );
//
// Create the eigenproblem
//
RCP<Anasazi::BasicEigenproblem<Scalar,TMV,TOP> > MyProblem =
rcp( new Anasazi::BasicEigenproblem<Scalar,TMV,TOP>(K, ivec) );
//
// Inform the eigenproblem that the matrix pencil (K,M) is symmetric
//
MyProblem->setHermitian(true);
//
// Set the number of eigenvalues requested
//
MyProblem->setNEV( nev );
//
// Inform the eigenproblem that you are finished passing it information
//
bool boolret = MyProblem->setProblem();
if (boolret != true) {
if (myRank == 0) {
cout << "Anasazi::BasicEigenproblem::setProblem() returned with error." << endl;
}
return -1;
}
bool testFailed = false;
//
// Initialize the TraceMin-Davidson solver
//
Anasazi::Experimental::TraceMinSolMgr<Scalar, TMV, TOP> MySolverMgr(MyProblem, MyPL);
//
// Solve the problem to the specified tolerances
//
Anasazi::ReturnType returnCode = MySolverMgr.solve();
if(returnCode != Anasazi::Converged) testFailed = true;
if (returnCode != Anasazi::Converged && myRank == 0) {
cout << "Anasazi::EigensolverMgr::solve() returned unconverged." << endl;
}
else if (myRank == 0)
cout << "Anasazi::EigensolverMgr::solve() returned converged." << endl;
//
// Get the eigenvalues and eigenvectors from the eigenproblem
//
Anasazi::Eigensolution<Scalar,TMV> sol = MyProblem->getSolution();
std::vector<Anasazi::Value<Scalar> > evals = sol.Evals;
RCP<TMV> evecs = sol.Evecs;
int numev = sol.numVecs;
//
// Compute the residual, just as a precaution
//
if (numev > 0) {
Teuchos::SerialDenseMatrix<int,Scalar> T(numev,numev);
for (int i = 0; i < numev; ++i) {
T(i,i) = evals[i].realpart;
}
TMV tempvec(K->getDomainMap(), MVT::GetNumberVecs( *evecs ));
std::vector<Scalar> normR(numev);
TMV Kvec( K->getRangeMap(), MVT::GetNumberVecs( *evecs ) );
OPT::Apply( *K, *evecs, Kvec );
MVT::MvTimesMatAddMv( -1.0, *evecs, T, 1.0, Kvec );
MVT::MvNorm( Kvec, normR );
std::vector<Scalar> true_eigs (numev);
const double PI = 3.141592653589793238463;
if (which == "LM") {
for (size_t i = static_cast<size_t> (n + 1 - numev);
i <= static_cast<size_t> (n); ++i) {
Scalar omega = i*PI/(2*n+2);
true_eigs[i-(n+1-numev)] = 4*sin(omega)*sin(omega);
}
}
else {
for (int i = 1; i <= numev; ++i) {
Scalar omega = i*PI/(2*n+2);
true_eigs[i-1] = 4*sin(omega)*sin(omega);
}
}
for (int i = 0; i<numev; ++i) {
if (normR[i]/T(i,i) > tol) {
testFailed = true;
if(myRank == 0)
cout << "Test is about to fail because "
<< normR[i]/T(i,i) << " > " << tol << endl;
}
if (std::abs(T(i,i)-true_eigs[i]) > tol) {
testFailed = true;
if (myRank == 0) {
cout << "Test is about to fail because "
<< std::abs (T(i,i) - true_eigs[i]) << " > " << tol << endl;
}
}
}
if (myRank == 0) {
cout.setf(std::ios_base::right, std::ios_base::adjustfield);
cout<<"Actual Eigenvalues (obtained by Rayleigh quotient) : "<<endl;
cout<<"------------------------------------------------------"<<endl;
cout<<std::setw(16)<<"Real Part"
<<std::setw(16)<<"Error"<<endl;
cout<<"------------------------------------------------------"<<endl;
for (int i=0; i<numev; i++) {
cout<<std::setw(16)<<T(i,i)
<<std::setw(16)<<normR[i]/T(i,i)
<<endl;
}
cout<<"------------------------------------------------------"<<endl;
}
}
if(testFailed) {
cout << myRank << ": TEST FAILED\n";
if(myRank == 0)
cout << "End Result: TEST FAILED" << endl;
return -1;
}
cout << myRank << ": TEST PASSED\n";
if(myRank == 0)
cout << "End Result: TEST PASSED" << endl;
return 0;
}
void
example (const Teuchos::RCP<const Teuchos::Comm<int> >& comm,
std::ostream& out,
std::ostream& err)
{
using std::endl;
using Teuchos::ParameterList;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::Time;
using Teuchos::TimeMonitor;
typedef Tpetra::global_size_t GST;
// Set up Tpetra typedefs.
typedef double scalar_type;
typedef Tpetra::CrsMatrix<scalar_type> crs_matrix_type;
typedef Tpetra::Map<> map_type;
typedef Tpetra::Map<>::global_ordinal_type global_ordinal_type;
// Print out the Tpetra software version information.
out << Tpetra::version () << endl << endl;
// The global number of rows in the matrix A to create. We scale
// this relative to the number of (MPI) processes, so that no matter
// how many MPI processes you run, every process will have 10 rows.
const GST numGlobalIndices = 10 * comm->getSize ();
const global_ordinal_type indexBase = 0;
// Construct a Map that is global (not locally replicated), but puts
// all the equations on MPI Proc 0.
RCP<const map_type> procZeroMap;
{
const int myRank = comm->getRank ();
const size_t numLocalIndices = (myRank == 0) ? numGlobalIndices : 0;
procZeroMap = rcp (new map_type (numGlobalIndices, numLocalIndices,
indexBase, comm));
}
// Construct a Map that puts approximately the same number of
// equations on each processor.
RCP<const map_type> globalMap =
rcp (new map_type (numGlobalIndices, indexBase, comm,
Tpetra::GloballyDistributed));
// Create a sparse matrix using procZeroMap.
RCP<const crs_matrix_type> A = createMatrix<crs_matrix_type> (procZeroMap);
//
// We've created a sparse matrix that lives entirely on Process 0.
// Now we want to distribute it over all the processes.
//
// Redistribute the matrix. Since both the source and target Maps
// are one-to-one, we could use either an Import or an Export. If
// only the source Map were one-to-one, we would have to use an
// Import; if only the target Map were one-to-one, we would have to
// use an Export. We do not allow redistribution using Import or
// Export if neither source nor target Map is one-to-one.
RCP<crs_matrix_type> B;
{
// We created exportTimer in main(). It's a global timer.
// Actually starting and stopping the timer is local, but
// computing timer statistics (e.g., in TimeMonitor::summarize(),
// called in main()) is global. There are ways to restrict the
// latter to any given MPI communicator; the default is
// MPI_COMM_WORLD.
TimeMonitor monitor (*exportTimer); // Time the redistribution
// Make an export object with procZeroMap as the source Map, and
// globalMap as the target Map. The Export type has the same
// template parameters as a Map. Note that Export does not depend
// on the Scalar template parameter of the objects it
// redistributes. You can reuse the same Export for different
// Tpetra object types, or for Tpetra objects of the same type but
// different Scalar template parameters (e.g., Scalar=float or
// Scalar=double).
typedef Tpetra::Export<> export_type;
export_type exporter (procZeroMap, globalMap);
// Make a new sparse matrix whose row map is the global Map.
B = rcp (new crs_matrix_type (globalMap, 0));
// Redistribute the data, NOT in place, from matrix A (which lives
// entirely on Proc 0) to matrix B (which is distributed evenly over
// the processes).
B->doExport (*A, exporter, Tpetra::INSERT);
}
// We time redistribution of B separately from fillComplete().
B->fillComplete ();
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession session(&argc, &argv);
RCP<const Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
int nprocs = comm->getSize();
int rank = comm->getRank();
int fail=0, gfail=0;
double epsilon = 10e-6;
////////////////
// Arrays to hold part Ids and part Sizes for each weight
int numIdsPerProc = 10;
int maxNumWeights = 3;
int maxNumPartSizes = nprocs;
int *lengths = new int [maxNumWeights];
part_t **idLists = new part_t * [maxNumWeights];
scalar_t **sizeLists = new scalar_t * [maxNumWeights];
for (int w=0; w < maxNumWeights; w++){
idLists[w] = new part_t [maxNumPartSizes];
sizeLists[w] = new scalar_t [maxNumPartSizes];
}
/////////////
// A default environment
RCP<const Zoltan2::Environment> env = rcp(new Zoltan2::Environment);
/////////////
// A simple identifier map.
gno_t *myGids = new gno_t [numIdsPerProc];
for (int i=0, x=rank*numIdsPerProc; i < numIdsPerProc; i++){
myGids[i] = x++;
}
ArrayRCP<const gno_t> gidArray(myGids, 0, numIdsPerProc, true);
RCP<const Zoltan2::IdentifierMap<user_t> > idMap =
rcp(new Zoltan2::IdentifierMap<user_t>(env, comm, gidArray));
/////////////
// TEST:
// One weight, one part per proc.
// Some part sizes are 2 and some are 1.
int numGlobalParts = nprocs;
int nWeights = 1;
ArrayRCP<ArrayRCP<part_t> > ids;
ArrayRCP<ArrayRCP<scalar_t> > sizes;
memset(lengths, 0, sizeof(int) * maxNumWeights);
lengths[0] = 1; // We give a size for 1 part.
idLists[0][0] = rank; // The part is my part.
sizeLists[0][0] = rank%2 + 1.0; // The size is 1.0 or 2.0
makeArrays(1, lengths, idLists, sizeLists, ids, sizes);
// Normalized part size for every part, for checking later on
scalar_t *normalizedPartSizes = new scalar_t [numGlobalParts];
scalar_t sumSizes=0;
for (int i=0; i < numGlobalParts; i++){
normalizedPartSizes[i] = 1.0;
if (i % 2) normalizedPartSizes[i] = 2.0;
sumSizes += normalizedPartSizes[i];
}
for (int i=0; i < numGlobalParts; i++)
normalizedPartSizes[i] /= sumSizes;
/////////////
// Create a solution object with part size information, and check it.
RCP<Zoltan2::PartitioningSolution<idInput_t> > solution;
try{
solution = rcp(new Zoltan2::PartitioningSolution<idInput_t>(
env, // application environment info
comm, // problem communicator
idMap, // problem identifiers (global Ids, local Ids)
nWeights, // number of weights
ids.view(0,nWeights), // part ids
sizes.view(0,nWeights))); // part sizes
}
catch (std::exception &e){
fail=1;
}
TEST_FAIL_AND_EXIT(*comm, fail==0, "constructor call 1", 1);
// Test the Solution queries that are used by algorithms
if (solution->getTargetGlobalNumberOfParts() != size_t(numGlobalParts))
fail=2;
if (!fail && solution->getLocalNumberOfParts() != 1)
fail=3;
if (!fail && !solution->oneToOnePartDistribution())
fail=4;
if (!fail && solution->getPartDistribution() != NULL)
fail=5;
if (!fail && solution->getProcDistribution() != NULL)
fail=6;
if (!fail &&
((nprocs>1 && solution->criteriaHasUniformPartSizes(0)) ||
(nprocs==1 && !solution->criteriaHasUniformPartSizes(0))) )
fail=8;
if (!fail){
for (int partId=0; !fail && partId < numGlobalParts; partId++){
scalar_t psize = solution->getCriteriaPartSize(0, partId);
if ( psize < normalizedPartSizes[partId] - epsilon ||
psize > normalizedPartSizes[partId] + epsilon )
fail=9;
}
}
delete [] normalizedPartSizes;
gfail = globalFail(comm, fail);
if (gfail){
printFailureCode(comm, fail); // exits after printing "FAIL"
}
// Test the Solution set method that is called by algorithms
part_t *partAssignments = new part_t [numIdsPerProc];
for (int i=0; i < numIdsPerProc; i++){
partAssignments[i] = myGids[i] % numGlobalParts; // round robin
}
ArrayRCP<part_t> partList = arcp(partAssignments, 0, numIdsPerProc);
try{
solution->setParts(gidArray, partList, true);
}
catch (std::exception &e){
fail=10;
}
gfail = globalFail(comm, fail);
if (gfail){
printFailureCode(comm, fail); // exits after printing "FAIL"
}
// Test the Solution get methods that may be called by users
// or migration functions.
if (solution->getLocalNumberOfIds() != size_t(numIdsPerProc))
fail = 11;
if (!fail){
const gno_t *gids = solution->getIdList();
for (int i=0; !fail && i < numIdsPerProc; i++){
if (gids[i] != myGids[i])
fail = 12;
}
}
if (!fail){
const part_t *parts = solution->getPartList();
for (int i=0; !fail && i < numIdsPerProc; i++){
if (parts[i] != myGids[i] % numGlobalParts)
fail = 13;
}
}
gfail = globalFail(comm, fail);
if (gfail){
printFailureCode(comm, fail); // exits after printing "FAIL"
}
if (rank==0)
std::cout << "PASS" << std::endl;
///////////////////////////////////////////////////////////////////
// TODO:
/////////////
// Create a solution object without part size information, and check it.
/////////////
// Test multiple weights.
/////////////
// Test multiple parts per process.
/////////////
// Specify a list of parts of size 0. (The rest should be uniform.)
delete [] lengths;
for (int w=0; w < maxNumWeights; w++){
delete [] idLists[w];
delete [] sizeLists[w];
}
delete [] idLists;
delete [] sizeLists;
}
int main(int argc, char *argv[])
{
// MEMORY_CHECK(true, "Before initializing MPI");
Teuchos::GlobalMPISession session(&argc, &argv, NULL);
RCP<const Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
int rank = comm->getRank();
int nprocs = comm->getSize();
MEMORY_CHECK(rank==0, "After initializing MPI");
if (rank==0)
cout << "Number of processes: " << nprocs << endl;
// Default values
double numGlobalCoords = 1000;
int numTestCuts = 1;
int nWeights = 0;
string timingType("no_timers");
string debugLevel("basic_status");
string memoryOn("memoryOn");
string memoryOff("memoryOff");
string memoryProcs("0");
bool doMemory=false;
int numGlobalParts = nprocs;
CommandLineProcessor commandLine(false, true);
commandLine.setOption("size", &numGlobalCoords,
"Approximate number of global coordinates.");
commandLine.setOption("testCuts", &numTestCuts,
"Number of test cuts to make when looking for bisector.");
commandLine.setOption("numParts", &numGlobalParts,
"Number of parts (default is one per proc).");
commandLine.setOption("nWeights", &nWeights,
"Number of weights per coordinate, zero implies uniform weights.");
string balanceCount("balance_object_count");
string balanceWeight("balance_object_weight");
string mcnorm1("multicriteria_minimize_total_weight");
string mcnorm2("multicriteria_balance_total_maximum");
string mcnorm3("multicriteria_minimize_maximum_weight");
string objective(balanceWeight); // default
string doc(balanceCount); doc.append(": ignore weights\n");
doc.append(balanceWeight); doc.append(": balance on first weight\n");
doc.append(mcnorm1);
doc.append(": given multiple weights, balance their total.\n");
doc.append(mcnorm3);
doc.append(": given multiple weights, balance the maximum for each coordinate.\n");
doc.append(mcnorm2);
doc.append(": given multiple weights, balance the L2 norm of the weights.\n");
commandLine.setOption("objective", &objective, doc.c_str());
commandLine.setOption("timers", &timingType,
"no_timers, micro_timers, macro_timers, both_timers, test_timers");
commandLine.setOption("debug", &debugLevel,
"no_status, basic_status, detailed_status, verbose_detailed_status");
commandLine.setOption(memoryOn.c_str(), memoryOff.c_str(), &doMemory,
"do memory profiling");
commandLine.setOption("memoryProcs", &memoryProcs,
"list of processes that output memory usage");
CommandLineProcessor::EParseCommandLineReturn rc =
commandLine.parse(argc, argv);
if (rc != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL){
if (rc == Teuchos::CommandLineProcessor::PARSE_HELP_PRINTED){
if (rank==0)
cout << "PASS" << endl;
return 1;
}
else{
if (rank==0)
cout << "FAIL" << endl;
return 0;
}
}
//MEMORY_CHECK(doMemory && rank==0, "After processing parameters");
zgno_t globalSize = static_cast<zgno_t>(numGlobalCoords);
RCP<tMVector_t> coordinates = getMeshCoordinates(comm, globalSize);
size_t numLocalCoords = coordinates->getLocalLength();
#if 0
comm->barrier();
for (int p=0; p < nprocs; p++){
if (p==rank){
cout << "Rank " << rank << ", " << numLocalCoords << "coords" << endl;
const zscalar_t *x = coordinates->getData(0).getRawPtr();
const zscalar_t *y = coordinates->getData(1).getRawPtr();
const zscalar_t *z = coordinates->getData(2).getRawPtr();
for (zlno_t i=0; i < numLocalCoords; i++)
cout << " " << x[i] << " " << y[i] << " " << z[i] << endl;
}
cout.flush();
comm->barrier();
}
#endif
Array<ArrayRCP<zscalar_t> > weights(nWeights);
if (nWeights > 0){
int wt = 0;
zscalar_t scale = 1.0;
for (int i=0; i < nWeights; i++){
weights[i] =
makeWeights(comm, numLocalCoords, weightTypes(wt++), scale, rank);
if (wt == numWeightTypes){
wt = 0;
scale++;
}
}
}
MEMORY_CHECK(doMemory && rank==0, "After creating input");
// Create an input adapter.
const RCP<const tMap_t> &coordmap = coordinates->getMap();
ArrayView<const zgno_t> ids = coordmap->getNodeElementList();
const zgno_t *globalIds = ids.getRawPtr();
size_t localCount = coordinates->getLocalLength();
typedef Zoltan2::BasicVectorAdapter<tMVector_t> inputAdapter_t;
RCP<inputAdapter_t> ia;
if (nWeights == 0){
ia = rcp(new inputAdapter_t (localCount, globalIds,
coordinates->getData(0).getRawPtr(), coordinates->getData(1).getRawPtr(),
coordinates->getData(2).getRawPtr(), 1,1,1));
}
else{
vector<const zscalar_t *> values(3);
for (int i=0; i < 3; i++)
values[i] = coordinates->getData(i).getRawPtr();
vector<int> valueStrides(0); // implies stride is one
vector<const zscalar_t *> weightPtrs(nWeights);
for (int i=0; i < nWeights; i++)
weightPtrs[i] = weights[i].getRawPtr();
vector<int> weightStrides(0); // implies stride is one
ia = rcp(new inputAdapter_t (localCount, globalIds,
values, valueStrides, weightPtrs, weightStrides));
}
MEMORY_CHECK(doMemory && rank==0, "After creating input adapter");
// Parameters
Teuchos::ParameterList params;
if (timingType != "no_timers"){
params.set("timer_output_stream" , "std::cout");
params.set("timer_type" , timingType);
}
if (doMemory){
params.set("memory_output_stream" , "std::cout");
params.set("memory_procs" , memoryProcs);
}
params.set("debug_output_stream" , "std::cerr");
params.set("debug_procs" , "0");
if (debugLevel != "basic_status"){
params.set("debug_level" , debugLevel);
}
params.set("algorithm", "rcb");
params.set("partitioning_objective", objective);
double tolerance = 1.1;
params.set("imbalance_tolerance", tolerance );
if (numGlobalParts != nprocs)
params.set("num_global_parts" , numGlobalParts);
if (rank==0){
cout << "Number of parts: " << numGlobalParts << endl;
}
// Create a problem, solve it, and display the quality.
Zoltan2::PartitioningProblem<inputAdapter_t> problem(&(*ia), ¶ms);
problem.solve();
comm->barrier();
problem.printTimers();
comm->barrier();
if (rank == 0){
cout << "PASS" << endl;
}
return 0;
}
int
main (int argc, char *argv[])
{
using namespace Anasazi;
using Teuchos::RCP;
using Teuchos::rcp;
using std::endl;
#ifdef HAVE_MPI
// Initialize MPI
MPI_Init (&argc, &argv);
#endif // HAVE_MPI
// Create an Epetra communicator
#ifdef HAVE_MPI
Epetra_MpiComm Comm (MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif // HAVE_MPI
// Create an Anasazi output manager
BasicOutputManager<double> printer;
printer.stream(Errors) << Anasazi_Version() << std::endl << std::endl;
// Get the sorting std::string from the command line
std::string which ("LM");
Teuchos::CommandLineProcessor cmdp (false, true);
cmdp.setOption("sort",&which,"Targetted eigenvalues (SM or LM).");
if (cmdp.parse (argc, argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize ();
#endif // HAVE_MPI
return -1;
}
// Dimension of the matrix
//
// Discretization points in any one direction.
const int nx = 10;
// Size of matrix nx*nx
const int NumGlobalElements = nx*nx;
// Construct a Map that puts approximately the same number of
// equations on each process.
Epetra_Map Map (NumGlobalElements, 0, Comm);
// Get update list and number of local equations from newly created Map.
int NumMyElements = Map.NumMyElements ();
std::vector<int> MyGlobalElements (NumMyElements);
Map.MyGlobalElements (&MyGlobalElements[0]);
// Create an integer vector NumNz that is used to build the Petra
// matrix. NumNz[i] is the number of OFF-DIAGONAL terms for the ith
// global equation on this process.
std::vector<int> NumNz(NumMyElements);
/* We are building a matrix of block structure:
| T -I |
|-I T -I |
| -I T |
| ... -I|
| -I T|
where each block is dimension nx by nx and the matrix is on the order of
nx*nx. The block T is a tridiagonal matrix.
*/
for (int i=0; i<NumMyElements; ++i) {
if (MyGlobalElements[i] == 0 || MyGlobalElements[i] == NumGlobalElements-1 ||
MyGlobalElements[i] == nx-1 || MyGlobalElements[i] == nx*(nx-1) ) {
NumNz[i] = 3;
}
else if (MyGlobalElements[i] < nx || MyGlobalElements[i] > nx*(nx-1) ||
MyGlobalElements[i]%nx == 0 || (MyGlobalElements[i]+1)%nx == 0) {
NumNz[i] = 4;
}
else {
NumNz[i] = 5;
}
}
// Create an Epetra_Matrix
RCP<Epetra_CrsMatrix> A = rcp (new Epetra_CrsMatrix (Copy, Map, &NumNz[0]));
// Compute coefficients for discrete convection-diffution operator
const double one = 1.0;
std::vector<double> Values(4);
std::vector<int> Indices(4);
double rho = 0.0;
double h = one /(nx+1);
double h2 = h*h;
double c = 5.0e-01*rho/ h;
Values[0] = -one/h2 - c; Values[1] = -one/h2 + c; Values[2] = -one/h2; Values[3]= -one/h2;
double diag = 4.0 / h2;
int NumEntries;
for (int i=0; i<NumMyElements; ++i) {
if (MyGlobalElements[i]==0) {
Indices[0] = 1;
Indices[1] = nx;
NumEntries = 2;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[1], &Indices[0]);
assert( info==0 );
}
else if (MyGlobalElements[i] == nx*(nx-1)) {
Indices[0] = nx*(nx-1)+1;
Indices[1] = nx*(nx-2);
NumEntries = 2;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[1], &Indices[0]);
assert( info==0 );
}
else if (MyGlobalElements[i] == nx-1) {
Indices[0] = nx-2;
NumEntries = 1;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]);
assert( info==0 );
Indices[0] = 2*nx-1;
info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[2], &Indices[0]);
assert( info==0 );
}
else if (MyGlobalElements[i] == NumGlobalElements-1) {
Indices[0] = NumGlobalElements-2;
NumEntries = 1;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]);
assert( info==0 );
Indices[0] = nx*(nx-1)-1;
info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[2], &Indices[0]);
assert( info==0 );
}
else if (MyGlobalElements[i] < nx) {
Indices[0] = MyGlobalElements[i]-1;
Indices[1] = MyGlobalElements[i]+1;
Indices[2] = MyGlobalElements[i]+nx;
NumEntries = 3;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]);
assert( info==0 );
}
else if (MyGlobalElements[i] > nx*(nx-1)) {
Indices[0] = MyGlobalElements[i]-1;
Indices[1] = MyGlobalElements[i]+1;
Indices[2] = MyGlobalElements[i]-nx;
NumEntries = 3;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]);
assert( info==0 );
}
else if (MyGlobalElements[i]%nx == 0) {
Indices[0] = MyGlobalElements[i]+1;
Indices[1] = MyGlobalElements[i]-nx;
Indices[2] = MyGlobalElements[i]+nx;
NumEntries = 3;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[1], &Indices[0]);
assert( info==0 );
}
else if ((MyGlobalElements[i]+1)%nx == 0) {
Indices[0] = MyGlobalElements[i]-nx;
Indices[1] = MyGlobalElements[i]+nx;
NumEntries = 2;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[2], &Indices[0]);
assert( info==0 );
Indices[0] = MyGlobalElements[i]-1;
NumEntries = 1;
info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]);
assert( info==0 );
}
else {
Indices[0] = MyGlobalElements[i]-1;
Indices[1] = MyGlobalElements[i]+1;
Indices[2] = MyGlobalElements[i]-nx;
Indices[3] = MyGlobalElements[i]+nx;
NumEntries = 4;
int info = A->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]);
assert( info==0 );
}
// Put in the diagonal entry
int info = A->InsertGlobalValues(MyGlobalElements[i], 1, &diag, &MyGlobalElements[i]);
assert( info==0 );
}
// Finish up
int info = A->FillComplete ();
assert( info==0 );
A->SetTracebackMode (1); // Shutdown Epetra Warning tracebacks
// Create a identity matrix for the temporary mass matrix
RCP<Epetra_CrsMatrix> M = rcp (new Epetra_CrsMatrix (Copy, Map, 1));
for (int i=0; i<NumMyElements; i++) {
Values[0] = one;
Indices[0] = i;
NumEntries = 1;
info = M->InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]);
assert( info==0 );
}
// Finish up
info = M->FillComplete ();
assert( info==0 );
M->SetTracebackMode (1); // Shutdown Epetra Warning tracebacks
//************************************
// Call the LOBPCG solver manager
//***********************************
//
// Variables used for the LOBPCG Method
const int nev = 10;
const int blockSize = 5;
const int maxIters = 500;
const double tol = 1.0e-8;
typedef Epetra_MultiVector MV;
typedef Epetra_Operator OP;
typedef MultiVecTraits<double, Epetra_MultiVector> MVT;
// Create an Epetra_MultiVector for an initial vector to start the
// solver. Note: This needs to have the same number of columns as
// the blocksize.
RCP<Epetra_MultiVector> ivec = rcp (new Epetra_MultiVector (Map, blockSize));
ivec->Random (); // fill the initial vector with random values
// Create the eigenproblem.
RCP<BasicEigenproblem<double, MV, OP> > MyProblem =
rcp (new BasicEigenproblem<double, MV, OP> (A, ivec));
// Inform the eigenproblem that the operator A is symmetric
MyProblem->setHermitian (true);
// Set the number of eigenvalues requested
MyProblem->setNEV (nev);
// Inform the eigenproblem that you are finishing passing it information
const bool success = MyProblem->setProblem ();
if (! success) {
printer.print (Errors, "Anasazi::BasicEigenproblem::setProblem() reported an error.\n");
#ifdef HAVE_MPI
MPI_Finalize ();
#endif
return -1;
}
// Create parameter list to pass into the solver manager
//
Teuchos::ParameterList MyPL;
MyPL.set ("Which", which);
MyPL.set ("Block Size", blockSize);
MyPL.set ("Maximum Iterations", maxIters);
MyPL.set ("Convergence Tolerance", tol);
// Create the solver manager
SimpleLOBPCGSolMgr<double, MV, OP> MySolverMan (MyProblem, MyPL);
// Solve the problem
ReturnType returnCode = MySolverMan.solve ();
// Get the eigenvalues and eigenvectors from the eigenproblem
Eigensolution<double, MV> sol = MyProblem->getSolution ();
std::vector<Value<double> > evals = sol.Evals;
RCP<MV> evecs = sol.Evecs;
// Compute residuals
std::vector<double> normR (sol.numVecs);
if (sol.numVecs > 0) {
Teuchos::SerialDenseMatrix<int,double> T (sol.numVecs, sol.numVecs);
Epetra_MultiVector tempAevec (Map, sol.numVecs );
T.putScalar (0.0);
for (int i = 0; i < sol.numVecs; ++i) {
T(i,i) = evals[i].realpart;
}
A->Apply (*evecs, tempAevec);
MVT::MvTimesMatAddMv (-1.0, *evecs, T, 1.0, tempAevec);
MVT::MvNorm (tempAevec, normR);
}
// Print the results
std::ostringstream os;
os.setf (std::ios_base::right, std::ios_base::adjustfield);
os << "Solver manager returned "
<< (returnCode == Converged ? "converged." : "unconverged.") << endl;
os << endl;
os << "------------------------------------------------------" << endl;
os << std::setw(16) << "Eigenvalue"
<< std::setw(18) << "Direct Residual"
<< endl;
os << "------------------------------------------------------" << endl;
for (int i = 0; i < sol.numVecs; ++i) {
os << std::setw(16) << evals[i].realpart
<< std::setw(18) << normR[i] / evals[i].realpart
<< endl;
}
os << "------------------------------------------------------" << endl;
printer.print (Errors, os.str ());
#ifdef HAVE_MPI
MPI_Finalize ();
#endif // HAVE_MPI
return 0;
}
void
Albany::ResponseFactory::
createResponseFunction(
const std::string& name,
Teuchos::ParameterList& responseParams,
Teuchos::Array< Teuchos::RCP<AbstractResponseFunction> >& responses) const
{
using std::string;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using Teuchos::Array;
RCP<const Teuchos_Comm> comm = app->getComm();
if (name == "Solution Average") {
responses.push_back(rcp(new Albany::SolutionAverageResponseFunction(comm)));
}
else if (name == "Solution Two Norm") {
responses.push_back(rcp(new Albany::SolutionTwoNormResponseFunction(comm)));
}
else if (name == "Solution Values") {
responses.push_back(rcp(new Albany::SolutionValuesResponseFunction(app, responseParams)));
}
else if (name == "Solution Max Value") {
int eq = responseParams.get("Equation", 0);
int neq = responseParams.get("Num Equations", 1);
bool inor = responseParams.get("Interleaved Ordering", true);
responses.push_back(
rcp(new Albany::SolutionMaxValueResponseFunction(comm, neq, eq, inor)));
}
else if (name == "Solution Two Norm File") {
responses.push_back(
rcp(new Albany::SolutionFileResponseFunction<Albany::NormTwo>(comm)));
}
else if (name == "Solution Inf Norm File") {
responses.push_back(
rcp(new Albany::SolutionFileResponseFunction<Albany::NormInf>(comm)));
}
else if (name == "OBC Functional") {
#ifdef ALBANY_PERIDIGM
#ifdef ALBANY_EPETRA
responses.push_back(rcp(new Albany::AlbanyPeridigmOBCFunctional(comm)));
#endif
#endif
}
else if (name == "Aggregated") {
int num_aggregate_responses = responseParams.get<int>("Number");
Array< RCP<AbstractResponseFunction> > aggregated_responses;
Array< RCP<ScalarResponseFunction> > scalar_responses;
for (int i=0; i<num_aggregate_responses; i++) {
std::string id = Albany::strint("Response",i);
std::string name = responseParams.get<std::string>(id);
std::string sublist_name = Albany::strint("ResponseParams",i);
createResponseFunction(name, responseParams.sublist(sublist_name),
aggregated_responses);
}
scalar_responses.resize(aggregated_responses.size());
for (int i=0; i<aggregated_responses.size(); i++) {
TEUCHOS_TEST_FOR_EXCEPTION(
aggregated_responses[i]->isScalarResponse() != true, std::logic_error,
"Response function " << i << " is not a scalar response function." <<
std::endl <<
"The aggregated response can only aggregate scalar response " <<
"functions!");
scalar_responses[i] =
Teuchos::rcp_dynamic_cast<ScalarResponseFunction>(
aggregated_responses[i]);
}
responses.push_back(
rcp(new Albany::AggregateScalarResponseFunction(comm, scalar_responses)));
}
else if (name == "Field Integral" ||
name == "Field Value" ||
name == "Field Average" ||
name == "Surface Velocity Mismatch" ||
name == "Aeras Shallow Water L2 Error" ||
name == "Aeras Total Volume" ||
name == "Center Of Mass" ||
name == "Save Field" ||
name == "Region Boundary" ||
name == "Element Size Field" ||
name == "Save Nodal Fields" ||
name == "Stiffness Objective" ||
name == "Internal Energy Objective" ||
name == "Tensor PNorm Objective" ||
name == "Homogenized Constants Response" ||
name == "Modal Objective" ||
name == "PHAL Field Integral" ||
name == "PHAL Field IntegralT") {
responseParams.set("Name", name);
for (int i=0; i<meshSpecs.size(); i++) {
#if defined(ALBANY_LCM)
// Skip if dealing with interface block
//if (meshSpecs[i]->ebName == "Surface Element") continue;
#endif
responses.push_back(
rcp(new Albany::FieldManagerScalarResponseFunction(
app, prob, meshSpecs[i], stateMgr, responseParams)));
}
}
else if (name == "IP to Nodal Field" ||
name == "Project IP to Nodal Field") {
responseParams.set("Name", name);
for (int i=0; i<meshSpecs.size(); i++) {
#if defined(ALBANY_LCM)
// Skip if dealing with interface block
//if (meshSpecs[i]->ebName == "Surface Element") continue;
#endif
// For these RFs, default to true for this parm.
const char* reb_parm = "Restrict to Element Block";
if ( ! responseParams.isType<bool>(reb_parm) &&
(name == "IP to Nodal Field" ||
name == "Project IP to Nodal Field"))
responseParams.set<bool>(reb_parm, true);
responses.push_back(
rcp(new Albany::FieldManagerResidualOnlyResponseFunction(
app, prob, meshSpecs[i], stateMgr, responseParams)));
}
}
else if (name == "Solution") {
#if defined(ALBANY_EPETRA)
responses.push_back(
rcp(new Albany::SolutionResponseFunction(app, responseParams)));
#endif
}
else if (name == "KL") {
Array< RCP<AbstractResponseFunction> > base_responses;
std::string name = responseParams.get<std::string>("Response");
createResponseFunction(name, responseParams.sublist("ResponseParams"),
base_responses);
for (int i=0; i<base_responses.size(); i++)
responses.push_back(
rcp(new Albany::KLResponseFunction(base_responses[i], responseParams)));
}
#ifdef ALBANY_QCAD
#if defined(ALBANY_EPETRA)
else if (name == "Saddle Value") {
responseParams.set("Name", name);
for (int i=0; i<meshSpecs.size(); i++) {
responses.push_back(
rcp(new QCAD::SaddleValueResponseFunction(
app, prob, meshSpecs[i], stateMgr, responseParams)));
}
}
#endif
#endif
else {
TEUCHOS_TEST_FOR_EXCEPTION(
true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error! Unknown response function " << name <<
"!" << std::endl << "Supplied parameter list is " <<
std::endl << responseParams);
}
}
//==========================================================================
int Ifpack_IC::ComputeSetup()
{
// (re)allocate memory for ICT factors
U_ = rcp(new Epetra_CrsMatrix(Copy, Matrix().RowMatrixRowMap(),
Matrix().RowMatrixRowMap(), 0));
D_ = rcp(new Epetra_Vector(Matrix().RowMatrixRowMap()));
if (U_.get() == 0 || D_.get() == 0)
IFPACK_CHK_ERR(-5); // memory allocation error
int ierr = 0;
int i, j;
int NumIn, NumU;
bool DiagFound;
int NumNonzeroDiags = 0;
// Get Maximun Row length
int MaxNumEntries = Matrix().MaxNumEntries();
vector<int> InI(MaxNumEntries); // Allocate temp space
vector<int> UI(MaxNumEntries);
vector<double> InV(MaxNumEntries);
vector<double> UV(MaxNumEntries);
double *DV;
ierr = D_->ExtractView(&DV); // Get view of diagonal
// First we copy the user's matrix into diagonal vector and U, regardless of fill level
int NumRows = Matrix().NumMyRows();
for (i=0; i< NumRows; i++) {
Matrix().ExtractMyRowCopy(i, MaxNumEntries, NumIn, &InV[0], &InI[0]); // Get Values and Indices
// Split into L and U (we don't assume that indices are ordered).
NumU = 0;
DiagFound = false;
for (j=0; j< NumIn; j++) {
int k = InI[j];
if (k==i) {
DiagFound = true;
// Store perturbed diagonal in Epetra_Vector D_
DV[i] += Rthresh_ * InV[j] + EPETRA_SGN(InV[j]) * Athresh_;
}
else if (k < 0) return(-1); // Out of range
else if (i<k && k<NumRows) {
UI[NumU] = k;
UV[NumU] = InV[j];
NumU++;
}
}
// Check in things for this row of L and U
if (DiagFound) NumNonzeroDiags++;
if (NumU) U_->InsertMyValues(i, NumU, &UV[0], &UI[0]);
}
U_->FillComplete(Matrix().OperatorDomainMap(),
Matrix().OperatorRangeMap());
int ierr1 = 0;
if (NumNonzeroDiags<U_->NumMyRows()) ierr1 = 1;
Matrix().Comm().MaxAll(&ierr1, &ierr, 1);
IFPACK_CHK_ERR(ierr);
return(0);
}
TEUCHOS_UNIT_TEST(tEpetraGather, constructor)
{
PHX::KokkosDeviceSession session;
using Teuchos::RCP;
using Teuchos::rcp;
typedef panzer::Traits::Residual Residual;
typedef panzer::Traits::Jacobian Jacobian;
Teuchos::RCP<shards::CellTopology> topo
= Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData< shards::Quadrilateral<4> >()));
// auxiliary information needed to construct basis object
std::size_t numCells = 10;
std::string basisType = "Q1";
panzer::CellData cellData(numCells,topo);
// build DOF names
RCP<std::vector<std::string> > dofNames = rcp(new std::vector<std::string>);
dofNames->push_back("ux"); // in practice these probably would not be gathered together!
dofNames->push_back("p");
// build basis
RCP<panzer::PureBasis> basis = rcp(new panzer::PureBasis(basisType,1,cellData));
// build gather parameter list
Teuchos::ParameterList gatherParams;
gatherParams.set<RCP<std::vector<std::string> > >("DOF Names",dofNames);
gatherParams.set<RCP<std::vector<std::string> > >("Indexer Names",dofNames);
gatherParams.set<RCP<panzer::PureBasis> >("Basis",basis);
// test residual gather evaluator
{
panzer::GatherSolution_Epetra<Residual,panzer::Traits,int,int> gatherResidual(Teuchos::null,gatherParams);
const std::vector<RCP<PHX::FieldTag> > & fields = gatherResidual.evaluatedFields();
TEST_EQUALITY(fields.size(),2);
TEST_EQUALITY(fields[0]->name(),"ux");
TEST_EQUALITY(fields[1]->name(),"p");
TEST_EQUALITY(fields[0]->dataLayout().dimension(0),Teuchos::as<int>(numCells));
TEST_EQUALITY(fields[0]->dataLayout().dimension(1),Teuchos::as<int>(4)); // for Q1
TEST_EQUALITY(fields[1]->dataLayout().dimension(0),Teuchos::as<int>(numCells));
TEST_EQUALITY(fields[1]->dataLayout().dimension(1),Teuchos::as<int>(4)); // for Q1
}
// test jacobian gather evaluator
{
panzer::GatherSolution_Epetra<Jacobian,panzer::Traits,int,int> gatherJacobian(Teuchos::null,gatherParams);
const std::vector<RCP<PHX::FieldTag> > & fields = gatherJacobian.evaluatedFields();
TEST_EQUALITY(fields.size(),2);
TEST_EQUALITY(fields[0]->name(),"ux");
TEST_EQUALITY(fields[1]->name(),"p");
TEST_EQUALITY(fields[0]->dataLayout().dimension(0),Teuchos::as<int>(numCells));
TEST_EQUALITY(fields[0]->dataLayout().dimension(1),Teuchos::as<int>(4)); // for Q1
TEST_EQUALITY(fields[1]->dataLayout().dimension(0),Teuchos::as<int>(numCells));
TEST_EQUALITY(fields[1]->dataLayout().dimension(1),Teuchos::as<int>(4)); // for Q1
}
}
//==========================================================================
int Ifpack_IC::Compute() {
if (!IsInitialized())
IFPACK_CHK_ERR(Initialize());
Time_.ResetStartTime();
IsComputed_ = false;
// copy matrix into L and U.
IFPACK_CHK_ERR(ComputeSetup());
int i;
int m, n, nz, Nrhs, ldrhs, ldlhs;
int * ptr=0, * ind;
double * val, * rhs, * lhs;
int ierr = Epetra_Util_ExtractHbData(U_.get(), 0, 0, m, n, nz, ptr, ind,
val, Nrhs, rhs, ldrhs, lhs, ldlhs);
if (ierr < 0)
IFPACK_CHK_ERR(ierr);
Ifpack_AIJMatrix * Aict;
if (Aict_==0) {
Aict = new Ifpack_AIJMatrix;
Aict_ = (void *) Aict;
}
else Aict = (Ifpack_AIJMatrix *) Aict_;
Ifpack_AIJMatrix * Lict;
if (Lict_==0) {
Lict = new Ifpack_AIJMatrix;
Lict_ = (void *) Lict;
}
else {
Lict = (Ifpack_AIJMatrix *) Lict_;
Ifpack_AIJMatrix_dealloc( Lict ); // Delete storage, crout_ict will allocate it again.
}
if (Ldiag_ != 0) delete [] Ldiag_; // Delete storage, crout_ict will allocate it again.
Aict->val = val;
Aict->col = ind;
Aict->ptr = ptr;
double *DV;
EPETRA_CHK_ERR(D_->ExtractView(&DV)); // Get view of diagonal
// lfil is average number of nonzeros per row times fill ratio.
// Currently crout_ict keeps a constant number of nonzeros per row.
// TODO: Pass Lfil_ and make crout_ict keep variable #nonzeros per row.
int lfil = (Lfil_ * nz)/n + .5;
crout_ict(m, Aict, DV, Droptol_, lfil, Lict, &Ldiag_);
// Get rid of unnecessary data
delete [] ptr;
// Create Epetra View of L from crout_ict
U_ = rcp(new Epetra_CrsMatrix(View, A_->RowMatrixRowMap(), A_->RowMatrixRowMap(),0));
D_ = rcp(new Epetra_Vector(View, A_->RowMatrixRowMap(), Ldiag_));
ptr = Lict->ptr;
ind = Lict->col;
val = Lict->val;
for (i=0; i< m; i++) {
int NumEntries = ptr[i+1]-ptr[i];
int * Indices = ind+ptr[i];
double * Values = val+ptr[i];
U_->InsertMyValues(i, NumEntries, Values, Indices);
}
U_->FillComplete(A_->OperatorDomainMap(), A_->OperatorRangeMap());
D_->Reciprocal(*D_); // Put reciprocal of diagonal in this vector
#ifdef IFPACK_FLOPCOUNTERS
double current_flops = 2 * nz; // Just an estimate
double total_flops = 0;
A_->Comm().SumAll(¤t_flops, &total_flops, 1); // Get total madds across all PEs
ComputeFlops_ += total_flops;
// Now count the rest. NOTE: those flops are *global*
ComputeFlops_ += (double) U_->NumGlobalNonzeros(); // Accounts for multiplier above
ComputeFlops_ += (double) D_->GlobalLength(); // Accounts for reciprocal of diagonal
#endif
++NumCompute_;
ComputeTime_ += Time_.ElapsedTime();
IsComputed_ = true;
return(0);
}
int main(int argc, char *argv[])
{
using std::endl;
typedef double Scalar;
// typedef double ScalarMag; // unused
typedef Teuchos::ScalarTraits<Scalar> ST;
using Teuchos::describe;
using Teuchos::Array;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::outArg;
using Teuchos::rcp_implicit_cast;
using Teuchos::rcp_dynamic_cast;
using Teuchos::as;
using Teuchos::ParameterList;
using Teuchos::CommandLineProcessor;
typedef Teuchos::ParameterList::PrintOptions PLPrintOptions;
typedef Thyra::ModelEvaluatorBase MEB;
bool result, success = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
RCP<Epetra_Comm> epetra_comm;
#ifdef HAVE_MPI
epetra_comm = rcp( new Epetra_MpiComm(MPI_COMM_WORLD) );
#else
epetra_comm = rcp( new Epetra_SerialComm );
#endif // HAVE_MPI
RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read commandline options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
std::string paramsFileName = "";
clp.setOption( "params-file", ¶msFileName,
"File name for XML parameters" );
double t_final = 1e-3;
clp.setOption( "final-time", &t_final,
"Final integration time (initial time is 0.0)" );
int numTimeSteps = 10;
clp.setOption( "num-time-steps", &numTimeSteps,
"Number of (fixed) time steps. If <= 0.0, then variable time steps are taken" );
double maxStateError = 1e-14;
clp.setOption( "max-state-error", &maxStateError,
"Maximum relative error in the integrated state allowed" );
Teuchos::EVerbosityLevel verbLevel = Teuchos::VERB_DEFAULT;
setVerbosityLevelOption( "verb-level", &verbLevel,
"Top-level verbosity level. By default, this gets deincremented as you go deeper into numerical objects.",
&clp );
Teuchos::EVerbosityLevel solnVerbLevel = Teuchos::VERB_DEFAULT;
setVerbosityLevelOption( "soln-verb-level", &solnVerbLevel,
"Solution verbosity level",
&clp );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
//
*out << "\nA) Get the base parameter list ...\n";
//
RCP<ParameterList>
paramList = Teuchos::parameterList();
if (paramsFileName.length())
updateParametersFromXmlFile( paramsFileName, paramList.ptr() );
paramList->validateParameters(*getValidParameters());
const Scalar t_init = 0.0;
const Rythmos::TimeRange<Scalar> fwdTimeRange(t_init, t_final);
const Scalar delta_t = t_final / numTimeSteps;
*out << "\ndelta_t = " << delta_t;
//
*out << "\nB) Create the Stratimikos linear solver factory ...\n";
//
// This is the linear solve strategy that will be used to solve for the
// linear system with the W.
//
Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder;
linearSolverBuilder.setParameterList(sublist(paramList,Stratimikos_name));
RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
W_factory = createLinearSolveStrategy(linearSolverBuilder);
//
*out << "\nC) Create and initalize the forward model ...\n";
//
// C.1) Create the underlying EpetraExt::ModelEvaluator
RCP<EpetraExt::DiagonalTransientModel> epetraStateModel =
EpetraExt::diagonalTransientModel(
epetra_comm,
sublist(paramList,DiagonalTransientModel_name)
);
*out <<"\nepetraStateModel valid options:\n";
epetraStateModel->getValidParameters()->print(
*out, PLPrintOptions().indent(2).showTypes(true).showDoc(true)
);
// C.2) Create the Thyra-wrapped ModelEvaluator
RCP<Thyra::ModelEvaluator<double> > fwdStateModel =
epetraModelEvaluator(epetraStateModel, W_factory);
const RCP<const Thyra::VectorSpaceBase<Scalar> >
x_space = fwdStateModel->get_x_space();
const RCP<const Thyra::VectorBase<Scalar> >
gamma = Thyra::create_Vector(epetraStateModel->get_gamma(), x_space);
*out << "\ngamma = " << describe(*gamma, solnVerbLevel);
//
*out << "\nD) Create the stepper and integrator for the forward problem ...\n";
//
RCP<Rythmos::TimeStepNonlinearSolver<double> > fwdTimeStepSolver =
Rythmos::timeStepNonlinearSolver<double>();
RCP<Rythmos::StepperBase<Scalar> > fwdStateStepper =
Rythmos::backwardEulerStepper<double>(fwdStateModel, fwdTimeStepSolver);
fwdStateStepper->setParameterList(sublist(paramList, RythmosStepper_name));
RCP<Rythmos::IntegratorBase<Scalar> > fwdStateIntegrator;
{
RCP<ParameterList>
integrationControlPL = sublist(paramList, RythmosIntegrationControl_name);
integrationControlPL->set( "Take Variable Steps", false );
integrationControlPL->set( "Fixed dt", as<double>(delta_t) );
RCP<Rythmos::IntegratorBase<Scalar> >
defaultIntegrator = Rythmos::controlledDefaultIntegrator<Scalar>(
Rythmos::simpleIntegrationControlStrategy<Scalar>(integrationControlPL)
);
fwdStateIntegrator = defaultIntegrator;
}
fwdStateIntegrator->setParameterList(sublist(paramList, RythmosIntegrator_name));
//
*out << "\nE) Solve the forward problem ...\n";
//
const MEB::InArgs<Scalar>
state_ic = fwdStateModel->getNominalValues();
*out << "\nstate_ic:\n" << describe(state_ic,solnVerbLevel);
fwdStateStepper->setInitialCondition(state_ic);
fwdStateIntegrator->setStepper(fwdStateStepper, t_final);
Array<RCP<const Thyra::VectorBase<Scalar> > > x_final_array;
fwdStateIntegrator->getFwdPoints(
Teuchos::tuple<Scalar>(t_final), &x_final_array, NULL, NULL
);
const RCP<const Thyra::VectorBase<Scalar> > x_final = x_final_array[0];
*out << "\nx_final:\n" << describe(*x_final, solnVerbLevel);
//
*out << "\nF) Check the solution to the forward problem ...\n";
//
const RCP<Thyra::VectorBase<Scalar> >
x_beta = createMember(x_space),
x_final_be_exact = createMember(x_space);
{
Thyra::ConstDetachedVectorView<Scalar> d_gamma(*gamma);
Thyra::ConstDetachedVectorView<Scalar> d_x_ic(*state_ic.get_x());
Thyra::DetachedVectorView<Scalar> d_x_beta(*x_beta);
Thyra::DetachedVectorView<Scalar> d_x_final_be_exact(*x_final_be_exact);
const int n = d_gamma.subDim();
for ( int i = 0; i < n; ++i ) {
d_x_beta(i) = 1.0 / ( 1.0 - delta_t * d_gamma(i) );
d_x_final_be_exact(i) = integralPow(d_x_beta(i), numTimeSteps) * d_x_ic(i);
}
}
*out << "\nx_final_be_exact:\n" << describe(*x_final_be_exact, solnVerbLevel);
result = Thyra::testRelNormDiffErr<Scalar>(
"x_final", *x_final,
"x_final_be_exact", *x_final_be_exact,
"maxStateError", maxStateError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
//
*out << "\nG) Create the Adjoint ME wrapper object ...\n";
//
RCP<Thyra::ModelEvaluator<double> > adjModel =
Rythmos::adjointModelEvaluator<double>(
fwdStateModel, fwdTimeRange
);
//
*out << "\nH) Create a stepper and integrator for the adjoint ...\n";
//
RCP<Thyra::LinearNonlinearSolver<double> > adjTimeStepSolver =
Thyra::linearNonlinearSolver<double>();
RCP<Rythmos::StepperBase<Scalar> > adjStepper =
Rythmos::backwardEulerStepper<double>(adjModel, adjTimeStepSolver);
adjStepper->setParameterList(sublist(paramList, RythmosStepper_name));
RCP<Rythmos::IntegratorBase<Scalar> > adjIntegrator =
fwdStateIntegrator->cloneIntegrator();
//
*out << "\nI) Set up the initial condition for the adjoint at the final time ...\n";
//
const RCP<const Thyra::VectorSpaceBase<Scalar> >
f_space = fwdStateModel->get_f_space();
// lambda(t_final) = x_final
const RCP<Thyra::VectorBase<Scalar> > lambda_ic = createMember(f_space);
V_V( outArg(*lambda_ic), *x_final_be_exact );
// lambda_dot(t_final,i) = - gamma(i) * lambda(t_final,i)
const RCP<Thyra::VectorBase<Scalar> > lambda_dot_ic = createMember(f_space);
Thyra::V_S<Scalar>( outArg(*lambda_dot_ic), ST::zero() );
Thyra::ele_wise_prod<Scalar>( -ST::one(), *gamma, *lambda_ic,
outArg(*lambda_dot_ic) );
MEB::InArgs<Scalar> adj_ic = adjModel->getNominalValues();
adj_ic.set_x(lambda_ic);
adj_ic.set_x_dot(lambda_dot_ic);
*out << "\nadj_ic:\n" << describe(adj_ic,solnVerbLevel);
//
*out << "\nJ) Integrate the adjoint backwards in time (using backward time) ...\n";
//
adjStepper->setInitialCondition(adj_ic);
adjIntegrator->setStepper(adjStepper, fwdTimeRange.length());
Array<RCP<const Thyra::VectorBase<Scalar> > > lambda_final_array;
adjIntegrator->getFwdPoints(
Teuchos::tuple<Scalar>(fwdTimeRange.length()), &lambda_final_array, NULL, NULL
);
const RCP<const Thyra::VectorBase<Scalar> > lambda_final = lambda_final_array[0];
*out << "\nlambda_final:\n" << describe(*lambda_final, solnVerbLevel);
//
*out << "\nK) Test the final adjoint againt exact discrete solution ...\n";
//
{
const RCP<Thyra::VectorBase<Scalar> >
lambda_final_be_exact = createMember(x_space);
{
Thyra::ConstDetachedVectorView<Scalar> d_gamma(*gamma);
Thyra::ConstDetachedVectorView<Scalar> d_x_final(*x_final);
Thyra::DetachedVectorView<Scalar> d_x_beta(*x_beta);
Thyra::DetachedVectorView<Scalar> d_lambda_final_be_exact(*lambda_final_be_exact);
const int n = d_gamma.subDim();
for ( int i = 0; i < n; ++i ) {
d_lambda_final_be_exact(i) = integralPow(d_x_beta(i), numTimeSteps) * d_x_final(i);
}
}
*out << "\nlambda_final_be_exact:\n" << describe(*lambda_final_be_exact, solnVerbLevel);
result = Thyra::testRelNormDiffErr<Scalar>(
"lambda_final", *lambda_final,
"lambda_final_be_exact", *lambda_final_be_exact,
"maxStateError", maxStateError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
}
//
*out << "\nL) Test the reduced gradient from the adjoint against the discrete forward reduced gradient ...\n";
//
{
const RCP<const Thyra::VectorBase<Scalar> >
d_d_hat_d_p_from_lambda = lambda_final; // See above
const RCP<Thyra::VectorBase<Scalar> >
d_d_hat_d_p_be_exact = createMember(x_space);
{
Thyra::ConstDetachedVectorView<Scalar> d_x_ic(*state_ic.get_x());
Thyra::DetachedVectorView<Scalar> d_x_beta(*x_beta);
Thyra::DetachedVectorView<Scalar> d_d_d_hat_d_p_be_exact(*d_d_hat_d_p_be_exact);
const int n = d_x_ic.subDim();
for ( int i = 0; i < n; ++i ) {
d_d_d_hat_d_p_be_exact(i) = integralPow(d_x_beta(i), 2*numTimeSteps) * d_x_ic(i);
}
}
*out << "\nd_d_hat_d_p_be_exact:\n" << describe(*d_d_hat_d_p_be_exact, solnVerbLevel);
result = Thyra::testRelNormDiffErr<Scalar>(
"d_d_hat_d_p_from_lambda", *d_d_hat_d_p_from_lambda,
"d_d_hat_d_p_be_exact", *d_d_hat_d_p_be_exact,
"maxStateError", maxStateError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
}
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success);
if(success)
*out << "\nEnd Result: TEST PASSED" << endl;
else
*out << "\nEnd Result: TEST FAILED" << endl;
return ( success ? 0 : 1 );
} // end main() [Doxygen looks for this!]
TEUCHOS_UNIT_TEST(tUniqueGlobalIndexer_Utilities,updateGhostedDataVector)
{
typedef Intrepid::FieldContainer<int> IntFieldContainer;
// build global (or serial communicator)
#ifdef HAVE_MPI
RCP<Epetra_Comm> eComm = rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
RCP<Epetra_Comm> eComm = rcp(new Epetra_SerialComm());
#endif
int myRank = eComm->MyPID();
int numProcs = eComm->NumProc();
TEUCHOS_ASSERT(numProcs==2);
RCP<panzer::UniqueGlobalIndexer<short,int> > globalIndexer
= rcp(new panzer::unit_test::UniqueGlobalIndexer(myRank,numProcs));
int uFieldNum = globalIndexer->getFieldNum("U");
int tFieldNum = globalIndexer->getFieldNum("T");
Teuchos::RCP<Tpetra::Vector<int,int,int> > reducedFieldVector
= panzer::buildGhostedFieldReducedVector<short,int,KokkosClassic::DefaultNode::DefaultNodeType>(*globalIndexer);
Tpetra::Vector<int,int,int> reducedUDataVector(getFieldMap(uFieldNum,*reducedFieldVector));
Tpetra::Vector<int,int,int> reducedTDataVector(getFieldMap(tFieldNum,*reducedFieldVector));
TEST_EQUALITY(reducedUDataVector.getLocalLength(),8);
TEST_EQUALITY(reducedTDataVector.getLocalLength(),4);
IntFieldContainer dataU_b0, dataU_b1;
fillFieldContainer(uFieldNum,"block_0",*globalIndexer,dataU_b0);
fillFieldContainer(uFieldNum,"block_1",*globalIndexer,dataU_b1);
IntFieldContainer dataT_b0;
fillFieldContainer(tFieldNum,"block_0",*globalIndexer,dataT_b0);
updateGhostedDataReducedVector("U","block_0",*globalIndexer,dataU_b0,reducedUDataVector);
updateGhostedDataReducedVector("U","block_1",*globalIndexer,dataU_b1,reducedUDataVector);
updateGhostedDataReducedVector("T","block_0",*globalIndexer,dataT_b0,reducedTDataVector);
std::vector<int> ghostedFields_u(reducedUDataVector.getLocalLength());
std::vector<int> ghostedFields_t(reducedTDataVector.getLocalLength());
reducedUDataVector.get1dCopy(Teuchos::arrayViewFromVector(ghostedFields_u));
reducedTDataVector.get1dCopy(Teuchos::arrayViewFromVector(ghostedFields_t));
if(myRank==0) {
TEST_EQUALITY(ghostedFields_u[0], 0);
TEST_EQUALITY(ghostedFields_u[1], 2);
TEST_EQUALITY(ghostedFields_u[2], 4);
TEST_EQUALITY(ghostedFields_u[3], 6);
TEST_EQUALITY(ghostedFields_u[4], 8);
TEST_EQUALITY(ghostedFields_u[5],12);
TEST_EQUALITY(ghostedFields_u[6],13);
TEST_EQUALITY(ghostedFields_u[7],10);
TEST_EQUALITY(ghostedFields_t[0], 1);
TEST_EQUALITY(ghostedFields_t[1], 3);
TEST_EQUALITY(ghostedFields_t[2], 5);
TEST_EQUALITY(ghostedFields_t[3], 7);
}
else if(myRank==1) {
TEST_EQUALITY(ghostedFields_u[0], 2);
TEST_EQUALITY(ghostedFields_u[1], 8);
TEST_EQUALITY(ghostedFields_u[2],10);
TEST_EQUALITY(ghostedFields_u[3], 4);
TEST_EQUALITY(ghostedFields_u[4],12);
TEST_EQUALITY(ghostedFields_u[5],14);
TEST_EQUALITY(ghostedFields_u[6],15);
TEST_EQUALITY(ghostedFields_u[7],13);
TEST_EQUALITY(ghostedFields_t[0], 3);
TEST_EQUALITY(ghostedFields_t[1], 9);
TEST_EQUALITY(ghostedFields_t[2],11);
TEST_EQUALITY(ghostedFields_t[3], 5);
}
else
TEUCHOS_ASSERT(false);
}