#include "users_modules/eshelbian_plasticity/src/impl/PlasticIncrementalOptimizationInternal.hpp"

Inheritance diagram for EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw:

Collaboration diagram for EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw:

Public Types
using	IncrementTensor = FTensor::Tensor1< double, plasticLogarithmicStretchCoordinateSize >

using	GradientTensor = FTensor::Tensor1< double, plasticLocalLawActiveCount >

using	DirectionTensor = FTensor::Tensor1< double, plasticLocalLawActiveCount >

using	HessianActionTensor = FTensor::Tensor1< double, plasticLocalLawActiveCount >

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

Public Member Functions
	PlasticLocalLaw (boost::shared_ptr< MatOps::MatOpsData > mat_ops_data_ptr, int tag)

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

MoFEMErrorCode	setParams (FEMethod *fe_ptr, int gg) override

MoFEMErrorCode	recordTape () override

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

MoFEMErrorCode	setParameters (const PlasticLocalLawParameters &parameters)

const PlasticLocalLawParameters &	getParameters () const

MoFEMErrorCode	evaluateValue (const IncrementTensor &t_increment, double latent, PlasticLocalLawTerms &terms)

MoFEMErrorCode	evaluateGradient (const IncrementTensor &t_increment, double latent, GradientTensor &t_gradient)

MoFEMErrorCode	evaluateHessianAction (const IncrementTensor &t_increment, double latent, const DirectionTensor &t_direction, HessianActionTensor &t_hessian_action)

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	setParams (FEMethod *fe_ptr, int gg)=0

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)

virtual ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent, bool update)=0

virtual MoFEMErrorCode	evaluateVariable (int tag, EntityHandle entity, int gg)

virtual MoFEMErrorCode	evaluateDerivatives (int tag, EntityHandle entity, int gg)

virtual MoFEMErrorCode	updateState (int tag, EntityHandle entity, int gg)

Static Public Attributes
static constexpr const char *	tapeName = "EshelbianPlasticLocalLaw"

static constexpr const char *	incrementDataName = "plastic_increment"

static constexpr const char *	latentDataName = "plastic_latent"

static constexpr const char *	densityDataName = "plastic_density"

static constexpr const char *	densityGradientDataName

Private Member Functions
MoFEMErrorCode	applyParameters ()

MoFEMErrorCode	setActiveVariables (const IncrementTensor &t_increment, double latent)

Private Attributes
PlasticLocalLawParameters	currentParameters {1., 0., 0., 0., 1., 1.}

std::vector< double >	parameterVector

bool	tapeRecorded = false

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

ADOL-C tape of the local density as a MatOps physical equation.

Active variables are the pointwise field values (five trace-free coordinates of Delta H^p, then psi), never P0 coefficients, so the same tape serves every polynomial order. Parameters are set per point with setParameters(); the tape is recorded once. The coefficient gradient rows (basis functions, reference-volume weights) are assembled by the calling operator, not here. createOp() is intentionally unsupported: EP operators call the point evaluators directly.

Definition at line 144 of file PlasticIncrementalOptimizationInternal.hpp.

Member Typedef Documentation

◆ DirectionTensor

using EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::DirectionTensor = FTensor::Tensor1<double, plasticLocalLawActiveCount>

Definition at line 155 of file PlasticIncrementalOptimizationInternal.hpp.

◆ GradientTensor

using EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::GradientTensor = FTensor::Tensor1<double, plasticLocalLawActiveCount>

Definition at line 154 of file PlasticIncrementalOptimizationInternal.hpp.

◆ HessianActionTensor

using EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::HessianActionTensor = FTensor::Tensor1<double, plasticLocalLawActiveCount>

Definition at line 156 of file PlasticIncrementalOptimizationInternal.hpp.

◆ IncrementTensor

using EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::IncrementTensor = FTensor::Tensor1<double, plasticLogarithmicStretchCoordinateSize>

Definition at line 152 of file PlasticIncrementalOptimizationInternal.hpp.

Constructor & Destructor Documentation

◆ PlasticLocalLaw()

EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::PlasticLocalLaw	(	boost::shared_ptr< MatOps::MatOpsData >	mat_ops_data_ptr,
		int	tag
	)

Definition at line 998 of file PlasticIncrementalOptimizationOperators.cpp.

    : MatOps::PhysicalEquations(mat_ops_data_ptr, tag) {
  if (!matOpsDataPtr)
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                      "Plastic local law requires MatOps data");
  parameterVector.resize(plasticLocalLawParameterCount);
}

Member Function Documentation

