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

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

Detailed Description

Definition at line 12 of file HMHHencky.cpp.

Member Enumeration Documentation

HenckyMatType

enum EshelbianPlasticity::HMHHencky::HenckyMatType

private

Enumerator
HOMOGENEOUS
HETEROGENEOUS
ANALYTICAL

Definition at line 626 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 14 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 354 of file HMHHencky.cpp.

                                                            {
    MoFEMFunctionBegin;
 
    auto getLamesParam = [](double E, double nu) {
      double bulk_modulus_K = E / (3 * (1 - 2 * nu));
      double shear_modulus_G = E / (2 * (1 + nu));
      double mu = shear_modulus_G;
      double lambda = bulk_modulus_K - 2 * shear_modulus_G / 3;
      return std::make_pair(mu, 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) {
            t_young_modulus = t_analytical_elastic;
            double bulk_modulus_K =
                t_analytical_elastic / (3 * (1 - 2 * b.poissonRatio));
            double shear_modulus_G =
                t_analytical_elastic / (2 * (1 + b.poissonRatio));
            t_mu = shear_modulus_G;
            t_lambda = bulk_modulus_K - 2 * shear_modulus_G / 3;
 
            CHKERR evalMatD(bulk_modulus_K, shear_modulus_G);
            CHKERR evalInvMatDPtr(bulk_modulus_K, shear_modulus_G);
            ++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) {
              t_young_modulus = elem_young_mod;
              auto [mu, lambda] = getLamesParam(elem_young_mod, b.poissonRatio);
              t_mu = mu;
              t_lambda = lambda;
              double bulk_modulus_K =
                  elem_young_mod / (3 * (1 - 2 * b.poissonRatio));
              double shear_modulus_G =
                  elem_young_mod / (2 * (1 + b.poissonRatio));
 
              CHKERR evalMatD(bulk_modulus_K, shear_modulus_G);
              CHKERR evalInvMatDPtr(bulk_modulus_K, shear_modulus_G);
              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;
              }
              auto [mu, lambda] =
                  getLamesParam(t_young_modulus, b.poissonRatio);
              t_mu = mu;
              t_lambda = lambda;
              double bulk_modulus_K =
                  t_young_modulus / (3 * (1 - 2 * b.poissonRatio));
              double shear_modulus_G =
                  t_young_modulus / (2 * (1 + b.poissonRatio));
 
              CHKERR evalMatD(bulk_modulus_K, shear_modulus_G);
              CHKERR evalInvMatDPtr(bulk_modulus_K, shear_modulus_G);
              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 E = this->E;
    const auto nu = this->nu;
 
    double bulk_modulus_K = E / (3 * (1 - 2 * nu));
    double shear_modulus_G = E / (2 * (1 + nu));
 
    // Keep scalar Lamé parameters in sync for homogeneous/default material.
    dataAtGaussPts->mu = shear_modulus_G;
    dataAtGaussPts->lambda = bulk_modulus_K - 2 * shear_modulus_G / 3;
 
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
      t_young_modulus = E;
      t_mu = shear_modulus_G;
      t_lambda = bulk_modulus_K - 2 * shear_modulus_G / 3;
      CHKERR evalMatD(bulk_modulus_K, shear_modulus_G);
      CHKERR evalInvMatDPtr(bulk_modulus_K, shear_modulus_G);
      next();
    }
 
    MoFEMFunctionReturn(0);
  }

extractBlockData() [1/2]

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

inline

Definition at line 292 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 305 of file HMHHencky.cpp.

                            {
    MoFEMFunctionBegin;
 
    for (auto m : meshset_vec_ptr) {
      MOFEM_TAG_AND_LOG("WORLD", sev, "MatBlock") << *m;
      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];
      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;
 
      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);
 
      HenckyMatType mat_type = HenckyMatType::HOMOGENEOUS;
      if (std::regex_match(block_name, reg_name_heterogeneous)) {
        mat_type = HenckyMatType::HETEROGENEOUS;
      } else if (std::regex_match(block_name, reg_name_analytical)) {
        mat_type = HenckyMatType::ANALYTICAL;
      }
 
      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 272 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);
 
    PetscOptionsEnd();
 
    MOFEM_LOG("EP", getOptionsSeverityLevels)
        << "Hencky: E = " << E << " nu = " << nu;
    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 183 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  )

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 210 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->getLogStretchTensorAtPts(),
          data_ptr->getApproxPAtPts(),
          boost::dynamic_pointer_cast<HMHHencky>(physics_ptr));
    } else {
      return new OpCalculateStretchFromStress<0>(
          data_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 242 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 46 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 94 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 144 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 118 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 613 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 636 of file HMHHencky.cpp.

E

double EshelbianPlasticity::HMHHencky::E

private

Definition at line 638 of file HMHHencky.cpp.

getOptionsSeverityLevels

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

private

Definition at line 643 of file HMHHencky.cpp.

mField

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

private

Definition at line 624 of file HMHHencky.cpp.

nu

double EshelbianPlasticity::HMHHencky::nu

private

Definition at line 639 of file HMHHencky.cpp.

StrideMatD

constexpr int EshelbianPlasticity::HMHHencky::StrideMatD

staticconstexpr

Initial value:

=
      DataAtIntegrationPts::SizeSymm * DataAtIntegrationPts::SizeSymm

Definition at line 17 of file HMHHencky.cpp.

---

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

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