48 #if defined(HAVE_MUELU_ML) 49 # include <ml_config.h> 50 # if defined(HAVE_ML_EPETRA) && defined(HAVE_ML_TEUCHOS) 51 # include <ml_ValidateParameters.h> 52 # include <ml_MultiLevelPreconditioner.h> 53 # include <ml_RefMaxwell.h> 64 TEUCHOS_TEST_FOR_EXCEPTION(pname !=
"coarse: type" && pname !=
"coarse: list" && pname !=
"smoother: type" && pname.find(
"smoother: list",0) != 0,
66 "MueLu::MLParameterListInterpreter::Setup(): Only \"coarse: type\", \"smoother: type\" or \"smoother: list\" (\"coarse: list\") are " 67 "supported as ML parameters for transformation of smoother/solver parameters to MueLu");
70 std::stringstream mueluss;
73 std::string mode =
"smoother:";
74 if (pname.find(
"coarse:", 0) == 0)
79 if (paramList.isParameter(mode +
" pre or post"))
80 PreOrPost = paramList.get<std::string>(mode +
" pre or post");
83 "MueLu::MLParameterListInterpreter::Setup(): The parameter \"coarse: pre or post\" is not supported by MueLu. " 84 "It does not make sense for direct solvers. For iterative solvers you obtain the same effect by increasing, " 85 "e.g., the number of sweeps for the coarse grid smoother. Please remove it from your parameters.");
88 std::string valuestr = value;
89 std::transform(valuestr.begin(), valuestr.end(), valuestr.begin(),
::tolower);
90 if ( valuestr ==
"jacobi" || valuestr ==
"gauss-seidel" || valuestr ==
"symmetric gauss-seidel" ) {
92 if (
PreOrPost ==
"both" ) my_name =
"\"" + pname +
"\"";
93 else my_name =
"\"smoother: " +
PreOrPost +
" type\"";
94 mueluss <<
"<Parameter name=" << my_name <<
" type=\"string\" value=\"RELAXATION\"/>" << std::endl;
96 }
else if ( valuestr ==
"ifpack" ) {
97 std::string my_name =
"\"" + pname +
"\"";
98 if ( paramList.isParameter(
"smoother: ifpack type") ) {
99 if ( paramList.get<std::string>(
"smoother: ifpack type") ==
"ILU" ) {
100 mueluss <<
"<Parameter name=" << my_name <<
" type=\"string\" value=\"ILU\"/>" << std::endl;
101 adaptingParamList.remove(
"smoother: ifpack type",
false);
103 if ( paramList.get<std::string>(
"smoother: ifpack type") ==
"ILUT" ) {
104 mueluss <<
"<Parameter name=" << my_name <<
" type\" type=\"string\" value=\"ILUT\"/>" << std::endl;
105 adaptingParamList.remove(
"smoother: ifpack type",
false);
109 }
else if (( valuestr ==
"chebyshev" ) || ( valuestr ==
"mls" )) {
110 std::string my_name =
"\"" + pname +
"\"";
111 mueluss <<
"<Parameter name=" << my_name <<
" type=\"string\" value=\"CHEBYSHEV\"/>" << std::endl;
113 }
else if (valuestr.length() > strlen(
"amesos") && valuestr.substr(0, strlen(
"amesos")) ==
"amesos") {
114 std::string solverType = valuestr.substr(strlen(
"amesos")+1);
117 const int validatorSize = 5;
118 std::string validator[validatorSize] = {
"superlu",
"superludist",
"klu",
"umfpack",
"mumps"};
119 for (
int i=0; i < validatorSize; i++)
120 if (validator[i] == solverType)
123 "MueLu::MLParameterListInterpreter: unknown smoother type. '" << solverType <<
"' not supported.");
125 mueluss <<
"<Parameter name=\"" << pname <<
"\" type=\"string\" value=\"" << solverType <<
"\"/>" << std::endl;
129 std::cout <<
"error in " << __FILE__ <<
":" << __LINE__ <<
" could not find valid smoother/solver" << std::endl;
134 if ( paramList.isParameter(
"smoother: pre or post") && mode ==
"smoother:") {
138 mueluss <<
"<Parameter name=\"smoother: pre or post\" type=\"string\" value=\"" <<
PreOrPost <<
"\"/>" << std::endl;
139 adaptingParamList.remove(
"smoother: pre or post",
false);
144 mueluss <<
"<ParameterList name=\"smoother: " <<
PreOrPost <<
" params\">" << std::endl;
146 mueluss <<
"<ParameterList name=\"" << mode <<
" params\">" << std::endl;
151 if ( valuestr ==
"jacobi" || valuestr ==
"gauss-seidel" || valuestr ==
"symmetric gauss-seidel" ) {
152 if ( valuestr ==
"jacobi" ) { mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"Jacobi\"/>" << std::endl; adaptingParamList.remove(
"relaxation: type",
false); }
153 if ( valuestr ==
"gauss-seidel" ) { mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"Gauss-Seidel\"/>" << std::endl; adaptingParamList.remove(
"relaxation: type",
false); }
154 if ( valuestr ==
"symmetric gauss-seidel" ) { mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"Symmetric Gauss-Seidel\"/>" << std::endl; adaptingParamList.remove(
"relaxation: type",
false); }
156 if ( paramList.isParameter(
"smoother: sweeps") ) { mueluss <<
"<Parameter name=\"relaxation: sweeps\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: sweeps") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: sweeps",
false); }
157 if ( paramList.isParameter(
"smoother: damping factor") ) { mueluss <<
"<Parameter name=\"relaxation: damping factor\" type=\"double\" value=\"" << paramList.get<
double>(
"smoother: damping factor") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: damping factor",
false); }
158 if ( paramList.isParameter(
"smoother: use l1 Gauss-Seidel") ) { mueluss <<
"<Parameter name=\"relaxation: use l1\" type=\"bool\" value=\"" << paramList.get<
bool>(
"smoother: use l1 Gauss-Seidel") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: use l1 Gauss-Seidel",
false); }
162 if ( valuestr ==
"chebyshev") {
163 if ( paramList.isParameter(
"smoother: polynomial order") ) { mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: polynomial order") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: polynomial order",
false); }
164 else { mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"2\"/>" << std::endl; }
165 if ( paramList.isParameter(
"smoother: Chebyshev alpha") ) { mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"" << paramList.get<
double>(
"smoother: Chebyshev alpha") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: Chebyshev alpha",
false); }
166 else { mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"20\"/>" << std::endl; adaptingParamList.remove(
"smoother: Chebyshev alpha",
false); }
167 if ( paramList.isParameter(
"eigen-analysis: type") ) { mueluss <<
"<Parameter name=\"eigen-analysis: type\" type=\"string\" value=\"" << paramList.get<std::string>(
"eigen-analysis: type") <<
"\"/>" << std::endl; adaptingParamList.remove(
"eigen-analysis: type",
false); }
168 else { mueluss <<
"<Parameter name=\"eigen-analysis: type\" type=\"string\" value=\"cg\"/>" << std::endl; }
172 if ( valuestr ==
"mls") {
173 if ( paramList.isParameter(
"smoother: MLS polynomial order") ) { mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: MLS polynomial order") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: MLS polynomial order",
false); }
174 else if ( paramList.isParameter(
"smoother: polynomial order") ) { mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: polynomial order") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: polynomial order",
false); }
175 else { mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"2\"/>" << std::endl; }
176 if ( paramList.isParameter(
"smoother: MLS alpha") ) { mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"" << paramList.get<
double>(
"smoother: MLS alpha") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: MLS alpha",
false); }
177 else if ( paramList.isParameter(
"smoother: Chebyshev alpha") ) { mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"" << paramList.get<
double>(
"smoother: Chebyshev alpha") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: Chebyshev alpha",
false); }
178 else { mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"20\"/>" << std::endl; }
179 if ( paramList.isParameter(
"eigen-analysis: type") ) { mueluss <<
"<Parameter name=\"eigen-analysis: type\" type=\"string\" value=\"" << paramList.get<std::string>(
"eigen-analysis: type") <<
"\"/>" << std::endl; adaptingParamList.remove(
"eigen-analysis: type",
false); }
180 else { mueluss <<
"<Parameter name=\"eigen-analysis: type\" type=\"string\" value=\"cg\"/>" << std::endl; }
184 if ( valuestr ==
"ifpack") {
187 if ( paramList.isParameter(
"smoother: ifpack overlap") ) { mueluss <<
"<Parameter name=\"partitioner: overlap\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: ifpack overlap") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: ifpack overlap",
false); }
188 if ( paramList.isParameter(
"smoother: ifpack level-of-fill") ) { mueluss <<
"<Parameter name=\"fact: level-of-fill\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: ifpack level-of-fill") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: ifpack level-of-fill",
false); }
189 if ( paramList.isParameter(
"smoother: ifpack absolute threshold") ) { mueluss <<
"<Parameter name=\"fact: absolute threshold\" type=\"int\" value=\"" << paramList.get<
double>(
"smoother: ifpack absolute threshold") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: ifpack absolute threshold",
false); }
190 if ( paramList.isParameter(
"smoother: ifpack relative threshold") ) { mueluss <<
"<Parameter name=\"fact: relative threshold\" type=\"int\" value=\"" << paramList.get<
double>(
"smoother: ifpack relative threshold") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: ifpack relative threshold",
false); }
193 mueluss <<
"</ParameterList>" << std::endl;
196 if ( paramList.isParameter(
"smoother: max size") ) {
197 mueluss <<
"<Parameter name=\"coarse: max size\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: max size") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: max size",
false);
200 return mueluss.str();
204 Teuchos::ParameterList paramList = paramList_in;
206 RCP<Teuchos::FancyOStream> out = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
208 #if defined(HAVE_MUELU_ML) && defined(HAVE_ML_EPETRA) && defined(HAVE_ML_TEUCHOS) 212 if (defaultVals !=
"") {
213 TEUCHOS_TEST_FOR_EXCEPTION(defaultVals!=
"SA" && defaultVals!=
"NSSA" && defaultVals!=
"refmaxwell",
Exceptions::RuntimeError,
214 "MueLu::MLParameterListInterpreter: only \"SA\", \"NSSA\", and \"refmaxwell\" allowed as options for ML default parameters.");
215 Teuchos::ParameterList ML_defaultlist;
216 if (defaultVals ==
"refmaxwell")
217 ML_Epetra::SetDefaultsRefMaxwell(ML_defaultlist);
219 ML_Epetra::SetDefaults(defaultVals,ML_defaultlist);
223 paramList = ML_defaultlist;
226 if (defaultVals !=
"") {
228 *out <<
"Warning: MueLu_ENABLE_ML=OFF, ML_ENABLE_Epetra=OFF or ML_ENABLE_TEUCHOS=OFF. No ML default values available." << std::endl;
230 #endif // HAVE_MUELU_ML && HAVE_ML_EPETRA && HAVE_ML_TEUCHOS 238 ParameterList paramListWithSubList;
240 paramList = paramListWithSubList;
241 Teuchos::ParameterList adaptingParamList = paramList;
247 bool validate = paramList.get(
"ML validate parameter list",
true);
248 if (validate && defaultVals!=
"refmaxwell") {
250 #if defined(HAVE_MUELU_ML) && defined(HAVE_ML_EPETRA) && defined(HAVE_ML_TEUCHOS) 252 int depth = paramList.get(
"ML validate depth", 5);
254 "ERROR: ML's Teuchos::ParameterList contains incorrect parameter!");
257 *out <<
"Warning: MueLu_ENABLE_ML=OFF, ML_ENABLE_Epetra=OFF or ML_ENABLE_TEUCHOS=OFF. The parameter list cannot be validated." << std::endl;
258 paramList.set(
"ML validate parameter list",
false);
260 #endif // HAVE_MUELU_ML && HAVE_ML_EPETRA && HAVE_ML_TEUCHOS 265 std::stringstream mueluss;
268 mueluss <<
"<ParameterList name=\"MueLu\">" << std::endl;
271 for (ParameterList::ConstIterator param = paramListWithSubList.begin(); param != paramListWithSubList.end(); ++param) {
274 const std::string & pname=paramListWithSubList.name(param);
278 std::stringstream valuess;
279 valuess << paramList.entry(param);
280 std::string valuestr = valuess.str();
283 valuestr =
trim(valuestr);
286 std::string valueInterpreterStr =
"\"" + valuestr +
"\"";
290 if (pname ==
"ML output") {
292 int verbosityLevel = std::stoi(valuestr);
293 std::string eVerbLevel =
"none";
294 if (verbosityLevel == 0) eVerbLevel =
"none";
295 if (verbosityLevel >= 1) eVerbLevel =
"low";
296 if (verbosityLevel >= 5) eVerbLevel =
"medium";
297 if (verbosityLevel >= 10) eVerbLevel =
"high";
298 if (verbosityLevel >= 11) eVerbLevel =
"extreme";
299 if (verbosityLevel >= 42) eVerbLevel =
"test";
300 if (verbosityLevel >= 666) eVerbLevel =
"interfacetest";
301 mueluss <<
"<Parameter name=\"verbosity\" type=\"string\" value=\"" << eVerbLevel <<
"\"/>" << std::endl;
307 mueluss << ret << std::endl;
310 adaptingParamList.remove(pname,
false);
316 if (pname ==
"energy minimization: enable") {
317 mueluss <<
"<Parameter name=\"problem: symmetric\" type=\"bool\" value=\"false\"/>" << std::endl;
318 mueluss <<
"<Parameter name=\"transpose: use implicit\" type=\"bool\" value=\"false\"/>" << std::endl;
322 if (pname ==
"smoother: type") {
329 if (pname.find(
"smoother: list (level",0) == 0) {
331 std::string type, option;
334 typedef Teuchos::ArrayRCP<char>::size_type size_type;
335 Teuchos::Array<char> ctype (size_type(pname.size()+1));
336 Teuchos::Array<char> coption(size_type(pname.size()+1));
338 int matched = sscanf(pname.c_str(),
"%s %[^(](level %d)", ctype.getRawPtr(), coption.getRawPtr(), &levelID);
339 type = std::string(ctype.getRawPtr());
340 option = std::string(coption.getRawPtr()); option.resize(option.size () - 1);
342 if (matched != 3 || (type !=
"smoother:")) {
344 <<
"Error in creating level-specific sublists" << std::endl
345 <<
"Offending parameter: " << pname << std::endl);
348 mueluss <<
"<ParameterList name=\"level " << levelID <<
"\">" << std::endl;
349 mueluss <<
GetSmootherFactory(paramList.sublist(pname),adaptingParamList.sublist(pname),
"smoother: type", paramList.sublist(pname).get<std::string>(
"smoother: type"));
350 mueluss <<
"</ParameterList>" << std::endl;
355 TEUCHOS_TEST_FOR_EXCEPTION(paramList.isParameter(
"coarse: type"),
Exceptions::RuntimeError,
"MueLu::MLParameterListInterpreter::Setup(): The parameter \"coarse: type\" should not exist but being stored in \"coarse: list\" instead.");
356 if ( pname ==
"coarse: list" ) {
362 TEUCHOS_TEST_FOR_EXCEPTION(!paramList.sublist(
"coarse: list").isParameter(
"smoother: type"),
Exceptions::RuntimeError,
"MueLu::MLParameterListInterpreter::Setup(): no coarse grid solver defined.");
363 mueluss <<
GetSmootherFactory(paramList.sublist(
"coarse: list"), adaptingParamList.sublist(
"coarse: list"),
"coarse: type", paramList.sublist(
"coarse: list").get<std::string>(
"smoother: type"));
369 mueluss <<
"</ParameterList>" << std::endl;
371 return mueluss.str();
static std::string SetParameterList(const Teuchos::ParameterList ¶mList_in, const std::string &defaultVals)
: Interpret parameter list
void MergeParameterList(const Teuchos::ParameterList &source, Teuchos::ParameterList &dest, bool overWrite)
: merge two parameter lists
static std::string interpretParameterName(const std::string &name, const std::string &value)
std::string tolower(const std::string &str)
Namespace for MueLu classes and methods.
static std::string GetSmootherFactory(const Teuchos::ParameterList ¶mList, Teuchos::ParameterList &adaptingParamList, const std::string &pname, const std::string &value)
: Helper function which translates ML smoother/solver paramters to MueLu XML string ...
void CreateSublists(const ParameterList &List, ParameterList &newList)
static std::string ML2MueLu(const std::string &name)
Translate ML parameter to corresponding MueLu parameter.
Exception throws to report errors in the internal logical of the program.
static std::string & trim(std::string &s)
void replaceAll(std::string &str, const std::string &from, const std::string &to)