MultiPlasticityRawComponentAssembler holds and computes yield functions, flow directions, etc, for use in FiniteStrainMultiPlasticity. More...

#include <MultiPlasticityRawComponentAssembler.h>

Inheritance diagram for MultiPlasticityRawComponentAssembler:

[legend]

Public Member Functions
	MultiPlasticityRawComponentAssembler (const MooseObject *moose_object)

virtual	~MultiPlasticityRawComponentAssembler ()

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	yieldFunction (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< Real > &f)
	The active yield function(s) More...

virtual void	dyieldFunction_dstress (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< RankTwoTensor > &df_dstress)
	The derivative of the active yield function(s) with respect to stress. More...

virtual void	dyieldFunction_dintnl (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< Real > &df_dintnl)
	The derivative of active yield function(s) with respect to their internal parameters (the user objects assume there is exactly one internal param per yield function) More...

virtual void	flowPotential (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< RankTwoTensor > &r)
	The active flow potential(s) - one for each yield function. More...

virtual void	dflowPotential_dstress (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< RankFourTensor > &dr_dstress)
	The derivative of the active flow potential(s) with respect to stress. More...

virtual void	dflowPotential_dintnl (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< RankTwoTensor > &dr_dintnl)
	The derivative of the active flow potentials with respect to the active internal parameters The UserObjects explicitly assume that r[alpha] is only dependent on intnl[alpha]. More...

virtual void	hardPotential (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< Real > &h)
	The active hardening potentials (one for each internal parameter and for each yield function) by assumption in the Userobjects, the h[a][alpha] is nonzero only if the surface alpha is part of model a, so we only calculate those here. More...

virtual void	dhardPotential_dstress (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< RankTwoTensor > &dh_dstress)
	The derivative of the active hardening potentials with respect to stress By assumption in the Userobjects, the h[a][alpha] is nonzero only for a = alpha, so we only calculate those here. More...

virtual void	dhardPotential_dintnl (const RankTwoTensor &stress, const std::vector< Real > &intnl, const std::vector< bool > &active, std::vector< Real > &dh_dintnl)
	The derivative of the active hardening potentials with respect to the active internal parameters. More...

virtual void	buildActiveConstraints (const std::vector< Real > &f, const RankTwoTensor &stress, const std::vector< Real > &intnl, const RankFourTensor &Eijkl, std::vector< bool > &act)
	Constructs a set of active constraints, given the yield functions, f. More...

unsigned int	modelNumber (unsigned int surface)
	returns the model number, given the surface number More...

bool	anyActiveSurfaces (int model, const std::vector< bool > &active)
	returns true if any internal surfaces of the given model are active according to 'active' More...

void	activeModelSurfaces (int model, const std::vector< bool > &active, std::vector< unsigned int > &active_surfaces_of_model)
	Returns the internal surface number(s) of the active surfaces of the given model This may be of size=0 if there are no active surfaces of the given model. More...

void	activeSurfaces (int model, const std::vector< bool > &active, std::vector< unsigned int > &active_surfaces)
	Returns the external surface number(s) of the active surfaces of the given model This may be of size=0 if there are no active surfaces of the given model. More...

bool	returnMapAll (const RankTwoTensor &trial_stress, const std::vector< Real > &intnl_old, const RankFourTensor &E_ijkl, Real ep_plastic_tolerance, RankTwoTensor &stress, std::vector< Real > &intnl, std::vector< Real > &pm, std::vector< Real > &cumulative_pm, RankTwoTensor &delta_dp, std::vector< Real > &yf, unsigned &num_successful_plastic_returns, unsigned &custom_model)
	Performs a returnMap for each plastic model using their inbuilt returnMap functions. More...

Protected Attributes
const InputParameters &	_params

unsigned int	_num_models
	Number of plastic models for this material. More...

unsigned int	_num_surfaces
	Number of surfaces within the plastic models. More...

std::vector< std::vector< unsigned int > >	_surfaces_given_model
	_surfaces_given_model[model_number] = vector of surface numbers for this model More...

MooseEnum	_specialIC
	Allows initial set of active constraints to be chosen optimally. More...

std::vector< const TensorMechanicsPlasticModel * >	_f
	User objects that define the yield functions, flow potentials, etc. More...

Private Member Functions
void	buildActiveConstraintsRock (const std::vector< Real > &f, const RankTwoTensor &stress, const std::vector< Real > &intnl, const RankFourTensor &Eijkl, std::vector< bool > &act)
	"Rock" version Constructs a set of active constraints, given the yield functions, f. More...

void	buildActiveConstraintsJoint (const std::vector< Real > &f, const RankTwoTensor &stress, const std::vector< Real > &intnl, const RankFourTensor &Eijkl, std::vector< bool > &act)
	"Joint" version Constructs a set of active constraints, given the yield functions, f. More...

Private Attributes
std::vector< unsigned int >	_model_given_surface
	given a surface number, this returns the model number More...

std::vector< unsigned int >	_model_surface_given_surface
	given a surface number, this returns the corresponding-model's internal surface number More...

Detailed Description

MultiPlasticityRawComponentAssembler holds and computes yield functions, flow directions, etc, for use in FiniteStrainMultiPlasticity.

Here there are a number of numbering systems.

There are _num_models of plastic models, read from the input file. Each of these models can, in principal, contain multiple 'internal surfaces'. Models are numbered from 0 to _num_models - 1.

There are num_surfaces surfaces. This = sum{plastic_models} (numberSurfaces in model) Evidently _num_surface >= _num_models Surfaces are numbered from 0 to _num_surfaces - 1.

The std::vectors _model_given_surface, _model_surface_given_surface and _surfaces_given_model allow translation between these

