#include "src/materials/MatUmatImpl.hpp"

Inheritance diagram for MatOps::MatUmatImpl< DIM, MODEL_TYPE >:

Collaboration diagram for MatOps::MatUmatImpl< DIM, MODEL_TYPE >:

Public Types
using	A = PhysicalEquations

using	UmatInterfaceType = MoFEM::UmatInterface< MODEL_TYPE >

Public Types inherited from MatOps::PhysicalEquations
using	HookFunction = std::function< MoFEMErrorCode(boost::shared_ptr< MatOpsData >, int, EntityHandle, int)>

Public Member Functions
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent, bool update) override

MoFEMErrorCode	getOptions (MoFEM::Interface *m_field_ptr=nullptr) override

MoFEMErrorCode	setParams (FEMethod *fe_ptr, int gg) override

MoFEMErrorCode	recordTape () override

MoFEMErrorCode	evaluateVariable (int, EntityHandle entity, int gg) override

MoFEMErrorCode	evaluateDerivatives (int, EntityHandle entity, int gg) override

MoFEMErrorCode	updateState (int, EntityHandle entity, int gg) override

	PhysicalEquations ()=delete

	PhysicalEquations (boost::shared_ptr< MatOpsData > mat_ops_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)

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

	PhysicalEquations (boost::shared_ptr< MatOpsData > mat_ops_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)

virtual	~PhysicalEquations ()=default

virtual MoFEMErrorCode	addBlockParameters (MoFEM::Interface &m_field, const std::string &block_name, int block_id, const Range &block_entities, const std::vector< double > &block_data)

Static Public Member Functions
static std::string	getStateVariableTagName (const int index)

Static Public Attributes
static constexpr auto	DFGRD0_TAG_NAME = "UMAT_DFGRD0"

static constexpr auto	STRESS_TAG_NAME = "UMAT_STRESS"

static constexpr auto	STATEV_TAG_NAME = "UMAT_STATEV"

static bool	useDeformationGradient

Protected Member Functions
virtual MoFEMErrorCode	bindAuxiliaryStateTags (MoFEM::Interface &m_field)

virtual MoFEMErrorCode	recordAuxiliaryMatOpsData ()

virtual MoFEMErrorCode	loadCoordinates (EntityHandle entity, int gg)

virtual MoFEMErrorCode	loadPredef (EntityHandle entity, int gg)

MoFEMErrorCode	loadPreviousDeformationGradient (EntityHandle entity, int gg)

MoFEMErrorCode	storeCurrentDeformationGradient (EntityHandle entity, int gg)

MoFEMErrorCode	loadPreviousStress (EntityHandle entity, int gg)

MoFEMErrorCode	loadPreviousStateVariables (EntityHandle entity, int gg)

MoFEMErrorCode	storeCurrentStress (EntityHandle entity, int gg)

MoFEMErrorCode	storeCurrentStateVariables (EntityHandle entity, int gg)

Protected Attributes
MoFEM::Interface *	mField = nullptr

std::unique_ptr< UmatInterfaceType >	umatInterfacePtr

std::string	libraryPath = "./umat.so"

std::string	materialName = "UMAT"

StrainType	strainType = StrainType::SMALL

PetscInt	currentTimeStep = 0

PetscReal	currentTime = 0

PetscReal	currentTimeIncrement = 0

double	youngModulus = 1.0

double	poissonRatio = 0.3

int	numberStateVariables = 1

int	numberMaterialProperties = 2

std::vector< double >	defaultMaterialParameters = {youngModulus, poissonRatio}

std::vector< double >	currentMaterialParameters = defaultMaterialParameters

std::vector< double >	stateVar = std::vector<double>(numberStateVariables, 0.0)

std::unique_ptr< StrainHandler< DIM, MODEL_TYPE > >	strainHandler

Friends
struct	SmallStrainHandler< DIM, MODEL_TYPE >

struct	HenckyStrainHandler< DIM, MODEL_TYPE >

