QuasiStaticSolidMechanicsPhysicsBase.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
 
#include "QuasiStaticSolidMechanicsPhysicsBase.h"
#include "CommonSolidMechanicsAction.h"
#include "ActionWarehouse.h"
#include "AddAuxVariableAction.h"
#include "ComputeFiniteStrain.h"
#include "MooseApp.h"
#include "InputParameterWarehouse.h"
 
// map tensor name shortcuts to tensor material property names
std::map<std::string, std::string>
    QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cartesian_component_table = {
        {"strain", "total_strain"},
        {"mechanical_strain", "mechanical_strain"},
        {"stress", "stress"},
        {"cauchy_stress", "cauchy_stress"},
        {"deformation_gradient", "deformation_gradient"},
        {"pk1_stress", "pk1_stress"},
        {"pk2_stress", "pk2_stress"},
        {"small_stress", "small_stress"},
        {"elastic_strain", "elastic_strain"},
        {"plastic_strain", "plastic_strain"},
        {"creep_strain", "creep_strain"},
        {"creep_stress", "creep_stress"}};
const std::vector<char> QuasiStaticSolidMechanicsPhysicsBase::_component_table = {'x', 'y', 'z'};
 
// map aux variable name prefixes to RankTwoInvariant option and list of permitted tensor name
// shortcuts
const std::map<std::string, std::pair<std::string, std::vector<std::string>>>
    QuasiStaticSolidMechanicsPhysicsBase::_rank_two_invariant_table = {
        {"vonmises", {"VonMisesStress", {"stress", "cauchy_stress", "pk1_stress", "pk2_stress"}}},
        {"effective", {"EffectiveStrain", {"plastic_strain", "creep_strain"}}},
        {"hydrostatic",
         {"Hydrostatic", {"stress", "cauchy_stress", "pk1_stress", "pk2_stress", "small_stress"}}},
        {"l2norm",
         {"L2norm",
          {"mechanical_strain",
           "stress",
           "cauchy_stress",
           "pk1_stress",
           "strain",
           "elastic_strain",
           "plastic_strain",
           "creep_strain"}}},
        {"volumetric", {"VolumetricStrain", {"mechanical_strain", "strain"}}},
        {"firstinv",
         {"FirstInvariant",
          {"stress", "cauchy_stress", "pk1_stress", "pk2_stress", "small_stress", "strain"}}},
        {"secondinv",
         {"SecondInvariant",
          {"stress", "cauchy_stress", "pk1_stress", "pk2_stress", "small_stress", "strain"}}},
        {"thirdinv",
         {"ThirdInvariant",
          {"stress", "cauchy_stress", "pk1_stress", "pk2_stress", "small_stress", "strain"}}},
        {"triaxiality",
         {"TriaxialityStress",
          {
              "stress",
              "cauchy_stress",
              "pk1_stress",
              "pk2_stress",
              "small_stress",
          }}},
        {"maxshear",
         {"MaxShear",
          {
              "stress",
              "cauchy_stress",
              "pk1_stress",
              "pk2_stress",
              "small_stress",
          }}},
        {"intensity",
         {"StressIntensity",
          {
              "stress",
              "cauchy_stress",
              "pk1_stress",
              "pk2_stress",
              "small_stress",
          }}},
        {"max_principal",
         {"MaxPrincipal",
          {"mechanical_strain",
           "stress",
           "cauchy_stress",
           "pk1_stress",
           "pk2_stress",
           "small_stress",
           "strain"}}},
        {"mid_principal",
         {"MidPrincipal",
          {"mechanical_strain",
           "stress",
           "cauchy_stress",
           "pk1_stress",
           "pk2_stress",
           "small_stress",
           "strain"}}},
        {"min_principal",
         {"MinPrincipal",
          {"mechanical_strain",
           "stress",
           "cauchy_stress",
           "pk1_stress",
           "pk2_stress",
           "small_stress",
           "strain"}}}};
 
const std::map<std::string, std::pair<std::string, std::vector<std::string>>>
    QuasiStaticSolidMechanicsPhysicsBase::_rank_two_directional_component_table = {
        {"directional", {"Direction", {"stress", "strain"}}}};
 
