Inheritance diagram for EshelbianPlasticity::HMHNeohookean:

Collaboration diagram for EshelbianPlasticity::HMHNeohookean:

Classes
struct	BlockData

struct	CalculateStretchFromStress
	Recover the stretch tensor from a prescribed Biot stress. More...

struct	OpCalculateStretchFromStress

struct	OpJacobian

struct	OpSpatialPhysical

struct	OpSpatialPhysical_du_du

struct	OpSpatialPhysicalExternalStrain

struct	PrincipalState

Public Member Functions
	HMHNeohookean (MoFEM::Interface &m_field, const double c10, const double K)

auto	getMaterialParameters (EntityHandle ent)

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

MoFEMErrorCode	getOptions ()

MoFEMErrorCode	extractBlockData (Sev sev)

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

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 *	returnOpCalculateExternalPressure (VectorPtr external_pressure_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)

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 double	getShearModulus (const double c10)

static double	getAbaqusD1 (const double K)

static MoFEMErrorCode	getCoordinateStretchFromStretch (const double stretch, double &coordinate_stretch)

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

template<typename T >
static PrincipalState	getPrincipalState (const double K, T &principal_coordinate_stretches)

static MoFEMErrorCode	validatePrincipalState (const PrincipalState &state, const char *source)

static double	getPrincipalCoordinateStress (const double c10, const PrincipalState &state, const double v)

static double	getPrincipalCoordinateStressDerivativeAtFixedInvariants (const double c10, const PrincipalState &state, const double v)

template<typename T >
static double	getStrainEnergy (const double c10, const double K, T &principal_coordinate_stretches)

static MoFEMErrorCode	validateMaterialParameters (const double c10, const double K, const char *source)

Private Attributes
MoFEM::Interface &	mField

double	c10_default

double	K_default

double	alphaGradU

double	lambdaMinU = 1e-4

double	lambdaMaxU = 1e4

double	betaStretchBoxMin = 1e-6

double	betaStretchBoxMax = 1e-8

std::vector< BlockData >	blockData

Detailed Description

Definition at line 39 of file HMHNeohookean.cpp.

Constructor & Destructor Documentation

◆ HMHNeohookean()

EshelbianPlasticity::HMHNeohookean::HMHNeohookean	(	MoFEM::Interface &	m_field,
		const double	c10,
		const double	K
	)

inline

Definition at line 157 of file HMHNeohookean.cpp.

      : PhysicalEquations(), mField(m_field), c10_default(c10), K_default(K) {
 
    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,
                        "Neo-Hookean requires natural logarithmic stretch");
    }
  }

Member Function Documentation

◆ extractBlockData() [1/2]

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

inline

Definition at line 226 of file HMHNeohookean.cpp.

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

◆ extractBlockData() [2/2]

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

inline

Definition at line 239 of file HMHNeohookean.cpp.

                            {
    MoFEMFunctionBegin;
 
    for (auto m : meshset_vec_ptr) {
      MOFEM_LOG("EP", sev) << *m;
      std::vector<double> block_data;
      CHKERR m->getAttributes(block_data);
      auto get_block_ents = [&]() {
        Range ents;
        CHKERR mField.get_moab().get_entities_by_handle(m->meshset, ents, true);
        return ents;
      };
 
      const auto json_parameters =
          mField.getInterface<JsonConfigManager>()->getParamsFromBlockset(
              "MAT_NEOHOOKEAN", m->getMeshsetId());
      double c10;
      double K;
      if (!json_parameters.empty()) {
        if (json_parameters.size() != 2 ||
            json_parameters.find("c10") == json_parameters.end() ||
            json_parameters.find("k") == json_parameters.end()) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "MAT_NEOHOOKEAN JSON block must have exactly two "
                  "attributes: c10, k");
        }
        c10 = json_parameters.at("c10");
        K = json_parameters.at("k");
      } else {
        if (block_data.size() < 2) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "MAT_NEOHOOKEAN block must have at least two attributes: "
                  "c10, K");
        }
        c10 = block_data[0];
        K = block_data[1];
      }
 
      CHKERR validateMaterialParameters(c10, K, "MAT_NEOHOOKEAN block");
 
      blockData.push_back({c10, K, get_block_ents()});
 
      MOFEM_LOG("EP", sev) << "MatBlock Neo-Hookean c10 = "
                           << blockData.back().c10
                           << " K = " << blockData.back().K
                           << " mu = " << getShearModulus(c10)
                           << " Abaqus D1 = " << getAbaqusD1(K)
                           << " nb ents. = "
                           << blockData.back().blockEnts.size();
    }
    MoFEMFunctionReturn(0);
  }

