void
MisesMat :: give1dStressStiffMtrx(FloatMatrix &answer,
MatResponseMode mode,
GaussPoint *gp,
TimeStep *tStep)
{
this->giveLinearElasticMaterial()->give1dStressStiffMtrx(answer, mode, gp, tStep);
MisesMatStatus *status = static_cast< MisesMatStatus * >( this->giveStatus(gp) );
double kappa = status->giveCumulativePlasticStrain();
// increment of cumulative plastic strain as an indicator of plastic loading
double tempKappa = status->giveTempCumulativePlasticStrain();
double omega = status->giveTempDamage();
double E = answer.at(1, 1);
if ( mode != TangentStiffness ) {
return;
}
if ( tempKappa <= kappa ) { // elastic loading - elastic stiffness plays the role of tangent stiffness
answer.times(1 - omega);
return;
}
// === plastic loading ===
const FloatArray &stressVector = status->giveTempEffectiveStress();
double stress = stressVector.at(1);
answer.resize(1, 1);
answer.at(1, 1) = ( 1 - omega ) * E * H / ( E + H ) - computeDamageParamPrime(tempKappa) * E / ( E + H ) * stress * signum(stress);
}
void
MisesMatGrad :: give3dGprime(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
{
MisesMatGradStatus *status = static_cast< MisesMatGradStatus * >( this->giveStatus(gp) );
answer.resize(6, 1);
answer.zero();
double damage, tempDamage;
double nlKappa, kappa;
double gPrime;
double tempKappa = status->giveTempCumulativePlasticStrain();
damage = status->giveDamage();
tempDamage = status->giveTempDamage();
nlKappa = status->giveNonlocalCumulatedStrain();
kappa = mParam * nlKappa + ( 1. - mParam ) * tempKappa;
if ( ( tempDamage - damage ) > 0 ) {
const FloatArray &tempEffStress = status->giveTempEffectiveStress();
for ( int i = 1; i <= 6; i++ ) {
answer.at(i, 1) = tempEffStress.at(i);
}
gPrime = computeDamageParamPrime(kappa);
answer.times(gPrime * mParam);
} else {
answer.zero();
}
}
void
MisesMatNl :: give1dStressStiffMtrx(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
{
answer.resize(1, 1);
answer.zero();
LinearElasticMaterial *lmat = this->giveLinearElasticMaterial();
double E = lmat->give('E', gp);
double nlKappa;
MisesMatNlStatus *status = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
double kappa = status->giveCumulativePlasticStrain();
double tempKappa = status->giveTempCumulativePlasticStrain();
double tempDamage = status->giveTempDamage();
double damage = status->giveDamage();
answer.at(1, 1) = ( 1 - tempDamage ) * E;
if ( mode != TangentStiffness ) {
return;
}
if ( tempKappa <= kappa ) { // elastic loading - elastic stiffness plays the role of tangent stiffness
return;
}
// === plastic loading ===
const FloatArray &stressVector = status->giveTempEffectiveStress();
double stress = stressVector.at(1);
answer.at(1, 1) = ( 1. - tempDamage ) * E * H / ( E + H );
if ( tempDamage > damage ) {
this->computeCumPlasticStrain(nlKappa, gp, tStep);
answer.at(1, 1) = answer.at(1, 1) - ( 1 - mm ) * computeDamageParamPrime(nlKappa) * E / ( E + H ) * stress * sgn(stress);
}
}
int
MisesMatNl :: giveLocalNonlocalStiffnessContribution(GaussPoint *gp, IntArray &loc, const UnknownNumberingScheme &s,
FloatArray &lcontrib, TimeStep *atTime)
{
int nrows, nsize, i, j;
double sum, nlKappa, damage, tempDamage, dDamF;
MisesMatNlStatus *status = ( MisesMatNlStatus * ) this->giveStatus(gp);
StructuralElement *elem = ( StructuralElement * )( gp->giveElement() );
FloatMatrix b;
FloatArray stress;
this->computeCumPlasticStrain(nlKappa, gp, atTime);
damage = status->giveDamage();
tempDamage = status->giveTempDamage();
if ( ( tempDamage - damage ) > 0 ) {
elem->giveLocationArray(loc, EID_MomentumBalance, s);
status->giveTempEffectiveStress(stress);
elem->computeBmatrixAt(gp, b);
dDamF = computeDamageParamPrime(nlKappa);
nrows = b.giveNumberOfColumns();
nsize = stress.giveSize();
lcontrib.resize(nrows);
for ( i = 1; i <= nrows; i++ ) {
sum = 0.0;
for ( j = 1; j <= nsize; j++ ) {
sum += b.at(j, i) * stress.at(j);
}
lcontrib.at(i) = sum * mm * dDamF;
}
}
return 1;
}
// returns the consistent (algorithmic) tangent stiffness matrix
void
MisesMat :: give3dSSMaterialStiffnessMatrix(FloatMatrix &answer,
MatResponseMode mode,
GaussPoint *gp,
TimeStep *atTime)
{
// start from the elastic stiffness
this->giveLinearElasticMaterial()->give3dMaterialStiffnessMatrix(answer, mode, gp, atTime);
if ( mode != TangentStiffness ) {
return;
}
MisesMatStatus *status = static_cast< MisesMatStatus * >( this->giveStatus(gp) );
double kappa = status->giveCumulativePlasticStrain();
double tempKappa = status->giveTempCumulativePlasticStrain();
// increment of cumulative plastic strain as an indicator of plastic loading
double dKappa = tempKappa - kappa;
if ( dKappa <= 0.0 ) { // elastic loading - elastic stiffness plays the role of tangent stiffness
return;
}
// === plastic loading ===
// yield stress at the beginning of the step
double sigmaY = sig0 + H * kappa;
// trial deviatoric stress and its norm
StressVector trialStressDev(_3dMat);
double trialStressVol;
status->giveTrialStressVol(trialStressVol);
status->giveTrialStressDev(trialStressDev);
double trialS = trialStressDev.computeStressNorm();
// one correction term
FloatMatrix stiffnessCorrection(6, 6);
stiffnessCorrection.beDyadicProductOf(trialStressDev, trialStressDev);
double factor = -2. * sqrt(6.) * G * G / trialS;
double factor1 = factor * sigmaY / ( ( H + 3. * G ) * trialS * trialS );
stiffnessCorrection.times(factor1);
answer.add(stiffnessCorrection);
// another correction term
stiffnessCorrection.bePinvID();
double factor2 = factor * dKappa;
stiffnessCorrection.times(factor2);
answer.add(stiffnessCorrection);
//influence of damage
// double omega = computeDamageParam(tempKappa);
double omega = status->giveTempDamage();
answer.times(1. - omega);
FloatArray effStress;
status->giveTempEffectiveStress(effStress);
double omegaPrime = computeDamageParamPrime(tempKappa);
double scalar = -omegaPrime *sqrt(6.) * G / ( 3. * G + H ) / trialS;
stiffnessCorrection.beDyadicProductOf(effStress, trialStressDev);
stiffnessCorrection.times(scalar);
answer.add(stiffnessCorrection);
}
void
MisesMatGrad :: givePlaneStrainStiffMtrx(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
{
this->giveLinearElasticMaterial()->giveStiffnessMatrix(answer, mode, gp, tStep);
if ( mode != TangentStiffness ) {
return;
}
MisesMatGradStatus *status = static_cast< MisesMatGradStatus * >( this->giveStatus(gp) );
double tempKappa = status->giveTempCumulativePlasticStrain();
double kappa = status->giveCumulativePlasticStrain();
double dKappa = tempKappa - kappa;
double tempDamage = status->giveTempDamage();
double damage = status->giveDamage();
if ( dKappa <= 0.0 ) { // elastic loading - elastic stiffness plays the role of tangent stiffness
return;
}
// === plastic loading ===
// yield stress at the beginning of the step
double sigmaY = sig0 + H * kappa;
// trial deviatoric stress and its norm
StressVector trialStressDev(status->giveTrialStressDev(), _PlaneStrain);
double trialS = trialStressDev.computeStressNorm();
// volumetric stress
//double trialStressVol = status->giveTrialStressVol();
// one correction term
FloatMatrix stiffnessCorrection(4, 4);
stiffnessCorrection.beDyadicProductOf(trialStressDev, trialStressDev);
double factor = -2. * sqrt(6.) * G * G / trialS;
double factor1 = factor * sigmaY / ( ( H + 3. * G ) * trialS * trialS );
stiffnessCorrection.times(factor1);
answer.add(stiffnessCorrection);
// another correction term
stiffnessCorrection.zero();
stiffnessCorrection.at(1, 1) = stiffnessCorrection.at(2, 2) = stiffnessCorrection.at(3, 3) = 2. / 3.;
stiffnessCorrection.at(1, 2) = stiffnessCorrection.at(1, 3) = stiffnessCorrection.at(2, 1) = -1. / 3.;
stiffnessCorrection.at(2, 3) = stiffnessCorrection.at(3, 1) = stiffnessCorrection.at(3, 2) = -1. / 3.;
stiffnessCorrection.at(4, 4) = 0.5;
double factor2 = factor * dKappa;
stiffnessCorrection.times(factor2);
answer.add(stiffnessCorrection);
//influence of damage
answer.times(1 - tempDamage);
if ( tempDamage > damage ) {
const FloatArray &effStress = status->giveTempEffectiveStress();
double nlKappa = status->giveNonlocalCumulatedStrain();
kappa = mParam * nlKappa + ( 1. - mParam ) * tempKappa;
double omegaPrime = computeDamageParamPrime(kappa);
double scalar = -omegaPrime *sqrt(6.) * G / ( 3. * G + H ) / trialS;
stiffnessCorrection.beDyadicProductOf(effStress, trialStressDev);
stiffnessCorrection.times( scalar * ( 1. - mParam ) );
answer.add(stiffnessCorrection);
}
}
void
MisesMatGrad :: give3dMaterialStiffnessMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
{
MisesMatGradStatus *status = static_cast< MisesMatGradStatus * >( this->giveStatus(gp) );
this->giveLinearElasticMaterial()->give3dMaterialStiffnessMatrix(answer, mode, gp, tStep);
// start from the elastic stiffness
if ( mode != TangentStiffness ) {
return;
}
double tempKappa = status->giveTempCumulativePlasticStrain();
double kappa = status->giveCumulativePlasticStrain();
double dKappa = tempKappa - kappa;
if ( dKappa > 0.0 ) {
double tempDamage = status->giveTempDamage();
double damage = status->giveDamage();
double sigmaY = sig0 + H * kappa;
// trial deviatoric stress and its norm
StressVector trialStressDev(status->giveTrialStressDev(), _3dMat);
/*****************************************************/
//double trialStressVol = status->giveTrialStressVol();
/****************************************************/
double trialS = trialStressDev.computeStressNorm();
// one correction term
FloatMatrix stiffnessCorrection(6, 6);
stiffnessCorrection.beDyadicProductOf(trialStressDev, trialStressDev);
double factor = -2. * sqrt(6.) * G * G / trialS;
double factor1 = factor * sigmaY / ( ( H + 3. * G ) * trialS * trialS );
stiffnessCorrection.times(factor1);
answer.add(stiffnessCorrection);
// another correction term
stiffnessCorrection.bePinvID();
double factor2 = factor * dKappa;
stiffnessCorrection.times(factor2);
answer.add(stiffnessCorrection);
//influence of damage
answer.times(1. - tempDamage);
if ( tempDamage > damage ) {
const FloatArray &effStress = status->giveTempEffectiveStress();
double nlKappa = status->giveNonlocalCumulatedStrain();
kappa = mParam * nlKappa + ( 1. - mParam ) * tempKappa;
double omegaPrime = computeDamageParamPrime(kappa);
double scalar = -omegaPrime *sqrt(6.) * G / ( 3. * G + H ) / trialS;
stiffnessCorrection.beDyadicProductOf(effStress, trialStressDev);
stiffnessCorrection.times( scalar * ( 1. - mParam ) );
answer.add(stiffnessCorrection);
}
}
}
// computes m*gprime*Btransposed*sigmaeff for the given Gauss point
// and returns 0 of damage is not growing, 1 if it is growing
// (if damage is not growing, the contribution is not considered at all)
int
RankineMatNl :: giveLocalNonlocalStiffnessContribution(GaussPoint *gp, IntArray &loc, const UnknownNumberingScheme &s,
FloatArray &lcontrib, TimeStep *atTime)
{
int nrows, nsize, i, j;
double sum, nlKappa, damage, tempDamage;
RankineMatNlStatus *status = ( RankineMatNlStatus * ) this->giveStatus(gp);
StructuralElement *elem = ( StructuralElement * )( gp->giveElement() );
FloatMatrix b;
FloatArray stress;
damage = status->giveDamage();
tempDamage = status->giveTempDamage();
if ( tempDamage <= damage ) {
return 0; // no contribution if damage is not growing
}
elem->giveLocationArray(loc, EID_MomentumBalance, s);
status->giveTempEffectiveStress(stress);
elem->computeBmatrixAt(gp, b);
this->computeCumPlasticStrain(nlKappa, gp, atTime);
double factor = computeDamageParamPrime(nlKappa);
factor *= mm; // this factor is m*gprime
nrows = b.giveNumberOfColumns();
nsize = stress.giveSize();
lcontrib.resize(nrows);
// compute the product Btransposed*stress and multiply by factor
for ( i = 1; i <= nrows; i++ ) {
sum = 0.0;
for ( j = 1; j <= nsize; j++ ) {
sum += b.at(j, i) * stress.at(j);
}
lcontrib.at(i) = sum * factor;
}
return 1; // contribution will be considered
}
int
MisesMatNl :: giveLocalNonlocalStiffnessContribution(GaussPoint *gp, IntArray &loc, const UnknownNumberingScheme &s,
FloatArray &lcontrib, TimeStep *tStep)
{
double nlKappa, damage, tempDamage, dDamF;
MisesMatNlStatus *status = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
StructuralElement *elem = static_cast< StructuralElement * >( gp->giveElement() );
FloatMatrix b;
this->computeCumPlasticStrain(nlKappa, gp, tStep);
damage = status->giveDamage();
tempDamage = status->giveTempDamage();
if ( ( tempDamage - damage ) > 0 ) {
const FloatArray &stress = status->giveTempEffectiveStress();
elem->giveLocationArray(loc, s);
elem->computeBmatrixAt(gp, b);
dDamF = computeDamageParamPrime(nlKappa);
lcontrib.clear();
lcontrib.plusProduct(b, stress, mm * dDamF);
}
return 1;
}
void
MisesMatGrad :: give1dStressStiffMtrx(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
{
answer.resize(1, 1);
LinearElasticMaterial *lmat = this->giveLinearElasticMaterial();
double E = lmat->give('E', gp);
answer.at(1, 1) = E;
if ( mode != TangentStiffness ) {
return;
}
MisesMatGradStatus *status = static_cast< MisesMatGradStatus * >( this->giveStatus(gp) );
double tempKappa = status->giveTempCumulativePlasticStrain();
// increment of cumulative plastic strain as an indicator of plastic loading
double dKappa = ( tempKappa - status->giveCumulativePlasticStrain() );
/********************************************************************/
double tempDamage = status->giveTempDamage();
double damage = status->giveDamage();
/*********************************************************************/
double nlKappa = status->giveNonlocalCumulatedStrain();
double kappa = mParam * nlKappa + ( 1. - mParam ) * tempKappa;
if ( dKappa <= 0.0 ) {
answer.at(1, 1) = ( 1. - tempDamage ) * E;
return;
}
// === plastic loading ===
const FloatArray &stressVector = status->giveTempEffectiveStress();
double stress = stressVector.at(1);
answer.at(1, 1) = ( 1. - tempDamage ) * E * H / ( E + H );
if ( ( tempDamage - damage ) > 0 ) {
answer.at(1, 1) = answer.at(1, 1) - ( 1. - mParam ) * computeDamageParamPrime(kappa) * E / ( E + H ) * signum(stress) * stress;
}
}
void
RankineMatNl :: givePlaneStressStiffMtrx(FloatMatrix &answer, MatResponseForm form, MatResponseMode mode, GaussPoint *gp, TimeStep *atTime)
{
if ( mode == ElasticStiffness ) {
this->giveLinearElasticMaterial()->giveCharacteristicMatrix(answer, form, mode, gp, atTime);
return;
}
RankineMatNlStatus *status = ( RankineMatNlStatus * ) this->giveStatus(gp);
if ( mode == SecantStiffness ) {
this->giveLinearElasticMaterial()->giveCharacteristicMatrix(answer, form, mode, gp, atTime);
double damage = status->giveTempDamage();
answer.times(1. - damage);
return;
}
if ( mode == TangentStiffness ) {
double tempDamage = status->giveTempDamage();
double damage = status->giveDamage();
double gprime;
if ( tempDamage <= damage ) { // unloading
gprime = 0.;
} else { // loading
double kappa;
computeCumPlasticStrain(kappa, gp, atTime);
gprime = computeDamageParamPrime(kappa);
gprime *= ( 1. - mm );
}
evaluatePlaneStressStiffMtrx(answer, form, mode, gp, atTime, gprime);
return;
}
_error("RankineMatNl :: givePlaneStressStiffMtrx ... unknown type of stiffness\n");
}