#include "users_modules/adolc-plasticity/src/ADOLCPlasticityMaterialModels.hpp"

Inheritance diagram for ADOLCPlasticity::ParaboloidalPlasticity:

Collaboration diagram for ADOLCPlasticity::ParaboloidalPlasticity:

Public Types
enum	ModelParams { LAMBDA , MU , NUP , SIGMA_YT , SIGMA_YC , HT , HC , NT , NC , LAST_PARAM }

using	ParamsArray = std::array<double, LAST_PARAM>

Public Types inherited from ADOLCPlasticity::ClosestPointProjection
enum	TypesTags { W = 0 , Y , H , LAST_TAPE }

Public Member Functions
	ParaboloidalPlasticity ()

MoFEMErrorCode	getDefaultMaterialParameters ()

MoFEMErrorCode	addMatBlockOps (MoFEM::Interface &m_field, boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip, std::string block_name, Sev sev)
	Get model parameters from blocks.

MoFEMErrorCode	setParams (short tag, bool &recalculate_elastic_tangent)
	Set parameters for ADOL-C of constitutive relations.

MoFEMErrorCode	freeHemholtzEnergy ()
	[Paraboloidal free energy]

MoFEMErrorCode	codedHessianW (vector< double * > hessian)
	[Paraboloidal free energy]

MoFEMErrorCode	evalF ()
	[Paraboloidal yield function]

MoFEMErrorCode	yieldFunction ()
	Set yield function.

MoFEMErrorCode	flowPotential ()
	[Paraboloidal yield function]

Public Member Functions inherited from ADOLCPlasticity::ClosestPointProjection
VectorAdaptor	getPlasticStrain ()

VectorAdaptor	getTotalStrain ()

VectorAdaptor	getInternalVariables ()

VectorAdaptor	getActiveVariablesYH ()

VectorAdaptor	getStress ()

VectorAdaptor	getInternalFluxes ()

	ClosestPointProjection ()

MoFEMErrorCode	recordW ()
	Record strain energy.

MoFEMErrorCode	recordY ()
	Record yield function.

MoFEMErrorCode	recordH ()
	Record flow potential.

MoFEMErrorCode	playW ()

MoFEMErrorCode	playW_NoHessian ()

MoFEMErrorCode	playY ()

MoFEMErrorCode	playY_NoGradient ()

MoFEMErrorCode	playH ()

MoFEMErrorCode	playH_NoHessian ()

MoFEMErrorCode	createMatAVecR ()

MoFEMErrorCode	evaluatePotentials ()

MoFEMErrorCode	playPotentials ()

MoFEMErrorCode	playPotentials_NoHessian ()

MoFEMErrorCode	calculateR (Vec R)

MoFEMErrorCode	calculateA ()

MoFEMErrorCode	snesCreate ()
	Create nested snes.

MoFEMErrorCode	solveClosestProjection ()
	Solve nonlinear system of equations to find stress, internal fluxes, and Lagrange plastic multiplier.

MoFEMErrorCode	consistentTangent ()
	Calculate consistent tangent matrix.

MoFEMErrorCode	recordTapes ()
	Record tapes.

Public Attributes
FTensor::Index< 'i', 3 >	i

FTensor::Index< 'j', 3 >	j

FTensor::Index< 'Z', 6 >	Z

FTensor::Tensor2_symmetric< adouble, 3 >	tTotalStrain

FTensor::Tensor2_symmetric< adouble, 3 >	tPlasticStrain

FTensor::Tensor2_symmetric< adouble, 3 >	tElasticStrain

FTensor::Tensor2_symmetric< adouble, 3 >	tStress

FTensor::Tensor2_symmetric< adouble, 3 >	tDeviator

adouble	tR

double	lambda

double	mu

double	nup

double	Ht

double	Hc

double	sigmaYt

double	sigmaYc

double	nt

double	nc

boost::shared_ptr< ParamsArray >	defaultParamsArrayPtr = nullptr

boost::shared_ptr< ParamsArray >	paramsArrayPtr = nullptr

boost::shared_ptr< ParamsArray >	oldParamsArrayPtr = nullptr

adouble	I1

adouble	J2

Public Attributes inherited from ADOLCPlasticity::ClosestPointProjection
int	nbInternalVariables

