EshelbianPlasticity::HMHHencky Struct Reference

Inheritance diagram for EshelbianPlasticity::HMHHencky:

Collaboration diagram for EshelbianPlasticity::HMHHencky:

Classes
struct	BlockData
struct	OpCalculateHelmholtzFreeEnergy
	Calculate energy density for Hencky material model. More...
struct	OpCalculateStretchFromStress
struct	OpHenckyJacobian
struct	OpSpatialPhysical
struct	OpSpatialPhysical_du_du
struct	OpSpatialPhysicalExternalStrain
struct	OpTopoSpatialPhysical

Public Member Functions
	HMHHencky (MoFEM::Interface &m_field, const double E, const double nu, const Features features)
UserDataOperator *	returnOpJacobian (const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr) override
VolUserDataOperator *	returnOpSpatialPhysical (const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha_u) override
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) override
VolUserDataOperator *	returnOpSpatialPhysical_du_du (std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha) override
VolUserDataOperator *	returnOpCalculateHelmholtzFreeEnergy (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< double > total_helmholtz_free_energy_ptr) override
bool	providesHelmholtzFreeEnergy () const override
VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr, boost::shared_ptr< MatrixDouble > strain_ptr) override
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) override
VolUserDataOperator *	returnOpCalculateVarStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr) override
MoFEMErrorCode	getOptions ()
MoFEMErrorCode	extractBlockData (Sev sev)
MoFEMErrorCode	extractBlockData (std::vector< const CubitMeshSets * > meshset_vec_ptr, Sev sev)
template<int STRIDEMATD, typename OP_PTR >
MoFEMErrorCode	computeMaterialParamsAtPts (OP_PTR op_ptr, EntitiesFieldData::EntData &data, boost::shared_ptr< DataAtIntegrationPts > dataAtGaussPts)
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) 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.
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 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 *	returnOpCalculateExternalPressure (VectorPtr external_pressure_ptr, boost::shared_ptr< ExternalStrainVec > external_strain_vec_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv)

Static Public Attributes
static constexpr int	StrideMatD
Static Public Attributes inherited from EshelbianPlasticity::PhysicalEquations
static const Features	noStretchMask

Private Types
enum	HenckyMatType { HOMOGENEOUS , HETEROGENEOUS , ANALYTICAL }

Private Attributes
MoFEM::Interface &	mField
std::vector< BlockData >	blockData
double	E
double	nu
PetscBool	effectiveNehookeanStiffness = PETSC_FALSE
double	effectiveDiagonalStrain = 0

Additional Inherited Members
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 >
Static Public Member Functions inherited from EshelbianPlasticity::PhysicalEquations
static MoFEMErrorCode	create (EshelbianCore &ep)
	Select and configure the material before registering fields and DMs.
Protected Attributes inherited from EshelbianPlasticity::PhysicalEquations
Features	materialFeatures

Detailed Description

Definition at line 37 of file HMHHencky.cpp.

Member Enumeration Documentation

HenckyMatType

enum EshelbianPlasticity::HMHHencky::HenckyMatType

private

Enumerator
HOMOGENEOUS
HETEROGENEOUS
ANALYTICAL

Definition at line 647 of file HMHHencky.cpp.

{ HOMOGENEOUS, HETEROGENEOUS, ANALYTICAL };

Constructor & Destructor Documentation

HMHHencky()

EshelbianPlasticity::HMHHencky::HMHHencky ( MoFEM::Interface &  m_field, const double  E, const double  nu, const Features  features  )

inline

Definition at line 39 of file HMHHencky.cpp.

      : PhysicalEquations(Hencky, features), mField(m_field), E(E), nu(nu) {
    CHK_THROW_MESSAGE(getOptions(), "getOptions failed");
    CHK_THROW_MESSAGE(extractBlockData(Sev::verbose),
                      "Can not get data from block");
    for (const auto &block : blockData) {
      if (block.matType != HenckyMatType::HOMOGENEOUS) {
        materialFeatures.set(NON_HOMOGENEOUS_MATERIAL);
        MOFEM_LOG("WORLD", Sev::verbose)
            << "Found non-homogeneous material block: " << block.blockName;
        break;
      }
    }
  }

Member Function Documentation

computeMaterialParamsAtPts()