struct	FiniteStrainHandler< DIM, MODEL_TYPE >

Additional Inherited Members
Public Attributes inherited from MatOps::PhysicalEquations
HookFunction	hookEvaluateVariable = AdolCEvaluation::evaluateVariable

HookFunction	hookEvaluateDerivatives = AdolCEvaluation::evaluateDerivatives

HookFunction	hookUpdateState = AdolCEvaluation::evaluateVariable

int	tAg

boost::shared_ptr< std::map< int, Range > >	tagVsRangePtr

std::vector< std::pair< Range, std::vector< double > > >	paramVecByRange

boost::shared_ptr< MatOpsData >	matOpsDataPtr

Detailed Description

template<int DIM, int MODEL_TYPE>
struct MatOps::MatUmatImpl< DIM, MODEL_TYPE >

Definition at line 179 of file MatUmatImpl.hpp.

Member Typedef Documentation

◆ A

template<int DIM, int MODEL_TYPE>

using MatOps::MatUmatImpl< DIM, MODEL_TYPE >::A = PhysicalEquations

Definition at line 181 of file MatUmatImpl.hpp.

◆ UmatInterfaceType

template<int DIM, int MODEL_TYPE>

using MatOps::MatUmatImpl< DIM, MODEL_TYPE >::UmatInterfaceType = MoFEM::UmatInterface<MODEL_TYPE>

Definition at line 182 of file MatUmatImpl.hpp.

Member Function Documentation

◆ bindAuxiliaryStateTags()

template<int DIM, int MODEL_TYPE>

virtual MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::bindAuxiliaryStateTags ( MoFEM::Interface & m_field )

inlineprotectedvirtual

Definition at line 396 of file MatUmatImpl.hpp.

                                                                         {
    MoFEMFunctionBeginHot;
    (void)m_field;
    MoFEMFunctionReturnHot(0);
  }

◆ createOp()

template<int DIM, int MODEL_TYPE>

template ForcesAndSourcesCore::UserDataOperator * MatOps::MatUmatImpl< DIM, MODEL_TYPE >::createOp	(	boost::shared_ptr< PhysicalEquations >	physical_ptr,
		bool	eval_stress,
		bool	eval_tangent,
		bool	update
	)

overridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 21 of file MatUmat.cpp.

                                    {
  using EleOp = ForcesAndSourcesCore::UserDataOperator;
  return createOpImpl<DIM, EleOp>(physical_ptr, eval_stress, eval_tangent,
                                  update);
}

◆ evaluateDerivatives()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::evaluateDerivatives	(	int	,
		EntityHandle	entity,
		int	gg
	)

inlineoverridevirtual

Reimplemented from MatOps::PhysicalEquations.

Definition at line 378 of file MatUmatImpl.hpp.

                                                      {
    MoFEMFunctionBegin;
    CHKERR strainHandler->runUmat(*this, entity, gg);
    CHKERR strainHandler->convertTangent(*this, A::matOpsDataPtr);
    MoFEMFunctionReturn(0);
  }

◆ evaluateVariable()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::evaluateVariable	(	int	,
		EntityHandle	entity,
		int	gg
	)

inlineoverridevirtual

Reimplemented from MatOps::PhysicalEquations.

Definition at line 371 of file MatUmatImpl.hpp.

                                                                             {
    MoFEMFunctionBegin;
    CHKERR strainHandler->runUmat(*this, entity, gg);
    CHKERR strainHandler->convertStress(*this, A::matOpsDataPtr);
    MoFEMFunctionReturn(0);
  }