const std::map<std::string, std::pair<std::string, std::vector<std::string>>>
    QuasiStaticSolidMechanicsPhysicsBase::_rank_two_cylindrical_component_table = {
        {"axial",
         {"AxialStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
        {"hoop",
         {"HoopStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
        {"radial", {"RadialStress", {"stress", "strain"}}}};
 
const std::map<std::string, std::pair<std::string, std::vector<std::string>>>
    QuasiStaticSolidMechanicsPhysicsBase::_rank_two_spherical_component_table = {
        {"spherical_hoop",
         {"HoopStress", {"stress", "strain", "plastic_strain", "creep_strain", "elastic_strain"}}},
        {"spherical_radial", {"RadialStress", {"stress", "strain"}}}};
 
InputParameters
QuasiStaticSolidMechanicsPhysicsBase::validParams()
{
  InputParameters params = Action::validParams();
 
  params.addRequiredParam<std::vector<VariableName>>(
      "displacements", "The nonlinear displacement variables for the problem");
  params.addParam<std::vector<VariableName>>("temperature", "The temperature");
 
  MooseEnum strainType("SMALL FINITE", "SMALL");
  params.addParam<MooseEnum>("strain", strainType, "Strain formulation");
  params.addParam<bool>("incremental",
                        "Use incremental or total strain (if not explicitly specified this "
                        "defaults to incremental for finite strain and total for small strain)");
 
  params.addParam<std::string>("base_name", "Material property base name");
  params.addParam<bool>(
      "volumetric_locking_correction", false, "Flag to correct volumetric locking");
  params.addParam<bool>(
      "use_finite_deform_jacobian", false, "Jacobian for corrotational finite strain");
  params.addParam<bool>("add_variables", false, "Add the displacement variables");
  params.addParam<std::vector<MaterialPropertyName>>(
      "eigenstrain_names", {}, "List of eigenstrains to be applied in this strain calculation");
  params.addParam<bool>("use_automatic_differentiation",
                        false,
                        "Flag to use automatic differentiation (AD) objects when possible");
  // Global Strain
  params.addParam<MaterialPropertyName>(
      "global_strain",
      "Name of the global strain material to be applied in this strain calculation. "
      "The global strain tensor is constant over the whole domain and allows visualization "
      "of the deformed shape with the periodic BC");
 
  // Advanced
  params.addParam<std::vector<AuxVariableName>>("save_in", {}, "The displacement residuals");
  params.addParam<std::vector<AuxVariableName>>(
      "diag_save_in", {}, "The displacement diagonal preconditioner terms");
  params.addParam<MooseEnum>("decomposition_method",
                             ComputeFiniteStrain::decompositionType(),
                             "Methods to calculate the finite strain and rotation increments");
  params.addParamNamesToGroup("save_in diag_save_in", "Advanced");
 
  // Planar Formulation
  MooseEnum planarFormulationType("NONE WEAK_PLANE_STRESS PLANE_STRAIN GENERALIZED_PLANE_STRAIN",
                                  "NONE");
  params.addParam<MooseEnum>(
      "planar_formulation", planarFormulationType, "Out-of-plane stress/strain formulation");
  params.addParam<VariableName>("scalar_out_of_plane_strain",
                                "Scalar variable for the out-of-plane strain (in y "
                                "direction for 1D Axisymmetric or in z direction for 2D "
                                "Cartesian problems)");
  params.addParam<VariableName>("out_of_plane_strain",
                                "Variable for the out-of-plane strain for plane stress models");
  MooseEnum outOfPlaneDirection("x y z", "z");
  params.addParam<MooseEnum>(
      "out_of_plane_direction", outOfPlaneDirection, "The direction of the out-of-plane strain.");
  params.addDeprecatedParam<FunctionName>(
      "out_of_plane_pressure",
      "Function used to prescribe pressure (applied toward the body) in the out-of-plane direction "
      "(y for 1D Axisymmetric or z for 2D Cartesian problems)",
      "This has been replaced by 'out_of_plane_pressure_function'");
  params.addParam<FunctionName>(
      "out_of_plane_pressure_function",
      "Function used to prescribe pressure (applied toward the body) in the out-of-plane direction "
      "(y for 1D Axisymmetric or z for 2D Cartesian problems)");
  params.addParam<Real>(
      "pressure_factor",
      "Scale factor applied to prescribed out-of-plane pressure (both material and function)");
  params.addParam<MaterialPropertyName>("out_of_plane_pressure_material",
                                        "0",
                                        "Material used to prescribe pressure (applied toward the "
                                        "body) in the out-of-plane direction");
  params.addParamNamesToGroup("planar_formulation scalar_out_of_plane_strain out_of_plane_pressure "
                              "out_of_plane_pressure_material out_of_plane_pressure_function "
                              "pressure_factor out_of_plane_direction out_of_plane_strain",
                              "Out-of-plane stress/strain");
 
  // Output
  params.addParam<MultiMooseEnum>("generate_output",
                                  QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType(),
                                  "Add scalar quantity output for stress and/or strain");
 
  params.addParam<MultiMooseEnum>(
      "material_output_order",
      QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders(),
      "Specifies the order of the FE shape function to use for this variable.");
 
  params.addParam<MultiMooseEnum>(
      "material_output_family",
      QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies(),
      "Specifies the family of FE shape functions to use for this variable.");
  params.addParamNamesToGroup("generate_output material_output_order material_output_family",
                              "Output");
  params.addParam<bool>("verbose", false, "Display extra information.");
 
  params.addParam<bool>("new_system",
                        false,
                        "If true use the new "
                        "LagrangianStressDiverence kernels.");
 
  params.addParam<bool>(
      "compatibility_mode",
      false,
      "If true, configure the Lagrangian kernel system to reproduce the OLD "
      "(StressDivergenceTensors + ComputeFiniteStrain) results bit-for-bit when wrapping an "
      "old-style ComputeStressBase material like ComputeMultiPlasticityStress. Implies "
      "`new_system = true` and `formulation = TOTAL`; auto-adds ComputeLagrangianWrappedStress "
      "around the user-supplied stress material; sets `kinematic_approximation` from "
      "`decomposition_method`; sets `F_bar_mode = incremental` when "
      "`volumetric_locking_correction = true`; redirects `stress` / `mechanical_strain` output "
      "requests to the equivalent NEW-system properties (`cauchy_stress` / "
      "`rotated_mechanical_strain`).");
 
  MooseEnum formulationType("TOTAL UPDATED", "TOTAL");
  params.addParam<MooseEnum>("formulation",
                             formulationType,
                             "Select between the total Lagrangian (TOTAL) "
                             "and updated Lagrangian (UPDATED) formulations "
                             "for the new kernel system.");
 
  MooseEnum kinematicApproximation("linear quadratic rashid_approximate rashid_eigen", "linear");
  params.addParam<MooseEnum>(
      "kinematic_approximation",
      kinematicApproximation,
      "Approximation used by the Lagrangian strain calculator to convert the incremental "
      "deformation gradient into the strain and vorticity increments (large deformation only).");
 
  params.addRangeCheckedParam<Real>(
      "generalized_midpoint_alpha",
      1.0,
      "generalized_midpoint_alpha >= 0.5 & generalized_midpoint_alpha <= 1.0",
      "Generalized midpoint weight for the deformation gradient in the Lagrangian strain "
      "calculator.  1.0 = backward Euler (default), 0.5 = midpoint rule.");
 
  MooseEnum volumetricLockingCorrectionMode("total incremental", "total");
  params.addParam<MooseEnum>(
      "volumetric_locking_correction_mode",
      volumetricLockingCorrectionMode,
      "Volumetric part averaged by the F-bar volumetric locking correction in the Lagrangian "
      "strain calculator: the total (default) or incremental deformation gradient.");
 
  params.addParamNamesToGroup("add_variables displacements temperature", "Variables");
  params.addParamNamesToGroup("strain incremental use_finite_deform_jacobian eigenstrain_names "
                              "volumetric_locking_correction kinematic_approximation "
                              "generalized_midpoint_alpha volumetric_locking_correction_mode",
                              "Strain");
  params.addParamNamesToGroup("new_system compatibility_mode formulation",
                              "Lagrangian formulation");
 
  return params;
}
 
QuasiStaticSolidMechanicsPhysicsBase::QuasiStaticSolidMechanicsPhysicsBase(
    const InputParameters & parameters)
  : Action(parameters), _use_ad(getParam<bool>("use_automatic_differentiation"))
{
  const auto & params = _app.getInputParameterWarehouse().getInputParameters();
  InputParameters & pars(*(params.find(uniqueActionName())->second.get()));
 
  // check if a container block with common parameters is found
  auto action = _awh.getActions<CommonSolidMechanicsAction>();
  if (action.size() == 1)
    pars.applyParameters(action[0]->parameters());
 
  // append additional_generate_output
  if (isParamValid("additional_generate_output"))
  {
    MultiMooseEnum generate_output = getParam<MultiMooseEnum>("generate_output");
    MultiMooseEnum additional_generate_output =
        getParam<MultiMooseEnum>("additional_generate_output");
 
    MultiMooseEnum material_output_order = getParam<MultiMooseEnum>("material_output_order");
    MultiMooseEnum additional_material_output_order =
        getParam<MultiMooseEnum>("additional_material_output_order");
 
    MultiMooseEnum material_output_family = getParam<MultiMooseEnum>("material_output_family");
    MultiMooseEnum additional_material_output_family =
        getParam<MultiMooseEnum>("additional_material_output_family");
 
    for (auto & output : additional_generate_output)
      generate_output.setAdditionalValue(output);
    for (auto & order : additional_material_output_order)
      material_output_order.setAdditionalValue(order);
    for (auto & family : additional_material_output_family)
      material_output_family.setAdditionalValue(family);
 
    pars.set<MultiMooseEnum>("generate_output") = generate_output;
    pars.set<MultiMooseEnum>("material_output_order") = material_output_order;
    pars.set<MultiMooseEnum>("material_output_family") = material_output_family;
  }
}
 
MultiMooseEnum
QuasiStaticSolidMechanicsPhysicsBase::materialOutputOrders()
{
  auto orders = AddAuxVariableAction::getAuxVariableOrders().getRawNames();
 
  return MultiMooseEnum(orders);
}
 
MultiMooseEnum
QuasiStaticSolidMechanicsPhysicsBase::materialOutputFamilies()
{
  return MultiMooseEnum("MONOMIAL LAGRANGE");
}
 
MultiMooseEnum
QuasiStaticSolidMechanicsPhysicsBase::outputPropertiesType()
{
  std::string options = "";
  for (auto & r2tc : _rank_two_cartesian_component_table)
    for (unsigned int a = 0; a < 3; ++a)
      for (unsigned int b = 0; b < 3; ++b)
        options += (options == "" ? "" : " ") + r2tc.first + '_' + _component_table[a] +
                   _component_table[b];
 
  for (auto & r2i : _rank_two_invariant_table)
    for (auto & t : r2i.second.second)
      options += " " + r2i.first + "_" + t;
 
  for (auto & r2sdc : _rank_two_directional_component_table)
    for (auto & r : r2sdc.second.second)
      options += " " + r2sdc.first + "_" + r;
 
  for (auto & r2cc : _rank_two_cylindrical_component_table)
    for (auto & r : r2cc.second.second)
      options += " " + r2cc.first + "_" + r;
 
  for (auto & r2sc : _rank_two_spherical_component_table)
    for (auto & r : r2sc.second.second)
      options += " " + r2sc.first + "_" + r;
 
  return MultiMooseEnum(options, "", true);
}
 
void
QuasiStaticSolidMechanicsPhysicsBase::addCartesianComponentOutput(const std::string & enum_name,
                                                                  const std::string & prop_name)
{
  if (prop_name.empty())
    // the enum name is the actual tensor material property name
    _rank_two_cartesian_component_table.emplace(enum_name, enum_name);
  else
    // supply a different name for the enum options (this is done for
    // 'strain' -> 'mechanical_strain' in the TMA)
    _rank_two_cartesian_component_table.emplace(enum_name, prop_name);
}