template<int STRIDEMATD, typename OP_PTR >

MoFEMErrorCode EshelbianPlasticity::HMHHencky::computeMaterialParamsAtPts ( OP_PTR  op_ptr, EntitiesFieldData::EntData &  data, boost::shared_ptr< DataAtIntegrationPts >  dataAtGaussPts  )

inline

Definition at line 382 of file HMHHencky.cpp.

                                                            {
    MoFEMFunctionBegin;
 
    auto getMaterialParams = [&](double E, double nu) {
      if (effectiveNehookeanStiffness) {
        return calc_effective_elastic_params(E, nu, effectiveDiagonalStrain);
      }
 
      const double bulk_modulus_K = E / (3 * (1 - 2 * nu));
      const double shear_modulus_G = E / (2 * (1 + nu));
      const double lambda = bulk_modulus_K - 2 * shear_modulus_G / 3;
      return EffectiveElasticParams{E, nu, bulk_modulus_K, shear_modulus_G,
                                    lambda};
    };
 
    auto fe_ent = op_ptr->getNumeredEntFiniteElementPtr()->getEnt();
    int nb_integration_pts = op_ptr->getGaussPts().size2();
 
    dataAtGaussPts->muAtPts.resize(nb_integration_pts, false);
    dataAtGaussPts->lambdaAtPts.resize(nb_integration_pts, false);
    dataAtGaussPts->muAtPts.clear();
    dataAtGaussPts->lambdaAtPts.clear();
 
    dataAtGaussPts->youngModulusAtPts.resize(nb_integration_pts, false);
    dataAtGaussPts->youngModulusAtPts.clear();
 
    auto t_young_modulus =
        getFTensor0FromVec(dataAtGaussPts->youngModulusAtPts);
    auto t_mu = getFTensor0FromVec(dataAtGaussPts->muAtPts);
    auto t_lambda = getFTensor0FromVec(dataAtGaussPts->lambdaAtPts);
 
    MatrixSizeHelper<
        GetFTensor4DdgFromMatType<SPACE_DIM, SPACE_DIM, STRIDEMATD, DL>,
        DL>::size(dataAtGaussPts->matD, nb_integration_pts);
    MatrixSizeHelper<
        GetFTensor4DdgFromMatType<SPACE_DIM, SPACE_DIM, STRIDEMATD, DL>,
        DL>::size(dataAtGaussPts->matAxiatorD, nb_integration_pts);
    MatrixSizeHelper<
        GetFTensor4DdgFromMatType<SPACE_DIM, SPACE_DIM, STRIDEMATD, DL>,
        DL>::size(dataAtGaussPts->matDeviatorD, nb_integration_pts);
    MatrixSizeHelper<
        GetFTensor4DdgFromMatType<SPACE_DIM, SPACE_DIM, STRIDEMATD, DL>,
        DL>::size(dataAtGaussPts->matInvD, nb_integration_pts);
 
    dataAtGaussPts->matD.clear();
    dataAtGaussPts->matAxiatorD.clear();
    dataAtGaussPts->matDeviatorD.clear();
    dataAtGaussPts->matInvD.clear();
 
    FTENSOR_INDEX(SPACE_DIM, i);
    FTENSOR_INDEX(SPACE_DIM, j);
    FTENSOR_INDEX(SPACE_DIM, k);
    FTENSOR_INDEX(SPACE_DIM, l);
    constexpr auto t_kd = FTensor::Kronecker_Delta_symmetric<int>();
 
    auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, STRIDEMATD>(
        dataAtGaussPts->matD);
    auto t_axiator_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, STRIDEMATD>(
        dataAtGaussPts->matAxiatorD);
    auto t_deviator_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, STRIDEMATD>(
        dataAtGaussPts->matDeviatorD);
    auto t_inv_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, STRIDEMATD>(
        dataAtGaussPts->matInvD);
 
    auto next = [&]() {
      ++t_young_modulus;
      ++t_mu;
      ++t_lambda;
      ++t_D;
      ++t_axiator_D;
      ++t_deviator_D;
      ++t_inv_D;
    };
 
    auto evalMatD = [&](double bulk_modulus_K, double shear_modulus_G) {
      MoFEMFunctionBegin;
      t_axiator_D(i, j, k, l) = (bulk_modulus_K - (2. / 3.) * shear_modulus_G) *
                                t_kd(i, j) * t_kd(k, l);
      t_deviator_D(i, j, k, l) =
          2 * shear_modulus_G * ((t_kd(i, k) ^ t_kd(j, l)) / 4.);
      t_D(i, j, k, l) = t_axiator_D(i, j, k, l) + t_deviator_D(i, j, k, l);
      MoFEMFunctionReturn(0);
    };
 
    auto evalInvMatDPtr = [&](double bulk_modulus_K, double shear_modulus_G) {
      MoFEMFunctionBegin;
      const double A = 1. / (2. * shear_modulus_G);
      const double B =
          (1. / (9. * bulk_modulus_K)) - (1. / (6. * shear_modulus_G));
      t_inv_D(i, j, k, l) =
          A * ((t_kd(i, k) ^ t_kd(j, l)) / 4.) + B * t_kd(i, j) * t_kd(k, l);
      MoFEMFunctionReturn(0);
    };
 
    // from block data (MAT_ELASTIC) or (ANALYTICAL_ELASTIC) if provided,
    // otherwise from command line options
    for (auto &b : this->blockData) {
      if (b.blockEnts.find(op_ptr->getFEEntityHandle()) != b.blockEnts.end()) {
 
        if (b.matType == HMHHencky::HenckyMatType::ANALYTICAL) {
          VectorDouble analytical_elastic;
          analytical_elastic = getAnalyticalElastic(op_ptr, b.blockName);
 
          auto t_analytical_elastic = getFTensor0FromVec(analytical_elastic);
 
          for (int gg = 0; gg != nb_integration_pts; ++gg) {
            const auto material_params =
                getMaterialParams(t_analytical_elastic, b.poissonRatio);
            t_young_modulus = material_params.youngModulus;
            t_mu = material_params.shearModulusG;
            t_lambda = material_params.lambda;
 
            CHKERR evalMatD(material_params.bulkModulusK,
                            material_params.shearModulusG);
            CHKERR evalInvMatDPtr(material_params.bulkModulusK,
                                  material_params.shearModulusG);
            ++t_analytical_elastic;
            next();
          }
 
        } else if (b.matType == HMHHencky::HenckyMatType::HETEROGENEOUS) {
          Tag tag_heterogenous_mat;
          CHKERR op_ptr->getPtrFE()->mField.get_moab().tag_get_handle(
              EshelbianCore::heterogeneousYoungModTagName.c_str(),
              tag_heterogenous_mat);
          int tag_length;
          CHKERR op_ptr->getPtrFE()->mField.get_moab().tag_get_length(
              tag_heterogenous_mat, tag_length);
          if (tag_length != 1) {
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                    "heterogeneous Young's modulus tag should be 1 but is %d",
                    tag_length);
          }
          if (EshelbianCore::meshTransferInterpOrder == 0) {
            // Constant interpolation (element-wise)
            double elem_young_mod = 0.0;
            CHKERR op_ptr->getPtrFE()->mField.get_moab().tag_get_data(
                tag_heterogenous_mat, &fe_ent, 1, &elem_young_mod);
 
            for (int gg = 0; gg != nb_integration_pts; ++gg) {
              const auto material_params =
                  getMaterialParams(elem_young_mod, b.poissonRatio);
              t_young_modulus = material_params.youngModulus;
              t_mu = material_params.shearModulusG;
              t_lambda = material_params.lambda;
 
              CHKERR evalMatD(material_params.bulkModulusK,
                              material_params.shearModulusG);
              CHKERR evalInvMatDPtr(material_params.bulkModulusK,
                                    material_params.shearModulusG);
              next();
            }
          } else if (EshelbianCore::meshTransferInterpOrder == 1) {
            // Linear interpolation (vertex-based)
            const EntityHandle *vert_conn;
            int vert_num;
            CHKERR op_ptr->getPtrFE()->mField.get_moab().get_connectivity(
                fe_ent, vert_conn, vert_num, true);
 
            VectorDouble vert_young_mod(vert_num);
            CHKERR op_ptr->getPtrFE()->mField.get_moab().tag_get_data(
                tag_heterogenous_mat, vert_conn, vert_num, &vert_young_mod[0]);
 
            auto t_shape_n = data.getFTensor0N();
            int nb_shape_fn = data.getN(NOBASE).size2();
 
            for (int gg = 0; gg != nb_integration_pts; ++gg) {
              t_young_modulus = 0; // Initialize to zero before accumulation
              auto t_vert_young_mod = getFTensor0FromVec(vert_young_mod);
              for (int bb = 0; bb != nb_shape_fn; ++bb) {
                t_young_modulus += t_vert_young_mod * t_shape_n;
                ++t_vert_young_mod;
                ++t_shape_n;
              }
              const auto material_params =
                  getMaterialParams(t_young_modulus, b.poissonRatio);
              t_young_modulus = material_params.youngModulus;
              t_mu = material_params.shearModulusG;
              t_lambda = material_params.lambda;
 
              CHKERR evalMatD(material_params.bulkModulusK,
                              material_params.shearModulusG);
              CHKERR evalInvMatDPtr(material_params.bulkModulusK,
                                    material_params.shearModulusG);
              next();
            }
          } else {
            SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                    "Unsupported heterogeneous Young's modulus interpolation "
                    "order %d",
                    EshelbianCore::meshTransferInterpOrder);
          }
        } else {
          // MAT_ELASTIC block with homogeneous material properties
          for (int gg = 0; gg != nb_integration_pts; ++gg) {
            t_young_modulus = b.youngModulus;
            t_mu = b.shearModulusG;
            t_lambda = b.bulkModulusK - 2 * b.shearModulusG / 3;
 
            CHKERR evalMatD(b.bulkModulusK, b.shearModulusG);
            CHKERR evalInvMatDPtr(b.bulkModulusK, b.shearModulusG);
            next();
          }
        }
        MoFEMFunctionReturnHot(0);
      }
    }
 
    // From command line options if no block data is provided
    const auto material_params = getMaterialParams(this->E, this->nu);
 
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
      t_young_modulus = material_params.youngModulus;
      t_mu = material_params.shearModulusG;
      t_lambda = material_params.lambda;
      CHKERR evalMatD(material_params.bulkModulusK,
                      material_params.shearModulusG);
      CHKERR evalInvMatDPtr(material_params.bulkModulusK,
                            material_params.shearModulusG);
      next();
    }
 
    MoFEMFunctionReturn(0);
  }

