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

Public Member Functions
	HMHHencky (MoFEM::Interface &m_field, const double E, const double nu)

MoFEMErrorCode	recordTape (const int tag, DTensor2Ptr *t_h)

virtual UserDataOperator *	returnOpJacobian (const int tag, 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)

MoFEMErrorCode	getMatDPtr (boost::shared_ptr< MatrixDouble > mat_D_ptr, boost::shared_ptr< MatrixDouble > mat_axiator_D_ptr, boost::shared_ptr< MatrixDouble > mat_deviator_D_ptr, double bulk_modulus_K, double shear_modulus_G)

MoFEMErrorCode	getInvMatDPtr (boost::shared_ptr< MatrixDouble > mat_inv_D_ptr, double bulk_modulus_K, double shear_modulus_G)

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

	PhysicalEquations (const int size_active, const int size_dependent)

virtual	~PhysicalEquations ()=default

virtual VolUserDataOperator *	returnOpSetScale (boost::shared_ptr< double > scale_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr)

DTensor2Ptr	get_P ()

DTensor3Ptr	get_P_dh0 ()

DTensor3Ptr	get_P_dh1 ()

DTensor3Ptr	get_P_dh2 ()

DTensor2Ptr	get_h ()

Private Attributes
MoFEM::Interface &	mField

std::vector< BlockData >	blockData

double	E

double	nu

Sev	getOptionsSeverityLevels = Sev::inform

Additional Inherited Members
Public Types inherited from EshelbianPlasticity::PhysicalEquations
typedef FTensor::Tensor1< adouble, 3 >	ATensor1

typedef FTensor::Tensor2< adouble, 3, 3 >	ATensor2

typedef FTensor::Tensor3< adouble, 3, 3, 3 >	ATensor3

typedef FTensor::Tensor1< double, 3 >	DTensor1

typedef FTensor::Tensor2< double, 3, 3 >	DTensor2

typedef FTensor::Tensor3< double, 3, 3, 3 >	DTensor3

typedef FTensor::Tensor0< FTensor::PackPtr< double *, 1 > >	DTensor0Ptr

typedef FTensor::Tensor2< FTensor::PackPtr< double *, 1 >, 3, 3 >	DTensor2Ptr

typedef FTensor::Tensor3< FTensor::PackPtr< double *, 1 >, 3, 3, 3 >	DTensor3Ptr

Static Public Member Functions inherited from EshelbianPlasticity::PhysicalEquations
template<int S>
static DTensor2Ptr	get_VecTensor2 (std::vector< double > &v)

template<int S>
static DTensor0Ptr	get_VecTensor0 (std::vector< double > &v)

template<int S0>
static DTensor3Ptr	get_vecTensor3 (std::vector< double > &v, const int nba)

Public Attributes inherited from EshelbianPlasticity::PhysicalEquations
std::vector< double >	activeVariables

std::vector< double >	dependentVariablesPiola

std::vector< double >	dependentVariablesPiolaDirevatives

Detailed Description

Definition at line 12 of file HMHHencky.cpp.

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.

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

E

EshelbianPlasticity::HMHHencky::E

double E

Definition HMHHencky.cpp:344

EshelbianPlasticity::HMHHencky::nu

double nu

Definition HMHHencky.cpp:345

EshelbianPlasticity::HMHHencky::mField

MoFEM::Interface & mField

Definition HMHHencky.cpp:335

EshelbianPlasticity::PhysicalEquations::PhysicalEquations

PhysicalEquations()=delete

Member Function Documentation

◆ extractBlockData() [1/2]

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

inline

Definition at line 230 of file HMHHencky.cpp.

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

◆ extractBlockData() [2/2]

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

inline

Definition at line 243 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;
 
      blockData.push_back({bulk_modulus_K, shear_modulus_G, get_block_ents()});
    }
    MOFEM_LOG_CHANNEL("WORLD");
    MoFEMFunctionReturn(0);
  }

◆ getInvMatDPtr()

MoFEMErrorCode EshelbianPlasticity::HMHHencky::getInvMatDPtr	(	boost::shared_ptr< MatrixDouble >	mat_inv_D_ptr,
		double	bulk_modulus_K,
		double	shear_modulus_G )

inline

[Calculate elasticity tensor]

Definition at line 309 of file HMHHencky.cpp.

                                                               {
    MoFEMFunctionBegin;
    //! [Calculate elasticity tensor]
    auto set_material_compilance = [&]() {
      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>();
      const double A = 1. / (2. * shear_modulus_G);
      const double B =
          (1. / (9. * bulk_modulus_K)) - (1. / (6. * shear_modulus_G));
      auto t_inv_D = getFTensor4DdgFromPtr<SPACE_DIM, SPACE_DIM, 0>(
          &*(mat_inv_D_ptr->data().begin()));
      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);
    };
    //! [Calculate elasticity tensor]
    constexpr auto size_symm = (SPACE_DIM * (SPACE_DIM + 1)) / 2;
    mat_inv_D_ptr->resize(size_symm, size_symm, false);
    set_material_compilance();
    MoFEMFunctionReturn(0);
  }