Definition at line 44 of file MultiPlasticityRawComponentAssembler.h.

Constructor & Destructor Documentation

◆ MultiPlasticityRawComponentAssembler()

MultiPlasticityRawComponentAssembler::MultiPlasticityRawComponentAssembler ( const MooseObject * moose_object )

Definition at line 38 of file MultiPlasticityRawComponentAssembler.C.

   : UserObjectInterface(moose_object),
     _params(moose_object->parameters()),
     _num_models(_params.get<std::vector<UserObjectName>>("plastic_models").size()),
     _num_surfaces(0),
     _specialIC(_params.get<MooseEnum>("specialIC"))
 {
   _f.resize(_num_models);
   for (unsigned model = 0; model < _num_models; ++model)
     _f[model] = &getUserObjectByName<TensorMechanicsPlasticModel>(
         _params.get<std::vector<UserObjectName>>("plastic_models")[model]);
  
   for (unsigned model = 0; model < _num_models; ++model)
     _num_surfaces += _f[model]->numberSurfaces();
  
   _model_given_surface.resize(_num_surfaces);
   _model_surface_given_surface.resize(_num_surfaces);
   unsigned int surface = 0;
   for (unsigned model = 0; model < _num_models; ++model)
     for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
     {
       _model_given_surface[surface] = model;
       _model_surface_given_surface[surface] = model_surface;
       surface++;
     }
  
   _surfaces_given_model.resize(_num_models);
   surface = 0;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     _surfaces_given_model[model].resize(_f[model]->numberSurfaces());
     for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
       _surfaces_given_model[model][model_surface] = surface++;
   }
  
   // check the plastic_models for specialIC
   if (_specialIC == "rock")
   {
     if (_num_models != 2)
       mooseError("Choosing specialIC=rock, you must have plasticity models of type 'TensileMulti "
                  "MohrCoulombMulti'\n");
     if (!(_f[0]->modelName().compare("TensileMulti") == 0 &&
           _f[1]->modelName().compare("MohrCoulombMulti") == 0))
       mooseError("Choosing specialIC=rock, you must have plasticity models of type 'TensileMulti "
                  "MohrCoulombMulti'\n");
   }
   if (_specialIC == "joint")
   {
     if (_num_models != 2)
       mooseError("Choosing specialIC=joint, you must have plasticity models of type "
                  "'WeakPlaneTensile WeakPlaneShear'\n");
     if (!(_f[0]->modelName().compare("WeakPlaneTensile") == 0 &&
           _f[1]->modelName().compare("WeakPlaneShear") == 0))
       mooseError("Choosing specialIC=joint, you must have plasticity models of type "
                  "'WeakPlaneTensile WeakPlaneShear'\n");
   }
 }

◆ ~MultiPlasticityRawComponentAssembler()

virtual MultiPlasticityRawComponentAssembler::~MultiPlasticityRawComponentAssembler ( )

inlinevirtual

Definition at line 51 of file MultiPlasticityRawComponentAssembler.h.

51 {}

Member Function Documentation

◆ activeModelSurfaces()

void MultiPlasticityRawComponentAssembler::activeModelSurfaces	(	int	model,
		const std::vector< bool > &	active,
		std::vector< unsigned int > &	active_surfaces_of_model
	)

protected

Returns the internal surface number(s) of the active surfaces of the given model This may be of size=0 if there are no active surfaces of the given model.

Parameters

	model	the model number
	active	array with entries being 'true' if the surface is active
[out]	active_surfaces_of_model	the output

Definition at line 811 of file MultiPlasticityRawComponentAssembler.C.

 {
   active_surfaces_of_model.resize(0);
   for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
     if (active[_surfaces_given_model[model][model_surface]])
       active_surfaces_of_model.push_back(model_surface);
 }

Referenced by dflowPotential_dintnl(), dflowPotential_dstress(), dhardPotential_dintnl(), dhardPotential_dstress(), dyieldFunction_dintnl(), dyieldFunction_dstress(), flowPotential(), hardPotential(), and yieldFunction().

◆ activeSurfaces()

void MultiPlasticityRawComponentAssembler::activeSurfaces	(	int	model,
		const std::vector< bool > &	active,
		std::vector< unsigned int > &	active_surfaces
	)

protected

Returns the external surface number(s) of the active surfaces of the given model This may be of size=0 if there are no active surfaces of the given model.

Parameters

	model	the model number
	active	array with entries being 'true' if the surface is active
[out]	active_surfaces	the output

Definition at line 800 of file MultiPlasticityRawComponentAssembler.C.

 {
   active_surfaces.resize(0);
   for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
     if (active[_surfaces_given_model[model][model_surface]])
       active_surfaces.push_back(_surfaces_given_model[model][model_surface]);
 }

Referenced by MultiPlasticityLinearSystem::calculateConstraints().

◆ anyActiveSurfaces()

bool MultiPlasticityRawComponentAssembler::anyActiveSurfaces	(	int	model,
		const std::vector< bool > &	active
	)

protected

returns true if any internal surfaces of the given model are active according to 'active'

Definition at line 791 of file MultiPlasticityRawComponentAssembler.C.

 {
   for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
     if (active[_surfaces_given_model[model][model_surface]])
       return true;
   return false;
 }

Referenced by MultiPlasticityLinearSystem::calculateJacobian(), MultiPlasticityLinearSystem::calculateRHS(), MultiPlasticityDebugger::checkSolution(), MultiPlasticityDebugger::dof_included(), MultiPlasticityLinearSystem::nrStep(), and ComputeMultiPlasticityStress::residual2().

◆ buildActiveConstraints()

