EshelbianPlasticity::HMHHencky Struct Reference

Inheritance diagram for EshelbianPlasticity::HMHHencky:

Collaboration diagram for EshelbianPlasticity::HMHHencky:

Classes
struct	BlockData
struct	OpCalculateEnergy
	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)
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)
VolUserDataOperator *	returnOpSpatialPhysical_du_du (std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha)
VolUserDataOperator *	returnOpCalculateEnergy (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< double > total_energy_ptr)
VolUserDataOperator *	returnOpCalculateStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr, boost::shared_ptr< MatrixDouble > strain_ptr) override
VolUserDataOperator *	returnOpCalculateVarStretchFromStress (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr)
MoFEMErrorCode	getOptions (boost::shared_ptr< DataAtIntegrationPts > data_ptr)
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 ()=default
virtual	~PhysicalEquations ()=default
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

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
Sev	getOptionsSeverityLevels = Sev::inform

Detailed Description

Definition at line 59 of file HMHHencky.cpp.

Member Enumeration Documentation

HenckyMatType

enum EshelbianPlasticity::HMHHencky::HenckyMatType

private

Enumerator
HOMOGENEOUS
HETEROGENEOUS
ANALYTICAL

Definition at line 701 of file HMHHencky.cpp.

{ HOMOGENEOUS, HETEROGENEOUS, ANALYTICAL };

Constructor & Destructor Documentation

HMHHencky()

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

inline

Definition at line 61 of file HMHHencky.cpp.

      : PhysicalEquations(), mField(m_field), E(E), nu(nu) {}

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 429 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);
 
    // Keep scalar Lamé parameters in sync for homogeneous/default material.
    dataAtGaussPts->mu = material_params.shearModulusG;
    dataAtGaussPts->lambda = material_params.lambda;
 
    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 354 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 367 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 ( boost::shared_ptr< DataAtIntegrationPts >  data_ptr )

inline

Definition at line 322 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", getOptionsSeverityLevels)
        << "Hencky: E = " << E << " nu = " << nu
        << " effective_neohookean_stiffness = "
        << (effectiveNehookeanStiffness ? "true" : "false")
        << " effective_diagonal_strain = " << effectiveDiagonalStrain;
    getOptionsSeverityLevels = Sev::verbose;
 
    CHKERRG(ierr);
 
    MoFEMFunctionReturn(0);
  }

returnOpCalculateEnergy()

VolUserDataOperator * EshelbianPlasticity::HMHHencky::returnOpCalculateEnergy ( boost::shared_ptr< DataAtIntegrationPts >  data_ptr, boost::shared_ptr< double >  total_energy_ptr  )

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 230 of file HMHHencky.cpp.

                                                                    {
 
    if (EshelbianCore::hasNonHomogeneousMaterialBlock) {
      return new OpCalculateEnergy<StrideMatD>(data_ptr, total_energy_ptr);
    } else {
      return new OpCalculateEnergy<0>(data_ptr, total_energy_ptr);
    }
  }

returnOpCalculateStretchFromStress()

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 257 of file HMHHencky.cpp.

                                                         {
    auto henckyPtr = boost::dynamic_pointer_cast<HMHHencky>(physics_ptr);
 
    CHK_THROW_MESSAGE(henckyPtr->getOptions(data_ptr), "getOptions failed");
    CHK_THROW_MESSAGE(henckyPtr->extractBlockData(Sev::verbose),
                      "Can not get data from block");
 
    // Check if any heterogeneous or analytical block exists
    for (const auto &b : henckyPtr->blockData) {
      if (b.matType != HenckyMatType::HOMOGENEOUS) {
        EshelbianCore::hasNonHomogeneousMaterialBlock = true;
        MOFEM_LOG("WORLD", Sev::verbose)
            << "Found non-homogeneous material block: " << b.blockName;
        break;
      }
    }
 
    if (EshelbianCore::hasNonHomogeneousMaterialBlock) {
      return new OpCalculateStretchFromStress<StrideMatD>(
          data_ptr,
          strain_ptr ? strain_ptr : data_ptr->getLogStretchTensorAtPts(),
          data_ptr->getApproxPAtPts(),
          boost::dynamic_pointer_cast<HMHHencky>(physics_ptr));
    } else {
      return new OpCalculateStretchFromStress<0>(
          data_ptr,
          strain_ptr ? strain_ptr : data_ptr->getLogStretchTensorAtPts(),
          data_ptr->getApproxPAtPts(),
          boost::dynamic_pointer_cast<HMHHencky>(physics_ptr));
    }
  }

