void
LIBeam3dNL :: computeRotMtrx(FloatMatrix &answer, FloatArray &psi)
{
FloatMatrix S(3, 3), SS(3, 3);
double psiSize;
if ( psi.giveSize() != 3 ) {
_error("computeSMtrx: psi param size mismatch");
}
answer.resize(3, 3);
answer.zero();
psiSize = psi.computeNorm();
answer.at(1, 1) = answer.at(2, 2) = answer.at(3, 3) = 1.;
if ( psiSize <= 1.e-40 ) {
return;
}
this->computeSMtrx(S, psi);
SS.beProductOf(S, S);
S.times(sin(psiSize) / psiSize);
SS.times( ( 1. - cos(psiSize) ) / ( psiSize * psiSize ) );
answer.add(S);
answer.add(SS);
}
// 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);
}
}
}
void Tr21Stokes :: giveIntegratedVelocity(FloatMatrix &answer, TimeStep *tStep )
{
/*
* Integrate velocity over element
*/
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FloatMatrix v, v_gamma, ThisAnswer, boundaryV, Nmatrix;
double detJ;
FloatArray *lcoords, N;
int i, j, k=0;
Dof *d;
GaussPoint *gp;
v.resize(12,1);
v.zero();
boundaryV.resize(2,1);
for (i=1; i<=this->giveNumberOfDofManagers(); i++) {
for (j=1; j<=this->giveDofManager(i)->giveNumberOfDofs(); j++) {
d = this->giveDofManager(i)->giveDof(j);
if ((d->giveDofID()==V_u) || (d->giveDofID()==V_v)) {
k=k+1;
v.at(k,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
/*} else if (d->giveDofID()==A_x) {
boundaryV.at(1,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
} else if (d->giveDofID()==A_y) {
boundaryV.at(2,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);*/
}
}
}
answer.resize(2,1);
answer.zero();
Nmatrix.resize(2,12);
for (i=0; i<iRule->getNumberOfIntegrationPoints(); i++) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
this->interpolation_quad.evalN(N, *lcoords, FEIElementGeometryWrapper(this));
detJ = this->interpolation_quad.giveTransformationJacobian(*lcoords, FEIElementGeometryWrapper(this));
N.times(detJ*gp->giveWeight());
for (j=1; j<=6;j++) {
Nmatrix.at(1,j*2-1)=N.at(j);
Nmatrix.at(2,j*2)=N.at(j);
}
ThisAnswer.beProductOf(Nmatrix,v);
answer.add(ThisAnswer);
}
}
void
LIBeam2dNL :: computeInitialStressMatrix(FloatMatrix &answer, TimeStep *tStep)
{
int i, j, n;
double dV;
GaussPoint *gp;
IntegrationRule *iRule;
FloatArray stress;
FloatMatrix A;
Material *mat = this->giveMaterial();
answer.resize(6, 6);
answer.zero();
iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
// assemble initial stress matrix
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
stress = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveStressVector();
n = stress.giveSize();
if ( n ) {
for ( j = 1; j <= n; j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( A.isNotEmpty() ) {
A.times(stress.at(j) * dV);
answer.add(A);
}
}
}
}
}
void
NonStationaryTransportProblem :: assembleDirichletBcRhsVector(FloatArray &answer, TimeStep *tStep,
ValueModeType mode,
const UnknownNumberingScheme &ns, Domain *d)
{
IntArray loc, dofids;
FloatArray rp, charVec;
FloatMatrix s;
FloatMatrix capacity;
int nelem = d->giveNumberOfElements();
for ( int ielem = 1; ielem <= nelem; ielem++ ) {
Element *element = d->giveElement(ielem);
element->giveElementDofIDMask(dofids);
element->computeVectorOfPrescribed(dofids, mode, tStep, rp);
if ( rp.containsOnlyZeroes() ) {
continue;
} else {
element->giveCharacteristicMatrix(s, TangentStiffnessMatrix, tStep);
element->giveCharacteristicMatrix(capacity, lumpedCapacityStab ? LumpedMassMatrix : MassMatrix, tStep);
s.times(this->alpha);
s.add(1. / tStep->giveTimeIncrement(), capacity);
charVec.beProductOf(s, rp);
charVec.negated();
element->giveLocationArray(loc, ns);
answer.assemble(charVec, loc);
}
} // end element loop
}
void
SUPGElement :: computeBCLhsPressureTerm_MB(FloatMatrix &answer, TimeStep *tStep)
{
bcType boundarytype;
int nLoads = 0;
//bcType loadtype;
FloatMatrix helpMatrix;
// loop over boundary load array
answer.clear();
nLoads = this->giveBoundaryLoadArray()->giveSize() / 2;
if ( nLoads ) {
for ( int i = 1; i <= nLoads; i++ ) {
int n = boundaryLoadArray.at(1 + ( i - 1 ) * 2);
int side = boundaryLoadArray.at(i * 2);
Load *load = domain->giveLoad(n);
boundarytype = load->giveType();
if ( boundarytype == OutFlowBC ) {
this->computeOutFlowBCTerm_MB(helpMatrix, side, tStep);
answer.add(helpMatrix);
} else {
//_warning("computeForceLoadVector : unsupported load type class");
}
}
}
}
void
NonLinearDynamic :: giveElementCharacteristicMatrix(FloatMatrix &answer, int num,
CharType type, TimeStep *tStep, Domain *domain)
{
// We don't directly call element ->GiveCharacteristicMatrix() function, because some
// engngm classes may require special modification of base types supported on
// element class level.
if ( type == EffectiveStiffnessMatrix ) {
Element *element;
FloatMatrix charMtrx;
element = domain->giveElement(num);
element->giveCharacteristicMatrix(answer, TangentStiffnessMatrix, tStep);
answer.times(1 + this->delta * a1);
element->giveCharacteristicMatrix(charMtrx, MassMatrix, tStep);
charMtrx.times(this->a0 + this->eta * this->a1);
answer.add(charMtrx);
return;
} else {
StructuralEngngModel :: giveElementCharacteristicMatrix(answer, num, type, tStep, domain);
}
}
void MidpointLhsAssembler :: matrixFromElement(FloatMatrix &answer, Element &el, TimeStep *tStep) const
{
FloatMatrix capacity;
el.giveCharacteristicMatrix(answer, TangentStiffnessMatrix, tStep);
el.giveCharacteristicMatrix(capacity, this->lumped ? LumpedMassMatrix : MassMatrix, tStep);
answer.times(this->alpha);
answer.add(1. / tStep->giveTimeIncrement(), capacity);
}
void
SUPGElement :: computeBCLhsTerm_MB(FloatMatrix &answer, TimeStep *tStep)
{
bcType boundarytype;
int nLoads = 0;
//bcType loadtype;
FloatMatrix helpMatrix;
// loop over boundary load array
answer.clear();
nLoads = this->giveBoundaryLoadArray()->giveSize() / 2;
if ( nLoads ) {
for ( int i = 1; i <= nLoads; i++ ) {
int n = boundaryLoadArray.at(1 + ( i - 1 ) * 2);
int side = boundaryLoadArray.at(i * 2);
Load *load = domain->giveLoad(n);
boundarytype = load->giveType();
if ( boundarytype == SlipWithFriction ) {
this->computeSlipWithFrictionBCTerm_MB(helpMatrix, load, side, tStep);
answer.add(helpMatrix);
} else if ( boundarytype == PenetrationWithResistance ) {
this->computePenetrationWithResistanceBCTerm_MB(helpMatrix, load, side, tStep);
answer.add(helpMatrix);
} else {
// OOFEM_ERROR("unsupported load type class");
}
}
}
nLoads = this->giveBodyLoadArray()->giveSize();
if ( nLoads ) {
bcGeomType ltype;
for ( int i = 1; i <= nLoads; i++ ) {
Load *load = domain->giveLoad( bodyLoadArray.at(i) );
ltype = load->giveBCGeoType();
if ( ( ltype == BodyLoadBGT ) && ( load->giveBCValType() == ReinforceBVT ) ) {
this->computeHomogenizedReinforceTerm_MB(helpMatrix, load, tStep);
answer.add(helpMatrix);
}
}
}
}
void
TrPlanestressRotAllman :: computeStiffnessMatrix(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
// compute standard stiffness matrix
TrPlaneStress2d::computeStiffnessMatrix (answer, rMode, tStep);
// add zero energy mode stabilization
FloatMatrix ks;
this->computeStiffnessMatrixZeroEnergyStabilization(ks, rMode, tStep);
answer.add(ks);
}
void
PerfectlyPlasticMaterial :: giveMaterialStiffnessMatrix(FloatMatrix &answer, MatResponseMode mode,
GaussPoint *gp,
TimeStep *tStep)
//
//
//
// computes full constitutive matrix for case of gp stress-strain state.
// it returns elasto-plastic stiffness material matrix.
// if strainIncrement == NULL a loading is assumed
// for detailed description see (W.F.Chen: Plasticity in Reinforced Concrete, McGraw-Hill, 1982,
// chapter 6.)
//
// if derived material would like to implement failure behaviour
// it must redefine basic Give3dMaterialStiffnessMatrix function
// in order to take possible failure (tension cracking) into account
//
// in this function answer is Material stiffness matrix respecting
// current stress-strain mode in gp. This is reached by using
// impose constraints functions
{
FloatArray statusFullStressVector, statusFullPlasticVector, plasticStrainVector;
double lambda;
PerfectlyPlasticMaterialStatus *status = static_cast< PerfectlyPlasticMaterialStatus * >( this->giveStatus(gp) );
// double f = domain->giveYieldCriteria(yieldCriteria)->
// computeValueAt(gp->giveStressVector(), gp->givePlasticStrainVector(),
// gp-> giveHardeningParam());
this->giveEffectiveMaterialStiffnessMatrix(answer, mode, gp, tStep);
// if (f < YIELD_BOUNDARY) // linear elastic behaviour
// return de;
if ( status->giveYieldFlag() == 0 ) {
return;
}
// if secant stiffness requested assume initial elastic matrix
if ( mode == SecantStiffness ) {
return;
}
plasticStrainVector = status->givePlasticStrainVector();
StructuralMaterial :: giveFullSymVectorForm( statusFullPlasticVector, plasticStrainVector, gp->giveMaterialMode() );
StructuralMaterial :: giveFullSymVectorForm( statusFullStressVector, status->giveStressVector(), gp->giveMaterialMode() );
// yield condition satisfied
FloatMatrix dp;
this->computePlasticStiffnessAt(dp, gp, & statusFullStressVector,
& statusFullPlasticVector,
NULL,
tStep,
lambda);
answer.add(dp);
}
void
NonlinearMassTransferMaterial :: giveCharacteristicMatrix(FloatMatrix &answer,
MatResponseForm form,
MatResponseMode mode,
GaussPoint *gp,
TimeStep *atTime)
{
MaterialMode mMode = gp->giveMaterialMode();
AnisotropicMassTransferMaterialStatus *status = ( ( AnisotropicMassTransferMaterialStatus * ) this->giveStatus(gp) );
FloatArray eps = status->giveGradP();
double gradPNorm;
FloatMatrix t1, t2;
gradPNorm = eps.computeNorm();
t1.beDyadicProductOf(eps, eps);
if ( gradPNorm != 0.0 ) {
t1.times( C * alpha * pow(gradPNorm, alpha - 2) );
}
switch ( mMode ) {
case _1dHeat:
t2.resize(1, 1);
t2.at(1, 1) = 1;
break;
case _2dHeat:
t2.resize(2, 2);
t2.at(1, 1) = t2.at(2, 2) = 1;
break;
case _3dHeat:
t2.resize(3, 3);
t2.at(1, 1) = t2.at(2, 2) = t2.at(3, 3) = 1;
break;
default:
_error2( "giveCharacteristicMatrix : unknown mode (%s)", __MaterialModeToString(mMode) );
}
answer.beEmptyMtrx();
answer.add(t1);
answer.add(1 + C * pow(gradPNorm, alpha), t2);
}
void
NonlinearMassTransferMaterial :: giveCharacteristicMatrix(FloatMatrix &answer,
MatResponseMode mode,
GaussPoint *gp,
TimeStep *tStep)
{
MaterialMode mMode = gp->giveMaterialMode();
TransportMaterialStatus *status = static_cast< TransportMaterialStatus * >( this->giveStatus(gp) );
const FloatArray &eps = status->giveTempGradient();
double gradPNorm;
FloatMatrix t1, t2;
gradPNorm = eps.computeNorm();
t1.beDyadicProductOf(eps, eps);
if ( gradPNorm != 0.0 ) {
t1.times( C * alpha * pow(gradPNorm, alpha - 2) );
}
switch ( mMode ) {
case _1dHeat:
t2.resize(1, 1);
break;
case _2dHeat:
t2.resize(2, 2);
break;
case _3dHeat:
t2.resize(3, 3);
break;
default:
OOFEM_ERROR("unknown mode (%s)", __MaterialModeToString(mMode));
}
t2.beUnitMatrix();
answer.clear();
answer.add(t1);
answer.add(1 + C * pow(gradPNorm, alpha), t2);
}
void
GradDpElement :: computeStiffnessMatrix_uu(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
NLStructuralElement *elem = this->giveNLStructuralElement();
StructuralCrossSection *cs = elem->giveStructuralCrossSection();
FloatMatrix B, D, DB;
int nlGeo = elem->giveGeometryMode();
bool matStiffSymmFlag = elem->giveCrossSection()->isCharacteristicMtrxSymmetric(rMode);
answer.clear();
for ( GaussPoint *gp: *elem->giveIntegrationRule(0) ) {
GradDpMaterialExtensionInterface *dpmat = dynamic_cast< GradDpMaterialExtensionInterface * >(
cs->giveMaterialInterface(GradDpMaterialExtensionInterfaceType, gp) );
if ( !dpmat ) {
OOFEM_ERROR("Material doesn't implement the required DpGrad interface!");
}
if ( nlGeo == 0 ) {
elem->computeBmatrixAt(gp, B);
} else if ( nlGeo == 1 ) {
if ( elem->domain->giveEngngModel()->giveFormulation() == AL ) {
elem->computeBmatrixAt(gp, B);
} else {
elem->computeBHmatrixAt(gp, B);
}
}
dpmat->givePDGradMatrix_uu(D, rMode, gp, tStep);
double dV = elem->computeVolumeAround(gp);
DB.beProductOf(D, B);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(B, DB, dV);
} else {
answer.plusProductUnsym(B, DB, dV);
}
}
if ( elem->domain->giveEngngModel()->giveFormulation() == AL ) {
FloatMatrix initialStressMatrix;
elem->computeInitialStressMatrix(initialStressMatrix, tStep);
answer.add(initialStressMatrix);
}
if ( matStiffSymmFlag ) {
answer.symmetrized();
}
}
void EffectiveTangentAssembler :: matrixFromElement(FloatMatrix &answer, Element &el, TimeStep *tStep) const
{
FloatMatrix massMatrix;
if ( this->rmode == TangentStiffness ) {
el.giveCharacteristicMatrix(answer, TangentStiffnessMatrix, tStep);
} else if ( this->rmode == ElasticStiffness ) {
el.giveCharacteristicMatrix(answer, ElasticStiffnessMatrix, tStep);
} else if ( this->rmode == SecantStiffness ) {
el.giveCharacteristicMatrix(answer, SecantStiffnessMatrix, tStep);
}
//element.computeTangentMatrix(answer, this->rmode, tStep);
answer.times(this->k);
el.giveCharacteristicMatrix(massMatrix, this->lumped ? LumpedMassMatrix : MassMatrix, tStep);
answer.add(this->m, massMatrix);
}
void
NonlinearFluidMaterial :: giveDeviatoricStiffnessMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp,
TimeStep *tStep)
{
FloatArray eps;
double normeps2;
NonlinearFluidMaterialStatus *status = static_cast< NonlinearFluidMaterialStatus * >( this->giveStatus(gp) );
eps = status->giveTempDeviatoricStrainVector();
normeps2 = status->giveTempStrainNorm2();
answer.resize( eps.giveSize(), eps.giveSize() );
answer.zero();
for ( int i = 1; i <= answer.giveNumberOfRows(); i++ ) {
answer.at(i, i) = 1.;
}
if ( eps.giveSize() == 3 ) {
answer.at(3, 3) *= 0.5;
} else if ( eps.giveSize() == 4 ) {
answer.at(4, 4) *= 0.5;
} else {
answer.at(4, 4) *= 0.5;
answer.at(5, 5) *= 0.5;
answer.at(6, 6) *= 0.5;
}
if ( normeps2 != 0 ) {
FloatMatrix op;
if ( eps.giveSize() == 3 ) {
eps.at(3) *= 0.5;
} else if ( eps.giveSize() == 4 ) {
eps.at(4) *= 0.5;
} else {
eps.at(4) *= 0.5;
eps.at(5) *= 0.5;
eps.at(6) *= 0.5;
}
op.beDyadicProductOf(eps, eps);
answer.times( 2 * viscosity * ( 1 + c * pow(normeps2, alpha * 0.5) ) );
answer.add(2 * viscosity * c * alpha * pow(normeps2, alpha * 0.5 - 1), op);
} else {
answer.times(2 * viscosity);
}
}
void
NonStationaryTransportProblem :: giveElementCharacteristicMatrix(FloatMatrix &answer, int num,
CharType type, TimeStep *tStep, Domain *domain)
{
// we don't directly call element->GiveCharacteristicMatrix() function, because some
// engngm classes may require special modification of base types supported on
// element class level
if ( ( type == NSTP_MidpointLhs ) || ( type == NSTP_MidpointRhs ) ) {
Element *element;
FloatMatrix charMtrx1, charMtrx2;
element = domain->giveElement(num);
element->giveCharacteristicMatrix(answer, ConductivityMatrix, tStep);
element->giveCharacteristicMatrix(charMtrx2, CapacityMatrix, tStep);
if ( lumpedCapacityStab ) {
int i, j, size = charMtrx2.giveNumberOfRows();
double s;
for ( i = 1; i <= size; i++ ) {
s = 0.0;
for ( j = 1; j <= size; j++ ) {
s += charMtrx2.at(i, j);
charMtrx2.at(i, j) = 0.0;
}
charMtrx2.at(i, i) = s;
}
}
if ( type == NSTP_MidpointLhs ) {
answer.times(this->alpha);
charMtrx2.times( 1. / tStep->giveTimeIncrement() );
} else {
answer.times(this->alpha - 1.0);
charMtrx2.times( 1. / tStep->giveTimeIncrement() );
}
answer.add(charMtrx2);
return;
} else {
EngngModel :: giveElementCharacteristicMatrix(answer, num, type, tStep, domain);
}
}
void
NonlinearFluidMaterial :: giveDeviatoricStiffnessMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp,
TimeStep *atTime)
{
FloatArray eps;
double normeps = 0;
FloatMatrix op, t2;
NonlinearFluidMaterialStatus *status = static_cast< NonlinearFluidMaterialStatus * >( this->giveStatus(gp) );
eps = status->giveTempDeviatoricStrainVector();
eps.at(3) *= 0.5;
normeps = eps.at(1) * eps.at(1) + eps.at(2) * eps.at(2) + 2 * ( eps.at(3) * eps.at(3) );
normeps = sqrt(normeps);
op.resize(3, 3);
op.beDyadicProductOf(eps, eps);
if ( normeps != 0 ) {
op.times( 2 * viscosity * c * alpha * pow(normeps, alpha - 2) );
} else {
op.times(0);
}
t2.resize(3, 3);
t2.zero();
for ( int i = 1; i <= 3; i++ ) {
if ( normeps != 0 ) {
t2.at(i, i) = 2 * viscosity * ( 1 + c * pow(normeps, alpha) );
} else {
t2.at(i, i) = 2 * viscosity;
}
}
t2.at(3, 3) *= 0.5;
answer.resize(3, 3);
answer.zero();
answer.add(op);
answer.add(t2);
}
void
SUPGElement :: computeBCLhsPressureTerm_MC(FloatMatrix &answer, TimeStep *tStep)
{
int nLoads = 0;
//bcType loadtype;
FloatMatrix helpMatrix;
nLoads = this->giveBodyLoadArray()->giveSize();
answer.clear();
if ( nLoads ) {
bcGeomType ltype;
for ( int i = 1; i <= nLoads; i++ ) {
Load *load = domain->giveLoad( bodyLoadArray.at(i) );
ltype = load->giveBCGeoType();
if ( ( ltype == BodyLoadBGT ) && ( load->giveBCValType() == ReinforceBVT ) ) {
this->computeHomogenizedReinforceTerm_MC(helpMatrix, load, tStep);
answer.add(helpMatrix);
}
}
}
}
void
MisesMat :: give3dLSMaterialStiffnessMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *tStep)
{
MisesMatStatus *status = static_cast< MisesMatStatus * >( this->giveStatus(gp) );
// start from the elastic stiffness
FloatMatrix I(6, 6);
I.at(1, 1) = I.at(2, 2) = I.at(3, 3) = 1;
I.at(4, 4) = I.at(5, 5) = I.at(6, 6) = 0.5;
FloatArray delta(6);
delta.at(1) = delta.at(2) = delta.at(3) = 1;
FloatMatrix F;
F.beMatrixForm( status->giveTempFVector() );
double J = F.giveDeterminant();
const FloatArray &trialStressDev = status->giveTrialStressDev();
double trialStressVol = status->giveTrialStressVol();
double trialS = computeStressNorm(trialStressDev);
FloatArray n = trialStressDev;
if ( trialS == 0 ) {
n.resize(6);
} else {
n.times(1 / trialS);
}
FloatMatrix C;
FloatMatrix help;
help.beDyadicProductOf(delta, delta);
C = help;
help.times(-1. / 3.);
FloatMatrix C1 = I;
C1.add(help);
C1.times(2 * trialStressVol);
FloatMatrix n1, n2;
n1.beDyadicProductOf(n, delta);
n2.beDyadicProductOf(delta, n);
help = n1;
help.add(n2);
C1.add(-2. / 3. * trialS, help);
C.times(K * J * J);
C.add(-K * ( J * J - 1 ), I);
C.add(C1);
//////////////////////////////////////////////////////////////////////////////////////////////////////////
FloatMatrix invF;
FloatMatrix T(6, 6);
invF.beInverseOf(F);
//////////////////////////////////////////////////
//first row of pull back transformation matrix
T.at(1, 1) = invF.at(1, 1) * invF.at(1, 1);
T.at(1, 2) = invF.at(1, 2) * invF.at(1, 2);
T.at(1, 3) = invF.at(1, 3) * invF.at(1, 3);
T.at(1, 4) = 2. * invF.at(1, 2) * invF.at(1, 3);
T.at(1, 5) = 2. * invF.at(1, 1) * invF.at(1, 3);
T.at(1, 6) = 2. * invF.at(1, 1) * invF.at(1, 2);
//second row of pull back transformation matrix
T.at(2, 1) = invF.at(2, 1) * invF.at(2, 1);
T.at(2, 2) = invF.at(2, 2) * invF.at(2, 2);
T.at(2, 3) = invF.at(2, 3) * invF.at(2, 3);
T.at(2, 4) = 2. * invF.at(2, 2) * invF.at(2, 3);
T.at(2, 5) = 2. * invF.at(2, 1) * invF.at(2, 3);
T.at(2, 6) = 2. * invF.at(2, 1) * invF.at(2, 2);
//third row of pull back transformation matrix
T.at(3, 1) = invF.at(3, 1) * invF.at(3, 1);
T.at(3, 2) = invF.at(3, 2) * invF.at(3, 2);
T.at(3, 3) = invF.at(3, 3) * invF.at(3, 3);
T.at(3, 4) = 2. * invF.at(3, 2) * invF.at(3, 3);
T.at(3, 5) = 2. * invF.at(3, 1) * invF.at(3, 3);
T.at(3, 6) = 2. * invF.at(3, 1) * invF.at(3, 2);
//fourth row of pull back transformation matrix
T.at(4, 1) = invF.at(2, 1) * invF.at(3, 1);
T.at(4, 2) = invF.at(2, 2) * invF.at(3, 2);
T.at(4, 3) = invF.at(2, 3) * invF.at(3, 3);
T.at(4, 4) = ( invF.at(2, 2) * invF.at(3, 3) + invF.at(2, 3) * invF.at(3, 2) );
T.at(4, 5) = ( invF.at(2, 1) * invF.at(3, 3) + invF.at(2, 3) * invF.at(3, 1) );
T.at(4, 6) = ( invF.at(2, 1) * invF.at(3, 2) + invF.at(2, 2) * invF.at(3, 1) );
//fifth row of pull back transformation matrix
T.at(5, 1) = invF.at(1, 1) * invF.at(3, 1);
T.at(5, 2) = invF.at(1, 2) * invF.at(3, 2);
T.at(5, 3) = invF.at(1, 3) * invF.at(3, 3);
T.at(5, 4) = ( invF.at(1, 2) * invF.at(3, 3) + invF.at(1, 3) * invF.at(3, 2) );
T.at(5, 5) = ( invF.at(1, 1) * invF.at(3, 3) + invF.at(1, 3) * invF.at(3, 1) );
T.at(5, 6) = ( invF.at(1, 1) * invF.at(3, 2) + invF.at(1, 2) * invF.at(3, 1) );
//sixth row of pull back transformation matrix
T.at(6, 1) = invF.at(1, 1) * invF.at(2, 1);
T.at(6, 2) = invF.at(1, 2) * invF.at(2, 2);
T.at(6, 3) = invF.at(1, 3) * invF.at(2, 3);
T.at(6, 4) = ( invF.at(1, 2) * invF.at(2, 3) + invF.at(1, 3) * invF.at(2, 2) );
T.at(6, 5) = ( invF.at(1, 1) * invF.at(2, 3) + invF.at(1, 3) * invF.at(2, 1) );
T.at(6, 6) = ( invF.at(1, 1) * invF.at(2, 2) + invF.at(1, 2) * invF.at(2, 1) );
///////////////////////////////////////////
if ( mode != TangentStiffness ) {
help.beProductTOf(C, T);
answer.beProductOf(T, help);
return;
}
double kappa = status->giveCumulativePlasticStrain();
// increment of cumulative plastic strain as an indicator of plastic loading
double dKappa = sqrt(3. / 2.) * ( status->giveTempCumulativePlasticStrain() - kappa );
//double dKappa = ( status->giveTempCumulativePlasticStrain() - kappa);
if ( dKappa <= 0.0 ) { // elastic loading - elastic stiffness plays the role of tangent stiffness
help.beProductTOf(C, T);
answer.beProductOf(T, help);
return;
}
// === plastic loading ===
//dKappa = dKappa*sqrt(3./2.);
// trial deviatoric stress and its norm
double beta0, beta1, beta2, beta3, beta4;
if ( trialS == 0 ) {
beta1 = 0;
} else {
beta1 = 2 * trialStressVol * dKappa / trialS;
}
if ( trialStressVol == 0 ) {
beta0 = 0;
beta2 = 0;
beta3 = beta1;
beta4 = 0;
} else {
beta0 = 1 + H / 3 / trialStressVol;
beta2 = ( 1 - 1 / beta0 ) * 2. / 3. * trialS * dKappa / trialStressVol;
beta3 = 1 / beta0 - beta1 + beta2;
beta4 = ( 1 / beta0 - beta1 ) * trialS / trialStressVol;
}
FloatMatrix N;
N.beDyadicProductOf(n, n);
N.times(-2 * trialStressVol * beta3);
C1.times(-beta1);
FloatMatrix mN(3, 3);
mN.at(1, 1) = n.at(1);
mN.at(1, 2) = n.at(6);
mN.at(1, 3) = n.at(5);
mN.at(2, 1) = n.at(6);
mN.at(2, 2) = n.at(2);
mN.at(2, 3) = n.at(4);
mN.at(3, 1) = n.at(5);
mN.at(3, 2) = n.at(4);
mN.at(3, 3) = n.at(3);
FloatMatrix mN2;
mN2.beProductOf(mN, mN);
double volN2 = 1. / 3. * ( mN2.at(1, 1) + mN2.at(2, 2) + mN2.at(3, 3) );
FloatArray devN2(6);
devN2.at(1) = mN2.at(1, 1) - volN2;
devN2.at(2) = mN2.at(2, 2) - volN2;
devN2.at(3) = mN2.at(3, 3) - volN2;
devN2.at(4) = mN2.at(2, 3);
devN2.at(5) = mN2.at(1, 3);
devN2.at(6) = mN2.at(1, 2);
FloatMatrix nonSymPart;
nonSymPart.beDyadicProductOf(n, devN2);
//symP.beTranspositionOf(nonSymPart);
//symP.add(nonSymPart);
//symP.times(1./2.);
nonSymPart.times(-2 * trialStressVol * beta4);
C.add(C1);
C.add(N);
C.add(nonSymPart);
help.beProductTOf(C, T);
answer.beProductOf(T, help);
}
void
NLStructuralElement :: computeStiffnessMatrix(FloatMatrix &answer,
MatResponseMode rMode, TimeStep *tStep)
{
StructuralCrossSection *cs = this->giveStructuralCrossSection();
bool matStiffSymmFlag = cs->isCharacteristicMtrxSymmetric(rMode);
answer.clear();
if ( !this->isActivated(tStep) ) {
return;
}
// Compute matrix from material stiffness (total stiffness for small def.) - B^T * dS/dE * B
if ( integrationRulesArray.size() == 1 ) {
FloatMatrix B, D, DB;
for ( auto &gp : *this->giveDefaultIntegrationRulePtr() ) {
// Engineering (small strain) stiffness
if ( nlGeometry == 0 ) {
this->computeBmatrixAt(gp, B);
this->computeConstitutiveMatrixAt(D, rMode, gp, tStep);
} else if ( nlGeometry == 1 ) {
if ( this->domain->giveEngngModel()->giveFormulation() == AL ) { // Material stiffness dC/de
this->computeBmatrixAt(gp, B);
/// @todo We probably need overloaded function (like above) here as well.
cs->giveStiffnessMatrix_dCde(D, rMode, gp, tStep);
} else { // Material stiffness dP/dF
this->computeBHmatrixAt(gp, B);
/// @todo We probably need overloaded function (like above) here as well.
cs->giveStiffnessMatrix_dPdF(D, rMode, gp, tStep);
}
}
double dV = this->computeVolumeAround(gp);
DB.beProductOf(D, B);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(B, DB, dV);
} else {
answer.plusProductUnsym(B, DB, dV);
}
}
if ( this->domain->giveEngngModel()->giveFormulation() == AL ) {
FloatMatrix initialStressMatrix;
this->computeInitialStressMatrix(initialStressMatrix, tStep);
answer.add(initialStressMatrix);
}
} else { /// @todo Verify that it works with large deformations
if ( this->domain->giveEngngModel()->giveFormulation() == AL ) {
OOFEM_ERROR("Updated lagrangian not supported yet");
}
int iStartIndx, iEndIndx, jStartIndx, jEndIndx;
FloatMatrix Bi, Bj, D, Dij, DBj;
for ( int i = 0; i < (int)integrationRulesArray.size(); i++ ) {
iStartIndx = integrationRulesArray [ i ]->getStartIndexOfLocalStrainWhereApply();
iEndIndx = integrationRulesArray [ i ]->getEndIndexOfLocalStrainWhereApply();
for ( int j = 0; j < (int)integrationRulesArray.size(); j++ ) {
IntegrationRule *iRule;
jStartIndx = integrationRulesArray [ j ]->getStartIndexOfLocalStrainWhereApply();
jEndIndx = integrationRulesArray [ j ]->getEndIndexOfLocalStrainWhereApply();
if ( i == j ) {
iRule = integrationRulesArray [ i ].get();
} else if ( integrationRulesArray [ i ]->giveNumberOfIntegrationPoints() < integrationRulesArray [ j ]->giveNumberOfIntegrationPoints() ) {
iRule = integrationRulesArray [ i ].get();
} else {
iRule = integrationRulesArray [ j ].get();
}
for ( GaussPoint *gp: *iRule ) {
// Engineering (small strain) stiffness dSig/dEps
if ( nlGeometry == 0 ) {
this->computeBmatrixAt(gp, Bi, iStartIndx, iEndIndx);
this->computeConstitutiveMatrixAt(D, rMode, gp, tStep);
} else if ( nlGeometry == 1 ) {
if ( this->domain->giveEngngModel()->giveFormulation() == AL ) { // Material stiffness dC/de
this->computeBmatrixAt(gp, Bi);
cs->giveStiffnessMatrix_dCde(D, rMode, gp, tStep);
} else { // Material stiffness dP/dF
this->computeBHmatrixAt(gp, Bi);
cs->giveStiffnessMatrix_dPdF(D, rMode, gp, tStep);
}
}
if ( i != j ) {
if ( nlGeometry == 0 ) {
this->computeBmatrixAt(gp, Bj, jStartIndx, jEndIndx);
} else if ( nlGeometry == 1 ) {
if ( this->domain->giveEngngModel()->giveFormulation() == AL ) {
this->computeBmatrixAt(gp, Bj);
} else {
this->computeBHmatrixAt(gp, Bj);
}
}
} else {
Bj = Bi;
}
Dij.beSubMatrixOf(D, iStartIndx, iEndIndx, jStartIndx, jEndIndx);
double dV = this->computeVolumeAround(gp);
DBj.beProductOf(Dij, Bj);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(Bi, DBj, dV);
} else {
answer.plusProductUnsym(Bi, DBj, dV);
}
}
}
}
}
if ( matStiffSymmFlag ) {
answer.symmetrized();
}
}
void Line2SurfaceTension :: computeTangent(FloatMatrix &answer, TimeStep *tStep)
{
#if 1
answer.resize(6, 6);
answer.zero();
#else
///@todo Support axisymm.
domainType dt = this->giveDomain()->giveDomainType();
if (dt == _3dAxisymmMode) {
OOFEM_ERROR("Line2SurfaceTension :: computeTangent - Axisymm not implemented");
}
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
double t = 1, gamma_s;
///@todo Should i use this? Not that meaningful for flow problems.
//t = this->giveDomain()->giveCrossSection(1)->give(CS_Thickness);
gamma_s = this->giveMaterial()->give('g', NULL);
FloatMatrix xy(2,3);
Node *node;
for (int i = 1; i <= 3; i++) {
node = giveNode(i);
xy.at(1,i) = node->giveCoordinate(1);
xy.at(2,i) = node->giveCoordinate(2);
}
FloatArray A;
FloatArray dNdxi(3);
FloatArray es(2); // tangent vector to curve
FloatMatrix BJ(2,6);
BJ.zero();
FloatMatrix temp1,temp2;
answer.resize(6,6);
answer.zero();
for (int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(k);
double xi = gp->giveCoordinate(1);
dNdxi.at(1) = -0.5+xi;
dNdxi.at(2) = 0.5+xi;
dNdxi.at(3) = -2.0*xi;
es.beProductOf(xy,dNdxi);
double J = es.computeNorm();
es.times(1/J); //es.normalize();
BJ.at(1,1) = BJ.at(2,2) = dNdxi.at(1);
BJ.at(1,3) = BJ.at(2,4) = dNdxi.at(2);
BJ.at(1,5) = BJ.at(2,6) = dNdxi.at(3);
A.beTProductOf(BJ,es);
temp1.beTProductOf(BJ,BJ);
temp2.beDyadicProductOf(A,A);
temp1.subtract(temp2);
temp1.times(t*gp->giveWeight()/J*(tStep->giveTimeIncrement()));
answer.add(temp1);
}
answer.times(gamma_s);
#endif
}
void
GradDpElement :: computeStiffnessMatrix_ku(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
double dV;
NLStructuralElement *elem = this->giveNLStructuralElement();
FloatArray Nk;
FloatMatrix B, DkuB, Dku;
StructuralCrossSection *cs = elem->giveStructuralCrossSection();
answer.clear();
int nlGeo = elem->giveGeometryMode();
for ( auto &gp: *elem->giveIntegrationRule(0) ) {
GradDpMaterialExtensionInterface *dpmat = dynamic_cast< GradDpMaterialExtensionInterface * >(
cs->giveMaterialInterface(GradDpMaterialExtensionInterfaceType, gp) );
if ( !dpmat ) {
OOFEM_ERROR("Material doesn't implement the required DpGrad interface!");
}
elem->computeBmatrixAt(gp, B);
if ( nlGeo == 1 ) {
if ( elem->domain->giveEngngModel()->giveFormulation() == AL ) {
elem->computeBmatrixAt(gp, B);
} else {
elem->computeBHmatrixAt(gp, B);
}
}
dpmat->givePDGradMatrix_ku(Dku, rMode, gp, tStep);
this->computeNkappaMatrixAt(gp, Nk);
dV = elem->computeVolumeAround(gp);
DkuB.beProductOf(Dku, B);
answer.plusProductUnsym(Nk, DkuB, -dV);
if ( dpmat->giveAveragingType() == 2 ) {
double dl1, dl2, dl3;
FloatArray Gk;
FloatMatrix D, DB, LDB;
FloatMatrix Bk, BktM22, BktM22Gk, BktM12, BktM12Gk, M22(2, 2), M12(2, 2);
FloatMatrix dL1(1, 3), dL2(1, 3), result1, result2, dLdS, n(2, 2);
this->computeBkappaMatrixAt(gp, Bk);
dpmat->givePDGradMatrix_uu(D, rMode, gp, tStep);
dpmat->givePDGradMatrix_LD(dLdS, rMode, gp, tStep);
this->computeNonlocalGradient(Gk, gp, tStep);
dl1 = dLdS.at(3, 3);
dl2 = dLdS.at(4, 4);
dl3 = dLdS.at(5, 5);
n.at(1, 1) = dLdS.at(1, 1);
n.at(1, 2) = dLdS.at(1, 2);
n.at(2, 1) = dLdS.at(2, 1);
n.at(2, 2) = dLdS.at(2, 2);
// first term Bk^T M22 G L1 D B
// M22 = n2 \otimes n2
M22.at(1, 1) = n.at(1, 2) * n.at(1, 2);
M22.at(1, 2) = n.at(1, 2) * n.at(2, 2);
M22.at(2, 1) = n.at(2, 2) * n.at(1, 2);
M22.at(2, 2) = n.at(2, 2) * n.at(2, 2);
// dL1
dL1.at(1, 1) = dl1 * n.at(1, 1) * n.at(1, 1) + dl2 *n.at(1, 2) * n.at(1, 2);
dL1.at(1, 2) = dl1 * n.at(2, 1) * n.at(2, 1) + dl2 *n.at(2, 2) * n.at(2, 2);
dL1.at(1, 3) = dl1 * n.at(1, 1) * n.at(2, 1) + dl2 *n.at(1, 2) * n.at(2, 2);
DB.beProductOf(D, B);
LDB.beProductOf(dL1, DB);
BktM22.beTProductOf(Bk, M22);
///@todo This can't possibly work if this is uncommented (!) / Mikael
//BktM22Gk.beProductOf(BktM22,Gk);
result1.beProductOf(BktM22Gk, LDB);
answer.add(dV, result1);
// This would be slightly shorter and faster;
//GkLDB.beProductOf(Gk, LDB);
//MGkLDB.beProductOf(M22, GkLDB);
//answer.plusProductUnsym(Bk, MGkLDB, dV);
// M12 + M21 = n1 \otimes n2 + n2 \otimes n1
M12.at(1, 1) = n.at(1, 1) * n.at(1, 2) + n.at(1, 2) * n.at(1, 1);
M12.at(1, 2) = n.at(1, 1) * n.at(2, 2) + n.at(1, 2) * n.at(2, 1);
M12.at(2, 1) = n.at(2, 1) * n.at(1, 2) + n.at(2, 2) * n.at(1, 1);
M12.at(2, 2) = n.at(2, 1) * n.at(2, 2) + n.at(2, 2) * n.at(2, 1);
//dL2
dL2.at(1, 1) = dl3 * ( n.at(1, 1) * n.at(1, 2) + n.at(1, 1) * n.at(1, 2) );
dL2.at(1, 2) = dl3 * ( n.at(2, 1) * n.at(2, 2) + n.at(2, 1) * n.at(2, 2) );
dL2.at(1, 3) = dl3 * ( n.at(1, 2) * n.at(2, 1) + n.at(1, 1) * n.at(2, 2) );
LDB.beProductOf(dL2, DB);
BktM12.beTProductOf(Bk, M12);
///@todo This can't possibly work if this is uncommented (!) / Mikael
//BktM12Gk.beProductOf(BktM12,Gk);
result2.beProductOf(BktM12Gk, LDB);
answer.add(dV, result2);
// This would be slightly shorter and faster;
//GkLDB.beProductOf(Gk, LDB);
//MGkLDB.beProductOf(M12, GkLDB);
//answer.plusProductUnsym(Bk, MGkLDB, dV);
}
}
}
void LineSurfaceTension :: computeTangent(FloatMatrix &answer, TimeStep *tStep)
{
#if 1
///@todo Not sure if it's a good idea to use this tangent.
answer.resize(4,4);
answer.zero();
#else
domainType dt = this->giveDomain()->giveDomainType();
int ndofs = this->computeNumberOfDofs(EID_MomentumBalance);
Node *node1, *node2;
double x1, x2, y1, y2, dx, dy, vx, vy, length, width, gamma_s;
gamma_s = this->giveMaterial()->give('g',NULL);
node1 = giveNode(1);
node2 = giveNode(2);
x1 = node1->giveCoordinate(1);
x2 = node2->giveCoordinate(1);
y1 = node1->giveCoordinate(2);
y2 = node2->giveCoordinate(2);
dx = x2-x1;
dy = y2-y1;
length = sqrt(dx*dx + dy*dy);
vx = dx/length;
vy = dy/length;
FloatArray Ah(4);
Ah.at(1) = -vx;
Ah.at(2) = -vy;
Ah.at(3) = vx;
Ah.at(4) = vy;
FloatMatrix NpTNp(4,4);
NpTNp.zero();
NpTNp.at(1,1) = 1;
NpTNp.at(2,2) = 1;
NpTNp.at(3,3) = 1;
NpTNp.at(4,4) = 1;
NpTNp.at(1,3) = -1;
NpTNp.at(2,4) = -1;
NpTNp.at(3,1) = -1;
NpTNp.at(4,2) = -1;
answer.resize(ndofs,ndofs);
answer.zero();
if (dt == _3dAxisymmMode) {
OOFEM_WARNING("Not tested");
FloatArray Bh(4);
Bh.zero();
Bh.at(1) = 1;
Bh.at(3) = 1;
// It was simpler to write this in index notation.
// Also using 0-based, to reduce typing
double rJinv = (x1+x2)/length;
answer.zero();
for (int i = 0; i < 4; i++) for (int j = 0; j < 4; j++) {
answer(i,j) = M_PI*(Ah(i)*Bh(j) + Bh(i)*Ah(j)+ rJinv*(NpTNp(i,j) - Ah(i)*Ah(j)));
}
}
else {
width = 1;
answer.beDyadicProductOf(Ah,Ah);
answer.add(NpTNp);
answer.times(width/length);
}
answer.times(gamma_s);
#endif
}
void
TrabBone3D :: give3dMaterialStiffnessMatrix(FloatMatrix &answer,
MatResponseMode mode, GaussPoint *gp,
TimeStep *tStep)
{
double tempDam, beta, tempKappa, kappa;
FloatArray tempEffectiveStress, tempTensor2, prodTensor, plasFlowDirec;
FloatMatrix elasticity, compliance, SSaTensor, secondTerm, thirdTerm, tangentMatrix;
TrabBone3DStatus *status = static_cast< TrabBone3DStatus * >( this->giveStatus(gp) );
if ( mode == ElasticStiffness ) {
this->constructAnisoComplTensor(compliance);
//this->constructAnisoStiffnessTensor(elasticity);
elasticity.beInverseOf(compliance);
answer = elasticity;
} else if ( mode == SecantStiffness ) {
if ( printflag ) {
printf("secant\n");
}
this->constructAnisoStiffnessTensor(elasticity);
this->constructAnisoComplTensor(compliance);
elasticity.beInverseOf(compliance);
tempDam = status->giveTempDam();
answer = elasticity;
answer.times(1.0 - tempDam);
} else if ( mode == TangentStiffness ) {
kappa = status->giveKappa();
tempKappa = status->giveTempKappa();
tempDam = status->giveTempDam();
if ( tempKappa > kappa ) {
// plastic loading
// Imports
tempEffectiveStress = status->giveTempEffectiveStress();
plasFlowDirec = status->givePlasFlowDirec();
SSaTensor = status->giveSSaTensor();
beta = status->giveBeta();
// Construction of the dyadic product tensor
prodTensor.beTProductOf(SSaTensor, plasFlowDirec);
// Construction of the tangent stiffness third term
thirdTerm.beDyadicProductOf(tempEffectiveStress, prodTensor);
thirdTerm.times( -expDam * critDam * exp(-expDam * tempKappa) );
thirdTerm.times(1. / beta);
// Construction of the tangent stiffness second term
tempTensor2.beProductOf(SSaTensor, plasFlowDirec);
secondTerm.beDyadicProductOf(tempTensor2, prodTensor);
secondTerm.times(-( 1.0 - tempDam ) / beta);
// Construction of the tangent stiffness
tangentMatrix = SSaTensor;
tangentMatrix.times(1.0 - tempDam);
tangentMatrix.add(secondTerm);
tangentMatrix.add(thirdTerm);
answer = tangentMatrix;
//answer.beTranspositionOf(tangentMatrix);
} else {
// elastic behavior with damage
// Construction of the secant stiffness
this->constructAnisoComplTensor(compliance);
elasticity.beInverseOf(compliance);
//this->constructAnisoStiffnessTensor(elasticity);
answer = elasticity;
answer.times(1.0 - tempDam);
}
double g = status->giveDensG();
if ( g <= 0. ) {
double factor = gammaL0 * pow(rho, rL) + gammaP0 *pow(rho, rP) * ( tDens - 1 ) * pow(g, tDens - 2);
// printf("densification");
tangentMatrix.resize(6, 6);
tangentMatrix.zero();
tangentMatrix.at(1, 1) = tangentMatrix.at(1, 2) = tangentMatrix.at(1, 3) = 1;
tangentMatrix.at(2, 1) = tangentMatrix.at(2, 2) = tangentMatrix.at(2, 3) = 1;
tangentMatrix.at(3, 1) = tangentMatrix.at(3, 2) = tangentMatrix.at(3, 3) = 1;
tangentMatrix.times(factor);
answer.add(tangentMatrix);
}
}
status->setSmtrx(answer);
}
void PrescribedGradientBCNeumann :: integrateTangent(FloatMatrix &oTangent, Element *e, int iBndIndex)
{
FloatArray normal, n;
FloatMatrix nMatrix, E_n;
FloatMatrix contrib;
Domain *domain = e->giveDomain();
XfemElementInterface *xfemElInt = dynamic_cast< XfemElementInterface * >( e );
FEInterpolation *interp = e->giveInterpolation(); // Geometry interpolation
int nsd = e->giveDomain()->giveNumberOfSpatialDimensions();
// Interpolation order
int order = interp->giveInterpolationOrder();
IntegrationRule *ir = NULL;
IntArray edgeNodes;
FEInterpolation2d *interp2d = dynamic_cast< FEInterpolation2d * >( interp );
if ( interp2d == NULL ) {
OOFEM_ERROR("failed to cast to FEInterpolation2d.")
}
interp2d->computeLocalEdgeMapping(edgeNodes, iBndIndex);
const FloatArray &xS = * ( e->giveDofManager( edgeNodes.at(1) )->giveCoordinates() );
const FloatArray &xE = * ( e->giveDofManager( edgeNodes.at( edgeNodes.giveSize() ) )->giveCoordinates() );
if ( xfemElInt != NULL && domain->hasXfemManager() ) {
std :: vector< Line >segments;
std :: vector< FloatArray >intersecPoints;
xfemElInt->partitionEdgeSegment(iBndIndex, segments, intersecPoints);
MaterialMode matMode = e->giveMaterialMode();
ir = new DiscontinuousSegmentIntegrationRule(1, e, segments, xS, xE);
int numPointsPerSeg = 1;
ir->SetUpPointsOnLine(numPointsPerSeg, matMode);
} else {
ir = interp->giveBoundaryIntegrationRule(order, iBndIndex);
}
oTangent.clear();
for ( GaussPoint *gp: *ir ) {
FloatArray &lcoords = * gp->giveNaturalCoordinates();
FEIElementGeometryWrapper cellgeo(e);
// Evaluate the normal;
double detJ = interp->boundaryEvalNormal(normal, iBndIndex, lcoords, cellgeo);
interp->boundaryEvalN(n, iBndIndex, lcoords, cellgeo);
// If cracks cross the edge, special treatment is necessary.
// Exploit the XfemElementInterface to minimize duplication of code.
if ( xfemElInt != NULL && domain->hasXfemManager() ) {
// Compute global coordinates of Gauss point
FloatArray globalCoord;
interp->boundaryLocal2Global(globalCoord, iBndIndex, lcoords, cellgeo);
// Compute local coordinates on the element
FloatArray locCoord;
e->computeLocalCoordinates(locCoord, globalCoord);
xfemElInt->XfemElementInterface_createEnrNmatrixAt(nMatrix, locCoord, * e, false);
} else {
// Evaluate the velocity/displacement coefficients
nMatrix.beNMatrixOf(n, nsd);
}
if ( nsd == 3 ) {
OOFEM_ERROR("not implemented for nsd == 3.")
} else if ( nsd == 2 ) {
E_n.resize(4, 2);
E_n.at(1, 1) = normal.at(1);
E_n.at(1, 2) = 0.0;
E_n.at(2, 1) = 0.0;
E_n.at(2, 2) = normal.at(2);
E_n.at(3, 1) = normal.at(2);
E_n.at(3, 2) = 0.0;
E_n.at(4, 1) = 0.0;
E_n.at(4, 2) = normal.at(1);
} else {
E_n.clear();
}
contrib.beProductOf(E_n, nMatrix);
oTangent.add(detJ * gp->giveWeight(), contrib);
}
delete ir;
}
void
NLStructuralElement :: computeStiffnessMatrix(FloatMatrix &answer,
MatResponseMode rMode, TimeStep *tStep)
//
// Computes numerically the stiffness matrix of the receiver.
// taking into account possible effects of nonlinear geometry
//
{
int i, j, k, l, m, n, iStartIndx, iEndIndx, jStartIndx, jEndIndx;
double dV;
FloatMatrix d, A, *ut = NULL, b2;
FloatMatrix bi, bj, dbj, dij;
FloatArray u, stress;
GaussPoint *gp;
IntegrationRule *iRule;
bool matStiffSymmFlag = this->giveCrossSection()->isCharacteristicMtrxSymmetric(rMode, this->material);
answer.resize( computeNumberOfDofs(EID_MomentumBalance), computeNumberOfDofs(EID_MomentumBalance) );
answer.zero();
if ( !this->isActivated(tStep) ) {
return;
}
Material *mat = this->giveMaterial();
if ( nlGeometry ) {
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, u);
if ( u.giveSize() ) {
ut = new FloatMatrix( &u, 1);
} else {
ut = NULL;
}
}
if ( numberOfIntegrationRules > 1 ) {
for ( i = 0; i < numberOfIntegrationRules; i++ ) {
iStartIndx = integrationRulesArray [ i ]->getStartIndexOfLocalStrainWhereApply();
iEndIndx = integrationRulesArray [ i ]->getEndIndexOfLocalStrainWhereApply();
for ( j = 0; j < numberOfIntegrationRules; j++ ) {
jStartIndx = integrationRulesArray [ j ]->getStartIndexOfLocalStrainWhereApply();
jEndIndx = integrationRulesArray [ j ]->getEndIndexOfLocalStrainWhereApply();
if ( i == j ) {
iRule = integrationRulesArray [ i ];
} else if ( integrationRulesArray [ i ]->getNumberOfIntegrationPoints() < integrationRulesArray [ j ]->getNumberOfIntegrationPoints() ) {
iRule = integrationRulesArray [ i ];
} else {
iRule = integrationRulesArray [ j ];
}
for ( k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
gp = iRule->getIntegrationPoint(k);
this->computeBmatrixAt(gp, bi, iStartIndx, iEndIndx);
if ( i != j ) {
this->computeBmatrixAt(gp, bj, jStartIndx, jEndIndx);
} else {
bj = bi;
}
if ( nlGeometry ) {
for ( l = 0; l < bi.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l + iStartIndx);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( m = 1; m <= bi.giveNumberOfColumns(); m++ ) {
// add nonlinear contribution to each component
bi.at(l + 1, m) += b2.at(1, m); //mj
}
}
}
}
if ( nlGeometry && ( i != j ) ) {
for ( l = 0; l < bj.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l + jStartIndx);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( m = 1; m <= bj.giveNumberOfColumns(); m++ ) {
// add nonlinear contribution to each component
bj.at(l + 1, m) += b2.at(1, m); //mj
}
}
}
} // end nlGeometry
this->computeConstitutiveMatrixAt(d, rMode, gp, tStep);
dij.beSubMatrixOf(d, iStartIndx, iEndIndx, jStartIndx, jEndIndx);
dV = this->computeVolumeAround(gp);
dbj.beProductOf(dij, bj);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(bi, dbj, dV);
} else {
answer.plusProductUnsym(bi, dbj, dV);
}
}
}
}
} else { // numberOfIntegrationRules == 1
iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
for ( j = 0; j < iRule->getNumberOfIntegrationPoints(); j++ ) {
gp = iRule->getIntegrationPoint(j);
this->computeBmatrixAt(gp, bj);
if ( nlGeometry ) {
for ( l = 1; l <= bj.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( k = 1; k <= bj.giveNumberOfColumns(); k++ ) {
// add nonlinear contribution to each component
bj.at(l, k) += b2.at(1, k); //mj
}
}
}
} // end nlGeometry
this->computeConstitutiveMatrixAt(d, rMode, gp, tStep);
dV = this->computeVolumeAround(gp);
dbj.beProductOf(d, bj);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(bj, dbj, dV);
} else {
answer.plusProductUnsym(bj, dbj, dV);
}
}
}
if ( nlGeometry ) {
delete ut;
}
if ( nlGeometry ) {
iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
// assemble initial stress matrix
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
stress = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveTempStressVector();
n = stress.giveSize();
if ( n ) {
for ( j = 1; j <= n; j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( A.isNotEmpty() ) {
A.times(stress.at(j) * dV);
answer.add(A);
}
}
}
}
} // end nlGeometry
if ( matStiffSymmFlag ) {
answer.symmetrized();
}
}
void
NLStructuralElement :: computeStiffnessMatrix_withIRulesAsSubcells(FloatMatrix &answer,
MatResponseMode rMode, TimeStep *tStep)
//
// Computes numerically the stiffness matrix of the receiver.
// taking into account possible effects of nonlinear geometry
//
{
int i, j, k, l, n, ir;
double dV;
FloatMatrix temp, d, A, *ut = NULL, b2;
FloatMatrix bi, bj, dbj, dij;
FloatArray u, stress;
GaussPoint *gp;
IntegrationRule *iRule;
IntArray irlocnum;
answer.resize( computeNumberOfDofs(EID_MomentumBalance), computeNumberOfDofs(EID_MomentumBalance) );
answer.zero();
if ( !this->isActivated(tStep) ) {
return;
}
Material *mat = this->giveMaterial();
if ( nlGeometry ) {
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, u);
if ( u.giveSize() ) {
ut = new FloatMatrix( &u, 1);
} else {
ut = NULL;
}
}
FloatMatrix *m = & answer;
if ( this->giveInterpolation() && this->giveInterpolation()->hasSubPatchFormulation() ) {
m = & temp;
}
// loop over individual integration rules
for ( ir = 0; ir < numberOfIntegrationRules; ir++ ) {
iRule = integrationRulesArray [ ir ];
for ( j = 0; j < iRule->getNumberOfIntegrationPoints(); j++ ) {
gp = iRule->getIntegrationPoint(j);
this->computeBmatrixAt(gp, bj);
if ( nlGeometry ) {
for ( l = 1; l <= bj.giveNumberOfRows(); l++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, l);
if ( ( A.isNotEmpty() ) && ( ut != NULL ) ) {
b2.beProductOf(* ut, A);
for ( k = 1; k <= bj.giveNumberOfColumns(); k++ ) {
// add nonlinear contribution to each component
bj.at(l, k) += b2.at(1, k); //mj
}
}
}
} // end nlGeometry
this->computeConstitutiveMatrixAt(d, rMode, gp, tStep);
dV = this->computeVolumeAround(gp);
dbj.beProductOf(d, bj);
m->plusProductSymmUpper(bj, dbj, dV);
}
if ( nlGeometry ) {
delete ut;
}
// localize irule contribution into element matrix
if ( this->giveIntegrationRuleLocalCodeNumbers(irlocnum, iRule, EID_MomentumBalance) ) {
answer.assemble(* m, irlocnum);
m->resize(0, 0);
}
}
if ( nlGeometry ) {
for ( ir = 0; ir < numberOfIntegrationRules; ir++ ) {
m->resize(0, 0);
iRule = integrationRulesArray [ ir ];
// assemble initial stress matrix
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
stress = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveStressVector();
n = stress.giveSize();
if ( n ) {
for ( j = 1; j <= n; j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( A.isNotEmpty() ) {
A.times(stress.at(j) * dV);
m->add(A);
}
}
}
}
// localize irule contribution into element matrix
if ( this->giveIntegrationRuleLocalCodeNumbers(irlocnum, iRule, EID_MomentumBalance) ) {
answer.assemble(* m, irlocnum);
m->resize(0, 0);
}
}
} // ens nlGeometry
answer.symmetrized();
}
