QuasiStaticSolidMechanicsPhysics.h

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
 
#pragma once
 
#include "QuasiStaticSolidMechanicsPhysicsBase.h"
#include "libmesh/point.h"
 
class QuasiStaticSolidMechanicsPhysics : public QuasiStaticSolidMechanicsPhysicsBase
{
public:
  static InputParameters validParams();
 
  QuasiStaticSolidMechanicsPhysics(const InputParameters & params);
 
  virtual void act();
 
protected:
  void actSubdomainChecks();
  void actOutputGeneration();
  void actEigenstrainNames();
  void actOutputMatProp();
  void actGatherActionParameters();
  void verifyOrderAndFamilyOutputs();
  void actLagrangianKernelStrain();
  void actStressDivergenceTensorsStrain();
 
  virtual std::string getKernelType();
  virtual InputParameters getKernelParameters(std::string type);
 
  std::string remapCompatOutputProp(const std::string & prop_name) const;
 
  template <typename T, typename T2>
  bool setupOutput(std::string out, T table, T2 setup);
 
  std::vector<VariableName> _displacements;
 
  unsigned int _ndisp;
 
  std::vector<VariableName> _coupled_displacements;
 
  std::vector<AuxVariableName> _save_in;
  std::vector<AuxVariableName> _diag_save_in;
 
  Moose::CoordinateSystemType _coord_system;
 
  std::vector<SubdomainName> _subdomain_names;
 
  std::set<SubdomainID> _subdomain_ids;
 
  std::set<SubdomainID> _subdomain_id_union;
 
  enum class Strain
  {
    Small,
    Finite
  } _strain;
 
  enum class StrainAndIncrement
  {
    SmallTotal,
    FiniteTotal,
    SmallIncremental,
    FiniteIncremental
  } _strain_and_increment;
 
  enum class PlanarFormulation
  {
    None,
    WeakPlaneStress,
    PlaneStrain,
    GeneralizedPlaneStrain,
  } _planar_formulation;
 
  enum class OutOfPlaneDirection
  {
    x,
    y,
    z
  };
 
  const OutOfPlaneDirection _out_of_plane_direction;
 
  const std::string _base_name;
 
  bool _use_displaced_mesh;
 
  std::vector<std::string> _generate_output;
  MultiMooseEnum _material_output_order;
  MultiMooseEnum _material_output_family;
 
  bool _cylindrical_axis_point1_valid;
  bool _cylindrical_axis_point2_valid;
  bool _direction_valid;
  bool _verbose;
 
  Point _cylindrical_axis_point1;
  Point _cylindrical_axis_point2;
  Point _direction;
 
  bool _spherical_center_point_valid;
 
  Point _spherical_center_point;
 
  const bool _auto_eigenstrain;
 
  std::vector<MaterialPropertyName> _eigenstrain_names;
 
  const bool _compatibility_mode;
 
  const bool _lagrangian_kernels;
 
  const bool _lk_large_kinematics;
 
  enum class LKFormulation
  {
    Total,
    Updated
  };
  const LKFormulation _lk_formulation;
 
  const bool _lk_locking;
 
  bool _lk_homogenization;
 
  // Helper to translate into MOOSE talk
  static const std::map<unsigned int, std::string> _order_mapper;
  // Name of the homogenization scalar variable
  const std::string _hname = "hvar";
  // Name of the integrator
  const std::string _integrator_name = "integrator";
  // Name of the homogenization strain
  const std::string _homogenization_strain_name = "homogenization_gradient";
  // Other homogenization info
  MultiMooseEnum _constraint_types;
  std::vector<FunctionName> _targets;
  const bool _lk_h_off_jac;
};
 
template <typename T, typename T2>
bool
QuasiStaticSolidMechanicsPhysics::setupOutput(std::string out, T table, T2 setup)
{
  for (const auto & t1 : table)
  {
    // find the officially supported properties
    for (const auto & t2 : t1.second.second)
      if (t1.first + '_' + t2 == out)
      {
        const auto it = _rank_two_cartesian_component_table.find(t2);
        if (it != _rank_two_cartesian_component_table.end())
        {
          setup(it->second, t1.second.first);
          return true;
        }
        else
          mooseError("Internal error. The permitted tensor shortcuts must be keys in the "
                     "'_rank_two_cartesian_component_table'.");
      }
 
    // check for custom properties
    auto prefix = t1.first + '_';
    if (out.substr(0, prefix.length()) == prefix)
    {
      setup(out.substr(prefix.length()), t1.second.first);
      return true;
    }
  }
 
  return false;
}