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() ); }