#include "users_modules/eshelbian_plasticity/src/EshelbianPlasticity.hpp"

Inheritance diagram for EshelbianPlasticity::PhysicalEquations:

Collaboration diagram for EshelbianPlasticity::PhysicalEquations:

Classes
struct	FieldDefinition

Public Types
enum	MaterialModel { StVenantKirchhoff , MooneyRivlin , Hencky , Neohookean , Meta , LastMaterial }

enum	Feature { DIRECT_STRETCH = 0 , NO_STRETCH_LINEAR , NO_STRETCH_NONLINEAR , AUXILIARY_LOGARITHMIC_STRESS , NON_HOMOGENEOUS_MATERIAL , LAST_FEATURE }

enum	FieldState { CURRENT , PREVIOUS }

using	Features = std::bitset< LAST_FEATURE >

Public Member Functions
	PhysicalEquations (MaterialModel model, Features features)

virtual	~PhysicalEquations ()=default

MoFEMErrorCode	checkSetup (const EshelbianCore &ep) const
	Check material capabilities after geometry and boundary setup.

MaterialModel	getMaterialModel () const

const Features &	getFeatures () const

std::vector< FieldDefinition >	getMaterialFieldDefinitions (const EshelbianCore &ep) const

std::vector< std::string >	getMaterialFields (const EshelbianCore &ep) const
	Active material unknowns used by the element, DMs and field split.

std::vector< std::pair< std::string, std::string > >	getMaterialCouplings (const EshelbianCore &ep) const
	Material-dependent blocks; each pair also represents its transpose.

std::vector< std::pair< std::string, std::string > >	getMaterialEmptyBlocks (const EshelbianCore &ep) const

MoFEMErrorCode	pushMaterialFields (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, FieldState state=CURRENT)
	Evaluate the selected fields, or recover stretch from the matching stress.

MoFEMErrorCode	pushMaterialRates (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr)

MoFEMErrorCode	pushMaterialEvaluation (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, bool rhs, bool lhs)
	Evaluate constitutive data after kinematics and before material assembly.

virtual MoFEMErrorCode	pushHelmholtzStateGradient (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
	Assemble the physical Helmholtz state derivative at equilibrium.

MoFEMErrorCode	pushStretchFromStress (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< MatrixDouble > strain_ptr=nullptr, boost::shared_ptr< MatrixDouble > stress_ptr=nullptr)

MoFEMErrorCode	pushMaterialResidual (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr)

MoFEMErrorCode	pushMaterialTangent (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr)

MoFEMErrorCode	pushEnergyEvaluation (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< double > total_energy_ptr)

MoFEMErrorCode	pushMaterialForceFields (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr)

MoFEMErrorCode	pushPostProc (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, MaterialPostProcData &output)

MoFEMErrorCode	pushMaterialVariation (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, SmartPetscObj< Vec > variation, MaterialPostProcData *output=nullptr)

MoFEMErrorCode	pushPostProcResidual (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, SmartPetscObj< Vec > residual, MaterialPostProcData &output)

MoFEMErrorCode	pushSkeletonEvaluation (const EshelbianCore &ep, VolumeElementForcesAndSourcesCoreOnSide &fe, boost::shared_ptr< DataAtIntegrationPts > data_ptr, SmartPetscObj< Vec > residual, MaterialPostProcData &output)

virtual MoFEMErrorCode	pushAuxiliaryLogarithmicStressOps (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, bool lhs)
	Assemble the selected material field group after kinematic reconstruction.

virtual MoFEMErrorCode	pushAuxiliaryLogarithmicMaterialEvaluation (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, bool lhs=false)
	Evaluate the auxiliary material copy and energies without assembly.

virtual UserDataOperator *	returnOpJacobian (const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr)

virtual VolUserDataOperator *	returnOpSpatialPhysical (const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha_u)

virtual VolUserDataOperator *	returnOpSpatialPhysicalExternalStrain (const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< ExternalStrainVec > external_strain_vec_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv)

virtual VolUserDataOperator *	returnOpSpatialPhysical_du_du (std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha)

virtual VolUserDataOperator *	returnOpTopoSpatialPhysical (const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, SmartPetscObj< Vec > assemble_vec, boost::shared_ptr< TopologicalData > topo_ptr, const double alpha_u, boost::shared_ptr< double > J_ptr)

virtual VolUserDataOperator *	returnOpCalculateHelmholtzFreeEnergy (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< double > total_helmholtz_free_energy_ptr)

virtual bool	providesHelmholtzFreeEnergy () const

virtual VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr, boost::shared_ptr< MatrixDouble > strain_ptr=nullptr)

virtual VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr, boost::shared_ptr< MatrixDouble > strain_ptr, VectorPtr external_pressure_ptr)

virtual VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr, boost::shared_ptr< MatrixDouble > strain_ptr, boost::shared_ptr< MatrixDouble > stress_ptr, VectorPtr external_pressure_ptr)

virtual VolUserDataOperator *	returnOpCalculateExternalPressure (VectorPtr external_pressure_ptr, boost::shared_ptr< ExternalStrainVec > external_strain_vec_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv)

virtual VolUserDataOperator *	returnOpCalculateVarStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr)

Static Public Member Functions
static MoFEMErrorCode	create (EshelbianCore &ep)
	Select and configure the material before registering fields and DMs.

Static Public Attributes
static const Features	noStretchMask

Protected Attributes
Features	materialFeatures

Private Member Functions
bool	usesStressBasedStrain () const

Static Private Member Functions
static MoFEMErrorCode	checkOptions (const EshelbianCore &ep, MaterialModel material_model, Features features)

Private Attributes
MaterialModel	materialModel

Detailed Description

Definition at line 710 of file EshelbianPlasticity.hpp.

Member Typedef Documentation

◆ Features

using EshelbianPlasticity::PhysicalEquations::Features = std::bitset<LAST_FEATURE>

Definition at line 731 of file EshelbianPlasticity.hpp.

Member Enumeration Documentation

◆ Feature

enum EshelbianPlasticity::PhysicalEquations::Feature

Enumerator
DIRECT_STRETCH	Direct stretch formulation.
NO_STRETCH_LINEAR	No-stretch linear formulation.
NO_STRETCH_NONLINEAR	No-stretch nonlinear formulation.
AUXILIARY_LOGARITHMIC_STRESS	Auxiliary logarithmic stress formulation.
NON_HOMOGENEOUS_MATERIAL
LAST_FEATURE

