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(); }