Aeras::ShallowWaterResponseL2Error<EvalT, Traits>::
ShallowWaterResponseL2Error(Teuchos::ParameterList& p,
const Teuchos::RCP<Albany::Layouts>& dl) :
sphere_coord("Lat-Long", dl->qp_gradient),
weighted_measure("Weights", dl->qp_scalar),
flow_state_field("Flow State", dl->node_vector),
BF("BF",dl->node_qp_scalar)
{
Teuchos::RCP<Teuchos::FancyOStream> out(Teuchos::VerboseObjectBase::getDefaultOStream());
// get and validate Response parameter list
Teuchos::ParameterList* plist =
p.get<Teuchos::ParameterList*>("Parameter List");
Teuchos::RCP<const Teuchos::ParameterList> reflist =
this->getValidResponseParameters();
plist->validateParameters(*reflist,0);
std::string fieldName = "Flow Field"; //field to integral is the flow field
// coordinate dimensions
std::vector<PHX::DataLayout::size_type> coord_dims;
dl->qp_vector->dimensions(coord_dims);
numQPs = coord_dims[1]; //# quad points
numDims = coord_dims[2]; //# spatial dimensions
std::vector<PHX::DataLayout::size_type> dims;
flow_state_field.fieldTag().dataLayout().dimensions(dims);
vecDim = dims[2]; //# dofs per node
numNodes = dims[1]; //# nodes per element
// User-specified parameters
refSolName = plist->get<std::string>("Reference Solution Name"); //no reference solution by default.
*out << "Reference Solution Name for Aeras::ShallowWaterResponseL2Error response: " << refSolName << std::endl;
inputData = plist->get<double>("Reference Solution Data", 0.0);
if (refSolName == "Zero")
ref_sol_name = ZERO;
else if (refSolName == "TC2")
ref_sol_name = TC2;
//Add other test case reference solutions here...
else if (refSolName == "TC4"){
ref_sol_name = TC4;
myPi = Aeras::ShallowWaterConstants::self().pi;
earthRadius = Aeras::ShallowWaterConstants::self().earthRadius;
gravity = Aeras::ShallowWaterConstants::self().gravity;
Omega = 2.0*myPi/(24.*3600.); //this should be sitting in SW Constants class
rlon0 = 0.;
rlat0 = myPi/4.;
npwr = 14.;
su0 = 20.;
phi0 = 1.0e5;
alfa = -0.03*(phi0/(2.*Omega*sin(myPi/4.)));
sigma = (2.*earthRadius/1.0e6)*(2.*earthRadius/1.0e6);
}
else {
TEUCHOS_TEST_FOR_EXCEPTION(
true, Teuchos::Exceptions::InvalidParameter,
std::endl << "Error! Unknown reference solution name " << ref_sol_name <<
"!" << std::endl;);
}
Teuchos::ParameterList Ifpack_GetValidParameters()
{
Teuchos::ParameterList List; // empty list
// ============================================================ //
// Parameters are reported from each used file in IFPACK. Files //
// are listed in alphabetical order, first all *.cpp, then *.h. //
// Some options not very tested or documented anywhere //
// are not reported here. //
// ============================================================ //
// Ifpack_Amesos.cpp
List.set("amesos: solver type", "Amesos_Klu");
// Ifpack_IC.cpp
List.set("fact: level-of-fill", (int)1);
List.set("fact: absolute threshold", (double)0.0);
List.set("fact: relative threshold", (double)0.0);
List.set("fact: drop tolerance", (double)0.0);
// Ifpack_ICT.cpp
List.set("fact: ict level-of-fill", (double)1.0);
List.set("fact: absolute threshold", (double)0.0);
List.set("fact: relative threshold", (double)1.0);
List.set("fact: relax value", (double)0.0);
List.set("fact: drop tolerance", (double)0.0);
// Ifpack_ILU.cpp
List.set("fact: level-of-fill", (int)0);
List.set("fact: absolute threshold", (double)0.0);
List.set("fact: relative threshold", (double)1.0);
List.set("fact: relax value", (double)0.0);
// Ifpack_ILUT.cpp
List.set("fact: ilut level-of-fill", (double)1.0);
List.set("fact: absolute threshold", (double)0.0);
List.set("fact: relative threshold", (double)1.0);
List.set("fact: relax value", (double)0.0);
#ifdef HAVE_IFPACK_SUPERLU
// Ifpack_SILU.cpp
List.set("fact: drop tolerance",1e-4);
List.set("fact: zero pivot threshold",1e-2);
List.set("fact: maximum fill factor",10.0);
List.set("fact: silu drop rule",9);
#endif
// Ifpack_METISPartitioner.cpp
List.set("partitioner: local parts", (int)1);
List.set("partitioner: overlap", (int)0);
List.set("partitioner: print level", (int)0);
// Ifpack_PointRelaxation.cpp
List.set("relaxation: type", "Jacobi");
List.set("relaxation: sweeps", (int)1);
List.set("relaxation: damping factor", (double)1.0);
List.set("relaxation: min diagonal value", (double)1.0);
List.set("relaxation: zero starting solution", true);
List.set("relaxation: backward mode",false);
List.set("relaxation: use l1",false);
List.set("relaxation: l1 eta",(double)1.5);
// Ifpack_SPARSKIT.cpp
List.set("fact: sparskit: lfil", (int)0);
List.set("fact: sparskit: tol", (double)0.0);
List.set("fact: sparskit: droptol", (double)0.0);
List.set("fact: sparskit: permtol", (double)0.1);
List.set("fact: sparskit: alph", (double)0.0);
List.set("fact: sparskit: mbloc", (int)(-1));
List.set("fact: sparskit: type", ("ILUT"));
// Additive Schwarz preconditioner
List.set("schwarz: compute condest", true);
List.set("schwarz: combine mode", "Zero"); // use std::string mode for this
List.set("schwarz: reordering type", "none");
List.set("schwarz: filter singletons", false);
// Ifpack_BlockRelaxation.h
// List.set("relaxation: type", "Jacobi"); // already set
// List.set("relaxation: sweeps", 1); // already set
// List.get("relaxation: damping factor", 1.0); // already set
// List.get("relaxation: zero starting solution", true); // already set
List.set("partitioner: type", "greedy");
List.set("partitioner: local parts", (int)1);
List.set("partitioner: overlap", (int)0);
// Ifpack_METISPartitioner.h
List.set("partitioner: use symmetric graph", true);
// Krylov smoother
List.set("krylov: iterations",(int)5);
List.set("krylov: tolerance",(double)0.001);
List.set("krylov: solver",(int)1);
List.set("krylov: preconditioner",(int)0);
List.set("krylov: number of sweeps",(int)1);
List.set("krylov: block size",(int)1);
List.set("krylov: damping parameter",(double)1.0);
List.set("krylov: zero starting solution",true);
return(List);
}
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// this example is in serial only
if (Comm.NumProc()>1) exit(0);
FileGrid Grid(Comm, "Hex_3D.grid");
// create a list of all nodes that are linked to a face
// we have 4 interfaces here with each 2 sides:
// with tags 1/2, 11/12, 21/22, 31/32
const int ninter = 4;
vector<map<int,int> > nodes(ninter*2);
for (int i=0; i<Grid.NumMyBoundaryFaces(); ++i)
{
int tag;
int nodeids[4];
Grid.FaceVertices(i,tag,nodeids);
if (tag==1)
{
for (int j=0; j<4; ++j)
nodes[0][nodeids[j]] = nodeids[j];
}
else if (tag==2)
{
for (int j=0; j<4; ++j)
nodes[1][nodeids[j]] = nodeids[j];
}
else if (tag==11)
{
for (int j=0; j<4; ++j)
nodes[2][nodeids[j]] = nodeids[j];
}
else if (tag==12)
{
for (int j=0; j<4; ++j)
nodes[3][nodeids[j]] = nodeids[j];
}
else if (tag==21)
{
for (int j=0; j<4; ++j)
nodes[4][nodeids[j]] = nodeids[j];
}
else if (tag==22)
{
for (int j=0; j<4; ++j)
nodes[5][nodeids[j]] = nodeids[j];
}
else if (tag==31)
{
for (int j=0; j<4; ++j)
nodes[6][nodeids[j]] = nodeids[j];
}
else if (tag==32)
{
for (int j=0; j<4; ++j)
nodes[7][nodeids[j]] = nodeids[j];
}
else
continue;
}
// ------------------------------------------------------------- //
// create 4 empty MOERTEL::Interface instances
// ------------------------------------------------------------- //
int printlevel = 3; // ( moertel takes values 0 - 10 )
//int printlevel = 8; // ( moertel takes values 0 - 10 ) // GAH gives info about intersection root finding
vector<RefCountPtr<MOERTEL::Interface> > interfaces(ninter);
for (int i=0; i<ninter; ++i)
interfaces[i] = rcp(new MOERTEL::Interface(i,false,Comm,printlevel));
// ------------------------------------------------------------- //
// Add nodes on both sides of interface to interfaces
// loop all nodes in the maps add them
// to the interface with unique ids
// ------------------------------------------------------------- //
for (int i=0; i<ninter; ++i)
{
map<int,int>::iterator curr;
for (int j=0; j<2; ++j)
for (curr = nodes[i*2+j].begin(); curr != nodes[i*2+j].end(); ++curr)
{
// get unique node id
int nodeid = curr->second;
// get node coordinates
double coord[3];
Grid.VertexCoord(nodeid,coord);
// create a moertel node
MOERTEL::Node node(nodeid,coord,1,&nodeid,false,printlevel);
// add node to interface i on side j
interfaces[i]->AddNode(node,j);
}
}
// ------------------------------------------------------------- //
// add segments on both sides of the interface to the interface
// ------------------------------------------------------------- //
for (int i=0; i<Grid.NumMyBoundaryFaces(); ++i)
{
int tag;
int nodeids[4];
Grid.FaceVertices(i,tag,nodeids);
if (tag == 0)
continue;
// create a segment (galeri calls it a face)
MOERTEL::Segment_BiLinearQuad segment(i,4,nodeids,printlevel);
if (tag==1)
interfaces[0]->AddSegment(segment,0);
else if (tag==2)
interfaces[0]->AddSegment(segment,1);
else if (tag==11)
interfaces[1]->AddSegment(segment,0);
else if (tag==12)
interfaces[1]->AddSegment(segment,1);
else if (tag==21)
interfaces[2]->AddSegment(segment,0);
else if (tag==22)
interfaces[2]->AddSegment(segment,1);
else if (tag==31)
interfaces[3]->AddSegment(segment,0);
else if (tag==32)
interfaces[3]->AddSegment(segment,1);
else
{
cout << "Face with unknown tag " << tag << endl;
exit(EXIT_FAILURE);
}
}
// ------------------------------------------------------------- //
// choose the mortar side of the interface (0 or 1)
// choose the finer side here, which is 0
// ------------------------------------------------------------- //
for (int i=0; i<ninter; ++i)
interfaces[i]->SetMortarSide(0);
// ------------------------------------------------------------- //
// As we do not know the mortar side yet (we decided to le the
// package choose it), we can not set a dual trace function (mortar space)
// as we don't know the side to set it to
// so we just give orders for the function type
// ------------------------------------------------------------- //
for (int i=0; i<ninter; ++i)
interfaces[i]->SetFunctionTypes(MOERTEL::Function::func_BiLinearQuad, // primal trace space
MOERTEL::Function::func_DualBiLinearQuad); // dual mortar space (recommended)
//MOERTEL::Function::func_BiLinearQuad); // mortar space (not recommended)
// ------------------------------------------------------------- //
// complete the interfaces
// ------------------------------------------------------------- //
for (int i=0; i<ninter; ++i)
if (!interfaces[i]->Complete())
{
cout << "Interface " << i << " completion returned false\n";
exit(EXIT_FAILURE);
}
// ------------------------------------------------------------- //
// create an empty MOERTEL::Manager for 3D problems
// It organizes everything from integration to solution
// ------------------------------------------------------------- //
MOERTEL::Manager manager(Comm,MOERTEL::Manager::manager_3D,printlevel);
// ------------------------------------------------------------- //
// Add the interfaces to the manager
// ------------------------------------------------------------- //
for (int i=0; i<ninter; ++i)
manager.AddInterface(*(interfaces[i]));
// ------------------------------------------------------------- //
// for mortar integration, the mortar manager needs to know about
// the rowmap of the original (uncoupled) problem because it will
// create coupling matrices D and M matching that rowmap
// ------------------------------------------------------------- //
manager.SetProblemMap(&Grid.RowMap());
// ============================================================= //
// choose integration parameters
// ============================================================= //
Teuchos::ParameterList& moertelparams = manager.Default_Parameters();
// this does affect this 3D case only
moertelparams.set("exact values at gauss points",true);
// 1D interface possible values are 1,2,3,4,5,6,7,8,10 (2 recommended with linear shape functions)
moertelparams.set("number gaussian points 1D",2);
// 2D interface possible values are 3,6,12,13,16,19,27 (12 recommended with linear functions)
moertelparams.set("number gaussian points 2D",12);
// ============================================================= //
// Here we are done with the construction phase of the interface
// so we can integrate the mortar integrals
// (Note we have not yet evaluated the PDE at all!)
// ============================================================= //
manager.Mortar_Integrate();
// print interface information
// (Manager, Interface, Segment, Node implement the << operator)
if (printlevel) cout << manager;
// ======================================================== //
// Prepares the linear system. This requires the definition //
// of a quadrature formula compatible with the grid, a //
// variational formulation, and a problem object which take //
// care of filling matrix and right-hand side. //
// NOTE:
// we are doing this AFTER we did all the mortar stuff to
// show that the mortar integration is actually PDE-independent
// ======================================================== //
Epetra_CrsMatrix A(Copy, Grid.RowMap(), 0);
Epetra_Vector LHS(Grid.RowMap(),true);
Epetra_Vector RHS(Grid.RowMap());
int NumQuadratureNodes = 8;
GalerkinVariational<HexQuadrature>
Laplace3D(NumQuadratureNodes, Diffusion, Source, Force,
BoundaryValue, BoundaryType);
LinearProblem FiniteElementProblem(Grid, Laplace3D, A, LHS, RHS);
FiniteElementProblem.Compute();
// ============================================================= //
// this is Galeri's dense solve method if you'd like to see how
// the uncoupled solution looks like
// ============================================================= //
//Solve(&A, &LHS, &RHS);
// ============================================================= //
// Since we now have all the pieces together, let's use the
// MOERTEL interface to other Trilinos packages to solve the
// problem
// ============================================================= //
// ------------------------------------------------------------- //
// Create a Teuchos::ParameterList to hold solver arguments and also
// to hold arguments for connected packages AztecOO, ML and Amesos
// ------------------------------------------------------------- //
Teuchos::ParameterList list;
// ------------------------------------------------------------- //
// Choose which type of system of equations to generate
// Note that only when using DUAL mortar spaces an spd system
// can be generated
// ------------------------------------------------------------- //
//list.set("System","SaddleSystem");
list.set("System","SPDSystem");
// ------------------------------------------------------------- //
// choose solver, currently there is a choice of Amesos and ML/AztecOO
// Note that if "SaddleSystem" was chosen as system of equations
// ML/AztecOO doesn't work
// ------------------------------------------------------------- //
list.set("Solver","Amesos");
//list.set("Solver","ML/Aztec"); // GAH Aztec not working FIX
// ------------------------------------------------------------- //
// create sublists for packages Amesos, ML, AztecOO. they will be
// passed on to the individual package that is used
// ------------------------------------------------------------- //
// Amesos parameters:
Teuchos::ParameterList& amesosparams = list.sublist("Amesos");
amesosparams.set("Solver","Amesos_Klu");
amesosparams.set("PrintTiming",true);
amesosparams.set("PrintStatus",true);
amesosparams.set("UseTranspose",true);
// AztecOO parameters
Teuchos::ParameterList& aztecparams = list.sublist("Aztec");
aztecparams.set("AZ_solver","AZ_cg");
// This will involve ML as preconditioner
// See the AztecOO manual for other options
aztecparams.set("AZ_precond","AZ_user_precond");
aztecparams.set("AZ_max_iter",1200);
aztecparams.set("AZ_output",100);
aztecparams.set("AZ_tol",1.0e-7);
aztecparams.set("AZ_scaling","AZ_none");
// ML parameters
// As Moertel comes with his own special mortar multigrid hierachy
// based on ML's smoothed aggregation, not all ML parameters are recognized
// It basically recognizes everything that recognized by ML's MLAPI
// (ML Application Programming Interface), see MLAPI documentation
Teuchos::ParameterList& mlparams = list.sublist("ML");
ML_Epetra::SetDefaults("SA",mlparams);
mlparams.set("output",10);
mlparams.set("print unused",1/*-2*/);
mlparams.set("PDE equations",1);
mlparams.set("max levels",10);
mlparams.set("coarse: max size",500);
mlparams.set("aggregation: type","Uncoupled");
mlparams.set("aggregation: damping factor",1.33);
// original : The unmodified ML (smoothed) aggregation prolongator
// mod_simple : ( R * (I-B*W^T) )^T
// mod_middle : ( (I - R B*W^T*P) * R * (I-B*W^T) )^T
// mod_full : ( (I - R B*W^T*P) * R * (I-B*W^T) )^T + ( R B*W^T*P * R * B*W^T )^T
mlparams.set("prolongator: type","mod_full");
// solvers/smoothers currently recognized by the MLAPI_InverseOperator are
// Ifpack:
// "Jacobi" "Gauss-Seidel" "symmetric Gauss-Seidel"
// "ILU" "ILUT" "IC" "ICT" "LU" "Amesos" "Amesos-KLU"
// and accompanying parameters as listed
// ML:
// "MLS" "ML MLS" "ML symmetric Gauss-Seidel"
// "ML Gauss-Seidel" "ML Jacobi"
// and accompanying parameters as listed
mlparams.set("coarse: type","Amesos-KLU");
mlparams.set("smoother: type","symmetric Gauss-Seidel");
mlparams.set("smoother: MLS polynomial order",3);
mlparams.set("smoother: damping factor",0.67);
mlparams.set("smoother: sweeps",1);
mlparams.set("smoother: pre or post","both");
// the ns for Laplace is the constant
int dimnullspace = 1;
int nummyrows = manager.ProblemMap()->NumMyElements();
int dimnsp = dimnullspace*nummyrows;
double* nsp = new double[dimnsp];
for (int i=0; i<dimnsp; ++i) nsp[i] = 1.;
mlparams.set("null space: type","pre-computed");
mlparams.set("null space: add default vectors",false);
mlparams.set("null space: dimension",dimnullspace);
mlparams.set("null space: vectors",nsp);
// ------------------------------------------------------------- //
// Pass input matrix to Moertel,
// Moertel does NOT take ownership of A!
// ------------------------------------------------------------- //
manager.SetInputMatrix(&A,false);
// ============================================================= //
// Solve
// ============================================================= //
manager.Solve(list,LHS,RHS);
// ------------------------------------------------------------- //
// One can reset the solver, change parameters and/or matrix (with the
// same rowmap) and solve again if needed.
// If no ResetSolver() is called, the same matrix and preconditioner
// will be used to solve for multiple rhs
// ------------------------------------------------------------- //
//manager.ResetSolver();
//LHS.PutScalar(0.0);
//manager.SetInputMatrix(&A,false);
//manager.Solve(list,LHS,RHS);
#ifdef MOERTEL_HAVE_EXODUS
// ================== //
// Output using ExodusII //
// ================== //
ExodusInterface exodus(Comm);
exodus.Write(Grid, "hex_output", LHS);
#else
// ================== //
// Output using MEDIT //
// ================== //
MEDITInterface MEDIT(Comm);
MEDIT.Write(Grid, "hex_output", LHS);
#endif
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return(0);
}
void ParameterListInterpreter<Scalar, LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::UpdateFactoryManager(Teuchos::ParameterList& paramList,
const Teuchos::ParameterList& defaultList, FactoryManager& manager) const {
// NOTE: Factory::SetParameterList must be called prior to Factory::SetFactory, as
// SetParameterList sets default values for non mentioned parameters, including factories
// === Smoothing ===
bool isCustomSmoother =
paramList.isParameter("smoother: pre or post") ||
paramList.isParameter("smoother: type") || paramList.isParameter("smoother: pre type") || paramList.isParameter("smoother: post type") ||
paramList.isSublist ("smoother: params") || paramList.isSublist ("smoother: pre params") || paramList.isSublist ("smoother: post params") ||
paramList.isParameter("smoother: sweeps") || paramList.isParameter("smoother: pre sweeps") || paramList.isParameter("smoother: post sweeps") ||
paramList.isParameter("smoother: overlap") || paramList.isParameter("smoother: pre overlap") || paramList.isParameter("smoother: post overlap");;
MUELU_READ_2LIST_PARAM(paramList, defaultList, "smoother: pre or post", std::string, "both", PreOrPost);
if (PreOrPost == "none") {
manager.SetFactory("Smoother", Teuchos::null);
} else if (isCustomSmoother) {
// FIXME: get default values from the factory
// NOTE: none of the smoothers at the moment use parameter validation framework, so we
// cannot get the default values from it.
#define TEST_MUTUALLY_EXCLUSIVE(arg1,arg2) \
TEUCHOS_TEST_FOR_EXCEPTION(paramList.isParameter(#arg1) && paramList.isParameter(#arg2), \
Exceptions::InvalidArgument, "You cannot specify both \""#arg1"\" and \""#arg2"\"");
#define TEST_MUTUALLY_EXCLUSIVE_S(arg1,arg2) \
TEUCHOS_TEST_FOR_EXCEPTION(paramList.isSublist(#arg1) && paramList.isSublist(#arg2), \
Exceptions::InvalidArgument, "You cannot specify both \""#arg1"\" and \""#arg2"\"");
TEST_MUTUALLY_EXCLUSIVE ("smoother: type", "smoother: pre type");
TEST_MUTUALLY_EXCLUSIVE ("smoother: type", "smoother: post type");
TEST_MUTUALLY_EXCLUSIVE ("smoother: sweeps", "smoother: pre sweeps");
TEST_MUTUALLY_EXCLUSIVE ("smoother: sweeps", "smoother: post sweeps");
TEST_MUTUALLY_EXCLUSIVE ("smoother: overlap", "smoother: pre overlap");
TEST_MUTUALLY_EXCLUSIVE ("smoother: overlap", "smoother: post overlap");
TEST_MUTUALLY_EXCLUSIVE_S("smoother: params", "smoother: pre params");
TEST_MUTUALLY_EXCLUSIVE_S("smoother: params", "smoother: post params");
TEUCHOS_TEST_FOR_EXCEPTION(PreOrPost == "both" && (paramList.isParameter("smoother: pre type") != paramList.isParameter("smoother: post type")),
Exceptions::InvalidArgument, "You must specify both \"smoother: pre type\" and \"smoother: post type\"");
// Default values
int overlap = 0;
ParameterList defaultSmootherParams;
defaultSmootherParams.set("relaxation: type", "Symmetric Gauss-Seidel");
defaultSmootherParams.set("relaxation: sweeps", Teuchos::OrdinalTraits<LO>::one());
defaultSmootherParams.set("relaxation: damping factor", Teuchos::ScalarTraits<Scalar>::one());
RCP<SmootherPrototype> preSmoother = Teuchos::null, postSmoother = Teuchos::null;
std::string preSmootherType, postSmootherType;
ParameterList preSmootherParams, postSmootherParams;
if (paramList.isParameter("smoother: overlap"))
overlap = paramList.get<int>("smoother: overlap");
if (PreOrPost == "pre" || PreOrPost == "both") {
if (paramList.isParameter("smoother: pre type")) {
preSmootherType = paramList.get<std::string>("smoother: pre type");
} else {
MUELU_READ_2LIST_PARAM(paramList, defaultList, "smoother: type", std::string, "RELAXATION", preSmootherTypeTmp);
preSmootherType = preSmootherTypeTmp;
}
if (paramList.isParameter("smoother: pre overlap"))
overlap = paramList.get<int>("smoother: pre overlap");
if (paramList.isSublist("smoother: pre params"))
preSmootherParams = paramList.sublist("smoother: pre params");
else if (paramList.isSublist("smoother: params"))
preSmootherParams = paramList.sublist("smoother: params");
else if (defaultList.isSublist("smoother: params"))
preSmootherParams = defaultList.sublist("smoother: params");
else if (preSmootherType == "RELAXATION")
preSmootherParams = defaultSmootherParams;
preSmoother = rcp(new TrilinosSmoother(preSmootherType, preSmootherParams, overlap));
}
if (PreOrPost == "post" || PreOrPost == "both") {
if (paramList.isParameter("smoother: post type"))
postSmootherType = paramList.get<std::string>("smoother: post type");
else {
MUELU_READ_2LIST_PARAM(paramList, defaultList, "smoother: type", std::string, "RELAXATION", postSmootherTypeTmp);
postSmootherType = postSmootherTypeTmp;
}
if (paramList.isSublist("smoother: post params"))
postSmootherParams = paramList.sublist("smoother: post params");
else if (paramList.isSublist("smoother: params"))
postSmootherParams = paramList.sublist("smoother: params");
else if (defaultList.isSublist("smoother: params"))
postSmootherParams = defaultList.sublist("smoother: params");
else if (postSmootherType == "RELAXATION")
postSmootherParams = defaultSmootherParams;
if (paramList.isParameter("smoother: post overlap"))
overlap = paramList.get<int>("smoother: post overlap");
if (postSmootherType == preSmootherType && areSame(preSmootherParams, postSmootherParams))
postSmoother = preSmoother;
else
postSmoother = rcp(new TrilinosSmoother(postSmootherType, postSmootherParams, overlap));
}
manager.SetFactory("Smoother", rcp(new SmootherFactory(preSmoother, postSmoother)));
}
// === Coarse solver ===
bool isCustomCoarseSolver =
paramList.isParameter("coarse: type") ||
paramList.isParameter("coarse: params");
if (paramList.isParameter("coarse: type") && paramList.get<std::string>("coarse: type") == "none") {
manager.SetFactory("CoarseSolver", Teuchos::null);
} else if (isCustomCoarseSolver) {
// FIXME: get default values from the factory
// NOTE: none of the smoothers at the moment use parameter validation framework, so we
// cannot get the default values from it.
MUELU_READ_2LIST_PARAM(paramList, defaultList, "coarse: type", std::string, "", coarseType);
int overlap = 0;
if (paramList.isParameter("coarse: overlap"))
overlap = paramList.get<int>("coarse: overlap");
ParameterList coarseParams;
if (paramList.isSublist("coarse: params"))
coarseParams = paramList.sublist("coarse: params");
else if (defaultList.isSublist("coarse: params"))
coarseParams = defaultList.sublist("coarse: params");
RCP<SmootherPrototype> coarseSmoother;
// TODO: this is not a proper place to check. If we consider direct solver to be a special
// case of smoother, we would like to unify Amesos and Ifpack2 smoothers in src/Smoothers, and
// have a single factory responsible for those. Then, this check would belong there.
if (coarseType == "RELAXATION" || coarseType == "CHEBYSHEV" ||
coarseType == "ILUT" || coarseType == "ILU" || coarseType == "RILUK" || coarseType == "SCHWARZ" ||
coarseType == "Amesos")
coarseSmoother = rcp(new TrilinosSmoother(coarseType, coarseParams, overlap));
else
coarseSmoother = rcp(new DirectSolver(coarseType, coarseParams));
manager.SetFactory("CoarseSolver", rcp(new SmootherFactory(coarseSmoother)));
}
// === Aggregation ===
// Aggregation graph
RCP<CoalesceDropFactory> dropFactory = rcp(new CoalesceDropFactory());
ParameterList dropParams;
dropParams.set("lightweight wrap", true);
MUELU_TEST_AND_SET_PARAM(dropParams, "algorithm", paramList, defaultList, "aggregation: drop scheme", std::string);
// Rename classical to original
if (dropParams.isParameter("algorithm") && dropParams.get<std::string>("algorithm") == "classical")
dropParams.set("algorithm", "original");
MUELU_TEST_AND_SET_PARAM(dropParams, "aggregation threshold", paramList, defaultList, "aggregation: drop tol", double);
MUELU_TEST_AND_SET_PARAM(dropParams, "Dirichlet detection threshold", paramList, defaultList, "aggregation: Dirichlet threshold", double);
dropFactory->SetParameterList(dropParams);
manager.SetFactory("Graph", dropFactory);
// Aggregation sheme
MUELU_READ_2LIST_PARAM(paramList, defaultList, "aggregation: type", std::string, "uncoupled", aggType);
RCP<Factory> aggFactory;
if (aggType == "uncoupled") {
aggFactory = rcp(new UncoupledAggregationFactory());
ParameterList aggParams;
MUELU_TEST_AND_SET_PARAM(aggParams, "mode", paramList, defaultList, "aggregation: mode", std::string);
MUELU_TEST_AND_SET_PARAM(aggParams, "MinNodesPerAggregate", paramList, defaultList, "aggregation: min agg size", int);
MUELU_TEST_AND_SET_PARAM(aggParams, "MaxNodesPerAggregate", paramList, defaultList, "aggregation: max agg size", int);
MUELU_TEST_AND_SET_PARAM(aggParams, "aggregation: preserve Dirichlet points", paramList, defaultList, "aggregation: preserve Dirichlet points", bool);
aggFactory->SetParameterList(aggParams);
} else if (aggType == "coupled") {
StochasticStefanBoltzmannMeshManager(Teuchos::ParameterList &parlist)
: MeshManager_Rectangle<Real>(parlist) {
nx_ = parlist.sublist("Geometry").get("NX", 3);
ny_ = parlist.sublist("Geometry").get("NY", 3);
computeSideSets();
}
void getValidParameters(Teuchos::ParameterList& params)
{
//params.clear();
Teuchos::ParameterList empty;
params = empty;
// ============================================================ //
// Parameters are reported from each used file in IFPACK2. Files //
// are listed in alphabetical order, first all *.cpp, then *.hpp. //
// Some options not very tested or documented anywhere //
// are not reported here. //
// ============================================================ //
// Ifpack2_IlukGraph.hpp
params.set("fact: iluk level-of-fill", (int)1);
params.set("fact: iluk level-of-overlap", (int)0);
// Ifpack2_Amesos.cpp
params.set("amesos: solver type", "Amesos_Klu");
// Ifpack2_IC.cpp
params.set("fact: level-of-fill", (int)1);
params.set("fact: absolute threshold", (double)0.0);
params.set("fact: relative threshold", (double)0.0);
params.set("fact: drop tolerance", (double)0.0);
// Ifpack2_ICT.cpp
params.set("fact: ict level-of-fill", (double)1.0);
params.set("fact: absolute threshold", (double)0.0);
params.set("fact: relative threshold", (double)1.0);
params.set("fact: relax value", (double)0.0);
params.set("fact: drop tolerance", (double)0.0);
// Ifpack2_ILU.cpp
params.set("fact: level-of-fill", (int)0);
params.set("fact: absolute threshold", (double)0.0);
params.set("fact: relative threshold", (double)1.0);
params.set("fact: relax value", (double)0.0);
// Ifpack2_ILUT.cpp
params.set("fact: ilut level-of-fill", (double)1.0);
params.set("fact: absolute threshold", (double)0.0);
params.set("fact: relative threshold", (double)1.0);
params.set("fact: relax value", (double)0.0);
// Ifpack2_METISPartitioner.cpp
params.set("partitioner: local parts", (int)1);
params.set("partitioner: overlap", (int)0);
params.set("partitioner: print level", (int)0);
// Ifpack2_Relaxation.cpp
params.set("relaxation: type", "Jacobi");
params.set("relaxation: sweeps", (int)1);
params.set("relaxation: damping factor", (double)1.0);
params.set("relaxation: min diagonal value", (double)1.0);
params.set("relaxation: zero starting solution", true);
// Ifpack2_SPARSKIT.cpp
params.set("fact: sparskit: lfil", (int)0);
params.set("fact: sparskit: tol", (double)0.0);
params.set("fact: sparskit: droptol", (double)0.0);
params.set("fact: sparskit: permtol", (double)0.1);
params.set("fact: sparskit: alph", (double)0.0);
params.set("fact: sparskit: mbloc", (int)(-1));
params.set("fact: sparskit: type", ("ILUT"));
// Additive Schwarz preconditioner
params.set("schwarz: compute condest", true);
params.set("schwarz: combine mode", "Zero"); // use string mode for this
params.set("schwarz: reordering type", "none");
params.set("schwarz: filter singletons", false);
// Ifpack2_BlockRelaxation.hpp
// params.set("relaxation: type", "Jacobi"); // already set
// params.set("relaxation: sweeps", 1); // already set
// params.get("relaxation: damping factor", 1.0); // already set
// params.get("relaxation: zero starting solution", true); // already set
params.set("partitioner: type", "greedy");
params.set("partitioner: local parts", (int)1);
params.set("partitioner: overlap", (int)0);
// Ifpack2_METISPartitioner.hpp
params.set("partitioner: use symmetric graph", true);
}
// Constructor
Brents( Teuchos::ParameterList &parlist ) : LineSearch<Real>(parlist) {
tol_ = parlist.get("Bracketing Tolerance",1.e-8);
btls_ = Teuchos::rcp(new BackTracking<Real>(parlist));
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= Teuchos::DefaultComm<int>::getComm();
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
bool print = (iprint>0); // && !(comm->getRank());
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (print)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
bool print0 = print && !comm->getRank();
Teuchos::RCP<std::ostream> outStream0;
if (print0)
outStream0 = Teuchos::rcp(&std::cout, false);
else
outStream0 = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
// *** Example body.
try {
/*************************************************************************/
/************* INITIALIZE BURGERS FEM CLASS ******************************/
/*************************************************************************/
int nx = 512; // Set spatial discretization.
RealT alpha = 1.e-3; // Set penalty parameter.
RealT nl = 1.0; // Nonlinearity parameter (1 = Burgers, 0 = linear).
RealT cH1 = 1.0; // Scale for derivative term in H1 norm.
RealT cL2 = 0.0; // Scale for mass term in H1 norm.
Teuchos::RCP<BurgersFEM<RealT> > fem
= Teuchos::rcp(new BurgersFEM<RealT>(nx,nl,cH1,cL2));
fem->test_inverse_mass(*outStream0);
fem->test_inverse_H1(*outStream0);
/*************************************************************************/
/************* INITIALIZE SIMOPT OBJECTIVE FUNCTION **********************/
/*************************************************************************/
Teuchos::RCP<std::vector<RealT> > ud_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<ROL::Vector<RealT> > ud
= Teuchos::rcp(new L2VectorPrimal<RealT>(ud_rcp,fem));
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > pobj
= Teuchos::rcp(new Objective_BurgersControl<RealT>(fem,ud,alpha));
/*************************************************************************/
/************* INITIALIZE SIMOPT EQUALITY CONSTRAINT *********************/
/*************************************************************************/
bool hess = true;
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > pcon
= Teuchos::rcp(new EqualityConstraint_BurgersControl<RealT>(fem,hess));
/*************************************************************************/
/************* INITIALIZE VECTOR STORAGE *********************************/
/*************************************************************************/
// INITIALIZE CONTROL VECTORS
Teuchos::RCP<std::vector<RealT> > z_rcp
= Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
Teuchos::RCP<std::vector<RealT> > gz_rcp
= Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
Teuchos::RCP<std::vector<RealT> > yz_rcp
= Teuchos::rcp( new std::vector<RealT> (nx+2, 1.0) );
for (int i=0; i<nx+2; i++) {
(*yz_rcp)[i] = 2.0*random<RealT>(comm)-1.0;
}
Teuchos::RCP<ROL::Vector<RealT> > zp
= Teuchos::rcp(new PrimalControlVector(z_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > gzp
= Teuchos::rcp(new DualControlVector(gz_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > yzp
= Teuchos::rcp(new PrimalControlVector(yz_rcp,fem));
// INITIALIZE STATE VECTORS
Teuchos::RCP<std::vector<RealT> > u_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<std::vector<RealT> > gu_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<ROL::Vector<RealT> > up
= Teuchos::rcp(new PrimalStateVector(u_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > gup
= Teuchos::rcp(new DualStateVector(gu_rcp,fem));
// INITIALIZE CONSTRAINT VECTORS
Teuchos::RCP<std::vector<RealT> > c_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
Teuchos::RCP<std::vector<RealT> > l_rcp
= Teuchos::rcp( new std::vector<RealT> (nx, 1.0) );
for (int i=0; i<nx; i++) {
(*l_rcp)[i] = random<RealT>(comm);
}
Teuchos::RCP<ROL::Vector<RealT> > cp
= Teuchos::rcp(new PrimalConstraintVector(c_rcp,fem));
Teuchos::RCP<ROL::Vector<RealT> > lp
= Teuchos::rcp(new DualConstraintVector(l_rcp,fem));
/*************************************************************************/
/************* INITIALIZE SAMPLE GENERATOR *******************************/
/*************************************************************************/
int dim = 4, nSamp = 1000;
std::vector<RealT> tmp(2,0.0); tmp[0] = -1.0; tmp[1] = 1.0;
std::vector<std::vector<RealT> > bounds(dim,tmp);
Teuchos::RCP<ROL::BatchManager<RealT> > bman
= Teuchos::rcp(new L2VectorBatchManager<RealT,int>(comm));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
= Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(
nSamp,bounds,bman,false,false,100));
/*************************************************************************/
/************* INITIALIZE REDUCED OBJECTIVE FUNCTION *********************/
/*************************************************************************/
bool storage = true, fdhess = false;
Teuchos::RCP<ROL::Objective<RealT> > robj
= Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(
pobj,pcon,up,zp,lp,gup,gzp,cp,storage,fdhess));
/*************************************************************************/
/************* INITIALIZE BOUND CONSTRAINTS ******************************/
/*************************************************************************/
std::vector<RealT> Zlo(nx+2,0.0), Zhi(nx+2,10.0);
for (int i = 0; i < nx+2; i++) {
if ( i < (int)((nx+2)/3) ) {
Zlo[i] = -1.0;
Zhi[i] = 1.0;
}
if ( i >= (int)((nx+2)/3) && i < (int)(2*(nx+2)/3) ) {
Zlo[i] = 1.0;
Zhi[i] = 5.0;
}
if ( i >= (int)(2*(nx+2)/3) ) {
Zlo[i] = 5.0;
Zhi[i] = 10.0;
}
}
Teuchos::RCP<ROL::BoundConstraint<RealT> > Zbnd
= Teuchos::rcp(new L2BoundConstraint<RealT>(Zlo,Zhi,fem));
/*************************************************************************/
/************* INITIALIZE OPTIMIZATION PROBLEM ***************************/
/*************************************************************************/
Teuchos::ParameterList SOLlist;
SOLlist.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
SOLlist.sublist("SOL").set("Store Sampled Value and Gradient",storage);
SOLlist.sublist("SOL").sublist("Risk Measure").set("Name","KL Divergence");
SOLlist.sublist("SOL").sublist("Risk Measure").sublist("KL Divergence").set("Threshold",1.e-2);
ROL::StochasticProblem<RealT> optProb(SOLlist,robj,sampler,zp,Zbnd);
/*************************************************************************/
/************* CHECK DERIVATIVES AND CONSISTENCY *************************/
/*************************************************************************/
// CHECK OBJECTIVE DERIVATIVES
bool derivcheck = false;
if (derivcheck) {
int nranks = sampler->numBatches();
for (int pid = 0; pid < nranks; pid++) {
if ( pid == sampler->batchID() ) {
for (int i = sampler->start(); i < sampler->numMySamples(); i++) {
*outStream << "Sample " << i << " Rank " << sampler->batchID() << "\n";
*outStream << "(" << sampler->getMyPoint(i)[0] << ", "
<< sampler->getMyPoint(i)[1] << ", "
<< sampler->getMyPoint(i)[2] << ", "
<< sampler->getMyPoint(i)[3] << ")\n";
pcon->setParameter(sampler->getMyPoint(i));
pcon->checkSolve(*up,*zp,*cp,print,*outStream);
robj->setParameter(sampler->getMyPoint(i));
*outStream << "\n";
robj->checkGradient(*zp,*gzp,*yzp,print,*outStream);
robj->checkHessVec(*zp,*gzp,*yzp,print,*outStream);
*outStream << "\n\n";
}
}
comm->barrier();
}
}
optProb.checkObjectiveGradient(*yzp,print0,*outStream0);
optProb.checkObjectiveHessVec(*yzp,print0,*outStream0);
/*************************************************************************/
/************* RUN OPTIMIZATION ******************************************/
/*************************************************************************/
// READ IN XML INPUT
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist
= Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
// RUN OPTIMIZATION
ROL::Algorithm<RealT> algo("Trust Region",*parlist,false);
zp->zero();
algo.run(optProb,print0,*outStream0);
/*************************************************************************/
/************* PRINT CONTROL AND STATE TO SCREEN *************************/
/*************************************************************************/
if ( print0 ) {
std::ofstream ofs;
ofs.open("output_example_08.txt",std::ofstream::out);
for ( int i = 0; i < nx+2; i++ ) {
ofs << std::scientific << std::setprecision(10);
ofs << std::setw(20) << std::left << (RealT)i/((RealT)nx+1.0);
ofs << std::setw(20) << std::left << (*z_rcp)[i];
ofs << "\n";
}
ofs.close();
}
*outStream0 << "Scalar Parameter: " << optProb.getSolutionStatistic() << "\n\n";
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
comm->barrier();
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
//***********************************************************************
bool NOX::Epetra::LinearSystemStratimikos::
applyJacobianInverse(Teuchos::ParameterList &p,
const NOX::Epetra::Vector& input,
NOX::Epetra::Vector& result)
{
using Teuchos::RCP;
using Teuchos::rcp;
NOX_FUNC_TIME_MONITOR("NOX: Total Linear Solve Time");
double startTime = timer.WallTime();
// Need non-const version of the input vector
// Epetra_LinearProblem requires non-const versions so we can perform
// scaling of the linear problem.
NOX::Epetra::Vector& nonConstInput = const_cast<NOX::Epetra::Vector&>(input);
// Zero out the delta X of the linear problem if requested by user.
if (zeroInitialGuess) result.init(0.0);
// Wrap Thyra objects around Epetra and NOX objects
Teuchos::RCP<const Thyra::LinearOpBase<double> > linearOp =
Thyra::epetraLinearOp(jacPtr);
// Set the linear Op and precomputed prec on this lows
if (precObj == Teuchos::null)
Thyra::initializeOp(*lowsFactory, linearOp, lows.ptr());
else
Thyra::initializePreconditionedOp<double>(
*lowsFactory, linearOp, precObj, lows.ptr());
Teuchos::RCP<Epetra_Vector> resultRCP =
Teuchos::rcp(&result.getEpetraVector(), false);
Teuchos::RCP<Epetra_Vector> inputRCP =
Teuchos::rcp(&nonConstInput.getEpetraVector(), false);
Teuchos::RCP<Thyra::VectorBase<double> >
x = Thyra::create_Vector(resultRCP , linearOp->domain() );
Teuchos::RCP<const Thyra::VectorBase<double> >
b = Thyra::create_Vector(inputRCP, linearOp->range() );
// Alter the convergence tolerance, if Inexact Newton
Teuchos::RCP<Thyra::SolveCriteria<double> > solveCriteria;
if (getLinearSolveToleranceFromNox) {
Thyra::SolveMeasureType solveMeasure(
Thyra::SOLVE_MEASURE_NORM_RESIDUAL,
Thyra::SOLVE_MEASURE_NORM_INIT_RESIDUAL );
solveCriteria = Teuchos::rcp(new Thyra::SolveCriteria<double>(
solveMeasure, p.get<double>("Tolerance") ) );
}
// Solve the linear system for x
Thyra::SolveStatus<double> status =
lows->solve(Thyra::NOTRANS, *b, x.ptr(), solveCriteria.ptr());
// MOVE TO FUNCTION: Update statistics: solves, iters, iters_total, achieved tol
++linearSolveCount;
if (status.extraParameters != Teuchos::null) {
if (status.extraParameters->isParameter("Belos/Iteration Count")) {
linearSolveIters_last = status.extraParameters->get<int>("Belos/Iteration Count");
linearSolveIters_total += linearSolveIters_last;
}
if (status.extraParameters->isParameter("Belos/Achieved Tolerance"))
linearSolveAchievedTol = status.extraParameters->get<double>("Belos/Achieved Tolerance");
if (status.extraParameters->isParameter("AztecOO/Iteration Count")) {
linearSolveIters_last = status.extraParameters->get<int>("AztecOO/Iteration Count");
linearSolveIters_total += linearSolveIters_last;
}
if (status.extraParameters->isParameter("AztecOO/Achieved Tolerance"))
linearSolveAchievedTol = status.extraParameters->get<double>("AztecOO/Achieved Tolerance");
}
// Dump solution of linear system
#ifdef HAVE_NOX_EPETRAEXT
if (p.get("Write Linear System", false)) {
std::ostringstream iterationNumber;
iterationNumber << linearSolveCount;
std::string prefixName = p.get("Write Linear System File Prefix",
"NOX_LinSys");
std::string postfixName = iterationNumber.str();
postfixName += ".mm";
std::string lhsFileName = prefixName + "_LHS_" + postfixName;
std::string rhsFileName = prefixName + "_RHS_" + postfixName;
std::string jacFileName = prefixName + "_Jacobian_" + postfixName;
EpetraExt::MultiVectorToMatrixMarketFile(lhsFileName.c_str(),
result.getEpetraVector());
EpetraExt::MultiVectorToMatrixMarketFile(rhsFileName.c_str(),
input.getEpetraVector());
Epetra_RowMatrix* printMatrix = NULL;
printMatrix = dynamic_cast<Epetra_RowMatrix*>(jacPtr.get());
if (printMatrix == NULL) {
std::cout << "Error: NOX::Epetra::LinearSystemAztecOO::applyJacobianInverse() - "
<< "Could not cast the Jacobian operator to an Epetra_RowMatrix!"
<< "Please set the \"Write Linear System\" parameter to false."
<< std::endl;
throw "NOX Error";
}
EpetraExt::RowMatrixToMatrixMarketFile(jacFileName.c_str(), *printMatrix,
"test matrix", "Jacobian XXX");
}
#endif
//Release RCPs
x = Teuchos::null; b = Teuchos::null;
resultRCP = Teuchos::null; inputRCP = Teuchos::null;
double endTime = timer.WallTime();
timeApplyJacbianInverse += (endTime - startTime);
return true;
}
// ***********************************************************
int DG_Prob::Eigenvectors(const double Dt,
const Epetra_Map & Map)
{
printf("Entrou em Eigenvectors\n");
#ifdef HAVE_MPI
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
//MPI::COMM_WORLD.Barrier();
Comm.Barrier();
Teuchos::RCP<Epetra_FECrsMatrix> M = Teuchos::rcp(new Epetra_FECrsMatrix(Copy, Map,0));//&NNz[0]);
Teuchos::RCP<Epetra_FEVector> RHS = Teuchos::rcp(new Epetra_FEVector(Map,1));
DG_MatrizVetor_Epetra(Dt,M,RHS);
Teuchos::RCP<Epetra_CrsMatrix> A = Teuchos::rcp(new Epetra_CrsMatrix(Copy, Map,0
/* &NNz[0]*/) );
Epetra_Export Exporter(Map,Map);
A->PutScalar(0.0);
A->Export(*(M.ptr()),Exporter,Add);
A->FillComplete();
using std::cout;
// int nx = 5;
bool boolret;
int MyPID = Comm.MyPID();
bool verbose = true;
bool debug = false;
std::string which("LR");
Teuchos::CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nodebug",&debug,"Print debugging information.");
cmdp.setOption("sort",&which,"Targetted eigenvalues (SM,LM,SR,LR,SI,or LI).");
typedef double ScalarType;
typedef Teuchos::ScalarTraits<ScalarType> SCT;
typedef SCT::magnitudeType MagnitudeType;
typedef Epetra_MultiVector MV;
typedef Epetra_Operator OP;
typedef Anasazi::MultiVecTraits<ScalarType,MV> MVT;
typedef Anasazi::OperatorTraits<ScalarType,MV,OP> OPT;
// double rho = 2*nx+1;
// Compute coefficients for discrete convection-diffution operator
// const double one = 1.0;
// int NumEntries, info;
//************************************
// Start the block Arnoldi iteration
//***********************************
//
// Variables used for the Block Krylov Schur Method
//
int nev = 10;
int blockSize = 1;
int numBlocks = 20;
int maxRestarts = 500;
//int stepSize = 5;
double tol = 1e-8;
// Create a sort manager to pass into the block Krylov-Schur solver manager
// --> Make sure the reference-counted pointer is of type Anasazi::SortManager<>
// --> The block Krylov-Schur solver manager uses Anasazi::BasicSort<> by default,
// so you can also pass in the parameter "Which", instead of a sort manager.
Teuchos::RCP<Anasazi::SortManager<MagnitudeType> > MySort =
Teuchos::rcp( new Anasazi::BasicSort<MagnitudeType>( which ) );
// Set verbosity level
int verbosity = Anasazi::Errors + Anasazi::Warnings;
if (verbose) {
verbosity += Anasazi::FinalSummary + Anasazi::TimingDetails;
}
if (debug) {
verbosity += Anasazi::Debug;
}
//
// Create parameter list to pass into solver manager
//
Teuchos::ParameterList MyPL;
MyPL.set( "Verbosity", verbosity );
MyPL.set( "Sort Manager", MySort );
//MyPL.set( "Which", which );
MyPL.set( "Block Size", blockSize );
MyPL.set( "Num Blocks", numBlocks );
MyPL.set( "Maximum Restarts", maxRestarts );
//MyPL.set( "Step Size", stepSize );
MyPL.set( "Convergence Tolerance", tol );
// 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.
Teuchos::RCP<Epetra_MultiVector> ivec = Teuchos::rcp( new Epetra_MultiVector(Map, blockSize) );
ivec->Random();
// Create the eigenproblem.
Teuchos::RCP<Anasazi::BasicEigenproblem<double, MV, OP> > MyProblem =
Teuchos::rcp( new Anasazi::BasicEigenproblem<double, MV, OP>(A, ivec) );
// Inform the eigenproblem that the operator A is symmetric
//MyProblem->setHermitian(rho==0.0);
// Set the number of eigenvalues requested
MyProblem->setNEV( nev );
// Inform the eigenproblem that you are finishing passing it information
boolret = MyProblem->setProblem();
if (boolret != true) {
if (verbose && MyPID == 0) {
cout << "Anasazi::BasicEigenproblem::setProblem() returned with error." << endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
// Initialize the Block Arnoldi solver
Anasazi::BlockKrylovSchurSolMgr<double, MV, OP> MySolverMgr(MyProblem, MyPL);
// Solve the problem to the specified tolerances or length
Anasazi::ReturnType returnCode = MySolverMgr.solve();
if (returnCode != Anasazi::Converged && MyPID==0 && verbose) {
cout << "Anasazi::EigensolverMgr::solve() returned unconverged." << endl;
}
// Get the Ritz values from the eigensolver
std::vector<Anasazi::Value<double> > ritzValues = MySolverMgr.getRitzValues();
// Output computed eigenvalues and their direct residuals
if (verbose && MyPID==0) {
int numritz = (int)ritzValues.size();
cout.setf(std::ios_base::right, std::ios_base::adjustfield);
cout<<endl<< "Computed Ritz Values"<< endl;
if (MyProblem->isHermitian()) {
cout<< std::setw(16) << "Real Part"
<< endl;
cout<<"-----------------------------------------------------------"<<endl;
for (int i=0; i<numritz; i++) {
cout<< std::setw(16) << ritzValues[i].realpart
<< endl;
}
cout<<"-----------------------------------------------------------"<<endl;
}
else {
cout<< std::setw(16) << "Real Part"
<< std::setw(16) << "Imag Part"
<< endl;
cout<<"-----------------------------------------------------------"<<endl;
for (int i=0; i<numritz; i++) {
cout<< std::setw(16) << ritzValues[i].realpart
<< std::setw(16) << ritzValues[i].imagpart
<< endl;
}
cout<<"-----------------------------------------------------------"<<endl;
}
}
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<ScalarType,MV> sol = MyProblem->getSolution();
std::vector<Anasazi::Value<ScalarType> > evals = sol.Evals;
Teuchos::RCP<MV> evecs = sol.Evecs;
std::vector<int> index = sol.index;
int numev = sol.numVecs;
if (numev > 0) {
// Compute residuals.
Teuchos::LAPACK<int,double> lapack;
std::vector<double> normA(numev);
if (MyProblem->isHermitian()) {
// Get storage
Epetra_MultiVector Aevecs(Map,numev);
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( *A, *evecs, Aevecs );
// Compute A*evecs - lambda*evecs and its norm
MVT::MvTimesMatAddMv( -1.0, *evecs, B, 1.0, Aevecs );
MVT::MvNorm( Aevecs, normA );
// Scale the norms by the eigenvalue
for (int i=0; i<numev; i++) {
normA[i] /= Teuchos::ScalarTraits<double>::magnitude( evals[i].realpart );
}
} else {
// The problem is non-Hermitian.
int i=0;
std::vector<int> curind(1);
std::vector<double> resnorm(1), tempnrm(1);
Teuchos::RCP<MV> tempAevec;
Teuchos::RCP<const MV> evecr, eveci;
Epetra_MultiVector Aevec(Map,numev);
// Compute A*evecs
OPT::Apply( *A, *evecs, Aevec );
Teuchos::SerialDenseMatrix<int,double> Breal(1,1), Bimag(1,1);
while (i<numev) {
if (index[i]==0) {
// Get a view of the current eigenvector (evecr)
curind[0] = i;
evecr = MVT::CloneView( *evecs, curind );
// Get a copy of A*evecr
tempAevec = MVT::CloneCopy( Aevec, curind );
// Compute A*evecr - lambda*evecr
Breal(0,0) = evals[i].realpart;
MVT::MvTimesMatAddMv( -1.0, *evecr, Breal, 1.0, *tempAevec );
// Compute the norm of the residual and increment counter
MVT::MvNorm( *tempAevec, resnorm );
normA[i] = resnorm[0]/Teuchos::ScalarTraits<MagnitudeType>::magnitude( evals[i].realpart );
i++;
} else {
// Get a view of the real part of the eigenvector (evecr)
curind[0] = i;
evecr = MVT::CloneView( *evecs, curind );
// Get a copy of A*evecr
tempAevec = MVT::CloneCopy( Aevec, curind );
// Get a view of the imaginary part of the eigenvector (eveci)
curind[0] = i+1;
eveci = MVT::CloneView( *evecs, curind );
// Set the eigenvalue into Breal and Bimag
Breal(0,0) = evals[i].realpart;
Bimag(0,0) = evals[i].imagpart;
// Compute A*evecr - evecr*lambdar + eveci*lambdai
MVT::MvTimesMatAddMv( -1.0, *evecr, Breal, 1.0, *tempAevec );
MVT::MvTimesMatAddMv( 1.0, *eveci, Bimag, 1.0, *tempAevec );
MVT::MvNorm( *tempAevec, tempnrm );
// Get a copy of A*eveci
tempAevec = MVT::CloneCopy( Aevec, curind );
// Compute A*eveci - eveci*lambdar - evecr*lambdai
MVT::MvTimesMatAddMv( -1.0, *evecr, Bimag, 1.0, *tempAevec );
MVT::MvTimesMatAddMv( -1.0, *eveci, Breal, 1.0, *tempAevec );
MVT::MvNorm( *tempAevec, resnorm );
// Compute the norms and scale by magnitude of eigenvalue
normA[i] = lapack.LAPY2( tempnrm[i], resnorm[i] ) /
lapack.LAPY2( evals[i].realpart, evals[i].imagpart );
normA[i+1] = normA[i];
i=i+2;
}
}
}
// Output computed eigenvalues and their direct residuals
if (verbose && MyPID==0) {
cout.setf(std::ios_base::right, std::ios_base::adjustfield);
cout<<endl<< "Actual Residuals"<<endl;
if (MyProblem->isHermitian()) {
cout<< std::setw(16) << "Real 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(20) << normA[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) << normA[i] << endl;
}
cout<<"-----------------------------------------------------------"<<endl;
}
}
}
#ifdef EPETRA_MPI
MPI_Finalize();
#endif
return 0;
}
TEUCHOS_UNIT_TEST(gs_evaluators, gather_constr)
{
PHX::KokkosDeviceSession session;
const std::size_t workset_size = 20;
Teuchos::RCP<panzer::BasisIRLayout> linBasis = buildLinearBasis(workset_size);
Teuchos::RCP<std::vector<std::string> > fieldNames
= Teuchos::rcp(new std::vector<std::string>);
fieldNames->push_back("dog");
Teuchos::ParameterList pl;
pl.set("Basis",linBasis);
pl.set("Field Names",fieldNames);
Teuchos::RCP<panzer_stk_classic::STK_Interface> mesh = buildMesh(2,2);
RCP<Epetra_Comm> Comm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList("Physics Blocks");
std::vector<panzer::BC> bcs;
testInitialzation(ipb, bcs);
Teuchos::RCP<panzer::FieldManagerBuilder> fmb =
Teuchos::rcp(new panzer::FieldManagerBuilder);
// build physics blocks
//////////////////////////////////////////////////////////////
Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
user_app::BCFactory bc_factory;
std::vector<Teuchos::RCP<panzer::PhysicsBlock> > physicsBlocks;
{
std::map<std::string,std::string> block_ids_to_physics_ids;
block_ids_to_physics_ids["eblock-0_0"] = "test physics";
block_ids_to_physics_ids["eblock-1_0"] = "test physics";
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");
Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
int default_integration_order = 1;
panzer::buildPhysicsBlocks(block_ids_to_physics_ids,
block_ids_to_cell_topo,
ipb,
default_integration_order,
workset_size,
eqset_factory,
gd,
false,
physicsBlocks);
}
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,physicsBlocks,workset_size));
// build DOF Manager
/////////////////////////////////////////////////////////////
// build the connection manager
const Teuchos::RCP<panzer::ConnManager<int,int> >
conn_manager = Teuchos::rcp(new panzer_stk_classic::STKConnManager<int>(mesh));
panzer::DOFManagerFactory<int,int> globalIndexerFactory;
RCP<panzer::UniqueGlobalIndexer<int,int> > dofManager
= globalIndexerFactory.buildUniqueGlobalIndexer(Teuchos::opaqueWrapper(MPI_COMM_WORLD),physicsBlocks,conn_manager);
Teuchos::RCP<panzer::EpetraLinearObjFactory<panzer::Traits,int> > eLinObjFactory
= Teuchos::rcp(new panzer::EpetraLinearObjFactory<panzer::Traits,int>(Comm.getConst(),dofManager));
Teuchos::RCP<panzer::LinearObjFactory<panzer::Traits> > linObjFactory = eLinObjFactory;
// setup field manager build
/////////////////////////////////////////////////////////////
// Add in the application specific closure model factory
user_app::MyModelFactory_TemplateBuilder cm_builder;
panzer::ClosureModelFactory_TemplateManager<panzer::Traits> cm_factory;
cm_factory.buildObjects(cm_builder);
Teuchos::ParameterList closure_models("Closure Models");
closure_models.sublist("solid").sublist("SOURCE_TEMPERATURE").set<double>("Value",1.0);
closure_models.sublist("ion solid").sublist("SOURCE_ION_TEMPERATURE").set<double>("Value",1.0);
Teuchos::ParameterList user_data("User Data");
fmb->setWorksetContainer(wkstContainer);
fmb->setupVolumeFieldManagers(physicsBlocks,cm_factory,closure_models,*linObjFactory,user_data);
fmb->setupBCFieldManagers(bcs,physicsBlocks,*eqset_factory,cm_factory,bc_factory,closure_models,*linObjFactory,user_data);
fmb->writeVolumeGraphvizDependencyFiles("field_manager",physicsBlocks);
panzer::AssemblyEngine_TemplateManager<panzer::Traits> ae_tm;
panzer::AssemblyEngine_TemplateBuilder builder(fmb,linObjFactory);
ae_tm.buildObjects(builder);
RCP<panzer::EpetraLinearObjContainer> eGhosted
= Teuchos::rcp_dynamic_cast<panzer::EpetraLinearObjContainer>(linObjFactory->buildGhostedLinearObjContainer());
RCP<panzer::EpetraLinearObjContainer> eGlobal
= Teuchos::rcp_dynamic_cast<panzer::EpetraLinearObjContainer>(linObjFactory->buildLinearObjContainer());
eLinObjFactory->initializeGhostedContainer(panzer::EpetraLinearObjContainer::X |
panzer::EpetraLinearObjContainer::DxDt |
panzer::EpetraLinearObjContainer::F |
panzer::EpetraLinearObjContainer::Mat,*eGhosted);
eLinObjFactory->initializeContainer(panzer::EpetraLinearObjContainer::X |
panzer::EpetraLinearObjContainer::DxDt |
panzer::EpetraLinearObjContainer::F |
panzer::EpetraLinearObjContainer::Mat,*eGlobal);
panzer::AssemblyEngineInArgs input(eGhosted,eGlobal);
ae_tm.getAsObject<panzer::Traits::Residual>()->evaluate(input);
ae_tm.getAsObject<panzer::Traits::Jacobian>()->evaluate(input);
}
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, *mgridLsgVec, mgridSweeps);
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, "", true);
}
return 0;
} //main
Teuchos::RCP<MueLu::Hierarchy<Scalar,LocalOrdinal,GlobalOrdinal,Node> >
CreateXpetraPreconditioner(Teuchos::RCP<Xpetra::Matrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> > op,
const Teuchos::ParameterList& inParamList,
Teuchos::RCP<Xpetra::MultiVector<double, LocalOrdinal, GlobalOrdinal, Node> > coords = Teuchos::null,
Teuchos::RCP<Xpetra::MultiVector<Scalar, LocalOrdinal, GlobalOrdinal, Node> > nullspace = Teuchos::null) {
typedef MueLu::HierarchyManager<Scalar,LocalOrdinal,GlobalOrdinal,Node> HierarchyManager;
typedef MueLu::HierarchyUtils<Scalar,LocalOrdinal,GlobalOrdinal,Node> HierarchyUtils;
typedef MueLu::Hierarchy<Scalar,LocalOrdinal,GlobalOrdinal,Node> Hierarchy;
typedef MueLu::MLParameterListInterpreter<Scalar,LocalOrdinal,GlobalOrdinal,Node> MLParameterListInterpreter;
typedef MueLu::ParameterListInterpreter<Scalar,LocalOrdinal,GlobalOrdinal,Node> ParameterListInterpreter;
typedef Xpetra::MultiVectorFactory<Scalar,LocalOrdinal,GlobalOrdinal,Node> MultiVectorFactory;
std::string timerName = "MueLu setup time";
RCP<Teuchos::Time> tm = Teuchos::TimeMonitor::getNewTimer(timerName);
tm->start();
bool hasParamList = inParamList.numParams();
RCP<HierarchyManager> mueLuFactory;
// Rip off non-serializable data before validation
Teuchos::ParameterList nonSerialList,paramList;
MueLu::ExtractNonSerializableData(inParamList, paramList, nonSerialList);
std::string syntaxStr = "parameterlist: syntax";
if (hasParamList && paramList.isParameter(syntaxStr) && paramList.get<std::string>(syntaxStr) == "ml") {
paramList.remove(syntaxStr);
mueLuFactory = rcp(new MLParameterListInterpreter(paramList));
} else {
mueLuFactory = rcp(new ParameterListInterpreter(paramList,op->getDomainMap()->getComm()));
}
// Create Hierarchy
RCP<Hierarchy> H = mueLuFactory->CreateHierarchy();
H->setlib(op->getDomainMap()->lib());
// Stick the non-serializible data on the hierarchy.
HierarchyUtils::AddNonSerializableDataToHierarchy(*mueLuFactory,*H, nonSerialList);
// Set fine level operator
H->GetLevel(0)->Set("A", op);
// Set coordinates if available
if (coords != Teuchos::null) {
H->GetLevel(0)->Set("Coordinates", coords);
}
// Wrap nullspace if available, otherwise use constants
if (nullspace == Teuchos::null) {
int nPDE = MueLu::MasterList::getDefault<int>("number of equations");
if (paramList.isSublist("Matrix")) {
// Factory style parameter list
const Teuchos::ParameterList& operatorList = paramList.sublist("Matrix");
if (operatorList.isParameter("PDE equations"))
nPDE = operatorList.get<int>("PDE equations");
} else if (paramList.isParameter("number of equations")) {
// Easy style parameter list
nPDE = paramList.get<int>("number of equations");
}
nullspace = MultiVectorFactory::Build(op->getDomainMap(), nPDE);
if (nPDE == 1) {
nullspace->putScalar(Teuchos::ScalarTraits<Scalar>::one());
} else {
for (int i = 0; i < nPDE; i++) {
Teuchos::ArrayRCP<Scalar> nsData = nullspace->getDataNonConst(i);
for (int j = 0; j < nsData.size(); j++) {
GlobalOrdinal GID = op->getDomainMap()->getGlobalElement(j) - op->getDomainMap()->getIndexBase();
if ((GID-i) % nPDE == 0)
nsData[j] = Teuchos::ScalarTraits<Scalar>::one();
}
}
}
}
H->GetLevel(0)->Set("Nullspace", nullspace);
mueLuFactory->SetupHierarchy(*H);
tm->stop();
tm->incrementNumCalls();
if (H->GetVerbLevel() & Statistics0) {
const bool alwaysWriteLocal = true;
const bool writeGlobalStats = true;
const bool writeZeroTimers = false;
const bool ignoreZeroTimers = true;
const std::string filter = timerName;
Teuchos::TimeMonitor::summarize(op->getRowMap()->getComm().ptr(), std::cout, alwaysWriteLocal, writeGlobalStats,
writeZeroTimers, Teuchos::Union, filter, ignoreZeroTimers);
}
tm->reset();
return H;
}
TEUCHOS_UNIT_TEST(SaPFactory_kokkos, EpetraVsTpetra)
{
# include "MueLu_UseShortNames.hpp"
MueLu::VerboseObject::SetDefaultOStream(Teuchos::rcpFromRef(out));
out << "version: " << MueLu::Version() << std::endl;
out << "Compare results of Epetra and Tpetra" << std::endl;
out << "for 3 level AMG solver using smoothed aggregation with" << std::endl;
out << "one SGS sweep on each multigrid level as pre- and postsmoother" << std::endl;
RCP<const Teuchos::Comm<int> > comm = Teuchos::DefaultComm<int>::getComm();
typedef Teuchos::ScalarTraits<SC> STS;
SC zero = STS::zero(), one = STS::one();
Array<STS::magnitudeType> results(2);
// run test only on 1 proc
if(comm->getSize() == 1) {
Xpetra::UnderlyingLib lib = Xpetra::UseEpetra;
// run Epetra and Tpetra test
for (int run = 0; run < 2; run++) { //TODO: create a subfunction instead or Tuple of UnderlyingLib
if (run == 0) lib = Xpetra::UseEpetra;
else lib = Xpetra::UseTpetra;
// generate problem
LO maxLevels = 3;
LO its = 10;
GO nEle = 63;
const RCP<const Map> map = MapFactory::Build(lib, nEle, 0, comm);
Teuchos::ParameterList matrixParameters;
matrixParameters.set("nx", nEle);
RCP<Galeri::Xpetra::Problem<Map,CrsMatrixWrap,MultiVector> > Pr =
Galeri::Xpetra::BuildProblem<SC,LO,GO,Map,CrsMatrixWrap,MultiVector>("Laplace1D", map, matrixParameters);
RCP<Matrix> Op = Pr->BuildMatrix();
// build nullspace
RCP<MultiVector> nullSpace = MultiVectorFactory::Build(map,1);
nullSpace->putScalar(one);
Array<STS::magnitudeType> norms(1);
nullSpace->norm1(norms);
if (comm->getRank() == 0)
out << "||NS|| = " << norms[0] << std::endl;
// fill hierarchy
RCP<Hierarchy> H = rcp( new Hierarchy() );
H->setDefaultVerbLevel(Teuchos::VERB_HIGH);
RCP<Level> Finest = H->GetLevel();
Finest->setDefaultVerbLevel(Teuchos::VERB_HIGH);
Finest->Set("A",Op); // set fine level matrix
Finest->Set("Nullspace",nullSpace); // set null space information for finest level
// define transfer operators
RCP<CoupledAggregationFactory> CoupledAggFact = rcp(new CoupledAggregationFactory());
CoupledAggFact->SetMinNodesPerAggregate(3);
CoupledAggFact->SetMaxNeighAlreadySelected(0);
CoupledAggFact->SetOrdering("natural");
CoupledAggFact->SetPhase3AggCreation(0.5);
RCP<TentativePFactory> Ptentfact = rcp(new TentativePFactory());
RCP<SaPFactory> Pfact = rcp( new SaPFactory());
RCP<Factory> Rfact = rcp( new TransPFactory() );
RCP<RAPFactory> Acfact = rcp( new RAPFactory() );
H->SetMaxCoarseSize(1);
// setup smoothers
Teuchos::ParameterList smootherParamList;
smootherParamList.set("relaxation: type", "Symmetric Gauss-Seidel");
smootherParamList.set("relaxation: sweeps", (LO) 1);
smootherParamList.set("relaxation: damping factor", (SC) 1.0);
RCP<SmootherPrototype> smooProto = rcp( new TrilinosSmoother("RELAXATION", smootherParamList) );
RCP<SmootherFactory> SmooFact = rcp( new SmootherFactory(smooProto) );
Acfact->setVerbLevel(Teuchos::VERB_HIGH);
RCP<SmootherFactory> coarseSolveFact = rcp(new SmootherFactory(smooProto, Teuchos::null));
FactoryManager M;
M.SetFactory("P", Pfact);
M.SetFactory("R", Rfact);
M.SetFactory("A", Acfact);
M.SetFactory("Ptent", Ptentfact);
M.SetFactory("Aggregates", CoupledAggFact);
M.SetFactory("Smoother", SmooFact);
M.SetFactory("CoarseSolver", coarseSolveFact);
H->Setup(M, 0, maxLevels);
// test some basic multigrid data
RCP<Level> coarseLevel = H->GetLevel(1);
TEST_EQUALITY(coarseLevel->IsRequested("A",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("P",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("PreSmoother",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("PostSmoother",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("R",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel->IsAvailable("A",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel->IsAvailable("P",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel->IsAvailable("PreSmoother",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel->IsAvailable("PostSmoother",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel->IsAvailable("R",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel->GetKeepFlag("A",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel->GetKeepFlag("P",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel->GetKeepFlag("PreSmoother",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel->GetKeepFlag("PostSmoother",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel->GetKeepFlag("R",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel->IsRequested("P",Pfact.get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("P",Ptentfact.get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("PreSmoother",SmooFact.get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("PostSmoother",SmooFact.get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("R",Rfact.get()), false);
TEST_EQUALITY(coarseLevel->IsRequested("A",Acfact.get()), false);
TEST_EQUALITY(coarseLevel->IsAvailable("P",Pfact.get()), false);
TEST_EQUALITY(coarseLevel->IsAvailable("P",Ptentfact.get()), false);
TEST_EQUALITY(coarseLevel->IsAvailable("PreSmoother",SmooFact.get()), false);
TEST_EQUALITY(coarseLevel->IsAvailable("PostSmoother",SmooFact.get()), false);
TEST_EQUALITY(coarseLevel->IsAvailable("R",Rfact.get()), false);
TEST_EQUALITY(coarseLevel->IsAvailable("A",Acfact.get()), false);
TEST_EQUALITY(coarseLevel->GetKeepFlag("P",Pfact.get()), 0);
TEST_EQUALITY(coarseLevel->GetKeepFlag("P",Ptentfact.get()), 0);
TEST_EQUALITY(coarseLevel->GetKeepFlag("PreSmoother",SmooFact.get()), 0);
TEST_EQUALITY(coarseLevel->GetKeepFlag("PostSmoother",SmooFact.get()), 0);
TEST_EQUALITY(coarseLevel->GetKeepFlag("R",Rfact.get()), 0);
TEST_EQUALITY(coarseLevel->GetKeepFlag("A",Acfact.get()), 0);
RCP<Matrix> P1 = coarseLevel->Get< RCP<Matrix> >("P");
RCP<Matrix> R1 = coarseLevel->Get< RCP<Matrix> >("R");
TEST_EQUALITY(P1->getGlobalNumRows(), 63);
TEST_EQUALITY(P1->getGlobalNumCols(), 21);
TEST_EQUALITY(R1->getGlobalNumRows(), 21);
TEST_EQUALITY(R1->getGlobalNumCols(), 63);
RCP<Level> coarseLevel2 = H->GetLevel(2);
TEST_EQUALITY(coarseLevel2->IsRequested("A",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel2->IsRequested("P",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel2->IsRequested("R",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel2->IsRequested("PreSmoother",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel2->IsRequested("PostSmoother",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel2->IsAvailable("A",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel2->IsAvailable("P",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel2->IsAvailable("PreSmoother",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel2->IsAvailable("PostSmoother",MueLu::NoFactory::get()), false);
TEST_EQUALITY(coarseLevel2->IsAvailable("R",MueLu::NoFactory::get()), true);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("A",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("P",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("PreSmoother",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("PostSmoother",MueLu::NoFactory::get()), 0);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("R",MueLu::NoFactory::get()), MueLu::Final);
TEST_EQUALITY(coarseLevel2->IsRequested("P",Pfact.get()), false);
TEST_EQUALITY(coarseLevel2->IsRequested("P",Ptentfact.get()), false);
TEST_EQUALITY(coarseLevel2->IsRequested("R",Rfact.get()), false);
TEST_EQUALITY(coarseLevel2->IsAvailable("P",Pfact.get()), false);
TEST_EQUALITY(coarseLevel2->IsAvailable("P",Ptentfact.get()), false);
TEST_EQUALITY(coarseLevel2->IsAvailable("PreSmoother",SmooFact.get()), false);
TEST_EQUALITY(coarseLevel2->IsAvailable("PostSmoother",SmooFact.get()), false);
TEST_EQUALITY(coarseLevel2->IsAvailable("R",Rfact.get()), false);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("P",Pfact.get()), 0);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("P",Ptentfact.get()), 0);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("PreSmoother",SmooFact.get()), 0);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("PostSmoother",SmooFact.get()), 0);
TEST_EQUALITY(coarseLevel2->GetKeepFlag("R",Rfact.get()), 0);
RCP<Matrix> P2 = coarseLevel2->Get< RCP<Matrix> >("P");
RCP<Matrix> R2 = coarseLevel2->Get< RCP<Matrix> >("R");
TEST_EQUALITY(P2->getGlobalNumRows(), 21);
TEST_EQUALITY(P2->getGlobalNumCols(), 7);
TEST_EQUALITY(R2->getGlobalNumRows(), 7);
TEST_EQUALITY(R2->getGlobalNumCols(), 21);
Teuchos::RCP<Xpetra::Matrix<Scalar,LO,GO> > PtentTPtent = Xpetra::MatrixMatrix<Scalar,LO,GO>::Multiply(*P1,true,*P1,false,out);
TEST_EQUALITY(PtentTPtent->getGlobalMaxNumRowEntries()-3<1e-12, true);
TEST_EQUALITY(P1->getGlobalMaxNumRowEntries()-2<1e-12, true);
TEST_EQUALITY(P2->getGlobalMaxNumRowEntries()-2<1e-12, true);
// Define RHS
RCP<MultiVector> X = MultiVectorFactory::Build(map,1);
RCP<MultiVector> RHS = MultiVectorFactory::Build(map,1);
X->putScalar(1.0);
X->norm2(norms);
if (comm->getRank() == 0)
out << "||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->Iterate(*RHS,*X,its);
X->norm2(norms);
if (comm->getRank() == 0)
out << "||X_" << std::setprecision(2) << its << "|| = " << std::setiosflags(std::ios::fixed) << std::setprecision(10) << norms[0] << std::endl;
results[run] = norms[0];
}
}
TEST_EQUALITY(results[0] - results[1] < 1e-10, true); // check results of EPETRA vs TPETRA
} // comm->getSize == 1
} //SaPFactory_EpetraVsTpetra
int main(int argc, char* argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > commptr =
Teuchos::DefaultComm<int>::getComm();
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0 && commptr->getRank() == 0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
try {
/**********************************************************************************************/
/************************* CONSTRUCT SOL COMPONENTS *******************************************/
/**********************************************************************************************/
// Set random seed
srand(123456789);
// Build samplers
size_t dimension = 1;
// Initialize distribution
Teuchos::RCP<ROL::Distribution<RealT> > dist;
std::vector<Teuchos::RCP<ROL::Distribution<RealT> > > distVec(dimension);
Teuchos::ParameterList Dlist;
Dlist.sublist("SOL").sublist("Distribution").set("Name","Beta");
RealT alpha = 1., beta = 4.;
// Fill moment vector and initial guess
for (size_t d = 0; d < dimension; d++) {
// Build distribution for dimension d
alpha++; beta++;
Dlist.sublist("SOL").sublist("Distribution").sublist("Beta").set("Shape 1",alpha);
Dlist.sublist("SOL").sublist("Distribution").sublist("Beta").set("Shape 2",beta);
dist = ROL::DistributionFactory<RealT>(Dlist);
distVec[d] = ROL::DistributionFactory<RealT>(Dlist);
}
// Get ROL parameterlist
std::string filename = "input_04.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
Teuchos::ParameterList &list = parlist->sublist("SOL").sublist("Sample Generator").sublist("SROM");
Teuchos::Array<int> moments = Teuchos::getArrayFromStringParameter<int>(list,"Moments");
size_t numMoments = static_cast<size_t>(moments.size());
std::clock_t timer = std::clock();
Teuchos::RCP<ROL::BatchManager<RealT> > bman =
Teuchos::rcp(new ROL::TeuchosBatchManager<RealT,int>(commptr));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler =
Teuchos::rcp(new ROL::SROMGenerator<RealT>(*parlist,bman,distVec));
*outStream << std::endl << "Sample Time: "
<< (std::clock()-timer)/(RealT)CLOCKS_PER_SEC << " seconds"
<< std::endl;
RealT val = 0., error = 0., data = 0., sum = 0.;
*outStream << std::endl;
*outStream << std::scientific << std::setprecision(11);
*outStream << std::right << std::setw(20) << "Computed Moment"
<< std::setw(20) << "True Moment"
<< std::setw(20) << "Relative Error"
<< std::endl;
for (size_t m = 0; m < numMoments; m++) {
for (size_t d = 0; d < dimension; d++) {
val = 0.; data = distVec[d]->moment(moments[m]);
for (size_t k = 0; k < (size_t)sampler->numMySamples(); k++) {
val += sampler->getMyWeight(k)*std::pow((sampler->getMyPoint(k))[d],moments[m]);
}
bman->sumAll(&val,&sum,1);
error = std::abs(sum-data)/std::abs(data);
if ( error > 1.e-1 ) {
errorFlag++;
}
*outStream << std::right << std::setw(20) << sum
<< std::setw(20) << data
<< std::setw(20) << error
<< std::endl;
}
}
*outStream << std::endl;
// std::ofstream file;
// std::stringstream name;
// name << "samples." << commptr->getRank() << ".txt";
// file.open(name.str().c_str());
// for (size_t k = 0; k < (size_t)sampler->numMySamples(); k++) {
// for (size_t d = 0; d < dimension; d++) {
// file << std::setprecision(std::numeric_limits<RealT>::digits10)
// << std::scientific
// << (sampler->getMyPoint(k))[d];
// file << " ";
// }
// file << std::setprecision(std::numeric_limits<RealT>::digits10)
// << std::scientific
// << sampler->getMyWeight(k) << std::endl;
// }
// file.close();
// commptr->barrier();
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main(int argc, char* argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
using Teuchos::CommandLineProcessor;
using Teuchos::OSTab;
bool result, success = true;
bool verbose = true;
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read options from command-line
//
std::string matrixDir = ".";
bool testTranspose = true;
int numRandomVectors = 1;
bool showAllTests = false;
bool showAllTestsDetails = false;
bool dumpAll = false;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption( "matrix-dir", &matrixDir, "Base directory for the test matrices" );
clp.setOption( "test-transpose", "no-test-transpose", &testTranspose, "Test the transpose solve or not." );
clp.setOption( "num-random-vectors", &numRandomVectors, "Number of times a test is performed with different random vectors." );
clp.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
clp.setOption( "show-all-tests", "no-show-all-tests", &showAllTests, "Set if all the tests are shown or not." );
clp.setOption( "show-all-tests-details", "no-show-all-tests-details", &showAllTestsDetails, "Set if all the details of the tests are shown or not." );
clp.setOption( "dump-all", "no-dump-all", &dumpAll, "Determines if vectors are printed or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
TEUCHOS_TEST_FOR_EXCEPT( matrixDir == "" );
//
// Define the test matrices
//
const int numTestMatrices = 9;
typedef MatrixTestPacket MTP;
// Set up the matices and the tolerances.
// Note, we may need to adjust these for bad platforms ...
const MTP testMatrices[numTestMatrices] =
{
MTP("bcsstk01.mtx",false,1e-12,1e-12,1e-12)
,MTP("bcsstk02.mtx",false,1e-12,1e-12,1e-12)
,MTP("bcsstk04.mtx",false,1e-12,1e-10,1e-12)
,MTP("Diagonal.mtx",false,1e-12,1e-12,1e-12)
,MTP("FourByFour.mtx",true,1e-12,1e-12,1e-12)
,MTP("KheadK.mtx",false,1e-12,1e-12,1e-12)
,MTP("KheadSorted.mtx",false,1e-12,1e-12,1e-12)
,MTP("nos1.mtx",false,1e-11,1e-10,1e-12)
,MTP("nos5.mtx",false,1e-12,1e-12,1e-12)
};
//
// Loop through all of the test matrices
//
for( int matrix_i = 0; matrix_i < numTestMatrices; ++matrix_i ) {
const MatrixTestPacket
mtp = testMatrices[matrix_i];
//
// Loop through all of the solvers
//
for( int solver_i = 0; solver_i < Thyra::Amesos::numSolverTypes; ++solver_i ) {
const Thyra::Amesos::ESolverType
solverType = Thyra::Amesos::solverTypeValues[solver_i];
// bug 1902 - Amesos_Superlu fails on bcsstk01.mtx
// bug 1903 - Amesos_Superlu fails on four matrices,
// when called from the thyra test
//
bool BadMatrixForSuperlu =
mtp.matrixFile == "bcsstk01.mtx" // bug 1902
|| mtp.matrixFile == "bcsstk04.mtx" // bug 1903
|| mtp.matrixFile == "KheadK.mtx" // bug 1903
|| mtp.matrixFile == "KheadSorted.mtx" // bug 1903
|| mtp.matrixFile == "nos1.mtx" ; // bug 1903
//
// Toggle the refactorization options
//
for( int factorizationPolicy_i = 0; factorizationPolicy_i < Thyra::Amesos::numRefactorizationPolices; ++factorizationPolicy_i ) {
const Thyra::Amesos::ERefactorizationPolicy
refactorizationPolicy = Thyra::Amesos::refactorizationPolicyValues[factorizationPolicy_i];
if(verbose)
*out
<< std::endl<<matrix_i<<"."<<solver_i<<"."<<factorizationPolicy_i<<": "
<< "Testing, matrixFile=\'"<<mtp.matrixFile<<"\', solverType=\'"<<toString(solverType)<<"\', refactorizationPolicy=\'"<<toString(refactorizationPolicy)<<"\' ...";
if( mtp.unsymmetric && !Thyra::Amesos::supportsUnsymmetric[solver_i] ) {
*out << " : Skipping since unsymmetric and not supported!\n";
}
else {
// bug 1902 and bug 1903
string StrSolverType = toString(solverType) ;
string StrSuperlu = "Superlu";
if ( StrSolverType==StrSuperlu && BadMatrixForSuperlu ) {
*out << " : Skipping since Superlu fails on this matrix!\n";
}
else {
std::ostringstream ossStore;
Teuchos::RCP<Teuchos::FancyOStream>
oss = Teuchos::rcp(new Teuchos::FancyOStream(Teuchos::rcp(&ossStore,false)));
Teuchos::ParameterList amesosLOWSFPL;
amesosLOWSFPL.set("Solver Type",toString(solverType));
amesosLOWSFPL.set("Refactorization Policy",toString(refactorizationPolicy));
result =
Thyra::test_single_amesos_thyra_solver(
matrixDir+"/"+mtp.matrixFile,&amesosLOWSFPL,testTranspose,numRandomVectors
,mtp.maxFwdError,mtp.maxError,mtp.maxResid,showAllTestsDetails,dumpAll,OSTab(oss).get()
);
if(!result) success = false;
if(verbose) {
if(result) {
if(showAllTests)
*out << std::endl << ossStore.str();
else
*out << " : passed!\n";
}
else {
if(showAllTests)
*out << std::endl << ossStore.str();
else
*out << " : failed!\n";
}
}
}
}
}
}
}
}
catch( const std::exception &excpt ) {
std::cerr << "*** Caught standard exception : " << excpt.what() << std::endl;
success = false;
}
catch( ... ) {
std::cerr << "*** Caught an unknown exception\n";
success = false;
}
if (verbose) {
if(success) *out << "\nCongratulations! All of the tests checked out!\n";
else *out << "\nOh no! At least one of the tests failed!\n";
}
return ( success ? 0 : 1 );
}
bool Options::setOptions(Teuchos::ParameterList& nlParams)
{
// Set status tests if not already set
if( Teuchos::is_null(testCombo) )
{
// Check for MaxIters option
int maxIters;
#if (PETSC_VERSION_MAJOR >= 3) || (PETSC_VERSION_MINOR >= 5)
PetscBool lflg;
#else
PetscTruth lflg; // Needed to permit two ways of specification
#endif
ierr = PetscOptionsGetInt(PETSC_NULL,"-snes_max_it", &maxIters, &flg);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(PETSC_NULL,"-nox_conv_maxiters", &maxIters, &lflg);CHKERRQ(ierr);
if(flg || lflg)
{
testMaxIters = Teuchos::rcp( new NOX::StatusTest::MaxIters(maxIters) );
if( Teuchos::is_null(testCombo) )
testCombo = Teuchos::rcp( new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR, testMaxIters) );
else
testCombo->addStatusTest(testMaxIters);
}
// Check for (absolute) residual norm (L2-norm) tolerance
double absResNorm;
PetscReal petscVal;
ierr = PetscOptionsGetReal(PETSC_NULL,"-snes_atol", &petscVal, &flg);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(PETSC_NULL,"-nox_conv_abs_res", &petscVal, &lflg);CHKERRQ(ierr);
if(flg || lflg)
{
absResNorm = (double) petscVal;
testNormF = Teuchos::rcp( new NOX::StatusTest::NormF(absResNorm) );
if( Teuchos::is_null(testCombo) )
testCombo = Teuchos::rcp( new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR, testNormF) );
else
testCombo->addStatusTest(testNormF);
}
// Check for update norm (L2-norm) tolerance
double absUpdateNorm;
ierr = PetscOptionsGetReal(PETSC_NULL,"-snes_stol", &petscVal, &flg);CHKERRQ(ierr);
ierr = PetscOptionsGetReal(PETSC_NULL,"-nox_conv_update", &petscVal, &lflg);CHKERRQ(ierr);
if(flg || lflg)
{
absUpdateNorm = (double) petscVal;
testNormUpdate = Teuchos::rcp( new NOX::StatusTest::NormUpdate(absUpdateNorm) );
if( Teuchos::is_null(testCombo) )
testCombo = Teuchos::rcp( new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR, testNormUpdate) );
else
testCombo->addStatusTest(testNormUpdate);
}
// Finally, provide a default test if none specified
if( Teuchos::is_null(testCombo) ) // No tests specified by the uesr
{
assert( Teuchos::is_null(testMaxIters) );
testMaxIters = Teuchos::rcp( new NOX::StatusTest::MaxIters(20) );
assert( Teuchos::is_null(testNormF) );
testNormF = Teuchos::rcp( new NOX::StatusTest::NormF(1.e-12) );
testCombo = Teuchos::rcp( new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR, testMaxIters, testNormF) );
}
} // End of StatusTest construction
// Allow solution-type to be specified
ierr = PetscOptionsHasName(PETSC_NULL,"-nox_trustregion_based",&flg);
CHKERRQ(ierr);
if(flg)
nlParams.set("Nonlinear Solver", "Trust Region Based");
else // default
// This is done to allow PetscOptions to register that this option was used
ierr = PetscOptionsHasName(PETSC_NULL,"-nox_linesearch_based",&flg);
CHKERRQ(ierr);
nlParams.set("Nonlinear Solver", "Line Search Based");
// Now allow linesearch type to be specified
Teuchos::ParameterList& searchParams = nlParams.sublist("Line Search");
ierr = PetscOptionsGetString(PETSC_NULL,"-nox_linesearch_type",
optionString, maxStringLength, &flg);CHKERRQ(ierr);
if(flg)
{
if( !strcmp(optionString, "full_step") )
searchParams.set("Method", "Full Step");
if( !strcmp(optionString, "polynomial") )
searchParams.set("Method", "Polynomial");
if( !strcmp(optionString, "backtrack") )
searchParams.set("Method", "Backtrack");
if( !strcmp(optionString, "more_thuente") )
searchParams.set("Method", "More'-Thuente");
#ifdef WITH_PRERELEASE
if( !strcmp(optionString, "nonlinearcg") )
searchParams.set("Method", "NonlinearCG");
#endif
}
else // default
searchParams.set("Method", "Full Step");
// Now allow direction type to be specified
Teuchos::ParameterList& dirParams = nlParams.sublist("Direction");
ierr = PetscOptionsGetString(PETSC_NULL,"-nox_direction_type",
optionString, maxStringLength, &flg);CHKERRQ(ierr);
if(flg)
{
if( !strcmp(optionString, "newton") )
dirParams.set("Method", "Newton");
if( !strcmp(optionString, "steepest_descent") )
{
dirParams.set("Method", "Steepest Descent");
// Check to see if any steepest_descent options are set
#if (PETSC_VERSION_MAJOR >= 3) || (PETSC_VERSION_MINOR >= 5)
PetscBool lflg;
#else
PetscTruth lflg;
#endif
ierr = PetscOptionsGetString(PETSC_NULL,"-nox_sd_scaling_type",
optionString, maxStringLength, &lflg);CHKERRQ(ierr);
if(lflg)
{
Teuchos::ParameterList& sdParams = dirParams.sublist("Steepest Descent");
if( !strcmp(optionString, "none") )
sdParams.set("Scaling Type", "None");
else if( !strcmp(optionString, "2norm") )
sdParams.set("Scaling Type", "2-Norm");
else if( !strcmp(optionString, "quadratic_model_min") )
sdParams.set("Scaling Type", "Quadratic Model Min");
else
{
if(rank == 0) std::cout << "WARNING: Unsupported Steepest Descent "
<< "Scaling Type --> " << optionString << std::endl;
sdParams.set("Scaling Type", "None"); // default
}
}
}
#ifdef WITH_PRERELEASE
if( !strcmp(optionString, "nonlinearcg") )
dirParams.set("Method", "Nonlinear CG");
// Need to make provision for the following
//Teuchos::ParameterList& nlcgParams = dirParams.sublist("Nonlinear CG");
//nlcgParams.set("Restart Frequency", 2000);
//nlcgParams.set("Precondition", "On");
//nlcgParams.set("Orthogonalize", "Polak-Ribiere");
//nlcgParams.set("Orthogonalize", "Fletcher-Reeves");
#endif
}
else // default
dirParams.set("Method", "Newton");
// Now set output parameters via the "Printing" sublist
// These are hard-coded for now
Teuchos::ParameterList& printParams = nlParams.sublist("Printing");
printParams.set("MyPID", rank);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::Warning);
return true;
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession session(&argc, &argv);
Teuchos::RCP<const Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
int rank = comm->getRank();
int nprocs = comm->getSize();
int fail = 0;
////////////////////////////////////////////////////////////
// Create a default Environment and test it
Environment *defEnv = NULL;
try{
defEnv = new Environment;
}
catch(std::exception &e){
std::cerr << e.what() << std::endl;
fail=1000;
}
if (checkErrorCode(comm, fail))
return 1;
if (!fail && defEnv->myRank_ != rank)
fail = 1001;
if (!fail && defEnv->numProcs_ != nprocs)
fail = 1002;
if (!fail && defEnv->comm_->getSize() != nprocs)
fail = 1003;
if (!fail && defEnv->doStatus() != true)
fail = 1005;
if (!fail && defEnv->doTiming() != false)
fail = 1006;
if (!fail && defEnv->doMemoryProfiling() != false)
fail = 1007;
if (!fail && defEnv->errorCheckLevel_ != Zoltan2::BASIC_ASSERTION)
fail = 1008;
if (checkErrorCode(comm, fail))
return 1;
delete defEnv;
////////////////////////////////////////////////////////////
// Set a few parameters and create an Environment
Teuchos::ParameterList myParams("testParameterList");
myParams.set("debug_level", "detailed_status");
myParams.set("debug_procs", "all");
myParams.set("debug_output_stream", "std::cout");
if (nprocs > 3)
myParams.set("memory_procs", "0-1,3");
else
myParams.set("memory_procs", "0");
myParams.set("memory_output_file", "memInfo.txt");
myParams.set("speed_versus_quality", "speed");
myParams.set("memory_versus_speed", "memory");
myParams.set("topology", "2,6,6");
myParams.set("randomize_input", "true");
myParams.set("partitioning_objective", "minimize_cut_edge_weight");
myParams.set("imbalance_tolerance", 1.2);
Environment *env = NULL;
try{
env = new Environment(myParams, comm);
}
catch(std::exception &e){
std::cerr << e.what() << std::endl;
fail=2000;
}
if (!fail){
try{
env->debug(Zoltan2::BASIC_STATUS, "A basic debugging message.");
}
catch(std::exception &e){
std::cerr << e.what() << std::endl;
fail=3000;
}
}
if (!fail){
try{
env->memory("Memory info");
env->memory("Memory info next");
env->memory("Memory info after");
}
catch(std::exception &e){
std::cerr << e.what() << std::endl;
fail=3002;
}
}
if (checkErrorCode(comm, fail))
return 1;
if (!fail && env->myRank_ != rank)
fail = 2001;
if (!fail && env->numProcs_ != nprocs)
fail = 2002;
if (!fail && env->comm_->getSize() != nprocs)
fail = 2003;
if (!fail){
const Teuchos::ParameterList &pl1 = env->getParameters();
const ParameterEntry *dl = pl1.getEntryPtr("debug_level");
if (!dl){
fail = 2004;
}
else if (!(dl->isType<int>())){
fail = 2013;
}
else{
int value;
int &val = dl->getValue<int>(&value);
if (val != Zoltan2::DETAILED_STATUS)
fail = 2005;
}
}
if (!fail && env->errorCheckLevel_ != Zoltan2::BASIC_ASSERTION)
fail = 2008;
if (checkErrorCode(comm, fail))
return 1;
if (rank==0){
std::cout << "\nA test parameter list" << std::endl;
const Teuchos::ParameterList &envParams = env->getParameters();
try{
envParams.print();
}
catch(std::exception &e){
std::cerr << e.what() << std::endl;
fail=2013;
}
}
if (checkErrorCode(comm, fail))
return 1;
////////////////////////////////////////////////////////////
// Given an existing Environment, get its parameters and
// add some new parameters and create a new Environment.
RCP<const Comm<int> > oldComm = env->comm_;
const Teuchos::ParameterList &oldParams = env->getUnvalidatedParameters();
Teuchos::ParameterList newParams = oldParams;
newParams.set("error_check_level", "debug_mode_assertions");
newParams.set("memory_versus_speed", "speed");
newParams.remove("memory_output_file");
newParams.set("imbalance_tolerance", "1.05");
newParams.set("algorithm", "phg");
newParams.set("partitioning_objective", "minimize_cut_edge_weight");
RCP<Environment> newEnv;
try{
newEnv = Teuchos::rcp(new Environment(newParams, oldComm));
}
catch(std::exception &e){
std::cerr << e.what() << std::endl;
fail=3000;
}
if (checkErrorCode(comm, fail))
return 1;
if (!fail && newEnv->errorCheckLevel_ != Zoltan2::DEBUG_MODE_ASSERTION)
fail = 3001;
if (!fail && rank==0){
std::cout << "\nA few changes/additions to the list" << std::endl;
const Teuchos::ParameterList &envParams = newEnv->getParameters();
try{
envParams.print();
}
catch(std::exception &e){
std::cerr << e.what() << std::endl;
fail=3003;
}
}
if (checkErrorCode(comm, fail))
return 1;
delete env;
if (rank==0)
std::cout << "PASS" << std::endl;
return 0;
}
int main(int argc, char *argv[])
{
// Create a communicator for Epetra objects.
#ifdef HAVE_MPI
MPI_Init( &argc, &argv );
RCP<const Epetra_MpiComm> Comm =
rcp<Epetra_MpiComm>(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
RCP<const Epetra_SerialComm> Comm =
rcp<Epetra_SerialComm>(new Epetra_SerialComm());
#endif
const int NumGlobalElements = 10;
// ---------------------------------------------------------------------------
// Construct a Map with NumElements and index base of 0
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]);
// NumNz[i] is the number of nonzero elements in row i of the sparse
// matrix on this MPI process. Epetra_CrsMatrix uses this to figure
// out how much space to allocate.
std::vector<int> NumNz (NumMyElements);
// We are building a tridiagonal matrix where each row contains the
// nonzero elements (-1 2 -1). Thus, we need 2 off-diagonal terms,
// except for the first and last row of the matrix.
for (int i = 0; i < NumMyElements; ++i)
if (MyGlobalElements[i] == 0 || MyGlobalElements[i] == NumGlobalElements-1)
NumNz[i] = 2; // First or last row
else
NumNz[i] = 3; // Not the (first or last row)
// Create the Epetra_CrsMatrix.
Epetra_CrsMatrix A (Copy, Map, &NumNz[0]);
//
// Add rows to the sparse matrix one at a time.
//
std::vector<double> Values(2);
Values[0] = -1.0; Values[1] = -1.0;
std::vector<int> Indices(2);
const double two = 2.0;
int NumEntries;
for (int i = 0; i < NumMyElements; ++i)
{
if (MyGlobalElements[i] == 0)
{ // The first row of the matrix.
Indices[0] = 1;
NumEntries = 1;
}
else if (MyGlobalElements[i] == NumGlobalElements - 1)
{ // The last row of the matrix.
Indices[0] = NumGlobalElements-2;
NumEntries = 1;
}
else
{ // Any row of the matrix other than the first or last.
Indices[0] = MyGlobalElements[i]-1;
Indices[1] = MyGlobalElements[i]+1;
NumEntries = 2;
}
TEUCHOS_ASSERT_EQUALITY(0, A.InsertGlobalValues(MyGlobalElements[i], NumEntries, &Values[0], &Indices[0]));
// Insert the diagonal entry.
TEUCHOS_ASSERT_EQUALITY(0, A.InsertGlobalValues(MyGlobalElements[i], 1, &two, &MyGlobalElements[i]));
}
// Finish up. We can call FillComplete() with no arguments, because
// the matrix is square.
TEUCHOS_ASSERT_EQUALITY(0, A.FillComplete());
// ---------------------------------------------------------------------------
// Now setup the Belos solver.
Teuchos::ParameterList belosList;
belosList.set("Convergence Tolerance", 1.0e-10);
belosList.set("Maximum Iterations", 1000);
belosList.set("Output Frequency", 1);
belosList.set("Output Style", (int) Belos::Brief);
belosList.set("Verbosity", Belos::Errors+Belos::StatusTestDetails+Belos::Warnings+Belos::TimingDetails+Belos::IterationDetails+Belos::FinalSummary );
RCP<Epetra_Vector> x = rcp(new Epetra_Vector(Map));
TEUCHOS_ASSERT_EQUALITY(0, x->PutScalar(0.0)); // not strictly necessary
RCP<Epetra_Vector> b = rcp(new Epetra_Vector(Map));
TEUCHOS_ASSERT_EQUALITY(0, b->Random());
// Construct an unpreconditioned linear problem instance.
Belos::LinearProblem<double,MV,OP> problem(Teuchos::rcpFromRef(A),
x, b);
// Make sure the problem sets up correctly.
TEUCHOS_ASSERT(problem.setProblem());
// Create an iterative solver manager.
RCP<Belos::SolverManager<double,MV,OP> > newSolver =
rcp(new Belos::PseudoBlockCGSolMgr<double,MV,OP>(rcp(&problem, false), rcp(&belosList, false)));
// Perform solve.
Belos::ReturnType ret = newSolver->solve();
if (ret==Belos::Converged)
std::cout << "Success!" << std::endl;
// ---------------------------------------------------------------------------
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return EXIT_SUCCESS;
}
// Constructor
CubicInterp( Teuchos::ParameterList &parlist ) : LineSearch<Real>(parlist) {
rho_ = parlist.sublist("Step").sublist("Line Search").sublist("Line-Search Method").get("Backtracking Rate",0.5);
}
// ======================================================================
bool TestContainer(std::string Type, const Teuchos::RefCountPtr<Epetra_RowMatrix>& A)
{
using std::cout;
using std::endl;
int NumVectors = 3;
int NumMyRows = A->NumMyRows();
Epetra_MultiVector LHS_exact(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector LHS(A->RowMatrixRowMap(), NumVectors);
Epetra_MultiVector RHS(A->RowMatrixRowMap(), NumVectors);
LHS_exact.Random(); LHS.PutScalar(0.0);
A->Multiply(false, LHS_exact, RHS);
Epetra_LinearProblem Problem(&*A, &LHS, &RHS);
if (verbose) {
cout << "Container type = " << Type << endl;
cout << "NumMyRows = " << NumMyRows << ", NumVectors = " << NumVectors << endl;
}
LHS.PutScalar(0.0);
Teuchos::RefCountPtr<Ifpack_Container> Container;
if (Type == "dense")
Container = Teuchos::rcp( new Ifpack_DenseContainer(A->NumMyRows(), NumVectors) );
else
Container = Teuchos::rcp( new Ifpack_SparseContainer<Ifpack_Amesos>(A->NumMyRows(), NumVectors) );
assert (Container != Teuchos::null);
IFPACK_CHK_ERR(Container->Initialize());
// set as ID all the local rows of A
for (int i = 0 ; i < A->NumMyRows() ; ++i)
Container->ID(i) = i;
// extract submatrix (in this case, the entire matrix)
// and complete setup
IFPACK_CHK_ERR(Container->Compute(*A));
// set the RHS and LHS
for (int i = 0 ; i < A->NumMyRows() ; ++i)
for (int j = 0 ; j < NumVectors ; ++j) {
Container->RHS(i,j) = RHS[j][i];
Container->LHS(i,j) = LHS[j][i];
}
// set parameters (empty for dense containers)
Teuchos::ParameterList List;
List.set("amesos: solver type", Type);
IFPACK_CHK_ERR(Container->SetParameters(List));
// solve the linear system
IFPACK_CHK_ERR(Container->ApplyInverse());
// get the computed solution, store it in LHS
for (int i = 0 ; i < A->NumMyRows() ; ++i)
for (int j = 0 ; j < NumVectors ; ++j) {
LHS[j][i] = Container->LHS(i,j);
}
double residual = Galeri::ComputeNorm(&LHS, &LHS_exact);
if (A->Comm().MyPID() == 0 && verbose) {
cout << "||x_exact - x||_2 = " << residual << endl;
cout << *Container;
}
bool passed = false;
if (residual < 1e-5)
passed = true;
return(passed);
}
int main(int narg, char** arg)
{
std::string inputFile = ""; // Matrix Market file to read
std::string outputFile = ""; // Matrix Market file to write
bool verbose = false; // Verbosity of output
int testReturn = 0;
////// Establish session.
Teuchos::GlobalMPISession mpiSession(&narg, &arg, NULL);
RCP<const Teuchos::Comm<int> > comm =
Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
int me = comm->getRank();
// Read run-time options.
Teuchos::CommandLineProcessor cmdp (false, false);
cmdp.setOption("inputFile", &inputFile,
"Name of a Matrix Market file in the data directory; "
"if not specified, a matrix will be generated by MueLu.");
cmdp.setOption("outputFile", &outputFile,
"Name of the Matrix Market sparse matrix file to write, "
"echoing the input/generated matrix.");
cmdp.setOption("verbose", "quiet", &verbose,
"Print messages and results.");
//////////////////////////////////
// Even with cmdp option "true", I get errors for having these
// arguments on the command line. (On redsky build)
// KDDKDD Should just be warnings, right? Code should still work with these
// KDDKDD params in the create-a-matrix file. Better to have them where
// KDDKDD they are used.
int xdim=10;
int ydim=10;
int zdim=10;
std::string matrixType("Laplace3D");
cmdp.setOption("x", &xdim,
"number of gridpoints in X dimension for "
"mesh used to generate matrix.");
cmdp.setOption("y", &ydim,
"number of gridpoints in Y dimension for "
"mesh used to generate matrix.");
cmdp.setOption("z", &zdim,
"number of gridpoints in Z dimension for "
"mesh used to generate matrix.");
cmdp.setOption("matrix", &matrixType,
"Matrix type: Laplace1D, Laplace2D, or Laplace3D");
//////////////////////////////////
cmdp.parse(narg, arg);
RCP<UserInputForTests> uinput;
if (inputFile != "") // Input file specified; read a matrix
uinput = rcp(new UserInputForTests(testDataFilePath, inputFile, comm, true));
else // Let MueLu generate a matrix
uinput = rcp(new UserInputForTests(xdim, ydim, zdim, matrixType, comm, true, true));
RCP<SparseMatrix> origMatrix = uinput->getUITpetraCrsMatrix();
if (outputFile != "") {
// Just a sanity check.
Tpetra::MatrixMarket::Writer<SparseMatrix>::writeSparseFile(outputFile,
origMatrix, verbose);
}
if (me == 0)
cout << "NumRows = " << origMatrix->getGlobalNumRows() << endl
<< "NumNonzeros = " << origMatrix->getGlobalNumEntries() << endl
<< "NumProcs = " << comm->getSize() << endl;
////// Create a vector to use with the matrix.
RCP<Vector> origVector, origProd;
origProd = Tpetra::createVector<z2TestScalar,z2TestLO,z2TestGO>(
origMatrix->getRangeMap());
origVector = Tpetra::createVector<z2TestScalar,z2TestLO,z2TestGO>(
origMatrix->getDomainMap());
origVector->randomize();
////// Specify problem parameters
Teuchos::ParameterList params;
////// Basic metric checking of the ordering solution
size_t checkLength;
z2TestLO *checkPerm;
////// Create an input adapter for the Tpetra matrix.
SparseMatrixAdapter adapter(origMatrix);
params.set("order_method", "minimum_degree");
params.set("order_package", "amd");
////// Create and solve ordering problem
try
{
Zoltan2::OrderingProblem<SparseMatrixAdapter> problem(&adapter, ¶ms);
problem.solve();
Zoltan2::OrderingSolution<z2TestLO, z2TestGO> *soln = problem.getSolution();
// Check that the solution is really a permutation
checkLength = soln->getPermutationSize();
checkPerm = soln->getPermutation();
for (size_t ii = 0; ii < checkLength; ii++)
cout << checkPerm[ii] << " ";
cout << endl;
// Verify that checkPerm is a permutation
testReturn = validatePerm(checkLength, checkPerm);
} catch (std::exception &e){
#ifdef HAVE_ZOLTAN2_AMD
// AMD is defined and still got an exception.
if (comm->getSize() != 1)
{
std::cout << "AMD is enabled. We do not support distributed matrices."
<< "AMD Algorithm threw an exception."
<< std::endl;
std::cout << "PASS" << std::endl;
}
else
{
std::cout << "Exception from AMD Algorithm" << std::endl;
std::cout << "FAIL" << std::endl;
}
return 0;
#else
std::cout << "AMD is not enabled. AMD Algorithm threw an exception."
<< std::endl;
std::cout << "PASS" << std::endl;
return 0;
#endif
}
if (me == 0) {
if (testReturn)
std::cout << "Solution is not a permutation; FAIL" << std::endl;
else
std::cout << "PASS" << std::endl;
}
return 0;
}
int main(int argc, char *argv[]){
Teuchos::GlobalMPISession mpisess(&argc, &argv);\
//Define communicator:
Tpetra::DefaultPlatform::DefaultPlatformType& platform = Tpetra::DefaultPlatform::getDefaultPlatform();
Teuchos::RCP<const Teuchos::Comm<int> > comm = platform.getComm();
typedef int LocalOrdinal;
typedef int GlobalOrdinal;
typedef double Scalar;
typedef Tpetra::DefaultPlatform::DefaultPlatformType::NodeType Node;
//typedef Tpetra::CrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node> sparse_matrix_type;
//typedef Tpetra::CrsGraph<LocalOrdinal,GlobalOrdinal,Node> crsgraph;
//typedef Tpetra::MatrixMarket::Reader<sparse_matrix_type> reader_type;
// typedef our matrix/local inverse type to make life a little easier
typedef Tpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> CRS;
typedef Ifpack2::BlockRelaxation<CRS, Ifpack2::SparseContainer<CRS,Ifpack2::ILUT<CRS> > > BlockRelax;
//typedef KokkosClassic::SerialNode node_type;
using Teuchos::RCP;
// Initialize a "FancyOStream" to output to standard out (cout)
Teuchos::RCP<Teuchos::FancyOStream> out = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
out->setOutputToRootOnly(0);
// **************************************** //
// 1D Poisson Test //
// **************************************** //
// ************************************************************************************************** //
// Create our matrix!
// Parameters
GlobalOrdinal numGlobalDOFs = 32;
// Create a map
Teuchos::RCP<const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > myMap = Tpetra::createUniformContigMap<LocalOrdinal,GlobalOrdinal>(numGlobalDOFs,comm);
// Get update list and number of local equations from newly created map
const size_t numMyDOFs = myMap->getNodeNumElements();
Teuchos::ArrayView<const GlobalOrdinal> myGlobalDOFs = myMap->getNodeElementList();
// Create a CrsMatrix using the map
Teuchos::RCP<Tpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> > A = Teuchos::rcp(new Tpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node>(myMap,3));
// Add rows
for (size_t ii = 0; ii < numMyDOFs; ii++){
if (myGlobalDOFs[ii] == 0) { //left boundary
A->insertGlobalValues(myGlobalDOFs[ii],
Teuchos::tuple<GlobalOrdinal>(myGlobalDOFs[ii],myGlobalDOFs[ii]+1),
Teuchos::tuple<Scalar>(2.0,-1.0));
}
else if (myGlobalDOFs[ii] == numGlobalDOFs - 1) { //right boundary
A->insertGlobalValues(myGlobalDOFs[ii],
Teuchos::tuple<GlobalOrdinal>(myGlobalDOFs[ii]-1,myGlobalDOFs[ii]),
Teuchos::tuple<Scalar>(-1.0,2.0));
}
else { //interior
A->insertGlobalValues(myGlobalDOFs[ii],
Teuchos::tuple<GlobalOrdinal>(myGlobalDOFs[ii]-1,myGlobalDOFs[ii],myGlobalDOFs[ii]+1),
Teuchos::tuple<Scalar>(-1.0,2.0,-1.0));
}
}
// Complete the fill
A->fillComplete();
// ************************************************************************************************** //
// Set up ifpack2 parameters
Teuchos::ParameterList MyList;
// Distribute the local dofs linearly across nonoverlapping partitions
MyList.set("partitioner: type" ,"linear");
// Distribute the local dofs over how many partitions?
MyList.set("partitioner: local parts",(LocalOrdinal) A->getNodeNumRows());
// How much overlap in the partitions
MyList.set("partitioner: overlap" ,(int) 1);
// What type of block relaxation should we use?
MyList.set("relaxation: type" ,"Gauss-Seidel");
// How many sweeps?
MyList.set("relaxation: sweeps" ,(int) 1);
// How much damping?
MyList.set("relaxation: damping factor",1.0);
// Do we have a zero initial guess
MyList.set("relaxation: zero starting solution", false);
// Solving local blocks with ILUT, so we need some parameters
MyList.set("fact: absolute threshold", 0.0);
MyList.set("fact: relative threshold", 1.0);
MyList.set("fact: ilut level-of-fill", 3.0);
// Schwarz for the parallel
MyList.set("schwarz: overlap level", (int) 1);
// Create our preconditioner
// Ifpack2::BlockRelaxation<CRS, Ifpack2::SparseContainer<CRS,Ifpack2::ILUT<CRS> > > prec(A);
Ifpack2::AdditiveSchwarz<CRS,BlockRelax> prec(A);
// Set the parameters
prec.setParameters(MyList);
// Initialize everything
prec.initialize();
// Compute - this will form the blocks and factor the local matrices
prec.compute();
// Define RHS / Initial Guess
Teuchos::RCP<Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > X = Tpetra::createVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>(myMap);
Teuchos::RCP<Tpetra::Vector<Scalar,LocalOrdinal,GlobalOrdinal,Node> > B = Tpetra::createVector<Scalar,LocalOrdinal,GlobalOrdinal,Node>(myMap);
Teuchos::ScalarTraits<Scalar>::seedrandom(846930883);
B->putScalar((Scalar) 2.0);
//B->randomize();
X->putScalar((Scalar) 0.0);
//X->randomize();
// Apply the preconditioner
prec.apply(*B,*X);
// This writes B = B - A*x;
A->apply(*X,*B,Teuchos::NO_TRANS,-1.0,1.0);
// Print X and B (multi)vectors
//X->describe(*out,Teuchos::VERB_EXTREME);
//B->describe(*out,Teuchos::VERB_EXTREME);
// Print final residual norm
std::cout << B->norm2() << std::endl;
// Print stuff about our precondtioner (timings and whatnot)
prec.describe(*out,Teuchos::VERB_EXTREME);
}//int main
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
// get the epetra matrix from the Gallery
int nx = 8;
int ny = 8 * Comm.NumProc();
ParameterList GaleriList;
GaleriList.set("nx", nx);
GaleriList.set("ny", ny);
GaleriList.set("mx", 1);
GaleriList.set("my", Comm.NumProc());
Epetra_Map* Map = CreateMap("Cartesian2D", Comm, GaleriList);
Epetra_CrsMatrix* A = CreateCrsMatrix("Laplace2D", Map, GaleriList);
Epetra_Vector LHS(*Map); LHS.Random();
Epetra_Vector RHS(*Map); RHS.PutScalar(0.0);
Epetra_LinearProblem Problem(A, &LHS, &RHS);
AztecOO solver(Problem);
Init();
try {
Space S(-1, A->NumMyRows(), A->RowMatrixRowMap().MyGlobalElements());
Operator A_MLAPI(S, S, A, false);
Teuchos::ParameterList MLList;
MLList.set("max levels",3);
MLList.set("increasing or decreasing","increasing");
MLList.set("aggregation: type", "Uncoupled");
MLList.set("aggregation: damping factor", 0.0);
MLList.set("smoother: type","symmetric Gauss-Seidel");
MLList.set("smoother: sweeps",1);
MLList.set("smoother: damping factor",1.0);
MLList.set("coarse: max size",3);
MLList.set("smoother: pre or post", "both");
MLList.set("coarse: type","Amesos-KLU");
MultiLevelSA Prec_MLAPI(A_MLAPI, MLList);
Epetra_Operator* Prec = new EpetraBaseOperator(A->RowMatrixRowMap(), Prec_MLAPI);
solver.SetPrecOperator(Prec);
solver.SetAztecOption(AZ_solver, AZ_cg_condnum);
solver.SetAztecOption(AZ_output, 32);
solver.Iterate(500, 1e-12);
// destroy the preconditioner
delete Prec;
}
catch (const int e) {
cerr << "Caught exception, code = " << e << endl;
}
catch (...) {
cerr << "Caught exception..." << endl;
}
Finalize();
// compute the real residual
double residual;
LHS.Norm2(&residual);
if( Comm.MyPID()==0 ) {
cout << "||b-Ax||_2 = " << residual << endl;
}
delete A;
delete Map;
// for testing purposes
if (residual > 1e-5)
exit(EXIT_FAILURE);
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return(EXIT_SUCCESS);
}
bool NOX::LineSearch::Polynomial::
reset(const Teuchos::RCP<NOX::GlobalData>& gd,
Teuchos::ParameterList& params)
{
globalDataPtr = gd;
meritFuncPtr = gd->getMeritFunction();
print.reset(gd->getUtils());
paramsPtr = ¶ms;
slopeUtil.reset(gd);
Teuchos::ParameterList& p = params.sublist("Polynomial");
std::string choice = p.get("Sufficient Decrease Condition", "Armijo-Goldstein");
if (choice == "Armijo-Goldstein")
suffDecrCond = ArmijoGoldstein;
else if (choice == "Ared/Pred")
suffDecrCond = AredPred;
else if (choice == "None")
suffDecrCond = None;
else
{
print.err() << "NOX::LineSearch::Polynomial::reset - Invalid \"Sufficient Decrease Condition\"" << std::endl;
throw "NOX Error";
}
choice = p.get("Interpolation Type", "Cubic");
if (choice == "Cubic")
interpolationType = Cubic;
else if (choice == "Quadratic")
interpolationType = Quadratic;
else if (choice == "Quadratic3")
interpolationType = Quadratic3;
else
{
print.err() << "NOX::LineSearch::Polynomial::reset - Invalid \"Interpolation Type\"" << std::endl;
throw "NOX Error";
}
choice = p.get("Recovery Step Type", "Constant");
if (choice == "Constant")
recoveryStepType = Constant;
else if (choice == "Last Computed Step") {
recoveryStepType = LastComputedStep;
}
else {
print.err() << "NOX::LineSearch::Polynomial::reset - Invalid \"Recovery Step Type\"" << std::endl;
throw "NOX Error";
}
minStep = p.get("Minimum Step", 1.0e-12);
defaultStep = p.get("Default Step", 1.0);
recoveryStep = p.get("Recovery Step", defaultStep);
maxIters = p.get("Max Iters", 100);
alpha = p.get("Alpha Factor", 1.0e-4);
minBoundFactor = p.get("Min Bounds Factor", 0.1);
maxBoundFactor = p.get("Max Bounds Factor", 0.5);
doForceInterpolation = p.get("Force Interpolation", false);
useCounter = p.get("Use Counters", true);
maxIncreaseIter = p.get("Maximum Iteration for Increase", 0);
maxRelativeIncrease = p.get("Allowed Relative Increase", 1.e2);
// Is increase allowed?
doAllowIncrease = (maxIncreaseIter > 0);
// Set up counter
if (useCounter)
counter.reset();
return true;
}
int main(int argc, char *argv[]) {
#include "MueLu_UseShortNames.hpp"
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::rcpFromRef;
using namespace MueLuTests;
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 MM(myTime);
// read in some command line parameters
Teuchos::CommandLineProcessor clp(false);
int rebalanceBlocks = 1;
clp.setOption("rebalanceBlocks", &rebalanceBlocks, "rebalance blocks (1=yes, else=no)");
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;
}
#if defined(HAVE_MPI) && defined(HAVE_MUELU_ZOLTAN) && defined(HAVE_MUELU_ISORROPIA)
#ifndef HAVE_TEUCHOS_LONG_LONG_INT
*out << "Warning: scaling test was not compiled with long long int support" << std::endl;
// custom parameters
LocalOrdinal maxLevels = 3;
GlobalOrdinal maxCoarseSize=1; //FIXME clp doesn't like long long int
int globalNumDofs = 8898; // used for the maps
int nDofsPerNode = 3; // used for generating the fine level null-space
// build strided maps
// striding information: 2 velocity dofs and 1 pressure dof = 3 dofs per node
std::vector<size_t> stridingInfo;
stridingInfo.push_back(2);
stridingInfo.push_back(1);
/////////////////////////////////////// build strided maps
// build strided maps:
// xstridedfullmap: full map (velocity and pressure dof gids), continous
// xstridedvelmap: only velocity dof gid maps (i.e. 0,1,3,4,6,7...)
// xstridedpremap: only pressure dof gid maps (i.e. 2,5,8,...)
Xpetra::UnderlyingLib lib = Xpetra::UseEpetra;
RCP<const StridedMap> xstridedfullmap = StridedMapFactory::Build(lib,globalNumDofs,0,stridingInfo,comm,-1);
RCP<const StridedMap> xstridedvelmap = StridedMapFactory::Build(xstridedfullmap,0);
RCP<const StridedMap> xstridedpremap = StridedMapFactory::Build(xstridedfullmap,1);
/////////////////////////////////////// transform Xpetra::Map objects to Epetra
// this is needed for AztecOO
const RCP<const Epetra_Map> fullmap = rcpFromRef(Xpetra::toEpetra(*xstridedfullmap));
RCP<const Epetra_Map> velmap = rcpFromRef(Xpetra::toEpetra(*xstridedvelmap));
RCP<const Epetra_Map> premap = rcpFromRef(Xpetra::toEpetra(*xstridedpremap));
/////////////////////////////////////// import problem matrix and RHS from files (-> Epetra)
// read in problem
Epetra_CrsMatrix * ptrA = 0;
Epetra_Vector * ptrf = 0;
Epetra_MultiVector* ptrNS = 0;
*out << "Reading matrix market file" << std::endl;
EpetraExt::MatrixMarketFileToCrsMatrix("A5932_re1000.txt",*fullmap,*fullmap,*fullmap,ptrA);
EpetraExt::MatrixMarketFileToVector("b5932_re1000.txt",*fullmap,ptrf);
//EpetraExt::MatrixMarketFileToCrsMatrix("/home/tobias/promotion/trilinos/fc17-dyn/packages/muelu/test/navierstokes/A5932_re1000.txt",*fullmap,*fullmap,*fullmap,ptrA);
//EpetraExt::MatrixMarketFileToVector("/home/tobias/promotion/trilinos/fc17-dyn/packages/muelu/test/navierstokes/b5932_re1000.txt",*fullmap,ptrf);
RCP<Epetra_CrsMatrix> epA = Teuchos::rcp(ptrA);
RCP<Epetra_Vector> epv = Teuchos::rcp(ptrf);
RCP<Epetra_MultiVector> epNS = Teuchos::rcp(ptrNS);
/////////////////////////////////////// split system into 2x2 block system
*out << "Split matrix into 2x2 block matrix" << std::endl;
// split fullA into A11,..., A22
Teuchos::RCP<Epetra_CrsMatrix> A11;
Teuchos::RCP<Epetra_CrsMatrix> A12;
Teuchos::RCP<Epetra_CrsMatrix> A21;
Teuchos::RCP<Epetra_CrsMatrix> A22;
if(SplitMatrix2x2(epA,*velmap,*premap,A11,A12,A21,A22)==false)
*out << "Problem with splitting matrix"<< std::endl;
/////////////////////////////////////// transform Epetra objects to Xpetra (needed for MueLu)
// build Xpetra objects from Epetra_CrsMatrix objects
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> > xA11 = Teuchos::rcp(new Xpetra::EpetraCrsMatrix(A11));
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> > xA12 = Teuchos::rcp(new Xpetra::EpetraCrsMatrix(A12));
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> > xA21 = Teuchos::rcp(new Xpetra::EpetraCrsMatrix(A21));
Teuchos::RCP<Xpetra::CrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> > xA22 = Teuchos::rcp(new Xpetra::EpetraCrsMatrix(A22));
/////////////////////////////////////// generate MapExtractor object
std::vector<Teuchos::RCP<const Xpetra::Map<LocalOrdinal,GlobalOrdinal,Node> > > xmaps;
xmaps.push_back(xstridedvelmap);
xmaps.push_back(xstridedpremap);
Teuchos::RCP<const Xpetra::MapExtractor<Scalar,LocalOrdinal,GlobalOrdinal,Node> > map_extractor = Xpetra::MapExtractorFactory<Scalar,LocalOrdinal,GlobalOrdinal>::Build(xstridedfullmap,xmaps);
/////////////////////////////////////// build blocked transfer operator
// using the map extractor
Teuchos::RCP<Xpetra::BlockedCrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal,Node> > bOp = Teuchos::rcp(new Xpetra::BlockedCrsMatrix<Scalar,LocalOrdinal,GlobalOrdinal>(map_extractor,map_extractor,10));
bOp->setMatrix(0,0,xA11);
bOp->setMatrix(0,1,xA12);
bOp->setMatrix(1,0,xA21);
bOp->setMatrix(1,1,xA22);
bOp->fillComplete();
//////////////////////////////////////////////////// create Hierarchy
RCP<Hierarchy> H = rcp ( new Hierarchy() );
H->setDefaultVerbLevel(Teuchos::VERB_HIGH);
//H->setDefaultVerbLevel(Teuchos::VERB_NONE);
H->SetMaxCoarseSize(maxCoarseSize);
//////////////////////////////////////////////////////// finest Level
RCP<MueLu::Level> Finest = H->GetLevel();
Finest->setDefaultVerbLevel(Teuchos::VERB_HIGH);
Finest->Set("A",Teuchos::rcp_dynamic_cast<Matrix>(bOp));
////////////////////////////////////////// prepare null space for A11
RCP<MultiVector> nullspace11 = MultiVectorFactory::Build(xstridedvelmap, 2); // this is a 2D standard null space
for (int i=0; i<nDofsPerNode-1; ++i) {
Teuchos::ArrayRCP<Scalar> nsValues = nullspace11->getDataNonConst(i);
int numBlocks = nsValues.size() / (nDofsPerNode - 1);
for (int j=0; j< numBlocks; ++j) {
nsValues[j*(nDofsPerNode - 1) + i] = 1.0;
}
}
Finest->Set("Nullspace1",nullspace11);
////////////////////////////////////////// prepare null space for A22
RCP<MultiVector> nullspace22 = MultiVectorFactory::Build(xstridedpremap, 1); // this is a 2D standard null space
Teuchos::ArrayRCP<Scalar> nsValues22 = nullspace22->getDataNonConst(0);
for (int j=0; j< nsValues22.size(); ++j) {
nsValues22[j] = 1.0;
}
Finest->Set("Nullspace2",nullspace22);
/////////////////////////////////////////// define rebalanced block AC factory
// This is the main factory for "A" and defines the input for
// - the SubBlockAFactory objects
// - the rebalanced block Ac factory
RCP<RebalanceBlockAcFactory> RebalancedAcFact = rcp(new RebalanceBlockAcFactory());
/////////////////////////////////////////// define non-rebalanced blocked transfer ops
RCP<BlockedPFactory> PFact = rcp(new BlockedPFactory()); // use row map index base from bOp
RCP<GenericRFactory> RFact = rcp(new GenericRFactory());
RFact->SetFactory("P", PFact);
// non-rebalanced block coarse matrix factory
// output is non-rebalanced coarse block matrix Ac
// used as input for rebalanced block coarse factory RebalancedAcFact
RCP<Factory> AcFact = rcp(new BlockedRAPFactory());
AcFact->SetFactory("A", MueLu::NoFactory::getRCP());
AcFact->SetFactory("P", PFact); // use non-rebalanced block prolongator as input
AcFact->SetFactory("R", RFact); // use non-rebalanced block restrictor as input
// define matrix sub-blocks of possibly rebalanced block matrix A
// These are used as input for
// - the sub blocks of the transfer operators
RCP<SubBlockAFactory> A11Fact = Teuchos::rcp(new SubBlockAFactory());
A11Fact->SetFactory("A",MueLu::NoFactory::getRCP());
A11Fact->SetParameter("block row",Teuchos::ParameterEntry(0));
A11Fact->SetParameter("block col",Teuchos::ParameterEntry(0));
RCP<SubBlockAFactory> A22Fact = Teuchos::rcp(new SubBlockAFactory());
A22Fact->SetFactory("A",MueLu::NoFactory::getRCP());
A22Fact->SetParameter("block row",Teuchos::ParameterEntry(1));
A22Fact->SetParameter("block col",Teuchos::ParameterEntry(1));
/////////////////////////////////////////// define rebalancing factories
// define sub blocks of the coarse non-rebalanced block matrix Ac
// input is the block operator generated by AcFact
RCP<SubBlockAFactory> rebA11Fact = Teuchos::rcp(new SubBlockAFactory());
rebA11Fact->SetFactory("A",AcFact);
rebA11Fact->SetParameter("block row",Teuchos::ParameterEntry(0));
rebA11Fact->SetParameter("block col",Teuchos::ParameterEntry(0));
RCP<SubBlockAFactory> rebA22Fact = Teuchos::rcp(new SubBlockAFactory());
rebA22Fact->SetFactory("A",AcFact);
rebA22Fact->SetParameter("block row",Teuchos::ParameterEntry(1));
rebA22Fact->SetParameter("block col",Teuchos::ParameterEntry(1));
// define rebalancing factory for coarse block matrix A(1,1)
RCP<AmalgamationFactory> rebAmalgFact11 = rcp(new AmalgamationFactory());
rebAmalgFact11->SetFactory("A", rebA11Fact);
rebAmalgFact11->setDefaultVerbLevel(Teuchos::VERB_EXTREME);
RCP<MueLu::IsorropiaInterface<LO, GO, NO, LMO> > isoInterface1 = rcp(new MueLu::IsorropiaInterface<LO, GO, NO, LMO>());
isoInterface1->SetFactory("A", rebA11Fact);
isoInterface1->SetFactory("UnAmalgamationInfo", rebAmalgFact11);
RCP<MueLu::RepartitionInterface<LO, GO, NO, LMO> > repInterface1 = rcp(new MueLu::RepartitionInterface<LO, GO, NO, LMO>());
repInterface1->SetFactory("A", rebA11Fact);
repInterface1->SetFactory("AmalgamatedPartition", isoInterface1);
// Repartitioning (creates "Importer" from "Partition")
RCP<Factory> RepartitionFact = rcp(new RepartitionFactory());
{
Teuchos::ParameterList paramList;
paramList.set("repartition: min rows per proc", 200);
paramList.set("repartition: max imbalance", 1.3);
if(rebalanceBlocks == 1)
paramList.set("repartition: start level",1);
else
paramList.set("repartition: start level",10); // supress rebalancing
RepartitionFact->SetParameterList(paramList);
}
RepartitionFact->SetFactory("A", rebA11Fact);
RepartitionFact->SetFactory("Partition", repInterface1);
// define rebalancing factory for coarse block matrix A(1,1)
RCP<AmalgamationFactory> rebAmalgFact22 = rcp(new AmalgamationFactory());
rebAmalgFact22->SetFactory("A", rebA22Fact);
rebAmalgFact22->setDefaultVerbLevel(Teuchos::VERB_EXTREME);
RCP<MueLu::RepartitionInterface<LO, GO, NO, LMO> > repInterface2 = rcp(new MueLu::RepartitionInterface<LO, GO, NO, LMO>());
repInterface2->SetFactory("A", rebA22Fact);
repInterface2->SetFactory("AmalgamatedPartition", isoInterface1);
// second repartition factory
RCP<Factory> RepartitionFact2 = rcp(new RepartitionFactory());
{
Teuchos::ParameterList paramList;
paramList.set("repartition: min rows per proc", 100);
paramList.set("repartition: max imbalance", 1.2);
if(rebalanceBlocks == 1)
paramList.set("repartition: start level",1);
else
paramList.set("repartition: start level",10); // supress rebalancing
RepartitionFact2->SetParameterList(paramList);
}
RepartitionFact2->SetFactory("A", rebA22Fact);
RepartitionFact2->SetFactory("Partition", repInterface2); // this is not valid
////////////////////////////////////////// build non-rebalanced matrix blocks
// build factories for transfer operator P(1,1) and R(1,1)
RCP<AmalgamationFactory> amalgFact11 = rcp(new AmalgamationFactory());
amalgFact11->SetFactory("A", A11Fact);
amalgFact11->setDefaultVerbLevel(Teuchos::VERB_EXTREME);
RCP<CoalesceDropFactory> dropFact11 = rcp(new CoalesceDropFactory());
dropFact11->SetFactory("A", A11Fact);
dropFact11->SetFactory("UnAmalgamationInfo", amalgFact11);
dropFact11->setDefaultVerbLevel(Teuchos::VERB_EXTREME);
RCP<UncoupledAggregationFactory> UncoupledAggFact11 = rcp(new UncoupledAggregationFactory());
UncoupledAggFact11->SetFactory("Graph", dropFact11);
UncoupledAggFact11->SetMinNodesPerAggregate(9);
UncoupledAggFact11->SetMaxNeighAlreadySelected(2);
UncoupledAggFact11->SetOrdering("natural");
RCP<CoarseMapFactory> coarseMapFact11 = Teuchos::rcp(new CoarseMapFactory());
coarseMapFact11->setStridingData(stridingInfo);
coarseMapFact11->setStridedBlockId(0);
RCP<TentativePFactory> P11Fact = rcp(new TentativePFactory());
RCP<TransPFactory> R11Fact = rcp(new TransPFactory());
Teuchos::RCP<NullspaceFactory> nspFact11 = Teuchos::rcp(new NullspaceFactory("Nullspace1"));
nspFact11->SetFactory("Nullspace1",P11Fact); // pick "Nullspace1" from Finest level
//////////////////////////////// define factory manager for (1,1) block
RCP<FactoryManager> M11 = rcp(new FactoryManager());
M11->SetFactory("A", A11Fact); // rebalanced fine-level block operator
M11->SetFactory("P", P11Fact); // non-rebalanced transfer operator block P(1,1)
M11->SetFactory("R", R11Fact); // non-rebalanced transfer operator block R(1,1)
M11->SetFactory("Aggregates", UncoupledAggFact11);
M11->SetFactory("Graph", dropFact11);
M11->SetFactory("DofsPerNode", dropFact11);
M11->SetFactory("UnAmalgamationInfo", amalgFact11);
M11->SetFactory("Nullspace", nspFact11); // TODO check me?
M11->SetFactory("CoarseMap", coarseMapFact11);
M11->SetIgnoreUserData(true); // always use data from factories defined in factory manager
////////////////////////////////////////// build non-rebalanced matrix blocks
// build factories for transfer operator P(2,2) and R(2,2)
RCP<AmalgamationFactory> amalgFact22 = rcp(new AmalgamationFactory());
RCP<TentativePFactory> P22Fact = rcp(new TentativePFactory());
RCP<TransPFactory> R22Fact = rcp(new TransPFactory());
// connect null space and tentative PFactory
Teuchos::RCP<NullspaceFactory> nspFact22 = Teuchos::rcp(new NullspaceFactory("Nullspace2"));
nspFact22->SetFactory("Nullspace2", P22Fact); // define null space generated by P22Fact as null space for coarse level (non-rebalanced)
RCP<CoarseMapFactory> coarseMapFact22 = Teuchos::rcp(new CoarseMapFactory());
coarseMapFact22->setStridingData(stridingInfo);
coarseMapFact22->setStridedBlockId(1);
//////////////////////////////// define factory manager for (2,2) block
RCP<FactoryManager> M22 = rcp(new FactoryManager());
M22->SetFactory("A", A22Fact); // rebalanced fine-level block operator
M22->SetFactory("P", P22Fact); // non-rebalanced transfer operator P(2,2)
M22->SetFactory("R", R22Fact); // non-rebalanced transfer operator R(2,2)
M22->SetFactory("Aggregates", UncoupledAggFact11); // aggregates from block (1,1)
M22->SetFactory("Nullspace", nspFact22);
M22->SetFactory("UnAmalgamationInfo", amalgFact22);
M22->SetFactory("Ptent", P22Fact);
M22->SetFactory("CoarseMap", coarseMapFact22);
M22->SetIgnoreUserData(true);
/////////////////////////////////////////// define rebalanced blocked transfer ops
//////////////////////////////// define factory manager for (1,1) block
RCP<FactoryManager> rebM11 = rcp(new FactoryManager());
rebM11->SetFactory("A", AcFact ); // important: must be a 2x2 block A Factory
rebM11->SetFactory("Importer", RepartitionFact);
rebM11->SetFactory("Nullspace", nspFact11);
//rebM11->SetIgnoreUserData(true);
RCP<FactoryManager> rebM22 = rcp(new FactoryManager());
rebM22->SetFactory("A", AcFact ); // important: must be a 2x2 block A Factory
rebM22->SetFactory("Importer", RepartitionFact2); // use dummy repartitioning factory
rebM22->SetFactory("Nullspace", nspFact22);
// Reordering of the transfer operators
RCP<RebalanceBlockInterpolationFactory> RebalancedBlockPFact = rcp(new RebalanceBlockInterpolationFactory());
RebalancedBlockPFact->SetFactory("P", PFact); // use non-rebalanced block P operator as input
RebalancedBlockPFact->AddFactoryManager(rebM11);
RebalancedBlockPFact->AddFactoryManager(rebM22);
RCP<RebalanceBlockRestrictionFactory> RebalancedBlockRFact = rcp(new RebalanceBlockRestrictionFactory());
//RebalancedBlockRFact->SetParameter("type", Teuchos::ParameterEntry(std::string("Restriction")));
RebalancedBlockRFact->SetFactory("R", RFact); // non-rebalanced block P operator
RebalancedBlockRFact->AddFactoryManager(rebM11);
RebalancedBlockRFact->AddFactoryManager(rebM22);
///////////////////////////////////////// initialize non-rebalanced block transfer operators
// output are the non-rebalanced block transfer operators used as input in AcFact to build
// the non-rebalanced coarse level block matrix Ac
PFact->AddFactoryManager(M11); // use non-rebalanced information from sub block factory manager M11
PFact->AddFactoryManager(M22); // use non-rebalanced information from sub block factory manager M22
///////////////////////////////////////// initialize rebalanced coarse block AC factory
RebalancedAcFact->SetFactory("A", AcFact); // use non-rebalanced block operator as input
RebalancedAcFact->AddFactoryManager(rebM11);
RebalancedAcFact->AddFactoryManager(rebM22);
//////////////////////////////////////////////////////////////////////
// Smoothers
//Another factory manager for braes sarazin smoother
//Schur Complement Factory, using the factory to generate AcFact
SC omega = 1.3;
RCP<SchurComplementFactory> SFact = Teuchos::rcp(new SchurComplementFactory());
SFact->SetParameter("omega", Teuchos::ParameterEntry(omega));
SFact->SetFactory("A", MueLu::NoFactory::getRCP()); // this finally be the rebalanced block operator!
//Smoother Factory, using SFact as a factory for A
std::string ifpackSCType;
Teuchos::ParameterList ifpackSCList;
ifpackSCList.set("relaxation: sweeps", (LocalOrdinal) 3);
ifpackSCList.set("relaxation: damping factor", (Scalar) 1.0);
ifpackSCType = "RELAXATION";
ifpackSCList.set("relaxation: type", "Gauss-Seidel");
RCP<SmootherPrototype> smoProtoSC = rcp( new TrilinosSmoother(ifpackSCType, ifpackSCList, 0) );
smoProtoSC->SetFactory("A", SFact);
RCP<SmootherFactory> SmooSCFact = rcp( new SmootherFactory(smoProtoSC) );
RCP<BraessSarazinSmoother> smootherPrototype = rcp( new BraessSarazinSmoother() );
smootherPrototype->SetParameter("Sweeps", Teuchos::ParameterEntry(3));
smootherPrototype->SetParameter("Damping factor", Teuchos::ParameterEntry(omega));
smootherPrototype->SetFactory("A",MueLu::NoFactory::getRCP());
RCP<SmootherFactory> smootherFact = rcp( new SmootherFactory(smootherPrototype) );
RCP<BraessSarazinSmoother> coarseSolverPrototype = rcp( new BraessSarazinSmoother() );
coarseSolverPrototype->SetParameter("Sweeps", Teuchos::ParameterEntry(3));
coarseSolverPrototype->SetParameter("Damping factor", Teuchos::ParameterEntry(omega));
coarseSolverPrototype->SetFactory("A",MueLu::NoFactory::getRCP());
RCP<SmootherFactory> coarseSolverFact = rcp( new SmootherFactory(coarseSolverPrototype, Teuchos::null) );
RCP<FactoryManager> MB = rcp(new FactoryManager());
MB->SetFactory("A", SFact);
MB->SetFactory("Smoother", SmooSCFact);
MB->SetIgnoreUserData(true); // always use data from factories defined in factory manager
smootherPrototype->AddFactoryManager(MB,0);
coarseSolverPrototype->AddFactoryManager(MB,0);
////////////////////////////////////////// define main factory manager
FactoryManager M;
M.SetFactory("A", RebalancedAcFact); // rebalance block AC Factory using importer
M.SetFactory("P", RebalancedBlockPFact); // rebalance prolongator using non-balanced Ac
M.SetFactory("R", RebalancedBlockRFact); // rebalance restrictor and null space using non-balanced Ac
M.SetFactory("Smoother", smootherFact);
M.SetFactory("PreSmoother", smootherFact);
M.SetFactory("PostSmoother", smootherFact);
M.SetFactory("CoarseSolver", coarseSolverFact);
H->Setup(M,0,maxLevels);
/**out << std::endl;
*out << "print content of multigrid levels:" << std::endl;
Finest->print(*out);
RCP<Level> coarseLevel = H->GetLevel(1);
coarseLevel->print(*out);
RCP<Level> coarseLevel2 = H->GetLevel(2);
coarseLevel2->print(*out);*/
RCP<MultiVector> xLsg = MultiVectorFactory::Build(xstridedfullmap,1);
// Use AMG directly as an iterative method
#if 0
{
xLsg->putScalar( (SC) 0.0);
// Epetra_Vector -> Xpetra::Vector
RCP<Vector> xRhs = Teuchos::rcp(new Xpetra::EpetraVector(epv));
// calculate initial (absolute) residual
Teuchos::Array<Teuchos::ScalarTraits<SC>::magnitudeType> norms(1);
xRhs->norm2(norms);
*out << "||x_0|| = " << norms[0] << std::endl;
// apply ten multigrid iterations
H->Iterate(*xRhs,*xLsg,100);
// calculate and print residual
RCP<MultiVector> xTmp = MultiVectorFactory::Build(xstridedfullmap,1);
bOp->apply(*xLsg,*xTmp,Teuchos::NO_TRANS,(SC)1.0,(SC)0.0);
xRhs->update((SC)-1.0,*xTmp,(SC)1.0);
xRhs->norm2(norms);
*out << "||x|| = " << norms[0] << std::endl;
}
#endif
//
// Solve Ax = b using AMG as a preconditioner in AztecOO
//
{
RCP<Epetra_Vector> X = rcp(new Epetra_Vector(epv->Map()));
X->PutScalar(0.0);
Epetra_LinearProblem epetraProblem(epA.get(), X.get(), epv.get());
AztecOO aztecSolver(epetraProblem);
aztecSolver.SetAztecOption(AZ_solver, AZ_gmres);
MueLu::EpetraOperator aztecPrec(H);
aztecSolver.SetPrecOperator(&aztecPrec);
int maxIts = 50;
double tol = 1e-8;
aztecSolver.Iterate(maxIts, tol);
}
#endif // end ifndef HAVE_LONG_LONG_INT
#endif // #if defined(HAVE_MPI) && defined(HAVE_MUELU_ZOLTAN) && defined(HAVE_MUELU_ISORROPIA)
return EXIT_SUCCESS;
}
void readGeoGenParams(string paramFileName, Teuchos::ParameterList &geoparams, const RCP<const Teuchos::Comm<int> > & comm){
std::string input = "";
char inp[25000];
for(int i = 0; i < 25000; ++i){
inp[i] = 0;
}
bool fail = false;
if(comm->getRank() == 0){
std::fstream inParam(paramFileName.c_str());
if (inParam.fail())
{
fail = true;
}
if(!fail)
{
std::string tmp = "";
getline (inParam,tmp);
while (!inParam.eof()){
if(tmp != ""){
tmp = trim_copy(tmp);
if(tmp != ""){
input += tmp + "\n";
}
}
getline (inParam,tmp);
}
inParam.close();
for (size_t i = 0; i < input.size(); ++i){
inp[i] = input[i];
}
}
}
int size = input.size();
if(fail){
size = -1;
}
comm->broadcast(0, sizeof(int), (char*) &size);
if(size == -1){
throw "File " + paramFileName + " cannot be opened.";
}
comm->broadcast(0, size, inp);
istringstream inParam(inp);
string str;
getline (inParam,str);
while (!inParam.eof()){
if(str[0] != param_comment){
size_t pos = str.find('=');
if(pos == string::npos){
throw "Invalid Line:" + str + " in parameter file";
}
string paramname = trim_copy(str.substr(0,pos));
string paramvalue = trim_copy(str.substr(pos + 1));
geoparams.set(paramname, paramvalue);
}
getline (inParam,str);
}
}
void testInitialzation(const Teuchos::RCP<Teuchos::ParameterList>& ipb,
std::vector<panzer::BC>& bcs)
{
// Physics block
Teuchos::ParameterList& physics_block = ipb->sublist("test physics");
{
Teuchos::ParameterList& p = physics_block.sublist("a");
p.set("Type","Energy");
p.set("Prefix","");
p.set("Model ID","solid");
p.set("Basis Type","HGrad");
p.set("Basis Order",2);
p.set("Integration Order",1);
}
{
Teuchos::ParameterList& p = physics_block.sublist("b");
p.set("Type","Energy");
p.set("Prefix","ION_");
p.set("Model ID","ion solid");
p.set("Basis Type","HGrad");
p.set("Basis Order",1);
p.set("Integration Order",1);
}
{
std::size_t bc_id = 0;
panzer::BCType neumann = BCT_Dirichlet;
std::string sideset_id = "left";
std::string element_block_id = "eblock-0_0";
std::string dof_name = "TEMPERATURE";
std::string strategy = "Constant";
double value = 5.0;
Teuchos::ParameterList p;
p.set("Value",value);
panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
strategy, p);
bcs.push_back(bc);
}
{
std::size_t bc_id = 1;
panzer::BCType neumann = BCT_Dirichlet;
std::string sideset_id = "right";
std::string element_block_id = "eblock-1_0";
std::string dof_name = "TEMPERATURE";
std::string strategy = "Constant";
double value = 5.0;
Teuchos::ParameterList p;
p.set("Value",value);
panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
strategy, p);
bcs.push_back(bc);
}
{
std::size_t bc_id = 2;
panzer::BCType neumann = BCT_Dirichlet;
std::string sideset_id = "top";
std::string element_block_id = "eblock-1_0";
std::string dof_name = "TEMPERATURE";
std::string strategy = "Constant";
double value = 5.0;
Teuchos::ParameterList p;
p.set("Value",value);
panzer::BC bc(bc_id, neumann, sideset_id, element_block_id, dof_name,
strategy, p);
bcs.push_back(bc);
}
}
//---------------------------------------------------------------------------
int Solver_Belos::solve(fei::LinearSystem* linearSystem,
fei::Matrix* preconditioningMatrix,
const fei::ParameterSet& parameterSet,
int& iterationsTaken,
int& status)
{
std::string krylov_solver_name;
parameterSet.getStringParamValue("krylov_solver", krylov_solver_name);
Teuchos::RCP<Teuchos::ParameterList>& paramlist = paramlist_;
#ifdef HAVE_FEI_ML
if (ml_aztec_options_ == NULL)
ml_aztec_options_ = new int[AZ_OPTIONS_SIZE];
if (ml_aztec_params_ == NULL)
ml_aztec_params_ = new double[AZ_PARAMS_SIZE];
if (!ml_defaults_set_ && useML_) {
Teuchos::ParameterList mlparams;
ML_Epetra::SetDefaults("SA", mlparams, ml_aztec_options_,ml_aztec_params_);
mlparams.setParameters(*paramlist);
*paramlist = mlparams;
ml_defaults_set_ = true;
}
#endif
Trilinos_Helpers::copy_parameterset(parameterSet, *paramlist);
fei::SharedPtr<fei::Matrix> feiA = linearSystem->getMatrix();
fei::SharedPtr<fei::Vector> feix = linearSystem->getSolutionVector();
fei::SharedPtr<fei::Vector> feib = linearSystem->getRHS();
Epetra_MultiVector* x = NULL;
Epetra_MultiVector* b = NULL;
Epetra_Operator* epetra_op = 0;
Epetra_CrsMatrix* crsA = NULL;
Trilinos_Helpers::get_Epetra_pointers(feiA, feix, feib,
crsA, epetra_op, x, b);
Teuchos::RCP<Epetra_CrsMatrix> rcp_A(crsA);
Teuchos::RCP<Epetra_MultiVector> rcp_x(x);
Teuchos::RCP<Epetra_MultiVector> rcp_b(b);
if (epetra_op == 0 || x == 0 || b == 0) {
fei::console_out() << "Solver_Belos::solve Error, couldn't obtain Epetra objects"
<< " from fei container-objects."<<FEI_ENDL;
return(-1);
}
Epetra_RowMatrix* precond = NULL;
if (preconditioningMatrix != NULL) {
fei::Matrix_Impl<Epetra_CrsMatrix>* snl_epetra_crs =
dynamic_cast<fei::Matrix_Impl<Epetra_CrsMatrix>*>(preconditioningMatrix);
fei::Matrix_Impl<Epetra_VbrMatrix>* snl_epetra_vbr =
dynamic_cast<fei::Matrix_Impl<Epetra_VbrMatrix>*>(preconditioningMatrix);
if (snl_epetra_crs != NULL) {
precond = snl_epetra_crs->getMatrix().get();
}
else if (snl_epetra_vbr != NULL) {
precond = snl_epetra_vbr->getMatrix().get();
}
else {
fei::console_out() << "Solver_Belos::solve: ERROR getting epetra row matrix"
<< " from preconditioningMatrix."<<FEI_ENDL;
return(-1);
}
}
if (precond != NULL) {
//TODO: set up preconditioner for Belos here
}
bool needNewPreconditioner = false;
if (feiA->changedSinceMark()) {
feiA->markState();
needNewPreconditioner = true;
}
if (needNewPreconditioner) {
//
// if (useML_) {
#ifdef HAVE_FEI_ML
// setup_ml_operator(*azoo_, crsA);
#else
// fei::console_out() <<"Solver_Belos::solve ERROR, ML requested but HAVE_FEI_ML not defined."
// << FEI_ENDL;
// return(-1);
#endif
// }
// else {
// azoo_->SetAztecOption(AZ_pre_calc, AZ_calc);
// azoo_->SetAztecOption(AZ_keep_info, 1);
// }
}
else {
// if (!useML_) {
// azoo_->SetAztecOption(AZ_pre_calc, AZ_reuse);
// }
}
epetra_op->SetUseTranspose(useTranspose_);
Belos::SolverFactory<double,Epetra_MultiVector,Epetra_Operator> belos_factory;
belos_solver_manager_ = belos_factory.create(krylov_solver_name, paramlist);
Teuchos::RCP<Belos::LinearProblem<double,Epetra_MultiVector,Epetra_Operator> > belos_lin_prob = Teuchos::rcp(new Belos::LinearProblem<double,Epetra_MultiVector,Epetra_Operator>(rcp_A, rcp_x, rcp_b));
belos_lin_prob->setProblem();
belos_solver_manager_->setProblem(belos_lin_prob);
belos_solver_manager_->solve();
status = 0;
iterationsTaken = belos_solver_manager_->getNumIters();
rcp_A.release();
rcp_x.release();
rcp_b.release();
int olevel = 0;
parameterSet.getIntParamValue("outputLevel", olevel);
std::string param2;
parameterSet.getStringParamValue("FEI_OUTPUT_LEVEL", param2);
if (olevel >= 3 || param2 == "MATRIX_FILES" || param2 == "ALL") {
std::string param1;
parameterSet.getStringParamValue("debugOutput", param1);
FEI_OSTRINGSTREAM osstr;
if (!param1.empty()) {
osstr << param1 << "/";
}
else osstr << "./";
osstr << "x_Belos.vec";
feix->writeToFile(osstr.str().c_str());
}
return(0);
}
void Operator<Node>::paramsToUpper(Teuchos::ParameterList &plist, int &changed, bool rmUnderscore)
{
changed = 0;
// get a list of all parameter names in the list
std::vector<std::string> paramNames ;
Teuchos::ParameterList::ConstIterator pIter;
pIter = plist.begin();
while (1){
//////////////////////////////////////////////////////////////////////
// Compiler considered this while statement an error
// for ( pIter = plist.begin() ; pIter != plist.end() ; pIter++ ){
// }
//////////////////////////////////////////////////////////////////////
if (pIter == plist.end()) break;
const std::string & nm = plist.name(pIter);
paramNames.push_back(nm);
pIter++;
}
// Change parameter names and values to upper case
for (unsigned int i=0; i < paramNames.size(); i++){
std::string origName(paramNames[i]);
int paramNameChanged = 0;
stringToUpper(paramNames[i], paramNameChanged, rmUnderscore);
if (plist.isSublist(origName)){
Teuchos::ParameterList &sublist = plist.sublist(origName);
int sublistChanged=0;
paramsToUpper(sublist, sublistChanged, false);
if (paramNameChanged){
// this didn't work, so I need to remove the old sublist
// and create a new one
//
//sublist.setName(paramNames[i]);
Teuchos::ParameterList newlist(sublist);
plist.remove(origName);
plist.set(paramNames[i], newlist);
}
}
else if (plist.isParameter(origName)){
std::string paramVal(plist.get<std::string>(origName));
int paramValChanged=0;
stringToUpper(paramVal, paramValChanged);
if (paramNameChanged || paramValChanged){
if (paramNameChanged){
plist.remove(origName);
}
plist.set(paramNames[i], paramVal);
changed++;
}
}
} // next parameter or sublist
}