Definition at line 722 of file EshelbianPlasticity.hpp.

               {
    DIRECT_STRETCH = 0,           ///< Direct stretch formulation
    NO_STRETCH_LINEAR,            ///< No-stretch linear formulation
    NO_STRETCH_NONLINEAR,         ///< No-stretch nonlinear formulation
    AUXILIARY_LOGARITHMIC_STRESS, ///< Auxiliary logarithmic stress formulation
    NON_HOMOGENEOUS_MATERIAL,
    LAST_FEATURE
  };

◆ FieldState

enum EshelbianPlasticity::PhysicalEquations::FieldState

Enumerator
CURRENT	Current state of the field.
PREVIOUS	Previous state of the field.

Definition at line 735 of file EshelbianPlasticity.hpp.

                  {
    CURRENT, ///< Current state of the field
    PREVIOUS ///< Previous state of the field
  };

◆ MaterialModel

enum EshelbianPlasticity::PhysicalEquations::MaterialModel

Enumerator
StVenantKirchhoff
MooneyRivlin
Hencky
Neohookean
Meta
LastMaterial

Definition at line 712 of file EshelbianPlasticity.hpp.

                     {
    StVenantKirchhoff,
    MooneyRivlin,
    Hencky,
    Neohookean,
    Meta, //< Metamaterial model, that is using off the shelf MatOps
          // functionality
    LastMaterial
  };

Constructor & Destructor Documentation

◆ PhysicalEquations()

EshelbianPlasticity::PhysicalEquations::PhysicalEquations	(	MaterialModel	model,
		Features	features
	)

inline

Definition at line 740 of file EshelbianPlasticity.hpp.

741 : materialModel(model), materialFeatures(features) {}

features

const char features[]

Definition feature_tests.c:2

EshelbianPlasticity::PhysicalEquations::materialModel

MaterialModel materialModel

Definition EshelbianPlasticity.hpp:926

EshelbianPlasticity::PhysicalEquations::materialFeatures

Features materialFeatures

Definition EshelbianPlasticity.hpp:929

◆ ~PhysicalEquations()

virtual EshelbianPlasticity::PhysicalEquations::~PhysicalEquations ( )

virtualdefault

Member Function Documentation

◆ checkOptions()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::checkOptions	(	const EshelbianCore &	ep,
		MaterialModel	material_model,
		Features	features
	)

staticprivate

Definition at line 101 of file EshelbianMat.cpp.

                                                         {
  MoFEMFunctionBegin;
  if (!features.test(AUXILIARY_LOGARITHMIC_STRESS))
    MoFEMFunctionReturnHot(0);
 
  double alpha_grad_u = 0;
  CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, PETSC_NULLPTR,
                               "-neo_hookean_viscosity_alpha_grad_u",
                               &alpha_grad_u, PETSC_NULLPTR);
  PetscBool h1_update = ep.physicalH1Update;
  CHKERR PetscOptionsGetBool(PETSC_NULLPTR, PETSC_NULLPTR,
                             "-physical_h1_update", &h1_update, PETSC_NULLPTR);
  const bool plastic_solver =
      ep.plasticVolume &&
      (ep.solverType == EshelbianCore::IncrementalOptimization ||
       ep.solverType == EshelbianCore::TestEquilibratedMechanicalValue ||
       ep.solverType == EshelbianCore::TestIncrementalOptimizationLayout ||
       ep.solverType == EshelbianCore::TestIncrementalOptimizationTransaction ||
       ep.solverType ==
           EshelbianCore::TestIncrementalOptimizationObjectiveDerivative ||
       ep.solverType ==
           EshelbianCore::TestIncrementalOptimizationConstraintDerivative);
  const std::pair<bool, const char *> unsupported[] = {
      {material_model != Neohookean, "requires -material neo_hookean"},
      {ep.stretchSelector != LOG, "requires -stretches log"},
      {ep.rotSelector != LARGE_ROT, "requires -rotations large"},
      {ep.symmetrySelector != SYMMETRIC,
       "requires the symmetric row convention"},
      {ep.gradApproximator != NO_H1_CONFIGURATION, "requires -grad no_h1"},
      {alpha_grad_u != 0,
       "requires zero -neo_hookean_viscosity_alpha_grad_u"},
      {!plastic_solver &&
           (ep.solverType != EshelbianCore::TimeSolver || ep.physicalTimeFlg),
       "requires time_solver without dynamic relaxation or plastic "
       "incremental optimization"},
      {h1_update == PETSC_TRUE, "does not yet support -physical_h1_update"},
      {ep.crackingOn || ep.interfaceCrack,
       "does not yet support -cracking_on or -cohesive_interface_on"},
      {!ep.internalStressTagName.empty(),
       "does not yet support internal stress"},
      {ep.meshTransferSourceMeshFileSpecified == PETSC_TRUE,
       "does not yet support material mesh transfer"}};
  for (const auto &[invalid, reason] : unsupported) {
    if (invalid)
      SETERRQ(ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
              "-auxiliary_logarithmic_stress %s", reason);
  }
 
  MoFEMFunctionReturn(0);
}

◆ checkSetup()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::checkSetup ( const EshelbianCore & ep ) const

Check material capabilities after geometry and boundary setup.

Definition at line 154 of file EshelbianMat.cpp.

                                                                          {
  MoFEMFunctionBegin;
  if (!getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS))
    MoFEMFunctionReturnHot(0);
 
  Range sdf_contact_faces;
  for (const auto &block :
       ep.mField.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(
           std::regex("CONTACT_SDF(.*)"))) {
    CHKERR block->getMeshsetIdEntitiesByDimension(
        ep.mField.get_moab(), SPACE_DIM - 1, sdf_contact_faces, true);
  }
  const auto nonempty = [](const auto &ptr) { return ptr && !ptr->empty(); };
  const std::pair<bool, const char *> unsupported_data[] = {
      {nonempty(ep.externalStrainVecPtr), "external strain prescriptions"},
      {nonempty(ep.bcSpatialPressureVecPtr), "follower pressure loads"},
      {nonempty(ep.contactFaces) || !sdf_contact_faces.empty(),
       "contact meshsets"},
      {nonempty(ep.frontEdges) || nonempty(ep.crackFaces) ||
           nonempty(ep.interfaceFaces),
       "front, crack or interface meshsets"}};
  for (const auto &[local_active, capability] : unsupported_data) {
    int active = local_active;
    CHKERR MPI_Allreduce(MPI_IN_PLACE, &active, 1, MPI_INT, MPI_MAX,
                         ep.mField.get_comm());
    if (active)
      SETERRQ(ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
              "-auxiliary_logarithmic_stress does not yet support %s",
              capability);
  }
 
  MoFEMFunctionReturn(0);
}

