MoFEM::UmatInterface< MODEL_TYPE > Struct Template Reference

#include "src/materials/UmatInterface.hpp"

Collaboration diagram for MoFEM::UmatInterface< MODEL_TYPE >:

Public Member Functions
	UmatInterface (int nstatv=0, int nprops=2)
	~UmatInterface ()
MoFEMErrorCode	initialise (const std::string &library_path="./umat.so", const std::string &material_name="UMAT")
MoFEMErrorCode	setIdentityDeformationGradient ()
MoFEMErrorCode	setIdentityRotationIncrement ()
MoFEMErrorCode	setProperties (const std::vector< double > &properties)
MoFEMErrorCode	storeStateVar (int n_state_var, const std::vector< double > &state_var_values)
MoFEMErrorCode	setTimeData (double current_time, double time_increment)
MoFEMErrorCode	setStepData (int step_number, int increment_number)
MoFEMErrorCode	setDeformationGradient (const MatrixDouble &grad, bool use_deformation_gradient)
MoFEMErrorCode	setStrainIncrementFromDeformationGradient ()
MoFEMErrorCode	callUmat ()
MoFEMErrorCode	getDeformationGradient (MatrixDouble &F) const
MoFEMErrorCode	getCauchyStressTensor (MatrixDouble &sigma) const
MoFEMErrorCode	getCauchyTangentTensor (MatrixDouble &cauchy_tangent) const

Public Attributes
boost::shared_ptr< MatOps::MatOpsData >	matOpsDataPtr
umat_f	umat = nullptr
void *	handle = nullptr
char	filename [256] = {}
int	ndi = NDI
int	nshr = NSHR
int	ntens = NTENS
int	nstatv
int	nprops
int	noel = 1
int	npt = 1
int	layer = 1
int	kspt = 1
int	kstep = 1
int	kinc = 1
std::vector< double >	props
std::vector< double >	statev
std::array< double, NTENS >	stress {}
std::array< double, NTENS >	stran {}
std::array< double, NTENS >	dstran {}
std::array< double, NTANGENT >	ddsdde {}
std::array< double, 9 >	dfgrd0 {}
std::array< double, 9 >	dfgrd1 {}
std::array< double, 9 >	drot {}
double	ddsddt [6]
double	drplde [6]
double	coords [3] = {}
char	cmname [80]
double	time [2] = {}
double	dtime = 0.0
double	temp = 0.0
double	dtemp = 0.0
std::vector< double >	predef {0.0}
std::vector< double >	dpred {0.0}
double	pnewdt = 1.0
double	celent = 0.0
double	sse = 0.0
double	spd = 0.0
double	scd = 0.0
double	rpl = 0.0
double	drpldt = 0.0

Static Public Attributes
static constexpr int	DIM
static constexpr int	NTENS
static constexpr int	NTANGENT = NTENS * NTENS
static constexpr int	NDI
static constexpr int	NSHR = (MODEL_TYPE == MatOps::MODEL_3D) ? 3 : 1

Detailed Description

template<int MODEL_TYPE>
struct MoFEM::UmatInterface< MODEL_TYPE >

Definition at line 30 of file UmatInterface.hpp.

Constructor & Destructor Documentation

UmatInterface()

template<int MODEL_TYPE>

MoFEM::UmatInterface< MODEL_TYPE >::UmatInterface	(	int	nstatv = 0,
		int	nprops = 2
	)

Definition at line 36 of file UmatInterface.cpp.

    : nstatv(nstatv), nprops(nprops), props(nprops, 0.0), statev(nstatv, 0.0) {}

~UmatInterface()

template<int MODEL_TYPE>

MoFEM::UmatInterface< MODEL_TYPE >::~UmatInterface

(

)

Definition at line 39 of file UmatInterface.cpp.

                                                                         {
  if (handle) {
    dlclose(handle);
    handle = nullptr;
    umat = nullptr;
  }
}

Member Function Documentation

callUmat()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::callUmat

(

)

Definition at line 84 of file UmatInterface.cpp.

                                                        {
  MoFEMFunctionBegin;
 
  if (!umat) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "UMAT function pointer is not initialised");
  }
 
  umat(stress.data(), statev.data(), ddsdde.data(), &sse, &spd, &scd, &rpl,
       ddsddt, drplde, &drpldt, stran.data(), dstran.data(), time, &dtime,
       &temp, &dtemp, predef.data(), dpred.data(), cmname, &ndi, &nshr, &ntens,
       &nstatv, props.data(), &nprops, coords, drot.data(), &pnewdt, &celent,
       dfgrd0.data(), dfgrd1.data(), &noel, &npt, &layer, &kspt, &kstep, &kinc,
       sizeof(cmname));
 
  MoFEMFunctionReturn(0);
}

