int main(int argc, char *argv[])
{
Teuchos::oblackholestream blackhole;
Teuchos::GlobalMPISession mpiSession(&argc,&argv,&blackhole);
//
// Get the default communicator and node
//
auto &platform = Tpetra::DefaultPlatform::getDefaultPlatform();
auto comm = platform.getComm();
auto node = platform.getNode();
const int myImageID = comm->getRank();
const int numImages = comm->getSize();
const bool verbose = (myImageID==0);
//
// Say hello, print some communicator info
//
if (verbose) {
std::cout << "\n" << Tpetra::version() << std::endl;
std::cout << "Comm info: " << *comm;
std::cout << "Node type: " << Teuchos::typeName(*node) << std::endl;
std::cout << std::endl;
}
//
// Create a simple map for domain and range
//
Tpetra::global_size_t numGlobalRows = 1000*numImages;
auto map = Tpetra::createUniformContigMapWithNode<int,int>(numGlobalRows, comm, node);
auto x = Tpetra::createVector<double>(map),
y = Tpetra::createVector<double>(map);
// Create a simple diagonal operator using lambda function
auto fTwoOp = Tpetra::RTI::binaryOp<double>( [](double /*y*/, double x) { return 2.0 * x; } , map );
// y = 3*fTwoOp*x + 2*y = 3*2*1 + 2*1 = 8
x->putScalar(1.0);
y->putScalar(1.0);
fTwoOp->apply( *x, *y, Teuchos::NO_TRANS, 3.0, 2.0 );
// check that y == eights
double norm = y->norm1();
if (verbose) {
std::cout << "Tpetra::RTI::binaryOp" << std::endl
<< "norm(y) result == " << std::setprecision(2) << std::scientific << norm
<< ", expected value is " << numGlobalRows * 8.0 << std::endl;
}
//
// Create a finite-difference stencil using a Kokkos kernel and non-trivial maps
//
decltype(map) colmap;
if (numImages > 1) {
Teuchos::Array<int> colElements;
Teuchos::ArrayView<const int> rowElements = map->getNodeElementList();
// This isn't the most efficient Map/Import layout, but it makes for a very straight-forward kernel
if (myImageID != 0) colElements.push_back( map->getMinGlobalIndex() - 1 );
colElements.insert(colElements.end(), rowElements.begin(), rowElements.end());
if (myImageID != numImages-1) colElements.push_back( map->getMaxGlobalIndex() + 1 );
colmap = Tpetra::createNonContigMapWithNode<int,int>(colElements(), comm, node);
}
else {
colmap = map;
}
auto importer = createImport(map,colmap);
// Finite-difference kernel = tridiag(-1, 2, -1)
FDStencil<double> kern(myImageID, numImages, map->getNodeNumElements(), -1.0, 2.0, -1.0);
auto FDStencilOp = Tpetra::RTI::kernelOp<double>( kern, map, map, importer );
// x = ones(), FD(x) = [1 zeros() 1]
FDStencilOp->apply( *x, *y );
norm = y->norm1();
if (verbose) {
std::cout << std::endl
<< "TpetraExamples::FDStencil" << std::endl
<< "norm(y) result == " << std::setprecision(2) << std::scientific << norm
<< ", expected value is " << 2.0 << std::endl;
}
std::cout << "\nEnd Result: TEST PASSED" << std::endl;
return 0;
}
int main(int argc, char *argv[]) {
Teuchos::GlobalMPISession session(&argc, &argv, NULL);
const auto mesh = nosh::read("pacman.h5m");
const auto f = std::make_shared<bratu::f>(mesh);
const auto jac = std::make_shared<bratu::jacobian>(mesh);
const auto dfdp = std::make_shared<bratu::dfdp>(mesh);
// const auto problem = bratu::bratu(mesh);
// Create a model evaluator.
const std::map<std::string, boost::any> linear_solver_params = {
{"package", std::string("Belos")},
{"method", std::string("Pseudo Block GMRES")},
{"parameters", dict{
{"Output Frequency", 1},
{"Output Style", 1},
{"Verbosity", 33}
}}
};
auto init_x = std::make_shared<nosh::function>(mesh);
init_x->putScalar(0.0);
const auto model = std::make_shared<nosh::model>(
mesh, init_x, f, jac, dfdp, linear_solver_params
);
const auto saver = std::make_shared<nosh::continuation_data_saver>(
mesh
);
// Check out
// https://trilinos.org/docs/dev/packages/nox/doc/html/loca_parameters.html
// for a full parameter description.
mikado::parameter_continuation(
model, saver,
{
{"NOX", dict{
{"Status Tests", dict{
{"Test Type", std::string("NormF")},
{"Norm Type", std::string("Two Norm")},
{"Tolerance", 1.0e-8}
}},
{"Printing", dict{
{"Output Information", dict{
{"Details", true},
{"Outer Iteration", true},
{"Outer Iteration Status Test", true},
{"Inner Iteration", true},
{"Linear Solver Details", true},
{"Parameters", true},
{"Warning", true},
{"Debug", true},
{"Test Details", true},
{"Error", true},
{"Stepper Iteration", true},
{"Stepper Details", true},
{"Stepper Parameters", true}
}}
}}
}},
{"LOCA", dict{
{"Predictor", dict{
{"Method", std::string("Tangent")}
}},
{"Stepper", dict{
{"Continuation Method", std::string("Arc Length")},
{"Continuation Parameter", std::string("lmbda")},
{"Initial Value", 2.0e-3},
{"Min Value", -1.0},
{"Max Value", 1.0},
{"Max Nonlinear Iterations", 5},
}},
{"Step Size", dict{
{"Initial Step Size", 1.0e-3},
{"Min Step Size", 1.0e-5},
{"Max Step Size", 1.0e-1},
{"Aggressiveness", 0.1}
}}
}}
}
);
return EXIT_SUCCESS;
}