returnOpCalculateVarStretchFromStress()

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

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 292 of file HMHHencky.cpp.

                                                      {
    auto henckyPtr = boost::dynamic_pointer_cast<HMHHencky>(physics_ptr);
 
    CHK_THROW_MESSAGE(henckyPtr->getOptions(data_ptr), "getOptions failed");
    CHK_THROW_MESSAGE(henckyPtr->extractBlockData(Sev::verbose),
                      "Can not get data from block");
 
    // Check if any heterogeneous or analytical block exists
    for (const auto &b : henckyPtr->blockData) {
      if (b.matType != HenckyMatType::HOMOGENEOUS) {
        EshelbianCore::hasNonHomogeneousMaterialBlock = true;
        MOFEM_LOG("WORLD", Sev::verbose)
            << "Found non-homogeneous material block: " << b.blockName;
        break;
      }
    }
 
    if (EshelbianCore::hasNonHomogeneousMaterialBlock) {
      return new OpCalculateStretchFromStress<StrideMatD>(
          data_ptr, data_ptr->getVarLogStreachPts(), data_ptr->getVarPiolaPts(),
          boost::dynamic_pointer_cast<HMHHencky>(physics_ptr));
    } else {
      return new OpCalculateStretchFromStress<0>(
          data_ptr, data_ptr->getVarLogStreachPts(), data_ptr->getVarPiolaPts(),
          boost::dynamic_pointer_cast<HMHHencky>(physics_ptr));
    }
  }

returnOpJacobian()

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

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 93 of file HMHHencky.cpp.

                                                                   {
 
    auto henckyPtr = boost::dynamic_pointer_cast<HMHHencky>(physics_ptr);
 
    CHK_THROW_MESSAGE(henckyPtr->getOptions(data_ptr), "getOptions failed");
    CHK_THROW_MESSAGE(henckyPtr->extractBlockData(Sev::verbose),
                      "Can not get data from block");
 
    // Check if any heterogeneous or analytical block exists
    for (const auto &b : henckyPtr->blockData) {
      if (b.matType != HenckyMatType::HOMOGENEOUS) {
        EshelbianCore::hasNonHomogeneousMaterialBlock = true;
        MOFEM_LOG("WORLD", Sev::verbose)
            << "Found non-homogeneous material block: " << b.blockName;
        break;
      }
    }
 
    if (EshelbianCore::hasNonHomogeneousMaterialBlock) {
      return (new OpHenckyJacobian<StrideMatD>(
          data_ptr, boost::dynamic_pointer_cast<HMHHencky>(physics_ptr)));
    } else {
      return (new OpHenckyJacobian<0>(
          data_ptr, boost::dynamic_pointer_cast<HMHHencky>(physics_ptr)));
    }
  }

returnOpSpatialPhysical()

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

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 141 of file HMHHencky.cpp.

                                                {
    if (EshelbianCore::hasNonHomogeneousMaterialBlock) {
      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  )

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 191 of file HMHHencky.cpp.

                                                                          {
 
    if (EshelbianCore::hasNonHomogeneousMaterialBlock) {
      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()

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

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 165 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 688 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 711 of file HMHHencky.cpp.

E

double EshelbianPlasticity::HMHHencky::E

private

Definition at line 713 of file HMHHencky.cpp.

effectiveDiagonalStrain

double EshelbianPlasticity::HMHHencky::effectiveDiagonalStrain = 0

private

Definition at line 716 of file HMHHencky.cpp.

effectiveNehookeanStiffness

PetscBool EshelbianPlasticity::HMHHencky::effectiveNehookeanStiffness = PETSC_FALSE

private

Definition at line 715 of file HMHHencky.cpp.

getOptionsSeverityLevels

Sev EshelbianPlasticity::HMHHencky::getOptionsSeverityLevels = Sev::inform

private

Definition at line 720 of file HMHHencky.cpp.

mField

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

private

Definition at line 699 of file HMHHencky.cpp.

nu

double EshelbianPlasticity::HMHHencky::nu

private

Definition at line 714 of file HMHHencky.cpp.

StrideMatD

constexpr int EshelbianPlasticity::HMHHencky::StrideMatD

staticconstexpr

Initial value:

=
      DataAtIntegrationPts::SizeSymm * DataAtIntegrationPts::SizeSymm

Definition at line 64 of file HMHHencky.cpp.

---

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

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