void MultiPlasticityRawComponentAssembler::buildActiveConstraints	(	const std::vector< Real > &	f,
		const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const RankFourTensor &	Eijkl,
		std::vector< bool > &	act
	)

protectedvirtual

Constructs a set of active constraints, given the yield functions, f.

This uses TensorMechanicsPlasticModel::activeConstraints to identify the active constraints for each model.

Parameters

	f	yield functions (should be _num_surfaces of these)
	stress	stress tensor
	intnl	internal parameters
	Eijkl	elasticity tensor (stress = Eijkl*strain)
[out]	act	the set of active constraints (will be resized to _num_surfaces)

Definition at line 344 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(f.size() == _num_surfaces,
               "buildActiveConstraints called with f.size = " << f.size() << " while there are "
                                                              << _num_surfaces << " surfaces");
   mooseAssert(intnl.size() == _num_models,
               "buildActiveConstraints called with intnl.size = "
                   << intnl.size() << " while there are " << _num_models << " models");
  
   if (_specialIC == "rock")
     buildActiveConstraintsRock(f, stress, intnl, Eijkl, act);
   else if (_specialIC == "joint")
     buildActiveConstraintsJoint(f, stress, intnl, Eijkl, act);
   else // no specialIC
   {
     act.resize(0);
     unsigned ind = 0;
     for (unsigned model = 0; model < _num_models; ++model)
     {
       std::vector<Real> model_f(0);
       for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
         model_f.push_back(f[ind++]);
       std::vector<bool> model_act;
       RankTwoTensor returned_stress;
       _f[model]->activeConstraints(
           model_f, stress, intnl[model], Eijkl, model_act, returned_stress);
       for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
         act.push_back(model_act[model_surface]);
     }
   }
 }

Referenced by ComputeMultiPlasticityStress::returnMap().

◆ buildActiveConstraintsJoint()

void MultiPlasticityRawComponentAssembler::buildActiveConstraintsJoint	(	const std::vector< Real > &	f,
		const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const RankFourTensor &	Eijkl,
		std::vector< bool > &	act
	)

private

"Joint" version Constructs a set of active constraints, given the yield functions, f.

This uses TensorMechanicsPlasticModel::activeConstraints to identify the active constraints for each model.

Parameters

	f	yield functions (should be _num_surfaces of these)
	stress	stress tensor
	intnl	internal parameters
	Eijkl	elasticity tensor (stress = Eijkl*strain)
[out]	act	the set of active constraints (will be resized to _num_surfaces)

Definition at line 381 of file MultiPlasticityRawComponentAssembler.C.

 {
   act.assign(2, false);
  
   RankTwoTensor returned_stress;
   std::vector<bool> active_tensile;
   std::vector<bool> active_shear;
   std::vector<Real> f_single;
  
   // first try tensile alone
   f_single.assign(1, 0);
   f_single[0] = f[0];
   _f[0]->activeConstraints(f_single, stress, intnl[0], Eijkl, active_tensile, returned_stress);
   _f[1]->yieldFunctionV(returned_stress, intnl[1], f_single);
   if (f_single[0] <= _f[1]->_f_tol)
   {
     act[0] = active_tensile[0];
     return;
   }
  
   // next try shear alone
   f_single.assign(1, 0);
   f_single[0] = f[1];
   _f[1]->activeConstraints(f_single, stress, intnl[1], Eijkl, active_shear, returned_stress);
   _f[0]->yieldFunctionV(returned_stress, intnl[0], f_single);
   if (f_single[0] <= _f[0]->_f_tol)
   {
     act[1] = active_shear[0];
     return;
   }
  
   // must be mixed
   act[0] = act[1] = true;
   return;
 }

Referenced by buildActiveConstraints().

◆ buildActiveConstraintsRock()

void MultiPlasticityRawComponentAssembler::buildActiveConstraintsRock	(	const std::vector< Real > &	f,
		const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const RankFourTensor &	Eijkl,
		std::vector< bool > &	act
	)

private

"Rock" version Constructs a set of active constraints, given the yield functions, f.

This uses TensorMechanicsPlasticModel::activeConstraints to identify the active constraints for each model.

Parameters

	f	yield functions (should be _num_surfaces of these)
	stress	stress tensor
	intnl	internal parameters
	Eijkl	elasticity tensor (stress = Eijkl*strain)
[out]	act	the set of active constraints (will be resized to _num_surfaces)