◆ applyParameters()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::applyParameters ( )

private

Definition at line 1068 of file PlasticIncrementalOptimizationOperators.cpp.

                                                {
  MoFEMFunctionBegin;
  parameterVector = {currentParameters.yieldStress,
                     currentParameters.hardeningModulus,
                     currentParameters.committedKappa,
                     currentParameters.latentCentre,
                     currentParameters.proximalCoefficient,
                     currentParameters.regularisationEpsilon};
  if (tapeRecorded)
    set_param_vec(tAg, parameterVector.size(), parameterVector.data());
  MoFEMFunctionReturn(0);
}

◆ createOp()

ForcesAndSourcesCore::UserDataOperator * EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::createOp	(	boost::shared_ptr< MatOps::PhysicalEquations >	physical_ptr,
		bool	eval_stress,
		bool	eval_tangent,
		bool	update
	)

override

Definition at line 1018 of file PlasticIncrementalOptimizationOperators.cpp.

                                      {
  CHK_THROW_MESSAGE(MOFEM_NOT_IMPLEMENTED,
                    "Plastic local law has no generic operator; EP operators "
                    "call its point evaluators directly");
  return nullptr;
}

◆ evaluateGradient()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::evaluateGradient	(	const IncrementTensor &	t_increment,
		double	latent,
		GradientTensor &	t_gradient
	)

Euclidean gradient of the density w.r.t. (h_1..h_5, psi).

Definition at line 1173 of file PlasticIncrementalOptimizationOperators.cpp.

                                                                             {
  MoFEMFunctionBegin;
  CHKERR setActiveVariables(t_increment, latent);
  CHKERR evaluateDerivatives(tAg, 0, 0);
  auto &gradient_data =
      *matOpsDataPtr->getDependentDerivativesDataPtr(densityGradientDataName);
  for (int a = 0; a != plasticLocalLawActiveCount; ++a)
    t_gradient(a) = gradient_data.data()[a];
  MoFEMFunctionReturn(0);
}

◆ evaluateHessianAction()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::evaluateHessianAction	(	const IncrementTensor &	t_increment,
		double	latent,
		const DirectionTensor &	t_direction,
		HessianActionTensor &	t_hessian_action
	)

Hessian-vector product of the density in active-variable order.

Definition at line 1185 of file PlasticIncrementalOptimizationOperators.cpp.

                                                                               {
  MoFEMFunctionBegin;
  CHKERR setActiveVariables(t_increment, latent);
  std::array<double, plasticLocalLawActiveCount> active;
  std::array<double, plasticLocalLawActiveCount> direction;
  std::array<double, plasticLocalLawActiveCount> action;
  for (int l = 0; l != plasticLogarithmicStretchCoordinateSize; ++l) {
    active[l] = t_increment(l);
    direction[l] = t_direction(l);
  }
  active[plasticLogarithmicStretchCoordinateSize] = latent;
  direction[plasticLogarithmicStretchCoordinateSize] =
      t_direction(plasticLogarithmicStretchCoordinateSize);
  const int result = ::hess_vec(tAg, plasticLocalLawActiveCount, active.data(),
                                direction.data(), action.data());
  if (result < 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "ADOL-C plastic local-law Hessian action failed with code %d",
            result);
  for (int a = 0; a != plasticLocalLawActiveCount; ++a) {
    if (!std::isfinite(action[a]))
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
              "Plastic local-law Hessian action component %d is not finite", a);
    t_hessian_action(a) = action[a];
  }
  MoFEMFunctionReturn(0);
}

◆ evaluateValue()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::evaluateValue	(	const IncrementTensor &	t_increment,
		double	latent,
		PlasticLocalLawTerms &	terms
	)

Density from the tape; the other terms from the shared formula.

Definition at line 1152 of file PlasticIncrementalOptimizationOperators.cpp.

                                                                           {
  MoFEMFunctionBegin;
  CHKERR setActiveVariables(t_increment, latent);
  CHKERR evaluateVariable(tAg, 0, 0);
  terms = evaluatePlasticLocalLawTerms(t_increment, latent, currentParameters);
  const double tape_density =
      (*matOpsDataPtr->getDependentDataPtr(densityDataName))(0, 0);
#ifndef NDEBUG
  if (std::isfinite(tape_density) && std::isfinite(terms.density) &&
      std::abs(tape_density - terms.density) >
          1e-12 * std::max(1., std::abs(terms.density)))
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Plastic local law tape value %g differs from direct value %g",
            tape_density, terms.density);