◆ create()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::create ( EshelbianCore & ep )

static

Select and configure the material before registering fields and DMs.

Definition at line 664 of file EshelbianMat.cpp.

                                                          {
  MoFEMFunctionBegin;
  const char *list_materials[] = {"stvenant_kirchhoff", "mooney_rivlin",
                                  "hencky", "neo_hookean", "meta"};
  PetscInt choice_material = MooneyRivlin;
  PetscBool no_stretch = PETSC_FALSE;
  PetscBool auxiliary_logarithmic_stress = PETSC_FALSE;
  PetscOptionsBegin(ep.mField.get_comm(), "", "Material physical equations",
                    "none");
  CHKERR PetscOptionsEList("-material", "material model", "", list_materials,
                           LastMaterial, list_materials[choice_material],
                           &choice_material, PETSC_NULLPTR);
  CHKERR PetscOptionsBool("-no_stretch", "do not solve for stretch", "",
                          no_stretch, &no_stretch, PETSC_NULLPTR);
  CHKERR PetscOptionsBool(
      "-auxiliary_logarithmic_stress",
      "independent logarithmic deviator, volume and auxiliary stress", "",
      PETSC_FALSE, &auxiliary_logarithmic_stress, PETSC_NULLPTR);
  PetscOptionsEnd();
 
  const auto material_model = static_cast<MaterialModel>(choice_material);
  if (auxiliary_logarithmic_stress && no_stretch &&
      material_model == Neohookean)
    SETERRQ(
        ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
        "-auxiliary_logarithmic_stress cannot be combined with -no_stretch");
  Features features;
  features.set(auxiliary_logarithmic_stress
                   ? AUXILIARY_LOGARITHMIC_STRESS
                   : (no_stretch ? NO_STRETCH_LINEAR : DIRECT_STRETCH));
  CHKERR checkOptions(ep, material_model, features);
  if (!ep.dataAtPts)
    ep.dataAtPts = boost::make_shared<DataAtIntegrationPts>();
  const std::map<std::string, std::string> material_model_names_dictionary = {
      {"grad", "stretchH1AtPts"}, {"P", "PAtPts"}, {"P_dF", "PAtPts_du"}};
  MatOps::MatPiolaResponse::useDeformationGradient = true;
  boost::shared_ptr<MatOps::PhysicalEquations> mat_physical_equations_ptr;
 
  switch (material_model) {
  case StVenantKirchhoff:
    MOFEM_LOG("EP", Sev::inform) << "St. Venant-Kirchhoff material model";
    mat_physical_equations_ptr = MatOps::createMatOpsPhysicalEquationsPtr<
        MatOps::ELASTICITY::STVENANTKIRCHHOFF, MatOps::MODEL_3D>(
        MatOps::createMatOpsDataPtr(ep.dataAtPts->matOpsData,
                                    material_model_names_dictionary),
        MatOps::MatOpsTagsRegistry::setTagName("StVenantKirchhoff", 0));
    break;
  case MooneyRivlin:
    MOFEM_LOG("EP", Sev::inform) << "Mooney-Rivlin material model";
    mat_physical_equations_ptr = MatOps::createMatOpsPhysicalEquationsPtr<
        MatOps::ELASTICITY::MOONEYRIVLINWRIGGERSEQ63, MatOps::MODEL_3D>(
        MatOps::createMatOpsDataPtr(ep.dataAtPts->matOpsData,
                                    material_model_names_dictionary),
        MatOps::MatOpsTagsRegistry::setTagName("MooneyRivlinWriggersEq63", 0));
    break;
  case Hencky:
    MOFEM_LOG("EP", Sev::inform) << "Hencky material model";
    ep.physicalEquations =
        boost::make_shared<HMHHencky>(ep.mField, 5., 0.25, features);
    break;
  case Neohookean:
    MOFEM_LOG("EP", Sev::inform) << "Neo-Hookean material model";
    ep.physicalEquations =
        boost::make_shared<HMHNeohookean>(ep.mField, 1., 2., features);
    break;
  case Meta:
    MOFEM_LOG("EP", Sev::inform) << "Meta Material model";
    mat_physical_equations_ptr =
        MatOps::createMatOpsPhysicalEquationsPtr<MatOps::PIOLA_RESPONSE::META,
                                                 MatOps::MODEL_3D>(
            MatOps::createMatOpsDataPtr(ep.dataAtPts->matOpsData,
                                        material_model_names_dictionary),
            MatOps::MatOpsTagsRegistry::setTagName("MetaPiolaResponse", 0));
    break;
  default:
    SETERRQ(ep.mField.get_comm(), MOFEM_DATA_INCONSISTENCY, "Unknown material");
  }
 
  if (mat_physical_equations_ptr) {
    CHKERR mat_physical_equations_ptr->getOptions(&ep.mField);
    CHKERR mat_physical_equations_ptr->recordTape();
    if (material_model == Meta)
      ep.physicalEquations = boost::make_shared<MatPhysicalEquations>(
          boost::static_pointer_cast<MatOps::MatPiolaResponse>(
              mat_physical_equations_ptr),
          material_model, features);
    else
      ep.physicalEquations = boost::make_shared<MatElasticPhysicalEquations>(
          boost::static_pointer_cast<MatOps::MatElastic>(
              mat_physical_equations_ptr),
          material_model, features);
  }
  ep.dataAtPts->physicsPtr = ep.physicalEquations;
  MOFEM_LOG("EP", Sev::inform) << "No stretch: -no_stretch "
                               << ((ep.physicalEquations->getFeatures() &
                                    PhysicalEquations::noStretchMask)
                                           .any()
                                       ? "yes"
                                       : "no");
  MoFEMFunctionReturn(0);
}

◆ getFeatures()

const Features & EshelbianPlasticity::PhysicalEquations::getFeatures ( ) const

inline

Test individual bits or compare (getFeatures() & mask) with a feature mask.

