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;
}