◆ getMatDPtr()

MoFEMErrorCode EshelbianPlasticity::HMHHencky::getMatDPtr	(	boost::shared_ptr< MatrixDouble >	mat_D_ptr,
		boost::shared_ptr< MatrixDouble >	mat_axiator_D_ptr,
		boost::shared_ptr< MatrixDouble >	mat_deviator_D_ptr,
		double	bulk_modulus_K,
		double	shear_modulus_G )

inline

[Calculate elasticity tensor]

Definition at line 275 of file HMHHencky.cpp.

                                                                           {
    MoFEMFunctionBegin;
    //! [Calculate elasticity tensor]
    auto set_material_stiffness = [&]() {
      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 = getFTensor4DdgFromPtr<SPACE_DIM, SPACE_DIM, 0>(
          &*(mat_D_ptr->data().begin()));
      auto t_axiator_D = getFTensor4DdgFromPtr<SPACE_DIM, SPACE_DIM, 0>(
          &*mat_axiator_D_ptr->data().begin());
      auto t_deviator_D = getFTensor4DdgFromPtr<SPACE_DIM, SPACE_DIM, 0>(
          &*mat_deviator_D_ptr->data().begin());
      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);
    };
    //! [Calculate elasticity tensor]
    constexpr auto size_symm = (SPACE_DIM * (SPACE_DIM + 1)) / 2;
    mat_D_ptr->resize(size_symm, size_symm, false);
    mat_axiator_D_ptr->resize(size_symm, size_symm, false);
    mat_deviator_D_ptr->resize(size_symm, size_symm, false);
    set_material_stiffness();
    MoFEMFunctionReturn(0);
  }

◆ getOptions()

MoFEMErrorCode EshelbianPlasticity::HMHHencky::getOptions ( boost::shared_ptr< DataAtIntegrationPts > data_ptr )

inline

Definition at line 210 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);
  }

◆ recordTape()

MoFEMErrorCode EshelbianPlasticity::HMHHencky::recordTape	(	const int	tag,
		DTensor2Ptr *	t_h )

inlinevirtual

Implements EshelbianPlasticity::PhysicalEquations.

Definition at line 17 of file HMHHencky.cpp.

17{ return 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 172 of file HMHHencky.cpp.

                                                                    {
    return new OpCalculateEnergy(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 193 of file HMHHencky.cpp.

                                                      {
    return new OpCalculateStretchFromStress(
        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 202 of file HMHHencky.cpp.

                                                      {
    return new OpCalculateStretchFromStress(
        data_ptr, data_ptr->getVarLogStreachPts(), data_ptr->getVarPiolaPts(),
        boost::dynamic_pointer_cast<HMHHencky>(physics_ptr));
  }

◆ returnOpJacobian()

virtual UserDataOperator * EshelbianPlasticity::HMHHencky::returnOpJacobian	(	const int	tag,
		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 70 of file HMHHencky.cpp.

                                                                   {
    return (new OpHenckyJacobian(
        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 95 of file HMHHencky.cpp.

                                                {
    return new OpSpatialPhysical(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 141 of file HMHHencky.cpp.

                                                                          {
    return new OpSpatialPhysical_du_du(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 115 of file HMHHencky.cpp.

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

Member Data Documentation

◆ blockData

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

private

Definition at line 342 of file HMHHencky.cpp.

◆ E

double EshelbianPlasticity::HMHHencky::E

private

Definition at line 344 of file HMHHencky.cpp.

◆ getOptionsSeverityLevels

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

private

Definition at line 349 of file HMHHencky.cpp.

◆ mField

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

private

Definition at line 335 of file HMHHencky.cpp.

◆ nu

double EshelbianPlasticity::HMHHencky::nu

private

Definition at line 345 of file HMHHencky.cpp.

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

users_modules/eshelbian_plasticity/src/impl/HMHHencky.cpp

Classes

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HMHHencky()

Member Function Documentation

◆ extractBlockData() [1/2]

◆ extractBlockData() [2/2]

◆ getInvMatDPtr()

◆ getMatDPtr()

◆ getOptions()

◆ recordTape()

◆ returnOpCalculateEnergy()

◆ returnOpCalculateStretchFromStress()

◆ returnOpCalculateVarStretchFromStress()

◆ returnOpJacobian()

◆ returnOpSpatialPhysical()

◆ returnOpSpatialPhysical_du_du()

◆ returnOpSpatialPhysicalExternalStrain()

Member Data Documentation

◆ blockData

◆ E

◆ getOptionsSeverityLevels

◆ mField

◆ nu