boost::function< int(int, int, int)>	integrationRule

VectorDouble	internalVariables0

VectorDouble	plasticStrain0

std::array< int, LAST_TAPE >	tapesTags

VectorAdaptor	activeVariablesW

VectorAdaptor	gradientW

double	w

double	y

double	h

double	deltaGamma

MatrixDouble	Ep

MatrixDouble	Cp

MatrixDouble	Cep

ublas::symmetric_matrix< double, ublas::lower >	C

ublas::symmetric_matrix< double, ublas::lower >	D

PetscBool	implHessianW

MatrixDouble	hessianW

VectorDouble	gradientY

VectorDouble	gradientH

MatrixDouble	hessianH

MatrixDouble	partialWStrainPlasticStrain

VectorAdaptor	partialYSigma

VectorAdaptor	partialYFlux

VectorAdaptor	partialHSigma

VectorAdaptor	partialHFlux

ublas::symmetric_matrix< double, ublas::lower >	partial2HSigma

ublas::symmetric_matrix< double, ublas::lower >	partial2HFlux

MatrixDouble	partial2HSigmaFlux

SmartPetscObj< Mat >	A

SmartPetscObj< Vec >	R

SmartPetscObj< Vec >	Chi

SmartPetscObj< Vec >	dChi

ublas::matrix< double, ublas::column_major >	dataA

SmartPetscObj< SNES >	sNes

ublas::vector< adouble >	a_sTrain

ublas::vector< adouble >	a_plasticStrain

ublas::vector< adouble >	a_internalVariables

ublas::vector< adouble >	a_sTress

ublas::vector< adouble >	a_internalFluxes

adouble	a_w

adouble	a_y

adouble	a_h

Detailed Description

[J2 2D]

Paraboloidal yield criterion

See paper for reference [ullah2017three] and [stier2015comparing]

Linear hardening

\[ \psi = \frac{1}{2} \lambda \textrm{tr}[\varepsilon]^2 + \mu \varepsilon : \varepsilon + \sigma_{yt}\alpha_0 + \frac{1}{2} H_t \alpha_0^2 + \sigma_{yc}\alpha_1 + \frac{1}{2} H_c \alpha_1^2 \]

Exponential hardening

\[ \psi = \frac{1}{2} \lambda \textrm{tr}[\varepsilon]^2 + \mu \varepsilon : \varepsilon\\ + (\sigma_{yt}+H_t)\alpha_0 + \frac{H_t}{n_t} \exp{(-n_t \alpha_0)}\\ + (\sigma_{yc}+H_c)\alpha_0 + \frac{H_c}{n_c} \exp{(-n_c \alpha_1)} \]

\[ I_1 = \textrm{tr} (\boldsymbol{\sigma}) \]

\[ \eta=\textrm{dev}[\boldsymbol{\sigma}] \]

\[ J_2 = \frac{1}{2} \eta:\eta \]

\[ y = 6J_2 + 2I_1\left(\overline{\alpha_1}-\overline{\alpha_0}\right) - 2\overline{\alpha_0} \,\overline{\alpha_1} \]

where

\[ \overline{\alpha_0}=\frac{\partial \psi}{\partial \alpha_0}=\sigma_{yt} + H_t \alpha_0 \]

\[ \overline{\alpha_1}=\frac{\partial \psi}{\partial \alpha_1}=\sigma_{yc} + H_c \alpha_1 \]

\[ \Psi = 6J_2 + 2\alpha I_1 \left(\overline{\alpha_1}-\overline{\alpha_0}\right) - 2\overline{\alpha_0} \,\overline{\alpha_1} \]

\[ \alpha= \frac{1-2\nu_p}{1+\nu_p} \]

Definition at line 596 of file ADOLCPlasticityMaterialModels.hpp.

Member Typedef Documentation

◆ ParamsArray

using ADOLCPlasticity::ParaboloidalPlasticity::ParamsArray = std::array<double, LAST_PARAM>

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 635 of file ADOLCPlasticityMaterialModels.hpp.

Member Enumeration Documentation

◆ ModelParams

enum ADOLCPlasticity::ParaboloidalPlasticity::ModelParams