◆ getOptions()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::getOptions ( MoFEM::Interface * m_field_ptr = nullptr )

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 198 of file MatUmatImpl.hpp.

                                                                            {
    MoFEMFunctionBegin;
 
    mField = m_field_ptr;
 
    MOFEM_LOG_CHANNEL("WORLD");
 
    char umat_library[PETSC_MAX_PATH_LEN] = "./umat.so";
    char umat_name[80] = "UMAT";
    PetscInt nstatev = 0;
    PetscInt nprops = 2;
    const char *list_strain_type[] = {"small", "hencky", "finite"};
    PetscInt choice_strain = StrainType::SMALL;
    PetscOptionsBegin(PETSC_COMM_WORLD, "umat_", "", "none");
    CHKERR PetscOptionsString("-library", "Path to UMAT shared library", "",
                              umat_library, umat_library, sizeof(umat_library),
                              PETSC_NULLPTR);
    CHKERR PetscOptionsString("-name", "UMAT material name", "", umat_name,
                              umat_name, sizeof(umat_name), PETSC_NULLPTR);
    CHKERR PetscOptionsInt("-nstatev", "Number of UMAT state variables", "",
                           nstatev, &nstatev, PETSC_NULLPTR);
    CHKERR PetscOptionsInt("-nprops", "Number of UMAT material properties", "",
                           nprops, &nprops, PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-young_modulus", "Default first property", "",
                              youngModulus, &youngModulus, PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-poisson_ratio", "Default second property", "",
                              poissonRatio, &poissonRatio, PETSC_NULLPTR);
    CHKERR PetscOptionsEList(
        "-strain_type", "Strain type", "", list_strain_type, 3,
        list_strain_type[choice_strain], &choice_strain, PETSC_NULLPTR);
    PetscOptionsEnd();
 
    strainType = static_cast<StrainType>(choice_strain);
 
    switch (strainType) {
    case SMALL:
      strainHandler = std::make_unique<SmallStrainHandler<DIM, MODEL_TYPE>>();
      break;
    case HENCKY:
      strainHandler = std::make_unique<HenckyStrainHandler<DIM, MODEL_TYPE>>();
      break;
    case FINITE:
      strainHandler = std::make_unique<FiniteStrainHandler<DIM, MODEL_TYPE>>();
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Unsupported UMAT strain type");
    }
 
    if (nprops <= 0) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "UMAT requires a positive number of properties");
    }
 
    if (nstatev < 0) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "UMAT requires a non-negative number of state variables");
    }
 
    numberStateVariables = static_cast<int>(nstatev);
    stateVar.resize(numberStateVariables, 0.0);
    numberMaterialProperties = static_cast<int>(nprops);
    materialName = umat_name;
    libraryPath = umat_library;
 
    defaultMaterialParameters.assign(numberMaterialProperties, 0.0);
    defaultMaterialParameters[0] = youngModulus;
    if (numberMaterialProperties > 1)
      defaultMaterialParameters[1] = poissonRatio;
    currentMaterialParameters = defaultMaterialParameters;
 
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "Default Umat parameters:")
        << " umat_library = " << libraryPath << " name = " << materialName
        << " umat_nstatev = " << numberStateVariables
        << " umat_nprops = " << numberMaterialProperties;
 
    std::string block_name = "MAT_UMAT";
    for (auto &m :
         m_field_ptr->getInterface<MeshsetsManager>()->getCubitMeshsetPtr(
             std::regex((boost::format("%s(.*)") % block_name).str()))) {
      std::vector<double> block_data;
      CHKERR m->getAttributes(block_data);
      if ((int)block_data.size() < numberMaterialProperties) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "MAT_UMAT block requires at least %d attributes", nprops);
      }
 
      auto get_block_ents = [&]() {
        Range ents;
        CHK_MOAB_THROW(m_field_ptr->get_moab().get_entities_by_handle(
                           m->meshset, ents, true),
                       "can not get block entities");
        return ents;
      };
 
      A::paramVecByRange.push_back(
          {get_block_ents(),
           std::vector<double>(block_data.begin(),
                               block_data.begin() + numberMaterialProperties)});
 
      std::ostringstream properties_stream;
      properties_stream << "[";
      for (int ii = 0; ii != numberMaterialProperties; ++ii) {
        if (ii)
          properties_stream << ", ";
        properties_stream << block_data[ii];
      }
      properties_stream << "]";
 
      MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "MatBlock for Umat")
          << *m << " properties = " << properties_stream.str();
    }
 
    umatInterfacePtr = std::make_unique<UmatInterfaceType>(
        numberStateVariables, numberMaterialProperties);
    CHKERR umatInterfacePtr->initialise(libraryPath, materialName);
 
    if (m_field_ptr) {
      CHKERR A::matOpsDataPtr->bindStateTag(*m_field_ptr, DFGRD0_TAG_NAME,
                                            DIM * DIM);
      CHKERR A::matOpsDataPtr->bindStateTag(*m_field_ptr, STRESS_TAG_NAME,
                                            UmatInterfaceType::NTENS);
      if (numberStateVariables > 0) {
        for (int ii = 0; ii != numberStateVariables; ++ii) {
          CHKERR A::matOpsDataPtr->bindStateTag(*m_field_ptr,
                                                getStateVariableTagName(ii), 1);
        }
      }
      CHKERR bindAuxiliaryStateTags(*m_field_ptr);
      CHKERR A::matOpsDataPtr->setupStateData();
    }
 
    MoFEMFunctionReturn(0);
  }

