Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars > Class Template Reference

#include <AdaptiveSubstepperExplicit.h>

Public Types

typedef Eigen::Matrix< double, materialTangentSize, materialTangentSize > TangentSizedMatrix
 Matrix for describing the nonlinear equation system of the return mapping algorithm. More...
 
typedef Eigen::Matrix< double, materialTangentSize, 6 > MatrixStateStrain
 
typedef Eigen::Matrix< double, nIntegrationDependentStateVars, 1 > IntegrationStateVector
 

Public Member Functions

 AdaptiveSubstepperExplicit (double initialStepSize, double minimumStepSize, double maxScaleUpFactor, double scaleDownFactor, double integrationErrorTolerance, int nPassesToIncrease, const Matrix6d &Cel)
 
void setConvergedProgress (const Marmot::Vector6d &stressOld, const IntegrationStateVector &stateVarsOld)
 Set the current converged state. More...
 
bool isFinished ()
 Check if the subincrementation is finished. More...
 
double getNextSubstep ()
 get the next subincrement size More...
 
int getNumberOfSubsteps ()
 get the finished number of subincrements More...
 
int getNumberDiscardedSubstepsDueToError ()
 get the number of discarded subincrements More...
 
bool finishSubstep (const Marmot::Vector6d &resultStress, const TangentSizedMatrix &dXdY, const TangentSizedMatrix &dYdXOld, const IntegrationStateVector &stateVars)
 finish a subincrement with plasticity More...
 
void finishElasticSubstep (const Marmot::Vector6d &resultStress)
 finish a subincrement with elasticity only More...
 
bool discardSubstep ()
 discard the current subincrement More...
 
bool repeatSubstep (double decrementationFactor)
 repeat the current subincrement with a smaller step More...
 
void getConvergedProgress (Marmot::Vector6d &stress, IntegrationStateVector &stateVars)
 get the last converged state More...
 
Matrix6d getCurrentTangentOperator ()
 get the algorithmic tangent for the current state More...
 
void getResults (Marmot::Vector6d &stress, Matrix6d &consistentTangent, IntegrationStateVector &stateVars)
 Write the current results. More...
 

Private Types

enum  SubsteppingState { FullStep, FirstHalfStep, SecondHalfStep }
 

Private Member Functions

const TangentSizedMatrix & IXX ()
 
const MatrixStateStrain & IX6 ()
 
bool acceptSubstepWithFullStepOnly ()
 
bool splitCurrentSubstep ()
 

Private Attributes

const double initialStepSize
 
const double minimumStepSize
 
const double maxScaleUpFactor
 
const double scaleDownFactor
 
const double integrationErrorTolerance
 
const int nPassesToIncrease
 
const bool ignoreErrorToleranceOnMinimumStepSize
 
const Matrix6d & Cel
 
double currentProgress
 
double currentSubstepSize
 
int passedSubsteps
 
int substepIndex
 
int discardedDueToError
 
Marmot::Vector6d stressProgress
 internal storages for the progress of the total increment More...
 
IntegrationStateVector stateProgress
 internal storages for the progress of the total increment More...
 
MatrixStateStrain consistentTangentProgress
 internal storages for the progress of the total increment More...
 
Marmot::Vector6d stressProgressHalfTemp
 temporal storages, which are used until a cycle full/half/half has finished successfully More...
 
Marmot::Vector6d stressProgressFullTemp
 
IntegrationStateVector stateProgressHalfTemp
 temporal storages, which are used until a cycle full/half/half has finished successfully More...
 
IntegrationStateVector stateProgressFullTemp
 
MatrixStateStrain consistentTangentProgressHalfTemp
 temporal storages, which are used until a cycle full/half/half has finished successfully More...
 
MatrixStateStrain consistentTangentProgressFullTemp
 
SubsteppingState currentState
 

Member Typedef Documentation

◆ TangentSizedMatrix

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
typedef Eigen::Matrix< double, materialTangentSize, materialTangentSize > Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::TangentSizedMatrix

Matrix for describing the nonlinear equation system of the return mapping algorithm.

◆ MatrixStateStrain

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
typedef Eigen::Matrix< double, materialTangentSize, 6 > Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::MatrixStateStrain

◆ IntegrationStateVector

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
typedef Eigen::Matrix< double, nIntegrationDependentStateVars, 1 > Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::IntegrationStateVector

Member Enumeration Documentation

◆ SubsteppingState

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
enum Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit::SubsteppingState
private
Enumerator
FullStep 
FirstHalfStep 
SecondHalfStep 

Constructor & Destructor Documentation

◆ AdaptiveSubstepperExplicit()

template<size_t n, size_t nState>
Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::AdaptiveSubstepperExplicit ( double  initialStepSize,
double  minimumStepSize,
double  maxScaleUpFactor,
double  scaleDownFactor,
double  integrationErrorTolerance,
int  nPassesToIncrease,
const Matrix6d &  Cel 
)

Member Function Documentation

◆ setConvergedProgress()