extractBlockData() [1/2]

MoFEMErrorCode EshelbianPlasticity::HMHHencky::extractBlockData ( Sev  sev )

inline

Definition at line 307 of file HMHHencky.cpp.

                                           {
    return extractBlockData(
 
        mField.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
            (boost::format("(.*)%s(.*)") % "_ELASTIC").str()
 
                )),
 
        sev);
  }

extractBlockData() [2/2]

MoFEMErrorCode EshelbianPlasticity::HMHHencky::extractBlockData ( std::vector< const CubitMeshSets * >  meshset_vec_ptr, Sev  sev  )

inline

Definition at line 320 of file HMHHencky.cpp.

                            {
    MoFEMFunctionBegin;
 
    for (auto m : meshset_vec_ptr) {
      MOFEM_TAG_AND_LOG("WORLD", sev, "MatBlock") << *m;
      std::string block_name = m->getName();
 
      auto block_name_heterogeneous = "(.*)HETEROGENEOUS_ELASTIC(.*)";
      auto block_name_analytical = "(.*)ANALYTICAL_ELASTIC(.*)";
      std::regex reg_name_heterogeneous(block_name_heterogeneous);
      std::regex reg_name_analytical(block_name_analytical);
      const bool is_heterogeneous =
          std::regex_match(block_name, reg_name_heterogeneous);
      const bool is_analytical =
          std::regex_match(block_name, reg_name_analytical);
 
      std::vector<double> block_data;
      CHKERR m->getAttributes(block_data);
      if (block_data.size() < 2) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Expected that block has atleast two attributes");
      }
      auto get_block_ents = [&]() {
        Range ents;
        CHKERR mField.get_moab().get_entities_by_handle(m->meshset, ents, true);
        return ents;
      };
 
      double young_modulus = block_data[0];
      double poisson_ratio = block_data[1];
 
      HenckyMatType mat_type = HenckyMatType::HOMOGENEOUS;
      if (is_heterogeneous) {
        mat_type = HenckyMatType::HETEROGENEOUS;
      } else if (is_analytical) {
        mat_type = HenckyMatType::ANALYTICAL;
      }
 
      if (effectiveNehookeanStiffness &&
          mat_type == HenckyMatType::HOMOGENEOUS) {
        const auto effective_params = calc_effective_elastic_params(
            young_modulus, poisson_ratio, effectiveDiagonalStrain);
        young_modulus = effective_params.youngModulus;
        poisson_ratio = effective_params.poissonRatio;
      }
 
      double bulk_modulus_K = young_modulus / (3 * (1 - 2 * poisson_ratio));
      double shear_modulus_G = young_modulus / (2 * (1 + poisson_ratio));
 
      MOFEM_TAG_AND_LOG("WORLD", sev, "MatBlock")
          << "E = " << young_modulus << " nu = " << poisson_ratio;
 
      blockData.push_back({block_name, young_modulus, poisson_ratio,
                           bulk_modulus_K, shear_modulus_G, get_block_ents(),
                           mat_type});
    }
    MOFEM_LOG_CHANNEL("WORLD");
    MoFEMFunctionReturn(0);
  }