◆ getStateVariableTagName()

template<int DIM, int MODEL_TYPE>

static std::string MatOps::MatUmatImpl< DIM, MODEL_TYPE >::getStateVariableTagName ( const int index )

inlinestatic

Definition at line 187 of file MatUmatImpl.hpp.

                                                            {
    return (boost::format("%s_%d") % STATEV_TAG_NAME % index).str();
  }

◆ loadCoordinates()

template<int DIM, int MODEL_TYPE>

virtual MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::loadCoordinates	(	EntityHandle	entity,
		int	gg
	)

inlineprotectedvirtual

Definition at line 409 of file MatUmatImpl.hpp.

                                                                      {
    MoFEMFunctionBeginHot;
    (void)entity;
    (void)gg;
    for (int dd = 0; dd != 3; ++dd)
      umatInterfacePtr->coords[dd] = 0.0;
    MoFEMFunctionReturnHot(0);
  }

◆ loadPredef()

template<int DIM, int MODEL_TYPE>

virtual MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::loadPredef	(	EntityHandle	entity,
		int	gg
	)

inlineprotectedvirtual

Definition at line 418 of file MatUmatImpl.hpp.

                                                                 {
    MoFEMFunctionBeginHot;
    (void)entity;
    (void)gg;
    if (umatInterfacePtr->predef.empty()) {
      umatInterfacePtr->predef.push_back(0.0);
    }
    if (umatInterfacePtr->dpred.empty()) {
      umatInterfacePtr->dpred.push_back(0.0);
    }
    std::fill(umatInterfacePtr->predef.begin(), umatInterfacePtr->predef.end(),
              0.0);
    std::fill(umatInterfacePtr->dpred.begin(), umatInterfacePtr->dpred.end(),
              0.0);
    MoFEMFunctionReturnHot(0);
  }

◆ loadPreviousDeformationGradient()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::loadPreviousDeformationGradient	(	EntityHandle	entity,
		int	gg
	)

inlineprotected

Definition at line 435 of file MatUmatImpl.hpp.

                                                                              {
    MoFEMFunctionBegin;
 
    CHKERR umatInterfacePtr->setIdentityDeformationGradient();
 
    auto state_ptr =
        A::matOpsDataPtr->getStateDataPtr(DFGRD0_TAG_NAME, entity, gg);
    bool has_stored_gradient = false;
    for (int row = 0; row != DIM; ++row) {
      for (int col = 0; col != DIM; ++col) {
        const double value = (*state_ptr)(row * DIM + col, 0);
        umatInterfacePtr->dfgrd0[row + 3 * col] = value;
        has_stored_gradient = has_stored_gradient || std::abs(value) > 0;
      }
    }
 
    if (!has_stored_gradient) {
      CHKERR umatInterfacePtr->setIdentityDeformationGradient();
    }
 
    MoFEMFunctionReturn(0);
  }