Definition at line 753 of file EshelbianPlasticity.hpp.

753{ return materialFeatures; }

◆ getMaterialCouplings()

std::vector< std::pair< std::string, std::string > > EshelbianPlasticity::PhysicalEquations::getMaterialCouplings ( const EshelbianCore & ep ) const

Material-dependent blocks; each pair also represents its transpose.

Definition at line 60 of file EshelbianMat.cpp.

                                                                     {
  std::vector<std::pair<std::string, std::string>> blocks;
  // Eliminated stretch and the updated plastic flow direction couple P/bubble.
  if ((getFeatures() & noStretchMask).any() || ep.plasticVolume) {
    blocks.emplace_back(ep.bubbleField, ep.bubbleField);
    blocks.emplace_back(ep.bubbleField, ep.piolaStress);
  }
  for (const auto &field : getMaterialFields(ep))
    blocks.emplace_back(field, field);
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    blocks.emplace_back(ep.logDeviator, ep.logJacobian);
    blocks.emplace_back(ep.logDeviator, ep.auxiliaryLogStress);
    for (const auto &field : {ep.logDeviator, ep.logJacobian})
      for (const auto &mechanical :
           {ep.piolaStress, ep.bubbleField, ep.rotAxis})
        blocks.emplace_back(field, mechanical);
  } else if (getFeatures().test(DIRECT_STRETCH)) {
    for (const auto &field : {ep.piolaStress, ep.bubbleField, ep.rotAxis})
      blocks.emplace_back(ep.stretchTensor, field);
  }
  return blocks;
}

◆ getMaterialEmptyBlocks()

std::vector< std::pair< std::string, std::string > > EshelbianPlasticity::PhysicalEquations::getMaterialEmptyBlocks ( const EshelbianCore & ep ) const

Definition at line 84 of file EshelbianMat.cpp.

                                                                       {
  std::vector<std::pair<std::string, std::string>> blocks;
  for (const auto &field : getMaterialFields(ep))
    blocks.emplace_back(ep.spatialL2Disp, field);
  if ((getFeatures() & noStretchMask).none()) {
    blocks.emplace_back(ep.bubbleField, ep.bubbleField);
    blocks.emplace_back(ep.piolaStress, ep.piolaStress);
    blocks.emplace_back(ep.bubbleField, ep.piolaStress);
  }
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS))
    for (const auto &field :
         {ep.logJacobian, ep.piolaStress, ep.bubbleField, ep.rotAxis})
      blocks.emplace_back(ep.auxiliaryLogStress, field);
  return blocks;
}

◆ getMaterialFieldDefinitions()

std::vector< PhysicalEquations::FieldDefinition > EshelbianPlasticity::PhysicalEquations::getMaterialFieldDefinitions ( const EshelbianCore & ep ) const

USER_BASE L2 fields; negative order retains an inactive field registration.

Definition at line 26 of file EshelbianMat.cpp.

                                                                            {
  std::vector<FieldDefinition> fields;
  auto set_fields = [&]<FieldApproximationBase Base>() {
    MoFEMFunctionBegin;
    using Orders = EshelbianCore::FieldOrders<Base>;
    if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
      fields = {{ep.logDeviator, Orders::logDeviator(ep.spaceOrder), 5},
                {ep.logJacobian, Orders::logJacobian(ep.spaceOrder), 1},
                {ep.auxiliaryLogStress,
                 Orders::auxiliaryLogStress(ep.spaceOrder), 5}};
    } else {
      fields = {{ep.stretchTensor,
                 (getFeatures() & noStretchMask).any()
                     ? -1
                     : Orders::stretch(ep.spaceOrder),
                 6}};
    }
    MoFEMFunctionReturn(0);
  };
  CHK_THROW_MESSAGE(ep.withFieldOrders(set_fields),
                    "Get material field orders failed");
  return fields;
}

◆ getMaterialFields()

std::vector< std::string > EshelbianPlasticity::PhysicalEquations::getMaterialFields ( const EshelbianCore & ep ) const

Active material unknowns used by the element, DMs and field split.

Definition at line 51 of file EshelbianMat.cpp.

                                                                  {
  std::vector<std::string> fields;
  for (const auto &field : getMaterialFieldDefinitions(ep))
    if (field.order >= 0)
      fields.push_back(field.name);
  return fields;
}

◆ getMaterialModel()

MaterialModel EshelbianPlasticity::PhysicalEquations::getMaterialModel ( ) const

inline

Definition at line 750 of file EshelbianPlasticity.hpp.

750{ return materialModel; }

◆ providesHelmholtzFreeEnergy()

bool EshelbianPlasticity::PhysicalEquations::providesHelmholtzFreeEnergy ( ) const

virtual

True when the material supplies its Helmholtz free energy.

Reimplemented in EshelbianPlasticity::MatElasticPhysicalEquations, EshelbianPlasticity::HMHHencky, and EshelbianPlasticity::HMHNeohookean.

Definition at line 490 of file EshelbianMat.cpp.

490{ return false; }

◆ pushAuxiliaryLogarithmicMaterialEvaluation()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushAuxiliaryLogarithmicMaterialEvaluation	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		bool	lhs = `false`
	)

virtual

Evaluate the auxiliary material copy and energies without assembly.

Reimplemented in EshelbianPlasticity::HMHNeohookean.

Definition at line 327 of file EshelbianMat.cpp.

                                                 {
  MoFEMFunctionBegin;
  SETERRQ(ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
          "Selected material does not evaluate auxiliary logarithmic stress");
  MoFEMFunctionReturn(0);
}

◆ pushAuxiliaryLogarithmicStressOps()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushAuxiliaryLogarithmicStressOps	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		bool	lhs
	)

virtual

Assemble the selected material field group after kinematic reconstruction.

Reimplemented in EshelbianPlasticity::HMHNeohookean.

Definition at line 318 of file EshelbianMat.cpp.

                                                 {
  MoFEMFunctionBegin;
  SETERRQ(ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
          "Selected material does not implement auxiliary logarithmic stress");
  MoFEMFunctionReturn(0);
}

◆ pushEnergyEvaluation()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushEnergyEvaluation	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< double >	total_energy_ptr
	)

