https://mooseframework.inl.gov
Split.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 // MOOSE includes
11 #include "Split.h"
12 #include "InputParameters.h"
13 #include "PetscSupport.h"
14 #include "FEProblem.h"
15 #include "Conversion.h"
16 #include "NonlinearSystem.h"
17 
18 registerMooseObject("MooseApp", Split);
19 
22 {
24  params.addClassDescription("Field split based preconditioner for nonlinear solver.");
25  params.addParam<std::vector<NonlinearVariableName>>(
26  "vars", {}, "Variables Split operates on (omitting this implies \"all variables\"");
27  params.addParam<std::vector<SubdomainName>>(
28  "blocks", {}, "Mesh blocks Split operates on (omitting this implies \"all blocks\"");
29  params.addParam<std::vector<BoundaryName>>(
30  "sides", {}, "Sidesets Split operates on (omitting this implies \"all sidesets\")");
31  params.addParam<std::vector<BoundaryName>>(
32  "unsides",
33  {},
34  "Sidesets Split excludes (omitting this implies \"do not exclude any sidesets\")");
35  params.addParam<std::vector<std::string>>(
36  "splitting", {}, "The names of the splits (subsystems) in the decomposition of this split");
37  params.addParam<std::vector<BoundaryName>>(
38  "unside_by_var_boundary_name",
39  "A map from boundary name to unside by variable, e.g. only unside for a given variable.");
40  params.addParam<std::vector<NonlinearVariableName>>(
41  "unside_by_var_var_name",
42  "A map from boundary name to unside by variable, e.g. only unside for a given variable.");
43  params.addParamNamesToGroup("sides unsides unside_by_var_boundary_name unside_by_var_var_name",
44  "Sideset restriction");
45 
46  MooseEnum SplittingTypeEnum("additive multiplicative symmetric_multiplicative schur", "additive");
47  params.addParam<MooseEnum>("splitting_type", SplittingTypeEnum, "Split decomposition type");
48 
49  MooseEnum SchurTypeEnum("diag upper lower full", "full");
50  params.addParam<MooseEnum>("schur_type", SchurTypeEnum, "Type of Schur complement");
51 
58  MooseEnum SchurPreEnum("S Sp A11", "S");
59  params.addParam<MooseEnum>(
60  "schur_pre", SchurPreEnum, "Type of Schur complement preconditioner matrix");
61 
62  params.addParam<MultiMooseEnum>("petsc_options",
64  "PETSc flags for the FieldSplit solver");
65  params.addParam<MultiMooseEnum>("petsc_options_iname",
67  "PETSc option names for the FieldSplit solver");
68  params.addParam<std::vector<std::string>>("petsc_options_value",
69  "PETSc option values for the FieldSplit solver");
70 
71  params.registerBase("Split");
72  params.registerSystemAttributeName("Split");
73  return params;
74 }
75 
76 Split::Split(const InputParameters & parameters)
77  : MooseObject(parameters),
78  Restartable(this, "Splits"),
79  _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
80  _vars(getParam<std::vector<NonlinearVariableName>>("vars")),
81  _blocks(getParam<std::vector<SubdomainName>>("blocks")),
82  _sides(getParam<std::vector<BoundaryName>>("sides")),
83  _unsides(getParam<std::vector<BoundaryName>>("unsides")),
84  _splitting(getParam<std::vector<std::string>>("splitting")),
85  _splitting_type(getParam<MooseEnum>("splitting_type")),
86  _schur_type(getParam<MooseEnum>("schur_type")),
87  _schur_pre(getParam<MooseEnum>("schur_pre"))
88 {
89 }
90 
91 void
92 Split::setup(NonlinearSystemBase & nl, const std::string & prefix)
93 {
94  // The Split::setup() implementation does not actually depend on any
95  // specific version of PETSc, so there's no need to wrap the entire
96  // function.
97 
98  // A reference to the PetscOptions
100  // prefix
101  std::string dmprefix = prefix + "dm_moose_";
102 
103  if (isParamValid("unside_by_var_boundary_name"))
104  {
105  const auto & unside_by_var_boundary_name =
106  getParam<std::vector<BoundaryName>>("unside_by_var_boundary_name");
107  const auto & unside_by_var_var_name =
108  getParam<std::vector<NonlinearVariableName>>("unside_by_var_var_name");
109 
110  std::vector<std::string> vector_of_pairs;
111  for (const auto i : index_range(unside_by_var_boundary_name))
112  vector_of_pairs.push_back(unside_by_var_boundary_name[i] + ":" + unside_by_var_var_name[i]);
113  po.pairs.emplace_back(dmprefix + "unside_by_var", Moose::stringify(vector_of_pairs, ","));
114  }
115 
116  // var options
117  if (!_vars.empty())
118  {
119  po.pairs.emplace_back(dmprefix + "vars", Moose::stringify(_vars, ","));
120 
121  // check that variables are either field or scalars
122  for (const auto & var : _vars)
124  mooseError("Variable '", var, "' specified in split '", name(), "' does not exist");
125  }
126 
127  // block options
128  if (!_blocks.empty())
129  po.pairs.emplace_back(dmprefix + "blocks", Moose::stringify(_blocks, ","));
130 
131  // side options
132  if (!_sides.empty())
133  po.pairs.emplace_back(dmprefix + "sides", Moose::stringify(_sides, ","));
134 
135  // unside options
136  if (!_unsides.empty())
137  po.pairs.emplace_back(dmprefix + "unsides", Moose::stringify(_unsides, ","));
138 
139  if (!_splitting.empty())
140  {
141  // If this split has subsplits, it is presumed that the pc_type used to solve this split's
142  // subsystem is fieldsplit
143  // with the following parameters (unless overridden by the user-specified petsc_options below).
144  po.pairs.emplace_back(prefix + "pc_type", "fieldsplit");
145 
146  // set Splitting Type
147  const std::string petsc_splitting_type[] = {
148  "additive", "multiplicative", "symmetric_multiplicative", "schur"};
149  po.pairs.emplace_back(prefix + "pc_fieldsplit_type", petsc_splitting_type[_splitting_type]);
150 
152  {
153  // set Schur Type
154  const std::string petsc_schur_type[] = {"diag", "upper", "lower", "full"};
155  po.pairs.emplace_back(prefix + "pc_fieldsplit_schur_fact_type",
156  petsc_schur_type[_schur_type]);
157 
158  // set Schur Preconditioner
159  const std::string petsc_schur_pre[] = {"self", "selfp", "a11"};
160  po.pairs.emplace_back(prefix + "pc_fieldsplit_schur_precondition",
161  petsc_schur_pre[_schur_pre]);
162  }
163 
164  // The DM associated with this split defines the subsplits' geometry.
165  po.pairs.emplace_back(dmprefix + "nfieldsplits", Moose::stringify(_splitting.size()));
166  po.pairs.emplace_back(dmprefix + "fieldsplit_names", Moose::stringify(_splitting, ","));
167 
168  // Finally, recursively configure the splits contained within this split.
169  for (const auto & split_name : _splitting)
170  {
171  std::shared_ptr<Split> split = nl.getSplit(split_name);
172  std::string sprefix = prefix + "fieldsplit_" + split_name + "_";
173  split->setup(nl, sprefix);
174  }
175  }
176 
177  // Now we set the user-specified petsc options for this split, possibly overriding the above
178  // settings.
180 }
virtual void setup(NonlinearSystemBase &nl, const std::string &prefix="-")
Definition: Split.C:92
MultiMooseEnum getCommonPetscKeys()
A helper function to produce a MultiMooseEnum with commonly used PETSc iname options (keys in key-val...
virtual bool hasVariable(const std::string &var_name) const override
Whether or not this problem has the variable.
Moose::PetscSupport::PetscOptions & getPetscOptions()
Retrieve a writable reference the PETSc options (used by PetscSupport)
A class for creating restricted objects.
Definition: Restartable.h:28
Base class for split-based preconditioners.
Definition: Split.h:25
std::vector< SubdomainName > _blocks
Definition: Split.h:52
std::vector< NonlinearVariableName > _vars
"Variables Split operates on
Definition: Split.h:48
registerMooseObject("MooseApp", Split)
std::vector< std::string > _splitting
Split subsystem list.
Definition: Split.h:58
A struct for storing the various types of petsc options and values.
Definition: PetscSupport.h:39
void registerSystemAttributeName(const std::string &value)
This method is used to define the MOOSE system name that is used by the TheWarehouse object for stori...
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
virtual bool hasScalarVariable(const std::string &var_name) const override
Returns a Boolean indicating whether any system contains a variable with the name provided...
std::vector< std::pair< std::string, std::string > > pairs
PETSc key-value pairs.
Definition: PetscSupport.h:48
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
FEProblemBase & _fe_problem
Definition: Split.h:45
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
void registerBase(const std::string &value)
This method must be called from every base "Moose System" to create linkage with the Action System...
Nonlinear system to be solved.
std::vector< BoundaryName > _sides
Definition: Split.h:53
MooseEnum _splitting_type
Definition: Split.h:62
MultiMooseEnum getCommonPetscFlags()
A helper function to produce a MultiMooseEnum with commonly used PETSc single options (flags) ...
Definition: PetscSupport.C:978
std::vector< BoundaryName > _unsides
Definition: Split.h:54
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:28
std::shared_ptr< Split > getSplit(const std::string &name)
Retrieves a split by name.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
tbb::split split
Split(const InputParameters &parameters)
Definition: Split.C:76
static InputParameters validParams()
Definition: Split.C:21
MooseEnum _schur_pre
Definition: Split.h:64
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
void storePetscOptions(FEProblemBase &fe_problem, const std::string &prefix, const ParallelParamObject &param_object)
Stores the PETSc options supplied from the parameter object on the problem.
Definition: PetscSupport.C:588
static InputParameters validParams()
Definition: MooseObject.C:25
auto index_range(const T &sizable)
MooseEnum _schur_type
Definition: Split.h:63
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...