Definition at line 422 of file MultiPlasticityRawComponentAssembler.C.

 {
   act.assign(9, false);
  
   RankTwoTensor returned_stress;
   std::vector<bool> active_tensile;
   std::vector<bool> active_MC;
   std::vector<Real> f_single;
  
   // first try tensile alone
   f_single.assign(3, 0);
   f_single[0] = f[0];
   f_single[1] = f[1];
   f_single[2] = f[2];
   _f[0]->activeConstraints(f_single, stress, intnl[0], Eijkl, active_tensile, returned_stress);
   _f[1]->yieldFunctionV(returned_stress, intnl[1], f_single);
   if (f_single[0] <= _f[1]->_f_tol && f_single[1] <= _f[1]->_f_tol &&
       f_single[2] <= _f[1]->_f_tol && f_single[3] <= _f[1]->_f_tol &&
       f_single[4] <= _f[1]->_f_tol && f_single[5] <= _f[1]->_f_tol)
   {
     act[0] = active_tensile[0];
     act[1] = active_tensile[1];
     act[2] = active_tensile[2];
     return;
   }
  
   // next try MC alone
   f_single.assign(6, 0);
   f_single[0] = f[3];
   f_single[1] = f[4];
   f_single[2] = f[5];
   f_single[3] = f[6];
   f_single[4] = f[7];
   f_single[5] = f[8];
   _f[1]->activeConstraints(f_single, stress, intnl[1], Eijkl, active_MC, returned_stress);
   _f[0]->yieldFunctionV(returned_stress, intnl[0], f_single);
   if (f_single[0] <= _f[0]->_f_tol && f_single[1] <= _f[0]->_f_tol && f_single[2] <= _f[0]->_f_tol)
   {
     act[3] = active_MC[0];
     act[4] = active_MC[1];
     act[5] = active_MC[2];
     act[6] = active_MC[3];
     act[7] = active_MC[4];
     act[8] = active_MC[5];
     return;
   }
  
   // must be a mix.
   // The possibilities are enumerated below.
  
   // tensile=edge, MC=tip (two possibilities)
   if (active_tensile[0] == false && active_tensile[1] == true && active_tensile[2] == true &&
       active_MC[0] == true && active_MC[1] == true && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == false)
   {
     act[1] = act[2] = act[6] = true;
     act[4] = true;
     return;
   }
   if (active_tensile[0] == false && active_tensile[1] == true && active_tensile[2] == true &&
       active_MC[0] == false && active_MC[1] == true && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == true)
   {
     act[1] = act[2] = act[6] = true; // i don't think act[4] is necessary, is it?!
     return;
   }
  
   // tensile = edge, MC=edge (two possibilities)
   if (active_tensile[0] == false && active_tensile[1] == true && active_tensile[2] == true &&
       active_MC[0] == false && active_MC[1] == true && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == false)
   {
     act[1] = act[2] = act[4] = act[6] = true;
     return;
   }
   if (active_tensile[0] == false && active_tensile[1] == true && active_tensile[2] == true &&
       active_MC[0] == false && active_MC[1] == false && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == true)
   {
     act[1] = act[2] = act[4] = act[6] = true;
     return;
   }
  
   // tensile = edge, MC=face
   if (active_tensile[0] == false && active_tensile[1] == true && active_tensile[2] == true &&
       active_MC[0] == false && active_MC[1] == false && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == false)
   {
     act[1] = act[2] = act[6] = true;
     return;
   }
  
   // tensile = face, MC=tip (two possibilities)
   if (active_tensile[0] == false && active_tensile[1] == false && active_tensile[2] == true &&
       active_MC[0] == true && active_MC[1] == true && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == false)
   {
     act[2] = act[6] = true;
     act[4] = true;
     act[8] = true;
     return;
   }
   if (active_tensile[0] == false && active_tensile[1] == false && active_tensile[2] == true &&
       active_MC[0] == false && active_MC[1] == true && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == true)
   {
     act[2] = act[6] = true;
     act[8] = true;
     return;
   }
  
   // tensile = face, MC=face
   if (active_tensile[0] == false && active_tensile[1] == false && active_tensile[2] == true &&
       active_MC[0] == false && active_MC[1] == false && active_MC[2] == false &&
       active_MC[3] == true && active_MC[4] == false && active_MC[5] == false)
   {
     act[1] = act[2] = act[6] = true;
     return;
   }
  
   // tensile = face, MC=edge (two possibilites).
   act[2] = true; // tensile face
   act[3] = active_MC[0];
   act[4] = active_MC[1];
   act[5] = active_MC[2];
   act[6] = active_MC[3];
   act[7] = active_MC[4];
   act[8] = active_MC[5];
   return;
 }

Referenced by buildActiveConstraints().

◆ dflowPotential_dintnl()

void MultiPlasticityRawComponentAssembler::dflowPotential_dintnl	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< RankTwoTensor > &	dr_dintnl
	)

protectedvirtual

The derivative of the active flow potentials with respect to the active internal parameters The UserObjects explicitly assume that r[alpha] is only dependent on intnl[alpha].

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	vector of internal parameters
	active	set of active constraints - only the active derivatives are put into "dr_dintnl"
[out]	dr_dintnl	the derivatives. dr_dintnl[alpha](i, j) = dr[alpha](i, j)/dintnl[alpha]

Definition at line 235 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   dr_dintnl.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<RankTwoTensor> model_dr_dintnl;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->dflowPotential_dintnlV(stress, intnl[model], model_dr_dintnl);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         dr_dintnl.push_back(model_dr_dintnl[*active_surface]);
     }
   }
 }

Referenced by MultiPlasticityLinearSystem::calculateJacobian(), MultiPlasticityDebugger::checkDerivatives(), and ComputeMultiPlasticityStress::consistentTangentOperator().

◆ dflowPotential_dstress()

void MultiPlasticityRawComponentAssembler::dflowPotential_dstress	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< RankFourTensor > &	dr_dstress
	)

protectedvirtual

The derivative of the active flow potential(s) with respect to stress.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	vector of internal parameters
	active	set of active constraints - only the active derivatives are put into "dr_dstress"
[out]	dr_dstress	the derivative. dr_dstress[alpha](i, j, k, l) = dr[alpha](i, j)/dstress(k, l)

Definition at line 207 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   dr_dstress.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<RankFourTensor> model_dr_dstress;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->dflowPotential_dstressV(stress, intnl[model], model_dr_dstress);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         dr_dstress.push_back(model_dr_dstress[*active_surface]);
     }
   }
 }

Referenced by MultiPlasticityLinearSystem::calculateJacobian(), MultiPlasticityDebugger::checkDerivatives(), and ComputeMultiPlasticityStress::consistentTangentOperator().

◆ dhardPotential_dintnl()

void MultiPlasticityRawComponentAssembler::dhardPotential_dintnl	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< Real > &	dh_dintnl
	)

protectedvirtual

