Inheritance diagram for EshelbianPlasticity::HMHNeohookean:

Collaboration diagram for EshelbianPlasticity::HMHNeohookean:

Classes
struct	BlockData

struct	OpAuxiliaryHelmholtzGradient

struct	OpEnergy

struct	OpExternalStrain

struct	OpJacobian

struct	OpResidual

struct	OpTangent

Public Types
using	Material = NeoHookeanLogarithmicMaterial

using	PackedStress = FTensor::Tensor1< double, size_symm >

using	PackedTangent = FTensor::Tensor2< double, size_symm, size_symm >

using	FormBase = typename FormsIntegrators< VolUserDataOperator >::Assembly< A >::OpBase

Public Types inherited from EshelbianPlasticity::PhysicalEquations
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
MoFEMErrorCode	pushAuxiliaryLogarithmicMaterialEvaluation (const EshelbianCore &ep, boost::ptr_deque< UserDataOperator > &pipeline, boost::shared_ptr< DataAtIntegrationPts > data_ptr, bool lhs) override
	Evaluate the auxiliary material copy and energies without assembly.

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

	HMHNeohookean (MoFEM::Interface &m_field, const double c10, const double bulk_modulus, const Features features)

Material::Parameters	getParameters (const EntityHandle entity) const

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

VolUserDataOperator *	returnOpCalculateHelmholtzFreeEnergy (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< double > total_energy_ptr) override

bool	providesHelmholtzFreeEnergy () const override

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

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

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

VolUserDataOperator *	returnOpSpatialPhysicalExternalStrain (const std::string &field, boost::shared_ptr< DataAtIntegrationPts >, boost::shared_ptr< ExternalStrainVec > external_strain_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > scaling_methods) override

VolUserDataOperator *	returnOpCalculateExternalPressure (VectorPtr pressure_ptr, boost::shared_ptr< ExternalStrainVec > external_strain_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > scaling_methods) override

VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts >, boost::shared_ptr< PhysicalEquations >, boost::shared_ptr< MatrixDouble >) override

VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts >, boost::shared_ptr< PhysicalEquations >, boost::shared_ptr< MatrixDouble >, VectorPtr) override

VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts >, boost::shared_ptr< PhysicalEquations >, boost::shared_ptr< MatrixDouble >, boost::shared_ptr< MatrixDouble >, VectorPtr) override

VolUserDataOperator *	returnOpCalculateVarStretchFromStress (boost::shared_ptr< DataAtIntegrationPts >, boost::shared_ptr< PhysicalEquations >) override

Public Member Functions inherited from EshelbianPlasticity::PhysicalEquations
	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.

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 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)

Static Public Member Functions
static MoFEMErrorCode	evaluateDirect (const Material::Parameters &parameters, const Material::SymmetricTensor &t_log_stretch, double &energy, PackedStress stress_ptr=nullptr, PackedTangent tangent_ptr=nullptr)

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

Private Member Functions
AuxiliaryLogarithmicMaterialParameters	prepareAuxiliaryEvaluation (const boost::shared_ptr< DataAtIntegrationPts > &data_ptr)

MoFEMErrorCode	getOptions ()

MoFEMErrorCode	extractBlockData ()

Static Private Member Functions
static MoFEMErrorCode	checkDirectConfiguration ()

static boost::shared_ptr< HMHNeohookean >	getMaterial (const boost::shared_ptr< DataAtIntegrationPts > &data_ptr)

static VolUserDataOperator *	retiredInverse ()

Private Attributes
MoFEM::Interface &	mField

Material::Parameters	defaultParameters

double	alphaGradU = 0.

std::vector< BlockData >	blockData

Additional Inherited Members
Static Public Attributes inherited from EshelbianPlasticity::PhysicalEquations
static const Features	noStretchMask

Protected Attributes inherited from EshelbianPlasticity::PhysicalEquations
Features	materialFeatures

Detailed Description

Definition at line 15 of file HMHNeohookean.cpp.

Member Typedef Documentation