getCauchyStressTensor()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::getCauchyStressTensor

(

MatrixDouble &

sigma

)

const

Definition at line 243 of file UmatInterface.cpp.

                               {
  MoFEMFunctionBegin;
  CHKERR resizeTensor2(sigma);
  if constexpr (MODEL_TYPE == MatOps::MODEL_3D) {
    sigma(0, 0) = stress[0];
    sigma(1, 1) = stress[1];
    sigma(2, 2) = stress[2];
    sigma(0, 1) = sigma(1, 0) = stress[3];
    sigma(0, 2) = sigma(2, 0) = stress[4];
    sigma(1, 2) = sigma(2, 1) = stress[5];
  } else if constexpr (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRAIN ||
                       MODEL_TYPE == MatOps::MODEL_AXISYMMETRIC) {
    sigma(0, 0) = stress[0];
    sigma(1, 1) = stress[1];
    sigma(2, 2) = stress[2];
    sigma(0, 1) = sigma(1, 0) = stress[3];
  } else if constexpr (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRESS) {
    sigma(0, 0) = stress[0];
    sigma(1, 1) = stress[1];
    sigma(0, 1) = sigma(1, 0) = stress[2];
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "UMAT stress conversion is not implemented for this model type");
  }
  MoFEMFunctionReturn(0);
}

getCauchyTangentTensor()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::getCauchyTangentTensor

(

MatrixDouble &

cauchy_tangent

)

const

Definition at line 272 of file UmatInterface.cpp.

                                        {
  MoFEMFunctionBegin;
  CHKERR resizeTensor4(cauchy_tangent);
  if constexpr (MODEL_TYPE == MatOps::MODEL_3D) {
    static const std::array<std::pair<int, int>, 6> pairs = {
        std::pair<int, int>{0, 0}, {1, 1}, {2, 2}, {0, 1}, {0, 2}, {1, 2}};
    for (int row = 0; row != 6; ++row) {
      const auto [i, j] = pairs[row];
      for (int col = 0; col != 6; ++col) {
        const auto [k, l] = pairs[col];
        const double value = ddsdde[row + 6 * col];
        cauchy_tangent(tensorIndex(i, j), tensorIndex(k, l)) = value;
        cauchy_tangent(tensorIndex(j, i), tensorIndex(k, l)) = value;
        cauchy_tangent(tensorIndex(i, j), tensorIndex(l, k)) = value;
        cauchy_tangent(tensorIndex(j, i), tensorIndex(l, k)) = value;
      }
    }
  } else if constexpr (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRAIN ||
                       MODEL_TYPE == MatOps::MODEL_AXISYMMETRIC) {
    static const std::array<std::pair<int, int>, 4> pairs = {
        std::pair<int, int>{0, 0}, {1, 1}, {2, 2}, {0, 1}};
    for (int row = 0; row != 4; ++row) {
      const auto [i, j] = pairs[row];
      for (int col = 0; col != 4; ++col) {
        const auto [k, l] = pairs[col];
        const double value = ddsdde[row + 4 * col];
        cauchy_tangent(tensorIndex(i, j), tensorIndex(k, l)) = value;
        cauchy_tangent(tensorIndex(j, i), tensorIndex(k, l)) = value;
        cauchy_tangent(tensorIndex(i, j), tensorIndex(l, k)) = value;
        cauchy_tangent(tensorIndex(j, i), tensorIndex(l, k)) = value;
      }
    }
  } else if constexpr (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRESS) {
    static const std::array<std::pair<int, int>, 3> pairs = {
        std::pair<int, int>{0, 0}, {1, 1}, {0, 1}};
    for (int row = 0; row != 3; ++row) {
      const auto [i, j] = pairs[row];
      for (int col = 0; col != 3; ++col) {
        const auto [k, l] = pairs[col];
        const double value = ddsdde[row + 3 * col];
        cauchy_tangent(tensorIndex(i, j), tensorIndex(k, l)) = value;
        cauchy_tangent(tensorIndex(j, i), tensorIndex(k, l)) = value;
        cauchy_tangent(tensorIndex(i, j), tensorIndex(l, k)) = value;
        cauchy_tangent(tensorIndex(j, i), tensorIndex(l, k)) = value;
      }
    }
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "UMAT tangent conversion is not implemented for this model type");
  }
  MoFEMFunctionReturn(0);
}

getDeformationGradient()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::getDeformationGradient

(

MatrixDouble &

F

)

const