#endif
  terms.density = tape_density;
  MoFEMFunctionReturn(0);
}

◆ getOptions()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::getOptions ( MoFEM::Interface * m_field_ptr = nullptr )

overridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 1007 of file PlasticIncrementalOptimizationOperators.cpp.

                                                           {
  // Parameters come from the optimisation problem and the state at each
  // point, not from material blocks or the command line.
  return 0;
}

◆ getParameters()

const PlasticLocalLawParameters & EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::getParameters ( ) const

inline

Definition at line 171 of file PlasticIncrementalOptimizationInternal.hpp.

                                                         {
    return currentParameters;
  }

◆ recordTape()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::recordTape ( )

overridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 1081 of file PlasticIncrementalOptimizationOperators.cpp.

                                           {
  MoFEMFunctionBegin;
  constexpr int nb_coords = plasticLogarithmicStretchCoordinateSize;
 
  matOpsDataPtr->insertActiveData(incrementDataName,
                                  MatrixDouble(nb_coords, 1));
  matOpsDataPtr->insertActiveData(latentDataName, MatrixDouble(1, 1));
  matOpsDataPtr->insertDependentData(densityDataName, MatrixDouble(1, 1));
  matOpsDataPtr->insertDependentDerivativesData(
      densityGradientDataName, MatrixDouble(plasticLocalLawActiveCount, 1));
  matOpsDataPtr->getActiveDataPtr(incrementDataName)
      ->resize(nb_coords, 1, false);
  matOpsDataPtr->getActiveDataPtr(latentDataName)->resize(1, 1, false);
  matOpsDataPtr->getDependentDataPtr(densityDataName)->resize(1, 1, false);
  matOpsDataPtr->getDependentDerivativesDataPtr(densityGradientDataName)
      ->resize(plasticLocalLawActiveCount, 1, false);
 
  auto &increment_data = *matOpsDataPtr->getActiveDataPtr(incrementDataName);
  auto &latent_data = *matOpsDataPtr->getActiveDataPtr(latentDataName);
  auto &density_data = *matOpsDataPtr->getDependentDataPtr(densityDataName);
  increment_data.clear();
  latent_data(0, 0) = 0;
 
  // The recording point is immaterial: the law is branch-free. Parameter
  // values recorded here are replaced by set_param_vec on every update.
  FTensor::Tensor1<adouble, nb_coords> ta_increment;
  adouble ta_latent;
  PlasticLocalLawParametersT<adouble> ta_parameters;
 
  trace_on(tAg);
  // Parameter order must match applyParameters().
  ta_parameters.yieldStress = mkparam(currentParameters.yieldStress);
  ta_parameters.hardeningModulus = mkparam(currentParameters.hardeningModulus);
  ta_parameters.committedKappa = mkparam(currentParameters.committedKappa);
  ta_parameters.latentCentre = mkparam(currentParameters.latentCentre);
  ta_parameters.proximalCoefficient =
      mkparam(currentParameters.proximalCoefficient);
  ta_parameters.regularisationEpsilon =
      mkparam(currentParameters.regularisationEpsilon);
  // Independent-variable order must match the MatOps active sequence:
  // increment coordinates first, then the latent value.
  for (int l = 0; l != nb_coords; ++l)
    ta_increment(l) <<= increment_data(l, 0);
  ta_latent <<= latent_data(0, 0);
  auto ta_terms =
      evaluatePlasticLocalLawTerms(ta_increment, ta_latent, ta_parameters);
  ta_terms.density >>= density_data(0, 0);
  trace_off();
 
  tapeRecorded = true;
  CHKERR applyParameters();
  MoFEMFunctionReturn(0);
}

◆ setActiveVariables()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::setActiveVariables	(	const IncrementTensor &	t_increment,
		double	latent
	)

private

Definition at line 1136 of file PlasticIncrementalOptimizationOperators.cpp.

                                                   {
  MoFEMFunctionBegin;
  if (!tapeRecorded)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Plastic local law tape is not recorded");
  auto &increment_data = *matOpsDataPtr->getActiveDataPtr(incrementDataName);
  auto &latent_data = *matOpsDataPtr->getActiveDataPtr(latentDataName);
  for (int l = 0; l != plasticLogarithmicStretchCoordinateSize; ++l) {
    increment_data(l, 0) = t_increment(l);
  }
  latent_data(0, 0) = latent;
  MoFEMFunctionReturn(0);
}

◆ setParameters()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::setParameters ( const PlasticLocalLawParameters & parameters )

Validate and apply parameters to the tape (set_param_vec).