◆ FormBase

using EshelbianPlasticity::HMHNeohookean::FormBase = typename FormsIntegrators<VolUserDataOperator>::Assembly<A>::OpBase

Definition at line 19 of file HMHNeohookean.cpp.

◆ Material

using EshelbianPlasticity::HMHNeohookean::Material = NeoHookeanLogarithmicMaterial

Definition at line 16 of file HMHNeohookean.cpp.

◆ PackedStress

using EshelbianPlasticity::HMHNeohookean::PackedStress = FTensor::Tensor1<double, size_symm>

Definition at line 17 of file HMHNeohookean.cpp.

◆ PackedTangent

using EshelbianPlasticity::HMHNeohookean::PackedTangent = FTensor::Tensor2<double, size_symm, size_symm>

Definition at line 18 of file HMHNeohookean.cpp.

Constructor & Destructor Documentation

◆ HMHNeohookean()

EshelbianPlasticity::HMHNeohookean::HMHNeohookean	(	MoFEM::Interface &	m_field,
		const double	c10,
		const double	bulk_modulus,
		const Features	features
	)

inline

Definition at line 42 of file HMHNeohookean.cpp.

      : PhysicalEquations(Neohookean, features), mField(m_field),
        defaultParameters{c10, bulk_modulus} {
    if ((getFeatures() & noStretchMask).any())
      CHK_THROW_MESSAGE(
          MOFEM_NOT_IMPLEMENTED,
          "Neo-Hookean -no_stretch physical-stress recovery was "
          "retired; omit -no_stretch and solve the material fields");
    if (EshelbianCore::stretchSelector != LOG)
      CHK_THROW_MESSAGE(
          MOFEM_NOT_IMPLEMENTED,
          "Neo-Hookean requires natural logarithms: -stretches log");
    CHK_THROW_MESSAGE(getOptions(), "Neo-Hookean options are invalid");
    CHK_THROW_MESSAGE(extractBlockData(),
                      "Neo-Hookean material blocks are invalid");
  }

Member Function Documentation

◆ checkDirectConfiguration()

static MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::checkDirectConfiguration ( )

inlinestaticprivate

Definition at line 577 of file HMHNeohookean.cpp.

                                                   {
    MoFEMFunctionBegin;
    if (EshelbianCore::gradApproximator != NO_H1_CONFIGURATION)
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "Neo-Hookean direct material equations require -grad no_h1");
    if (EshelbianCore::rotSelector != LARGE_ROT &&
        EshelbianCore::rotSelector != SMALL_ROT)
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "Neo-Hookean direct material equations require "
              "-rotations large or -rotations small");
    MoFEMFunctionReturn(0);
  }

◆ evaluateDirect()

static MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::evaluateDirect	(	const Material::Parameters &	parameters,
		const Material::SymmetricTensor &	t_log_stretch,
		double &	energy,
		PackedStress *	stress_ptr = `nullptr`,
		PackedTangent *	tangent_ptr = `nullptr`
	)

inlinestatic

Map derivatives from five orthonormal coordinates and theta to the six raw symmetric coefficients. SymmLTensor supplies both shear occurrences.