Enumerator
LAMBDA
MU
NUP
SIGMA_YT
SIGMA_YC
HT
HC
NT
NC
LAST_PARAM

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 622 of file ADOLCPlasticityMaterialModels.hpp.

                   {
    LAMBDA,
    MU,
    NUP,
    SIGMA_YT,
    SIGMA_YC,
    HT,
    HC,
    NT,
    NC,
    LAST_PARAM
  };

Constructor & Destructor Documentation

◆ ParaboloidalPlasticity()

ADOLCPlasticity::ParaboloidalPlasticity::ParaboloidalPlasticity ( )

inline

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 598 of file ADOLCPlasticityMaterialModels.hpp.

                           : ClosestPointProjection() {
    nbInternalVariables = 2;
    activeVariablesW.resize(12 + nbInternalVariables, false);
  }

Member Function Documentation

◆ addMatBlockOps()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::addMatBlockOps	(	MoFEM::Interface &	m_field,
		boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &	pip,
		std::string	block_name,
		Sev	sev )

inlinevirtual

Get model parameters from blocks.

Reimplemented from ADOLCPlasticity::ClosestPointProjection.

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 714 of file ADOLCPlasticityMaterialModels.hpp.

                                                {
    MoFEMFunctionBegin;
 
    struct OpMatBlocks : public ForcesAndSourcesCore::UserDataOperator {
 
      using OP = ForcesAndSourcesCore::UserDataOperator;
 
      OpMatBlocks(boost::shared_ptr<ParamsArray> params_array_ptr,
                  boost::shared_ptr<ParamsArray> def_params_array_ptr,
                  MoFEM::Interface &m_field, Sev sev,
                  std::vector<const CubitMeshSets *> meshset_vec_ptr)
          : OP(NOSPACE, OP::OPSPACE), paramsArrayPtr(params_array_ptr),
            defParamsArray(def_params_array_ptr) {
        CHK_THROW_MESSAGE(extractBlockData(m_field, meshset_vec_ptr, sev),
                          "Can not get data from block");
      }
 
      MoFEMErrorCode doWork(int side, EntityType type,
                            EntitiesFieldData::EntData &data) {
        MoFEMFunctionBegin;
 
        for (auto &b : blockData) {
 
          if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
            std::copy(b.paramsArray.begin(), b.paramsArray.end(),
                      paramsArrayPtr->begin());
            MoFEMFunctionReturnHot(0);
          }
        }
 
        std::copy(defParamsArray->begin(), defParamsArray->end(),
                  paramsArrayPtr->begin());
 
        MoFEMFunctionReturn(0);
      }
 
    private:
      boost::shared_ptr<ParamsArray> paramsArrayPtr;
      boost::shared_ptr<ParamsArray> defParamsArray;
 
      struct BlockData {
        ParamsArray paramsArray;
        Range blockEnts;
      };
 
      std::vector<BlockData> blockData;
 
      MoFEMErrorCode
      extractBlockData(MoFEM::Interface &m_field,
                       std::vector<const CubitMeshSets *> meshset_vec_ptr,
                       Sev sev) {
        MoFEMFunctionBegin;
 
        for (auto m : meshset_vec_ptr) {
          MOFEM_TAG_AND_LOG("ADOLCPlasticityWold", sev, "Paraboloidal") << *m;
          std::vector<double> block_data;
          CHKERR m->getAttributes(block_data);
          if (block_data.size() != 9) {
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                    "Expected that block has nine attributes");
          }
          auto get_block_ents = [&]() {
            Range ents;
            CHKERR
            m_field.get_moab().get_entities_by_handle(m->meshset, ents, true);
            return ents;
          };
 
          blockData.push_back({*defParamsArray, get_block_ents()});
          std::copy(block_data.begin(), block_data.end(),
                    blockData.back().paramsArray.begin());
 
          const auto young_modulus = blockData.back().paramsArray[LAMBDA];
          const auto poisson_ratio = blockData.back().paramsArray[MU];
 
          // It is assumed that user provide young_modulus and poisson_ratio in
          // first two arguments of the block
 
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "Young modulus: " << (blockData.back().paramsArray)[LAMBDA];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "Poisson ratio: " << (blockData.back().paramsArray)[MU];
 
          blockData.back().paramsArray[LAMBDA] =
              LAMBDA(young_modulus, poisson_ratio);
          blockData.back().paramsArray[MU] = MU(young_modulus, poisson_ratio);
 
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "LAMBDA: " << (blockData.back().paramsArray)[LAMBDA];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "MU: " << (blockData.back().paramsArray)[MU];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "NUP: " << (blockData.back().paramsArray)[NUP];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "SIGMA_YT: " << (blockData.back().paramsArray)[SIGMA_YT];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "SIGMA_YC: " << (blockData.back().paramsArray)[SIGMA_YC];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "HT: " << (blockData.back().paramsArray)[HT];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "HC: " << (blockData.back().paramsArray)[HC];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "NT: " << (blockData.back().paramsArray)[NT];
          MOFEM_LOG("ADOLCPlasticityWold", sev)
              << "NC: " << (blockData.back().paramsArray)[NC];
        }
        MoFEMFunctionReturn(0);
      }
    };
 
    auto cubit_meshsets_vec_ptr =
        m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(
            std::regex((boost::format("%s(.*)") % block_name).str()));
 
    pip.push_back(new OpMatBlocks(paramsArrayPtr, defaultParamsArrayPtr,
                                  m_field, sev, cubit_meshsets_vec_ptr));
 
    MoFEMFunctionReturn(0);
  }

