//! Initialize from a parameter list
void PresLaplaceLSCStrategy::initializeFromParameterList(const Teuchos::ParameterList & pl,const InverseLibrary & invLib)
{
// get string specifying inverse
std::string invStr="Amesos", invVStr="", invPStr="";
bool useLDU = false;
scaleType_ = AbsRowSum;
// "parse" the parameter list
if(pl.isParameter("Inverse Type"))
invStr = pl.get<std::string>("Inverse Type");
if(pl.isParameter("Inverse Velocity Type"))
invVStr = pl.get<std::string>("Inverse Velocity Type");
if(pl.isParameter("Inverse Pressure Type"))
invPStr = pl.get<std::string>("Inverse Pressure Type");
if(pl.isParameter("Use LDU"))
useLDU = pl.get<bool>("Use LDU");
if(pl.isParameter("Use Mass Scaling"))
useMass_ = pl.get<bool>("Use Mass Scaling");
if(pl.isParameter("Eigen Solver Iterations"))
eigSolveParam_ = pl.get<int>("Eigen Solver Iterations");
if(pl.isParameter("Scaling Type")) {
scaleType_ = getDiagonalType(pl.get<std::string>("Scaling Type"));
TEUCHOS_TEST_FOR_EXCEPT(scaleType_==NotDiag);
}
// set defaults as needed
if(invVStr=="") invVStr = invStr;
if(invPStr=="") invPStr = invStr;
Teko_DEBUG_MSG_BEGIN(5)
DEBUG_STREAM << "LSC Inverse Strategy Parameters: " << std::endl;
DEBUG_STREAM << " inv v type = \"" << invVStr << "\"" << std::endl;
DEBUG_STREAM << " inv p type = \"" << invPStr << "\"" << std::endl;
DEBUG_STREAM << " use ldu = " << useLDU << std::endl;
DEBUG_STREAM << " use mass = " << useMass_ << std::endl;
DEBUG_STREAM << " scale type = " << getDiagonalName(scaleType_) << std::endl;
DEBUG_STREAM << "LSC Pressure Laplace Strategy Parameter list: " << std::endl;
pl.print(DEBUG_STREAM);
Teko_DEBUG_MSG_END()
// build velocity inverse factory
invFactoryV_ = invLib.getInverseFactory(invVStr);
invFactoryP_ = invFactoryV_; // by default these are the same
if(invVStr!=invPStr) // if different, build pressure inverse factory
invFactoryP_ = invLib.getInverseFactory(invPStr);
// set other parameters
setUseFullLDU(useLDU);
}
/** \brief This function builds the internals of the state from a parameter list.
*
* This function builds the internals of the LU 2x2 state
* from a parameter list. Furthermore, it allows a
* developer to easily add a factory to the build system.
*
* \param[in] settings Parameter list to use as the internal settings
* \param[in] invLib Inverse library to use for building inverse factory objects
*
* \note The default implementation does nothing.
*/
void LU2x2DiagonalStrategy::initializeFromParameterList(const Teuchos::ParameterList & pl,
const InverseLibrary & invLib)
{
Teko_DEBUG_SCOPE("LU2x2DiagonalStrategy::initializeFromParameterList",10);
std::string invStr="Amesos", invA00Str="", invSStr="";
// "parse" the parameter list
if(pl.isParameter("Inverse Type"))
invStr = pl.get<std::string>("Inverse Type");
if(pl.isParameter("Inverse A00 Type"))
invA00Str = pl.get<std::string>("Inverse A00 Type");
if(pl.isParameter("Inverse Schur Type"))
invSStr = pl.get<std::string>("Inverse Schur Type");
if(pl.isParameter("Diagonal Type")) {
std::string massInverseStr = pl.get<std::string>("Diagonal Type");
// build inverse types
a00InverseType_ = getDiagonalType(massInverseStr);
}
// set defaults as needed
if(invA00Str=="") invA00Str = invStr;
if(invSStr=="") invSStr = invStr;
Teko_DEBUG_MSG_BEGIN(5)
DEBUG_STREAM << "LU2x2 Diagonal Strategy Parameters: " << std::endl;
DEBUG_STREAM << " inv type = \"" << invStr << "\"" << std::endl;
DEBUG_STREAM << " inv A00 type = \"" << invA00Str << "\"" << std::endl;
DEBUG_STREAM << " inv S type = \"" << invSStr << "\"" << std::endl;
DEBUG_STREAM << "LU2x2 Diagonal Strategy Parameter list: " << std::endl;
pl.print(DEBUG_STREAM);
Teko_DEBUG_MSG_END()
// build velocity inverse factory
invFactoryA00_ = invLib.getInverseFactory(invA00Str);
if(invA00Str==invSStr)
invFactoryS_ = invFactoryA00_;
else
invFactoryS_ = invLib.getInverseFactory(invSStr);
}
/** \brief This function builds the internals of the state from a parameter list.
*
* This function builds the internals of the LU 2x2 state
* from a parameter list. Furthermore, it allows a
* developer to easily add a factory to the build system.
*
* \param[in] settings Parameter list to use as the internal settings
* \param[in] invLib Inverse library to use for building inverse factory objects
*
* \note The default implementation does nothing.
*/
void PCDStrategy::initializeFromParameterList(const Teuchos::ParameterList & pl,
const InverseLibrary & invLib)
{
Teko_DEBUG_SCOPE("PCDStrategy::initializeFromParameterList",10);
std::string invStr="Amesos", invFStr="", invSStr="";
massInverseType_ = Diagonal;
// "parse" the parameter list
if(pl.isParameter("Inverse Type"))
invStr = pl.get<std::string>("Inverse Type");
if(pl.isParameter("Inverse F Type"))
invFStr = pl.get<std::string>("Inverse F Type");
if(pl.isParameter("Inverse Laplace Type"))
invSStr = pl.get<std::string>("Inverse Laplace Type");
if(pl.isParameter("Inverse Mass Type")) {
std::string massInverseStr = pl.get<std::string>("Inverse Mass Type");
// build inverse types
massInverseType_ = getDiagonalType(massInverseStr);
}
if(pl.isParameter("Flip Schur Complement Ordering"))
schurCompOrdering_ = pl.get<bool>("Flip Schur Complement Ordering");
// set defaults as needed
if(invFStr=="") invFStr = invStr;
if(invSStr=="") invSStr = invStr;
// read pressure laplace parameters
if(pl.isSublist("Pressure Laplace Parameters"))
lapParams_ = Teuchos::rcp(new Teuchos::ParameterList(pl.sublist("Pressure Laplace Parameters")));
else
lapParams_ = Teuchos::rcp(new Teuchos::ParameterList);
// read pcd operator parameters
if(pl.isSublist("Pressure Convection Diffusion Parameters"))
pcdParams_ = Teuchos::rcp(new Teuchos::ParameterList(pl.sublist("Pressure Convection Diffusion Parameters")));
else
pcdParams_ = Teuchos::rcp(new Teuchos::ParameterList);
// The user should not have already added this parameters
TEUCHOS_TEST_FOR_EXCEPTION(lapParams_->isParameter("Name"),std::logic_error,
"Teko: Parameter \"Name\" is not allowed in the sublist \""+lapParams_->name()+"\"");
TEUCHOS_TEST_FOR_EXCEPTION(lapParams_->isParameter("Tag"),std::logic_error,
"Teko: Parameter \"Tag\" is not allowed in the sublist \""+lapParams_->name()+"\"");
TEUCHOS_TEST_FOR_EXCEPTION(pcdParams_->isParameter("Name"),std::logic_error,
"Teko: Parameter \"Name\" is not allowed in the sublist \""+pcdParams_->name()+"\"");
TEUCHOS_TEST_FOR_EXCEPTION(pcdParams_->isParameter("Tag"),std::logic_error,
"Teko: Parameter \"Tag\" is not allowed in the sublist \""+pcdParams_->name()+"\"");
Teko_DEBUG_MSG_BEGIN(5)
DEBUG_STREAM << "PCD Strategy Parameters: " << std::endl;
DEBUG_STREAM << " inv type = \"" << invStr << "\"" << std::endl;
DEBUG_STREAM << " inv F type = \"" << invFStr << "\"" << std::endl;
DEBUG_STREAM << " inv Laplace type = \"" << invSStr << "\"" << std::endl;
DEBUG_STREAM << " inv Mass type = \"" << Teko::getDiagonalName(massInverseType_) << "\"" << std::endl;
DEBUG_STREAM << "PCD Strategy Parameter list: " << std::endl;
pl.print(DEBUG_STREAM);
Teko_DEBUG_MSG_END()
// build velocity inverse factory
invFactoryF_ = invLib.getInverseFactory(invFStr);
if(invFStr==invSStr)
invFactoryS_ = invFactoryF_;
else
invFactoryS_ = invLib.getInverseFactory(invSStr);
lapParams_->set("Name",getPressureLaplaceString());
pcdParams_->set("Name",getPCDString());
// setup a request for required operators
getRequestHandler()->preRequest<Teko::LinearOp>(getPressureMassString());
// getRequestHandler()->preRequest<Teko::LinearOp>(getPCDString());
// getRequestHandler()->preRequest<Teko::LinearOp>(getPressureLaplaceString());
getRequestHandler()->preRequest<Teko::LinearOp>(Teko::RequestMesg(lapParams_));
getRequestHandler()->preRequest<Teko::LinearOp>(Teko::RequestMesg(pcdParams_));
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv, 0);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int nProcs, myPID ;
Teuchos::ParameterList pLUList ; // ParaLU parameters
Teuchos::ParameterList isoList ; // Isorropia parameters
Teuchos::ParameterList shyLUList ; // shyLU parameters
Teuchos::ParameterList ifpackList ; // shyLU parameters
string ipFileName = "ShyLU.xml"; // TODO : Accept as i/p
nProcs = mpiSession.getNProc();
myPID = Comm.MyPID();
if (myPID == 0)
{
cout <<"Parallel execution: nProcs="<< nProcs << endl;
}
// =================== Read input xml file =============================
Teuchos::updateParametersFromXmlFile(ipFileName, &pLUList);
isoList = pLUList.sublist("Isorropia Input");
shyLUList = pLUList.sublist("ShyLU Input");
shyLUList.set("Outer Solver Library", "AztecOO");
// Get matrix market file name
string MMFileName = Teuchos::getParameter<string>(pLUList, "mm_file");
string prec_type = Teuchos::getParameter<string>(pLUList, "preconditioner");
int maxiters = Teuchos::getParameter<int>(pLUList, "Outer Solver MaxIters");
double tol = Teuchos::getParameter<double>(pLUList, "Outer Solver Tolerance");
string rhsFileName = pLUList.get<string>("rhs_file", "");
if (myPID == 0)
{
cout << "Input :" << endl;
cout << "ParaLU params " << endl;
pLUList.print(std::cout, 2, true, true);
cout << "Matrix market file name: " << MMFileName << endl;
}
// ==================== Read input Matrix ==============================
Epetra_CrsMatrix *A;
Epetra_MultiVector *b1;
int err = EpetraExt::MatrixMarketFileToCrsMatrix(MMFileName.c_str(), Comm,
A);
//EpetraExt::MatlabFileToCrsMatrix(MMFileName.c_str(), Comm, A);
//assert(err != 0);
//cout <<"Done reading the matrix"<< endl;
int n = A->NumGlobalRows();
//cout <<"n="<< n << endl;
// Create input vectors
Epetra_Map vecMap(n, 0, Comm);
if (rhsFileName != "")
{
err = EpetraExt::MatrixMarketFileToMultiVector(rhsFileName.c_str(),
vecMap, b1);
}
else
{
b1 = new Epetra_MultiVector(vecMap, 1, false);
b1->PutScalar(1.0);
}
Epetra_MultiVector x(vecMap, 1);
//cout << "Created the vectors" << endl;
// Partition the matrix with hypergraph partitioning and redisstribute
Isorropia::Epetra::Partitioner *partitioner = new
Isorropia::Epetra::Partitioner(A, isoList, false);
partitioner->partition();
Isorropia::Epetra::Redistributor rd(partitioner);
Epetra_CrsMatrix *newA;
Epetra_MultiVector *newX, *newB;
rd.redistribute(*A, newA);
delete A;
A = newA;
rd.redistribute(x, newX);
rd.redistribute(*b1, newB);
Epetra_LinearProblem problem(A, newX, newB);
AztecOO solver(problem);
ifpackList ;
Ifpack_Preconditioner *prec;
ML_Epetra::MultiLevelPreconditioner *MLprec;
if (prec_type.compare("ShyLU") == 0)
{
prec = new Ifpack_ShyLU(A);
prec->SetParameters(shyLUList);
prec->Initialize();
prec->Compute();
//(dynamic_cast<Ifpack_ShyLU *>(prec))->JustTryIt();
//cout << " Going to set it in solver" << endl ;
solver.SetPrecOperator(prec);
//cout << " Done setting the solver" << endl ;
}
else if (prec_type.compare("ILU") == 0)
{
ifpackList.set( "fact: level-of-fill", 1 );
prec = new Ifpack_ILU(A);
prec->SetParameters(ifpackList);
prec->Initialize();
prec->Compute();
solver.SetPrecOperator(prec);
}
else if (prec_type.compare("ILUT") == 0)
{
ifpackList.set( "fact: ilut level-of-fill", 2 );
ifpackList.set( "fact: drop tolerance", 1e-8);
prec = new Ifpack_ILUT(A);
prec->SetParameters(ifpackList);
prec->Initialize();
prec->Compute();
solver.SetPrecOperator(prec);
}
else if (prec_type.compare("ML") == 0)
{
Teuchos::ParameterList mlList; // TODO : Take it from i/p
MLprec = new ML_Epetra::MultiLevelPreconditioner(*A, mlList, true);
solver.SetPrecOperator(MLprec);
}
solver.SetAztecOption(AZ_solver, AZ_gmres);
solver.SetMatrixName(333);
//solver.SetAztecOption(AZ_output, 1);
//solver.SetAztecOption(AZ_conv, AZ_Anorm);
//cout << "Going to iterate for the global problem" << endl;
solver.Iterate(maxiters, tol);
// compute ||Ax - b||
double Norm;
Epetra_MultiVector Ax(vecMap, 1);
Epetra_MultiVector *newAx;
rd.redistribute(Ax, newAx);
A->Multiply(false, *newX, *newAx);
newAx->Update(1.0, *newB, -1.0);
newAx->Norm2(&Norm);
double ANorm = A->NormOne();
cout << "|Ax-b |/|A| = " << Norm/ANorm << endl;
delete newAx;
if (prec_type.compare("ML") == 0)
{
delete MLprec;
}
else
{
delete prec;
}
delete b1;
delete newX;
delete newB;
delete A;
delete partitioner;
}
Teuchos::RCP< std::vector< Teuchos::RCP<PHX::Evaluator<panzer::Traits> > > >
user_app::MyModelFactory<EvalT>::
buildClosureModels(const std::string& model_id,
const Teuchos::ParameterList& models,
const panzer::FieldLayoutLibrary& fl,
const Teuchos::RCP<panzer::IntegrationRule>& ir,
const Teuchos::ParameterList& default_params,
const Teuchos::ParameterList& user_data,
const Teuchos::RCP<panzer::GlobalData>& global_data,
PHX::FieldManager<panzer::Traits>& fm) const
{
using std::string;
using std::vector;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using PHX::Evaluator;
RCP< vector< RCP<Evaluator<panzer::Traits> > > > evaluators =
rcp(new vector< RCP<Evaluator<panzer::Traits> > > );
if (!models.isSublist(model_id)) {
models.print(std::cout);
std::stringstream msg;
msg << "Falied to find requested model, \"" << model_id
<< "\", for equation set:\n" << std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!models.isSublist(model_id), std::logic_error, msg.str());
}
std::vector<Teuchos::RCP<const panzer::PureBasis> > bases;
fl.uniqueBases(bases);
const ParameterList& my_models = models.sublist(model_id);
for (ParameterList::ConstIterator model_it = my_models.begin();
model_it != my_models.end(); ++model_it) {
bool found = false;
const std::string key = model_it->first;
ParameterList input;
const Teuchos::ParameterEntry& entry = model_it->second;
const ParameterList& plist = Teuchos::getValue<Teuchos::ParameterList>(entry);
if (plist.isType<std::string>("Type")) {
if (plist.get<std::string>("Type") == "Parameter") {
TEUCHOS_ASSERT(!plist.isParameter("Value"));
// Defaults for backward compatibility
std::string parameter_name = key;
std::string field_name = key;
if (plist.isType<std::string>("Parameter Name"))
parameter_name = plist.get<std::string>("Parameter Name");
if (plist.isType<std::string>("Field Name"))
field_name = plist.get<std::string>("Field Name");
{ // at IP
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Parameter<EvalT,panzer::Traits>(parameter_name,field_name,ir->dl_scalar,*global_data->pl));
evaluators->push_back(e);
}
for (std::vector<Teuchos::RCP<const panzer::PureBasis> >::const_iterator basis_itr = bases.begin();
basis_itr != bases.end(); ++basis_itr) { // at BASIS
Teuchos::RCP<const panzer::BasisIRLayout> basis = basisIRLayout(*basis_itr,*ir);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Parameter<EvalT,panzer::Traits>(parameter_name,field_name,basis->functional,*global_data->pl));
evaluators->push_back(e);
}
found = true;
continue;
}
else if (plist.get<std::string>("Type") == "Distributed Parameter") {
// sanity check
TEUCHOS_ASSERT(distr_param_lof!=Teuchos::null);
// build a nodal basis
Teuchos::RCP<const panzer::PureBasis> nodal_basis
= Teuchos::rcp(new panzer::PureBasis("HGrad",1,bases[0]->numCells(),
bases[0]->getCellTopology()));
{
Teuchos::RCP<std::vector<std::string> > dof_names = Teuchos::rcp(new std::vector<std::string>);
dof_names->push_back(key);
ParameterList p("Gather");
p.set("Basis", nodal_basis);
p.set("DOF Names", dof_names);
p.set("Indexer Names", dof_names);
p.set("Sensitivities Name", key);
p.set("Disable Sensitivities", false);
p.set("Gather Seed Index", 0);
p.set("Global Data Key", key);
RCP< PHX::Evaluator<panzer::Traits> > e = distr_param_lof->buildGatherDomain<EvalT>(p);
evaluators->push_back(e);
}
{
ParameterList p;
p.set("Name", key);
p.set("Basis", basisIRLayout(nodal_basis,*ir));
p.set("IR", ir);
RCP< PHX::Evaluator<panzer::Traits> > e = rcp(new panzer::DOF<EvalT,panzer::Traits>(p));
evaluators->push_back(e);
}
found = true;
}
else if (plist.get<std::string>("Type") == "Product") {
RCP<std::vector<std::string> > valuesNames = rcp(new std::vector<std::string>);
// Tokenize a string, put tokens in a vector
panzer::StringTokenizer(*valuesNames,plist.get<std::string>("Term Names"));
double scaling = 1.0;
if(plist.isType<double>("Scaling"))
scaling = plist.get<double>("Scaling");
{
Teuchos::ParameterList input;
input.set("Scaling", scaling);
input.set("Product Name", key);
input.set("Values Names", valuesNames);
input.set("Data Layout", ir->dl_scalar);
RCP< panzer::Product<EvalT,panzer::Traits> > e =
rcp(new panzer::Product<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
}
else if (plist.isType<double>("Value")) {
{ // at IP
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
input.set("Data Layout", ir->dl_scalar);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Constant<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
// at BASIS
for (std::vector<Teuchos::RCP<const panzer::PureBasis> >::const_iterator basis_itr = bases.begin();
basis_itr != bases.end(); ++basis_itr) {
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
Teuchos::RCP<const panzer::BasisIRLayout> basis = basisIRLayout(*basis_itr,*ir);
input.set("Data Layout", basis->functional);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Constant<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (plist.isType<std::string>("Value")) {
const std::string value = plist.get<std::string>("Value");
if (key == "Global Statistics") {
if (typeid(EvalT) == typeid(panzer::Traits::Residual)) {
input.set("Comm", user_data.get<Teuchos::RCP<const Teuchos::Comm<int> > >("Comm"));
input.set("Names", value);
input.set("IR", ir);
input.set("Global Data", global_data);
RCP< panzer::GlobalStatistics<EvalT,panzer::Traits> > e =
rcp(new panzer::GlobalStatistics<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
// Require certain fields be evaluated
fm.template requireField<EvalT>(e->getRequiredFieldTag());
}
found = true;
}
else if(value=="Field Spy") {
const std::string & source = plist.get<std::string>("Source Field");
RCP<panzer::FieldSpy<EvalT,panzer::Traits> > e =
rcp(new panzer::FieldSpy<EvalT,panzer::Traits>(source,ir->dl_scalar));
evaluators->push_back(e);
fm.template requireField<EvalT>(e->getRequiredFieldTag());
found = true;
}
else if(value=="Field Spy Basis") {
const std::string & source = plist.get<std::string>("Source Field");
RCP<panzer::FieldSpy<EvalT,panzer::Traits> > e =
rcp(new panzer::FieldSpy<EvalT,panzer::Traits>(source,bases[0]->functional));
evaluators->push_back(e);
fm.template requireField<EvalT>(e->getRequiredFieldTag());
found = true;
}
}
if (key == "Volume Integral") {
{
ParameterList input;
input.set("Name", "Unit Value");
input.set("Value", 1.0);
input.set("Data Layout", ir->dl_scalar);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Constant<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
{
ParameterList input;
input.set("Integral Name", "Volume_Integral");
input.set("Integrand Name", "Unit Value");
input.set("IR", ir);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Integrator_Scalar<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (key == "Coordinates") {
std::string dim_str[3] = {"X","Y","Z"};
panzer::CellData cell_data(ir->workset_size,ir->topology);
panzer::PureBasis basis("HGrad",1,cell_data);
for(int i=0; i<basis.dimension(); i++) {
ParameterList input;
input.set("Field Name", "COORD"+dim_str[i]);
input.set("Data Layout", basis.functional);
input.set("Dimension", i);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::CoordinatesEvaluator<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (!found) {
std::stringstream msg;
msg << "ClosureModelFactory failed to build evaluator for key \"" << key
<< "\"\nin model \"" << model_id
<< "\". Please correct the type or add support to the \nfactory." <<std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!found, std::logic_error, msg.str());
}
}
return evaluators;
}
int main(int argc, char *argv[]) {
using Teuchos::RCP;
Teuchos::oblackholestream blackhole;
Teuchos::GlobalMPISession mpiSession(&argc,&argv,&blackhole);
RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
RCP<Teuchos::FancyOStream> out = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
out->setOutputToRootOnly(0);
*out << MueLu::MemUtils::PrintMemoryUsage() << std::endl;
// Timing
Teuchos::Time myTime("global");
Teuchos::TimeMonitor M(myTime);
#ifndef HAVE_TEUCHOS_LONG_LONG_INT
*out << "Warning: scaling test was not compiled with long long int support" << std::endl;
#endif
// custom parameters
LO maxLevels = 10;
LO its=40;
std::string smooType="sgs";
int sweeps=1;
int maxCoarseSize=1; //FIXME clp doesn't like long long int
std::string aggOrdering = "natural";
int minPerAgg=2;
int maxNbrAlreadySelected=0;
// read in problem
Epetra_Map emap(10201,0,*Xpetra::toEpetra(comm));
Epetra_CrsMatrix * ptrA = 0;
Epetra_Vector * ptrf = 0;
std::cout << "Reading matrix market file" << std::endl;
EpetraExt::MatrixMarketFileToCrsMatrix("Condif2Mat.mat",emap,emap,emap,ptrA);
EpetraExt::MatrixMarketFileToVector("Condif2Rhs.mat",emap,ptrf);
RCP<Epetra_CrsMatrix> epA = Teuchos::rcp(ptrA);
RCP<Epetra_Vector> epv = Teuchos::rcp(ptrf);
// Epetra_CrsMatrix -> Xpetra::Matrix
RCP<Xpetra::CrsMatrix<double, int, int> > exA = Teuchos::rcp(new Xpetra::EpetraCrsMatrix(epA));
RCP<Xpetra::CrsMatrixWrap<double, int, int> > crsOp = Teuchos::rcp(new Xpetra::CrsMatrixWrap<double, int, int>(exA));
RCP<Xpetra::Matrix<double, int, int> > Op = Teuchos::rcp_dynamic_cast<Xpetra::Matrix<double, int, int> >(crsOp);
// Epetra_Vector -> Xpetra::Vector
RCP<Xpetra::Vector<double,int,int> > xRhs = Teuchos::rcp(new Xpetra::EpetraVector(epv));
// Epetra_Map -> Xpetra::Map
const RCP< const Xpetra::Map<int, int> > map = Xpetra::toXpetra(emap);
// build nullspace
RCP<MultiVector> nullSpace = MultiVectorFactory::Build(map,1);
nullSpace->putScalar( (SC) 1.0);
/*for (size_t i=0; i<nullSpace->getLocalLength(); i++) {
Teuchos::ArrayRCP< Scalar > data0 = nullSpace->getDataNonConst(0);
Teuchos::ArrayRCP< Scalar > data1 = nullSpace->getDataNonConst(1);
GlobalOrdinal gid = map->getGlobalElement(Teuchos::as<LocalOrdinal>(i));
if(gid % 2 == 0) {
data0[i] = 1.0; data1[i] = 0.0;
}
else {
data0[i] = 0.0; data1[i] = 1.0;
}
}*/
RCP<MueLu::Hierarchy<SC,LO,GO,NO,LMO> > H = rcp ( new Hierarchy() );
H->setDefaultVerbLevel(Teuchos::VERB_HIGH);
H->SetMaxCoarseSize((GO) maxCoarseSize);;
// build finest Level
RCP<MueLu::Level> Finest = H->GetLevel();
Finest->setDefaultVerbLevel(Teuchos::VERB_HIGH);
Finest->Set("A",Op);
Finest->Set("Nullspace",nullSpace);
RCP<CoupledAggregationFactory> CoupledAggFact = rcp(new CoupledAggregationFactory());
*out << "========================= Aggregate option summary =========================" << std::endl;
*out << "min DOFs per aggregate : " << minPerAgg << std::endl;
*out << "min # of root nbrs already aggregated : " << maxNbrAlreadySelected << std::endl;
CoupledAggFact->SetMinNodesPerAggregate(minPerAgg); //TODO should increase if run anything other than 1D
CoupledAggFact->SetMaxNeighAlreadySelected(maxNbrAlreadySelected);
std::transform(aggOrdering.begin(), aggOrdering.end(), aggOrdering.begin(), ::tolower);
if (aggOrdering == "natural") {
*out << "aggregate ordering : NATURAL" << std::endl;
CoupledAggFact->SetOrdering(MueLu::AggOptions::NATURAL);
} else if (aggOrdering == "random") {
*out << "aggregate ordering : RANDOM" << std::endl;
CoupledAggFact->SetOrdering(MueLu::AggOptions::RANDOM);
} else if (aggOrdering == "graph") {
*out << "aggregate ordering : GRAPH" << std::endl;
CoupledAggFact->SetOrdering(MueLu::AggOptions::GRAPH);
} else {
std::string msg = "main: bad aggregation option """ + aggOrdering + """.";
throw(MueLu::Exceptions::RuntimeError(msg));
}
CoupledAggFact->SetPhase3AggCreation(0.5);
*out << "=============================================================================" << std::endl;
// build transfer operators
RCP<TentativePFactory> TentPFact = rcp(new TentativePFactory(CoupledAggFact));
*out << " afer TentativePFactory " << std::endl;
//RCP<TentativePFactory> Pfact = rcp(new TentativePFactory(CoupledAggFact));
//RCP<Factory> Rfact = rcp( new TransPFactory(Pfact));
//RCP<SaPFactory> Pfact = rcp( new SaPFactory(TentPFact) );
//RCP<Factory> Rfact = rcp( new TransPFactory(Pfact));
RCP<ThresholdAFilterFactory> Afiltered = rcp(new ThresholdAFilterFactory("A",NULL,0.0005));
RCP<PgPFactory> Pfact = rcp( new PgPFactory(TentPFact,Afiltered) );
RCP<Factory> Rfact = rcp( new GenericRFactory(Pfact));
RCP<RAPFactory> Acfact = rcp( new RAPFactory(Pfact, Rfact) );
Acfact->setVerbLevel(Teuchos::VERB_HIGH);
*out << " after ACFactory " << std::endl;
// build level smoothers
RCP<SmootherPrototype> smooProto;
std::string ifpackType;
Teuchos::ParameterList ifpackList;
ifpackList.set("relaxation: sweeps", (LO) sweeps);
ifpackList.set("relaxation: damping factor", (SC) 0.9); // 0.7
ifpackType = "RELAXATION";
ifpackList.set("relaxation: type", "Gauss-Seidel");
smooProto = Teuchos::rcp( new TrilinosSmoother(Xpetra::UseEpetra, ifpackType, ifpackList) );
RCP<SmootherFactory> SmooFact;
if (maxLevels > 1)
SmooFact = rcp( new SmootherFactory(smooProto) );
Teuchos::ParameterList status;
#if 0 // both variants are equivalent
// fill FactoryManager object by hand
FactoryManager Manager;
Manager.SetFactory("A", Acfact);
Manager.SetFactory("P", Pfact);
Manager.SetFactory("R", Rfact);
Manager.SetFactory("Smoother", SmooFact);
Manager.SetFactory("CoarseSolver", Teuchos::null);
status = H->Setup(Manager);
#else
// use FullPopulate (short, but outdated?)
status = H->FullPopulate(*Pfact,*Rfact,*Acfact,*SmooFact,0,maxLevels);
#endif
H->SetCoarsestSolver(*SmooFact,MueLu::PRE);
*out << "======================\n Multigrid statistics \n======================" << std::endl;
status.print(*out,Teuchos::ParameterList::PrintOptions().indent(2));
/**********************************************************************************/
/* SOLVE PROBLEM */
/**********************************************************************************/
RCP<MultiVector> x = MultiVectorFactory::Build(map,1);
RCP<Xpetra::MultiVector<double,int,int> > rhs = Teuchos::rcp_dynamic_cast<Xpetra::MultiVector<double,int,int> >(xRhs);//(new Xpetra::EpetraVector(epv));
// Use AMG directly as an iterative method
{
x->putScalar( (SC) 0.0);
H->Iterate(*rhs,its,*x);
//x->describe(*out,Teuchos::VERB_EXTREME);
}
RCP<Level> coarseLevel = H->GetLevel(1);
coarseLevel->print(*out);
RCP<Level> coarseLevel2 = H->GetLevel(1);
coarseLevel2->print(*out);
//M.summarize();
return EXIT_SUCCESS;
}
//! Initialize from a parameter list
void InvLSCStrategy::initializeFromParameterList(const Teuchos::ParameterList & pl,const InverseLibrary & invLib)
{
// get string specifying inverse
std::string invStr="", invVStr="", invPStr="";
bool rowZeroing = true;
bool useLDU = false;
scaleType_ = Diagonal;
// "parse" the parameter list
if(pl.isParameter("Inverse Type"))
invStr = pl.get<std::string>("Inverse Type");
if(pl.isParameter("Inverse Velocity Type"))
invVStr = pl.get<std::string>("Inverse Velocity Type");
if(pl.isParameter("Inverse Pressure Type"))
invPStr = pl.get<std::string>("Inverse Pressure Type");
if(pl.isParameter("Ignore Boundary Rows"))
rowZeroing = pl.get<bool>("Ignore Boundary Rows");
if(pl.isParameter("Use LDU"))
useLDU = pl.get<bool>("Use LDU");
if(pl.isParameter("Use Mass Scaling"))
useMass_ = pl.get<bool>("Use Mass Scaling");
// if(pl.isParameter("Use Lumping"))
// useLumping_ = pl.get<bool>("Use Lumping");
if(pl.isParameter("Use W-Scaling"))
useWScaling_ = pl.get<bool>("Use W-Scaling");
if(pl.isParameter("Eigen Solver Iterations"))
eigSolveParam_ = pl.get<int>("Eigen Solver Iterations");
if(pl.isParameter("Scaling Type")) {
scaleType_ = getDiagonalType(pl.get<std::string>("Scaling Type"));
TEUCHOS_TEST_FOR_EXCEPT(scaleType_==NotDiag);
}
if(pl.isParameter("Assume Stable Discretization"))
assumeStable_ = pl.get<bool>("Assume Stable Discretization");
Teko_DEBUG_MSG_BEGIN(5)
DEBUG_STREAM << "LSC Inverse Strategy Parameters: " << std::endl;
DEBUG_STREAM << " inv type = \"" << invStr << "\"" << std::endl;
DEBUG_STREAM << " inv v type = \"" << invVStr << "\"" << std::endl;
DEBUG_STREAM << " inv p type = \"" << invPStr << "\"" << std::endl;
DEBUG_STREAM << " bndry rows = " << rowZeroing << std::endl;
DEBUG_STREAM << " use ldu = " << useLDU << std::endl;
DEBUG_STREAM << " use mass = " << useMass_ << std::endl;
DEBUG_STREAM << " use w-scaling = " << useWScaling_ << std::endl;
DEBUG_STREAM << " assume stable = " << assumeStable_ << std::endl;
DEBUG_STREAM << " scale type = " << getDiagonalName(scaleType_) << std::endl;
DEBUG_STREAM << "LSC Inverse Strategy Parameter list: " << std::endl;
pl.print(DEBUG_STREAM);
Teko_DEBUG_MSG_END()
// set defaults as needed
if(invStr=="") invStr = "Amesos";
if(invVStr=="") invVStr = invStr;
if(invPStr=="") invPStr = invStr;
// build velocity inverse factory
invFactoryF_ = invLib.getInverseFactory(invVStr);
invFactoryS_ = invFactoryF_; // by default these are the same
if(invVStr!=invPStr) // if different, build pressure inverse factory
invFactoryS_ = invLib.getInverseFactory(invPStr);
// set other parameters
setUseFullLDU(useLDU);
setRowZeroing(rowZeroing);
if(useMass_) {
Teuchos::RCP<Teko::RequestHandler> rh = getRequestHandler();
rh->preRequest<Teko::LinearOp>(Teko::RequestMesg("Velocity Mass Matrix"));
Teko::LinearOp mass
= rh->request<Teko::LinearOp>(Teko::RequestMesg("Velocity Mass Matrix"));
setMassMatrix(mass);
}
}
Teuchos::RCP< std::vector< Teuchos::RCP<PHX::Evaluator<panzer::Traits> > > >
user_app::MyModelFactory<EvalT>::
buildClosureModels(const std::string& model_id,
const Teuchos::ParameterList& models,
const panzer::FieldLayoutLibrary& fl,
const Teuchos::RCP<panzer::IntegrationRule>& ir,
const Teuchos::ParameterList& default_params,
const Teuchos::ParameterList& user_data,
const Teuchos::RCP<panzer::GlobalData>& global_data,
PHX::FieldManager<panzer::Traits>& fm) const
{
using std::string;
using std::vector;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using PHX::Evaluator;
RCP< vector< RCP<Evaluator<panzer::Traits> > > > evaluators =
rcp(new vector< RCP<Evaluator<panzer::Traits> > > );
if (!models.isSublist(model_id)) {
models.print(std::cout);
std::stringstream msg;
msg << "Falied to find requested model, \"" << model_id
<< "\", for equation set:\n" << std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!models.isSublist(model_id), std::logic_error, msg.str());
}
std::vector<Teuchos::RCP<const panzer::PureBasis> > bases;
fl.uniqueBases(bases);
const ParameterList& my_models = models.sublist(model_id);
for (ParameterList::ConstIterator model_it = my_models.begin();
model_it != my_models.end(); ++model_it) {
bool found = false;
const std::string key = model_it->first;
ParameterList input;
const Teuchos::ParameterEntry& entry = model_it->second;
const ParameterList& plist = Teuchos::getValue<Teuchos::ParameterList>(entry);
#ifdef HAVE_STOKHOS
if (plist.isType<double>("Value") && plist.isType<double>("UQ")
&& plist.isParameter("Expansion")
&& (typeid(EvalT)==typeid(panzer::Traits::SGResidual) ||
typeid(EvalT)==typeid(panzer::Traits::SGJacobian)) ) {
{ // at IP
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
input.set("UQ", plist.get<double>("UQ"));
input.set("Expansion", plist.get<Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > >("Expansion"));
input.set("Data Layout", ir->dl_scalar);
RCP< Evaluator<panzer::Traits> > e =
rcp(new user_app::ConstantModel<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
for (std::vector<Teuchos::RCP<const panzer::PureBasis> >::const_iterator basis_itr = bases.begin();
basis_itr != bases.end(); ++basis_itr) { // at BASIS
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
input.set("UQ", plist.get<double>("UQ"));
input.set("Expansion", plist.get<Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > >("Expansion"));
Teuchos::RCP<const panzer::BasisIRLayout> basis = basisIRLayout(*basis_itr,*ir);
input.set("Data Layout", basis->functional);
RCP< Evaluator<panzer::Traits> > e =
rcp(new user_app::ConstantModel<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
else
#endif
if (plist.isType<std::string>("Type")) {
if (plist.get<std::string>("Type") == "Parameter") {
{ // at IP
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Parameter<EvalT,panzer::Traits>(key,ir->dl_scalar,plist.get<double>("Value"),*global_data->pl));
evaluators->push_back(e);
}
for (std::vector<Teuchos::RCP<const panzer::PureBasis> >::const_iterator basis_itr = bases.begin();
basis_itr != bases.end(); ++basis_itr) { // at BASIS
Teuchos::RCP<const panzer::BasisIRLayout> basis = basisIRLayout(*basis_itr,*ir);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Parameter<EvalT,panzer::Traits>(key,basis->functional,plist.get<double>("Value"),*global_data->pl));
evaluators->push_back(e);
}
found = true;
}
}
else if (plist.isType<double>("Value")) {
{ // at IP
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
input.set("Data Layout", ir->dl_scalar);
RCP< Evaluator<panzer::Traits> > e =
rcp(new user_app::ConstantModel<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
// at BASIS
for (std::vector<Teuchos::RCP<const panzer::PureBasis> >::const_iterator basis_itr = bases.begin();
basis_itr != bases.end(); ++basis_itr) {
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
Teuchos::RCP<const panzer::BasisIRLayout> basis = basisIRLayout(*basis_itr,*ir);
input.set("Data Layout", basis->functional);
RCP< Evaluator<panzer::Traits> > e =
rcp(new user_app::ConstantModel<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (plist.isType<std::string>("Value")) {
const std::string value = plist.get<std::string>("Value");
if (key == "Global Statistics") {
if (typeid(EvalT) == typeid(panzer::Traits::Residual)) {
input.set("Comm", user_data.get<Teuchos::RCP<const Teuchos::Comm<int> > >("Comm"));
input.set("Names", value);
input.set("IR", ir);
input.set("Global Data", global_data);
RCP< panzer::GlobalStatistics<EvalT,panzer::Traits> > e =
rcp(new panzer::GlobalStatistics<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
// Require certain fields be evaluated
fm.template requireField<EvalT>(e->getRequiredFieldTag());
}
found = true;
}
}
if (key == "Volume Integral") {
{
ParameterList input;
input.set("Name", "Unit Value");
input.set("Value", 1.0);
input.set("Data Layout", ir->dl_scalar);
RCP< Evaluator<panzer::Traits> > e =
rcp(new user_app::ConstantModel<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
{
ParameterList input;
input.set("Integral Name", "Volume_Integral");
input.set("Integrand Name", "Unit Value");
input.set("IR", ir);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Integrator_Scalar<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (key == "Coordinates") {
std::string dim_str[3] = {"X","Y","Z"};
panzer::CellData cell_data(ir->workset_size,ir->topology);
panzer::PureBasis basis("HGrad",1,cell_data);
for(int i=0;i<basis.dimension();i++) {
ParameterList input;
input.set("Field Name", "COORD"+dim_str[i]);
input.set("Data Layout", basis.functional);
input.set("Dimension", i);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::CoordinatesEvaluator<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (!found) {
std::stringstream msg;
msg << "ClosureModelFactory failed to build evaluator for key \"" << key
<< "\"\nin model \"" << model_id
<< "\". Please correct the type or add support to the \nfactory." <<std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!found, std::logic_error, msg.str());
}
}
return evaluators;
}
int main(int argc, char *argv[]) {
#include "MueLu_UseShortNames.hpp"
Teuchos::oblackholestream blackhole;
Teuchos::GlobalMPISession mpiSession(&argc,&argv,&blackhole);
RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
/**********************************************************************************/
/* SET TEST PARAMETERS */
/**********************************************************************************/
// Note: use --help to list available options.
Teuchos::CommandLineProcessor clp(false);
// Default is Laplace1D with nx = 8748.
// It's a nice size for 1D and perfect aggregation. (6561=3^8)
//Nice size for 1D and perfect aggregation on small numbers of processors. (8748=4*3^7)
Galeri::Xpetra::Parameters<GO> matrixParameters(clp, 8748); // manage parameters of the test case
Xpetra::Parameters xpetraParameters(clp); // manage parameters of xpetra
// custom parameters
LO maxLevels = 1;
LO its=2;
std::string coarseSolver="amesos2";
clp.setOption("maxLevels",&maxLevels,"maximum number of levels allowed");
clp.setOption("its",&its,"number of multigrid cycles");
clp.setOption("coarseSolver",&coarseSolver,"amesos2 or ifpack2 (Tpetra specific. Ignored for Epetra)");
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;
}
matrixParameters.check();
xpetraParameters.check();
// TODO: check custom parameters
if (comm->getRank() == 0) {
matrixParameters.print();
xpetraParameters.print();
// TODO: print custom parameters
}
#ifdef FOR_PARALLEL_DEBUGGING
//Utils::BreakForDebugger(*comm);
LO mypid = comm->getRank();
if (mypid == 0) std::cout << "Host and Process Ids for tasks" << std::endl;
for (LO i = 0; i <comm->getSize(); i++) {
if (i == mypid ) {
char buf[80];
char hostname[80];
gethostname(hostname, sizeof(hostname));
LO pid = getpid();
sprintf(buf, "Host: %s\tMPI rank: %d,\tPID: %d\n\tattach %d\n\tcontinue\n",
hostname, mypid, pid, pid);
printf("%s\n",buf);
fflush(stdout);
sleep(1);
}
}
if (mypid == 0) {
printf( "** Enter a character to continue > "); fflush(stdout);
char go = ' ';
scanf("%c",&go);
}
comm->barrier();
#endif
/**********************************************************************************/
/* CREATE INITIAL MATRIX */
/**********************************************************************************/
const RCP<const Map> map = MapFactory::Build(xpetraParameters.GetLib(), matrixParameters.GetNumGlobalElements(), 0, comm);
RCP<Galeri::Xpetra::Problem<Map,CrsMatrixWrap,MultiVector> > Pr =
Galeri::Xpetra::BuildProblem<SC, LO, GO, Map, CrsMatrixWrap, MultiVector>(matrixParameters.GetMatrixType(), map, matrixParameters.GetParameterList()); //TODO: Matrix vs. CrsMatrixWrap
RCP<Matrix> Op = Pr->BuildMatrix();
/**********************************************************************************/
/* */
/**********************************************************************************/
// dump matrix to file
//std::string fileName = "Amat.mm";
//Utils::Write(fileName,Op);
RCP<MultiVector> nullSpace = MultiVectorFactory::Build(map,1);
nullSpace->putScalar( (SC) 1.0);
Teuchos::Array<Teuchos::ScalarTraits<SC>::magnitudeType> norms(1);
nullSpace->norm1(norms);
if (comm->getRank() == 0)
std::cout << "||NS|| = " << norms[0] << std::endl;
RCP<MueLu::Hierarchy<SC,LO,GO,NO,LMO> > H = rcp( new Hierarchy() );
H->setDefaultVerbLevel(Teuchos::VERB_HIGH);
RCP<MueLu::Level> Finest = rcp( new MueLu::Level() );
Finest->setDefaultVerbLevel(Teuchos::VERB_HIGH);
Finest->Set("A",Op);
Finest->Set("Nullspace",nullSpace);
Finest->Request("Nullspace"); //FIXME putting this in to avoid error until Merge needs business
//FIXME is implemented
Finest->Set("NullSpace",nullSpace);
H->SetLevel(Finest);
RCP<CoupledAggregationFactory> CoupledAggFact = rcp(new CoupledAggregationFactory());
CoupledAggFact->SetMinNodesPerAggregate(3);
CoupledAggFact->SetMaxNeighAlreadySelected(0);
CoupledAggFact->SetOrdering("natural");
CoupledAggFact->SetPhase3AggCreation(0.5);
RCP<TentativePFactory> TentPFact = rcp(new TentativePFactory(CoupledAggFact));
RCP<SaPFactory> Pfact = rcp( new SaPFactory(TentPFact) );
//Pfact->SetDampingFactor(0.);
RCP<Factory> Rfact = rcp( new TransPFactory() );
RCP<GenericPRFactory> PRfact = rcp( new GenericPRFactory(Pfact,Rfact));
RCP<RAPFactory> Acfact = rcp( new RAPFactory() );
RCP<SmootherPrototype> smooProto;
Teuchos::ParameterList ifpackList;
ifpackList.set("relaxation: sweeps", (LO) 1);
ifpackList.set("relaxation: damping factor", (SC) 1.0);
/*
ifpackList.set("type", "Chebyshev");
ifpackList.set("chebyshev: degree", (int) 1);
ifpackList.set("chebyshev: max eigenvalue", (double) 2.0);
ifpackList.set("chebyshev: min eigenvalue", (double) 1.0);
ifpackList.set("chebyshev: zero starting solution", false);
*/
if (xpetraParameters.GetLib() == Xpetra::UseEpetra) {
#if defined(HAVE_MUELU_EPETRA) && defined(HAVE_MUELU_IFPACK)
ifpackList.set("relaxation: type", "symmetric Gauss-Seidel");
smooProto = rcp( new IfpackSmoother("point relaxation stand-alone",ifpackList) );
#endif
} else if (xpetraParameters.GetLib() == Xpetra::UseTpetra) {
#if defined(HAVE_MUELU_TPETRA) && defined(HAVE_MUELU_IFPACK2)
ifpackList.set("relaxation: type", "Symmetric Gauss-Seidel");
smooProto = rcp( new Ifpack2Smoother("RELAXATION",ifpackList) );
#endif
}
if (smooProto == Teuchos::null) {
throw(MueLu::Exceptions::RuntimeError("main: smoother error"));
}
RCP<SmootherFactory> SmooFact = rcp( new SmootherFactory(smooProto) );
Acfact->setVerbLevel(Teuchos::VERB_HIGH);
Teuchos::ParameterList status;
status = H->FullPopulate(PRfact,Acfact,SmooFact,0,maxLevels);
//RCP<MueLu::Level> coarseLevel = H.GetLevel(1);
//RCP<Matrix> P = coarseLevel->template Get< RCP<Matrix> >("P");
//fileName = "Pfinal.mm";
//Utils::Write(fileName,P);
if (comm->getRank() == 0) {
std::cout << "======================\n Multigrid statistics \n======================" << std::endl;
status.print(std::cout,Teuchos::ParameterList::PrintOptions().indent(2));
}
//FIXME we should be able to just call smoother->SetNIts(50) ... but right now an exception gets thrown
RCP<SmootherPrototype> coarseProto;
if (xpetraParameters.GetLib() == Xpetra::UseEpetra) {
#if defined(HAVE_MUELU_EPETRA) && defined(HAVE_MUELU_AMESOS)
if (comm->getRank() == 0) std::cout << "CoarseGrid: AMESOS" << std::endl;
Teuchos::ParameterList amesosList;
amesosList.set("PrintTiming",true);
coarseProto = rcp( new AmesosSmoother("Amesos_Klu",amesosList) );
//#elif
#endif
} else if (xpetraParameters.GetLib() == Xpetra::UseTpetra) {
if (coarseSolver=="amesos2") {
#if defined(HAVE_MUELU_TPETRA) && defined(HAVE_MUELU_AMESOS2)
if (comm->getRank() == 0) std::cout << "CoarseGrid: AMESOS2" << std::endl;
Teuchos::ParameterList paramList; //unused
coarseProto = rcp( new Amesos2Smoother("Superlu", paramList) );
#else
std::cout << "AMESOS2 not available (try --coarseSolver=ifpack2)" << std::endl;
return EXIT_FAILURE;
#endif // HAVE_MUELU_TPETRA && HAVE_MUELU_AMESOS2
} else if(coarseSolver=="ifpack2") {
#if defined(HAVE_MUELU_TPETRA) && defined(HAVE_MUELU_IFPACK2)
if (comm->getRank() == 0) std::cout << "CoarseGrid: IFPACK2" << std::endl;
Teuchos::ParameterList ifpack2List;
ifpack2List.set("fact: ilut level-of-fill",99); // TODO ??
ifpack2List.set("fact: drop tolerance", 0);
ifpack2List.set("fact: absolute threshold", 0);
ifpack2List.set("fact: relative threshold", 0);
coarseProto = rcp( new Ifpack2Smoother("ILUT",ifpack2List) );
#else
std::cout << "IFPACK2 not available (try --coarseSolver=amesos2)" << std::endl;
return EXIT_FAILURE;
#endif
} else {
std::cout << "Unknow coarse grid solver (try --coarseSolver=ifpack2 or --coarseSolver=amesos2)" << std::endl;
return EXIT_FAILURE;
}
}
if (coarseProto == Teuchos::null) {
throw(MueLu::Exceptions::RuntimeError("main: coarse smoother error"));
}
SmootherFactory coarseSolveFact(coarseProto);
H->SetCoarsestSolver(coarseSolveFact,MueLu::PRE);
// Define RHS
RCP<MultiVector> X = MultiVectorFactory::Build(map,1);
RCP<MultiVector> RHS = MultiVectorFactory::Build(map,1);
X->setSeed(846930886);
X->randomize();
X->norm2(norms);
if (comm->getRank() == 0)
std::cout << "||X_true|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << norms[0] << std::endl;
Op->apply(*X,*RHS,Teuchos::NO_TRANS,(SC)1.0,(SC)0.0);
// Use AMG directly as an iterative method
{
X->putScalar( (SC) 0.0);
H->PrintResidualHistory(true);
H->Iterate(*RHS,*X,its);
X->norm2(norms);
if (comm->getRank() == 0)
std::cout << "||X_" << std::setprecision(2) << its << "|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << norms[0] << std::endl;
}
return EXIT_SUCCESS;
}
// Printing the valid parameter list only showing documentation fields
inline void printParameterListOptions(std::ostream &os, const Teuchos::ParameterList & p) {
p.print(os, Teuchos::ParameterList::PrintOptions().showDoc(true).indent(2).showTypes(true));
os << std::endl;
}
int main(int narg, char *arg[])
{
using std::cout;
#ifdef EPETRA_MPI
// Initialize MPI
MPI_Init(&narg,&arg);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
int MyPID = Comm.MyPID();
bool verbose = true;
int verbosity = 1;
bool testEpetra64 = true;
// Matrix properties
bool isHermitian = true;
// Multivector properties
std::string initvec = "random";
// Eigenvalue properties
std::string which = "SR";
std::string method = "LOBPCG";
std::string precond = "none";
std::string ortho = "SVQB";
bool lock = true;
bool relconvtol = false;
bool rellocktol = false;
int nev = 5;
// Block-Arnoldi properties
int blockSize = -1;
int numblocks = -1;
int maxrestarts = -1;
int maxiterations = -1;
int extrablocks = 0;
int gensize = 25; // Needs to be long long to test with > INT_MAX rows
double tol = 1.0e-5;
// Echo the command line
if (MyPID == 0) {
for (int i = 0; i < narg; i++)
cout << arg[i] << " ";
cout << endl;
}
// Command-line processing
Teuchos::CommandLineProcessor cmdp(false,true);
cmdp.setOption("Epetra64", "no-Epetra64", &testEpetra64,
"Force code to use Epetra64, even if the problem size does "
"not require it. (Epetra64 will be used automatically for "
"sufficiently large problems, or not used if Epetra does not have built in support.)");
cmdp.setOption("gen",&gensize,
"Generate a simple Laplacian matrix of size n.");
cmdp.setOption("verbosity", &verbosity, "0=quiet, 1=low, 2=medium, 3=high.");
cmdp.setOption("method",&method,
"Solver method to use: LOBPCG, BD, BKS or IRTR.");
cmdp.setOption("nev",&nev,"Number of eigenvalues to find.");
cmdp.setOption("which",&which,"Targetted eigenvalues (SM,LM,SR,or LR).");
cmdp.setOption("tol",&tol,"Solver convergence tolerance.");
cmdp.setOption("blocksize",&blockSize,"Block size to use in solver.");
cmdp.setOption("numblocks",&numblocks,"Number of blocks to allocate.");
cmdp.setOption("extrablocks",&extrablocks,
"Number of extra NEV blocks to allocate in BKS.");
cmdp.setOption("maxrestarts",&maxrestarts,
"Maximum number of restarts in BKS or BD.");
cmdp.setOption("maxiterations",&maxiterations,
"Maximum number of iterations in LOBPCG.");
cmdp.setOption("lock","no-lock",&lock,
"Use Locking parameter (deflate for converged eigenvalues)");
cmdp.setOption("initvec", &initvec,
"Initial vectors (random, unit, zero, random2)");
cmdp.setOption("ortho", &ortho,
"Orthogonalization method (DGKS, SVQB, TSQR).");
cmdp.setOption("relative-convergence-tol","no-relative-convergence-tol",
&relconvtol,
"Use Relative convergence tolerance "
"(normalized by eigenvalue)");
cmdp.setOption("relative-lock-tol","no-relative-lock-tol",&rellocktol,
"Use Relative locking tolerance (normalized by eigenvalue)");
if (cmdp.parse(narg,arg)!=Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) {
FINALIZE;
return -1;
}
// Print the most essential options (not in the MyPL parameters later)
verbose = (verbosity>0);
if (verbose && MyPID==0){
cout << "verbosity = " << verbosity << endl;
cout << "method = " << method << endl;
cout << "initvec = " << initvec << endl;
cout << "nev = " << nev << endl;
}
// We need blockSize to be set so we can allocate memory with it.
// If it wasn't set on the command line, set it to the Anasazi defaults here.
// Defaults are those given in the documentation.
if (blockSize < 0)
if (method == "BKS")
blockSize = 1;
else // other methods: LOBPCG, BD, IRTR
blockSize = nev;
// Make sure Epetra was built with 64-bit global indices enabled.
#ifdef EPETRA_NO_64BIT_GLOBAL_INDICES
if (testEpetra64)
testEpetra64 = false;
#endif
Epetra_CrsMatrix *K = NULL;
// Read matrix from file or generate a matrix
if ((gensize > 0 && testEpetra64)) {
// Generate the matrix using long long for global indices
build_simple_matrix<long long>(Comm, K, (long long)gensize, true, verbose);
}
else if (gensize) {
// Generate the matrix using int for global indices
build_simple_matrix<int>(Comm, K, gensize, false, verbose);
}
else {
printf("YOU SHOULDN'T BE HERE \n");
exit(-1);
}
if (verbose && (K->NumGlobalRows64() < TINYMATRIX)) {
if (MyPID == 0) cout << "Input matrix: " << endl;
K->Print(cout);
}
Teuchos::RCP<Epetra_CrsMatrix> rcpK = Teuchos::rcp( K );
// Set Anasazi verbosity level
if (MyPID == 0) cout << "Setting up the problem..." << endl;
int anasazi_verbosity = Anasazi::Errors + Anasazi::Warnings;
if (verbosity >= 1) // low
anasazi_verbosity += Anasazi::FinalSummary + Anasazi::TimingDetails;
if (verbosity >= 2) // medium
anasazi_verbosity += Anasazi::IterationDetails;
if (verbosity >= 3) // high
anasazi_verbosity += Anasazi::StatusTestDetails
+ Anasazi::OrthoDetails
+ Anasazi::Debug;
// Create parameter list to pass into solver
Teuchos::ParameterList MyPL;
MyPL.set("Verbosity", anasazi_verbosity);
MyPL.set("Which", which);
MyPL.set("Convergence Tolerance", tol);
MyPL.set("Relative Convergence Tolerance", relconvtol);
MyPL.set("Orthogonalization", ortho);
// For the following, use Anasazi's defaults unless explicitly specified.
if (numblocks > 0) MyPL.set( "Num Blocks", numblocks);
if (maxrestarts > 0) MyPL.set( "Maximum Restarts", maxrestarts);
if (maxiterations > 0) MyPL.set( "Maximum Iterations", maxiterations);
if (blockSize > 0) MyPL.set( "Block Size", blockSize );
typedef Epetra_MultiVector MV;
typedef Epetra_Operator OP;
typedef Anasazi::MultiVecTraits<double, MV> MVT;
typedef Anasazi::OperatorTraits<double, MV, OP> OPT;
// Create the eigenproblem to be solved.
// Dummy initial vectors - will be set later.
Teuchos::RCP<Epetra_MultiVector> ivec =
Teuchos::rcp(new Epetra_MultiVector(K->Map(), blockSize));
Teuchos::RCP<Anasazi::BasicEigenproblem<double, MV, OP> > MyProblem;
MyProblem =
Teuchos::rcp(new Anasazi::BasicEigenproblem<double, MV, OP>(rcpK, ivec) );
// Inform the eigenproblem whether K is Hermitian
MyProblem->setHermitian(isHermitian);
// Set the number of eigenvalues requested
MyProblem->setNEV(nev);
// Loop to solve the same eigenproblem numtrial times (different initial vectors)
int numfailed = 0;
int iter = 0;
double solvetime = 0;
// Set random seed to have consistent initial vectors between
// experiments. Different seed in each loop iteration.
ivec->SetSeed(2*(MyPID) +1); // Odd seed
// Set up initial vectors
// Using random values as the initial guess.
if (initvec == "random"){
MVT::MvRandom(*ivec);
}
else if (initvec == "zero"){
// All zero initial vector should be essentially the same,
// but appears slightly worse in practice.
ivec->PutScalar(0.);
}
else if (initvec == "unit"){
// Orthogonal unit initial vectors.
ivec->PutScalar(0.);
for (int i = 0; i < blockSize; i++)
ivec->ReplaceGlobalValue(i,i,1.);
}
else if (initvec == "random2"){
// Partially random but orthogonal (0,1) initial vectors.
// ivec(i,*) is zero in all but one column (for each i)
// Inefficient implementation but this is only done once...
double rowmax;
int col;
ivec->Random();
for (int i = 0; i < ivec->MyLength(); i++){
rowmax = -1;
col = -1;
for (int j = 0; j < blockSize; j++){
// Make ivec(i,j) = 1 for largest random value in row i
if ((*ivec)[j][i] > rowmax){
rowmax = (*ivec)[j][i];
col = j;
}
ivec->ReplaceMyValue(i,j,0.);
}
ivec->ReplaceMyValue(i,col,1.);
}
}
else
cout << "ERROR: Unknown value for initial vectors." << endl;
if (verbose && (ivec->GlobalLength64() < TINYMATRIX))
ivec->Print(std::cout);
// Inform the eigenproblem that you are finished passing it information
bool boolret = MyProblem->setProblem();
if (boolret != true) {
if (verbose && MyPID == 0) {
cout << "Anasazi::BasicEigenproblem::setProblem() returned with error."
<< endl;
}
FINALIZE;
return -1;
}
Teuchos::RCP<Anasazi::SolverManager<double, MV, OP> > MySolverMgr;
if (method == "BKS") {
// Initialize the Block Arnoldi solver
MyPL.set("Extra NEV Blocks", extrablocks);
MySolverMgr = Teuchos::rcp( new Anasazi::BlockKrylovSchurSolMgr<double, MV, OP>(MyProblem,MyPL) );
}
else if (method == "BD") {
// Initialize the Block Davidson solver
MyPL.set("Use Locking", lock);
MyPL.set("Relative Locking Tolerance", rellocktol);
MySolverMgr = Teuchos::rcp( new Anasazi::BlockDavidsonSolMgr<double, MV, OP>(MyProblem, MyPL) );
}
else if (method == "LOBPCG") {
// Initialize the LOBPCG solver
MyPL.set("Use Locking", lock);
MyPL.set("Relative Locking Tolerance", rellocktol);
MySolverMgr = Teuchos::rcp( new Anasazi::LOBPCGSolMgr<double, MV, OP>(MyProblem, MyPL) );
}
else if (method == "IRTR") {
// Initialize the IRTR solver
MySolverMgr = Teuchos::rcp( new Anasazi::RTRSolMgr<double, MV, OP>(MyProblem, MyPL) );
}
else
cout << "Unknown solver method!" << endl;
if (verbose && MyPID==0) MyPL.print(cout);
// Solve the problem to the specified tolerances or length
if (MyPID == 0) cout << "Beginning the " << method << " solve..." << endl;
Anasazi::ReturnType returnCode = MySolverMgr->solve();
if (returnCode != Anasazi::Converged && MyPID==0) {
++numfailed;
cout << "Anasazi::SolverManager::solve() returned unconverged." << endl;
}
iter = MySolverMgr->getNumIters();
solvetime = (MySolverMgr->getTimers()[0])->totalElapsedTime();
if (MyPID == 0) {
cout << "Iterations in this solve: " << iter << endl;
cout << "Solve complete; beginning post-processing..."<< endl;
}
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<double,MV> sol = MyProblem->getSolution();
std::vector<Anasazi::Value<double> > evals = sol.Evals;
Teuchos::RCP<MV> evecs = sol.Evecs;
std::vector<int> index = sol.index;
int numev = sol.numVecs;
// Compute residuals.
if (numev > 0) {
Teuchos::LAPACK<int,double> lapack;
std::vector<double> normR(numev);
if (MyProblem->isHermitian()) {
// Get storage
Epetra_MultiVector Kevecs(K->Map(),numev);
Teuchos::RCP<Epetra_MultiVector> Mevecs;
Teuchos::SerialDenseMatrix<int,double> B(numev,numev);
B.putScalar(0.0);
for (int i=0; i<numev; i++) {B(i,i) = evals[i].realpart;}
// Compute A*evecs
OPT::Apply( *rcpK, *evecs, Kevecs );
Mevecs = evecs;
// Compute A*evecs - lambda*evecs and its norm
MVT::MvTimesMatAddMv( -1.0, *Mevecs, B, 1.0, Kevecs );
MVT::MvNorm( Kevecs, normR );
// Scale the norms by the eigenvalue if relative convergence tol was used
if (relconvtol) {
for (int i=0; i<numev; i++)
normR[i] /= Teuchos::ScalarTraits<double>::magnitude(evals[i].realpart);
}
} else {
printf("The problem isn't non-Hermitian; sorry.\n");
exit(-1);
}
if (verbose && MyPID==0) {
cout.setf(std::ios_base::right, std::ios_base::adjustfield);
cout<<endl<< "Actual Results"<<endl;
if (MyProblem->isHermitian()) {
cout<< std::setw(16) << "Eigenvalue "
<< std::setw(20) << "Direct Residual"
<< (relconvtol?" (normalized by eigenvalue)":" (no normalization)")
<< endl;
cout<<"--------------------------------------------------------"<<endl;
for (int i=0; i<numev; i++) {
cout<< "EV" << i << std::setw(16) << evals[i].realpart
<< std::setw(20) << normR[i] << endl;
}
cout<<"--------------------------------------------------------"<<endl;
}
else {
cout<< std::setw(16) << "Real Part"
<< std::setw(16) << "Imag Part"
<< std::setw(20) << "Direct Residual"<< endl;
cout<<"--------------------------------------------------------"<<endl;
for (int i=0; i<numev; i++) {
cout<< std::setw(16) << evals[i].realpart
<< std::setw(16) << evals[i].imagpart
<< std::setw(20) << normR[i] << endl;
}
cout<<"--------------------------------------------------------"<<endl;
}
}
}
// Summarize iteration counts and solve time
if (MyPID == 0) {
cout << endl;
cout << "DRIVER SUMMARY" << endl;
cout << "Failed to converge: " << numfailed << endl;
cout << "Solve time: " << solvetime << endl;
}
FINALIZE;
if (numfailed) {
if (MyPID == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return -1;
}
//
// Default return value
//
if (MyPID == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
Teuchos::GlobalMPISession mpiSession(&argc, &argv, 0);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
int nProcs, myPID ;
Teuchos::ParameterList pLUList ; // ParaLU parameters
Teuchos::ParameterList isoList ; // Isorropia parameters
string ipFileName = "ShyLU.xml"; // TODO : Accept as i/p
nProcs = mpiSession.getNProc();
myPID = Comm.MyPID();
if (myPID == 0)
{
cout <<"Parallel execution: nProcs="<< nProcs << endl;
}
// =================== Read input xml file =============================
Teuchos::updateParametersFromXmlFile(ipFileName, &pLUList);
isoList = pLUList.sublist("Isorropia Input");
// Get matrix market file name
string MMFileName = Teuchos::getParameter<string>(pLUList, "mm_file");
string prec_type = Teuchos::getParameter<string>(pLUList, "preconditioner");
if (myPID == 0)
{
cout << "Input :" << endl;
cout << "ParaLU params " << endl;
pLUList.print(std::cout, 2, true, true);
cout << "Matrix market file name: " << MMFileName << endl;
}
// ==================== Read input Matrix ==============================
Epetra_CrsMatrix *A;
int err = EpetraExt::MatrixMarketFileToCrsMatrix(MMFileName.c_str(), Comm, A);
//EpetraExt::MatlabFileToCrsMatrix(MMFileName.c_str(), Comm, A);
//assert(err != 0);
cout <<"Done reading the matrix"<< endl;
int n = A->NumGlobalRows();
cout <<"n="<< n << endl;
// Create input vectors
Epetra_Map vecMap(n, 0, Comm);
Epetra_MultiVector x(vecMap, 1);
Epetra_MultiVector b(vecMap, 1, false);
b.PutScalar(1.0); // TODO : Accept it as input
// Partition the matrix with hypergraph partitioning and redisstribute
Isorropia::Epetra::Partitioner *partitioner = new
Isorropia::Epetra::Partitioner(A, isoList, false);
partitioner->partition();
Isorropia::Epetra::Redistributor rd(partitioner);
Epetra_CrsMatrix *newA;
Epetra_MultiVector *newX, *newB;
rd.redistribute(*A, newA);
delete A;
A = newA;
rd.redistribute(x, newX);
rd.redistribute(b, newB);
Epetra_LinearProblem problem(A, newX, newB);
Amesos Factory;
char* SolverType = "Amesos_Klu";
bool IsAvailable = Factory.Query(SolverType);
Epetra_LinearProblem *LP = new Epetra_LinearProblem();
LP->SetOperator(A);
LP->SetLHS(newX);
LP->SetRHS(newB);
Amesos_BaseSolver *Solver = Factory.Create(SolverType, *LP);
Solver->SymbolicFactorization();
Teuchos::Time ftime("setup time");
ftime.start();
Solver->NumericFactorization();
cout << "Numeric Factorization" << endl;
Solver->Solve();
cout << "Solve done" << endl;
ftime.stop();
cout << "Time to setup" << ftime.totalElapsedTime() << endl;
// compute ||Ax - b||
double Norm;
Epetra_MultiVector Ax(vecMap, 1);
Epetra_MultiVector *newAx;
rd.redistribute(Ax, newAx);
A->Multiply(false, *newX, *newAx);
newAx->Update(1.0, *newB, -1.0);
newAx->Norm2(&Norm);
double ANorm = A->NormOne();
cout << "|Ax-b |/|A| = " << Norm/ANorm << endl;
delete newAx;
delete newX;
delete newB;
delete A;
delete partitioner;
}
int main( int argc, char* argv[] )
{
using Teuchos::inoutArg;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
std::cout << std::endl << Teuchos::Teuchos_Version() << std::endl;
bool success = true;
try {
std::string xmlInFileName = "";
std::string extraXmlFile = "";
std::string xmlOutFileName = "paramList.out";
Teuchos::CommandLineProcessor clp(false); // Don't throw exceptions
clp.setOption("xml-in-file",&xmlInFileName,"The XML file to read into a parameter list");
clp.setOption("extra-xml-file",&extraXmlFile,"File with extra XML text that will modify the initial XML read in");
clp.setOption("xml-out-file",&xmlOutFileName,"The XML file to write the final parameter list to");
clp.setDocString(
"This example program shows how to read in a parameter list from an"
" XML file (given by --xml-in-file=xmlInFileName) and then modify it"
" given some XML specified on the command-line (given by --extra-xml=extrXmlStr)."
" The final parameter list is then written back to an XML file."
" (given by --xml-out-file=xmlOutFileName)."
);
Teuchos::CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv);
if( parse_return != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL ) {
std::cout << "\nEnd Result: TEST FAILED" << std::endl;
return parse_return;
}
Teuchos::ParameterList paramList;
if(xmlInFileName.length()) {
std::cout << "\nReading a parameter list from the XML file \""<<xmlInFileName<<"\" ...\n";
Teuchos::updateParametersFromXmlFile(xmlInFileName, inoutArg(paramList));
std::cout << "\nParameter list read from the XML file \""<<xmlInFileName<<"\":\n\n";
paramList.print(std::cout,2,true,true);
}
std::string line("");
if(extraXmlFile.length()) {
std::ifstream myfile(extraXmlFile.c_str());
if (myfile.is_open())
{
getline (myfile,line);
std::cout << line << "\n";
myfile.close();
}
std::cout << "\nUpdating the parameter list given the extra XML std::string:\n\n"<<line<<"\n";
Teuchos::updateParametersFromXmlString(line, inoutArg(paramList));
std::cout << "\nParameter list after ammending extra XML std::string:\n\n";
paramList.print(std::cout,2,true,true);
}
std::cout << "\nWriting the final parameter list back to the XML file \""<<xmlOutFileName<<"\" ... \n";
Teuchos::writeParameterListToXmlFile(paramList,xmlOutFileName);
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,std::cerr,success);
if(success)
std::cout << "\nEnd Result: TEST PASSED" << std::endl;
else
std::cout << "\nEnd Result: TEST FAILED" << std::endl;
return ( success ? 0 : 1 );
}
Teuchos::RCP< std::vector< Teuchos::RCP<PHX::Evaluator<panzer::Traits> > > >
Example::ModelFactory<EvalT>::
buildClosureModels(const std::string& model_id,
const Teuchos::ParameterList& models,
const panzer::FieldLayoutLibrary& fl,
const Teuchos::RCP<panzer::IntegrationRule>& ir,
const Teuchos::ParameterList& default_params,
const Teuchos::ParameterList& user_data,
const Teuchos::RCP<panzer::GlobalData>& global_data,
PHX::FieldManager<panzer::Traits>& fm) const
{
using std::string;
using std::vector;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using PHX::Evaluator;
RCP< vector< RCP<Evaluator<panzer::Traits> > > > evaluators =
rcp(new vector< RCP<Evaluator<panzer::Traits> > > );
if (!models.isSublist(model_id)) {
models.print(std::cout);
std::stringstream msg;
msg << "Falied to find requested model, \"" << model_id
<< "\", for equation set:\n" << std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!models.isSublist(model_id), std::logic_error, msg.str());
}
std::vector<Teuchos::RCP<const panzer::PureBasis> > bases;
fl.uniqueBases(bases);
const ParameterList& my_models = models.sublist(model_id);
for (ParameterList::ConstIterator model_it = my_models.begin();
model_it != my_models.end(); ++model_it) {
bool found = false;
const std::string key = model_it->first;
ParameterList input;
const Teuchos::ParameterEntry& entry = model_it->second;
const ParameterList& plist = Teuchos::getValue<Teuchos::ParameterList>(entry);
if (plist.isType<double>("Value")) {
{ // at IP
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
input.set("Data Layout", ir->dl_scalar);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Constant<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
for (std::vector<Teuchos::RCP<const panzer::PureBasis> >::const_iterator basis_itr = bases.begin();
basis_itr != bases.end(); ++basis_itr) { // at BASIS
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
Teuchos::RCP<const panzer::BasisIRLayout> basis = basisIRLayout(*basis_itr,*ir);
input.set("Data Layout", basis->functional);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Constant<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (plist.isType<std::string>("Type")) {
const std::string type = plist.get<std::string>("Type");
if (type == "SIMPLE SOURCE") {
RCP<Evaluator<panzer::Traits> > e = rcp(new Example::SimpleSource<EvalT,panzer::Traits>(key, *ir));
evaluators->push_back(e);
found = true;
} else if (type == "EXACT") {
RCP<Evaluator<panzer::Traits> > e = rcp(new Example::Solution<EvalT,panzer::Traits>(key, *ir));
evaluators->push_back(e);
found = true;
} else if (type == "EXACT nonlinear Robin") {
RCP<Evaluator<panzer::Traits> > e = rcp(new Example::Solution<EvalT,panzer::Traits>(key, *ir, false));
evaluators->push_back(e);
found = true;
} else if (type == "ERROR_CALC") {
{
std::vector<std::string> values(2);
values[0] = plist.get<std::string>("Field A");
values[1] = plist.get<std::string>("Field B");
std::vector<double> scalars(2);
scalars[0] = 1.0;
scalars[1] = -1.0;
Teuchos::ParameterList p;
p.set("Sum Name", key + "_DIFF");
p.set<RCP<std::vector<std::string> > >("Values Names", Teuchos::rcpFromRef(values));
p.set<RCP<const std::vector<double> > >("Scalars", Teuchos::rcpFromRef(scalars));
p.set("Data Layout", ir->dl_scalar);
RCP<Evaluator<panzer::Traits> > e = rcp(new panzer::Sum<EvalT,panzer::Traits>(p));
evaluators->push_back(e);
}
{
std::vector<std::string> values(2);
values[0] = key + "_DIFF";
values[1] = key + "_DIFF";
Teuchos::ParameterList p;
p.set("Product Name",key);
p.set<RCP<std::vector<std::string> > >("Values Names",Teuchos::rcpFromRef(values));
p.set("Data Layout",ir->dl_scalar);
RCP<Evaluator<panzer::Traits> > e = rcp(new panzer::Product<EvalT,panzer::Traits>(p));
evaluators->push_back(e);
}
found = true;
}
}
if ( ! found) {
std::stringstream msg;
msg << "ClosureModelFactory failed to build evaluator for key \"" << key
<< "\"\nin model \"" << model_id
<< "\". Please correct the type or add support to the \nfactory." <<std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!found, std::logic_error, msg.str());
}
}
return evaluators;
}
Teuchos::RCP< std::vector< Teuchos::RCP<PHX::Evaluator<panzer::Traits> > > >
user_app::MyModelFactory_Physics1<EvalT>::
buildClosureModels(const std::string& model_id,
const Teuchos::ParameterList& models,
const panzer::FieldLayoutLibrary& fl,
const Teuchos::RCP<panzer::IntegrationRule>& ir,
const Teuchos::ParameterList& default_params,
const Teuchos::ParameterList& user_data,
const Teuchos::RCP<panzer::GlobalData>& global_data,
PHX::FieldManager<panzer::Traits>& fm) const
{
using std::string;
using std::vector;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using PHX::Evaluator;
RCP< vector< RCP<Evaluator<panzer::Traits> > > > evaluators =
rcp(new vector< RCP<Evaluator<panzer::Traits> > > );
if (!models.isSublist(model_id)) {
models.print(std::cout);
std::stringstream msg;
msg << "Falied to find requested model, \"" << model_id
<< "\", for equation set:\n" << std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!models.isSublist(model_id), std::logic_error, msg.str());
}
const ParameterList& my_models = models.sublist(model_id);
for (ParameterList::ConstIterator model_it = my_models.begin();
model_it != my_models.end(); ++model_it) {
bool found = false;
const std::string key = model_it->first;
ParameterList input;
const Teuchos::ParameterEntry& entry = model_it->second;
const ParameterList& plist = Teuchos::getValue<Teuchos::ParameterList>(entry);
if (plist.isType<double>("Value")) {
// at IP
{
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
input.set("Data Layout", ir->dl_scalar);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Constant<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
// at BASIS
std::vector<Teuchos::RCP<const panzer::PureBasis> > bases;
fl.uniqueBases(bases);
for (std::vector<Teuchos::RCP<const panzer::PureBasis> >::const_iterator basis_itr = bases.begin();
basis_itr != bases.end(); ++basis_itr) {
input.set("Name", key);
input.set("Value", plist.get<double>("Value"));
Teuchos::RCP<const panzer::BasisIRLayout> basis = basisIRLayout(*basis_itr,*ir);
input.set("Data Layout", basis->functional);
RCP< Evaluator<panzer::Traits> > e =
rcp(new panzer::Constant<EvalT,panzer::Traits>(input));
evaluators->push_back(e);
}
found = true;
}
if (!found && m_throw_if_model_not_found) {
std::stringstream msg;
msg << "ClosureModelFactory failed to build evaluator for key \"" << key
<< "\"\nin model \"" << model_id
<< "\". Please correct the type or add support to the \nfactory." <<std::endl;
TEUCHOS_TEST_FOR_EXCEPTION(!found, std::logic_error, msg.str());
}
}
return evaluators;
}
