void areSameTest_04(){
double a,b;
a = 1.00000;
b = 1.00001;
ASSERT_EQUAL(false,areSame(a,b));
}
void areSameTest_06(){
double a,b;
a = 1.000000;
b = 1.000009;
ASSERT_EQUAL(true,areSame(a,b));
}
void areSameTest_02(){
double a,b;
a = 1.0;
b = 2.0;
ASSERT_EQUAL(false,areSame(a,b));
}
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);
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")
coarseSmoother = rcp(new TrilinosSmoother(coarseType, coarseParams));
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") {
int GrassPro::createRegion(){
int j, k;
double x, z, y, diameter, zCord;
int atomStep = 0, moleculeId=1;
// open the data file for writing
dataFile = fopen(dataFName.c_str(), "w");
gatherInfo();
fprintf(stderr, "Creating Lattice, please wait...\n");
// Print atom bond and angle info
fprintf(dataFile,"\n%d atoms\n", atomNum);
fprintf(dataFile,"\n%d atom types\n", atomType);
fprintf(dataFile,"%d bonds\n", objNum*(objAtoms-1));
fprintf(dataFile,"%d bond types\n", bondType);
// Print box bounds
fprintf(dataFile, "\n%g %g xlo xhi\n", dim[0], dim[1]);
fprintf(dataFile, "%g %g ylo yhi\n", dim[2], dim[3]);
fprintf(dataFile, "%g %g zlo zhi\n", dim[4], dim[5]);
// Print Atoms
fprintf(dataFile, "\nAtoms\n\n");
for(x=dim[0]+radius; x<(dim[1]-radius) || areSame(x,(dim[1]-radius)); x+=(2.0*radius+sphereSep)){
for(y=dim[2]+radius; y<(dim[3]-radius) || areSame(y, (dim[3]-radius)); y+=(2.0*radius+sphereSep)){
if(FLAG_RAND){
/*diameter = 2.0*radius;
zCord = dim[4]+radius;
while((diameter > (2.0*cutOff)) && (zCord+diameter) < dim[5]){
atomStep++;
// Print atomNumber atomType xCord yCord zCord diameter density moleculeID
fprintf(dataFile, "%d %d %g %g %g %g %g %d\n", atomStep, 1,
x, y, zCord, diameter, atomDensity, moleculeId);
diameter *= scaleFactor;
zCord += sphereSep+diameter;*/
} else {
diameter = 2.0*radius;
zCord = dim[4]+radius;
while(((diameter > (2.0*cutOff))) && ((zCord+(1.0/2.0)*diameter) < dim[5])){
atomStep++;
// Print atomNumber atomType xCord yCord zCord diameter density moleculeID
if(areSame(zCord, dim[4]+radius))
fprintf(dataFile, "%d %d %g %g %g %g %g %d\n", atomStep, 2,
x, y, zCord, diameter, atomDensity, moleculeId);
else
fprintf(dataFile, "%d %d %g %g %g %g %g %d\n", atomStep, 1,
x, y, zCord, diameter, atomDensity, moleculeId);
zCord += (1.0/2.0)*diameter;
diameter *= scaleFactor;
zCord += (1.0/2.0)*diameter;
// fprintf(stderr, "d: %g, cutoff: %g, zcord: %g\n", diameter, cutOff, zCord);
}
}
}
}
// Print Bonds
fprintf(dataFile, "\nBonds\n\n");
for(j=0; j < objNum; j++){
for(k=1; k < objAtoms; k++){
fprintf(dataFile, "%d %d %d %d\n", j*objAtoms+(k-j), bondType, j*objAtoms+k, j*objAtoms+k+1);
}
}
fclose(dataFile);
printInfo();
printStderr();
}