◆ getAbaqusD1()

static double EshelbianPlasticity::HMHNeohookean::getAbaqusD1 ( const double K )

inlinestatic

Definition at line 48 of file HMHNeohookean.cpp.

48{ return 2. / K; }

◆ getCoordinateStretchFromStretch()

static MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::getCoordinateStretchFromStretch	(	const double	stretch,
		double &	coordinate_stretch
	)

inlinestatic

Definition at line 59 of file HMHNeohookean.cpp.

                                                              {
    MoFEMFunctionBegin;
    if (!std::isfinite(stretch) || stretch <= 0.) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
              "Abaqus Neo-Hookean stretch must be finite and positive");
    }
    coordinate_stretch = std::log(stretch);
    if (!std::isfinite(coordinate_stretch)) {
      SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FP,
              "Non-finite Abaqus Neo-Hookean coordinate stretch");
    }
    MoFEMFunctionReturn(0);
  }

◆ getLogJacobian()

template<typename T >

static double EshelbianPlasticity::HMHNeohookean::getLogJacobian ( T & principal_coordinate_stretches )

inlinestatic

Definition at line 75 of file HMHNeohookean.cpp.

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

◆ getMaterialParameters()

auto EshelbianPlasticity::HMHNeohookean::getMaterialParameters ( EntityHandle ent )

inline

Definition at line 174 of file HMHNeohookean.cpp.

                                               {
    for (auto &b : blockData) {
      if (b.blockEnts.find(ent) != b.blockEnts.end()) {
        return std::make_pair(b.c10, b.K);
      }
    }
    if (blockData.size() != 0)
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Block not found for entity handle. If you mat set "
                        "block, set it to all elements");
    return std::make_pair(c10_default, K_default);
  }

◆ getOptions()

MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::getOptions ( )

inline

Definition at line 200 of file HMHNeohookean.cpp.

                              {
    MoFEMFunctionBegin;
    PetscOptionsBegin(PETSC_COMM_WORLD, "neo_hookean_", "", "none");
 
    CHKERR PetscOptionsScalar("-c10", "C10", "", c10_default, &c10_default,
                              PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-K", "Bulk modulus K", "", K_default, &K_default,
                              PETSC_NULLPTR);
 
    alphaGradU = 0;
    CHKERR PetscOptionsScalar("-viscosity_alpha_grad_u", "viscosity", "",
                              alphaGradU, &alphaGradU, PETSC_NULLPTR);
    PetscOptionsEnd();
 
    CHKERR validateMaterialParameters(c10_default, K_default,
                                      "default options");
 
    MOFEM_LOG_CHANNEL("WORLD");
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "MatBlock Neo-Hookean (default)")
        << " c10 = " << c10_default << " K = " << K_default
        << " mu = " << getShearModulus(c10_default)
        << " Abaqus D1 = " << getAbaqusD1(K_default)
        << " grad alpha u = " << alphaGradU;
    MoFEMFunctionReturn(0);
  }

◆ getPrincipalCoordinateStress()

static double EshelbianPlasticity::HMHNeohookean::getPrincipalCoordinateStress	(	const double	c10,
		const PrincipalState &	state,
		const double	v
	)

inlinestatic

