Split.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
// MOOSE includes
#include "Split.h"
#include "InputParameters.h"
#include "PetscSupport.h"
#include "FEProblem.h"
#include "Conversion.h"
#include "NonlinearSystem.h"
 
#include <algorithm>
 
registerMooseObject("MooseApp", Split);
 
InputParameters
Split::validParams()
{
  InputParameters params = MooseObject::validParams();
  params.addClassDescription("Field split based preconditioner for nonlinear solver.");
  params.addParam<std::vector<NonlinearVariableName>>(
      "vars", {}, "Variables Split operates on (omitting this implies \"all variables\"");
  params.addParam<std::vector<SubdomainName>>(
      "blocks", {}, "Mesh blocks Split operates on (omitting this implies \"all blocks\"");
  params.addParam<std::vector<BoundaryName>>(
      "sides", {}, "Sidesets Split operates on (omitting this implies \"all sidesets\")");
  params.addParam<std::vector<BoundaryName>>(
      "unsides",
      {},
      "Sidesets Split excludes (omitting this implies \"do not exclude any sidesets\")");
  params.addParam<std::vector<std::string>>(
      "splitting", {}, "The names of the splits (subsystems) in the decomposition of this split");
  params.addParam<std::vector<BoundaryName>>(
      "unside_by_var_boundary_name",
      "A map from boundary name to unside by variable, e.g. only unside for a given variable.");
  params.addParam<std::vector<NonlinearVariableName>>(
      "unside_by_var_var_name",
      "A map from boundary name to unside by variable, e.g. only unside for a given variable.");
  params.addParamNamesToGroup("sides unsides unside_by_var_boundary_name unside_by_var_var_name",
                              "Sideset restriction");
 
  MooseEnum SplittingTypeEnum("additive multiplicative symmetric_multiplicative schur", "additive");
  params.addParam<MooseEnum>("splitting_type", SplittingTypeEnum, "Split decomposition type");
 
  MooseEnum SchurTypeEnum("diag upper lower full", "full");
  params.addParam<MooseEnum>("schur_type", SchurTypeEnum, "Type of Schur complement");
 
  MooseEnum SchurPreEnum("S Sp A11", "S");
  params.addParam<MooseEnum>(
      "schur_pre", SchurPreEnum, "Type of Schur complement preconditioner matrix");
 
  params.addParam<MultiMooseEnum>("petsc_options",
                                  Moose::PetscSupport::getCommonPetscFlags(),
                                  "PETSc flags for the FieldSplit solver");
  params.addParam<MultiMooseEnum>("petsc_options_iname",
                                  Moose::PetscSupport::getCommonPetscKeys(),
                                  "PETSc option names for the FieldSplit solver");
  params.addParam<std::vector<std::string>>("petsc_options_value",
                                            "PETSc option values for the FieldSplit solver");
 
  params.registerBase("Split");
  params.registerSystemAttributeName("Split");
  return params;
}
 
Split::Split(const InputParameters & parameters)
  : MooseObject(parameters),
    Restartable(this, "Splits"),
    _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
    _vars(getParam<std::vector<NonlinearVariableName>>("vars")),
    _blocks(getParam<std::vector<SubdomainName>>("blocks")),
    _sides(getParam<std::vector<BoundaryName>>("sides")),
    _unsides(getParam<std::vector<BoundaryName>>("unsides")),
    _splitting(getParam<std::vector<std::string>>("splitting")),
    _splitting_type(getParam<MooseEnum>("splitting_type")),
    _schur_type(getParam<MooseEnum>("schur_type")),
    _schur_pre(getParam<MooseEnum>("schur_pre"))
{
}
 
