MortarPeriodicAction Class Reference

Set up Mortar based periodicity in an input file with a MortarPeriodicMesh. More...

#include <MortarPeriodicAction.h>

Inheritance diagram for MortarPeriodicAction:

Public Member Functions
	MortarPeriodicAction (const InputParameters &parameters)
virtual void	act ()

Protected Attributes
std::vector< VariableName >	_variables
const unsigned int	_periodicity
const MultiMooseEnum	_periodic_directions

Detailed Description

Set up Mortar based periodicity in an input file with a MortarPeriodicMesh.

Definition at line 22 of file MortarPeriodicAction.h.

Constructor & Destructor Documentation

MortarPeriodicAction()

MortarPeriodicAction::MortarPeriodicAction

(

const InputParameters &

parameters

)

Definition at line 43 of file MortarPeriodicAction.C.

  : Action(parameters),
    _variables(getParam<std::vector<VariableName>>("variable")),
    _periodicity(getParam<MooseEnum>("periodicity")),
    _periodic_directions(getParam<MultiMooseEnum>("periodic_directions"))
{
}

Member Function Documentation

act()

void MortarPeriodicAction::act ( )

virtual

Definition at line 52 of file MortarPeriodicAction.C.

{
  // mesh dimension
  const unsigned short dim = _mesh->dimension();
 
  // periodicity subblock name
  std::string periodicity_name = name();
 
  // axis names
  const std::vector<BoundaryName> axis = {"x", "y", "z"};
 
  // boundaries
  const std::vector<BoundaryName> boundary_names = {"left", "bottom", "back"};
  // opposite boundaries
  const std::vector<BoundaryName> opposite_boundary_names = {"right", "top", "front"};
 
  // Get the current subdomain ids
  std::set<SubdomainID> current_subdomain_ids;
  _mesh->getMesh().subdomain_ids(current_subdomain_ids);
 
  SubdomainID new_subdomain_id =
      *std::max_element(current_subdomain_ids.begin(), current_subdomain_ids.end()) + 1;
 
  // iterate over the periodic directions
  for (unsigned short i = 0; i < dim; ++i)
  {
    if (_periodic_directions.contains(i))
    {
      //
      // Add Mortar interfaces. I am only going to add these to the reference
      // mesh because this action currently has no machinery to add constraints
      // on the displaced problem (e.g. see the add_constraint block)
      //
      if (_current_task == "add_mesh_modifier")
      {
        // Don't do mesh modifiers when recovering!
        if (!_app.isRecovering())
        {
          auto slave_params = _factory.getValidParams("LowerDBlockFromSideset");
          auto master_params = _factory.getValidParams("LowerDBlockFromSideset");
 
          auto slave_boundary_id = _mesh->getBoundaryID(boundary_names[i]);
          auto master_boundary_id = _mesh->getBoundaryID(opposite_boundary_names[i]);
 
          slave_params.set<SubdomainID>("new_block_id") = new_subdomain_id++;
          slave_params.set<SubdomainName>("new_block_name") = "slave_" + axis[i];
          slave_params.set<std::vector<BoundaryID>>("sidesets") = {slave_boundary_id};
          slave_params.set<MooseMesh *>("_mesh") = _mesh.get();
 
          master_params.set<SubdomainID>("new_block_id") = new_subdomain_id++;
          master_params.set<SubdomainName>("new_block_name") = "master_" + axis[i];
          master_params.set<std::vector<BoundaryID>>("sidesets") = {master_boundary_id};
          master_params.set<MooseMesh *>("_mesh") = _mesh.get();
 
          _app.addMeshModifier("LowerDBlockFromSideset", axis[i] + "_slave_lower_d", slave_params);
          _app.addMeshModifier(
              "LowerDBlockFromSideset", axis[i] + "_master_lower_d", master_params);
        }
      }
 
      // Lagrange multiplier variable base name
      const std::string lm_base = "lm_" + periodicity_name + "_" + boundary_names[i];
 
      //
      // Add Lagrange multiplier variables
      //
 
      if (_current_task == "add_variable")
      {
        std::set<SubdomainID> sub_ids = {_mesh->getSubdomainID("slave_" + axis[i])};
        for (auto & var : _variables)
        {
          switch (_periodicity)
          {
            case 0: // gradient
            {
              for (unsigned short j = 0; j < dim; ++j)
              {
                _problem->addVariable(lm_base + "_" + var + "_d" + axis[j],
                                      FEType(Utility::string_to_enum<Order>("FIRST"),
                                             Utility::string_to_enum<FEFamily>("LAGRANGE")),
                                      1.0,
                                      &sub_ids);
              }
              break;
            }
 
            case 1: // value
            {
              _problem->addVariable(lm_base + "_" + var,
                                    FEType(Utility::string_to_enum<Order>("FIRST"),
                                           Utility::string_to_enum<FEFamily>("LAGRANGE")),
                                    1.0,
                                    &sub_ids);
              break;
            }
 
            default:
              paramError("periodicity", "Periodicity type not implemented");
          }
        }
      }
 
      //
      // Add Constraints
      //
 
      if (_current_task == "add_constraint")
      {
        for (auto & var : _variables)
        {
          const std::string ct_base =
              "ct_" + periodicity_name + "_" + boundary_names[i] + "_" + var;
          switch (_periodicity)
          {
            case 0: // gradient
            {
              for (unsigned short j = 0; j < dim; ++j)
              {
                InputParameters params =
                    _factory.getValidParams("EqualGradientConstraint<RESIDUAL>");
                params.set<NonlinearVariableName>("variable") =
                    lm_base + "_" + var + "_d" + axis[j];
                params.set<VariableName>("master_variable") = var;
                params.set<BoundaryName>("slave_boundary_name") = boundary_names[i];
                params.set<BoundaryName>("master_boundary_name") = opposite_boundary_names[i];
                params.set<SubdomainName>("slave_subdomain_name") = "slave_" + axis[i];
                params.set<SubdomainName>("master_subdomain_name") = "master_" + axis[i];
                params.set<unsigned int>("component") = j;
                params.set<bool>("periodic") = true;
                _problem->addConstraint("EqualGradientConstraint<RESIDUAL>",
                                        ct_base + "_d" + axis[j] + "_residual",
                                        params);
                _problem->addConstraint("EqualGradientConstraint<JACOBIAN>",
                                        ct_base + "_d" + axis[j] + "_jacobian",
                                        params);
              }
              break;
            }
 
            case 1: // value
            {
              InputParameters params = _factory.getValidParams("EqualValueConstraint<RESIDUAL>");
              params.set<NonlinearVariableName>("variable") = lm_base + "_" + var;
              params.set<VariableName>("master_variable") = var;
              params.set<BoundaryName>("slave_boundary_name") = boundary_names[i];
              params.set<BoundaryName>("master_boundary_name") = opposite_boundary_names[i];
              params.set<SubdomainName>("slave_subdomain_name") = "slave_" + axis[i];
              params.set<SubdomainName>("master_subdomain_name") = "master_" + axis[i];
              params.set<bool>("periodic") = true;
              _problem->addConstraint(
                  "EqualValueConstraint<RESIDUAL>", ct_base + "_residual", params);
              _problem->addConstraint(
                  "EqualValueConstraint<JACOBIAN>", ct_base + "_jacobian", params);
 
              break;
            }
 
            default:
              mooseError("Periodicity type not implemented");
          }
        }
      }
    }
  }
}

Member Data Documentation

_periodic_directions

const MultiMooseEnum MortarPeriodicAction::_periodic_directions

protected

Definition at line 37 of file MortarPeriodicAction.h.

Referenced by act().

_periodicity

const unsigned int MortarPeriodicAction::_periodicity

protected

Definition at line 34 of file MortarPeriodicAction.h.

Referenced by act().

_variables

std::vector<VariableName> MortarPeriodicAction::_variables

protected

Definition at line 31 of file MortarPeriodicAction.h.

Referenced by act().

---

The documentation for this class was generated from the following files:

• phase_field/include/action/MortarPeriodicAction.h
• phase_field/src/action/MortarPeriodicAction.C