Definition at line 1027 of file PlasticIncrementalOptimizationOperators.cpp.

                                                                          {
  MoFEMFunctionBegin;
  const auto finite = [](double v) { return std::isfinite(v); };
  if (!finite(parameters.yieldStress) || !(parameters.yieldStress > 0))
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Plastic local law: yield stress must be finite and positive; "
            "got %g",
            parameters.yieldStress);
  if (!finite(parameters.hardeningModulus) || parameters.hardeningModulus < 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Plastic local law: hardening modulus must be finite and "
            "non-negative; got %g",
            parameters.hardeningModulus);
  if (!finite(parameters.committedKappa) || parameters.committedKappa < 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Plastic local law: committed kappa must be finite and "
            "non-negative; got %g",
            parameters.committedKappa);
  if (!finite(parameters.latentCentre))
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Plastic local law: latent centre must be finite; got %g",
            parameters.latentCentre);
  if (!finite(parameters.proximalCoefficient) ||
      !(parameters.proximalCoefficient > 0))
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Plastic local law: proximal coefficient must be finite and "
            "positive; got %g",
            parameters.proximalCoefficient);
  // The tape differentiates sqrt(2/3 H:H + eps^2); at eps = 0 the derivative
  // at the tensor origin is not finite, so the two-field law requires eps > 0.
  if (!finite(parameters.regularisationEpsilon) ||
      !(parameters.regularisationEpsilon > 0))
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Plastic local law: regularisation epsilon must be finite and "
            "positive; got %g",
            parameters.regularisationEpsilon);
  currentParameters = parameters;
  CHKERR applyParameters();
  MoFEMFunctionReturn(0);
}

◆ setParams()

MoFEMErrorCode EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::setParams	(	FEMethod *	fe_ptr,
		int	gg
	)

override

Definition at line 1013 of file PlasticIncrementalOptimizationOperators.cpp.

                                                         {
  return applyParameters();
}

Member Data Documentation

◆ currentParameters

PlasticLocalLawParameters EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::currentParameters {1., 0., 0., 0., 1., 1.}

private

Definition at line 191 of file PlasticIncrementalOptimizationInternal.hpp.

191{1., 0., 0., 0., 1., 1.};

◆ densityDataName

constexpr const char* EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::densityDataName = "plastic_density"

staticconstexpr

Definition at line 148 of file PlasticIncrementalOptimizationInternal.hpp.

◆ densityGradientDataName

constexpr const char* EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::densityGradientDataName

staticconstexpr

Initial value:

=

"plastic_density_gradient"

Definition at line 149 of file PlasticIncrementalOptimizationInternal.hpp.

◆ incrementDataName

constexpr const char* EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::incrementDataName = "plastic_increment"

staticconstexpr

Definition at line 146 of file PlasticIncrementalOptimizationInternal.hpp.

◆ latentDataName

constexpr const char* EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::latentDataName = "plastic_latent"

staticconstexpr

Definition at line 147 of file PlasticIncrementalOptimizationInternal.hpp.

◆ parameterVector

std::vector<double> EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::parameterVector

private

Definition at line 192 of file PlasticIncrementalOptimizationInternal.hpp.

◆ tapeName

constexpr const char* EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::tapeName = "EshelbianPlasticLocalLaw"

staticconstexpr

Definition at line 145 of file PlasticIncrementalOptimizationInternal.hpp.

◆ tapeRecorded

bool EshelbianPlasticity::PlasticIncrementalOptimizationInternal::PlasticLocalLaw::tapeRecorded = false

private

Definition at line 193 of file PlasticIncrementalOptimizationInternal.hpp.

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

users_modules/eshelbian_plasticity/src/impl/PlasticIncrementalOptimizationInternal.hpp
users_modules/eshelbian_plasticity/src/impl/PlasticIncrementalOptimizationOperators.cpp

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ DirectionTensor

◆ GradientTensor

◆ HessianActionTensor

◆ IncrementTensor

Constructor & Destructor Documentation

◆ PlasticLocalLaw()

Member Function Documentation

◆ applyParameters()

◆ createOp()

◆ evaluateGradient()

◆ evaluateHessianAction()

◆ evaluateValue()

◆ getOptions()

◆ getParameters()

◆ recordTape()

◆ setActiveVariables()

◆ setParameters()

◆ setParams()

Member Data Documentation

◆ currentParameters

◆ densityDataName

◆ densityGradientDataName

◆ incrementDataName

◆ latentDataName

◆ parameterVector

◆ tapeName

◆ tapeRecorded