Definition at line 418 of file EshelbianMat.cpp.

                                              {
  MoFEMFunctionBegin;
  if (auto op =
          returnOpCalculateHelmholtzFreeEnergy(data_ptr, total_energy_ptr)) {
    // Energy uses the physical strain recovered from stress for these models.
    if (usesStressBasedStrain())
      CHKERR pushStretchFromStress(ep, pipeline, data_ptr,
                                   data_ptr->getLogStretchTotalTensorAtPts());
    pipeline.push_back(op);
  }
  MoFEMFunctionReturn(0);
}

◆ pushHelmholtzStateGradient()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushHelmholtzStateGradient	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr
	)

virtual

Assemble the physical Helmholtz state derivative at equilibrium.

Reimplemented in EshelbianPlasticity::HMHNeohookean.

Definition at line 304 of file EshelbianMat.cpp.

                                                    {
  MoFEMFunctionBegin;
  auto gradient_at_points = boost::make_shared<MatrixDouble>();
  pipeline.push_back(
      new OpCalculateHelmholtzStateGradient(data_ptr, gradient_at_points));
  using OpAssembleGradient = FormsIntegrators<VolUserDataOperator>::Assembly<
      A>::LinearForm<GAUSS>::OpBaseTimesVector<1, 6, 6>;
  pipeline.push_back(
      new OpAssembleGradient(ep.stretchTensor, gradient_at_points));
  MoFEMFunctionReturn(0);
}

◆ pushMaterialEvaluation()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushMaterialEvaluation	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		bool	rhs,
		bool	lhs
	)

Evaluate constitutive data after kinematics and before material assembly.

Definition at line 245 of file EshelbianMat.cpp.

                    {
  MoFEMFunctionBegin;
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    if (rhs || lhs)
      CHKERR pushAuxiliaryLogarithmicMaterialEvaluation(ep, pipeline, data_ptr,
                                                        lhs);
  } else if (getFeatures().test(DIRECT_STRETCH)) {
    pipeline.push_back(
        returnOpJacobian(rhs, lhs, data_ptr, ep.physicalEquations));
  }
  MoFEMFunctionReturn(0);
}

◆ pushMaterialFields()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushMaterialFields	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		FieldState	state = `CURRENT`
	)

Evaluate the selected fields, or recover stretch from the matching stress.

Definition at line 188 of file EshelbianMat.cpp.

                                                                            {
  MoFEMFunctionBegin;
  data_ptr->physicsPtr = ep.physicalEquations;
  const bool previous = state == PREVIOUS;
  auto strain_ptr = previous ? data_ptr->getLogStretchTensor0AtPts()
                             : data_ptr->getLogStretchTensorAtPts();
  auto values = previous ? ep.solTSStep : SmartPetscObj<Vec>();
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    auto &fields =
        previous ? data_ptr->auxiliaryData0 : data_ptr->auxiliaryData;
    if (!fields)
      fields = boost::make_shared<AuxiliaryLogarithmicStressData>();
    CHKERR pushAuxiliaryLogarithmicFields(ep, pipeline, fields, strain_ptr,
                                          values);
  } else if ((getFeatures() & noStretchMask).any()) {
    CHKERR pushStretchFromStress(ep, pipeline, data_ptr, strain_ptr,
                                 previous ? data_ptr->getApproxP0AtPts()
                                          : data_ptr->getApproxPAtPts());
  } else {
    pipeline.push_back(new OpCalculateTensor2SymmetricFieldValues<3>(
        ep.stretchTensor, strain_ptr, values, MBTET));
  }
  MoFEMFunctionReturn(0);
}

◆ pushMaterialForceFields()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushMaterialForceFields	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr
	)

Definition at line 434 of file EshelbianMat.cpp.

                                                    {
  MoFEMFunctionBegin;
  if (usesStressBasedStrain()) {
    CHKERR pushStretchFromStress(ep, pipeline, data_ptr);
  } else {
    // These fields represent mechanical stretch; this force evaluation does
    // not reconstruct physical strain for imposed internal stress or strain.
    CHKERR pushMaterialFields(ep, pipeline, data_ptr);
  }
  MoFEMFunctionReturn(0);
}

◆ pushMaterialRates()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushMaterialRates	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr
	)

Definition at line 215 of file EshelbianMat.cpp.

                                                    {
  MoFEMFunctionBegin;
  if (getFeatures().test(DIRECT_STRETCH)) {
    pipeline.push_back(new OpCalculateTensor2SymmetricFieldValuesDot<3>(
        ep.stretchTensor, data_ptr->getLogStretchDotTensorAtPts(), MBTET));
    pipeline.push_back(new OpCalculateVectorFieldGradientDot<6, 3>(
        ep.stretchTensor, data_ptr->getGradLogStretchDotTensorAtPts(), MBTET));
  }
  MoFEMFunctionReturn(0);
}

◆ pushMaterialResidual()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushMaterialResidual	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr
	)

Definition at line 336 of file EshelbianMat.cpp.

                                                    {
  MoFEMFunctionBegin;
  if ((getFeatures() & noStretchMask).any())
    MoFEMFunctionReturnHot(0);
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    CHKERR pushAuxiliaryLogarithmicStressOps(ep, pipeline, data_ptr, false);
    MoFEMFunctionReturnHot(0);
  }
 
  if (!ep.internalStressTagName.empty()) {
    switch (ep.meshTransferInterpOrder) {
    case 0:
      pipeline.push_back(
          new OpGetInternalStress<0>(data_ptr, ep.internalStressTagName));
      break;
    case 1:
      pipeline.push_back(
          new OpGetInternalStress<1>(data_ptr, ep.internalStressTagName));
      break;
    default:
      SETERRQ(ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
              "Unsupported mesh transfer interpolation order %d, for "
              "internal stress",
              ep.meshTransferInterpOrder);
    }
    TimeScale::ScalingFun default_scaling = [](double) { return 1; };
    auto time_scale =
        boost::make_shared<EshelbianCore::DynamicRelaxationTimeScale>(
            "internal_stress_history.txt", false, default_scaling);
    if (ep.internalStressVoigt)
      pipeline.push_back(new OpSpatialPhysicalInternalStress<true>(
          ep.stretchTensor, data_ptr, time_scale));
    else
      pipeline.push_back(new OpSpatialPhysicalInternalStress<false>(
          ep.stretchTensor, data_ptr, time_scale));
  }
  if (auto op = returnOpSpatialPhysicalExternalStrain(
          ep.stretchTensor, data_ptr, ep.externalStrainVecPtr, ep.timeScaleMap))
    pipeline.push_back(op);
  else if (ep.externalStrainVecPtr && !ep.externalStrainVecPtr->empty())
    SETERRQ(
        ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
        "OpSpatialPhysicalExternalStrain not implemented for this material");
 
  pipeline.push_back(
      returnOpSpatialPhysical(ep.stretchTensor, data_ptr, ep.alphaU));
  MoFEMFunctionReturn(0);
}