◆ codedHessianW()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::codedHessianW ( vector< double * > hessian )

inlinevirtual

[Paraboloidal free energy]

Reimplemented from ADOLCPlasticity::ClosestPointProjection.

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 900 of file ADOLCPlasticityMaterialModels.hpp.

  {
    MoFEMFunctionBegin;
    // first 6x6 is \frac{\partial^2 \psi}{\partial \varepsilon^p^2}
    // lower symmetric part
 
    lambda = (*paramsArrayPtr)[0];
    mu = (*paramsArrayPtr)[1];
    
    Ht = (*paramsArrayPtr)[5];
    Hc = (*paramsArrayPtr)[6];
 
    double lambda_plus_2mu = lambda + 2 * mu;
    
    // Diagonal elements
    hessian[0][0] = lambda_plus_2mu;
    hessian[1][1] = lambda_plus_2mu;
    hessian[2][2] = lambda_plus_2mu;
    
    // Off-diagonal elements
    hessian[1][0] = lambda;
    hessian[2][0] = lambda;
    hessian[2][1] = lambda;
    
    // Shear components
    for (int i = 3; i <= 5; ++i) {
        hessian[i][i] = mu;
    }
 
    //next 6x6 is \frac{\partial^2 \psi}{\partial \varepsilon \partial \varepsilon^p}
    double neg_lambda_plus_2mu = -(lambda + 2 * mu);
    double neg_lambda = -lambda;
    double neg_mu = -mu;
 
    for (int i = 6; i <= 8; ++i) {
      for (int j = 0; j <= 2; ++j) {
        hessian[i][j] = (i - 6 == j) ? neg_lambda_plus_2mu : neg_lambda;
      }
    }
 
    hessian[9][3] = neg_mu;
    hessian[10][4] = neg_mu;
    hessian[11][5] = neg_mu;
 
    //next 6x6 is \frac{\partial^2 \psi}{\partial \varepsilon \partial \varepsilon}
    hessian[6][6] = lambda_plus_2mu;
    hessian[7][6] = lambda;
    hessian[7][7] = lambda_plus_2mu;
    hessian[8][6] = lambda;
    hessian[8][7] = lambda;
    hessian[8][8] = lambda_plus_2mu;
    hessian[9][9] = mu;
    hessian[10][10] = mu;
    hessian[11][11] = mu;
 
    // internalVariables is \frac{\partial^2 \psi}{\partial \alpha^2}
    hessian[12][12] = Ht;
    hessian[13][13] = Hc;
 
    MoFEMFunctionReturn(0);
  }

◆ evalF()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::evalF ( )

inline