Definition at line 232 of file UmatInterface.cpp.

                           {
  MoFEMFunctionBegin;
  CHKERR resizeTensor2(F);
  for (int row = 0; row != DIM; ++row)
    for (int col = 0; col != DIM; ++col)
      F(row, col) = dfgrd1[row + 3 * col];
  MoFEMFunctionReturn(0);
}

initialise()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::initialise	(	const std::string &	library_path = "./umat.so",
		const std::string &	material_name = "UMAT"
	)

Definition at line 49 of file UmatInterface.cpp.

                                                                             {
  MoFEMFunctionBegin;
 
  if (handle) {
    dlclose(handle);
    handle = nullptr;
    umat = nullptr;
  }
 
  std::memset(filename, 0, sizeof(filename));
  std::strncpy(filename, library_path.c_str(), sizeof(filename) - 1);
 
  std::memset(cmname, ' ', sizeof(cmname));
  const auto material_name_size = material_name.size() < sizeof(cmname)
                                      ? material_name.size()
                                      : sizeof(cmname);
  std::memcpy(cmname, material_name.data(), material_name_size);
 
  handle = dlopen(filename, RTLD_NOW | RTLD_LOCAL);
  if (!handle) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "Failed to open UMAT library %s: %s", filename, dlerror());
  }
 
  umat = (umat_f)dlsym(handle, "umat_");
  if (!umat) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "Failed to resolve symbol umat_ in %s: %s", filename, dlerror());
  }
 
  MoFEMFunctionReturn(0);
}

setDeformationGradient()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::setDeformationGradient	(	const MatrixDouble &	grad,
		bool	use_deformation_gradient
	)

Definition at line 127 of file UmatInterface.cpp.

                                                             {
  MoFEMFunctionBegin;
 
  dfgrd1.fill(0);
  for (int dd = 0; dd != 3; ++dd)
    dfgrd1[dd + 3 * dd] = 1.0;
 
  for (int row = 0; row != DIM; ++row) {
    for (int col = 0; col != DIM; ++col) {
      const double grad_value = grad(row, col);
      dfgrd1[row + 3 * col] = use_deformation_gradient
                                  ? grad_value
                                  : grad_value + (row == col ? 1.0 : 0.0);
    }
  }
 
  MoFEMFunctionReturn(0);
}

setIdentityDeformationGradient()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::setIdentityDeformationGradient

(

)

Definition at line 104 of file UmatInterface.cpp.

                                                               {
  MoFEMFunctionBegin;
 
  dfgrd0.fill(0);
  for (int dd = 0; dd != 3; ++dd)
    dfgrd0[dd + 3 * dd] = 1.0;
 
  MoFEMFunctionReturn(0);
}

setIdentityRotationIncrement()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::setIdentityRotationIncrement

(

)

Definition at line 116 of file UmatInterface.cpp.

                                                             {
  MoFEMFunctionBegin;
 
  drot.fill(0);
  for (int dd = 0; dd != 3; ++dd)
    drot[dd + 3 * dd] = 1.0;
 
  MoFEMFunctionReturn(0);
}

setProperties()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::setProperties

(

const std::vector< double > &

properties

)

setStepData()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::setStepData	(	int	step_number,
		int	increment_number
	)

Definition at line 162 of file UmatInterface.cpp.

                                                                    {
  MoFEMFunctionBegin;
 
  kstep = step_number;
  kinc = increment_number;
 
  MoFEMFunctionReturn(0);
}

setStrainIncrementFromDeformationGradient()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::setStrainIncrementFromDeformationGradient

(

)

Definition at line 174 of file UmatInterface.cpp.

                                                                          {
  MoFEMFunctionBegin;
 
  auto get_small_strain_voigt = [](const std::array<double, 9> &dfgrd,
                                   auto &strain) {
    std::array<double, 9> grad = dfgrd;
    for (int dd = 0; dd != DIM; ++dd)
      grad[dd + 3 * dd] -= 1.0;
 
    if constexpr (MODEL_TYPE == MatOps::MODEL_3D) {
      strain[0] = grad[0];
      strain[1] = grad[4];
      strain[2] = grad[8];
      strain[3] = grad[1] + grad[3];
      strain[4] = grad[2] + grad[6];
      strain[5] = grad[5] + grad[7];
    } else if constexpr (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRAIN) {
      strain[0] = grad[0];
      strain[1] = grad[4];
      strain[2] = 0.0;
      strain[3] = grad[1] + grad[3];
    } else if constexpr (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRESS) {
      strain[0] = grad[0];
      strain[1] = grad[4];
      strain[2] = grad[1] + grad[3];
    } else if constexpr (MODEL_TYPE == MatOps::MODEL_AXISYMMETRIC) {
      strain[0] = grad[0];
      strain[1] = grad[4];
      strain[2] = grad[8];
      strain[3] = grad[1] + grad[3];
    } else {
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "UMAT strain increment is not implemented for this model type");
    }
  };
 
  std::array<double, NTENS> reference_strain{};
  std::array<double, NTENS> current_strain{};
  get_small_strain_voigt(dfgrd0, reference_strain);
  get_small_strain_voigt(dfgrd1, current_strain);
 
  for (int ii = 0; ii != NTENS; ++ii) {
    stran[ii] = reference_strain[ii];
    dstran[ii] = current_strain[ii] - reference_strain[ii];
  }
 
  MoFEMFunctionReturn(0);
}