◆ loadPreviousStateVariables()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::loadPreviousStateVariables	(	EntityHandle	entity,
		int	gg
	)

inlineprotected

Definition at line 485 of file MatUmatImpl.hpp.

                                                                         {
    MoFEMFunctionBegin;
 
    umatInterfacePtr->statev.assign(numberStateVariables, -1);
    if (!numberStateVariables) {
      MoFEMFunctionReturnHot(0);
    }
 
    for (int ii = 0; ii != numberStateVariables; ++ii) {
      auto state_ptr = A::matOpsDataPtr->getStateDataPtr(
          getStateVariableTagName(ii), entity, gg);
      umatInterfacePtr->statev[ii] = (*state_ptr)(0, 0);
    }
 
    MoFEMFunctionReturn(0);
  }

◆ loadPreviousStress()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::loadPreviousStress	(	EntityHandle	entity,
		int	gg
	)

inlineprotected

Definition at line 473 of file MatUmatImpl.hpp.

                                                                 {
    MoFEMFunctionBegin;
 
    auto state_ptr =
        A::matOpsDataPtr->getStateDataPtr(STRESS_TAG_NAME, entity, gg);
    for (int ii = 0; ii != UmatInterfaceType::NTENS; ++ii) {
      umatInterfacePtr->stress[ii] = (*state_ptr)(ii, 0);
    }
 
    MoFEMFunctionReturn(0);
  }

◆ PhysicalEquations() [1/2]

template<int DIM, int MODEL_TYPE>

MatOps::PhysicalEquations::PhysicalEquations ( )

delete

◆ PhysicalEquations() [2/2]

template<int DIM, int MODEL_TYPE>

MatOps::PhysicalEquations::PhysicalEquations	(	boost::shared_ptr< MatOpsData >	mat_ops_data_ptr,
		int	tag,
		boost::shared_ptr< std::map< int, Range > >	tag_vs_range_ptr = `nullptr`
	)

inline

Definition at line 114 of file MatOps.hpp.

117 : tAg(tag), tagVsRangePtr(tag_vs_range_ptr),

118 matOpsDataPtr(mat_ops_data_ptr) {}

MatOps::PhysicalEquations::tagVsRangePtr

boost::shared_ptr< std::map< int, Range > > tagVsRangePtr

Definition MatOps.hpp:161

MatOps::PhysicalEquations::tAg

int tAg

Definition MatOps.hpp:160

◆ recordAuxiliaryMatOpsData()

template<int DIM, int MODEL_TYPE>

virtual MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::recordAuxiliaryMatOpsData ( )

inlineprotectedvirtual

Definition at line 402 of file MatUmatImpl.hpp.

                                                     {
    MoFEMFunctionBeginHot;
    MoFEMFunctionReturnHot(0);
  }

◆ recordTape()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::recordTape ( )

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 350 of file MatUmatImpl.hpp.

                                       {
    MoFEMFunctionBegin;
 
    A::matOpsDataPtr->insertCommonData("grad", MatrixDouble());
    A::matOpsDataPtr->insertCommonData("P", MatrixDouble());
    A::matOpsDataPtr->insertCommonData("P_dF", MatrixDouble());
 
    A::matOpsDataPtr->insertActiveData("F", MatrixDouble());
    A::matOpsDataPtr->insertDependentData("P", MatrixDouble());
    A::matOpsDataPtr->insertDependentDerivativesData("P_dF", MatrixDouble());
 
    A::matOpsDataPtr->getActiveDataPtr("F")->resize(DIM, DIM, false);
    A::matOpsDataPtr->getDependentDataPtr("P")->resize(DIM, DIM, false);
    A::matOpsDataPtr->getDependentDerivativesDataPtr("P_dF")->resize(
        DIM * DIM, DIM * DIM, false);
 
    CHKERR recordAuxiliaryMatOpsData();
 
    MoFEMFunctionReturn(0);
  }

