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 ==
"hiptmair" ) {
98 if (
PreOrPost ==
"both" ) my_name =
"\"" + pname +
"\"";
99 else my_name =
"\"smoother: " +
PreOrPost +
" type\"";
100 mueluss <<
"<Parameter name=" << my_name <<
" type=\"string\" value=\"HIPTMAIR\"/>" << std::endl;
102 }
else if ( valuestr ==
"ifpack" ) {
103 std::string my_name =
"\"" + pname +
"\"";
104 if ( paramList.isParameter(
"smoother: ifpack type") ) {
105 if ( paramList.get<std::string>(
"smoother: ifpack type") ==
"ILU" ) {
106 mueluss <<
"<Parameter name=" << my_name <<
" type=\"string\" value=\"ILU\"/>" << std::endl;
107 adaptingParamList.remove(
"smoother: ifpack type",
false);
109 if ( paramList.get<std::string>(
"smoother: ifpack type") ==
"ILUT" ) {
110 mueluss <<
"<Parameter name=" << my_name <<
" type\" type=\"string\" value=\"ILUT\"/>" << std::endl;
111 adaptingParamList.remove(
"smoother: ifpack type",
false);
115 }
else if (( valuestr ==
"chebyshev" ) || ( valuestr ==
"mls" )) {
116 std::string my_name =
"\"" + pname +
"\"";
117 mueluss <<
"<Parameter name=" << my_name <<
" type=\"string\" value=\"CHEBYSHEV\"/>" << std::endl;
119 }
else if (valuestr.length() > strlen(
"amesos") && valuestr.substr(0, strlen(
"amesos")) ==
"amesos") {
120 std::string solverType = valuestr.substr(strlen(
"amesos")+1);
123 const int validatorSize = 5;
124 std::string validator[validatorSize] = {
"superlu",
"superludist",
"klu",
"umfpack",
"mumps"};
125 for (
int i=0; i < validatorSize; i++)
126 if (validator[i] == solverType)
129 "MueLu::MLParameterListInterpreter: unknown smoother type. '" << solverType <<
"' not supported.");
131 mueluss <<
"<Parameter name=\"" << pname <<
"\" type=\"string\" value=\"" << solverType <<
"\"/>" << std::endl;
135 std::cout <<
"error in " << __FILE__ <<
":" << __LINE__ <<
" could not find valid smoother/solver" << std::endl;
140 if ( paramList.isParameter(
"smoother: pre or post") && mode ==
"smoother:") {
144 mueluss <<
"<Parameter name=\"smoother: pre or post\" type=\"string\" value=\"" <<
PreOrPost <<
"\"/>" << std::endl;
145 adaptingParamList.remove(
"smoother: pre or post",
false);
150 mueluss <<
"<ParameterList name=\"smoother: " <<
PreOrPost <<
" params\">" << std::endl;
152 mueluss <<
"<ParameterList name=\"" << mode <<
" params\">" << std::endl;
157 if ( valuestr ==
"jacobi" || valuestr ==
"gauss-seidel" || valuestr ==
"symmetric gauss-seidel" ) {
158 if ( valuestr ==
"jacobi" ) { mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"Jacobi\"/>" << std::endl; adaptingParamList.remove(
"relaxation: type",
false); }
159 if ( valuestr ==
"gauss-seidel" ) { mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"Gauss-Seidel\"/>" << std::endl; adaptingParamList.remove(
"relaxation: type",
false); }
160 if ( valuestr ==
"symmetric gauss-seidel" ) { mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"Symmetric Gauss-Seidel\"/>" << std::endl; adaptingParamList.remove(
"relaxation: type",
false); }
162 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); }
163 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); }
164 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); }
168 if ( valuestr ==
"chebyshev") {
169 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); }
170 else { mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"2\"/>" << std::endl; }
171 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); }
172 else { mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"20\"/>" << std::endl; adaptingParamList.remove(
"smoother: Chebyshev alpha",
false); }
173 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); }
174 else { mueluss <<
"<Parameter name=\"eigen-analysis: type\" type=\"string\" value=\"cg\"/>" << std::endl; }
178 if ( valuestr ==
"mls") {
179 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); }
180 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); }
181 else { mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"2\"/>" << std::endl; }
182 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); }
183 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); }
184 else { mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"20\"/>" << std::endl; }
185 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); }
186 else { mueluss <<
"<Parameter name=\"eigen-analysis: type\" type=\"string\" value=\"cg\"/>" << std::endl; }
189 if ( valuestr ==
"hiptmair" ) {
190 std::string subSmootherType =
"Chebyshev";
191 if (paramList.isParameter(
"subsmoother: type"))
192 subSmootherType = paramList.get<std::string>(
"subsmoother: type");
193 std::string subSmootherIfpackType;
194 if (subSmootherType ==
"Chebyshev")
195 subSmootherIfpackType =
"CHEBYSHEV";
196 else if (subSmootherType ==
"Jacobi" || subSmootherType ==
"Gauss-Seidel" || subSmootherType ==
"symmetric Gauss-Seidel") {
197 if (subSmootherType ==
"symmetric Gauss-Seidel") subSmootherType =
"Symmetric Gauss-Seidel";
198 subSmootherIfpackType =
"RELAXATION";
200 TEUCHOS_TEST_FOR_EXCEPTION(
true,
Exceptions::RuntimeError,
"MueLu::MLParameterListTranslator: unknown smoother type. '" << subSmootherType <<
"' not supported by MueLu.");
202 mueluss <<
"<Parameter name=\"hiptmair: smoother type 1\" type=\"string\" value=\"" << subSmootherIfpackType <<
"\"/>" << std::endl;
203 mueluss <<
"<Parameter name=\"hiptmair: smoother type 2\" type=\"string\" value=\"" << subSmootherIfpackType <<
"\"/>" << std::endl;
205 mueluss <<
"<ParameterList name=\"hiptmair: smoother list 1\">" << std::endl;
206 if (subSmootherType ==
"Chebyshev") {
207 if (paramList.isParameter(
"subsmoother: edge sweeps")) {
208 mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"" << paramList.get<
int>(
"subsmoother: edge sweeps") <<
"\"/>" << std::endl;
209 adaptingParamList.remove(
"subsmoother: edge sweeps",
false);
211 if (paramList.isParameter(
"subsmoother: Chebyshev alpha")) {
212 mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"" << paramList.get<
double>(
"subsmoother: Chebyshev alpha") <<
"\"/>" << std::endl;
215 if (paramList.isParameter(
"subsmoother: edge sweeps")) {
216 mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"" << subSmootherType <<
"\"/>" << std::endl;
217 mueluss <<
"<Parameter name=\"relaxation: sweeps\" type=\"int\" value=\"" << paramList.get<
int>(
"subsmoother: edge sweeps") <<
"\"/>" << std::endl;
218 adaptingParamList.remove(
"subsmoother: edge sweeps",
false);
220 if (paramList.isParameter(
"subsmoother: SGS damping factor")) {
221 mueluss <<
"<Parameter name=\"relaxation: damping factor\" type=\"double\" value=\"" << paramList.get<
double>(
"subsmoother: SGS damping factor") <<
"\"/>" << std::endl;
224 mueluss <<
"</ParameterList>" << std::endl;
226 mueluss <<
"<ParameterList name=\"hiptmair: smoother list 2\">" << std::endl;
227 if (subSmootherType ==
"Chebyshev") {
228 if (paramList.isParameter(
"subsmoother: node sweeps")) {
229 mueluss <<
"<Parameter name=\"chebyshev: degree\" type=\"int\" value=\"" << paramList.get<
int>(
"subsmoother: node sweeps") <<
"\"/>" << std::endl;
230 adaptingParamList.remove(
"subsmoother: node sweeps",
false);
232 if (paramList.isParameter(
"subsmoother: Chebyshev alpha")) {
233 mueluss <<
"<Parameter name=\"chebyshev: ratio eigenvalue\" type=\"double\" value=\"" << paramList.get<
double>(
"subsmoother: Chebyshev alpha") <<
"\"/>" << std::endl;
234 adaptingParamList.remove(
"subsmoother: Chebyshev alpha",
false);
237 if (paramList.isParameter(
"subsmoother: node sweeps")) {
238 mueluss <<
"<Parameter name=\"relaxation: type\" type=\"string\" value=\"" << subSmootherType <<
"\"/>" << std::endl;
239 mueluss <<
"<Parameter name=\"relaxation: sweeps\" type=\"int\" value=\"" << paramList.get<
int>(
"subsmoother: node sweeps") <<
"\"/>" << std::endl;
240 adaptingParamList.remove(
"subsmoother: node sweeps",
false);
242 if (paramList.isParameter(
"subsmoother: SGS damping factor")) {
243 mueluss <<
"<Parameter name=\"relaxation: damping factor\" type=\"double\" value=\"" << paramList.get<
double>(
"subsmoother: SGS damping factor") <<
"\"/>" << std::endl;
244 adaptingParamList.remove(
"subsmoother: SGS damping factor",
false);
247 mueluss <<
"</ParameterList>" << std::endl;
252 if ( valuestr ==
"ifpack") {
255 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); }
256 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); }
257 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); }
258 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); }
261 mueluss <<
"</ParameterList>" << std::endl;
264 if ( paramList.isParameter(
"smoother: max size") ) {
265 mueluss <<
"<Parameter name=\"coarse: max size\" type=\"int\" value=\"" << paramList.get<
int>(
"smoother: max size") <<
"\"/>" << std::endl; adaptingParamList.remove(
"smoother: max size",
false);
268 return mueluss.str();
272 Teuchos::ParameterList paramList = paramList_in;
274 RCP<Teuchos::FancyOStream> out = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout));
276#if defined(HAVE_MUELU_ML) && defined(HAVE_ML_EPETRA) && defined(HAVE_ML_TEUCHOS)
280 if (defaultVals !=
"") {
281 TEUCHOS_TEST_FOR_EXCEPTION(defaultVals!=
"SA" && defaultVals!=
"NSSA" && defaultVals!=
"refmaxwell" && defaultVals!=
"Maxwell",
Exceptions::RuntimeError,
282 "MueLu::MLParameterListInterpreter: only \"SA\", \"NSSA\", \"refmaxwell\" and \"Maxwell\" allowed as options for ML default parameters.");
283 Teuchos::ParameterList ML_defaultlist;
284 if (defaultVals ==
"refmaxwell")
285 ML_Epetra::SetDefaultsRefMaxwell(ML_defaultlist);
287 ML_Epetra::SetDefaults(defaultVals,ML_defaultlist);
291 paramList = ML_defaultlist;
294 if (defaultVals !=
"") {
296 *out <<
"Warning: MueLu_ENABLE_ML=OFF, ML_ENABLE_Epetra=OFF or ML_ENABLE_TEUCHOS=OFF. No ML default values available." << std::endl;
306 ParameterList paramListWithSubList;
308 paramList = paramListWithSubList;
309 Teuchos::ParameterList adaptingParamList = paramList;
315 bool validate = paramList.get(
"ML validate parameter list",
true);
316 if (validate && defaultVals!=
"refmaxwell") {
318#if defined(HAVE_MUELU_ML) && defined(HAVE_ML_EPETRA) && defined(HAVE_ML_TEUCHOS)
320 int depth = paramList.get(
"ML validate depth", 5);
322 "ERROR: ML's Teuchos::ParameterList contains incorrect parameter!");
325 *out <<
"Warning: MueLu_ENABLE_ML=OFF, ML_ENABLE_Epetra=OFF or ML_ENABLE_TEUCHOS=OFF. The parameter list cannot be validated." << std::endl;
326 paramList.set(
"ML validate parameter list",
false);
342 if (paramListWithSubList.isParameter(
"aggregation: aux: enable") && paramListWithSubList.get<
bool>(
"aggregation: aux: enable")) {
343 if (paramListWithSubList.isParameter(
"aggregation: aux: threshold")) {
344 paramListWithSubList.set(
"aggregation: threshold", paramListWithSubList.get<
double>(
"aggregation: aux: threshold"));
345 paramListWithSubList.remove(
"aggregation: aux: threshold");
351 std::stringstream mueluss;
354 mueluss <<
"<ParameterList name=\"MueLu\">" << std::endl;
357 for (ParameterList::ConstIterator param = paramListWithSubList.begin(); param != paramListWithSubList.end(); ++param) {
360 const std::string & pname=paramListWithSubList.name(param);
364 std::stringstream valuess;
365 valuess << paramList.entry(param);
366 std::string valuestr = valuess.str();
369 valuestr =
trim(valuestr);
372 std::string valueInterpreterStr =
"\"" + valuestr +
"\"";
376 if (pname ==
"ML output") {
378 int verbosityLevel = std::stoi(valuestr);
379 std::string eVerbLevel =
"none";
380 if (verbosityLevel == 0) eVerbLevel =
"none";
381 if (verbosityLevel >= 1) eVerbLevel =
"low";
382 if (verbosityLevel >= 5) eVerbLevel =
"medium";
383 if (verbosityLevel >= 10) eVerbLevel =
"high";
384 if (verbosityLevel >= 11) eVerbLevel =
"extreme";
385 if (verbosityLevel >= 42) eVerbLevel =
"test";
386 if (verbosityLevel >= 666) eVerbLevel =
"interfacetest";
387 mueluss <<
"<Parameter name=\"verbosity\" type=\"string\" value=\"" << eVerbLevel <<
"\"/>" << std::endl;
393 mueluss << ret << std::endl;
396 adaptingParamList.remove(pname,
false);
402 if (pname ==
"energy minimization: enable") {
403 mueluss <<
"<Parameter name=\"problem: symmetric\" type=\"bool\" value=\"false\"/>" << std::endl;
404 mueluss <<
"<Parameter name=\"transpose: use implicit\" type=\"bool\" value=\"false\"/>" << std::endl;
408 if (pname ==
"smoother: type") {
415 if (pname.find(
"smoother: list (level",0) == 0) {
417 std::string type, option;
420 typedef Teuchos::ArrayRCP<char>::size_type size_type;
421 Teuchos::Array<char> ctype (size_type(pname.size()+1));
422 Teuchos::Array<char> coption(size_type(pname.size()+1));
424 int matched = sscanf(pname.c_str(),
"%s %[^(](level %d)", ctype.getRawPtr(), coption.getRawPtr(), &levelID);
425 type = std::string(ctype.getRawPtr());
426 option = std::string(coption.getRawPtr()); option.resize(option.size () - 1);
428 if (matched != 3 || (type !=
"smoother:")) {
430 <<
"Error in creating level-specific sublists" << std::endl
431 <<
"Offending parameter: " << pname << std::endl);
434 mueluss <<
"<ParameterList name=\"level " << levelID <<
"\">" << std::endl;
435 mueluss <<
GetSmootherFactory(paramList.sublist(pname),adaptingParamList.sublist(pname),
"smoother: type", paramList.sublist(pname).get<std::string>(
"smoother: type"));
436 mueluss <<
"</ParameterList>" << std::endl;
441 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.");
442 if ( pname ==
"coarse: list" ) {
448 TEUCHOS_TEST_FOR_EXCEPTION(!paramList.sublist(
"coarse: list").isParameter(
"smoother: type"),
Exceptions::RuntimeError,
"MueLu::MLParameterListInterpreter::Setup(): no coarse grid solver defined.");
449 mueluss <<
GetSmootherFactory(paramList.sublist(
"coarse: list"), adaptingParamList.sublist(
"coarse: list"),
"coarse: type", paramList.sublist(
"coarse: list").get<std::string>(
"smoother: type"));
455 mueluss <<
"</ParameterList>" << std::endl;
457 return mueluss.str();