Definition at line 75 of file HMHNeohookean.cpp.

                                                       {
    MoFEMFunctionBegin;
    FTENSOR_INDEXES(3, i, j);
    FTENSOR_INDEXES(size_symm, L, J);
    FTensor::Index<'a', 5> a;
    FTensor::Index<'b', 5> b;
    const auto t_coordinates = Material::getCoordinates(t_log_stretch);
    Material::Coordinates t_stress;
    Material::Tangent t_hessian;
    Material::VolumeState volume;
    CHKERR Material::evaluateDeviator(parameters, t_coordinates, energy,
                                      stress_ptr ? &t_stress : nullptr,
                                      tangent_ptr ? &t_hessian : nullptr);
    CHKERR Material::evaluateVolume(parameters, t_log_stretch(i, i), volume);
    energy += volume.energy;
    if (!std::isfinite(energy))
      SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
              "Neo-Hookean total strain energy is not representable");
    const auto t_packed_basis = FTensor::SymmLTensor<double, 3>();
    constexpr auto t_identity = FTensor::Kronecker_Delta_symmetric<int>();
    if (stress_ptr) {
      const auto t_deviatoric_stress = Material::getTensor(t_stress);
      Material::SymmetricTensor t_total_stress;
      t_total_stress(i, j) =
          t_deviatoric_stress(i, j) + volume.firstDerivative * t_identity(i, j);
      (*stress_ptr)(L) = t_packed_basis(i, j, L) * t_total_stress(i, j);
      for (int component = 0; component != size_symm; ++component)
        if (!std::isfinite((*stress_ptr)(component)))
          SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                  "Neo-Hookean packed material stress is not representable");
    }
    if (tangent_ptr) {
      const auto &t_basis = Tensor2SymmetricDeviatorBasis::getBasis();
      FTensor::Tensor2<double, 5, size_symm> t_projection;
      t_projection(a, L) = t_basis(i, j, a) * t_packed_basis(i, j, L);
      PackedStress t_trace;
      t_trace(L) = t_packed_basis(i, j, L) * t_identity(i, j);
      FTensor::Tensor2<double, 5, size_symm> t_hessian_projection;
      t_hessian_projection(a, J) = t_hessian(a, b) * t_projection(b, J);
      (*tangent_ptr)(L, J) = t_projection(a, L) * t_hessian_projection(a, J) +
                             volume.secondDerivative * t_trace(L) * t_trace(J);
      for (int row = 0; row != size_symm; ++row)
        for (int col = 0; col != size_symm; ++col)
          if (!std::isfinite((*tangent_ptr)(row, col)))
            SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                    "Neo-Hookean packed material tangent is not representable");
    }
    MoFEMFunctionReturn(0);
  }

◆ extractBlockData()

MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::extractBlockData ( )

inlineprivate

Definition at line 646 of file HMHNeohookean.cpp.

                                    {
    MoFEMFunctionBegin;
    auto meshsets = mField.getInterface<MeshsetsManager>();
    auto json_config = mField.getInterface<JsonConfigManager>();
    for (const auto block :
         meshsets->getCubitMeshsetPtr(std::regex("MAT_NEOHOOKEAN(.*)"))) {
      Material::Parameters parameters;
      const auto json_parameters = json_config->getParamsFromBlockset(
          "MAT_NEOHOOKEAN", block->getMeshsetId());
      if (!json_parameters.empty()) {
        if (json_parameters.size() != 2 || !json_parameters.count("c10") ||
            !json_parameters.count("k"))
          SETERRQ(mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "MAT_NEOHOOKEAN JSON block must contain exactly c10,k");
        parameters = {json_parameters.at("c10"), json_parameters.at("k")};
      } else {
        std::vector<double> attributes;
        CHKERR block->getAttributes(attributes);
        if (attributes.size() < 2)
          SETERRQ(mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "MAT_NEOHOOKEAN block requires C10,K attributes");
        parameters = {attributes[0], attributes[1]};
      }
      CHKERR Material::validateParameters(parameters);
      Range entities;
      CHKERR mField.get_moab().get_entities_by_handle(block->getMeshset(),
                                                      entities, true);
      blockData.push_back({parameters, std::move(entities)});
      MOFEM_LOG("EP", Sev::inform)
          << "MAT_NEOHOOKEAN " << block->getMeshsetId()
          << " C10=" << parameters.c10 << " K=" << parameters.bulkModulus;
    }
    MoFEMFunctionReturn(0);
  }

◆ getMaterial()

static boost::shared_ptr< HMHNeohookean > EshelbianPlasticity::HMHNeohookean::getMaterial ( const boost::shared_ptr< DataAtIntegrationPts > & data_ptr )

inlinestaticprivate

