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

#include <AdaptiveSubstepper.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, nIntegrationDependentStateVars, 1 > IntegrationStateVector
 Vector to carry the internal state of a material. More...
 

Public Member Functions

 AdaptiveSubstepper (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...
 
bool finishSubstep (const Marmot::Vector6d &resultStress, const TangentSizedMatrix &dXdY, 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

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
 
double currentProgress
 
double currentSubstepSize
 
int passedSubsteps
 
int substepIndex
 
Marmot::Vector6d stressProgress
 internal storages for the progress of the total increment More...
 
IntegrationStateVector stateProgress
 
TangentSizedMatrix consistentTangentProgress
 
Marmot::Vector6d stressProgressHalfTemp
 
Marmot::Vector6d stressProgressFullTemp
 
IntegrationStateVector stateProgressHalfTemp
 
IntegrationStateVector stateProgressFullTemp
 
TangentSizedMatrix consistentTangentProgressHalfTemp
 
TangentSizedMatrix consistentTangentProgressFullTemp
 
TangentSizedMatrix elasticTangent
 
SubsteppingState currentState
 

Member Typedef Documentation

◆ TangentSizedMatrix

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

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

Adaptive Substepper, employing an error estimation and Richardson Extrapolation for an Implicit Return Mapping algorithm

Matthias Neuner (2016), developed within the DK-CIM collaboration

◆ IntegrationStateVector

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

Vector to carry the internal state of a material.

Member Enumeration Documentation

◆ SubsteppingState

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

Constructor & Destructor Documentation

◆ AdaptiveSubstepper()

template<size_t n, size_t nState>
Marmot::NumericalAlgorithms::AdaptiveSubstepper< n, nState >::AdaptiveSubstepper ( 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::AdaptiveSubstepper< 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::AdaptiveSubstepper< n, nState >::isFinished

Check if the subincrementation is finished.

◆ getNextSubstep()

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

get the next subincrement size

◆ getNumberOfSubsteps()

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

get the finished number of subincrements

◆ finishSubstep()

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

finish a subincrement with plasticity

◆ finishElasticSubstep()

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

finish a subincrement with elasticity only

◆ discardSubstep()

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

discard the current subincrement

◆ repeatSubstep()

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

repeat the current subincrement with a smaller step

◆ getConvergedProgress()

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

get the last converged state

◆ getCurrentTangentOperator()

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

get the algorithmic tangent for the current state

◆ getResults()

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

Write the current results.

◆ acceptSubstepWithFullStepOnly()

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

◆ splitCurrentSubstep()

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

Member Data Documentation

◆ initialStepSize

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

◆ minimumStepSize

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

◆ maxScaleUpFactor

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

◆ scaleDownFactor

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

◆ integrationErrorTolerance

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

◆ nPassesToIncrease

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

◆ ignoreErrorToleranceOnMinimumStepSize

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

◆ currentProgress

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

◆ currentSubstepSize

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

◆ passedSubsteps

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

◆ substepIndex

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

◆ stressProgress

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

internal storages for the progress of the total increment

◆ stateProgress

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

◆ consistentTangentProgress

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
TangentSizedMatrix Marmot::NumericalAlgorithms::AdaptiveSubstepper< materialTangentSize, nIntegrationDependentStateVars >::consistentTangentProgress
private

◆ stressProgressHalfTemp

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

◆ stressProgressFullTemp

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

◆ stateProgressHalfTemp

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

◆ stateProgressFullTemp

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

◆ consistentTangentProgressHalfTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
TangentSizedMatrix Marmot::NumericalAlgorithms::AdaptiveSubstepper< materialTangentSize, nIntegrationDependentStateVars >::consistentTangentProgressHalfTemp
private

◆ consistentTangentProgressFullTemp

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
TangentSizedMatrix Marmot::NumericalAlgorithms::AdaptiveSubstepper< materialTangentSize, nIntegrationDependentStateVars >::consistentTangentProgressFullTemp
private

◆ elasticTangent

template<size_t materialTangentSize, size_t nIntegrationDependentStateVars>
TangentSizedMatrix Marmot::NumericalAlgorithms::AdaptiveSubstepper< materialTangentSize, nIntegrationDependentStateVars >::elasticTangent
private

◆ currentState

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