getOptions()

MoFEMErrorCode EshelbianPlasticity::HMHHencky::getOptions ( )

inline

Definition at line 276 of file HMHHencky.cpp.

                              {
    MoFEMFunctionBegin;
    PetscOptionsBegin(PETSC_COMM_WORLD, "hencky_", "", "none");
 
    CHKERR PetscOptionsScalar("-young_modulus", "Young modulus", "", E, &E,
                              PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-poisson_ratio", "poisson ratio", "", nu, &nu,
                              PETSC_NULLPTR);
    CHKERR PetscOptionsBool("-effective_neohookean_stiffness",
                            "Use effective Neo-Hookean stiffness", "",
                            effectiveNehookeanStiffness,
                            &effectiveNehookeanStiffness, PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-effective_diagonal_strain",
                              "Diagonal logarithmic strain for effective "
                              "Neo-Hookean stiffness",
                              "", effectiveDiagonalStrain,
                              &effectiveDiagonalStrain, PETSC_NULLPTR);
 
    PetscOptionsEnd();
 
    MOFEM_LOG("EP", Sev::inform)
        << "Hencky: E = " << E << " nu = " << nu
        << " effective_neohookean_stiffness = "
        << (effectiveNehookeanStiffness ? "true" : "false")
        << " effective_diagonal_strain = " << effectiveDiagonalStrain;
 
    CHKERRG(ierr);
 
    MoFEMFunctionReturn(0);
  }