◆ pushMaterialTangent()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushMaterialTangent	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr
	)

Definition at line 387 of file EshelbianMat.cpp.

                                                    {
  MoFEMFunctionBegin;
  if ((getFeatures() & noStretchMask).any()) {
    const bool heterogeneous = getFeatures().test(NON_HOMOGENEOUS_MATERIAL);
    pipeline.push_back(new OpSpatialConsistency_dP_dP(
        ep.piolaStress, ep.piolaStress, data_ptr, heterogeneous));
    pipeline.push_back(new OpSpatialConsistency_dBubble_dP(
        ep.bubbleField, ep.piolaStress, data_ptr, heterogeneous));
    pipeline.push_back(new OpSpatialConsistency_dBubble_dBubble(
        ep.bubbleField, ep.bubbleField, data_ptr, heterogeneous));
  } else if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    CHKERR pushAuxiliaryLogarithmicStressOps(ep, pipeline, data_ptr, true);
  } else {
    pipeline.push_back(returnOpSpatialPhysical_du_du(
        ep.stretchTensor, ep.stretchTensor, data_ptr, ep.alphaU));
    pipeline.push_back(new OpSpatialPhysical_du_dP(
        ep.stretchTensor, ep.piolaStress, data_ptr, true));
    pipeline.push_back(new OpSpatialPhysical_du_dBubble(
        ep.stretchTensor, ep.bubbleField, data_ptr, true));
    pipeline.push_back(
        new OpSpatialPhysical_du_domega(ep.stretchTensor, ep.rotAxis, data_ptr,
                                        ep.symmetrySelector == SYMMETRIC));
    if (ep.symmetrySelector > SYMMETRIC)
      pipeline.push_back(new OpSpatialRotation_domega_du(
          ep.rotAxis, ep.stretchTensor, data_ptr, false));
  }
  MoFEMFunctionReturn(0);
}

◆ pushMaterialVariation()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushMaterialVariation	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		SmartPetscObj< Vec >	variation,
		MaterialPostProcData *	output = `nullptr`
	)

Definition at line 557 of file EshelbianMat.cpp.

                                                                {
  MoFEMFunctionBegin;
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    auto values = boost::make_shared<AuxiliaryLogarithmicStressData>();
    CHKERR pushAuxiliaryLogarithmicFields(
        ep, pipeline, values, data_ptr->getVarLogStreachPts(), variation);
    if (output)
      CHKERR pushAuxiliaryLogarithmicStatePostProc(pipeline, values, "Var",
                                                   *output);
  } else if ((getFeatures() & noStretchMask).any()) {
    pipeline.push_back(
        returnOpCalculateVarStretchFromStress(data_ptr, ep.physicalEquations));
  } else {
    pipeline.push_back(new OpCalculateTensor2SymmetricFieldValues<SPACE_DIM>(
        ep.stretchTensor, data_ptr->getVarLogStreachPts(), variation, MBTET));
  }
  if (output)
    output->symmetricFields["VarLogSpatialStretch"] =
        data_ptr->getVarLogStreachPts();
  MoFEMFunctionReturn(0);
}

◆ pushPostProc()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushPostProc	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		MaterialPostProcData &	output
	)

Definition at line 532 of file EshelbianMat.cpp.

                                  {
  MoFEMFunctionBegin;
  if ((getFeatures() & noStretchMask).any()) {
    pipeline.push_back(
        returnOpJacobian(true, false, data_ptr, ep.physicalEquations));
  } else {
    CHKERR pushMaterialEvaluation(ep, pipeline, data_ptr, true, false);
  }
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    CHKERR pushAuxiliaryLogarithmicPostProc(pipeline, data_ptr, output);
  } else if (auto op =
                 returnOpCalculateHelmholtzFreeEnergy(data_ptr, nullptr)) {
    pipeline.push_back(op);
  }
  output.symmetricFields["LogSpatialStretch"] =
      data_ptr->getLogStretchTensorAtPts();
  output.symmetricFields["SpatialStretch"] = data_ptr->getStretchTensorAtPts();
  if ((getFeatures() & noStretchMask).none())
    output.vectorFields["EiegnLogStreach"] = data_ptr->getEigenVals();
  MoFEMFunctionReturn(0);
}

◆ pushPostProcResidual()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushPostProcResidual	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		SmartPetscObj< Vec >	residual,
		MaterialPostProcData &	output
	)

Definition at line 582 of file EshelbianMat.cpp.

                                                               {
  MoFEMFunctionBegin;
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    auto values = boost::make_shared<AuxiliaryLogarithmicStressData>();
    auto residual_stretch = boost::make_shared<MatrixDouble>();
    CHKERR pushAuxiliaryLogarithmicFields(ep, pipeline, values,
                                          residual_stretch, residual);
    CHKERR pushAuxiliaryLogarithmicStatePostProc(pipeline, values, "Res",
                                                 output);
  } else if (getFeatures().test(DIRECT_STRETCH)) {
    auto residual_stretch = boost::make_shared<MatrixDouble>();
    pipeline.push_back(new OpCalculateTensor2SymmetricFieldValues<SPACE_DIM>(
        ep.stretchTensor, residual_stretch, residual, MBTET));
    output.symmetricFields["ResLogSpatialStretch"] = residual_stretch;
  }
  MoFEMFunctionReturn(0);
}

◆ pushSkeletonEvaluation()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushSkeletonEvaluation	(	const EshelbianCore &	ep,
		VolumeElementForcesAndSourcesCoreOnSide &	fe,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		SmartPetscObj< Vec >	residual,
		MaterialPostProcData &	output
	)

