void
MisesMatNl :: giveRemoteNonlocalStiffnessContribution(GaussPoint *gp, IntArray &rloc, const UnknownNumberingScheme &s,
FloatArray &rcontrib, TimeStep *tStep)
{
double kappa, tempKappa;
MisesMatNlStatus *status = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
StructuralElement *elem = static_cast< StructuralElement * >( gp->giveElement() );
FloatMatrix b;
LinearElasticMaterial *lmat = this->giveLinearElasticMaterial();
double E = lmat->give('E', gp);
elem->giveLocationArray(rloc, s);
elem->computeBmatrixAt(gp, b);
kappa = status->giveCumulativePlasticStrain();
tempKappa = status->giveTempCumulativePlasticStrain();
rcontrib.clear();
if ( ( tempKappa - kappa ) > 0 ) {
const FloatArray &stress = status->giveTempEffectiveStress();
if ( gp->giveMaterialMode() == _1dMat ) {
double coeff = sgn( stress.at(1) ) * E / ( E + H );
rcontrib.plusProduct(b, stress, coeff);
return;
}
}
rcontrib.resize(b.giveNumberOfColumns());
rcontrib.zero();
}
std :: list< localIntegrationRecord > *
MisesMatNl :: NonlocalMaterialStiffnessInterface_giveIntegrationDomainList(GaussPoint *gp)
{
MisesMatNlStatus *status = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
this->buildNonlocalPointTable(gp);
return status->giveIntegrationDomainList();
}
void
MisesMatNl :: updateBeforeNonlocAverage(const FloatArray &strainVector, GaussPoint *gp, TimeStep *tStep)
{
/* Implements the service updating local variables in given integration points,
* which take part in nonlocal average process. Actually, no update is necessary,
* because the value used for nonlocal averaging is strain vector used for nonlocal secant stiffness
* computation. It is therefore necessary only to store local strain in corresponding status.
* This service is declared at StructuralNonlocalMaterial level.
*/
double cumPlasticStrain;
MisesMatNlStatus *nlstatus = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
this->initTempStatus(gp);
this->initGpForNewStep(gp);
this->performPlasticityReturn(gp, strainVector);
this->computeLocalCumPlasticStrain(cumPlasticStrain, gp, tStep);
// standard formulation based on averaging of equivalent strain
nlstatus->setLocalCumPlasticStrainForAverage(cumPlasticStrain);
// influence of damage on weight function
if ( averType >= 2 && averType <= 5 ) {
this->modifyNonlocalWeightFunctionAround(gp);
}
}
void
MisesMatNl :: NonlocalMaterialStiffnessInterface_addIPContribution(SparseMtrx &dest, const UnknownNumberingScheme &s,
GaussPoint *gp, TimeStep *tStep)
{
double coeff;
MisesMatNlStatus *status = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
std :: list< localIntegrationRecord > *list = status->giveIntegrationDomainList();
MisesMatNl *rmat;
FloatArray rcontrib, lcontrib;
IntArray loc, rloc;
FloatMatrix contrib;
if ( this->giveLocalNonlocalStiffnessContribution(gp, loc, s, lcontrib, tStep) == 0 ) {
return;
}
for ( auto &lir: *list ) {
rmat = dynamic_cast< MisesMatNl * >( lir.nearGp->giveMaterial() );
if ( rmat ) {
rmat->giveRemoteNonlocalStiffnessContribution(lir.nearGp, rloc, s, rcontrib, tStep);
coeff = gp->giveElement()->computeVolumeAround(gp) * lir.weight / status->giveIntegrationScale();
contrib.clear();
contrib.plusDyadUnsym(lcontrib, rcontrib, - 1.0 * coeff);
dest.assemble(loc, rloc, contrib);
}
}
}
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;
}
int
MisesMatNl :: packUnknowns(CommunicationBuffer &buff, TimeStep *tStep, GaussPoint *ip)
{
MisesMatNlStatus *nlStatus = static_cast< MisesMatNlStatus * >( this->giveStatus(ip) );
this->buildNonlocalPointTable(ip);
this->updateDomainBeforeNonlocAverage(tStep);
return buff.packDouble( nlStatus->giveLocalCumPlasticStrainForAverage() );
}
int
MisesMatNl :: unpackAndUpdateUnknowns(CommunicationBuffer &buff, TimeStep *tStep, GaussPoint *ip)
{
int result;
MisesMatNlStatus *nlStatus = static_cast< MisesMatNlStatus * >( this->giveStatus(ip) );
double localCumPlasticStrainForAverage;
result = buff.unpackDouble(localCumPlasticStrainForAverage);
nlStatus->setLocalCumPlasticStrainForAverage(localCumPlasticStrainForAverage);
return result;
}
void
MisesMatNl :: giveRealStressVector(FloatArray &answer, GaussPoint *gp,
const FloatArray &totalStrain, TimeStep *tStep)
{
MisesMatNlStatus *nlStatus = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
this->initGpForNewStep(gp);
double tempDam;
performPlasticityReturn(gp, totalStrain);
tempDam = this->computeDamage(gp, tStep);
answer.beScaled(1.0 - tempDam, nlStatus->giveTempEffectiveStress());
nlStatus->setTempDamage(tempDam);
nlStatus->letTempStrainVectorBe(totalStrain);
nlStatus->letTempStressVectorBe(answer);
}
double
MisesMatNl :: computeDamage(GaussPoint *gp, TimeStep *tStep)
{
MisesMatNlStatus *nlStatus = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
double nlKappa;
this->computeCumPlasticStrain(nlKappa, gp, tStep);
double dam, tempDam;
dam = nlStatus->giveDamage();
tempDam = this->computeDamageParam(nlKappa);
if ( tempDam < dam ) {
tempDam = dam;
}
return tempDam;
}
void
MisesMatNl :: giveRealStressVector(FloatArray &answer, MatResponseForm form, GaussPoint *gp,
const FloatArray &totalStrain, TimeStep *atTime)
{
MisesMatNlStatus *nlStatus = ( MisesMatNlStatus * ) this->giveStatus(gp);
this->initGpForNewStep(gp);
double tempDam;
FloatArray tempEffStress, totalStress;
MaterialMode mode = gp->giveMaterialMode();
performPlasticityReturn(gp, totalStrain, mode);
tempDam = this->computeDamage(gp, atTime);
nlStatus->giveTempEffectiveStress(tempEffStress);
answer.beScaled( 1.0 - tempDam, tempEffStress);
nlStatus->setTempDamage(tempDam);
nlStatus->letTempStrainVectorBe(totalStrain);
nlStatus->letTempStressVectorBe(answer);
}
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);
}
}
void
MisesMatNl :: giveRemoteNonlocalStiffnessContribution(GaussPoint *gp, IntArray &rloc, const UnknownNumberingScheme &s,
FloatArray &rcontrib, TimeStep *atTime)
{
int ncols, nsize, i, j;
double sum, kappa, tempKappa;
MisesMatNlStatus *status = ( MisesMatNlStatus * ) this->giveStatus(gp);
StructuralElement *elem = ( StructuralElement * )( gp->giveElement() );
FloatMatrix b;
FloatArray stress;
LinearElasticMaterial *lmat = this->giveLinearElasticMaterial();
double E = lmat->give('E', gp);
elem->giveLocationArray(rloc, EID_MomentumBalance, s);
elem->computeBmatrixAt(gp, b);
ncols = b.giveNumberOfColumns();
rcontrib.resize(ncols);
kappa = status->giveCumulativePlasticStrain();
tempKappa = status->giveTempCumulativePlasticStrain();
if ( ( tempKappa - kappa ) > 0 ) {
status->giveTempEffectiveStress(stress);
if ( gp->giveMaterialMode() == _1dMat ) {
nsize = stress.giveSize();
double coeff = sgn( stress.at(1) ) * E / ( E + H );
for ( i = 1; i <= ncols; i++ ) {
sum = 0.;
for ( j = 1; j <= nsize; j++ ) {
sum += stress.at(j) * coeff * b.at(j, i);
}
rcontrib.at(i) = sum;
}
}
} else {
rcontrib.zero();
}
}
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
MisesMatNl :: NonlocalMaterialStiffnessInterface_addIPContribution(SparseMtrx &dest, const UnknownNumberingScheme &s,
GaussPoint *gp, TimeStep *atTime)
{
double coeff;
MisesMatNlStatus *status = ( MisesMatNlStatus * ) this->giveStatus(gp);
std::list< localIntegrationRecord > *list = status->giveIntegrationDomainList();
std::list< localIntegrationRecord > :: iterator pos;
MisesMatNl *rmat;
FloatArray rcontrib, lcontrib;
IntArray loc, rloc;
FloatMatrix contrib;
if ( this->giveLocalNonlocalStiffnessContribution(gp, loc, s, lcontrib, atTime) == 0 ) {
return;
}
for ( pos = list->begin(); pos != list->end(); ++pos ) {
rmat = ( MisesMatNl * )( ( * pos ).nearGp )->giveMaterial();
if ( rmat->giveClassID() == this->giveClassID() ) {
rmat->giveRemoteNonlocalStiffnessContribution( ( * pos ).nearGp, rloc, s, rcontrib, atTime );
coeff = gp->giveElement()->computeVolumeAround(gp) * ( * pos ).weight / status->giveIntegrationScale();
int i, j, dim1 = loc.giveSize(), dim2 = rloc.giveSize();
contrib.resize(dim1, dim2);
for ( i = 1; i <= dim1; i++ ) {
for ( j = 1; j <= dim2; j++ ) {
contrib.at(i, j) = -1.0 * lcontrib.at(i) * rcontrib.at(j) * coeff;
}
}
dest.assemble(loc, rloc, contrib);
}
}
}