void
Split::setup(NonlinearSystemBase & nl, const std::string & prefix)
{
  // The Split::setup() implementation does not actually depend on any
  // specific version of PETSc, so there's no need to wrap the entire
  // function.
 
  // A reference to the PetscOptions
  Moose::PetscSupport::PetscOptions & po = _fe_problem.getPetscOptions();
  // prefix
  const std::string prefix_with_dash = '-' + prefix;
  std::string dmprefix = prefix_with_dash + "dm_moose_";
 
  if (isParamValid("unside_by_var_boundary_name"))
  {
    const auto & unside_by_var_boundary_name =
        getParam<std::vector<BoundaryName>>("unside_by_var_boundary_name");
    const auto & unside_by_var_var_name =
        getParam<std::vector<NonlinearVariableName>>("unside_by_var_var_name");
 
    std::vector<std::string> vector_of_pairs;
    for (const auto i : index_range(unside_by_var_boundary_name))
      vector_of_pairs.push_back(unside_by_var_boundary_name[i] + ":" + unside_by_var_var_name[i]);
    po.pairs.emplace_back(dmprefix + "unside_by_var", Moose::stringify(vector_of_pairs, ","));
  }
 
  // var options
  if (!_vars.empty())
  {
    po.pairs.emplace_back(dmprefix + "vars", Moose::stringify(_vars, ","));
 
    // check that variables are either field or scalars
    for (const auto & var : _vars)
      if (!_fe_problem.hasVariable(var) && !_fe_problem.hasScalarVariable(var))
        mooseError("Variable '", var, "' specified in split '", name(), "' does not exist");
  }
 
  // block options
  if (!_blocks.empty())
    po.pairs.emplace_back(dmprefix + "blocks", Moose::stringify(_blocks, ","));
 
  // side options
  if (!_sides.empty())
    po.pairs.emplace_back(dmprefix + "sides", Moose::stringify(_sides, ","));
 
  // unside options
  if (!_unsides.empty())
    po.pairs.emplace_back(dmprefix + "unsides", Moose::stringify(_unsides, ","));
 
  if (!_splitting.empty())
  {
    // If this split has subsplits, it is presumed that the pc_type used to solve this split's
    // subsystem is fieldsplit
    // with the following parameters (unless overridden by the user-specified petsc_options below).
    po.pairs.emplace_back(prefix_with_dash + "pc_type", "fieldsplit");
 
    // set Splitting Type
    const std::string petsc_splitting_type[] = {
        "additive", "multiplicative", "symmetric_multiplicative", "schur"};
    po.pairs.emplace_back(prefix_with_dash + "pc_fieldsplit_type",
                          petsc_splitting_type[_splitting_type]);
 
    if (_splitting_type == SplittingTypeSchur)
    {
      // set Schur Type
      const std::string petsc_schur_type[] = {"diag", "upper", "lower", "full"};
      po.pairs.emplace_back(prefix_with_dash + "pc_fieldsplit_schur_fact_type",
                            petsc_schur_type[_schur_type]);
 
      // set Schur Preconditioner
      const std::string petsc_schur_pre[] = {"self", "selfp", "a11"};
      po.pairs.emplace_back(prefix_with_dash + "pc_fieldsplit_schur_precondition",
                            petsc_schur_pre[_schur_pre]);
    }
 
    // The DM associated with this split defines the subsplits' geometry.
    po.pairs.emplace_back(dmprefix + "nfieldsplits", Moose::stringify(_splitting.size()));
    po.pairs.emplace_back(dmprefix + "fieldsplit_names", Moose::stringify(_splitting, ","));
 
    // Finally, recursively configure the splits contained within this split.
    std::map<NonlinearVariableName, std::vector<std::pair<std::string, std::shared_ptr<Split>>>>
        vars_to_splits;
    for (const auto & split_name : _splitting)
    {
      std::shared_ptr<Split> split = nl.getSplit(split_name);
 
      // Make sure no two sibling splits explicitly claim the same variable in a way that would
      // leave at most one of them actually preconditioning it. Two splits sharing a variable are
      // only known to be safe if they are both restricted to disjoint regions; we can only prove
      // that when both restrict via non-overlapping "blocks" (blocks partition the mesh, so any
      // shared block name means the splits overlap). An unrestricted split applies to the whole
      // mesh, so it conflicts with any sibling that claims the same variable, however that
      // sibling restricts itself. Restrictions we cannot compare this way (sides/unsides, or
      // subclass-specific mechanisms like ContactSplit's contact/uncontact surfaces) are assumed
      // to legitimately partition the variable, as before.
      for (const auto & var : split->getVars())
      {
        auto & prior_claims = vars_to_splits[var];
        for (const auto & [prior_name, prior_split] : prior_claims)
        {
          const auto & blocks = split->getBlocks();
          const auto & prior_blocks = prior_split->getBlocks();
          const bool blocks_overlap =
              !blocks.empty() && !prior_blocks.empty() &&
              std::any_of(blocks.begin(),
                          blocks.end(),
                          [&prior_blocks](const auto & block)
                          {
                            return std::find(prior_blocks.begin(), prior_blocks.end(), block) !=
                                   prior_blocks.end();
                          });
          if (!split->restrictsRegion() || !prior_split->restrictsRegion() || blocks_overlap)
            mooseError("Variable '",
                       var,
                       "' is specified in both split '",
                       prior_name,
                       "' and split '",
                       split_name,
                       "', which are both part of split '",
                       name(),
                       "'");
        }
        prior_claims.emplace_back(split_name, split);
      }
 
      std::string sprefix = prefix + "fieldsplit_" + split_name + "_";
      split->setup(nl, sprefix);
    }
  }
 
  // Now we set the user-specified petsc options for this split, possibly overriding the above
  // settings.
  Moose::PetscSupport::storePetscOptions(_fe_problem, prefix, *this);
}