Definition at line 116 of file HMHNeohookean.cpp.

                                                                    {
    const double squared_stretch = std::exp(2. * v);
    return getShearModulus(c10) * state.jacobianToMinusTwoThirds *
               (squared_stretch - state.firstInvariant / 3.) +
           state.volumetricStress;
  }

◆ getPrincipalCoordinateStressDerivativeAtFixedInvariants()

static double EshelbianPlasticity::HMHNeohookean::getPrincipalCoordinateStressDerivativeAtFixedInvariants	(	const double	c10,
		const PrincipalState &	state,
		const double	v
	)

inlinestatic

Definition at line 125 of file HMHNeohookean.cpp.

                                                                     {
    return 2. * getShearModulus(c10) * state.jacobianToMinusTwoThirds *
           std::exp(2. * v);
  }

◆ getPrincipalState()

template<typename T >

static PrincipalState EshelbianPlasticity::HMHNeohookean::getPrincipalState	(	const double	K,
		T &	principal_coordinate_stretches
	)

inlinestatic

Definition at line 83 of file HMHNeohookean.cpp.

                                                                       {
    FTENSOR_INDEX(SPACE_DIM, i);
    constexpr auto t_one = FTensor::One<>();
    const double log_jacobian = getLogJacobian(principal_coordinate_stretches);
    const double jacobian = std::exp(log_jacobian);
    const double jacobian_to_minus_two_thirds =
        std::exp((-2. / 3.) * log_jacobian);
    FTensor::Tensor1<double, SPACE_DIM> t_squared_stretches;
    for (int aa = 0; aa != SPACE_DIM; ++aa) {
      t_squared_stretches(aa) =
          std::exp(2. * principal_coordinate_stretches(aa));
    }
    const double first_invariant = t_squared_stretches(i) * t_one(i);
    return {jacobian, jacobian_to_minus_two_thirds, first_invariant,
            K * jacobian * (jacobian - 1.),
            K * jacobian * (2. * jacobian - 1.)};
  }

◆ getShearModulus()

static double EshelbianPlasticity::HMHNeohookean::getShearModulus ( const double c10 )

inlinestatic

Definition at line 46 of file HMHNeohookean.cpp.

46{ return 2. * c10; }

◆ getStrainEnergy()

template<typename T >

static double EshelbianPlasticity::HMHNeohookean::getStrainEnergy	(	const double	c10,
		const double	K,
		T &	principal_coordinate_stretches
	)

inlinestatic

Definition at line 132 of file HMHNeohookean.cpp.

                                                                          {
    const auto state = getPrincipalState(K, principal_coordinate_stretches);
    const double jacobian_minus_one = state.jacobian - 1.;
    return c10 * (state.jacobianToMinusTwoThirds * state.firstInvariant - 3.) +
           0.5 * K * jacobian_minus_one * jacobian_minus_one;
  }

◆ returnOpCalculateExternalPressure()

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

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

◆ returnOpCalculateStretchFromStress() [1/2]

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

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

◆ returnOpCalculateStretchFromStress() [2/2]

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

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

◆ returnOpJacobian()

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

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 194 of file HMHNeohookean.cpp.

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

◆ returnOpSpatialPhysical()

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

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 306 of file HMHNeohookean.cpp.

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

◆ returnOpSpatialPhysical_du_du()

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

inlinevirtual

Reimplemented from EshelbianPlasticity::PhysicalEquations.

Definition at line 357 of file HMHNeohookean.cpp.

                                                                          {
    return new OpSpatialPhysical_du_du(row_field, col_field, data_ptr, alpha);
  }

◆ returnOpSpatialPhysicalExternalStrain()

virtual VolUserDataOperator * EshelbianPlasticity::HMHNeohookean::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 327 of file HMHNeohookean.cpp.

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

◆ validateMaterialParameters()

static MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::validateMaterialParameters	(	const double	c10,
		const double	K,
		const char *	source
	)

inlinestatic

