double
RCSDEMaterial :: giveNormalCrackingStress(GaussPoint *gp, double crackStrain, int i)
//
// returns receivers Normal Stress in crack i for given cracking strain
//
{
double Gf, Ft, Le, answer, ef;
RCM2MaterialStatus *status = static_cast< RCM2MaterialStatus * >( this->giveStatus(gp) );
Le = status->giveCharLength(i);
Ft = this->computeStrength(gp, Le);
Gf = this->give(pscm_Gf, gp);
ef = Gf / ( Le * Ft );
if ( this->checkSizeLimit(gp, Le) ) {
if ( crackStrain >= status->giveTempMaxCrackStrain(i) ) {
// further softening
answer = Ft * exp(-crackStrain / ef);
} else {
// crack closing
// or unloading or reloading regime
answer = Ft * crackStrain / status->giveTempMaxCrackStrain(i) *
exp(-status->giveTempMaxCrackStrain(i) / ef);
}
} else {
answer = 0.;
}
return answer;
}
double
RCSDEMaterial :: giveCrackingModulus(MatResponseMode rMode, GaussPoint *gp,
double crackStrain, int i)
//
// returns current cracking modulus according to crackStrain for i-th
// crackplane
// now linear softening is implemented
// see also CreateStatus () function.
// softening modulus represents a relation between the normal crack strain
// rate and the normal stress rate.
//
{
// double Ee, Gf;
double Gf, Cf, Ft, Le, ef;
RCM2MaterialStatus *status = static_cast< RCM2MaterialStatus * >( this->giveStatus(gp) );
//
// now we have to set proper reduced strength and softening modulus Et
// in order to obtain energetically correct solution using the concept
// of fracture energy Gf, which is a material constant.
//
//Ee = this->give(pscm_Ee);
Gf = this->give(pscm_Gf, gp);
Le = status->giveCharLength(i);
Ft = this->computeStrength(gp, Le);
//minEffStrainForFullyOpenCrack = this->giveMinCrackStrainsForFullyOpenCrack(gp,i);
ef = Gf / ( Le * Ft );
if ( rMode == TangentStiffness ) {
if ( this->checkSizeLimit(gp, Le) ) {
if ( crackStrain >= status->giveTempMaxCrackStrain(i) ) {
// further softening
Cf = -Ft / ef *exp(-crackStrain / ef);
} else {
// unloading or reloading regime
Cf = Ft / status->giveTempMaxCrackStrain(i) * exp(-status->giveTempMaxCrackStrain(i) / ef);
}
} else {
Cf = 0.;
}
} else {
if ( this->checkSizeLimit(gp, Le) ) {
Cf = Ft / status->giveTempMaxCrackStrain(i) * exp(-status->giveTempMaxCrackStrain(i) / ef);
} else {
Cf = 0.;
}
}
return Cf;
}
double
RCSDMaterial :: giveNormalCrackingStress(GaussPoint *gp, double crackStrain, int i)
//
// returns receivers Normal Stress in crack i for given cracking strain
//
{
double Cf, Ft, Le, answer, minEffStrainForFullyOpenCrack;
RCM2MaterialStatus *status = static_cast< RCM2MaterialStatus * >( this->giveStatus(gp) );
minEffStrainForFullyOpenCrack = this->giveMinCrackStrainsForFullyOpenCrack(gp, i);
Cf = this->giveCrackingModulus(TangentStiffness, gp, crackStrain, i); // < 0
Le = status->giveCharLength(i);
Ft = this->computeStrength(gp, Le);
if ( this->checkSizeLimit(gp, Le) ) {
if ( ( crackStrain >= minEffStrainForFullyOpenCrack ) ||
( status->giveTempMaxCrackStrain(i) >= minEffStrainForFullyOpenCrack ) ) {
// fully open crack - no stiffness
answer = 0.;
} else if ( crackStrain >= status->giveTempMaxCrackStrain(i) ) {
// further softening
answer = Ft + Cf * crackStrain;
} else if ( crackStrain <= 0. ) {
// crack closing
// no stress due to cracking
answer = 0.;
} else {
// unloading or reloading regime
answer = crackStrain * Ft *
( minEffStrainForFullyOpenCrack - status->giveTempMaxCrackStrain(i) ) /
( status->giveTempMaxCrackStrain(i) * minEffStrainForFullyOpenCrack );
}
} else {
answer = 0.;
}
return answer;
}
void
RCM2Material :: updateCrackStatus(GaussPoint *gp, const FloatArray &crackStrain)
//
// updates gp records and MatStatus due to cracking.
//
// Updates MatStatus (respective it's temporary variables) to current
// reached status during integrating incremental constitutive relations
// Temporary variables are used, because we may integrate constitutive
// realtions many times for different strainIncrement in order to
// reach equilibrium state, so we don't want to change other variables
// which describing previously reached equlibrium. After a new equilibrium
// is reached, this->updateYourself is called which invokes matStatus->
// updateYourself(), which copies temporary variables to variables
// describing equilibrium.
//
//
{
int i;
double minCrackStrainsForFullyOpenCrack;
RCM2MaterialStatus *status = ( RCM2MaterialStatus * ) this->giveStatus(gp);
IntArray crackMap;
status->giveCrackMap(crackMap);
// check if material previously cracked
// and compute possible crack planes
// or if newer cracked, so we compute principal stresses
// (for iso mat. coincide with princ strains)
// and compare them with reduced tension strength
// as a criterion for crack initiation
// principalStrain = status->givePrincipalStrainVector();
// transform stresses to principal directions of strains
//
// local stress is updated according to reached local crack strain
//
for ( i = 1; i <= 3; i++ ) { // loop over each possible crack plane
if ( ( crackMap.at(i) != 0 ) &&
( this->giveStressStrainComponentIndOf(FullForm, gp->giveMaterialMode(), i) ) ) {
if ( status->giveTempMaxCrackStrain(i) < crackStrain.at(i) ) {
status->setTempMaxCrackStrain( i, crackStrain.at(i) );
}
minCrackStrainsForFullyOpenCrack = this->giveMinCrackStrainsForFullyOpenCrack(gp, i);
//if ((crackStrain.at(i) >= status->giveMinCrackStrainsForFullyOpenCrack(i)) &&
if ( ( crackStrain.at(i) >= minCrackStrainsForFullyOpenCrack ) &&
( crackStrain.at(i) >= status->giveTempMaxCrackStrain(i) ) ) {
//
// fully open crack
//
status->setTempCrackStatus(i, pscm_OPEN);
} else if ( crackStrain.at(i) >= status->giveTempMaxCrackStrain(i) ) {
//
// further softening of crack
//
status->setTempCrackStatus(i, pscm_SOFTENING);
// status->giveTempReachedSofteningStress()->at(i) = localStress->at(i);
} else if ( crackStrain.at(i) <= 0. ) {
if ( status->giveTempCrackStatus(i) != pscm_NONE ) {
// previously active crack becomes closed
status->setTempCrackStatus(i, pscm_CLOSED);
}
} else {
//
// crack unloading or reloading
//
status->setTempCrackStatus(i, pscm_UNLOADING);
}
} // end for possible direction
} // end loop over prin directions
}
void
RCM2Material :: checkForNewActiveCracks(IntArray &answer, GaussPoint *gp,
const FloatArray &crackStrain,
const FloatArray &princStressVector,
FloatArray &crackStressVector,
const FloatArray &princStrainVector)
//
// returns int_array flag showing if some crack
// is newly activated or
// closed crack is reopened
// return 0 if no crack is activated or reactivated.
// modifies crackStressVector for newly activated crack.
//
{
double initStress, Le = 0.0;
int i, j, upd, activationFlag = 0;
RCM2MaterialStatus *status = ( RCM2MaterialStatus * ) this->giveStatus(gp);
FloatArray localStress;
FloatMatrix tempCrackDirs;
IntArray crackMap;
answer.resize(3);
answer.zero();
status->giveCrackMap(crackMap);
localStress = princStressVector;
//
// local stress is updated according to reached local crack strain
//
for ( i = 1; i <= 3; i++ ) { // loop over each possible crack plane
// test previous status of each possible crack plane
upd = 0;
if ( ( crackMap.at(i) == 0 ) &&
( this->giveStressStrainComponentIndOf(FullForm, gp->giveMaterialMode(), i) ) ) {
if ( status->giveTempMaxCrackStrain(i) > 0. ) {
// if (status->giveTempCrackStatus()->at(i) != pscm_NONE) {
//
// previously cracked direction
//
initStress = 0.;
} else {
// newer cracked, so we compute principal stresses
// and compare them with reduced tension strength
// as a criterion for crack initiation
FloatArray crackPlaneNormal(3);
status->giveTempCrackDirs(tempCrackDirs);
for ( j = 1; j <= 3; j++ ) {
crackPlaneNormal.at(j) = tempCrackDirs.at(j, i);
}
// Le = gp->giveElement()->giveCharacteristicLenght (gp, &crackPlaneNormal);
Le = this->giveCharacteristicElementLenght(gp, crackPlaneNormal);
initStress = this->computeStrength(gp, Le);
upd = 1;
}
if ( localStress.at(i) > initStress ) {
crackStressVector.at(i) = initStress;
answer.at(i) = 1;
activationFlag = 1;
if ( upd ) {
this->updateStatusForNewCrack(gp, i, Le);
}
}
} // end of tested crack
} // end of loop over are possible directions
if ( activationFlag ) {
return;
}
answer.resize(0);
}