Definition at line 591 of file HMHNeohookean.cpp.

                                                                     {
    if (!data_ptr)
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Neo-Hookean integration-point data is missing");
    const auto material_ptr =
        boost::dynamic_pointer_cast<HMHNeohookean>(data_ptr->physicsPtr);
    if (!material_ptr)
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Neo-Hookean material pointer is missing");
    return material_ptr;
  }

◆ getOptions()

MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::getOptions ( )

inlineprivate

Definition at line 610 of file HMHNeohookean.cpp.

                              {
    MoFEMFunctionBegin;
    PetscOptionsBegin(mField.get_comm(), "neo_hookean_", "Neo-Hookean material",
                      "none");
    CHKERR PetscOptionsScalar("-c10", "C10", "", defaultParameters.c10,
                              &defaultParameters.c10, nullptr);
    CHKERR PetscOptionsScalar("-K", "Bulk modulus", "",
                              defaultParameters.bulkModulus,
                              &defaultParameters.bulkModulus, nullptr);
    CHKERR PetscOptionsScalar("-viscosity_alpha_grad_u",
                              "Logarithmic-stretch-gradient rate viscosity", "",
                              alphaGradU, &alphaGradU, nullptr);
    PetscOptionsEnd();
    CHKERR Material::validateParameters(defaultParameters);
    if (!std::isfinite(alphaGradU))
      SETERRQ(
          mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
          "Neo-Hookean logarithmic-stretch-gradient viscosity must be finite");
    char *options_ptr = nullptr;
    CHKERR PetscOptionsGetAll(nullptr, &options_ptr);
    std::istringstream options(options_ptr ? options_ptr : "");
    CHKERR PetscFree(options_ptr);
    std::string option;
    while (options >> option)
      if (option.rfind("-nh_stretch_", 0) == 0 ||
          option == "-neo_hookean_min_eigen_value")
        SETERRQ(mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
                "Option %s belongs to the retired Neo-Hookean physical inverse "
                "or tangent projection; remove it",
                option.c_str());
    MOFEM_LOG("EP", Sev::inform) << "Neo-Hookean C10=" << defaultParameters.c10
                                 << " K=" << defaultParameters.bulkModulus
                                 << " alphaGradU=" << alphaGradU;
    MoFEMFunctionReturn(0);
  }

◆ getParameters()

Material::Parameters EshelbianPlasticity::HMHNeohookean::getParameters ( const EntityHandle entity ) const

inline

Definition at line 60 of file HMHNeohookean.cpp.

                                                                    {
    for (const auto &block : blockData)
      if (block.entities.find(entity) != block.entities.end())
        return block.parameters;
    if (!blockData.empty())
      CHK_THROW_MESSAGE(
          MOFEM_DATA_INCONSISTENCY,
          "MAT_NEOHOOKEAN blocks must cover every material element");
    return defaultParameters;
  }

◆ prepareAuxiliaryEvaluation()

AuxiliaryLogarithmicMaterialParameters EshelbianPlasticity::HMHNeohookean::prepareAuxiliaryEvaluation ( const boost::shared_ptr< DataAtIntegrationPts > & data_ptr )

inlineprivate

Definition at line 566 of file HMHNeohookean.cpp.

                                                             {
    if (!data_ptr)
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Auxiliary material evaluation requires field data");
    if (!data_ptr->auxiliaryMaterialData)
      data_ptr->auxiliaryMaterialData =
          boost::make_shared<AuxiliaryLogarithmicStressMaterialData>();
    return [this](EntityHandle entity) { return getParameters(entity); };
  }

◆ providesHelmholtzFreeEnergy()

bool EshelbianPlasticity::HMHNeohookean::providesHelmholtzFreeEnergy ( ) const

inlineoverridevirtual

True when the material supplies its Helmholtz free energy.

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 187 of file HMHNeohookean.cpp.

187{ return true; }

◆ pushAuxiliaryLogarithmicMaterialEvaluation()

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

inlineoverridevirtual