template<size_t n, size_t nState>
void Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::setConvergedProgress ( const Marmot::Vector6d &  stressOld,
const IntegrationStateVector &  stateVarsOld 
)

Set the current converged state.

◆ isFinished()

template<size_t n, size_t nState>
bool Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::isFinished

Check if the subincrementation is finished.

◆ getNextSubstep()

template<size_t n, size_t nState>
double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::getNextSubstep

get the next subincrement size

◆ getNumberOfSubsteps()

template<size_t n, size_t nState>
int Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::getNumberOfSubsteps

get the finished number of subincrements

◆ getNumberDiscardedSubstepsDueToError()

template<size_t n, size_t nState>
int Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::getNumberDiscardedSubstepsDueToError

get the number of discarded subincrements

◆ finishSubstep()

template<size_t n, size_t nState>
bool Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::finishSubstep ( const Marmot::Vector6d &  resultStress,
const TangentSizedMatrix &  dXdY,
const TangentSizedMatrix &  dYdXOld,
const IntegrationStateVector &  stateVars 
)

finish a subincrement with plasticity

◆ finishElasticSubstep()

template<size_t n, size_t nState>
void Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::finishElasticSubstep ( const Marmot::Vector6d &  resultStress)

finish a subincrement with elasticity only

◆ discardSubstep()

template<size_t n, size_t nState>
bool Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::discardSubstep

discard the current subincrement

◆ repeatSubstep()

template<size_t n, size_t nState>
bool Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::repeatSubstep ( double  decrementationFactor)

repeat the current subincrement with a smaller step

◆ getConvergedProgress()

template<size_t n, size_t nState>
void Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::getConvergedProgress ( Marmot::Vector6d &  stress,
IntegrationStateVector &  stateVars 
)

get the last converged state

◆ getCurrentTangentOperator()

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
Matrix6d Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::getCurrentTangentOperator ( )

get the algorithmic tangent for the current state

◆ getResults()

template<size_t n, size_t nState>
void Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::getResults ( Marmot::Vector6d &  stress,
Matrix6d &  consistentTangent,
IntegrationStateVector &  stateVars 
)

Write the current results.

◆ IXX()

template<size_t n, size_t nState>
const AdaptiveSubstepperExplicit< n, nState >::TangentSizedMatrix & Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::IXX
private

◆ IX6()

template<size_t n, size_t nState>
const AdaptiveSubstepperExplicit< n, nState >::MatrixStateStrain & Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::IX6
private

◆ acceptSubstepWithFullStepOnly()

template<size_t n, size_t nState>
bool Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::acceptSubstepWithFullStepOnly
private

◆ splitCurrentSubstep()

template<size_t n, size_t nState>
bool Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< n, nState >::splitCurrentSubstep
private

Member Data Documentation

◆ initialStepSize

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::initialStepSize
private

◆ minimumStepSize

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::minimumStepSize
private

◆ maxScaleUpFactor

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::maxScaleUpFactor
private

◆ scaleDownFactor

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::scaleDownFactor
private

◆ integrationErrorTolerance

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::integrationErrorTolerance
private

◆ nPassesToIncrease

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const int Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::nPassesToIncrease
private

◆ ignoreErrorToleranceOnMinimumStepSize

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const bool Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::ignoreErrorToleranceOnMinimumStepSize
private

◆ Cel

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
const Matrix6d& Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::Cel
private

◆ currentProgress

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::currentProgress
private

◆ currentSubstepSize

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
double Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::currentSubstepSize
private

◆ passedSubsteps

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
int Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::passedSubsteps
private

◆ substepIndex

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
int Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::substepIndex
private

◆ discardedDueToError

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
int Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::discardedDueToError
private

◆ stressProgress

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
Marmot::Vector6d Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::stressProgress
private

internal storages for the progress of the total increment

◆ stateProgress

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
IntegrationStateVector Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::stateProgress
private

internal storages for the progress of the total increment

◆ consistentTangentProgress

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
MatrixStateStrain Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::consistentTangentProgress
private

internal storages for the progress of the total increment

◆ stressProgressHalfTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
Marmot::Vector6d Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::stressProgressHalfTemp
private

temporal storages, which are used until a cycle full/half/half has finished successfully

◆ stressProgressFullTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
Marmot::Vector6d Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::stressProgressFullTemp
private

◆ stateProgressHalfTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
IntegrationStateVector Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::stateProgressHalfTemp
private

temporal storages, which are used until a cycle full/half/half has finished successfully

◆ stateProgressFullTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
IntegrationStateVector Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::stateProgressFullTemp
private

◆ consistentTangentProgressHalfTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
MatrixStateStrain Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::consistentTangentProgressHalfTemp
private

temporal storages, which are used until a cycle full/half/half has finished successfully

◆ consistentTangentProgressFullTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
MatrixStateStrain Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::consistentTangentProgressFullTemp
private

◆ currentState

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
SubsteppingState Marmot::NumericalAlgorithms::AdaptiveSubstepperExplicit< materialTangentSize, nIntegrationDependentStateVars >::currentState
private
The documentation for this class was generated from the following file: