Inheritance diagram for EshelbianPlasticity::HMHStorakers:

Collaboration diagram for EshelbianPlasticity::HMHStorakers:

Classes
struct	BlockData

struct	DerivedParameters

struct	MaterialParameters

struct	OpCalculateStretchFromStress
	Evaluate Storakers stretch and its tangent from the supplied stress. More...

struct	OpJacobian

struct	OpSpatialPhysical
	Assemble the full-order equation conjugate to H = log(U) More...

struct	OpSpatialPhysical_du_du
	Assemble the consistent full-order H–H tangent. More...

struct	OpSpatialPhysicalExternalStrain
	Assemble the isotropic external-strain contribution. More...

struct	StressToStrech
	Recover the right stretch from a symmetric Biot stress. More...

Public Member Functions
	HMHStorakers (MoFEM::Interface &m_field, const double eta, const double mu, const double beta)

MaterialParameters	getMaterialParameters (const EntityHandle ent) const

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

MoFEMErrorCode	getOptions ()

MoFEMErrorCode	extractBlockData (const Sev sev)

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

VolUserDataOperator *	returnOpSpatialPhysical (const std::string &field_name, 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_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 *	returnOpCalculateExternalPressure (VectorPtr external_pressure_ptr, boost::shared_ptr< ExternalStrainVec > external_strain_vec_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv) 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, VectorPtr external_pressure_ptr) override

Public Member Functions inherited from EshelbianPlasticity::PhysicalEquations
	PhysicalEquations ()=default

virtual	~PhysicalEquations ()=default

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

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

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

Static Public Member Functions
static DerivedParameters	getDerivedParameters (const double mu, const double beta)

static double	getMu1 (const MaterialParameters &parameters)

static double	getMu2 (const MaterialParameters &parameters)

template<typename T >
static double	getLogJacobian (T &principal_hencky_stretches)

template<typename T >
static double	getJacobianPower (const MaterialParameters &parameters, T &principal_hencky_stretches)

static double	getGamma (const MaterialParameters &parameters, const double jacobian_power)

static double	getGammaY (const MaterialParameters &parameters, const double jacobian_power)

static double	getPrincipalCoordinateStress (const MaterialParameters &parameters, const double gamma, const double hencky_stretch)

static double	getPrincipalCoordinateStressDerivativeAtFixedGamma (const MaterialParameters &parameters, const double hencky_stretch)

Static Private Member Functions
static MoFEMErrorCode	validateParameters (const MaterialParameters &parameters, const char *source)

Private Attributes
MoFEM::Interface &	mField

MaterialParameters	defaultParameters

double	alphaGradU = 0

std::vector< BlockData >	blockData

Detailed Description

Definition at line 22 of file HMHStorakers.cpp.

Constructor & Destructor Documentation

◆ HMHStorakers()

EshelbianPlasticity::HMHStorakers::HMHStorakers	(	MoFEM::Interface &	m_field,
		const double	eta,
		const double	mu,
		const double	beta
	)

inline

Definition at line 35 of file HMHStorakers.cpp.

      : mField(m_field), defaultParameters{eta, mu, beta} {
    CHK_THROW_MESSAGE(getOptions(), "get options failed");
    CHK_THROW_MESSAGE(extractBlockData(Sev::inform),
                      "extract block data failed");
 
    if (EshelbianCore::isNoStretch()) {
      EshelbianCore::stretchHandling = EshelbianCore::NO_STREACH_NONLINEAR;
    }
    if (EshelbianCore::stretchSelector != StretchSelector::LOG) {
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Storakers requires natural logarithmic stretch");
    }
  }

Member Function Documentation

◆ extractBlockData() [1/2]

MoFEMErrorCode EshelbianPlasticity::HMHStorakers::extractBlockData ( const Sev sev )

inline

Definition at line 183 of file HMHStorakers.cpp.

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

◆ extractBlockData() [2/2]

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

inline

Definition at line 191 of file HMHStorakers.cpp.

                                  {
    MoFEMFunctionBegin;
 
    for (const auto meshset : meshset_vec_ptr) {
      MOFEM_LOG("EP", sev) << *meshset;
 
      std::vector<double> attributes;
      CHKERR meshset->getAttributes(attributes);
 
      const auto json_parameters =
          mField.getInterface<JsonConfigManager>()->getParamsFromBlockset(
              "MAT_STORAKES", meshset->getMeshsetId());
 
      MaterialParameters parameters{};
      if (!json_parameters.empty()) {
        if (json_parameters.size() != 3 ||
            json_parameters.find("eta") == json_parameters.end() ||
            json_parameters.find("mu") == json_parameters.end() ||
            json_parameters.find("beta") == json_parameters.end()) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "MAT_STORAKES JSON block must have exactly three "
                  "attributes: eta, mu, beta");
        }
        parameters = {json_parameters.at("eta"), json_parameters.at("mu"),
                      json_parameters.at("beta")};
      } else {
        if (attributes.size() != 3) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "MAT_STORAKES block must have exactly three attributes: "
                  "eta, mu, beta");
        }
        parameters = {attributes[0], attributes[1], attributes[2]};
      }
      CHKERR validateParameters(parameters, "MAT_STORAKES block");
 
      Range entities;
      CHKERR mField.get_moab().get_entities_by_handle(meshset->meshset,
                                                      entities, true);
      blockData.push_back(
          {parameters.eta, parameters.mu, parameters.beta, entities});
 
      const auto derived = getDerivedParameters(parameters.mu, parameters.beta);
      MOFEM_LOG("EP", sev) << "MatBlock Storakers: eta = " << parameters.eta
                           << ", mu = " << parameters.mu
                           << ", beta = " << parameters.beta
                           << ", K = " << derived.bulkModulus
                           << ", nu = " << derived.poissonRatio
                           << ", lambda_L = " << derived.lameLambda
                           << ", nb. entities = " << entities.size();
    }
 
    MoFEMFunctionReturn(0);
  }

◆ getDerivedParameters()

static DerivedParameters EshelbianPlasticity::HMHStorakers::getDerivedParameters	(	const double	mu,
		const double	beta
	)

inlinestatic

Definition at line 51 of file HMHStorakers.cpp.

                                                                   {
    return {
        2 * mu * (beta + 1. / 3.),
        beta / (1 + 2 * beta),
        2 * beta * mu,
    };
  }

◆ getGamma()

static double EshelbianPlasticity::HMHStorakers::getGamma	(	const MaterialParameters &	parameters,
		const double	jacobian_power
	)

inlinestatic

Definition at line 83 of file HMHStorakers.cpp.

                                                             {
    const double mu1 = getMu1(parameters);
    const double mu2 = getMu2(parameters);
    return 2 * mu1 * jacobian_power +
           mu2 * jacobian_power * jacobian_power;
  }

◆ getGammaY()

static double EshelbianPlasticity::HMHStorakers::getGammaY	(	const MaterialParameters &	parameters,
		const double	jacobian_power
	)

inlinestatic

Definition at line 91 of file HMHStorakers.cpp.

                                                              {
    const double mu1 = getMu1(parameters);
    const double mu2 = getMu2(parameters);
    return 2 * mu1 * jacobian_power +
           2 * mu2 * jacobian_power * jacobian_power;
  }

◆ getJacobianPower()

template<typename T >

static double EshelbianPlasticity::HMHStorakers::getJacobianPower	(	const MaterialParameters &	parameters,
		T &	principal_hencky_stretches
	)

inlinestatic

Definition at line 76 of file HMHStorakers.cpp.

                                     {
    return std::exp(-parameters.beta *
                    getLogJacobian(principal_hencky_stretches));
  }

◆ getLogJacobian()

template<typename T >

static double EshelbianPlasticity::HMHStorakers::getLogJacobian ( T & principal_hencky_stretches )

inlinestatic

Definition at line 69 of file HMHStorakers.cpp.

                                                                     {
    FTENSOR_INDEX(SPACE_DIM, i);
    constexpr auto t_one = FTensor::One<>();
    return principal_hencky_stretches(i) * t_one(i);
  }

◆ getMaterialParameters()

MaterialParameters EshelbianPlasticity::HMHStorakers::getMaterialParameters ( const EntityHandle ent ) const

inline