[Paraboloidal yield function]

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 965 of file ADOLCPlasticityMaterialModels.hpp.

                         {
    MoFEMFunctionBegin;
    auto t_voight_stress_op = voight_to_stress_op();
    auto t_vioght_stress = getFTensor1FromPtr<6>(&a_sTress[0]);
    tStress(i, j) = t_voight_stress_op(i, j, Z) * t_vioght_stress(Z);
    tR = tStress(i, i);
    I1 = tR;
    constexpr auto t_kd = FTensor::Kronecker_Delta_symmetric<double>();
    tR /= 3.;
    tDeviator(i, j) = tStress(i, j) - tR * t_kd(i, j);
    J2 = 0.5 * (tDeviator(i, j) * tDeviator(i, j));
    MoFEMFunctionReturn(0);
  }

◆ flowPotential()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::flowPotential ( )

inlinevirtual

[Paraboloidal yield function]

[Paraboloidal flow potential]

Implements ADOLCPlasticity::ClosestPointProjection.

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 989 of file ADOLCPlasticityMaterialModels.hpp.

                                 {
    MoFEMFunctionBegin;
    CHKERR evalF();
    double alpha =
        (1 - 2 * nup) /
        (1 + nup); // relation between alpha and plastic poisson's ratio
    a_h = 6 * J2 +
          2 * alpha * I1 * (a_internalFluxes[1] - a_internalFluxes[0]) -
          2 * a_internalFluxes[0] * a_internalFluxes[1];
    MoFEMFunctionReturn(0);
  }

◆ freeHemholtzEnergy()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::freeHemholtzEnergy ( )

inlinevirtual

[Paraboloidal free energy]

Implements ADOLCPlasticity::ClosestPointProjection.

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 864 of file ADOLCPlasticityMaterialModels.hpp.

                                      {
    MoFEMFunctionBegin;
 
    auto p_lambda = mkparam(lambda);  // 0
    auto p_mu = mkparam(mu);          // 1
    auto p_nup = mkparam(nup);            // 2
    auto p_sigma_yt = mkparam(sigmaYt); // 3
    auto p_sigma_yc = mkparam(sigmaYc); // 4
    auto p_Ht = mkparam(Ht);            // 5
    auto p_Hc = mkparam(Hc);            // 6
    auto p_nt = mkparam(nt);            // 7
    auto p_nc = mkparam(nc);            // 8
 
    auto t_voight_strain_op = voight_to_strain_op();
    auto t_voight_total_strain = getFTensor1FromPtr<6>(&a_sTrain[0]);
    auto t_voight_plastic_strain = getFTensor1FromPtr<6>(&a_plasticStrain[0]);
 
    tTotalStrain(i, j) = t_voight_strain_op(i, j, Z) * t_voight_total_strain(Z);
    tPlasticStrain(i, j) =
        t_voight_strain_op(i, j, Z) * t_voight_plastic_strain(Z);
    tElasticStrain(i, j) = tTotalStrain(i, j) - tPlasticStrain(i, j);
    tR = tElasticStrain(i, i);
 
    a_w = 0.5 * p_lambda * tR * tR +
          p_mu * (tElasticStrain(i, j) * tElasticStrain(i, j));
 
    a_w += p_sigma_yt * a_internalVariables[0] +
           0.5 * p_Ht * a_internalVariables[0] * a_internalVariables[0];
    a_w += p_sigma_yc * a_internalVariables[1] +
           0.5 * p_Hc * a_internalVariables[1] * a_internalVariables[1];
 
    MoFEMFunctionReturn(0);
  }

◆ getDefaultMaterialParameters()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::getDefaultMaterialParameters ( )

