void Tet21Stokes :: computeStiffnessMatrix(FloatMatrix &answer, MatResponseMode mode, TimeStep *tStep)
{
FluidDynamicMaterial *mat = static_cast< FluidCrossSection * >( this->giveCrossSection() )->giveFluidMaterial();
FloatMatrix B(6, 30), EdB, K, G, Dp, DvT, C, Ed, dN;
FloatArray dN_V(30), Nlin, Ep, Cd, tmpA, tmpB;
double Cp;
B.zero();
for ( GaussPoint *gp: *this->integrationRulesArray [ 0 ] ) {
// Compute Gauss point and determinant at current element
const FloatArray &lcoords = gp->giveNaturalCoordinates();
double detJ = fabs( this->interpolation_quad.evaldNdx( dN, lcoords, FEIElementGeometryWrapper(this) ) );
double dV = detJ * gp->giveWeight();
this->interpolation_lin.evalN( Nlin, lcoords, FEIElementGeometryWrapper(this) );
for ( int j = 0, k = 0; j < dN.giveNumberOfRows(); j++, k += 3 ) {
dN_V(k + 0) = B(0, k + 0) = B(3, k + 1) = B(4, k + 2) = dN(j, 0);
dN_V(k + 1) = B(1, k + 1) = B(3, k + 0) = B(5, k + 2) = dN(j, 1);
dN_V(k + 2) = B(2, k + 2) = B(4, k + 0) = B(5, k + 1) = dN(j, 2);
}
// Computing the internal forces should have been done first.
// dsigma_dev/deps_dev dsigma_dev/dp deps_vol/deps_dev deps_vol/dp
mat->giveStiffnessMatrices(Ed, Ep, Cd, Cp, mode, gp, tStep);
EdB.beProductOf(Ed, B);
K.plusProductSymmUpper(B, EdB, dV);
G.plusDyadUnsym(dN_V, Nlin, -dV);
C.plusDyadSymmUpper(Nlin, Cp * dV);
tmpA.beTProductOf(B, Ep);
Dp.plusDyadUnsym(tmpA, Nlin, dV);
tmpB.beTProductOf(B, Cd);
DvT.plusDyadUnsym(Nlin, tmpB, dV);
}
K.symmetrized();
C.symmetrized();
FloatMatrix GTDvT, GDp;
GTDvT.beTranspositionOf(G);
GTDvT.add(DvT);
GDp = G;
GDp.add(Dp);
answer.resize(34, 34);
answer.zero();
answer.assemble(K, this->momentum_ordering);
answer.assemble(GDp, this->momentum_ordering, this->conservation_ordering);
answer.assemble(GTDvT, this->conservation_ordering, this->momentum_ordering);
answer.assemble(C, this->conservation_ordering);
// K.printYourself();
// GDp.printYourself();
// GTDvT.printYourself();
// C.printYourself();
}
void Tet21Stokes :: computeInternalForcesVector(FloatArray &answer, TimeStep *tStep)
{
FluidDynamicMaterial *mat = static_cast< FluidCrossSection * >( this->giveCrossSection() )->giveFluidMaterial();
FloatArray a_pressure, a_velocity, devStress, epsp, Nh, dN_V(30);
FloatMatrix dN, B(6, 30);
double r_vol, pressure;
this->computeVectorOfVelocities(VM_Total, tStep, a_velocity);
this->computeVectorOfPressures(VM_Total, tStep, a_pressure);
FloatArray momentum, conservation;
B.zero();
for ( GaussPoint *gp: *integrationRulesArray [ 0 ] ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
double detJ = fabs( this->interpolation_quad.evaldNdx( dN, lcoords, FEIElementGeometryWrapper(this) ) );
this->interpolation_lin.evalN( Nh, lcoords, FEIElementGeometryWrapper(this) );
double dV = detJ * gp->giveWeight();
for ( int j = 0, k = 0; j < dN.giveNumberOfRows(); j++, k += 3 ) {
dN_V(k + 0) = B(0, k + 0) = B(3, k + 1) = B(4, k + 2) = dN(j, 0);
dN_V(k + 1) = B(1, k + 1) = B(3, k + 0) = B(5, k + 2) = dN(j, 1);
dN_V(k + 2) = B(2, k + 2) = B(4, k + 0) = B(5, k + 1) = dN(j, 2);
}
epsp.beProductOf(B, a_velocity);
pressure = Nh.dotProduct(a_pressure);
mat->computeDeviatoricStressVector(devStress, r_vol, gp, epsp, pressure, tStep);
momentum.plusProduct(B, devStress, dV);
momentum.add(-pressure * dV, dN_V);
conservation.add(r_vol * dV, Nh);
}
answer.resize(34);
answer.zero();
answer.assemble(momentum, this->momentum_ordering);
answer.assemble(conservation, this->conservation_ordering);
}
void Tr21Stokes :: computeStiffnessMatrix(FloatMatrix &answer, TimeStep *tStep)
{
// Note: Working with the components; [K, G+Dp; G^T+Dv^T, C] . [v,p]
FluidDynamicMaterial *mat = ( FluidDynamicMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
GaussPoint *gp;
FloatMatrix B(3, 12), EdB, K(12,12), G, Dp, DvT, C, Ed, dN;
FloatArray *lcoords, dN_V(12), Nlin, Ep, Cd, tmpA, tmpB;
double Cp;
K.zero();
G.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
// Compute Gauss point and determinant at current element
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)));
double dA = detJ * gp->giveWeight();
this->interpolation_quad.evaldNdx(dN, * lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(Nlin, * lcoords, FEIElementGeometryWrapper(this));
for ( int j = 0, k = 0; j < 6; j++, k += 2 ) {
dN_V(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dN_V(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
// Computing the internal forces should have been done first.
mat->giveDeviatoricStiffnessMatrix(Ed, TangentStiffness, gp, tStep); // dsigma_dev/deps_dev
mat->giveDeviatoricPressureStiffness(Ep, TangentStiffness, gp, tStep); // dsigma_dev/dp
mat->giveVolumetricDeviatoricStiffness(Cd, TangentStiffness, gp, tStep); // deps_vol/deps_dev
mat->giveVolumetricPressureStiffness(Cp, TangentStiffness, gp, tStep); // deps_vol/dp
EdB.beProductOf(Ed,B);
K.plusProductSymmUpper(B, EdB, dA);
G.plusDyadUnsym(dN_V, Nlin, -dA);
C.plusDyadSymmUpper(Nlin, Nlin, Cp*dA);
tmpA.beTProductOf(B, Ep);
Dp.plusDyadUnsym(tmpA, Nlin, dA);
tmpB.beTProductOf(B, Cd);
DvT.plusDyadUnsym(Nlin, tmpB, dA);
}
K.symmetrized();
C.symmetrized();
FloatMatrix GTDvT, GDp;
GTDvT.beTranspositionOf(G);
GTDvT.add(DvT);
GDp = G;
GDp.add(Dp);
FloatMatrix temp(15, 15);
temp.setSubMatrix(K, 1, 1);
temp.setSubMatrix(GTDvT, 13, 1);
temp.setSubMatrix(GDp, 1, 13);
temp.setSubMatrix(C, 13, 13);
answer.resize(15, 15);
answer.zero();
answer.assemble(temp, this->ordering);
}