Definition at line 114 of file HMHStorakers.cpp.

                                                                         {
    for (const auto &block : blockData) {
      if (block.blockEnts.find(ent) != block.blockEnts.end()) {
        return {block.eta, block.mu, block.beta};
      }
    }
 
    if (!blockData.empty()) {
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Storakers material block not found for entity. If "
                        "blocks are used, assign all material entities");
    }
 
    return defaultParameters;
  }

◆ getMu1()

static double EshelbianPlasticity::HMHStorakers::getMu1 ( const MaterialParameters & parameters )

inlinestatic

Definition at line 60 of file HMHStorakers.cpp.

                                                                    {
    return (1 - parameters.eta) * parameters.mu;
  }

◆ getMu2()

static double EshelbianPlasticity::HMHStorakers::getMu2 ( const MaterialParameters & parameters )

inlinestatic

Definition at line 64 of file HMHStorakers.cpp.

                                                                    {
    return parameters.eta * parameters.mu;
  }

◆ getOptions()

MoFEMErrorCode EshelbianPlasticity::HMHStorakers::getOptions ( )

inline

Definition at line 144 of file HMHStorakers.cpp.

                              {
    MoFEMFunctionBegin;
 
    PetscOptionsBegin(PETSC_COMM_WORLD, "storakers_", "Storakers material",
                      "none");
    CHKERR PetscOptionsScalar("-eta", "Blend fraction eta", "",
                              defaultParameters.eta, &defaultParameters.eta,
                              PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-mu", "Infinitesimal shear modulus mu", "",
                              defaultParameters.mu, &defaultParameters.mu,
                              PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-beta", "Compressibility parameter beta", "",
                              defaultParameters.beta, &defaultParameters.beta,
                              PETSC_NULLPTR);
    alphaGradU = 0;
    CHKERR PetscOptionsScalar("-viscosity_alpha_grad_u", "viscosity", "",
                              alphaGradU, &alphaGradU, PETSC_NULLPTR);
    PetscOptionsEnd();
 
    CHKERR validateParameters(defaultParameters, "default options");
 
    const auto derived =
        getDerivedParameters(defaultParameters.mu, defaultParameters.beta);
    MOFEM_LOG("EP", Sev::inform)
        << "MatBlock Storakers (default): "
        << "eta = " << defaultParameters.eta
        << ", mu = " << defaultParameters.mu
        << ", beta = " << defaultParameters.beta
        << ", K = " << derived.bulkModulus << ", nu = " << derived.poissonRatio
        << ", lambda_L = " << derived.lameLambda
        << ", grad alpha u = " << alphaGradU;
    MOFEM_LOG("EP", Sev::inform)
        << "Storakers conversions: mu_1 = (1 - eta)*mu; mu_2 = eta*mu; "
           "lambda_L = 2*beta*mu; K = 2*mu*(beta + 1/3); "
           "nu = beta/(1 + 2*beta); beta = nu/(1 - 2*nu)";
 
    MoFEMFunctionReturn(0);
  }

◆ getPrincipalCoordinateStress()

static double EshelbianPlasticity::HMHStorakers::getPrincipalCoordinateStress	(	const MaterialParameters &	parameters,
		const double	gamma,
		const double	hencky_stretch
	)

inlinestatic

Definition at line 99 of file HMHStorakers.cpp.

                                   {
    const double stretch = std::exp(hencky_stretch);
    return 2 * getMu1(parameters) * stretch +
           getMu2(parameters) * stretch * stretch - gamma;
  }

◆ getPrincipalCoordinateStressDerivativeAtFixedGamma()

static double EshelbianPlasticity::HMHStorakers::getPrincipalCoordinateStressDerivativeAtFixedGamma	(	const MaterialParameters &	parameters,
		const double	hencky_stretch
	)

inlinestatic

Definition at line 107 of file HMHStorakers.cpp.

                                                                         {
    const double stretch = std::exp(hencky_stretch);
    return 2 * getMu1(parameters) * stretch +
           2 * getMu2(parameters) * stretch * stretch;
  }

◆ returnOpCalculateExternalPressure()