The derivative of the active hardening potentials with respect to the active internal parameters.

Parameters

	stress	the stress at which to calculate the hardening potentials
	intnl	vector of internal parameters
	active	set of active constraints - only the active derivatives are put into "dh_dintnl"
[out]	dh_dintnl	the derivatives. dh_dintnl[a][alpha][b] = dh[a][alpha]/dintnl[b]. Note that the userobjects assume that there is exactly one internal parameter per yield function, so the derivative is only nonzero for a=alpha=b, so that is all we calculate

Definition at line 317 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   dh_dintnl.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<Real> model_dh_dintnl;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->dhardPotential_dintnlV(stress, intnl[model], model_dh_dintnl);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         dh_dintnl.push_back(model_dh_dintnl[*active_surface]);
     }
   }
 }

Referenced by MultiPlasticityLinearSystem::calculateJacobian().

◆ dhardPotential_dstress()

void MultiPlasticityRawComponentAssembler::dhardPotential_dstress	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< RankTwoTensor > &	dh_dstress
	)

protectedvirtual

The derivative of the active hardening potentials with respect to stress By assumption in the Userobjects, the h[a][alpha] is nonzero only for a = alpha, so we only calculate those here.

Parameters

	stress	the stress at which to calculate the hardening potentials
	intnl	vector of internal parameters
	active	set of active constraints - only the active derivatives are put into "dh_dstress"
[out]	dh_dstress	the derivative. dh_dstress[a](i, j) = dh[a]/dstress(k, l)

Definition at line 289 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   dh_dstress.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<RankTwoTensor> model_dh_dstress;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->dhardPotential_dstressV(stress, intnl[model], model_dh_dstress);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         dh_dstress.push_back(model_dh_dstress[*active_surface]);
     }
   }
 }

Referenced by MultiPlasticityLinearSystem::calculateJacobian().

◆ dyieldFunction_dintnl()

void MultiPlasticityRawComponentAssembler::dyieldFunction_dintnl	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< Real > &	df_dintnl
	)

protectedvirtual

The derivative of active yield function(s) with respect to their internal parameters (the user objects assume there is exactly one internal param per yield function)

Parameters

	stress	the stress at which to calculate the yield function
	intnl	vector of internal parameters
	active	set of active constraints - only the active derivatives are put into "df_dintnl"
[out]	df_dintnl	the derivatives. df_dstress[alpha] = dyieldFunction[alpha]/dintnl[alpha]

Definition at line 153 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   df_dintnl.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<Real> model_df_dintnl;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->dyieldFunction_dintnlV(stress, intnl[model], model_df_dintnl);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         df_dintnl.push_back(model_df_dintnl[*active_surface]);
     }
   }
 }

Referenced by MultiPlasticityLinearSystem::calculateJacobian(), MultiPlasticityDebugger::checkDerivatives(), and ComputeMultiPlasticityStress::consistentTangentOperator().

◆ dyieldFunction_dstress()

void MultiPlasticityRawComponentAssembler::dyieldFunction_dstress	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< RankTwoTensor > &	df_dstress
	)

protectedvirtual

The derivative of the active yield function(s) with respect to stress.

Parameters

	stress	the stress at which to calculate the yield function
	intnl	vector of internal parameters
	active	set of active constraints - only the active derivatives are put into "df_dstress"
[out]	df_dstress	the derivative (or derivatives in the case of multisurface plasticity). df_dstress[alpha](i, j) = dyieldFunction[alpha]/dstress(i, j)

Definition at line 125 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   df_dstress.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<RankTwoTensor> model_df_dstress;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->dyieldFunction_dstressV(stress, intnl[model], model_df_dstress);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         df_dstress.push_back(model_df_dstress[*active_surface]);
     }
   }
 }

Referenced by ComputeMultiPlasticityStress::buildDumbOrder(), MultiPlasticityLinearSystem::calculateJacobian(), MultiPlasticityDebugger::checkDerivatives(), ComputeMultiPlasticityStress::consistentTangentOperator(), and MultiPlasticityLinearSystem::eliminateLinearDependence().

◆ flowPotential()

void MultiPlasticityRawComponentAssembler::flowPotential	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< RankTwoTensor > &	r
	)

protectedvirtual

The active flow potential(s) - one for each yield function.

Parameters

	stress	the stress at which to calculate the flow potential
	intnl	vector of internal parameters
	active	set of active constraints - only the active flow potentials are put into "r"
[out]	r	the flow potential (flow potentials in the multi-surface case)

Definition at line 180 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   r.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<RankTwoTensor> model_r;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->flowPotentialV(stress, intnl[model], model_r);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         r.push_back(model_r[*active_surface]);
     }
   }
 }

Referenced by MultiPlasticityLinearSystem::calculateConstraints(), MultiPlasticityLinearSystem::calculateJacobian(), ComputeMultiPlasticityStress::consistentTangentOperator(), MultiPlasticityDebugger::fddflowPotential_dintnl(), and MultiPlasticityDebugger::fddflowPotential_dstress().

◆ hardPotential()

void MultiPlasticityRawComponentAssembler::hardPotential	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< Real > &	h
	)

protectedvirtual

The active hardening potentials (one for each internal parameter and for each yield function) by assumption in the Userobjects, the h[a][alpha] is nonzero only if the surface alpha is part of model a, so we only calculate those here.

Parameters

	stress	the stress at which to calculate the hardening potential
	intnl	vector of internal parameters
	active	set of active constraints - only the active hardening potentials are put into "h"
[out]	h	the hardening potentials. h[alpha] = hardening potential for yield fcn alpha (and, by the above assumption we know which hardening parameter, a, this belongs to)