◆ setParams()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::setParams	(	FEMethod *	fe_ptr,
		int	gg
	)

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 333 of file MatUmatImpl.hpp.

                                                              {
    MoFEMFunctionBeginHot;
    (void)gg;
    currentTimeStep = fe_ptr->ts_step;
    currentTime = fe_ptr->ts_t;
    currentTimeIncrement = fe_ptr->ts_dt;
    const auto ent = fe_ptr->getFEEntityHandle();
    currentMaterialParameters = defaultMaterialParameters;
    for (auto &[range, param_vec] : A::paramVecByRange) {
      if (range.find(ent) != range.end()) {
        currentMaterialParameters = param_vec;
        break;
      }
    }
    MoFEMFunctionReturnHot(0);
  }

◆ storeCurrentDeformationGradient()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::storeCurrentDeformationGradient	(	EntityHandle	entity,
		int	gg
	)

inlineprotected

Definition at line 458 of file MatUmatImpl.hpp.

                                                                              {
    MoFEMFunctionBegin;
 
    auto state_ptr =
        A::matOpsDataPtr->getStateDataPtr(DFGRD0_TAG_NAME, entity, gg);
    for (int row = 0; row != DIM; ++row) {
      for (int col = 0; col != DIM; ++col) {
        (*state_ptr)(row *DIM + col, 0) =
            umatInterfacePtr->dfgrd1[row + 3 * col];
      }
    }
 
    MoFEMFunctionReturn(0);
  }

◆ storeCurrentStateVariables()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::storeCurrentStateVariables	(	EntityHandle	entity,
		int	gg
	)

inlineprotected

Definition at line 514 of file MatUmatImpl.hpp.

                                                                         {
    MoFEMFunctionBegin;
 
    if (!numberStateVariables) {
      MoFEMFunctionReturnHot(0);
    }
 
    for (int ii = 0; ii != numberStateVariables; ++ii) {
      auto state_ptr = A::matOpsDataPtr->getStateDataPtr(
          getStateVariableTagName(ii), entity, gg);
      (*state_ptr)(0, 0) = umatInterfacePtr->statev[ii];
    }
 
    MoFEMFunctionReturn(0);
  }

◆ storeCurrentStress()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::storeCurrentStress	(	EntityHandle	entity,
		int	gg
	)

inlineprotected

Definition at line 502 of file MatUmatImpl.hpp.

                                                                 {
    MoFEMFunctionBegin;
 
    auto state_ptr =
        A::matOpsDataPtr->getStateDataPtr(STRESS_TAG_NAME, entity, gg);
    for (int ii = 0; ii != UmatInterfaceType::NTENS; ++ii) {
      (*state_ptr)(ii, 0) = umatInterfacePtr->stress[ii];
    }
 
    MoFEMFunctionReturn(0);
  }

◆ updateState()

template<int DIM, int MODEL_TYPE>

MoFEMErrorCode MatOps::MatUmatImpl< DIM, MODEL_TYPE >::updateState	(	int	,
		EntityHandle	entity,
		int	gg
	)

inlineoverridevirtual

Reimplemented from MatOps::PhysicalEquations.

Definition at line 386 of file MatUmatImpl.hpp.

                                                                        {
    MoFEMFunctionBegin;
    CHKERR strainHandler->runUmat(*this, entity, gg);
    CHKERR storeCurrentDeformationGradient(entity, gg);
    CHKERR storeCurrentStress(entity, gg);
    CHKERR storeCurrentStateVariables(entity, gg);
    MoFEMFunctionReturn(0);
  }

Friends And Related Symbol Documentation

◆ FiniteStrainHandler< DIM, MODEL_TYPE >

template<int DIM, int MODEL_TYPE>

friend struct FiniteStrainHandler< DIM, MODEL_TYPE >

friend