providesHelmholtzFreeEnergy()

bool EshelbianPlasticity::HMHHencky::providesHelmholtzFreeEnergy ( ) const

inlineoverridevirtual

True when the material supplies its Helmholtz free energy.

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 211 of file HMHHencky.cpp.

{ return true; }

returnOpCalculateHelmholtzFreeEnergy()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 198 of file HMHHencky.cpp.

                                                                        {
 
    if (getFeatures().test(NON_HOMOGENEOUS_MATERIAL)) {
      return new OpCalculateHelmholtzFreeEnergy<StrideMatD>(
          data_ptr, total_helmholtz_free_energy_ptr);
    } else {
      return new OpCalculateHelmholtzFreeEnergy<0>(
          data_ptr, total_helmholtz_free_energy_ptr);
    }
  }

returnOpCalculateStretchFromStress() [1/2]

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 230 of file HMHHencky.cpp.

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

returnOpCalculateStretchFromStress() [2/2]

VolUserDataOperator * EshelbianPlasticity::HMHHencky::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  )

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 239 of file HMHHencky.cpp.

                                                {
    auto hencky_ptr = boost::dynamic_pointer_cast<HMHHencky>(physics_ptr);
 
    if (getFeatures().test(NON_HOMOGENEOUS_MATERIAL)) {
      return new OpCalculateStretchFromStress<StrideMatD>(
          data_ptr,
          strain_ptr ? strain_ptr : data_ptr->getLogStretchTensorAtPts(),
          stress_ptr ? stress_ptr : data_ptr->getApproxPAtPts(), hencky_ptr);
    } else {
      return new OpCalculateStretchFromStress<0>(
          data_ptr,
          strain_ptr ? strain_ptr : data_ptr->getLogStretchTensorAtPts(),
          stress_ptr ? stress_ptr : data_ptr->getApproxPAtPts(), hencky_ptr);
    }
  }