Definition at line 262 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   h.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<Real> model_h;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->hardPotentialV(stress, intnl[model], model_h);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         h.push_back(model_h[*active_surface]);
     }
   }
 }

Referenced by MultiPlasticityLinearSystem::calculateConstraints(), MultiPlasticityLinearSystem::calculateJacobian(), and ComputeMultiPlasticityStress::consistentTangentOperator().

◆ modelNumber()

unsigned int MultiPlasticityRawComponentAssembler::modelNumber ( unsigned int surface )

protected

returns the model number, given the surface number

Definition at line 785 of file MultiPlasticityRawComponentAssembler.C.

 {
   return _model_given_surface[surface];
 }

Referenced by ComputeMultiPlasticityStress::applyKuhnTucker(), MultiPlasticityLinearSystem::calculateJacobian(), ComputeMultiPlasticityStress::canAddConstraints(), ComputeMultiPlasticityStress::checkAdmissible(), ComputeMultiPlasticityStress::checkKuhnTucker(), ComputeMultiPlasticityStress::consistentTangentOperator(), MultiPlasticityDebugger::fddflowPotential_dintnl(), MultiPlasticityDebugger::fddyieldFunction_dintnl(), ComputeMultiPlasticityStress::residual2(), ComputeMultiPlasticityStress::returnMap(), and ComputeMultiPlasticityStress::singleStep().

◆ returnMapAll()

bool MultiPlasticityRawComponentAssembler::returnMapAll	(	const RankTwoTensor &	trial_stress,
		const std::vector< Real > &	intnl_old,
		const RankFourTensor &	E_ijkl,
		Real	ep_plastic_tolerance,
		RankTwoTensor &	stress,
		std::vector< Real > &	intnl,
		std::vector< Real > &	pm,
		std::vector< Real > &	cumulative_pm,
		RankTwoTensor &	delta_dp,
		std::vector< Real > &	yf,
		unsigned &	num_successful_plastic_returns,
		unsigned &	custom_model
	)

protected

Performs a returnMap for each plastic model using their inbuilt returnMap functions.

Performs a returnMap for each plastic model.

This may be used to quickly ascertain whether a (trial_stress, intnl_old) configuration is admissible, or whether a single model's customized returnMap function can provide a solution to the return-map problem, or whether a full Newton-Raphson approach such as implemented in ComputeMultiPlasticityStress is needed.

There are three cases mentioned below: (A) The (trial_stress, intnl_old) configuration is admissible according to all plastic models (B) The (trial_stress, intnl_old) configuration is inadmissible to exactly one plastic model, and that model can successfully use its customized returnMap function to provide a returned (stress, intnl) configuration, and that configuration is admissible according to all plastic models (C) All other cases. This includes customized returnMap functions failing, or more than one plastic_model being inadmissible, etc

Parameters

	trial_stress	the trial stress
	intnl_old	the old values of the internal parameters
	E_ijkl	the elasticity tensor
	ep_plastic_tolerance	the tolerance on the plastic strain
[out]	stress	is set to trial_stress in case (A) or (C), and the returned value of stress in case (B).
[out]	intnl	is set to intnl_old in case (A) or (C), and the returned value of intnl in case (B)
[out]	pm	Zero in case (A) or (C), otherwise the plastic multipliers needed to bring about the returnMap in case (B)
	[in/out]	cumulative_pm cumulative plastic multipliers, updated in case (B), otherwise left untouched
[out]	delta_dp	is unchanged in case (A) or (C), and is set to the change in plastic strain in case(B)
[out]	yf	will contain the yield function values at (stress, intnl)
[out]	num_successful_plastic_returns	will be 0 for (A) and (C), and 1 for (B)

Returns: true in case (A) and (B), and false in case (C)

If all models actually signal "elastic" by returning true from their returnMap, and by returning model_plastically_active=0, then yf will contain the yield function values num_successful_plastic_returns will be zero intnl = intnl_old delta_dp will be unchanged from its input value stress will be set to trial_stress pm will be zero cumulative_pm will be unchanged return value will be true num_successful_plastic_returns = 0

If only one model signals "plastically active" by returning true from its returnMap, and by returning model_plastically_active=1, then yf will contain the yield function values num_successful_plastic_returns will be one intnl will be set by the returnMap algorithm delta_dp will be set by the returnMap algorithm stress will be set by the returnMap algorithm pm will be nonzero for the single model, and zero for other models cumulative_pm will be updated return value will be true num_successful_plastic_returns = 1

If >1 model signals "plastically active" or if >=1 model's returnMap fails, then yf will contain the yield function values num_successful_plastic_returns will be set appropriately intnl = intnl_old delta_dp will be unchanged from its input value stress will be set to trial_stress pm will be zero cumulative_pm will be unchanged return value will be true if all returnMap functions returned true, otherwise it will be false num_successful_plastic_returns is set appropriately

