void
GradDpElement :: giveNonlocalInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
double dV, localCumulatedStrain = 0.;
NLStructuralElement *elem = this->giveNLStructuralElement();
FloatMatrix stiffKappa, Nk;
FloatArray fKappa(nlSize), aux(nlSize), dKappa, stress;
aux.zero();
int size = nSecVars * nSecNodes;
//set displacement and nonlocal location array
this->setDisplacementLocationArray(locU, nPrimNodes, nPrimVars, nSecNodes, nSecVars);
this->setNonlocalLocationArray(locK, nPrimNodes, nPrimVars, nSecNodes, nSecVars);
answer.resize(size);
for ( GaussPoint *gp: *elem->giveIntegrationRule(0) ) {
this->computeNkappaMatrixAt(gp, Nk);
for ( int j = 1; j <= nlSize; j++ ) {
fKappa.at(j) = Nk.at(1, j);
}
dV = elem->computeVolumeAround(gp);
this->computeStressVectorAndLocalCumulatedStrain(stress, localCumulatedStrain, gp, tStep);
fKappa.times(localCumulatedStrain);
fKappa.times(-dV);
aux.add(fKappa);
}
this->computeStiffnessMatrix_kk(stiffKappa, TangentStiffness, tStep);
this->computeNonlocalDegreesOfFreedom(dKappa, tStep);
answer.beProductOf(stiffKappa, dKappa);
answer.add(aux);
}
void
GradDpElement :: computeStressVectorAndLocalCumulatedStrain(FloatArray &answer, double localCumulatedStrain, GaussPoint *gp, TimeStep *tStep)
{
NLStructuralElement *elem = this->giveNLStructuralElement();
double nlCumulatedStrain;
int nlGeo = elem->giveGeometryMode();
StructuralCrossSection *cs = elem->giveStructuralCrossSection();
GradDpMaterialExtensionInterface *dpmat = static_cast< GradDpMaterialExtensionInterface * >(
cs->giveMaterialInterface(GradDpMaterialExtensionInterfaceType, gp) );
if ( !dpmat ) {
OOFEM_ERROR("Material doesn't implement the required DpGrad interface!");
}
this->computeNonlocalCumulatedStrain(nlCumulatedStrain, gp, tStep);
if ( nlGeo == 0 ) {
FloatArray Epsilon;
this->computeLocalStrainVector(Epsilon, gp, tStep);
dpmat->giveRealStressVectorGrad(answer, localCumulatedStrain, gp, Epsilon, nlCumulatedStrain, tStep);
} else if ( nlGeo == 1 ) {
if ( elem->giveDomain()->giveEngngModel()->giveFormulation() == TL ) {
FloatArray vF;
this->computeDeformationGradientVector(vF, gp, tStep);
dpmat->giveFirstPKStressVectorGrad(answer, localCumulatedStrain, gp, vF, nlCumulatedStrain, tStep);
} else {
FloatArray vF;
this->computeDeformationGradientVector(vF, gp, tStep);
dpmat->giveCauchyStressVectorGrad(answer, localCumulatedStrain, gp, vF, nlCumulatedStrain, tStep);
}
}
}
void
PhaseFieldElement :: giveInternalForcesVector_d(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
// Computes int_V ( N^t *Nstress_d + B^t * g_c*l*grad(d) ) dV
FloatArray NStress, BStress, NS, a_d, grad_d;
FloatMatrix N, B;
NLStructuralElement *el = this->giveElement();
this->computeDamageUnknowns( a_d, VM_Total, tStep );
for ( auto &gp: el->giveIntegrationRule(0) ) {
double dV = el->computeVolumeAround(gp);
// compute generalized stress measures
this->computeNd_matrixAt( *gp->giveNaturalCoordinates(), N);
computeNStress_d(NStress, gp, tStep, useUpdatedGpRecord);
NS.beTProductOf(N, NStress);
answer.add(dV, NS);
this->computeBd_matrixAt(gp, B);
grad_d.beProductOf(B, a_d);
double l = this->giveInternalLength();
double g_c = this->giveCriticalEnergy();
BStress = grad_d * l * g_c;
answer.plusProduct(B, BStress, dV);
}
}
void
PhaseFieldElement :: computeStiffnessMatrix_ud(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
FloatMatrix B, DB, N_d, DN, S(3,1);
FloatArray stress;
NLStructuralElement *el = this->giveElement();
StructuralCrossSection *cs = dynamic_cast<StructuralCrossSection* > (el->giveCrossSection() );
answer.clear();
for ( auto &gp: el->giveIntegrationRule(0) ) {
StructuralMaterialStatus *matStat = static_cast< StructuralMaterialStatus * >( gp->giveMaterialStatus() );
double dV = el->computeVolumeAround(gp);
// compute int_V ( B^t * D_B * B )dV
this->computeNd_matrixAt(*gp->giveNaturalCoordinates(), N_d);
// stress
FloatArray reducedStrain, a_u;
FloatMatrix B_u;
el->computeBmatrixAt( gp, B_u );
stress = matStat->giveTempStressVector();
stress.times( this->computeGPrim( gp, VM_Total, tStep ) );
S.setColumn(stress,1);
DN.beProductOf(S, N_d);
answer.plusProductUnsym(B_u, DN, dV);
}
}
void
GradDpElement :: giveNonlocalInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
double localCumulatedStrain = 0.;
NLStructuralElement *elem = this->giveNLStructuralElement();
FloatMatrix stiffKappa;
FloatArray Nk;
FloatArray aux, dKappa, stress;
int size = nSecVars * nSecNodes;
//set displacement and nonlocal location array
this->setDisplacementLocationArray();
this->setNonlocalLocationArray();
answer.resize(size);
for ( GaussPoint *gp: *elem->giveIntegrationRule(0) ) {
this->computeNkappaMatrixAt(gp, Nk);
double dV = elem->computeVolumeAround(gp);
this->computeStressVectorAndLocalCumulatedStrain(stress, localCumulatedStrain, gp, tStep);
aux.add(-dV * localCumulatedStrain, Nk);
}
this->computeStiffnessMatrix_kk(stiffKappa, TangentStiffness, tStep);
this->computeNonlocalDegreesOfFreedom(dKappa, tStep);
answer.beProductOf(stiffKappa, dKappa);
answer.add(aux);
}
void
PhaseFieldElement :: computeStiffnessMatrix_dd(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
double Delta_t = tStep->giveTimeIncrement();
double t_star = this->giveRelaxationTime();
double l = this->giveInternalLength();
double g_c = this->giveCriticalEnergy();
FloatMatrix B_d, N_d;
//StructuralCrossSection *cs = dynamic_cast<StructuralCrossSection* > (this->giveCrossSection() );
NLStructuralElement *el = this->giveElement();
answer.clear();
for ( auto &gp: el->giveIntegrationRule(0) ) {
double dV = el->computeVolumeAround(gp);
this->computeNd_matrixAt(*gp->giveNaturalCoordinates(), N_d);
this->computeBd_matrixAt(gp, B_d, 1, 3);
double Gprim = this->computeGPrim(gp, VM_Total, tStep);
double psiBar = this->computeFreeEnergy( gp, tStep );
//double factorN = t_star/Delta_t + g_c/l + psiBar*Gbis;
double factorN = t_star / Delta_t + g_c / l + psiBar*(-2.0);
double factorB = g_c*l;
answer.plusProductSymmUpper(N_d, N_d, factorN*dV);
answer.plusProductSymmUpper(B_d, B_d, factorB*dV);
}
answer.symmetrized();
}
void
PhaseFieldElement :: computeStiffnessMatrix_uu(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
// This is the regular stiffness matrix times G
FloatMatrix B, DB, N, D_B;
NLStructuralElement *el = this->giveElement();
StructuralCrossSection *cs = dynamic_cast<StructuralCrossSection* > (el->giveCrossSection() );
bool matStiffSymmFlag = cs->isCharacteristicMtrxSymmetric(rMode);
answer.clear();
for ( auto gp: el->giveIntegrationRule(0) ) {
double dV = el->computeVolumeAround(gp);
// compute int_V ( B^t * D_B * B )dV
el->computeBmatrixAt(gp, B );
cs->giveCharMaterialStiffnessMatrix(D_B, rMode, gp, tStep);
D_B.times( computeG(gp, VM_Total, tStep) );
DB.beProductOf(D_B, B);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(B, DB, dV);
} else {
answer.plusProductUnsym(B, DB, dV);
}
}
if ( matStiffSymmFlag ) {
answer.symmetrized();
}
}
void
GradDpElement :: computeDeformationGradientVector(FloatArray &answer, GaussPoint *gp, TimeStep *tStep)
{
// Computes the deformation gradient in the Voigt format at the Gauss point gp of
// the receiver at time step tStep.
// Order of components: 11, 22, 33, 23, 13, 12, 32, 31, 21 in the 3D.
// Obtain the current displacement vector of the element and subtract initial displacements (if present)
FloatArray u;
FloatMatrix B;
NLStructuralElement *elem = this->giveNLStructuralElement();
this->computeDisplacementDegreesOfFreedom(u, tStep);
// Displacement gradient H = du/dX
elem->computeBHmatrixAt(gp, B);
answer.beProductOf(B, u);
// Deformation gradient F = H + I
MaterialMode matMode = gp->giveMaterialMode();
if ( matMode == _3dMat || matMode == _PlaneStrain ) {
answer.at(1) += 1.0;
answer.at(2) += 1.0;
answer.at(3) += 1.0;
} else if ( matMode == _PlaneStress ) {
answer.at(1) += 1.0;
answer.at(2) += 1.0;
} else if ( matMode == _1dMat ) {
answer.at(1) += 1.0;
} else {
OOFEM_ERROR( "MaterialMode is not supported yet (%s)", __MaterialModeToString(matMode) );
}
}
void
PhaseFieldElement :: computeNd_matrixAt(const FloatArray &lCoords, FloatMatrix &N)
{
NLStructuralElement *el = this->giveElement();
FloatArray Nvec;
el->giveInterpolation( )->evalN( Nvec, lCoords, FEIElementGeometryWrapper( el ) );
N.resize(1, Nvec.giveSize());
N.beNMatrixOf(Nvec,1);
}
void
GradDpElement :: computeLocalStrainVector(FloatArray &answer, GaussPoint *gp, TimeStep *tStep)
{
FloatArray u;
FloatMatrix b;
NLStructuralElement *elem = this->giveNLStructuralElement();
this->computeDisplacementDegreesOfFreedom(u, tStep);
elem->computeBmatrixAt(gp, b);
answer.beProductOf(b, u);
}
double
PhaseFieldElement :: computeDamageAt(GaussPoint *gp, ValueModeType valueMode, TimeStep *stepN)
{
// d = N_d * a_d
NLStructuralElement *el = this->giveElement();
FloatArray dVec;
computeDamageUnknowns(dVec, valueMode, stepN);
FloatArray Nvec;
el->giveInterpolation()->evalN(Nvec, *gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(el));
return Nvec.dotProduct(dVec);
}
void
PhaseFieldElement :: computeBd_matrixAt(GaussPoint *gp, FloatMatrix &answer, int li, int ui)
{
// Returns the [numSpaceDim x nDofs] gradient matrix {B_d} of the receiver,
// evaluated at gp.
NLStructuralElement *el = this->giveElement();
FloatMatrix dNdx;
el->giveInterpolation( )->evaldNdx( dNdx, *gp->giveNaturalCoordinates( ), FEIElementGeometryWrapper( el ) );
answer.beTranspositionOf( dNdx );
}
void
GradDpElement :: computeStiffnessMatrix_uk(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
NLStructuralElement *elem = this->giveNLStructuralElement();
double dV;
StructuralCrossSection *cs = elem->giveStructuralCrossSection();
int nlGeo = elem->giveGeometryMode();
FloatArray Nk;
FloatMatrix B, SNk, gPSigma;
answer.clear();
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!");
}
dpmat->givePDGradMatrix_uk(gPSigma, rMode, gp, tStep);
this->computeNkappaMatrixAt(gp, Nk);
elem->computeBmatrixAt(gp, B);
if ( nlGeo == 1 ) {
if ( elem->domain->giveEngngModel()->giveFormulation() == AL ) {
elem->computeBmatrixAt(gp, B);
} else {
elem->computeBHmatrixAt(gp, B);
}
}
dV = elem->computeVolumeAround(gp);
SNk.beProductOf(gPSigma, Nk);
answer.plusProductUnsym(B, SNk, -dV);
}
}
void
PhaseFieldElement :: computeBStress_u(FloatArray &answer, GaussPoint *gp, TimeStep *tStep, int useUpdatedGpRecord)
{
// computes G(d)*sig(u)
NLStructuralElement *el = this->giveElement();
FloatArray strain, a_u;
FloatMatrix B_u;
el->computeBmatrixAt(gp, B_u);
this->computeDisplacementUnknowns(a_u, VM_Total, tStep);
strain.beProductOf(B_u, a_u);
el->computeStressVector(answer, strain, gp, tStep);
answer.times( this->computeG(gp, VM_Total, tStep) );
}
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
PhaseFieldElement :: giveInternalForcesVector_u(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
// computes int_V ( B_u^t * BSgima_u ) * dV
FloatArray NStress, BStress, vGenStress, NS;
FloatMatrix N, B;
NLStructuralElement *el = this->giveElement();
answer.clear();
for ( auto &gp: el->giveIntegrationRule(0) ) {
double dV = el->computeVolumeAround(gp);
// compute generalized stress measure
el->computeBmatrixAt(gp, B);
this->computeBStress_u(BStress, gp, tStep, useUpdatedGpRecord);
answer.plusProduct(B, BStress, dV);
}
}
void
PhaseFieldElement :: computeLocationArrayOfDofIDs( const IntArray &dofIdArray, IntArray &answer )
{
// Routine to extract compute the location array an element given an dofid array.
answer.clear();
NLStructuralElement *el = this->giveElement();
int k = 0;
for ( int i = 1; i <= el->giveNumberOfDofManagers(); i++ ) {
DofManager *dMan = el->giveDofManager( i );
for ( int j = 1; j <= dofIdArray.giveSize( ); j++ ) {
if ( dMan->hasDofID( (DofIDItem) dofIdArray.at( j ) ) ) {
Dof *d = dMan->giveDofWithID( dofIdArray.at( j ) );
answer.followedBy( k + d->giveNumber( ) );
}
}
k += dMan->giveNumberOfDofs( );
}
}
void
GradDpElement :: giveLocalInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
NLStructuralElement *elem = this->giveNLStructuralElement();
int nlGeo = elem->giveGeometryMode();
FloatArray BS, vStress;
FloatMatrix B;
for ( GaussPoint *gp: *elem->giveIntegrationRule(0) ) {
if ( nlGeo == 0 || elem->domain->giveEngngModel()->giveFormulation() == AL ) {
elem->computeBmatrixAt(gp, B);
} else if ( nlGeo == 1 ) {
elem->computeBHmatrixAt(gp, B);
}
vStress = static_cast< StructuralMaterialStatus * >( gp->giveMaterialStatus() )->giveTempStressVector();
if ( vStress.giveSize() == 0 ) { /// @todo is this check really necessary?
break;
}
// Compute nodal internal forces at nodes as f = B^T*Stress dV
double dV = elem->computeVolumeAround(gp);
BS.beTProductOf(B, vStress);
answer.add(dV, BS);
}
}
void
PhaseFieldElement :: computeStressVectorAndLocalCumulatedStrain(FloatArray &answer, double localCumulatedStrain, GaussPoint *gp, TimeStep *stepN)
//PhaseFieldElement :: computeStressVector(FloatArray &answer, double localCumulatedStrain, GaussPoint *gp, TimeStep *stepN)
{
NLStructuralElement *elem = this->giveNLStructuralElement();
nlGeo = elem->giveGeometryMode();
StructuralCrossSection *cs = this->giveNLStructuralElement()->giveStructuralCrossSection();
//this->computeDamage(alpha, gp, stepN);
if ( nlGeo == 0 ) {
FloatArray Epsilon;
this->computeLocalStrainVector(Epsilon, gp, stepN);
dpmat->giveRealStressVector(answer, gp, Epsilon, nlCumulatedStrain, stepN);
} else if ( nlGeo == 1 ) {
if ( elem->giveDomain()->giveEngngModel()->giveFormulation() == TL ) {
FloatArray vF;
this->computeDeformationGradientVector(vF, gp, stepN);
dpmat->giveFirstPKStressVector(answer, gp, vF, nlCumulatedStrain, stepN);
}
}
}
void
GradDpElement :: computeLocForceLoadVector(FloatArray &answer, TimeStep *tStep, ValueModeType mode)
// computes the part of load vector, which is imposed by force loads acting
// on element volume (surface).
// When reactions forces are computed, they are computed from element::GiveRealStressVector
// in this vector a real forces are stored (temperature part is subtracted).
// so we need further sobstract part corresponding to non-nodeal loading.
{
FloatMatrix T;
NLStructuralElement *elem = this->giveNLStructuralElement();
elem->computeLocalForceLoadVector(answer, tStep, mode);
// transform result from global cs to nodal cs. if necessary
if ( answer.isNotEmpty() ) {
if ( elem->computeGtoLRotationMatrix(T) ) {
// first back to global cs from element local
answer.rotatedWith(T, 't');
}
} else {
answer.resize(locSize);
answer.zero();
}
}
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
GradDpElement :: computeStiffnessMatrix(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
//set displacement and nonlocal location array
this->setDisplacementLocationArray();
this->setNonlocalLocationArray();
NLStructuralElement *elem = this->giveNLStructuralElement();
StructuralCrossSection *cs = elem->giveStructuralCrossSection();
FloatMatrix B, D, DB;
FloatMatrix DkuB, Dku;
FloatArray Nk;
FloatMatrix SNk, gPSigma;
FloatMatrix lStiff;
FloatMatrix Bk, LBk;
FloatMatrix answer_uu, answer_ku, answer_uk, answer_kk;
int nlGeo = elem->giveGeometryMode();
bool matStiffSymmFlag = elem->giveCrossSection()->isCharacteristicMtrxSymmetric(rMode);
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!");
}
double dV = elem->computeVolumeAround(gp);
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);
}
}
this->computeNkappaMatrixAt(gp, Nk);
this->computeBkappaMatrixAt(gp, Bk);
dpmat->givePDGradMatrix_uu(D, rMode, gp, tStep);
dpmat->givePDGradMatrix_ku(Dku, rMode, gp, tStep);
dpmat->givePDGradMatrix_uk(gPSigma, rMode, gp, tStep);
dpmat->givePDGradMatrix_kk(lStiff, rMode, gp, tStep);
/////////////////////////////////////////////////////////////////// uu:
DB.beProductOf(D, B);
if ( matStiffSymmFlag ) {
answer_uu.plusProductSymmUpper(B, DB, dV);
} else {
answer_uu.plusProductUnsym(B, DB, dV);
}
//////////////////////////////////////////////////////////////////////// ku:
DkuB.beProductOf(Dku, B);
answer_ku.plusProductUnsym(Nk, DkuB, -dV);
if ( dpmat->giveAveragingType() == 2 ) {
double dl1, dl2, dl3;
FloatMatrix LDB;
FloatMatrix GkLDB, MGkLDB;
FloatMatrix M22, M12;
FloatMatrix dL1(1, 3), dL2(1, 3), dLdS;
FloatArray Gk, n1, n2;
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);
n1 = {dLdS.at(1, 1), dLdS.at(2, 1)};
n2 = {dLdS.at(1, 2), dLdS.at(2, 2)};
// first term Bk^T M22 G L1 D B
// M22 = n2 \otimes n2
M22.plusDyadUnsym(n2, n2, 1.);
// dL1
dL1.at(1, 1) = dl1 * n1.at(1) * n1.at(1) + dl2 * n2.at(1) * n2.at(1);
dL1.at(1, 2) = dl1 * n1.at(2) * n1.at(2) + dl2 * n2.at(2) * n2.at(2);
dL1.at(1, 3) = dl1 * n1.at(1) * n1.at(2) + dl2 * n2.at(1) * n2.at(2);
LDB.beProductOf(dL1, DB);
GkLDB.beProductOf(Gk, LDB);
MGkLDB.beProductOf(M22, GkLDB);
answer.plusProductUnsym(Bk, MGkLDB, dV);
// M12 + M21 = n1 \otimes n2 + n2 \otimes n1
M12.plusDyadUnsym(n1, n2, 1.);
M12.plusDyadUnsym(n2, n1, 1.);
//dL2
dL2.at(1, 1) = dl3 * ( n1.at(1) * n2.at(1) + n1.at(1) * n2.at(1) );
dL2.at(1, 2) = dl3 * ( n1.at(2) * n2.at(2) + n1.at(2) * n2.at(2) );
dL2.at(1, 3) = dl3 * ( n1.at(2) * n2.at(1) + n1.at(1) * n2.at(2) );
// Bk * ((M12 * L2 + M22 * L1) * DB)
LDB.beProductOf(dL2, DB);
GkLDB.beProductOf(Gk, LDB);
MGkLDB.beProductOf(M12, GkLDB);
answer.plusProductUnsym(Bk, MGkLDB, dV);
}
//////////////////////////////////////////////////////////////////////// uk:
SNk.beProductOf(gPSigma, Nk);
answer_uk.plusProductUnsym(B, SNk, -dV); // uk
/////////////////////////////////////////////////////////////////////// kk:
answer_kk.plusProductUnsym(Nk, Nk, dV);
if ( dpmat->giveAveragingType() == 0 || dpmat->giveAveragingType() == 1 ) {
double l = lStiff.at(1, 1);
answer_kk.plusProductUnsym(Bk, Bk, l * l * dV);
} else if ( dpmat->giveAveragingType() == 2 ) {
LBk.beProductOf(lStiff, Bk);
answer_kk.plusProductUnsym(Bk, LBk, dV);
}
}
if ( elem->domain->giveEngngModel()->giveFormulation() == AL ) {
FloatMatrix initialStressMatrix;
elem->computeInitialStressMatrix(initialStressMatrix, tStep);
answer_uu.add(initialStressMatrix);
}
if ( matStiffSymmFlag ) {
answer_uu.symmetrized();
}
answer.resize(totalSize, totalSize);
answer.zero();
answer.assemble(answer_uu, locU);
answer.assemble(answer_uk, locU, locK);
answer.assemble(answer_ku, locK, locU);
answer.assemble(answer_kk,locK);
}
void
GradDpElement :: giveInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
NLStructuralElement *elem = this->giveNLStructuralElement();
StructuralCrossSection *cs = elem->giveStructuralCrossSection();
FloatArray answerU, answerK;
double localCumulatedStrain = 0.;
FloatMatrix stiffKappa, B;
FloatArray Nk, aux, dKappa, stress;
FloatMatrix lStiff;
FloatMatrix Bk;
FloatArray gKappa, L_gKappa;
//set displacement and nonlocal location array
this->setDisplacementLocationArray();
this->setNonlocalLocationArray();
this->computeNonlocalDegreesOfFreedom(dKappa, tStep);
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!");
}
double dV = elem->computeVolumeAround(gp);
if ( nlGeo == 0 || elem->domain->giveEngngModel()->giveFormulation() == AL ) {
elem->computeBmatrixAt(gp, B);
} else if ( nlGeo == 1 ) {
elem->computeBHmatrixAt(gp, B);
}
this->computeStressVectorAndLocalCumulatedStrain(stress, localCumulatedStrain, gp, tStep);
answerU.plusProduct(B, stress, dV);
// Gradient part:
this->computeNkappaMatrixAt(gp, Nk);
this->computeBkappaMatrixAt(gp, Bk);
dpmat->givePDGradMatrix_kk(lStiff, TangentStiffness, gp, tStep);
double kappa = Nk.dotProduct(dKappa);
gKappa.beProductOf(Bk, dKappa);
answerK.add(-dV * localCumulatedStrain, Nk);
answerK.add(kappa * dV, Nk);
if ( dpmat->giveAveragingType() == 0 || dpmat->giveAveragingType() == 1 ) {
double l = lStiff.at(1, 1);
answerK.plusProduct(Bk, gKappa, l * l * dV);
} else if ( dpmat->giveAveragingType() == 2 ) {
L_gKappa.beProductOf(lStiff, gKappa);
answerK.plusProduct(Bk, L_gKappa, dV);
}
}
//this->computeStiffnessMatrix_kk(stiffKappa, TangentStiffness, tStep);
//answerK.beProductOf(stiffKappa, dKappa);
answerK.add(aux);
answer.resize(totalSize);
answer.zero();
answer.assemble(answerU, locU);
answer.assemble(answerK, locK);
}
