void Tr21Stokes :: computeLoadVector(FloatArray &answer, BodyLoad *load, CharType type, ValueModeType mode, TimeStep *tStep)
{
if ( type != ExternalForcesVector ) {
answer.clear();
return;
}
FluidDynamicMaterial *mat = static_cast< FluidCrossSection * >( this->giveCrossSection() )->giveFluidMaterial();
FloatArray N, gVector, temparray(12);
load->computeComponentArrayAt(gVector, tStep, VM_Total);
temparray.zero();
if ( gVector.giveSize() ) {
for ( GaussPoint *gp: *integrationRulesArray [ 0 ] ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
double rho = mat->give('d', gp);
double detJ = fabs( this->interpolation_quad.giveTransformationJacobian( lcoords, FEIElementGeometryWrapper(this) ) );
double dA = detJ * gp->giveWeight();
this->interpolation_quad.evalN( N, lcoords, FEIElementGeometryWrapper(this) );
for ( int j = 0; j < 6; j++ ) {
temparray(2 * j) += N(j) * rho * gVector(0) * dA;
temparray(2 * j + 1) += N(j) * rho * gVector(1) * dA;
}
}
}
answer.resize(15);
answer.zero();
answer.assemble(temparray, this->momentum_ordering);
}
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 Tr21Stokes :: computeInternalForcesVector(FloatArray &answer, TimeStep *tStep)
{
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FluidDynamicMaterial *mat = ( FluidDynamicMaterial * ) this->domain->giveMaterial(this->material);
FloatArray a_pressure, a_velocity, devStress, epsp, BTs, Nh, dNv(12);
double r_vol, pressure;
FloatMatrix dN, B(3, 12);
B.zero();
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, a_velocity);
this->computeVectorOf(EID_ConservationEquation, VM_Total, tStep, a_pressure);
FloatArray momentum(12), conservation(3);
momentum.zero();
conservation.zero();
GaussPoint *gp;
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
FloatArray *lcoords = gp->giveCoordinates();
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)));
this->interpolation_quad.evaldNdx(dN, * lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(Nh, * lcoords, FEIElementGeometryWrapper(this));
double dA = detJ * gp->giveWeight();
for ( int j = 0, k = 0; j < 6; j++, k += 2 ) {
dNv(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dNv(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
pressure = Nh.dotProduct(a_pressure);
epsp.beProductOf(B, a_velocity);
mat->computeDeviatoricStressVector(devStress, r_vol, gp, epsp, pressure, tStep);
BTs.beTProductOf(B, devStress);
momentum.add(dA, BTs);
momentum.add(-pressure*dA, dNv);
conservation.add(r_vol*dA, Nh);
}
FloatArray temp(15);
temp.zero();
temp.addSubVector(momentum, 1);
temp.addSubVector(conservation, 13);
answer.resize(15);
answer.zero();
answer.assemble(temp, this->ordering);
}
void Tr21Stokes :: computeInternalForcesVector(FloatArray &answer, TimeStep *tStep)
{
FluidDynamicMaterial *mat = static_cast< FluidCrossSection * >( this->giveCrossSection() )->giveFluidMaterial();
FloatArray a_pressure, a_velocity, devStress, epsp, Nh, dNv(12);
double r_vol, pressure;
FloatMatrix dN, B(3, 12);
B.zero();
this->computeVectorOfVelocities(VM_Total, tStep, a_velocity);
this->computeVectorOfPressures(VM_Total, tStep, a_pressure);
FloatArray momentum, conservation;
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 dA = detJ * gp->giveWeight();
for ( int j = 0, k = 0; j < dN.giveNumberOfRows(); j++, k += 2 ) {
dNv(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dNv(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
pressure = Nh.dotProduct(a_pressure);
epsp.beProductOf(B, a_velocity);
mat->computeDeviatoricStressVector(devStress, r_vol, gp, epsp, pressure, tStep);
momentum.plusProduct(B, devStress, dA);
momentum.add(-pressure * dA, dNv);
conservation.add(r_vol * dA, Nh);
}
answer.resize(15);
answer.zero();
answer.assemble(momentum, this->momentum_ordering);
answer.assemble(conservation, this->conservation_ordering);
}
void
tet21ghostsolid :: computeStiffnessMatrix(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
#ifdef __FM_MODULE
FluidDynamicMaterial *fluidMaterial = static_cast< FluidCrossSection * >( this->giveCrossSection() )->giveFluidMaterial();
#endif
FloatMatrix Kf, G, Kx, D, B, Ed, EdB, dNx;
FloatArray Nlin, dNv;
for (int j = 0; j<iRule->giveNumberOfIntegrationPoints(); j++) {
GaussPoint *gp = iRule->getIntegrationPoint(j);
double detJ = fabs( ( this->interpolation.giveTransformationJacobian( * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) ) ) );
double weight = gp->giveWeight();
this->interpolation.evaldNdx( dNx, * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) );
this->interpolation_lin.evalN( Nlin, * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) );
dNv.resize(30); // dNv = [dN1/dx dN1/dy dN1/dz dN2/dx dN2/dy dN2/dz ... dN10/dz]
for (int k = 0; k<dNx.giveNumberOfRows(); k++) {
dNv.at(k*3+1) = dNx.at(k+1,1);
dNv.at(k*3+2) = dNx.at(k+1,2);
dNv.at(k*3+3) = dNx.at(k+1,3);
}
if (nlGeometry == 0) {
this->computeBmatrixAt(gp, B);
// Fluid part
gp->setMaterialMode(_3dFlow);
#ifdef __FM_MODULE
fluidMaterial->giveDeviatoricStiffnessMatrix(Ed, TangentStiffness, gp, tStep);
#else
OOFEM_ERROR("Fluid module missing\n");
#endif
gp->setMaterialMode(_3dMat);
EdB.beProductOf(Ed, B);
Kf.plusProductSymmUpper(B, EdB, detJ*weight);
// Ghost solid part
EdB.beProductOf(Dghost, B);
Kx.plusProductSymmUpper(B, EdB, detJ*weight);
// Incompressibility part
G.plusDyadUnsym(dNv, Nlin, -detJ*weight);
} else {
OOFEM_ERROR ("No support for large deformations yet!");
}
}
FloatMatrix GT;
GT.beTranspositionOf(G);
//GTdeltat.beTranspositionOf(G);
//GTdeltat.times(deltat);
Kf.symmetrized();
Kx.symmetrized();
// Kf.printYourself();
// G.printYourself();
// GT.printYourself();
// Kx.printYourself();
answer.resize(64, 64);
answer.zero();
#define USEUNCOUPLED 0
#if USEUNCOUPLED == 1
// Totaly uncoupled
answer.assemble(Kf, momentum_ordering, momentum_ordering);
answer.assemble(G, momentum_ordering, conservation_ordering);
answer.assemble(GT, conservation_ordering, momentum_ordering);
answer.assemble(Kx, ghostdisplacement_ordering, ghostdisplacement_ordering);
#else
answer.assemble(Kf, ghostdisplacement_ordering, ghostdisplacement_ordering);
answer.assemble(Kf, ghostdisplacement_ordering, momentum_ordering);
answer.assemble(G, ghostdisplacement_ordering, conservation_ordering);
answer.assemble(GT, conservation_ordering, ghostdisplacement_ordering);
answer.assemble(GT, conservation_ordering, momentum_ordering);
answer.assemble(Kx, momentum_ordering, ghostdisplacement_ordering);
#endif
//answer.printYourself();
}
void
tet21ghostsolid :: giveInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
#ifdef __FM_MODULE
FluidDynamicMaterial *fluidMaterial = static_cast< FluidCrossSection * >( this->giveCrossSection() )->giveFluidMaterial();
#endif
FloatMatrix Kf, G, Kx, B, Ed, dNx;
FloatArray Strain, Stress, Nlin, dNv, a, aVelocity, aPressure, aGhostDisplacement, fluidStress, epsf;
FloatArray momentum, conservation, auxstress;
double pressure, epsvol;
this->computeVectorOf( VM_Total, tStep, a);
if (!tStep->isTheFirstStep()) {
// a.printYourself();
}
aVelocity.beSubArrayOf(a, momentum_ordering);
aPressure.beSubArrayOf(a, conservation_ordering);
aGhostDisplacement.beSubArrayOf(a, ghostdisplacement_ordering);
for (int j = 0; j<iRule->giveNumberOfIntegrationPoints(); j++) {
GaussPoint *gp = iRule->getIntegrationPoint(j);
double detJ = fabs( ( this->interpolation.giveTransformationJacobian( * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) ) ) );
double weight = gp->giveWeight();
this->interpolation.evaldNdx( dNx, * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) );
this->interpolation_lin.evalN( Nlin, * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) );
dNv.resize(30);
for (int k = 0; k<dNx.giveNumberOfColumns(); k++) {
dNv.at(k*3+1) = dNx.at(1,k+1);
dNv.at(k*3+2) = dNx.at(2,k+1);
dNv.at(k*3+3) = dNx.at(3,k+1);
}
if (nlGeometry == 0) {
this->computeBmatrixAt(gp, B);
epsf.beProductOf(B, aVelocity);
pressure = Nlin.dotProduct(aPressure);
// Fluid part
gp->setMaterialMode(_3dFlow);
#ifdef __FM_MODULE
fluidMaterial->computeDeviatoricStressVector(fluidStress, epsvol, gp, epsf, pressure, tStep);
#else
OOFEM_ERROR("Missing FM module");
#endif
gp->setMaterialMode(_3dMat);
momentum.plusProduct(B, fluidStress, detJ*weight);
momentum.add(-pressure * detJ * weight, dNv);
conservation.add(epsvol * detJ * weight, Nlin);
// Ghost solid part
Strain.beProductOf(B, aGhostDisplacement);
Stress.beProductOf(Dghost, Strain);
auxstress.plusProduct(B, Stress, detJ * weight);
} else {
OOFEM_ERROR("No support for large deformations yet!");
}
}
answer.resize(64);
answer.zero();
#if USEUNCOUPLED == 1
// Totaly uncoupled
answer.assemble(momentum, momentum_ordering);
answer.assemble(conservation, conservation_ordering);
answer.assemble(auxstress, ghostdisplacement_ordering);
#else
answer.assemble(momentum, ghostdisplacement_ordering);
answer.assemble(conservation, conservation_ordering);
answer.assemble(auxstress, momentum_ordering);
#endif
// Test linear
/* if (this->giveNumber() == 364) {
FloatMatrix K;
FloatArray ans;
this->computeStiffnessMatrix(K, TangentStiffness, tStep);
ans.beProductOf(K, a);
ans.printYourself();
answer.printYourself();
} */
}
void
tet21ghostsolid :: computeLoadVector(FloatArray &answer, Load *load, CharType type, ValueModeType mode, TimeStep *tStep)
{
answer.resize(64);
answer.zero();
if ( type != ExternalForcesVector ) {
answer.resize(0);
return;
}
#ifdef __FM_MODULE
FluidDynamicMaterial *mat = static_cast< FluidCrossSection * >( this->giveCrossSection() )->giveFluidMaterial();
#endif
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
FloatArray N, gVector, temparray(30), dNv, u, inc, u_prev, vload;
FloatMatrix dNx, G;
load->computeComponentArrayAt(gVector, tStep, VM_Total);
temparray.zero();
vload.resize(4);
vload.zero();
this->giveDisplacementsIncrementData(u_prev, u, inc, tStep);
for ( int k = 0; k < iRule->giveNumberOfIntegrationPoints(); k++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(k);
FloatArray *lcoords = gp->giveNaturalCoordinates();
double detJ = fabs( this->interpolation.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) ) );
double dA = detJ * gp->giveWeight();
// Body load
if ( gVector.giveSize() ) {
#ifdef __FM_MODULE
double rho = mat->give('d', gp);
#else
OOFEM_ERROR("Missing FM module");
double rho = 1.0;
#endif
this->interpolation.evalN( N, * lcoords, FEIElementGeometryWrapper(this) );
for ( int j = 0; j < N.giveSize(); j++ ) {
temparray(3 * j + 0) += N(j) * rho * gVector(0) * dA;
temparray(3 * j + 1) += N(j) * rho * gVector(1) * dA;
temparray(3 * j + 2) += N(j) * rho * gVector(2) * dA;
}
}
// "load" from previous step
this->interpolation.evaldNdx( dNx, * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) );
this->interpolation_lin.evalN( N, * gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) );
dNv.resize(30);
for (int k = 0; k<dNx.giveNumberOfColumns(); k++) {
dNv.at(k*3+1) = dNx.at(1,k+1);
dNv.at(k*3+2) = dNx.at(2,k+1);
dNv.at(k*3+3) = dNx.at(3,k+1);
}
G.plusDyadUnsym(N, dNv, dA);
FloatMatrix GT;
GT.beTranspositionOf(G);
vload.plusProduct(GT, u_prev, -0.0 );
//vload.printYourself();
}
#if USEUNCOUPLED == 1
// Totaly uncoupled
answer.assemble(temparray, this->momentum_ordering);
#else
answer.assemble(temparray, this->ghostdisplacement_ordering);
answer.assemble(vload, this->conservation_ordering);
#endif
// answer.printYourself();
}
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);
}
