int
LinQuad3DPlaneStress :: giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep)
{
FloatMatrix globTensor;
CharTensor cht;
answer.resize(6);
if ( type == IST_ShellForceTensor || type == IST_ShellStrainTensor ) {
double c = 1.0;
if ( type == IST_ShellForceTensor ) {
cht = GlobalForceTensor;
} else {
cht = GlobalStrainTensor;
c = 2.0;
}
this->giveCharacteristicTensor(globTensor, cht, gp, tStep);
answer.at(1) = globTensor.at(1, 1); //xx
answer.at(2) = globTensor.at(2, 2); //yy
answer.at(3) = globTensor.at(3, 3); //zz
answer.at(4) = c * globTensor.at(2, 3); //yz
answer.at(5) = c * globTensor.at(1, 3); //xz
answer.at(6) = c * globTensor.at(2, 3); //yz
return 1;
} else if ( type == IST_ShellMomentTensor || type == IST_ShellCurvatureTensor ) {
answer.clear();
return 1;
} else {
answer.clear();
return 0;
}
}
void
FEI3dTrQuad :: surfaceEvalBaseVectorsAt(FloatArray &G1, FloatArray &G2, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
{
// Note: These are not normalized. Returns the two tangent vectors to the surface.
FloatMatrix dNdxi;
this->surfaceEvaldNdxi(dNdxi, lcoords);
G1.clear();
G2.clear();
for ( int i = 0; i < 6; ++i ) {
G1.add( dNdxi(i, 1), * cellgeo.giveVertexCoordinates(i) );
G2.add( dNdxi(i, 2), * cellgeo.giveVertexCoordinates(i) );
}
}
void
RankinePlasticMaterial :: computeStressSpaceHardeningVarsReducedGradient(FloatArray &answer, functType ftype, int isurf, GaussPoint *gp,
const FloatArray &stressVector,
const FloatArray &stressSpaceHardeningVars)
{
answer.clear();
}
void
POIExportModule :: exportIntVarAs(InternalStateType valID, FILE *stream, TimeStep *tStep)
{
int i, region;
IntArray toMap(1);
Domain *d = emodel->giveDomain(1);
FloatArray poiCoords(3);
FloatArray val;
toMap.at(1) = ( int ) valID;
// loop over POIs
for ( auto &poi: POIList ) {
poiCoords.at(1) = poi.x;
poiCoords.at(2) = poi.y;
poiCoords.at(3) = poi.z;
region = poi.region;
this->giveMapper()->__init(d, toMap, poiCoords, * d->giveSet(region), tStep);
if ( !this->giveMapper()->__mapVariable(val, poiCoords, valID, tStep) ) {
OOFEM_WARNING("Failed to map variable");
val.clear();
}
fprintf(stream, "%10d ", poi.id);
for ( i = 1; i <= val.giveSize(); i++ ) {
fprintf( stream, " %15e", val.at(i) );
}
fprintf(stream, "\n");
}
}
void
SimpleCrossSection :: giveTemperatureVector(FloatArray &answer, GaussPoint *gp, TimeStep *tStep)
{
Element *elem = gp->giveElement();
answer.clear();
//sum up all prescribed temperatures over an element
StructuralElement *selem = dynamic_cast< StructuralElement * >(elem);
selem->computeResultingIPTemperatureAt(answer, tStep, gp, VM_Total);
/* add external source, if provided */
FieldManager *fm = this->domain->giveEngngModel()->giveContext()->giveFieldManager();
FM_FieldPtr tf;
if ( ( tf = fm->giveField(FT_Temperature) ) ) {
// temperature field registered
FloatArray gcoords, et2;
int err;
elem->computeGlobalCoordinates( gcoords, gp->giveNaturalCoordinates() );
if ( ( err = tf->evaluateAt(et2, gcoords, VM_Total, tStep) ) ) {
OOFEM_ERROR("tf->evaluateAt failed, element %d, error code %d", elem->giveNumber(), err);
}
if ( et2.isNotEmpty() ) {
if ( answer.isEmpty() ) {
answer = et2;
} else {
answer.at(1) += et2.at(1);
}
}
}
}
void
SUPGElement2 :: computeAdvectionTerm_MB(FloatArray &answer, TimeStep *tStep)
{
FloatMatrix n, b, bn;
FloatArray u, v;
answer.clear();
this->computeVectorOfVelocities(VM_Total, tStep, u);
int rule = 2;
/* consistent part + supg stabilization term */
for ( GaussPoint *gp: *this->integrationRulesArray [ rule ] ) {
this->computeNuMatrix(n, gp);
this->computeUDotGradUMatrix( bn, gp, tStep->givePreviousStep() );
this->computeUDotGradUMatrix(b, gp, tStep);
v.beProductOf(b, u);
double dV = this->computeVolumeAround(gp);
double rho = this->giveMaterial()->give('d', gp);
/* consistent part */
answer.plusProduct(n, v, rho * dV);
/* supg stabilization */
answer.plusProduct(bn, v, t_supg * rho * dV);
}
}
void MixedGradientPressureWeakPeriodic :: integrateTractionDev(FloatArray &answer, Element *el, int boundary, const FloatMatrix &ddev)
{
// Computes the integral: int dt . dx dA
FloatMatrix mMatrix;
FloatArray normal, coords, vM_dev;
FEInterpolation *interp = el->giveInterpolation(); // Geometry interpolation. The displacements or velocities must have the same interpolation scheme (on the boundary at least).
int maxorder = this->order + interp->giveInterpolationOrder() * 3;
std :: unique_ptr< IntegrationRule >ir( interp->giveBoundaryIntegrationRule(maxorder, boundary) );
answer.clear();
for ( GaussPoint *gp: *ir ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
FEIElementGeometryWrapper cellgeo(el);
double detJ = interp->boundaryEvalNormal(normal, boundary, lcoords, cellgeo);
// Compute v_m = d_dev . x
interp->boundaryLocal2Global(coords, boundary, lcoords, cellgeo);
vM_dev.beProductOf(ddev, coords);
this->constructMMatrix(mMatrix, coords, normal);
answer.plusProduct(mMatrix, vM_dev, detJ * gp->giveWeight());
}
}
void
SUPGElement2 :: computeDiffusionTerm_MB(FloatArray &answer, TimeStep *tStep)
{
FloatArray u, eps, stress, bs, dDB_u;
FloatMatrix b, un_gu, dDB;
double Re = static_cast< FluidModel * >( domain->giveEngngModel() )->giveReynoldsNumber();
answer.clear();
this->computeVectorOfVelocities(VM_Total, tStep, u);
int rule = 1;
for ( GaussPoint *gp: *this->integrationRulesArray [ rule ] ) {
double dV = this->computeVolumeAround(gp);
this->computeBMatrix(b, gp);
this->computeDivTauMatrix(dDB, gp, tStep);
this->computeUDotGradUMatrix( un_gu, gp, tStep->givePreviousStep() );
eps.beProductOf(b, u);
static_cast< FluidDynamicMaterial * >( this->giveMaterial() )->computeDeviatoricStressVector(stress, gp, eps, tStep);
dDB_u.beProductOf(dDB, u);
/* consistent part */
answer.plusProduct(b, stress, dV / Re);
/* SUPG term */
answer.plusProduct(un_gu, dDB_u, ( -1.0 ) * t_supg * dV);
}
}
void Tr21Stokes :: NodalAveragingRecoveryMI_computeNodalValue(FloatArray &answer, int node, InternalStateType type, TimeStep *tStep)
{
if ( type == IST_Pressure ) {
answer.resize(1);
if ( node == 1 || node == 2 || node == 3 ) {
answer.at(1) = this->giveNode(node)->giveDofWithID(P_f)->giveUnknown(VM_Total, tStep);
} else {
double a, b;
if ( node == 4 ) {
a = this->giveNode(1)->giveDofWithID(P_f)->giveUnknown(VM_Total, tStep);
b = this->giveNode(2)->giveDofWithID(P_f)->giveUnknown(VM_Total, tStep);
} else if ( node == 5 ) {
a = this->giveNode(2)->giveDofWithID(P_f)->giveUnknown(VM_Total, tStep);
b = this->giveNode(3)->giveDofWithID(P_f)->giveUnknown(VM_Total, tStep);
} else { /*if ( node == 6 )*/
a = this->giveNode(3)->giveDofWithID(P_f)->giveUnknown(VM_Total, tStep);
b = this->giveNode(1)->giveDofWithID(P_f)->giveUnknown(VM_Total, tStep);
}
answer.at(1) = ( a + b ) / 2;
}
} else {
answer.clear();
}
}
void
MisesMatNl :: giveRemoteNonlocalStiffnessContribution(GaussPoint *gp, IntArray &rloc, const UnknownNumberingScheme &s,
FloatArray &rcontrib, TimeStep *tStep)
{
double kappa, tempKappa;
MisesMatNlStatus *status = static_cast< MisesMatNlStatus * >( this->giveStatus(gp) );
StructuralElement *elem = static_cast< StructuralElement * >( gp->giveElement() );
FloatMatrix b;
LinearElasticMaterial *lmat = this->giveLinearElasticMaterial();
double E = lmat->give('E', gp);
elem->giveLocationArray(rloc, s);
elem->computeBmatrixAt(gp, b);
kappa = status->giveCumulativePlasticStrain();
tempKappa = status->giveTempCumulativePlasticStrain();
rcontrib.clear();
if ( ( tempKappa - kappa ) > 0 ) {
const FloatArray &stress = status->giveTempEffectiveStress();
if ( gp->giveMaterialMode() == _1dMat ) {
double coeff = sgn( stress.at(1) ) * E / ( E + H );
rcontrib.plusProduct(b, stress, coeff);
return;
}
}
rcontrib.resize(b.giveNumberOfColumns());
rcontrib.zero();
}
void
StructuralInterfaceElementPhF :: giveInternalForcesVector_u(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
FloatMatrix N;
FloatArray u, traction, jump;
IntArray dofIdArray;
this->giveDofManDofIDMask_u(dofIdArray);
this->computeVectorOf(dofIdArray, VM_Total, tStep, u);
// subtract initial displacements, if defined
if ( initialDisplacements.giveSize() ) {
u.subtract(initialDisplacements);
}
// zero answer will resize accordingly when adding first contribution
answer.clear();
for ( auto &ip: *this->giveDefaultIntegrationRulePtr() ) {
this->computeNmatrixAt(ip, N);
jump.beProductOf(N, u);
this->computeTraction(traction, ip, jump, tStep);
//traction.resize(2);
// compute internal cohesive forces as f = N^T*traction dA
double dA = this->computeAreaAround(ip);
answer.plusProduct(N, traction, dA);
}
}
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 Tr21Stokes :: computeExternalForcesVector(FloatArray &answer, TimeStep *tStep)
{
FloatArray vec;
answer.clear();
int nLoads = this->boundaryLoadArray.giveSize() / 2;
for ( int i = 1; i <= nLoads; i++ ) { // For each Neumann boundary condition
int load_number = this->boundaryLoadArray.at(2 * i - 1);
int load_id = this->boundaryLoadArray.at(2 * i);
Load *load = this->domain->giveLoad(load_number);
bcGeomType ltype = load->giveBCGeoType();
if ( ltype == EdgeLoadBGT ) {
this->computeBoundarySurfaceLoadVector(vec, static_cast< BoundaryLoad * >(load), load_id, ExternalForcesVector, VM_Total, tStep);
answer.add(vec);
}
}
BodyLoad *bload;
nLoads = this->giveBodyLoadArray()->giveSize();
for ( int i = 1; i <= nLoads; i++ ) {
Load *load = domain->giveLoad( bodyLoadArray.at(i) );
if ((bload = dynamic_cast<BodyLoad*>(load))) {
bcGeomType ltype = load->giveBCGeoType();
if ( ltype == BodyLoadBGT && load->giveBCValType() == ForceLoadBVT ) {
this->computeLoadVector(vec, bload, ExternalForcesVector, VM_Total, tStep);
answer.add(vec);
}
}
}
}
void
SUPGElement2 :: computeBCRhsTerm_MB(FloatArray &answer, TimeStep *tStep)
{
int nLoads;
answer.clear();
int rule = 0;
IntegrationRule *iRule = this->integrationRulesArray [ rule ];
FloatArray un, gVector, s, helpLoadVector;
FloatMatrix b, nu;
// add body load (gravity) termms
nLoads = this->giveBodyLoadArray()->giveSize();
for ( int i = 1; i <= nLoads; i++ ) {
Load *load = domain->giveLoad( bodyLoadArray.at(i) );
bcGeomType ltype = load->giveBCGeoType();
if ( ( ltype == BodyLoadBGT ) && ( load->giveBCValType() == ForceLoadBVT ) ) {
load->computeComponentArrayAt(gVector, tStep, VM_Total);
if ( gVector.giveSize() ) {
for ( GaussPoint *gp: *iRule ) {
this->computeUDotGradUMatrix( b, gp, tStep->givePreviousStep() );
this->computeNuMatrix(nu, gp);
double dV = this->computeVolumeAround(gp);
double rho = this->giveMaterial()->give('d', gp);
answer.plusProduct(b, gVector, t_supg * rho * dV);
answer.plusProduct(nu, gVector, rho * dV);
}
}
}
}
// integrate tractions
// if no traction bc applied but side marked as with traction load
// then zero traction is assumed !!!
// loop over boundary load array
nLoads = this->giveBoundaryLoadArray()->giveSize() / 2;
for ( int i = 1; i <= nLoads; i++ ) {
int n = boundaryLoadArray.at(1 + ( i - 1 ) * 2);
int id = boundaryLoadArray.at(i * 2);
Load *load = domain->giveLoad(n);
bcGeomType ltype = load->giveBCGeoType();
if ( ltype == EdgeLoadBGT ) {
this->computeEdgeLoadVector_MB(helpLoadVector, load, id, tStep);
if ( helpLoadVector.giveSize() ) {
answer.add(helpLoadVector);
}
} else if ( ltype == SurfaceLoadBGT ) {
this->computeSurfaceLoadVector_MB(helpLoadVector, load, id, tStep);
if ( helpLoadVector.giveSize() ) {
answer.add(helpLoadVector);
}
} else {
OOFEM_ERROR("unsupported load type class");
}
}
}
void
Beam2d :: computeBoundaryEdgeLoadVector(FloatArray &answer, BoundaryLoad *load, int edge, CharType type, ValueModeType mode, TimeStep *tStep, bool global)
{
answer.clear();
if ( edge != 1 ) {
OOFEM_ERROR("Beam2D only has 1 edge (the midline) that supports loads. Attempted to apply load to edge %d", edge);
}
if ( type != ExternalForcesVector ) {
return;
}
double l = this->computeLength();
FloatArray coords, t;
FloatMatrix N, T;
answer.clear();
for ( auto &gp : *this->giveDefaultIntegrationRulePtr() ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
this->computeNmatrixAt(lcoords, N);
if ( load ) {
this->computeGlobalCoordinates(coords, lcoords);
load->computeValues(t, tStep, coords, { D_u, D_w, R_v }, mode);
} else {
load->computeValues(t, tStep, lcoords, { D_u, D_w, R_v }, mode);
}
if ( load->giveCoordSystMode() == Load :: CST_Global ) {
if ( this->computeLoadGToLRotationMtrx(T) ) {
t.rotatedWith(T, 'n');
}
}
double dl = gp->giveWeight() * 0.5 * l;
answer.plusProduct(N, t, dl);
}
if (global) {
// Loads from sets expects global c.s.
this->computeGtoLRotationMatrix(T);
answer.rotatedWith(T, 't');
}
}
void
FEI3dTrQuad :: local2global(FloatArray &answer, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
{
FloatArray n;
this->evalN(n, lcoords, cellgeo);
answer.clear();
for ( int i = 1; i <= 6; ++i ) {
answer.add( n.at(i), * cellgeo.giveVertexCoordinates(i) );
}
}
void DofManager :: computeLoadVector(FloatArray &answer, Load *load, CharType type, TimeStep *tStep, ValueModeType mode)
{
if ( load->giveBCGeoType() != NodalLoadBGT ) {
OOFEM_ERROR("incompatible load type applied");
}
if ( type != ExternalForcesVector ) {
answer.clear();
return;
}
load->computeComponentArrayAt(answer, tStep, mode);
}
void
CCTPlate3d :: computeBodyLoadVectorAt(FloatArray &answer, Load *forLoad, TimeStep *tStep, ValueModeType mode)
// Computes numerically the load vector of the receiver due to the body loads, at tStep.
// load is assumed to be in global cs.
// load vector is then transformed to coordinate system in each node.
// (should be global coordinate system, but there may be defined
// different coordinate system in each node)
{
double dens, dV, load;
FloatArray force;
FloatMatrix T;
if ( ( forLoad->giveBCGeoType() != BodyLoadBGT ) || ( forLoad->giveBCValType() != ForceLoadBVT ) ) {
OOFEM_ERROR("unknown load type");
}
GaussIntegrationRule irule(1, this, 1, 5);
irule.SetUpPointsOnTriangle(1, _2dPlate);
// note: force is assumed to be in global coordinate system.
forLoad->computeComponentArrayAt(force, tStep, mode);
if ( force.giveSize() ) {
GaussPoint *gp = irule.getIntegrationPoint(0);
dens = this->giveStructuralCrossSection()->give('d', gp); // constant density assumed
dV = this->computeVolumeAround(gp) * this->giveCrossSection()->give(CS_Thickness, gp); // constant thickness assumed
answer.resize(18);
answer.zero();
load = force.at(1) * dens * dV / 3.0;
answer.at(1) = load;
answer.at(7) = load;
answer.at(13) = load;
load = force.at(2) * dens * dV / 3.0;
answer.at(2) = load;
answer.at(8) = load;
answer.at(14) = load;
load = force.at(3) * dens * dV / 3.0;
answer.at(3) = load;
answer.at(9) = load;
answer.at(15) = load;
// transform result from global cs to local element cs.
if ( this->computeGtoLRotationMatrix(T) ) {
answer.rotatedWith(T, 'n');
}
} else {
answer.clear(); // nil resultant
}
}
void
SUPGElement2 :: computeBCRhsTerm_MC(FloatArray &answer, TimeStep *tStep)
{
int nLoads;
FloatArray s, gVector, helpLoadVector;
FloatMatrix g;
int rule = 1;
answer.clear();
nLoads = this->giveBodyLoadArray()->giveSize();
for ( int i = 1; i <= nLoads; i++ ) {
Load *load = domain->giveLoad( bodyLoadArray.at(i) );
bcGeomType ltype = load->giveBCGeoType();
if ( ( ltype == BodyLoadBGT ) && ( load->giveBCValType() == ForceLoadBVT ) ) {
load->computeComponentArrayAt(gVector, tStep, VM_Total);
if ( gVector.giveSize() ) {
for ( GaussPoint *gp: *this->integrationRulesArray [ rule ] ) {
this->computeGradPMatrix(g, gp);
double dV = this->computeVolumeAround(gp);
answer.plusProduct(g, gVector, t_pspg * dV);
}
}
}
}
// integrate tractions
// if no traction bc applied but side marked as with traction load
// then zero traction is assumed !!!
// loop over boundary load array
nLoads = this->giveBoundaryLoadArray()->giveSize() / 2;
for ( int i = 1; i <= nLoads; i++ ) {
int n = boundaryLoadArray.at(1 + ( i - 1 ) * 2);
int id = boundaryLoadArray.at(i * 2);
Load *load = domain->giveLoad(n);
bcGeomType ltype = load->giveBCGeoType();
if ( ltype == EdgeLoadBGT ) {
this->computeEdgeLoadVector_MC(helpLoadVector, load, id, tStep);
if ( helpLoadVector.giveSize() ) {
answer.add(helpLoadVector);
}
} else if ( ltype == SurfaceLoadBGT ) {
this->computeSurfaceLoadVector_MC(helpLoadVector, load, id, tStep);
if ( helpLoadVector.giveSize() ) {
answer.add(helpLoadVector);
}
} else {
OOFEM_ERROR("unsupported load type class");
}
}
}
int
CCTPlate3d :: giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *tStep)
{
FloatMatrix globTensor;
CharTensor cht;
answer.resize(9);
if ( ( type == IST_ShellForceTensor ) || ( type == IST_ShellStrainTensor ) ) {
if ( type == IST_ShellForceTensor ) {
cht = GlobalForceTensor;
} else {
cht = GlobalStrainTensor;
}
this->giveCharacteristicTensor(globTensor, cht, gp, tStep);
answer.at(1) = globTensor.at(1, 1); //sxForce
answer.at(2) = globTensor.at(1, 2); //qxyForce
answer.at(3) = globTensor.at(1, 3); //qxzForce
answer.at(4) = globTensor.at(1, 2); //qxyForce
answer.at(5) = globTensor.at(2, 2); //syForce
answer.at(6) = globTensor.at(2, 3); //syzForce
answer.at(7) = globTensor.at(1, 3); //qxzForce
answer.at(8) = globTensor.at(2, 3); //syzForce
answer.at(9) = 0.0;
return 1;
} else if ( ( type == IST_ShellMomentumTensor ) || ( type == IST_ShellCurvatureTensor ) ) {
if ( type == IST_ShellMomentumTensor ) {
cht = GlobalMomentumTensor;
} else {
cht = GlobalCurvatureTensor;
}
this->giveCharacteristicTensor(globTensor, cht, gp, tStep);
answer.at(1) = globTensor.at(1, 1); //mxForce
answer.at(2) = globTensor.at(1, 2); //mxyForce
answer.at(3) = 0.0;
answer.at(4) = globTensor.at(1, 2); //mxyForce
answer.at(5) = globTensor.at(2, 2); //myForce
answer.at(6) = 0.0;
answer.at(7) = 0.0;
answer.at(8) = 0.0;
answer.at(9) = globTensor.at(3, 3); //mzForce
return 1;
} else {
answer.clear();
return 0;
}
}
void
FEI3dTrQuad :: surfaceLocal2global(FloatArray &answer, int isurf,
const FloatArray &lcoords, const FEICellGeometry &cellgeo)
{
//Note: This gives the coordinate in the reference system
FloatArray N;
this->surfaceEvalN(N, isurf, lcoords, cellgeo);
answer.clear();
for ( int i = 0; i < N.giveSize(); ++i ) {
answer.add( N(i), * cellgeo.giveVertexCoordinates(i) );
}
}
//
// The element interface required by NodalAveragingRecoveryModel
//
void
DKTPlate :: NodalAveragingRecoveryMI_computeNodalValue(FloatArray &answer, int node,
InternalStateType type, TimeStep *tStep)
{
GaussPoint *gp;
if ( ( type == IST_ShellForceTensor ) || ( type == IST_ShellMomentumTensor ) ||
( type == IST_ShellStrainTensor ) || ( type == IST_ShellCurvatureTensor ) ) {
gp = integrationRulesArray [ 0 ]->getIntegrationPoint(0);
this->giveIPValue(answer, gp, type, tStep);
} else {
answer.clear();
}
}
void
Quad1MindlinShell3D :: computeBodyLoadVectorAt(FloatArray &answer, Load *forLoad, TimeStep *tStep, ValueModeType mode)
{
// Only gravity load
double dV, density;
FloatArray forceX, forceY, forceZ, glob_gravity, gravity, n;
if ( ( forLoad->giveBCGeoType() != BodyLoadBGT ) || ( forLoad->giveBCValType() != ForceLoadBVT ) ) {
OOFEM_ERROR("unknown load type");
}
// note: force is assumed to be in global coordinate system.
forLoad->computeComponentArrayAt(glob_gravity, tStep, mode);
// Transform the load into the local c.s.
gravity.beProductOf(this->lcsMatrix, glob_gravity); ///@todo Check potential transpose here.
if ( gravity.giveSize() ) {
for ( GaussPoint *gp: *integrationRulesArray [ 0 ] ) {
this->interp.evalN( n, * gp->giveNaturalCoordinates(), FEIVoidCellGeometry() );
dV = this->computeVolumeAround(gp) * this->giveCrossSection()->give(CS_Thickness, gp);
density = this->giveStructuralCrossSection()->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.clear();
}
}
void
FEI3dWedgeLin :: edgeLocal2global(FloatArray &answer, int iedge, const FloatArray &lcoords, const FEICellGeometry &cellgeo)
{
IntArray nodes;
FloatArray n;
this->computeLocalEdgeMapping(nodes, iedge);
this->edgeEvalN(n, iedge, lcoords, cellgeo);
answer.clear();
for ( int i = 1; i <= n.giveSize(); ++i ) {
answer.add( n.at(i), * cellgeo.giveVertexCoordinates( nodes.at(i) ) );
}
}
void
FEI3dTrQuad :: edgeLocal2global(FloatArray &answer, int iedge,
const FloatArray &lcoords, const FEICellGeometry &cellgeo)
{
IntArray edgeNodes;
FloatArray N;
this->computeLocalEdgeMapping(edgeNodes, iedge);
this->edgeEvalN(N, iedge, lcoords, cellgeo);
answer.clear();
for ( int i = 0; i < N.giveSize(); ++i ) {
answer.add( N(i), * cellgeo.giveVertexCoordinates( edgeNodes(i) ) );
}
}
void
Axisymm3d :: NodalAveragingRecoveryMI_computeNodalValue(FloatArray &answer, int node,
InternalStateType type, TimeStep *tStep)
{
GaussPoint *gp;
if ( numberOfGaussPoints != 1 ) {
answer.clear(); // for more gp's need to be refined
return;
}
gp = integrationRulesArray [ 0 ]->getIntegrationPoint(0);
this->giveIPValue(answer, gp, type, tStep);
}
void
J2MPlasticMaterial :: giveStressBackVector(FloatArray &answer,
const FloatArray &stressSpaceHardeningVars)
{
/* returns part of hardening vector corresponding to kinematic hardening */
if ( this->kinematicHardeningFlag ) {
answer.resize(6);
for ( int i = 1; i <= 6; i++ ) {
answer.at(i) = stressSpaceHardeningVars.at(i);
}
return;
}
answer.clear();
}
void Tet21Stokes :: computeBoundaryLoadVector(FloatArray &answer, BoundaryLoad *load, int iSurf, CharType type, ValueModeType mode, TimeStep *tStep)
{
if ( type != ExternalForcesVector ) {
answer.clear();
return;
}
answer.resize(34);
answer.zero();
if ( load->giveType() == TransmissionBC ) { // Neumann boundary conditions (traction)
int numberOfSurfaceIPs = ( int ) ceil( ( load->giveApproxOrder() + 1. ) / 2. ) * 2; ///@todo Check this.
GaussIntegrationRule iRule(1, this, 1, 1);
FloatArray N, t, f(18);
f.zero();
iRule.SetUpPointsOnTriangle(numberOfSurfaceIPs, _Unknown);
for ( GaussPoint *gp: iRule ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
this->interpolation_quad.surfaceEvalN( N, iSurf, lcoords, FEIElementGeometryWrapper(this) );
double dA = gp->giveWeight() * this->interpolation_quad.surfaceGiveTransformationJacobian( iSurf, lcoords, FEIElementGeometryWrapper(this) );
if ( load->giveFormulationType() == Load :: FT_Entity ) { // load in xi-eta system
load->computeValueAt(t, tStep, lcoords, VM_Total);
} else { // Edge load in x-y system
FloatArray gcoords;
this->interpolation_quad.surfaceLocal2global( gcoords, iSurf, lcoords, FEIElementGeometryWrapper(this) );
load->computeValueAt(t, tStep, gcoords, VM_Total);
}
// Reshape the vector
for ( int j = 0; j < N.giveSize(); j++ ) {
f(3 * j + 0) += N(j) * t(0) * dA;
f(3 * j + 1) += N(j) * t(1) * dA;
f(3 * j + 2) += N(j) * t(2) * dA;
}
}
answer.assemble(f, this->surf_ordering [ iSurf - 1 ]);
} else {
OOFEM_ERROR("Strange boundary condition type");
}
}
void Tr21Stokes :: computeBoundarySurfaceLoadVector(FloatArray &answer, BoundaryLoad *load, int boundary, CharType type, ValueModeType mode, TimeStep *tStep, bool global)
{
if ( type != ExternalForcesVector ) {
answer.clear();
return;
}
if ( load->giveType() == TransmissionBC ) { // Neumann boundary conditions (traction)
int numberOfEdgeIPs = ( int ) ceil( ( load->giveApproxOrder() + 1. ) / 2. ) * 2;
GaussIntegrationRule iRule(1, this, 1, 1);
FloatArray N, t, f(6);
f.zero();
iRule.SetUpPointsOnLine(numberOfEdgeIPs, _Unknown);
for ( GaussPoint *gp: iRule ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
this->interpolation_quad.edgeEvalN( N, boundary, lcoords, FEIElementGeometryWrapper(this) );
double detJ = fabs( this->interpolation_quad.boundaryGiveTransformationJacobian( boundary, lcoords, FEIElementGeometryWrapper(this) ) );
double dS = gp->giveWeight() * detJ;
if ( load->giveFormulationType() == Load :: FT_Entity ) { // Edge load in xi-eta system
load->computeValueAt(t, tStep, lcoords, VM_Total);
} else { // Edge load in x-y system
FloatArray gcoords;
this->interpolation_quad.boundaryLocal2Global( gcoords, boundary, lcoords, FEIElementGeometryWrapper(this) );
load->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.resize(15);
answer.zero();
answer.assemble(f, this->edge_ordering [ boundary - 1 ]);
} else {
OOFEM_ERROR("Strange boundary condition type");
}
}
void
StokesFlowVelocityHomogenization :: computeSeepage(FloatArray &v, TimeStep *tStep)
{
FloatMatrix N;
FloatArray v_hatTemp, unknowns;
v.clear();
for ( auto &elem : this->giveDomain(1)->giveElements() ) {
this->integrateNMatrix(N, *elem, tStep);
elem->computeVectorOf({V_u, V_v, V_w}, VM_Total, tStep, unknowns);
v_hatTemp.beProductOf(N, unknowns);
v.add(v_hatTemp);
}
v.times( 1. / this->giveAreaOfRVE() );
}