Definition at line 544 of file MatUmatImpl.hpp.

◆ HenckyStrainHandler< DIM, MODEL_TYPE >

template<int DIM, int MODEL_TYPE>

friend struct HenckyStrainHandler< DIM, MODEL_TYPE >

friend

Definition at line 544 of file MatUmatImpl.hpp.

◆ SmallStrainHandler< DIM, MODEL_TYPE >

template<int DIM, int MODEL_TYPE>

friend struct SmallStrainHandler< DIM, MODEL_TYPE >

friend

Definition at line 544 of file MatUmatImpl.hpp.

Member Data Documentation

◆ currentMaterialParameters

template<int DIM, int MODEL_TYPE>

std::vector<double> MatOps::MatUmatImpl< DIM, MODEL_TYPE >::currentMaterialParameters = defaultMaterialParameters

protected

Definition at line 543 of file MatUmatImpl.hpp.

◆ currentTime

template<int DIM, int MODEL_TYPE>

PetscReal MatOps::MatUmatImpl< DIM, MODEL_TYPE >::currentTime = 0

protected

Definition at line 536 of file MatUmatImpl.hpp.

◆ currentTimeIncrement

template<int DIM, int MODEL_TYPE>

PetscReal MatOps::MatUmatImpl< DIM, MODEL_TYPE >::currentTimeIncrement = 0

protected

Definition at line 537 of file MatUmatImpl.hpp.

◆ currentTimeStep

template<int DIM, int MODEL_TYPE>

PetscInt MatOps::MatUmatImpl< DIM, MODEL_TYPE >::currentTimeStep = 0

protected

Definition at line 535 of file MatUmatImpl.hpp.

◆ defaultMaterialParameters

template<int DIM, int MODEL_TYPE>

std::vector<double> MatOps::MatUmatImpl< DIM, MODEL_TYPE >::defaultMaterialParameters = {youngModulus, poissonRatio}

protected

Definition at line 542 of file MatUmatImpl.hpp.

542{youngModulus, poissonRatio};

◆ DFGRD0_TAG_NAME

template<int DIM, int MODEL_TYPE>

constexpr auto MatOps::MatUmatImpl< DIM, MODEL_TYPE >::DFGRD0_TAG_NAME = "UMAT_DFGRD0"

staticconstexpr

Definition at line 183 of file MatUmatImpl.hpp.

◆ libraryPath

template<int DIM, int MODEL_TYPE>

std::string MatOps::MatUmatImpl< DIM, MODEL_TYPE >::libraryPath = "./umat.so"

protected

Definition at line 532 of file MatUmatImpl.hpp.

◆ materialName

template<int DIM, int MODEL_TYPE>

std::string MatOps::MatUmatImpl< DIM, MODEL_TYPE >::materialName = "UMAT"

protected

Definition at line 533 of file MatUmatImpl.hpp.

◆ mField

template<int DIM, int MODEL_TYPE>

MoFEM::Interface* MatOps::MatUmatImpl< DIM, MODEL_TYPE >::mField = nullptr

protected

Definition at line 530 of file MatUmatImpl.hpp.

◆ numberMaterialProperties

template<int DIM, int MODEL_TYPE>

int MatOps::MatUmatImpl< DIM, MODEL_TYPE >::numberMaterialProperties = 2

protected

Definition at line 541 of file MatUmatImpl.hpp.

◆ numberStateVariables

template<int DIM, int MODEL_TYPE>

int MatOps::MatUmatImpl< DIM, MODEL_TYPE >::numberStateVariables = 1

protected

Definition at line 540 of file MatUmatImpl.hpp.

◆ poissonRatio

template<int DIM, int MODEL_TYPE>

double MatOps::MatUmatImpl< DIM, MODEL_TYPE >::poissonRatio = 0.3

protected

Definition at line 539 of file MatUmatImpl.hpp.

◆ STATEV_TAG_NAME

template<int DIM, int MODEL_TYPE>