Definition at line 140 of file HMHNeohookean.cpp.

                                                                       {
    MoFEMFunctionBegin;
    if (!std::isfinite(c10) || c10 <= 0.) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
              "Neo-Hookean c10 must be finite and positive in %s", source);
    }
    if (!std::isfinite(K) || K <= 0.) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
              "Abaqus Neo-Hookean K must be finite and positive in %s "
              "(received c10=%.16g, K=%.16g)",
              source, c10, K);
    }
    MoFEMFunctionReturn(0);
  }

◆ validatePrincipalState()

static MoFEMErrorCode EshelbianPlasticity::HMHNeohookean::validatePrincipalState	(	const PrincipalState &	state,
		const char *	source
	)

inlinestatic

Definition at line 101 of file HMHNeohookean.cpp.

                                                                   {
    MoFEMFunctionBegin;
    if (!std::isfinite(state.jacobian) || state.jacobian <= 0. ||
        !std::isfinite(state.jacobianToMinusTwoThirds) ||
        state.jacobianToMinusTwoThirds <= 0. ||
        !std::isfinite(state.firstInvariant) || state.firstInvariant <= 0. ||
        !std::isfinite(state.volumetricStress) ||
        !std::isfinite(state.volumetricTangent)) {
      SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FP,
              "Non-finite Abaqus Neo-Hookean principal state in %s", source);
    }
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

◆ alphaGradU

double EshelbianPlasticity::HMHNeohookean::alphaGradU

private

Definition at line 481 of file HMHNeohookean.cpp.

◆ betaStretchBoxMax

double EshelbianPlasticity::HMHNeohookean::betaStretchBoxMax = 1e-8

private

Definition at line 485 of file HMHNeohookean.cpp.

◆ betaStretchBoxMin

double EshelbianPlasticity::HMHNeohookean::betaStretchBoxMin = 1e-6

private

Definition at line 484 of file HMHNeohookean.cpp.

◆ blockData

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

private

Definition at line 491 of file HMHNeohookean.cpp.

◆ c10_default

double EshelbianPlasticity::HMHNeohookean::c10_default

private

Definition at line 479 of file HMHNeohookean.cpp.

◆ K_default

double EshelbianPlasticity::HMHNeohookean::K_default

private

Definition at line 480 of file HMHNeohookean.cpp.

◆ lambdaMaxU

double EshelbianPlasticity::HMHNeohookean::lambdaMaxU = 1e4

private

Definition at line 483 of file HMHNeohookean.cpp.

◆ lambdaMinU

double EshelbianPlasticity::HMHNeohookean::lambdaMinU = 1e-4

private

Definition at line 482 of file HMHNeohookean.cpp.

◆ mField

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

private

Definition at line 477 of file HMHNeohookean.cpp.

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

users_modules/eshelbian_plasticity/src/impl/HMHNeohookean.cpp

Classes

Public Member Functions

Static Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ HMHNeohookean()

Member Function Documentation

◆ extractBlockData() [1/2]

◆ extractBlockData() [2/2]

◆ getAbaqusD1()

◆ getCoordinateStretchFromStretch()

◆ getLogJacobian()

◆ getMaterialParameters()

◆ getOptions()

◆ getPrincipalCoordinateStress()

◆ getPrincipalCoordinateStressDerivativeAtFixedInvariants()

◆ getPrincipalState()

◆ getShearModulus()

◆ getStrainEnergy()

◆ returnOpCalculateExternalPressure()

◆ returnOpCalculateStretchFromStress() [1/2]

◆ returnOpCalculateStretchFromStress() [2/2]

◆ returnOpJacobian()

◆ returnOpSpatialPhysical()

◆ returnOpSpatialPhysical_du_du()

◆ returnOpSpatialPhysicalExternalStrain()

◆ validateMaterialParameters()

◆ validatePrincipalState()

Member Data Documentation

◆ alphaGradU

◆ betaStretchBoxMax

◆ betaStretchBoxMin

◆ blockData

◆ c10_default

◆ K_default

◆ lambdaMaxU

◆ lambdaMinU

◆ mField