Definition at line 603 of file EshelbianMat.cpp.

                                                               {
  MoFEMFunctionBegin;
  auto &pipeline = fe.getOpPtrVector();
  fe.getUserPolynomialBase() = boost::make_shared<CGGUserPolynomialBase>(
      nullptr, !getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS));
  CHKERR EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
      pipeline, {HDIV, H1, L2}, ep.materialH1Positions, ep.frontAdjEdges);
  pipeline.push_back(new OpCalculateHVecTensorField<SPACE_DIM, SPACE_DIM>(
      ep.piolaStress, data_ptr->getApproxPAtPts()));
  pipeline.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
      ep.rotAxis, data_ptr->getRotAxisAtPts(), MBTET));
  pipeline.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
      ep.spatialL2Disp, data_ptr->getSmallWL2AtPts(), MBTET));
 
  if (getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
    const bool add_bubble = ep.mField.check_field(ep.bubbleField);
    if (add_bubble)
      pipeline.push_back(new OpCalculateHTensorTensorField<3, 3>(
          ep.bubbleField, data_ptr->getApproxPAtPts(), MBMAXTYPE));
    CHKERR VecSetDM(ep.solTSStep.get(), PETSC_NULLPTR);
    pipeline.push_back(new OpCalculateHVecTensorField<3, 3>(
        ep.piolaStress, data_ptr->getApproxP0AtPts(), nullptr, ep.solTSStep));
    if (add_bubble)
      pipeline.push_back(new OpCalculateHTensorTensorField<3, 3>(
          ep.bubbleField, data_ptr->getApproxP0AtPts(), nullptr, ep.solTSStep,
          MBMAXTYPE));
    CHKERR pushMaterialFields(ep, pipeline, data_ptr, PREVIOUS);
    CHKERR pushMaterialFields(ep, pipeline, data_ptr, CURRENT);
    pipeline.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
        ep.rotAxis, data_ptr->getRotAxis0AtPts(), ep.solTSStep, MBTET));
    pipeline.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
        ep.spatialH1Disp, data_ptr->getSmallWH1AtPts()));
    pipeline.push_back(new OpCalculateVectorFieldGradient<SPACE_DIM, SPACE_DIM>(
        ep.spatialH1Disp, data_ptr->getSmallWGradH1AtPts()));
    CHKERR addCalculatePlasticLogarithmicStretchFieldValues(
        pipeline, ep.plasticHField, data_ptr->getPlasticH(), MBTET);
    pipeline.push_back(new OpCalculateRotationAndSpatialGradient(data_ptr));
    CHKERR pushMaterialEvaluation(ep, pipeline, data_ptr, true, false);
    CHKERR pushAuxiliaryLogarithmicPostProc(pipeline, data_ptr, output);
    output.symmetricFields["SpatialStretch"] =
        data_ptr->getStretchTensorAtPts();
    if (residual)
      CHKERR pushPostProcResidual(ep, pipeline, data_ptr, residual, output);
  } else {
    CHKERR pushMaterialFields(ep, pipeline, data_ptr, CURRENT);
  }
  output.symmetricFields["LogSpatialStretch"] =
      data_ptr->getLogStretchTensorAtPts();
  MoFEMFunctionReturn(0);
}

◆ pushStretchFromStress()

MoFEMErrorCode EshelbianPlasticity::PhysicalEquations::pushStretchFromStress	(	const EshelbianCore &	ep,
		boost::ptr_deque< UserDataOperator > &	pipeline,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< MatrixDouble >	strain_ptr = `nullptr`,
		boost::shared_ptr< MatrixDouble >	stress_ptr = `nullptr`
	)

Definition at line 228 of file EshelbianMat.cpp.

                                              {
  MoFEMFunctionBegin;
  data_ptr->physicsPtr = ep.physicalEquations;
  auto external_pressure_ptr = boost::make_shared<VectorDouble>();
  if (auto op = returnOpCalculateExternalPressure(
          external_pressure_ptr, ep.externalStrainVecPtr, ep.timeScaleMap))
    pipeline.push_back(op);
  pipeline.push_back(returnOpCalculateStretchFromStress(
      std::move(data_ptr), ep.physicalEquations, std::move(strain_ptr),
      std::move(stress_ptr), std::move(external_pressure_ptr)));
  MoFEMFunctionReturn(0);
}

◆ returnOpCalculateExternalPressure()

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpCalculateExternalPressure	(	VectorPtr	external_pressure_ptr,
		boost::shared_ptr< ExternalStrainVec >	external_strain_vec_ptr,
		std::map< std::string, boost::shared_ptr< ScalingMethod > >	smv
	)

virtual

Reimplemented in EshelbianPlasticity::HMHNeohookean.

Definition at line 519 of file EshelbianMat.cpp.

                                                           {
  return nullptr;
}

◆ returnOpCalculateHelmholtzFreeEnergy()

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpCalculateHelmholtzFreeEnergy	(	boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< double >	total_helmholtz_free_energy_ptr
	)

virtual

Reimplemented in EshelbianPlasticity::HMHNeohookean, EshelbianPlasticity::MatElasticPhysicalEquations, and EshelbianPlasticity::HMHHencky.

Definition at line 484 of file EshelbianMat.cpp.

                                                             {
  return nullptr;
}

◆ returnOpCalculateStretchFromStress() [1/3]

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpCalculateStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< PhysicalEquations >	physics_ptr,
		boost::shared_ptr< MatrixDouble >	strain_ptr,
		boost::shared_ptr< MatrixDouble >	stress_ptr,
		VectorPtr	external_pressure_ptr
	)

virtual

Reimplemented in EshelbianPlasticity::HMHHencky, and EshelbianPlasticity::HMHNeohookean.

Definition at line 508 of file EshelbianMat.cpp.

                                     {
  return returnOpCalculateStretchFromStress(
      std::move(data_ptr), std::move(physics_ptr), std::move(strain_ptr),
      std::move(external_pressure_ptr));
}

◆ returnOpCalculateStretchFromStress() [2/3]

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpCalculateStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< PhysicalEquations >	physics_ptr,
		boost::shared_ptr< MatrixDouble >	strain_ptr,
		VectorPtr	external_pressure_ptr
	)

virtual

Reimplemented in EshelbianPlasticity::HMHNeohookean.

Definition at line 499 of file EshelbianMat.cpp.

                                     {
  return returnOpCalculateStretchFromStress(
      std::move(data_ptr), std::move(physics_ptr), std::move(strain_ptr));
}

◆ returnOpCalculateStretchFromStress() [3/3]

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpCalculateStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< PhysicalEquations >	physics_ptr,
		boost::shared_ptr< MatrixDouble >	strain_ptr = `nullptr`
	)

virtual

Reimplemented in EshelbianPlasticity::HMHHencky, and EshelbianPlasticity::HMHNeohookean.

Definition at line 492 of file EshelbianMat.cpp.

                                              {
  return nullptr;
}

◆ returnOpCalculateVarStretchFromStress()

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpCalculateVarStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< PhysicalEquations >	physics_ptr
	)

virtual

Reimplemented in EshelbianPlasticity::HMHHencky, and EshelbianPlasticity::HMHNeohookean.

Definition at line 526 of file EshelbianMat.cpp.

                                                    {
  return nullptr;
};

◆ returnOpJacobian()

UserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpJacobian	(	const bool	eval_rhs,
		const bool	eval_lhs,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< PhysicalEquations >	physics_ptr
	)

virtual

Reimplemented in EshelbianPlasticity::MatPhysicalEquations, EshelbianPlasticity::HMHHencky, and EshelbianPlasticity::HMHNeohookean.

Definition at line 448 of file EshelbianMat.cpp.

                                                    {
  return nullptr;
}

◆ returnOpSpatialPhysical()

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpSpatialPhysical	(	const std::string &	field_name,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		const double	alpha_u
	)

virtual

Reimplemented in EshelbianPlasticity::HMHNeohookean, EshelbianPlasticity::MatPhysicalEquations, and EshelbianPlasticity::HMHHencky.

Definition at line 455 of file EshelbianMat.cpp.

                                                                          {
  return nullptr;
}

◆ returnOpSpatialPhysical_du_du()

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpSpatialPhysical_du_du	(	std::string	row_field,
		std::string	col_field,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		const double	alpha
	)

virtual

Reimplemented in EshelbianPlasticity::MatPhysicalEquations, EshelbianPlasticity::HMHHencky, and EshelbianPlasticity::HMHNeohookean.

Definition at line 469 of file EshelbianMat.cpp.

                                                                        {
  return nullptr;
}

◆ returnOpSpatialPhysicalExternalStrain()

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpSpatialPhysicalExternalStrain	(	const std::string &	field_name,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< ExternalStrainVec >	external_strain_vec_ptr,
		std::map< std::string, boost::shared_ptr< ScalingMethod > >	smv
	)

virtual

Reimplemented in EshelbianPlasticity::HMHNeohookean, EshelbianPlasticity::MatPhysicalEquations, and EshelbianPlasticity::HMHHencky.

Definition at line 461 of file EshelbianMat.cpp.

                                                           {
  return nullptr;
}

◆ returnOpTopoSpatialPhysical()

VolUserDataOperator * EshelbianPlasticity::PhysicalEquations::returnOpTopoSpatialPhysical	(	const std::string &	field_name,
		boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		SmartPetscObj< Vec >	assemble_vec,
		boost::shared_ptr< TopologicalData >	topo_ptr,
		const double	alpha_u,
		boost::shared_ptr< double >	J_ptr
	)

virtual

Reimplemented in EshelbianPlasticity::HMHHencky.

Definition at line 475 of file EshelbianMat.cpp.

                                   {
  return nullptr;
}

◆ usesStressBasedStrain()

bool EshelbianPlasticity::PhysicalEquations::usesStressBasedStrain ( ) const

inlineprivate

Definition at line 919 of file EshelbianPlasticity.hpp.

                                     {
    return (materialFeatures & noStretchMask).any() || materialModel == Hencky;
  }

Member Data Documentation

◆ materialFeatures

Features EshelbianPlasticity::PhysicalEquations::materialFeatures

protected

Definition at line 929 of file EshelbianPlasticity.hpp.

◆ materialModel

MaterialModel EshelbianPlasticity::PhysicalEquations::materialModel

private

Definition at line 926 of file EshelbianPlasticity.hpp.

◆ noStretchMask

const Features EshelbianPlasticity::PhysicalEquations::noStretchMask

inlinestatic

Initial value:

=

Features{}.set(NO_STRETCH_LINEAR).set(NO_STRETCH_NONLINEAR)

Examples: /home/lk58p/mofem_install/vanilla_dev_release/mofem-cephas/mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianOperators.cpp.

Definition at line 732 of file EshelbianPlasticity.hpp.

733 {}.set(NO_STRETCH_LINEAR).set(NO_STRETCH_NONLINEAR);

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

users_modules/eshelbian_plasticity/src/EshelbianPlasticity.hpp
users_modules/eshelbian_plasticity/src/impl/EshelbianMat.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Features

Member Enumeration Documentation

◆ Feature

◆ FieldState

◆ MaterialModel

Constructor & Destructor Documentation

◆ PhysicalEquations()

◆ ~PhysicalEquations()

Member Function Documentation

◆ checkOptions()

◆ checkSetup()

◆ create()

◆ getFeatures()

◆ getMaterialCouplings()

◆ getMaterialEmptyBlocks()

◆ getMaterialFieldDefinitions()

◆ getMaterialFields()

◆ getMaterialModel()

◆ providesHelmholtzFreeEnergy()

◆ pushAuxiliaryLogarithmicMaterialEvaluation()

◆ pushAuxiliaryLogarithmicStressOps()

◆ pushEnergyEvaluation()

◆ pushHelmholtzStateGradient()

◆ pushMaterialEvaluation()

◆ pushMaterialFields()

◆ pushMaterialForceFields()

◆ pushMaterialRates()

◆ pushMaterialResidual()

◆ pushMaterialTangent()

◆ pushMaterialVariation()

◆ pushPostProc()

◆ pushPostProcResidual()

◆ pushSkeletonEvaluation()

◆ pushStretchFromStress()

◆ returnOpCalculateExternalPressure()

◆ returnOpCalculateHelmholtzFreeEnergy()

◆ returnOpCalculateStretchFromStress() [1/3]

◆ returnOpCalculateStretchFromStress() [2/3]

◆ returnOpCalculateStretchFromStress() [3/3]

◆ returnOpCalculateVarStretchFromStress()

◆ returnOpJacobian()

◆ returnOpSpatialPhysical()

◆ returnOpSpatialPhysical_du_du()

◆ returnOpSpatialPhysicalExternalStrain()

◆ returnOpTopoSpatialPhysical()

◆ usesStressBasedStrain()

Member Data Documentation

◆ materialFeatures

◆ materialModel

◆ noStretchMask