VolUserDataOperator * EshelbianPlasticity::HMHStorakers::returnOpCalculateExternalPressure	(	VectorPtr	external_pressure_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 1160 of file HMHStorakers.cpp.

                                                                      {
    return new OpCalculateExternalPressure(
        std::move(external_pressure_ptr),
        std::move(external_strain_vec_ptr), std::move(smv));
  }

◆ returnOpCalculateStretchFromStress() [1/2]

VolUserDataOperator * EshelbianPlasticity::HMHStorakers::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 1190 of file HMHStorakers.cpp.

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

◆ returnOpCalculateStretchFromStress() [2/2]

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 1199 of file HMHStorakers.cpp.

                                                {
    auto storakers_ptr = boost::dynamic_pointer_cast<HMHStorakers>(physics_ptr);
    if (!storakers_ptr) {
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Pointer to HMHStorakers is null");
    }
 
    return new OpCalculateStretchFromStress(
        data_ptr,
        strain_ptr ? strain_ptr : data_ptr->getLogStretchTensorAtPts(),
        data_ptr->getApproxPAtPts(), storakers_ptr,
        std::move(external_pressure_ptr));
  }

◆ returnOpJacobian()

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

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

◆ returnOpSpatialPhysical()

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

inlineoverridevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 267 of file HMHStorakers.cpp.

                                                         {
    return new OpSpatialPhysical(field_name, data_ptr, alpha_u);
  }

◆ returnOpSpatialPhysical_du_du()

VolUserDataOperator * EshelbianPlasticity::HMHStorakers::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 294 of file HMHStorakers.cpp.

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

◆ returnOpSpatialPhysicalExternalStrain()

VolUserDataOperator * EshelbianPlasticity::HMHStorakers::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 1151 of file HMHStorakers.cpp.

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

◆ validateParameters()

static MoFEMErrorCode EshelbianPlasticity::HMHStorakers::validateParameters	(	const MaterialParameters &	parameters,
		const char *	source
	)

inlinestaticprivate

Definition at line 1218 of file HMHStorakers.cpp.

                                                               {
    MoFEMFunctionBegin;
 
    if (!std::isfinite(parameters.eta) || parameters.eta <= 0 ||
        parameters.eta > 1) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Storakers eta must satisfy 0 < eta <= 1 in %s", source);
    }
    if (!std::isfinite(parameters.mu) || parameters.mu <= 0) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Storakers mu must be positive in %s", source);
    }
    if (!std::isfinite(parameters.beta) || parameters.beta <= 0) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Storakers beta must be positive in %s", source);
    }
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

◆ alphaGradU

double EshelbianPlasticity::HMHStorakers::alphaGradU = 0

private

Definition at line 1248 of file HMHStorakers.cpp.

◆ blockData

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

private

Definition at line 1249 of file HMHStorakers.cpp.

◆ defaultParameters

MaterialParameters EshelbianPlasticity::HMHStorakers::defaultParameters

private

Definition at line 1247 of file HMHStorakers.cpp.

◆ mField

MoFEM::Interface& EshelbianPlasticity::HMHStorakers::mField

private

Definition at line 1246 of file HMHStorakers.cpp.

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

users_modules/eshelbian_plasticity/src/impl/HMHStorakers.cpp

Classes

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ HMHStorakers()

Member Function Documentation

◆ extractBlockData() [1/2]

◆ extractBlockData() [2/2]

◆ getDerivedParameters()

◆ getGamma()

◆ getGammaY()

◆ getJacobianPower()

◆ getLogJacobian()

◆ getMaterialParameters()

◆ getMu1()

◆ getMu2()

◆ getOptions()

◆ getPrincipalCoordinateStress()

◆ getPrincipalCoordinateStressDerivativeAtFixedGamma()

◆ returnOpCalculateExternalPressure()

◆ returnOpCalculateStretchFromStress() [1/2]

◆ returnOpCalculateStretchFromStress() [2/2]

◆ returnOpJacobian()

◆ returnOpSpatialPhysical()

◆ returnOpSpatialPhysical_du_du()

◆ returnOpSpatialPhysicalExternalStrain()

◆ validateParameters()

Member Data Documentation

◆ alphaGradU

◆ blockData

◆ defaultParameters

◆ mField