Definition at line 599 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl_old.size() == _num_models,
               "returnMapAll: Incorrect size of internal parameters");
   mooseAssert(intnl.size() == _num_models, "returnMapAll: Incorrect size of internal parameters");
   mooseAssert(pm.size() == _num_surfaces, "returnMapAll: Incorrect size of pm");
  
   num_successful_plastic_returns = 0;
   yf.resize(0);
   pm.assign(_num_surfaces, 0.0);
  
   RankTwoTensor returned_stress; // each model will give a returned_stress.  if only one model is
                                  // plastically active, i set stress=returned_stress, so as to
                                  // record this returned value
   std::vector<Real> model_f;
   RankTwoTensor model_delta_dp;
   std::vector<Real> model_pm;
   bool trial_stress_inadmissible;
   bool successful_return = true;
   unsigned the_single_plastic_model = 0;
   bool using_custom_return_map = true;
  
   // run through all the plastic models, performing their
   // returnMap algorithms.
   // If one finds (trial_stress, intnl) inadmissible and
   // successfully returns, break from the loop to evaluate
   // all the others at that returned stress
   for (unsigned model = 0; model < _num_models; ++model)
   {
     if (using_custom_return_map)
     {
       model_pm.assign(_f[model]->numberSurfaces(), 0.0);
       bool model_returned = _f[model]->returnMap(trial_stress,
                                                  intnl_old[model],
                                                  E_ijkl,
                                                  ep_plastic_tolerance,
                                                  returned_stress,
                                                  intnl[model],
                                                  model_pm,
                                                  model_delta_dp,
                                                  model_f,
                                                  trial_stress_inadmissible);
       if (!trial_stress_inadmissible)
       {
         // in the elastic zone: record the yield-function values (returned_stress, intnl, model_pm
         // and model_delta_dp are undefined)
         for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces();
              ++model_surface)
           yf.push_back(model_f[model_surface]);
       }
       else if (trial_stress_inadmissible && !model_returned)
       {
         // in the plastic zone, and the customized returnMap failed
         // for some reason (or wasn't implemented).  The coder
         // should have correctly returned model_f(trial_stress, intnl_old)
         // so record them
         // (returned_stress, intnl, model_pm and model_delta_dp are undefined)
         for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces();
              ++model_surface)
           yf.push_back(model_f[model_surface]);
         // now there's almost zero point in using the custom
         // returnMap functions
         using_custom_return_map = false;
         successful_return = false;
       }
       else
       {
         // in the plastic zone, and the customized returnMap
         // succeeded.
         // record the first returned_stress and delta_dp if everything is going OK
         // as they could be the actual answer
         if (trial_stress_inadmissible)
           num_successful_plastic_returns++;
         the_single_plastic_model = model;
         stress = returned_stress;
         // note that i break here, and don't push_back
         // model_f to yf.  So now yf contains only the values of
         // model_f from previous models to the_single_plastic_model
         // also i don't set delta_dp = model_delta_dp yet, because
         // i might find problems later on
         // also, don't increment cumulative_pm for the same reason
  
         break;
       }
     }
     else
     {
       // not using custom returnMap functions because one
       // has already failed and that one said trial_stress
       // was inadmissible.  So now calculate the yield functions
       // at the trial stress
       _f[model]->yieldFunctionV(trial_stress, intnl_old[model], model_f);
       for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
         yf.push_back(model_f[model_surface]);
     }
   }
  
   if (num_successful_plastic_returns == 0)
   {
     // here either all the models were elastic (successful_return=true),
     // or some were plastic and either the customized returnMap failed
     // or wasn't implemented (successful_return=false).
     // In either case, have to set the following:
     stress = trial_stress;
     for (unsigned model = 0; model < _num_models; ++model)
       intnl[model] = intnl_old[model];
     return successful_return;
   }
  
   // Now we know that num_successful_plastic_returns == 1 and all the other
   // models (with model number < the_single_plastic_model) must have been
   // admissible at (trial_stress, intnl).  However, all models might
   // not be admissible at (trial_stress, intnl), so must check that
   std::vector<Real> yf_at_returned_stress(0);
   bool all_admissible = true;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     if (model == the_single_plastic_model)
     {
       // no need to spend time calculating the yield function: we know its admissible
       for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
         yf_at_returned_stress.push_back(model_f[model_surface]);
       continue;
     }
     _f[model]->yieldFunctionV(stress, intnl_old[model], model_f);
     for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
     {
       if (model_f[model_surface] > _f[model]->_f_tol)
         // bummer, this model is not admissible at the returned_stress
         all_admissible = false;
       yf_at_returned_stress.push_back(model_f[model_surface]);
     }
     if (!all_admissible)
       // no point in continuing computing yield functions
       break;
   }
  
   if (!all_admissible)
   {
     // we tried using the returned value of stress predicted by
     // the_single_plastic_model, but it wasn't admissible according
     // to other plastic models.  We need to set:
     stress = trial_stress;
     for (unsigned model = 0; model < _num_models; ++model)
       intnl[model] = intnl_old[model];
     // and calculate the remainder of the yield functions at trial_stress
     for (unsigned model = the_single_plastic_model; model < _num_models; ++model)
     {
       _f[model]->yieldFunctionV(trial_stress, intnl[model], model_f);
       for (unsigned model_surface = 0; model_surface < _f[model]->numberSurfaces(); ++model_surface)
         yf.push_back(model_f[model_surface]);
     }
     num_successful_plastic_returns = 0;
     return false;
   }
  
   // So the customized returnMap algorithm can provide a returned
   // (stress, intnl) configuration, and that is admissible according
   // to all plastic models
   yf.resize(0);
   for (unsigned surface = 0; surface < yf_at_returned_stress.size(); ++surface)
     yf.push_back(yf_at_returned_stress[surface]);
   delta_dp = model_delta_dp;
   for (unsigned model_surface = 0; model_surface < _f[the_single_plastic_model]->numberSurfaces();
        ++model_surface)
   {
     cumulative_pm[_surfaces_given_model[the_single_plastic_model][model_surface]] +=
         model_pm[model_surface];
     pm[_surfaces_given_model[the_single_plastic_model][model_surface]] = model_pm[model_surface];
   }
   custom_model = the_single_plastic_model;
   return true;
 }

Referenced by ComputeMultiPlasticityStress::quickStep().

◆ validParams()

InputParameters MultiPlasticityRawComponentAssembler::validParams ( )

static