returnOpCalculateVarStretchFromStress()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 260 of file HMHHencky.cpp.

                                                               {
    auto hencky_ptr = boost::dynamic_pointer_cast<HMHHencky>(physics_ptr);
 
    if (getFeatures().test(NON_HOMOGENEOUS_MATERIAL)) {
      return new OpCalculateStretchFromStress<StrideMatD>(
          data_ptr, data_ptr->getVarLogStreachPts(), data_ptr->getVarPiolaPts(),
          hencky_ptr);
    } else {
      return new OpCalculateStretchFromStress<0>(
          data_ptr, data_ptr->getVarLogStreachPts(), data_ptr->getVarPiolaPts(),
          hencky_ptr);
    }
  }

returnOpJacobian()

UserDataOperator * EshelbianPlasticity::HMHHencky::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 84 of file HMHHencky.cpp.

                                                                            {
 
    auto hencky_ptr = boost::dynamic_pointer_cast<HMHHencky>(physics_ptr);
 
    if (getFeatures().test(NON_HOMOGENEOUS_MATERIAL))
      return new OpHenckyJacobian<StrideMatD>(data_ptr, hencky_ptr);
    return new OpHenckyJacobian<0>(data_ptr, hencky_ptr);
  }

returnOpSpatialPhysical()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 111 of file HMHHencky.cpp.

                                                         {
    if (getFeatures().test(NON_HOMOGENEOUS_MATERIAL)) {
      return new OpSpatialPhysical<StrideMatD>(field_name, data_ptr, alpha_u);
    } else {
      return new OpSpatialPhysical<0>(field_name, data_ptr, alpha_u);
    }
  }

returnOpSpatialPhysical_du_du()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 157 of file HMHHencky.cpp.

                                   {
 
    if (getFeatures().test(NON_HOMOGENEOUS_MATERIAL)) {
      return new OpSpatialPhysical_du_du<StrideMatD>(row_field, col_field,
                                                     data_ptr, alpha);
    } else {
      return new OpSpatialPhysical_du_du<0>(row_field, col_field, data_ptr,
                                            alpha);
    }
  }

returnOpSpatialPhysicalExternalStrain()

VolUserDataOperator * EshelbianPlasticity::HMHHencky::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  )

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 135 of file HMHHencky.cpp.

                                                                      {
    return new OpSpatialPhysicalExternalStrain(field_name, data_ptr,
                                               external_strain_vec_ptr, smv);
  }

returnOpTopoSpatialPhysical()

virtual VolUserDataOperator * EshelbianPlasticity::HMHHencky::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  )

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 634 of file HMHHencky.cpp.

                                                                      {
    return new OpTopoSpatialPhysical(field_name, data_ptr, assemble_vec,
                                     topo_ptr, alpha_u, J_ptr);
  }

Member Data Documentation

blockData

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

private

Definition at line 657 of file HMHHencky.cpp.

E

double EshelbianPlasticity::HMHHencky::E

private

Definition at line 659 of file HMHHencky.cpp.

effectiveDiagonalStrain

double EshelbianPlasticity::HMHHencky::effectiveDiagonalStrain = 0

private

Definition at line 662 of file HMHHencky.cpp.

effectiveNehookeanStiffness

PetscBool EshelbianPlasticity::HMHHencky::effectiveNehookeanStiffness = PETSC_FALSE

private

Definition at line 661 of file HMHHencky.cpp.

mField

MoFEM::Interface& EshelbianPlasticity::HMHHencky::mField

private

Definition at line 645 of file HMHHencky.cpp.

nu

double EshelbianPlasticity::HMHHencky::nu

private

Definition at line 660 of file HMHHencky.cpp.

StrideMatD

constexpr int EshelbianPlasticity::HMHHencky::StrideMatD

staticconstexpr

Initial value:

=
      DataAtIntegrationPts::SizeSymm * DataAtIntegrationPts::SizeSymm

Definition at line 55 of file HMHHencky.cpp.

---

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

• users_modules/eshelbian_plasticity/src/impl/HMHHencky.cpp