Evaluate the auxiliary material copy and energies without assembly.

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 22 of file HMHNeohookean.cpp.

                                                                         {
    MoFEMFunctionBegin;
    auto parameters = prepareAuxiliaryEvaluation(data_ptr);
    CHKERR EshelbianPlasticity::pushAuxiliaryLogarithmicMaterialEvaluation(
        ep, pipeline, data_ptr, data_ptr->auxiliaryMaterialData,
        std::move(parameters), lhs);
    MoFEMFunctionReturn(0);
  }

◆ pushAuxiliaryLogarithmicStressOps()

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

inlineoverridevirtual

Assemble the selected material field group after kinematic reconstruction.

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 33 of file HMHNeohookean.cpp.

                                                                         {
    MoFEMFunctionBegin;
    CHKERR pushAuxiliaryLogarithmicMaterialOps(
        ep, pipeline, data_ptr->auxiliaryMaterialData, lhs);
    MoFEMFunctionReturn(0);
  }

◆ pushHelmholtzStateGradient()

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

inlineoverridevirtual

Assemble the physical Helmholtz state derivative at equilibrium.

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 243 of file HMHNeohookean.cpp.

                                                               {
    MoFEMFunctionBegin;
    if (!getFeatures().test(AUXILIARY_LOGARITHMIC_STRESS)) {
      CHKERR PhysicalEquations::pushHelmholtzStateGradient(ep, pipeline,
                                                           data_ptr);
      MoFEMFunctionReturnHot(0);
    }
    auto deviator_gradient = boost::make_shared<MatrixDouble>();
    auto volume_gradient = boost::make_shared<MatrixDouble>();
    pipeline.push_back(new OpAuxiliaryHelmholtzGradient(
        data_ptr, deviator_gradient, volume_gradient));
    using OpDeviatorGradient = FormsIntegrators<VolUserDataOperator>::Assembly<
        A>::LinearForm<GAUSS>::OpBaseTimesVector<1, 5, 5>;
    using OpVolumeGradient = FormsIntegrators<VolUserDataOperator>::Assembly<
        A>::LinearForm<GAUSS>::OpBaseTimesVector<1, 1, 1>;
    pipeline.push_back(
        new OpDeviatorGradient(ep.logDeviator, deviator_gradient));
    pipeline.push_back(new OpVolumeGradient(ep.logJacobian, volume_gradient));
    MoFEMFunctionReturn(0);
  }

◆ retiredInverse()

static VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::retiredInverse ( )

inlinestaticprivate

Definition at line 603 of file HMHNeohookean.cpp.

                                               {
    CHK_THROW_MESSAGE(MOFEM_NOT_IMPLEMENTED,
                      "Neo-Hookean physical-stress-to-stretch recovery was "
                      "retired; solve the logarithmic material fields");
    return nullptr;
  }

◆ returnOpCalculateExternalPressure()

VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::returnOpCalculateExternalPressure	(	VectorPtr	pressure_ptr,
		boost::shared_ptr< ExternalStrainVec >	external_strain_ptr,
		std::map< std::string, boost::shared_ptr< ScalingMethod > >	scaling_methods
	)

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 530 of file HMHNeohookean.cpp.

               {
    return new OpCalculateExternalPressure(std::move(pressure_ptr),
                                           std::move(external_strain_ptr),
                                           std::move(scaling_methods));
  }

◆ returnOpCalculateHelmholtzFreeEnergy()

VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::returnOpCalculateHelmholtzFreeEnergy	(	boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< double >	total_energy_ptr
	)

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 181 of file HMHNeohookean.cpp.

                                                         {
    return new OpEnergy(std::move(data_ptr), std::move(total_energy_ptr));
  }

◆ returnOpCalculateStretchFromStress() [1/3]

VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::returnOpCalculateStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	,
		boost::shared_ptr< PhysicalEquations >	,
		boost::shared_ptr< MatrixDouble >
	)

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 541 of file HMHNeohookean.cpp.

                                                                             {
    return retiredInverse();
  }

◆ returnOpCalculateStretchFromStress() [2/3]

VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::returnOpCalculateStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	,
		boost::shared_ptr< PhysicalEquations >	,
		boost::shared_ptr< MatrixDouble >	,
		boost::shared_ptr< MatrixDouble >	,
		VectorPtr
	)

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 553 of file HMHNeohookean.cpp.

                                                         {
    return retiredInverse();
  }

◆ returnOpCalculateStretchFromStress() [3/3]

VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::returnOpCalculateStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	,
		boost::shared_ptr< PhysicalEquations >	,
		boost::shared_ptr< MatrixDouble >	,
		VectorPtr
	)

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 547 of file HMHNeohookean.cpp.

                                                         {
    return retiredInverse();
  }

◆ returnOpCalculateVarStretchFromStress()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 559 of file HMHNeohookean.cpp.

                                                   {
    return retiredInverse();
  }

◆ returnOpJacobian()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 135 of file HMHNeohookean.cpp.

                                                                            {
    return new OpJacobian(eval_rhs, eval_lhs, std::move(data_ptr),
                          std::move(physics_ptr));
  }

◆ returnOpSpatialPhysical()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 350 of file HMHNeohookean.cpp.

                                                         {
    return new OpResidual(field, std::move(data_ptr), alpha_u);
  }

◆ returnOpSpatialPhysical_du_du()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 448 of file HMHNeohookean.cpp.

                                     {
    return new OpTangent(row_field, col_field, std::move(data_ptr), alpha_u);
  }

◆ returnOpSpatialPhysicalExternalStrain()

VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::returnOpSpatialPhysicalExternalStrain	(	const std::string &	field,
		boost::shared_ptr< DataAtIntegrationPts >	,
		boost::shared_ptr< ExternalStrainVec >	external_strain_ptr,
		std::map< std::string, boost::shared_ptr< ScalingMethod > >	scaling_methods
	)

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 521 of file HMHNeohookean.cpp.

               {
    return new OpExternalStrain(field, std::move(external_strain_ptr),
                                std::move(scaling_methods));
  }

Member Data Documentation

◆ alphaGradU

double EshelbianPlasticity::HMHNeohookean::alphaGradU = 0.

private

Definition at line 687 of file HMHNeohookean.cpp.

◆ blockData

std::vector<BlockData> EshelbianPlasticity::HMHNeohookean::blockData

private

Definition at line 688 of file HMHNeohookean.cpp.

◆ defaultParameters

Material::Parameters EshelbianPlasticity::HMHNeohookean::defaultParameters

private

Definition at line 686 of file HMHNeohookean.cpp.

◆ mField

MoFEM::Interface& EshelbianPlasticity::HMHNeohookean::mField

private

Definition at line 685 of file HMHNeohookean.cpp.

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

users_modules/eshelbian_plasticity/src/impl/HMHNeohookean.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ FormBase

◆ Material

◆ PackedStress

◆ PackedTangent

Constructor & Destructor Documentation

◆ HMHNeohookean()

Member Function Documentation

◆ checkDirectConfiguration()

◆ evaluateDirect()

◆ extractBlockData()

◆ getMaterial()

◆ getOptions()

◆ getParameters()

◆ prepareAuxiliaryEvaluation()

◆ providesHelmholtzFreeEnergy()

◆ pushAuxiliaryLogarithmicMaterialEvaluation()

◆ pushAuxiliaryLogarithmicStressOps()

◆ pushHelmholtzStateGradient()

◆ retiredInverse()

◆ returnOpCalculateExternalPressure()

◆ returnOpCalculateHelmholtzFreeEnergy()

◆ returnOpCalculateStretchFromStress() [1/3]

◆ returnOpCalculateStretchFromStress() [2/3]

◆ returnOpCalculateStretchFromStress() [3/3]

◆ returnOpCalculateVarStretchFromStress()

◆ returnOpJacobian()

◆ returnOpSpatialPhysical()

◆ returnOpSpatialPhysical_du_du()

◆ returnOpSpatialPhysicalExternalStrain()

Member Data Documentation

◆ alphaGradU

◆ blockData

◆ defaultParameters

◆ mField