setTimeData()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::setTimeData	(	double	current_time,
		double	time_increment
	)

Definition at line 149 of file UmatInterface.cpp.

                                                                     {
  MoFEMFunctionBegin;
 
  time[1] = current_time;
  dtime = time_increment;
  time[0] = current_time - time_increment;
 
  MoFEMFunctionReturn(0);
}

storeStateVar()

template<int MODEL_TYPE>

MoFEMErrorCode MoFEM::UmatInterface< MODEL_TYPE >::storeStateVar	(	int	n_state_var,
		const std::vector< double > &	state_var_values
	)

Definition at line 224 of file UmatInterface.cpp.

                                                             {
  MoFEMFunctionBegin;
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

celent

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::celent = 0.0

Definition at line 106 of file UmatInterface.hpp.

cmname

template<int MODEL_TYPE>

char MoFEM::UmatInterface< MODEL_TYPE >::cmname[80]

Definition at line 100 of file UmatInterface.hpp.

coords

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::coords[3] = {}

Definition at line 99 of file UmatInterface.hpp.

{};

ddsdde

template<int MODEL_TYPE>

std::array<double, NTANGENT> MoFEM::UmatInterface< MODEL_TYPE >::ddsdde {}

Definition at line 91 of file UmatInterface.hpp.

{};

ddsddt

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::ddsddt[6]

Definition at line 97 of file UmatInterface.hpp.

dfgrd0

template<int MODEL_TYPE>

std::array<double, 9> MoFEM::UmatInterface< MODEL_TYPE >::dfgrd0 {}

Definition at line 93 of file UmatInterface.hpp.

{}; // F at start of increment

dfgrd1

template<int MODEL_TYPE>

std::array<double, 9> MoFEM::UmatInterface< MODEL_TYPE >::dfgrd1 {}

Definition at line 94 of file UmatInterface.hpp.

{}; // F at end   of increment

DIM

template<int MODEL_TYPE>

constexpr int MoFEM::UmatInterface< MODEL_TYPE >::DIM

staticconstexpr

Initial value:

= (MODEL_TYPE == MatOps::MODEL_3D ||
                              MODEL_TYPE == MatOps::MODEL_AXISYMMETRIC) ? 3 : 2

Definition at line 32 of file UmatInterface.hpp.

dpred

template<int MODEL_TYPE>

std::vector<double> MoFEM::UmatInterface< MODEL_TYPE >::dpred {0.0}

Definition at line 105 of file UmatInterface.hpp.

{0.0};

drot

template<int MODEL_TYPE>

std::array<double, 9> MoFEM::UmatInterface< MODEL_TYPE >::drot {}

Definition at line 95 of file UmatInterface.hpp.

{};

drplde

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::drplde[6]

Definition at line 98 of file UmatInterface.hpp.

drpldt

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::drpldt = 0.0

Definition at line 107 of file UmatInterface.hpp.

dstran

template<int MODEL_TYPE>

std::array<double, NTENS> MoFEM::UmatInterface< MODEL_TYPE >::dstran {}

Definition at line 89 of file UmatInterface.hpp.

{}; // strain increment

dtemp

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::dtemp = 0.0

Definition at line 103 of file UmatInterface.hpp.

dtime

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::dtime = 0.0

Definition at line 102 of file UmatInterface.hpp.

filename

template<int MODEL_TYPE>

char MoFEM::UmatInterface< MODEL_TYPE >::filename[256] = {}

Definition at line 72 of file UmatInterface.hpp.

{};

handle

template<int MODEL_TYPE>

void* MoFEM::UmatInterface< MODEL_TYPE >::handle = nullptr

Definition at line 71 of file UmatInterface.hpp.

kinc

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::kinc = 1

Definition at line 81 of file UmatInterface.hpp.

kspt

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::kspt = 1

Definition at line 81 of file UmatInterface.hpp.

kstep

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::kstep = 1

Definition at line 81 of file UmatInterface.hpp.

layer

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::layer = 1

Definition at line 81 of file UmatInterface.hpp.

matOpsDataPtr

template<int MODEL_TYPE>

boost::shared_ptr<MatOps::MatOpsData> MoFEM::UmatInterface< MODEL_TYPE >::matOpsDataPtr

Definition at line 68 of file UmatInterface.hpp.

NDI

template<int MODEL_TYPE>

constexpr int MoFEM::UmatInterface< MODEL_TYPE >::NDI

staticconstexpr

Initial value:

= (MODEL_TYPE == MatOps::MODEL_3D) ? 3
                             : (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRESS)
                                 ? 2
                                 : 3

Definition at line 74 of file UmatInterface.hpp.

ndi

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::ndi = NDI

Definition at line 80 of file UmatInterface.hpp.

noel

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::noel = 1

Definition at line 81 of file UmatInterface.hpp.

nprops

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::nprops

Definition at line 80 of file UmatInterface.hpp.

npt

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::npt = 1

Definition at line 81 of file UmatInterface.hpp.

NSHR

template<int MODEL_TYPE>

constexpr int MoFEM::UmatInterface< MODEL_TYPE >::NSHR = (MODEL_TYPE == MatOps::MODEL_3D) ? 3 : 1

staticconstexpr

Definition at line 78 of file UmatInterface.hpp.

nshr

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::nshr = NSHR

Definition at line 80 of file UmatInterface.hpp.

nstatv

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::nstatv

Definition at line 80 of file UmatInterface.hpp.

NTANGENT

template<int MODEL_TYPE>

constexpr int MoFEM::UmatInterface< MODEL_TYPE >::NTANGENT = NTENS * NTENS

staticconstexpr

Definition at line 40 of file UmatInterface.hpp.

NTENS

template<int MODEL_TYPE>

constexpr int MoFEM::UmatInterface< MODEL_TYPE >::NTENS

staticconstexpr

Initial value:

= (MODEL_TYPE == MatOps::MODEL_3D) ? 6
                               : (MODEL_TYPE == MatOps::MODEL_2D_PLANE_STRESS)
                                   ? 3
                                   : 4

Definition at line 35 of file UmatInterface.hpp.

ntens

template<int MODEL_TYPE>

int MoFEM::UmatInterface< MODEL_TYPE >::ntens = NTENS

Definition at line 80 of file UmatInterface.hpp.

pnewdt

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::pnewdt = 1.0

Definition at line 106 of file UmatInterface.hpp.

predef

template<int MODEL_TYPE>

std::vector<double> MoFEM::UmatInterface< MODEL_TYPE >::predef {0.0}

Definition at line 104 of file UmatInterface.hpp.

{0.0};

props

template<int MODEL_TYPE>

std::vector<double> MoFEM::UmatInterface< MODEL_TYPE >::props

Definition at line 83 of file UmatInterface.hpp.

rpl

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::rpl = 0.0

Definition at line 107 of file UmatInterface.hpp.

scd

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::scd = 0.0

Definition at line 107 of file UmatInterface.hpp.

spd

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::spd = 0.0

Definition at line 107 of file UmatInterface.hpp.

sse

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::sse = 0.0

Definition at line 107 of file UmatInterface.hpp.

statev

template<int MODEL_TYPE>

std::vector<double> MoFEM::UmatInterface< MODEL_TYPE >::statev

Definition at line 84 of file UmatInterface.hpp.

stran

template<int MODEL_TYPE>

std::array<double, NTENS> MoFEM::UmatInterface< MODEL_TYPE >::stran {}

Definition at line 88 of file UmatInterface.hpp.

{};  // total strain at start of increment

stress

template<int MODEL_TYPE>

std::array<double, NTENS> MoFEM::UmatInterface< MODEL_TYPE >::stress {}

Definition at line 87 of file UmatInterface.hpp.

{}; // Cauchy stress at end of step

temp

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::temp = 0.0

Definition at line 103 of file UmatInterface.hpp.

time

template<int MODEL_TYPE>

double MoFEM::UmatInterface< MODEL_TYPE >::time[2] = {}

Definition at line 101 of file UmatInterface.hpp.

{};

umat

template<int MODEL_TYPE>

umat_f MoFEM::UmatInterface< MODEL_TYPE >::umat = nullptr

Definition at line 70 of file UmatInterface.hpp.

---

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

• src/materials/UmatInterface.hpp
• src/materials/impl/UmatInterface.cpp