Definition at line 16 of file MultiPlasticityRawComponentAssembler.C.

 {
   InputParameters params = emptyInputParameters();
   MooseEnum specialIC("none rock joint", "none");
   params.addParam<MooseEnum>("specialIC",
                              specialIC,
                              "For certain combinations of plastic models, the set of active "
                              "constraints can be initialized optimally.  'none': no special "
                              "initialization is performed.  For all other choices, the "
                              "plastic_models must be chosen to have the following types.  'rock': "
                              "'TensileMulti MohrCoulombMulti'.  'joint': 'WeakPlaneTensile "
                              "WeakPlaneShear'.");
   params.addParam<std::vector<UserObjectName>>(
       "plastic_models",
       "List of names of user objects that define the plastic models that could "
       "be active for this material.  If no plastic_models are provided, only "
       "elasticity will be used.");
   params.addClassDescription("RawComponentAssembler class to calculate yield functions, etc, used "
                              "in multi-surface finite-strain plasticity");
   return params;
 }

Referenced by MultiPlasticityLinearSystem::validParams().

◆ yieldFunction()

void MultiPlasticityRawComponentAssembler::yieldFunction	(	const RankTwoTensor &	stress,
		const std::vector< Real > &	intnl,
		const std::vector< bool > &	active,
		std::vector< Real > &	f
	)

protectedvirtual

The active yield function(s)

Parameters

	stress	the stress at which to calculate the yield function
	intnl	vector of internal parameters
	active	set of active constraints - only the active yield functions are put into "f"
[out]	f	the yield function (or functions in the case of multisurface plasticity)

Definition at line 98 of file MultiPlasticityRawComponentAssembler.C.

 {
   mooseAssert(intnl.size() == _num_models, "Incorrect size of internal parameters");
   mooseAssert(active.size() == _num_surfaces, "Incorrect size of active");
  
   f.resize(0);
   std::vector<unsigned int> active_surfaces_of_model;
   std::vector<unsigned int>::iterator active_surface;
   std::vector<Real> model_f;
   for (unsigned model = 0; model < _num_models; ++model)
   {
     activeModelSurfaces(model, active, active_surfaces_of_model);
     if (active_surfaces_of_model.size() > 0)
     {
       _f[model]->yieldFunctionV(stress, intnl[model], model_f);
       for (active_surface = active_surfaces_of_model.begin();
            active_surface != active_surfaces_of_model.end();
            ++active_surface)
         f.push_back(model_f[*active_surface]);
     }
   }
 }

Referenced by ComputeMultiPlasticityStress::buildDumbOrder(), MultiPlasticityLinearSystem::calculateConstraints(), ComputeMultiPlasticityStress::checkAdmissible(), MultiPlasticityDebugger::fddyieldFunction_dintnl(), MultiPlasticityDebugger::fddyieldFunction_dstress(), and ComputeMultiPlasticityStress::returnMap().

Member Data Documentation

◆ _f

std::vector<const TensorMechanicsPlasticModel *> MultiPlasticityRawComponentAssembler::_f

protected

User objects that define the yield functions, flow potentials, etc.

Definition at line 75 of file MultiPlasticityRawComponentAssembler.h.

◆ _model_given_surface

std::vector<unsigned int> MultiPlasticityRawComponentAssembler::_model_given_surface

private

given a surface number, this returns the model number

Definition at line 295 of file MultiPlasticityRawComponentAssembler.h.

Referenced by modelNumber(), and MultiPlasticityRawComponentAssembler().

◆ _model_surface_given_surface

std::vector<unsigned int> MultiPlasticityRawComponentAssembler::_model_surface_given_surface

private

given a surface number, this returns the corresponding-model's internal surface number

Definition at line 298 of file MultiPlasticityRawComponentAssembler.h.

Referenced by MultiPlasticityRawComponentAssembler().

◆ _num_models

unsigned int MultiPlasticityRawComponentAssembler::_num_models

protected

Number of plastic models for this material.

Definition at line 57 of file MultiPlasticityRawComponentAssembler.h.

Referenced by buildActiveConstraints(), MultiPlasticityLinearSystem::calculateConstraints(), MultiPlasticityLinearSystem::calculateJacobian(), MultiPlasticityLinearSystem::calculateRHS(), MultiPlasticityDebugger::checkSolution(), dflowPotential_dintnl(), dflowPotential_dstress(), dhardPotential_dintnl(), dhardPotential_dstress(), dyieldFunction_dintnl(), dyieldFunction_dstress(), MultiPlasticityDebugger::fddflowPotential_dintnl(), MultiPlasticityDebugger::fddyieldFunction_dintnl(), MultiPlasticityDebugger::fdJacobian(), flowPotential(), hardPotential(), ComputeMultiPlasticityStress::initQpStatefulProperties(), MultiPlasticityLinearSystem::MultiPlasticityLinearSystem(), MultiPlasticityRawComponentAssembler(), MultiPlasticityLinearSystem::nrStep(), MultiPlasticityDebugger::outputAndCheckDebugParameters(), ComputeMultiPlasticityStress::plasticStep(), ComputeMultiPlasticityStress::residual2(), ComputeMultiPlasticityStress::returnMap(), returnMapAll(), ComputeMultiPlasticityStress::singleStep(), and yieldFunction().

◆ _num_surfaces

unsigned int MultiPlasticityRawComponentAssembler::_num_surfaces

protected

Number of surfaces within the plastic models.

For many situations this will be = _num_models since each model will contain just one surface. More generally it is >= _num_models. For instance, Mohr-Coulomb is a single model with 6 surfaces

Definition at line 66 of file MultiPlasticityRawComponentAssembler.h.