constexpr auto MatOps::MatUmatImpl< DIM, MODEL_TYPE >::STATEV_TAG_NAME = "UMAT_STATEV"

staticconstexpr

Definition at line 185 of file MatUmatImpl.hpp.

◆ stateVar

template<int DIM, int MODEL_TYPE>

std::vector<double> MatOps::MatUmatImpl< DIM, MODEL_TYPE >::stateVar = std::vector<double>(numberStateVariables, 0.0)

protected

Definition at line 544 of file MatUmatImpl.hpp.

◆ strainHandler

template<int DIM, int MODEL_TYPE>

std::unique_ptr<StrainHandler<DIM, MODEL_TYPE> > MatOps::MatUmatImpl< DIM, MODEL_TYPE >::strainHandler

protected

Definition at line 548 of file MatUmatImpl.hpp.

◆ strainType

template<int DIM, int MODEL_TYPE>

StrainType MatOps::MatUmatImpl< DIM, MODEL_TYPE >::strainType = StrainType::SMALL

protected

Definition at line 534 of file MatUmatImpl.hpp.

◆ STRESS_TAG_NAME

template<int DIM, int MODEL_TYPE>

constexpr auto MatOps::MatUmatImpl< DIM, MODEL_TYPE >::STRESS_TAG_NAME = "UMAT_STRESS"

staticconstexpr

Definition at line 184 of file MatUmatImpl.hpp.

◆ umatInterfacePtr

template<int DIM, int MODEL_TYPE>

std::unique_ptr<UmatInterfaceType> MatOps::MatUmatImpl< DIM, MODEL_TYPE >::umatInterfacePtr

protected

Definition at line 531 of file MatUmatImpl.hpp.

◆ useDeformationGradient

template<int DIM, int MODEL_TYPE>

bool MatOps::MatUmatImpl< DIM, MODEL_TYPE >::useDeformationGradient

inlinestatic

Initial value:

=

false

Definition at line 191 of file MatUmatImpl.hpp.

◆ youngModulus

template<int DIM, int MODEL_TYPE>

double MatOps::MatUmatImpl< DIM, MODEL_TYPE >::youngModulus = 1.0

protected

Definition at line 538 of file MatUmatImpl.hpp.

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

src/materials/MatUmat.hpp
src/materials/MatUmatImpl.hpp
src/materials/impl/MatUmat.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ A

◆ UmatInterfaceType

Member Function Documentation

◆ bindAuxiliaryStateTags()

◆ createOp()

◆ evaluateDerivatives()

◆ evaluateVariable()

◆ getOptions()

◆ getStateVariableTagName()

◆ loadCoordinates()

◆ loadPredef()

◆ loadPreviousDeformationGradient()

◆ loadPreviousStateVariables()

◆ loadPreviousStress()

◆ PhysicalEquations() [1/2]

◆ PhysicalEquations() [2/2]

◆ recordAuxiliaryMatOpsData()

◆ recordTape()

◆ setParams()

◆ storeCurrentDeformationGradient()

◆ storeCurrentStateVariables()

◆ storeCurrentStress()

◆ updateState()

Friends And Related Symbol Documentation

◆ FiniteStrainHandler< DIM, MODEL_TYPE >

◆ HenckyStrainHandler< DIM, MODEL_TYPE >

◆ SmallStrainHandler< DIM, MODEL_TYPE >

Member Data Documentation

◆ currentMaterialParameters

◆ currentTime

◆ currentTimeIncrement

◆ currentTimeStep

◆ defaultMaterialParameters

◆ DFGRD0_TAG_NAME

◆ libraryPath

◆ materialName

◆ mField

◆ numberMaterialProperties

◆ numberStateVariables

◆ poissonRatio

◆ STATEV_TAG_NAME

◆ stateVar

◆ strainHandler

◆ strainType

◆ STRESS_TAG_NAME

◆ umatInterfacePtr

◆ useDeformationGradient

◆ youngModulus