inline

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 640 of file ADOLCPlasticityMaterialModels.hpp.

                                                {
    MoFEMFunctionBegin;
 
    double young_modulus = 1;
    double poisson_ratio = 0.25;
 
    sigmaYt = 1;
    sigmaYc = 1;
    Ht = 0.1;
    Hc = 0.1;
    nc = 1.;
    nt = 1.;
    nup = 0.;
 
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-young_modulus", &young_modulus,
                                 PETSC_NULLPTR);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-poisson_ratio", &poisson_ratio,
                                 0);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-sigma_yt", &sigmaYt, PETSC_NULLPTR);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-sigma_yc", &sigmaYc, PETSC_NULLPTR);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-Ht", &Ht, PETSC_NULLPTR);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-Hc", &Hc, PETSC_NULLPTR);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-nt", &nt, PETSC_NULLPTR);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-nc", &nc, PETSC_NULLPTR);
    CHKERR PetscOptionsGetScalar(PETSC_NULLPTR, "-nup", &nup, PETSC_NULLPTR);
 
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "Young modulus: " << young_modulus;
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "Poisson ratio: " << poisson_ratio;
 
    mu = MU(young_modulus, poisson_ratio);
    lambda = LAMBDA(young_modulus, poisson_ratio);
 
    defaultParamsArrayPtr = boost::make_shared<ParamsArray>();
    (*defaultParamsArrayPtr)[LAMBDA] = lambda;
    (*defaultParamsArrayPtr)[MU] = mu;
    (*defaultParamsArrayPtr)[NUP] = nup;
    (*defaultParamsArrayPtr)[SIGMA_YT] = sigmaYt;
    (*defaultParamsArrayPtr)[SIGMA_YC] = sigmaYc;
    (*defaultParamsArrayPtr)[HT] = Ht;
    (*defaultParamsArrayPtr)[HC] = Hc;
    (*defaultParamsArrayPtr)[NT] = nt;
    (*defaultParamsArrayPtr)[NC] = nc;
 
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "LAMBDA: " << (*defaultParamsArrayPtr)[LAMBDA];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "MU: " << (*defaultParamsArrayPtr)[MU];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "NUP: " << (*defaultParamsArrayPtr)[NUP];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "SIGMA_YT: " << (*defaultParamsArrayPtr)[SIGMA_YT];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "SIGMA_YC: " << (*defaultParamsArrayPtr)[SIGMA_YC];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "HT: " << (*defaultParamsArrayPtr)[HT];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "HC: " << (*defaultParamsArrayPtr)[HC];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "NT: " << (*defaultParamsArrayPtr)[NT];
    MOFEM_LOG("ADOLCPlasticityWold", Sev::inform)
        << "NC: " << (*defaultParamsArrayPtr)[NC];
 
    paramsArrayPtr = boost::make_shared<ParamsArray>();
    std::copy(defaultParamsArrayPtr->begin(), defaultParamsArrayPtr->end(),
              paramsArrayPtr->begin());
    oldParamsArrayPtr = boost::make_shared<ParamsArray>();
    std::fill(oldParamsArrayPtr->begin(), oldParamsArrayPtr->end(), 0);
 
    MoFEMFunctionReturn(0);
  };

◆ setParams()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::setParams	(	short	tag,
		bool &	recalculate_elastic_tangent )

inlinevirtual

Set parameters for ADOL-C of constitutive relations.

Parameters

tag	[in] - tag of the tape
recalculate_elastic_tangent	[out] - if setParam set it to true, tangent matrix for elastic domain should be recalculated

Reimplemented from ADOLCPlasticity::ClosestPointProjection.

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 836 of file ADOLCPlasticityMaterialModels.hpp.

                                                                         {
        MoFEMFunctionBegin;
    switch (tag) {
    case TypesTags::W: {
      set_param_vec(tapesTags[tag], paramsArrayPtr->size(),
                    paramsArrayPtr->data());
      for (auto p = 0; p != LAST_PARAM; p++) {
        if ((*paramsArrayPtr)[p] != (*oldParamsArrayPtr)[p]) {
          recalculate_elastic_tangent = true;
          std::copy(paramsArrayPtr->begin(), paramsArrayPtr->end(),
                    oldParamsArrayPtr->begin());
          break;
        }
      }
 
    } break;
    case TypesTags::Y:
    case TypesTags::H:
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Unknown tag for setParams");
    }
    MoFEMFunctionReturn(0);
    return 0;
  }

◆ yieldFunction()

MoFEMErrorCode ADOLCPlasticity::ParaboloidalPlasticity::yieldFunction ( )

inlinevirtual

Set yield function.

Implements ADOLCPlasticity::ClosestPointProjection.

Examples: ADOLCPlasticityMaterialModels.hpp.

Definition at line 979 of file ADOLCPlasticityMaterialModels.hpp.

                                 {
    MoFEMFunctionBegin;
    CHKERR evalF();
    a_y = 6 * J2 + 2 * I1 * (a_internalFluxes[1] - a_internalFluxes[0]) -
          2 * a_internalFluxes[0] * a_internalFluxes[1];
    MoFEMFunctionReturn(0);
  }