void
TrPlaneStrRot3d :: printOutputAt(FILE *file, TimeStep *tStep)
// Performs end-of-step operations.
{
FloatArray v;
fprintf( file, "element %d (%8d) :\n", this->giveLabel(), this->giveNumber() );
for ( int i = 0; i < numberOfIntegrationRules; i++ ) {
for ( int j = 0; j < integrationRulesArray [ i ]->giveNumberOfIntegrationPoints(); j++ ) {
GaussPoint *gp = integrationRulesArray [ i ]->getIntegrationPoint(j);
// gp -> printOutputAt(file,stepN) ;
fprintf( file, " GP %2d.%-2d :", i + 1, gp->giveNumber() );
this->giveIPValue(v, gp, IST_ShellStrainCurvatureTensor, tStep);
fprintf(file, " strains ");
fprintf( file,
" % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e ",
v.at(1), v.at(2), v.at(3), 2. * v.at(4), 2. * v.at(5), 2. * v.at(6),
v.at(7), v.at(8), v.at(9), 2. * v.at(10), 2. * v.at(11), 2. * v.at(12) );
this->giveIPValue(v, gp, IST_ShellForceMomentumTensor, tStep);
fprintf(file, "\n stresses");
fprintf( file,
" % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e % .4e ",
v.at(1), v.at(2), v.at(3), v.at(4), v.at(5), v.at(6),
v.at(7), v.at(8), v.at(9), v.at(10), v.at(11), v.at(12) );
fprintf(file, "\n");
}
}
}
void Tr1Darcy :: computeInternalForcesVector(FloatArray &answer, TimeStep *atTime)
{
FloatArray *lcoords, w, a, gradP, I;
FloatMatrix BT;
GaussPoint *gp;
TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
this->computeVectorOf(EID_ConservationEquation, VM_Total, atTime, a);
answer.resize(3);
answer.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = this->interpolation_lin.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) );
this->interpolation_lin.evaldNdx( BT, * lcoords, FEIElementGeometryWrapper(this) );
gradP.beTProductOf(BT, a);
mat->giveFluxVector(w, gp, gradP, atTime);
I.beProductOf(BT, w);
answer.add(- gp->giveWeight() * detJ, I);
}
}
double ShapeFunction::det_jacobian(const Element *el, const GaussPoint &g) const
{
double result;
if(sfcache[g.order()]->query_jac(el, g, result))
return result;
// don't be tempted to rewrite this in terms of
// det_jacobian(Element*, MasterCoord&) because that one doesn't use
// the precomputed values of the shape function derivatives!
#if DIM==2
result = el->jacobian(0, 0, g) * el->jacobian(1, 1, g) -
el->jacobian(0, 1, g) * el->jacobian(1, 0, g);
#elif DIM==3
// typing out a closed form in code is messy for 3d
double m[DIM][DIM];
int ii, jj;
for(ii=0; ii<DIM; ++ii) {
for(jj=0; jj<DIM; ++jj) {
m[ii][jj] = el->jacobian(ii,jj,g);
}
}
result = vtkMath::Determinant3x3(m);
#endif
sfcache[g.order()]->store_jac(el, g, result);
return result;
}
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
LIBeam3dNL :: giveInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
GaussPoint *gp = this->giveDefaultIntegrationRulePtr()->getIntegrationPoint(0);
FloatArray nm(6), stress, strain;
FloatMatrix x;
double s1, s2;
// update temp triad
this->updateTempTriad(tStep);
if ( useUpdatedGpRecord == 1 ) {
stress = static_cast< StructuralMaterialStatus * >( gp->giveMaterialStatus() )->giveStrainVector();
} else {
this->computeStrainVector(strain, gp, tStep);
this->computeStressVector(stress, strain, gp, tStep);
}
for ( int i = 1; i <= 3; i++ ) {
s1 = s2 = 0.0;
for ( int j = 1; j <= 3; j++ ) {
s1 += tempTc.at(i, j) * stress.at(j);
s2 += tempTc.at(i, j) * stress.at(j + 3);
}
nm.at(i) = s1;
nm.at(i + 3) = s2;
}
this->computeXMtrx(x, tStep);
answer.beProductOf(x, nm);
}
void Tr21Stokes :: computeBodyLoadVectorAt(FloatArray &answer, Load *load, TimeStep *tStep)
{
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
GaussPoint *gp;
FloatArray N, gVector, *lcoords, temparray(15);
double dA, detJ, rho;
load->computeComponentArrayAt(gVector, tStep, VM_Total);
temparray.zero();
if ( gVector.giveSize() ) {
for ( int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
gp = iRule->getIntegrationPoint(k);
lcoords = gp->giveCoordinates();
rho = this->giveMaterial()->giveCharacteristicValue(MRM_Density, gp, tStep);
detJ = fabs( this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)) );
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->ordering );
}
void Tr1Darcy :: computeStiffnessMatrix(FloatMatrix &answer, TimeStep *atTime)
{
/*
* Return Ke = integrate(B^T K B)
*/
FloatMatrix B, BT, K, KB;
FloatArray *lcoords;
GaussPoint *gp;
TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
answer.resize(3, 3);
answer.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = this->interpolation_lin.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) );
this->interpolation_lin.evaldNdx( BT, * lcoords, FEIElementGeometryWrapper(this) );
mat->giveCharacteristicMatrix(K, FullForm, TangentStiffness, gp, atTime);
B.beTranspositionOf(BT);
KB.beProductOf(K, B);
answer.plusProductUnsym(B, KB, detJ * gp->giveWeight() ); // Symmetric part is just a single value, not worth it.
}
}
void
Quad1MindlinShell3D :: giveInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
// We need to overload this for practical reasons (this 3d shell has all 9 dofs, but the shell part only cares for the first 8)
// This elements adds an additional stiffness for the so called drilling dofs, meaning we need to work with all 9 components.
FloatMatrix b, d;
FloatArray n, strain, stress;
FloatArray shellUnknowns(20), drillUnknowns(4), unknowns;
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, unknowns);
// Split this for practical reasons into normal shell dofs and drilling dofs
for ( int i = 0; i < 4; ++i ) {
shellUnknowns(0 + i*5) = unknowns(0 + i*6);
shellUnknowns(1 + i*5) = unknowns(1 + i*6);
shellUnknowns(2 + i*5) = unknowns(2 + i*6);
shellUnknowns(3 + i*5) = unknowns(3 + i*6);
shellUnknowns(4 + i*5) = unknowns(4 + i*6);
drillUnknowns(i) = unknowns(5 + i*6);
}
FloatArray shellForces(20), drillMoment(4);
shellForces.zero();
drillMoment.zero();
StructuralCrossSection *cs = this->giveStructuralCrossSection();
double drillCoeff = cs->give(CS_DrillingStiffness);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
for ( int i = 0; i < iRule->giveNumberOfIntegrationPoints(); i++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(i);
this->computeBmatrixAt(gp, b);
double dV = this->computeVolumeAround(gp);
if ( useUpdatedGpRecord ) {
stress = static_cast< StructuralMaterialStatus * >( this->giveMaterial()->giveStatus(gp) )->giveStressVector();
} else {
strain.beProductOf(b, shellUnknowns);
cs->giveRealStress_Shell(stress, gp, strain, tStep);
}
shellForces.plusProduct(b, stress, dV);
// Drilling stiffness is here for improved numerical properties
if (drillCoeff > 0.) {
this->interp.evalN(n, *gp->giveCoordinates(), FEIVoidCellGeometry());
for ( int j = 0; j < 4; j++) {
n(j) -= 0.25;
}
double dtheta = n.dotProduct(drillUnknowns);
drillMoment.add(drillCoeff * dV * dtheta, n); ///@todo Decide on how to alpha should be defined.
}
}
answer.resize(24);
answer.zero();
answer.assemble(shellForces, this->shellOrdering);
if (drillCoeff > 0.) {
answer.assemble(drillMoment, this->drillOrdering);
}
}
double
Lattice2d :: giveCrackWidth()
{
GaussPoint *gp = this->giveDefaultIntegrationRulePtr()->getIntegrationPoint(0);
LatticeMaterialStatus *status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double crackWidth = 0;
crackWidth = status->giveCrackWidth();
return crackWidth;
}
int
Lattice2d :: giveCrackFlag()
{
GaussPoint *gp = this->giveDefaultIntegrationRulePtr()->getIntegrationPoint(0);
LatticeMaterialStatus *status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
int crackFlag = 0;
crackFlag = status->giveCrackFlag();
return crackFlag;
}
double
Lattice2d :: giveDeltaDissipation()
{
GaussPoint *gp = this->giveDefaultIntegrationRulePtr()->getIntegrationPoint(0);
LatticeMaterialStatus *status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double deltaDissipation = 0;
deltaDissipation = status->giveDeltaDissipation();
return deltaDissipation;
}
double
Lattice2d :: giveNormalStress()
{
GaussPoint *gp = this->giveDefaultIntegrationRulePtr()->getIntegrationPoint(0);
LatticeMaterialStatus *status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double normalStress = 0;
normalStress = status->giveNormalStress();
return normalStress;
}
double
Lattice2d_mt :: givePressure()
{
LatticeTransportMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeTransportMaterialStatus * >( gp->giveMaterialStatus() );
return status->givePressure();
}
void
Quad1MindlinShell3D :: computeBodyLoadVectorAt(FloatArray &answer, Load *forLoad, TimeStep *stepN, ValueModeType mode)
{
// Only gravity load
double dV, density;
GaussPoint *gp;
FloatArray forceX, forceY, forceZ, glob_gravity, gravity, n;
if ( ( forLoad->giveBCGeoType() != BodyLoadBGT ) || ( forLoad->giveBCValType() != ForceLoadBVT ) ) {
_error("computeBodyLoadVectorAt: unknown load type");
}
// note: force is assumed to be in global coordinate system.
forLoad->computeComponentArrayAt(glob_gravity, stepN, mode);
// Transform the load into the local c.s.
gravity.beProductOf(this->lcsMatrix, glob_gravity); ///@todo Check potential transpose here.
if ( gravity.giveSize() ) {
IntegrationRule *ir = integrationRulesArray [ 0 ];
for ( int i = 0; i < ir->giveNumberOfIntegrationPoints(); ++i) {
gp = ir->getIntegrationPoint(i);
this->interp.evalN(n, *gp->giveCoordinates(), FEIVoidCellGeometry());
dV = this->computeVolumeAround(gp) * this->giveCrossSection()->give(CS_Thickness);
density = this->giveMaterial()->give('d', gp);
forceX.add(density * gravity.at(1) * dV, n);
forceY.add(density * gravity.at(2) * dV, n);
forceZ.add(density * gravity.at(3) * dV, n);
}
answer.resize(24);
answer.zero();
answer.at(1) = forceX.at(1);
answer.at(2) = forceY.at(1);
answer.at(3) = forceZ.at(1);
answer.at(7) = forceX.at(2);
answer.at(8) = forceY.at(2);
answer.at(9) = forceZ.at(2);
answer.at(13) = forceX.at(3);
answer.at(14) = forceY.at(3);
answer.at(15) = forceZ.at(3);
answer.at(19) = forceX.at(4);
answer.at(20) = forceY.at(4);
answer.at(21) = forceZ.at(4);
} else {
answer.resize(0);
}
}
void
FiberedCrossSection :: giveGeneralizedStress_Beam3d(FloatArray &answer, GaussPoint *gp, const FloatArray &strain, TimeStep *tStep)
{
double fiberThick, fiberWidth, fiberZCoord, fiberYCoord;
FloatArray fiberStrain, reducedFiberStress;
StructuralElement *element = static_cast< StructuralElement * >( gp->giveElement() );
FiberedCrossSectionInterface *interface;
if ( ( interface = static_cast< FiberedCrossSectionInterface * >( element->giveInterface(FiberedCrossSectionInterfaceType) ) ) == NULL ) {
OOFEM_ERROR("element with no fiber support encountered");
}
answer.resize(6);
answer.zero();
for ( int i = 1; i <= numberOfFibers; i++ ) {
GaussPoint *fiberGp = this->giveSlaveGaussPoint(gp, i - 1);
StructuralMaterial *fiberMat = static_cast< StructuralMaterial * >( domain->giveMaterial( fiberMaterials.at(i) ) );
// the question is whether this function should exist ?
// if yes the element details will be hidden.
// good idea also should be existence of element::GiveBmatrixOfLayer
// and computing strains here - but first idea looks better
// but treating of geometric non-linearities may become more complicated
// another approach - use several functions with assumed kinematic constraints
// resolve current layer z-coordinate
fiberThick = this->fiberThicks.at(i);
fiberWidth = this->fiberWidths.at(i);
fiberYCoord = fiberGp->giveNaturalCoordinate(1);
fiberZCoord = fiberGp->giveNaturalCoordinate(2);
interface->FiberedCrossSectionInterface_computeStrainVectorInFiber(fiberStrain, strain, fiberGp, tStep);
fiberMat->giveRealStressVector_Fiber(reducedFiberStress, fiberGp, fiberStrain, tStep);
// perform integration
// 1) membrane terms N, Qz, Qy
answer.at(1) += reducedFiberStress.at(1) * fiberWidth * fiberThick;
answer.at(2) += reducedFiberStress.at(2) * fiberWidth * fiberThick;
answer.at(3) += reducedFiberStress.at(3) * fiberWidth * fiberThick;
// 2) bending terms mx, my, mxy
answer.at(4) += ( reducedFiberStress.at(2) * fiberWidth * fiberThick * fiberYCoord -
reducedFiberStress.at(3) * fiberWidth * fiberThick * fiberZCoord );
answer.at(5) += reducedFiberStress.at(1) * fiberWidth * fiberThick * fiberZCoord;
answer.at(6) -= reducedFiberStress.at(1) * fiberWidth * fiberThick * fiberYCoord;
}
// now we must update master gp ///@ todo simply chosen the first fiber material as master material /JB
StructuralMaterialStatus *status = static_cast< StructuralMaterialStatus * >
( domain->giveMaterial( fiberMaterials.at(1) )->giveStatus(gp) );
status->letTempStrainVectorBe(strain);
status->letTempStressVectorBe(answer);
}
void Line2SurfaceTension :: computeLoadVector(FloatArray &answer, ValueModeType mode, TimeStep *tStep)
{
///@todo Support axisymm.
//domainType dt = this->giveDomain()->giveDomainType();
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
double t = 1, gamma_s;
///@todo Should i use this? Not used in FM module (but perhaps it should?) / Mikael.
//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();
answer.resize(6);
answer.zero();
for ( int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(k);
//interpolation.evaldNdx(dN, domain, dofManArray, * gp->giveCoordinates(), 0.0);
double xi = gp->giveCoordinate(1);
// Some simplifications can be performed, since the mapping J is a scalar.
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();
// dNds = dNdxi/J
// B.at(1,1) = dNds.at(1); and so on.
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);
answer.add( - gamma_s * t * gp->giveWeight(), A); // Note! Negative sign!
}
}
int
Lattice2d :: hasBeenUpdated()
{
LatticeMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
int updateFlag = 0;
updateFlag = status->hasBeenUpdated();
return updateFlag;
}
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);
}
double
Lattice2d :: giveCrackWidth()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double crackWidth = 0;
crackWidth = status->giveCrackWidth();
return crackWidth;
}
int
Lattice2d :: giveCrackFlag()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
int crackFlag = 0;
crackFlag = status->giveCrackFlag();
return crackFlag;
}
double
Lattice2d :: giveOldNormalStress()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double normalStress = 0;
normalStress = status->giveOldNormalStress();
return normalStress;
}
double
Lattice2d :: giveDeltaDissipation()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double deltaDissipation = 0;
deltaDissipation = status->giveDeltaDissipation();
return deltaDissipation;
}
void
SimpleCrossSection :: createMaterialStatus(GaussPoint &iGP)
{
Material *mat = domain->giveMaterial(materialNumber);
MaterialStatus *matStat = mat->CreateStatus(& iGP);
iGP.setMaterialStatus(matStat);
}
double
Lattice2d_mt :: giveMass()
{
LatticeTransportMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeTransportMaterialStatus * >( gp->giveMaterialStatus() );
double mass = 0;
mass = status->giveMass();
//multiply with volume
mass *= this->length * this->width / 2.;
return mass;
}
FloatMatrix Quadr::ComputeJacobi(GaussPoint & B)
{
double ksi, eta;
ksi = B.GetCoordinate(0);
eta = B.GetCoordinate(1);
Shape.at(0) = 0.25*(1 + ksi)*(1 + eta);
Shape.at(1) = 0.25*(1 - ksi)*(1 + eta);
Shape.at(2) = 0.25*(1 - ksi)*(1 - eta);
Shape.at(3) = 0.25*(1 + ksi)*(1 - eta);
DShape.at(0, 0) = 0.25*(1 + eta);
DShape.at(1, 0) = 0.25*(1 + ksi);
DShape.at(0, 1) = -0.25*(1 + eta);
DShape.at(1, 1) = 0.25*(1 - ksi);
DShape.at(0, 2) = -0.25*(1 - eta);
DShape.at(1, 2) = -0.25*(1 - ksi);
DShape.at(0, 3) = 0.25*(1 - eta);
DShape.at(1, 3) = -0.25*(1 + ksi);
//DShape.Print();
//Coors.Print();
Jacobi = DShape.Mult(Coors);
//Jacobi.Print();
Det = Jacobi.Determinant();
InvJacobi = Jacobi.Inverse();
//InvJacobi.Print();
DShapeX = InvJacobi.Mult(DShape);
//DShapeX.Print();
return Jacobi;
}
void Tr1Darcy :: computeEdgeBCSubVectorAt(FloatArray &answer, Load *load, int iEdge, TimeStep *tStep)
{
/*
* Given the load *load, return it's contribution.
*
*/
answer.resize(3);
answer.zero();
if ( load->giveType() == TransmissionBC ) { // Neumann boundary conditions (traction)
BoundaryLoad *boundaryLoad;
boundaryLoad = ( BoundaryLoad * ) load;
int numberOfEdgeIPs;
numberOfEdgeIPs = ( int ) ceil( ( boundaryLoad->giveApproxOrder() + 1. ) / 2. ) * 2;
GaussIntegrationRule iRule(1, this, 1, 1);
GaussPoint *gp;
FloatArray N, loadValue, reducedAnswer;
reducedAnswer.resize(3);
reducedAnswer.zero();
IntArray mask;
iRule.setUpIntegrationPoints(_Line, numberOfEdgeIPs, _Unknown);
for ( int i = 0; i < iRule.getNumberOfIntegrationPoints(); i++ ) {
gp = iRule.getIntegrationPoint(i);
FloatArray *lcoords = gp->giveCoordinates();
this->interpolation_lin.edgeEvalN(N, *lcoords, FEIElementGeometryWrapper(this));
double dV = this->computeEdgeVolumeAround(gp, iEdge);
if ( boundaryLoad->giveFormulationType() == BoundaryLoad :: BL_EntityFormulation ) { // Edge load in xi-eta system
boundaryLoad->computeValueAt(loadValue, tStep, *lcoords, VM_Total);
} else { // Edge load in x-y system
FloatArray gcoords;
this->interpolation_lin.edgeLocal2global(gcoords, iEdge, *lcoords, FEIElementGeometryWrapper(this));
boundaryLoad->computeValueAt(loadValue, tStep, gcoords, VM_Total);
}
reducedAnswer.add(loadValue.at(1) * dV, N);
}
this->interpolation_lin.computeLocalEdgeMapping(mask, iEdge);
answer.assemble(reducedAnswer, mask);
}
}
void Tr21Stokes :: computeEdgeBCSubVectorAt(FloatArray &answer, Load *load, int iEdge, TimeStep *tStep)
{
answer.resize(15);
answer.zero();
if ( load->giveType() == TransmissionBC ) { // Neumann boundary conditions (traction)
BoundaryLoad *boundaryLoad = ( BoundaryLoad * ) load;
int numberOfEdgeIPs = ( int ) ceil( ( boundaryLoad->giveApproxOrder() + 1. ) / 2. ) * 2;
GaussIntegrationRule iRule(1, this, 1, 1);
GaussPoint *gp;
FloatArray N, t, f(6);
IntArray edge_mapping;
f.zero();
iRule.setUpIntegrationPoints(_Line, numberOfEdgeIPs, _Unknown);
for ( int i = 0; i < iRule.getNumberOfIntegrationPoints(); i++ ) {
gp = iRule.getIntegrationPoint(i);
FloatArray *lcoords = gp->giveCoordinates();
this->interpolation_quad.edgeEvalN(N, * lcoords, FEIElementGeometryWrapper(this));
double detJ = fabs(this->interpolation_quad.edgeGiveTransformationJacobian(iEdge, * lcoords, FEIElementGeometryWrapper(this)));
double dS = gp->giveWeight() * detJ;
if ( boundaryLoad->giveFormulationType() == BoundaryLoad :: BL_EntityFormulation ) { // Edge load in xi-eta system
boundaryLoad->computeValueAt(t, tStep, * lcoords, VM_Total);
} else { // Edge load in x-y system
FloatArray gcoords;
this->interpolation_quad.edgeLocal2global(gcoords, iEdge, * lcoords, FEIElementGeometryWrapper(this));
boundaryLoad->computeValueAt(t, tStep, gcoords, VM_Total);
}
// Reshape the vector
for ( int j = 0; j < 3; j++ ) {
f(2 * j) += N(j) * t(0) * dS;
f(2 * j + 1) += N(j) * t(1) * dS;
}
}
answer.assemble(f, this->edge_ordering [ iEdge - 1 ]);
} else {
OOFEM_ERROR("Tr21Stokes :: computeEdgeBCSubVectorAt - Strange boundary condition type");
}
}
FloatMatrix Quadr::ComputeStiff()
{
FloatArray GaussCoor(2);
GaussPoint B;
FloatMatrix G(2, 2);
FloatMatrix BT(3, 2);
FloatMatrix DT(3, 3);
double W1,W2;
DMatrix = ComputeConstitutiveMatrix();
for (int inode = 0; inode < 4; inode++)
{
for (int jnode = 0; jnode < 4; jnode++)
{
for (int iksi = 0; iksi < 3; iksi++)
{
GaussCoor .at(0) = Gauss3[iksi];
W1 = Weight3[iksi];
for (int ieta = 0; ieta < 3; ieta++)
{
GaussCoor.at(1) = Gauss3[ieta];
W2 = Weight3[ieta];
B.Init(0, GaussCoor);
ComputeJacobi(B);
BMatrix = ComputeBMarix(inode);
BT=BMatrix.Trans();
//BT.Print();
DT = BT.Mult(DMatrix);
//DT.Print();
BMatrix = ComputeBMarix(jnode);
G = DT.Mult(BMatrix);
W2 = W1*W2*Det;
G = G.Mult(W2);
//G.Print();
Stiff.at(2 * inode, 2 * jnode) += G.at(0, 0);
Stiff.at(2 * inode + 1, 2 * jnode) += G.at(1, 0);
Stiff.at(2 * inode, 2 * jnode + 1) += G.at(0, 1);
Stiff.at(2 * inode + 1, 2 * jnode + 1) += G.at(1, 1);
}
}
}
}
//cout << "**********************************************" << endl;
//Stiff.Print();
return Stiff;
}
void FiberedCrossSection :: createMaterialStatus(GaussPoint &iGP)
{
for ( int i = 1; i <= numberOfFibers; i++ ) {
GaussPoint *fiberGp = this->giveSlaveGaussPoint(& iGP, i - 1);
StructuralMaterial *mat = static_cast< StructuralMaterial * >( domain->giveMaterial( fiberMaterials.at(i) ) );
MaterialStatus *matStat = mat->CreateStatus(fiberGp);
iGP.setMaterialStatus(matStat);
}
}
int
PatchIntegrationRule :: SetUpPointsOnTriangle(int nPoints, MaterialMode mode, GaussPoint ***arry)
{
numberOfIntegrationPoints = GaussIntegrationRule :: SetUpPointsOnTriangle(nPoints, mode, arry);
firstLocalStrainIndx = 1;
lastLocalStrainIndx = 3;
// convert patch coordinates into element based, update weights accordingly
for ( int j = 0; j < numberOfIntegrationPoints; j++ ) {
GaussPoint *gp = ( * arry ) [ j ];
patch->convertGPIntoParental(gp); // convert coordinates into parental
Element *elg = ( Element * ) patch->giveParent();
double parentArea = elg->computeArea();
Triangle *tr = ( Triangle * ) patch;
gp->setWeight(8.0 * gp->giveWeight() * tr->getArea() / parentArea); // update integration weight
}
return numberOfIntegrationPoints;
}
