IntegrationRule * Brick1_ht :: GetSurfaceIntegrationRule(int approxOrder) { IntegrationRule *iRule = new GaussIntegrationRule(1, this, 1, 1); int npoints = iRule->getRequiredNumberOfIntegrationPoints(_Square, approxOrder); iRule->SetUpPointsOnSquare(npoints, _Unknown); return iRule; }
IntegrationRule * DKTPlate :: GetSurfaceIntegrationRule(int approxOrder) { IntegrationRule *iRule = new GaussIntegrationRule(1, this, 1, 1); int npoints = iRule->getRequiredNumberOfIntegrationPoints(_Triangle, approxOrder); iRule->SetUpPointsOnTriangle(npoints, _Unknown); return iRule; }
IntegrationRule * FEI2dTrQuad :: giveIntegrationRule(int order) { IntegrationRule *iRule = new GaussIntegrationRule(1, NULL); int points = iRule->getRequiredNumberOfIntegrationPoints(_Triangle, order + 2); iRule->SetUpPointsOnTriangle(points, _Unknown); return iRule; }
void TR_SHELL01 :: printOutputAt(FILE *file, TimeStep *tStep) // Performs end-of-step operations. { FloatArray v, aux; GaussPoint *membraneGP; IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr(); fprintf( file, "element %d (%8d) :\n", this->giveLabel(), this->giveNumber() ); for ( GaussPoint *gp: *iRule ) { fprintf( file, " GP %2d.%-2d :", iRule->giveNumber(), gp->giveNumber() ); membraneGP = membrane->giveDefaultIntegrationRulePtr()->getIntegrationPoint(gp->giveNumber() - 1); // Strain - Curvature plate->giveIPValue(v, gp, IST_ShellStrainTensor, tStep); membrane->giveIPValue(aux, membraneGP, IST_ShellStrainTensor, tStep); v.add(aux); fprintf(file, " strains "); // eps_x, eps_y, eps_z, eps_yz, eps_xz, eps_xy (global) fprintf( file, " % .4e % .4e % .4e % .4e % .4e % .4e ", v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) ); plate->giveIPValue(v, gp, IST_ShellCurvatureTensor, tStep); membrane->giveIPValue(aux, membraneGP, IST_ShellCurvatureTensor, tStep); v.add(aux); fprintf(file, "\n curvatures "); // k_x, k_y, k_z, k_yz, k_xz, k_xy (global) fprintf( file, " % .4e % .4e % .4e % .4e % .4e % .4e ", v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) ); // Forces - Moments plate->giveIPValue(v, gp, IST_ShellForceTensor, tStep); membrane->giveIPValue(aux, membraneGP, IST_ShellForceTensor, tStep); v.add(aux); fprintf(file, "\n stresses "); // n_x, n_y, n_z, v_yz, v_xz, v_xy (global) fprintf( file, " % .4e % .4e % .4e % .4e % .4e % .4e ", v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) ); plate->giveIPValue(v, gp, IST_ShellMomentumTensor, tStep); membrane->giveIPValue(aux, membraneGP, IST_ShellMomentumTensor, tStep); v.add(aux); fprintf(file, "\n moments "); // m_x, m_y, m_z, m_yz, m_xz, m_xy (global) fprintf( file, " % .4e % .4e % .4e % .4e % .4e % .4e ", v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) ); fprintf(file, "\n"); } }
void InterfaceElem1d :: drawScalar(oofegGraphicContext &context) { int i, indx, result = 0; GaussPoint *gp; IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ]; TimeStep *tStep = this->giveDomain()->giveEngngModel()->giveCurrentStep(); FloatArray gcoord(3), v1; WCRec p [ 1 ]; IntArray map; GraphicObj *go; double val [ 1 ]; if ( !context.testElementGraphicActivity(this) ) { return; } if ( context.getInternalVarsDefGeoFlag() ) { double defScale = context.getDefScale(); p [ 0 ].x = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(1, tStep, EID_MomentumBalance, defScale) + this->giveNode(2)->giveUpdatedCoordinate(1, tStep, EID_MomentumBalance, defScale) ); p [ 0 ].y = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(2, tStep, EID_MomentumBalance, defScale) + this->giveNode(2)->giveUpdatedCoordinate(2, tStep, EID_MomentumBalance, defScale) ); p [ 0 ].z = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(3, tStep, EID_MomentumBalance, defScale) + this->giveNode(2)->giveUpdatedCoordinate(3, tStep, EID_MomentumBalance, defScale) ); } else { p [ 0 ].x = ( FPNum )( this->giveNode(1)->giveCoordinate(1) ); p [ 0 ].y = ( FPNum )( this->giveNode(1)->giveCoordinate(2) ); p [ 0 ].z = ( FPNum )( this->giveNode(1)->giveCoordinate(3) ); } result += giveIPValue(v1, iRule->getIntegrationPoint(0), context.giveIntVarType(), tStep); for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) { result = 0; gp = iRule->getIntegrationPoint(i); result += giveIPValue(v1, gp, context.giveIntVarType(), tStep); result += this->giveIntVarCompFullIndx( map, context.giveIntVarType() ); if ( result != 2 ) { continue; } if ( ( indx = map.at( context.giveIntVarIndx() ) ) == 0 ) { return; } val [ 0 ] = v1.at(indx); context.updateFringeTableMinMax(val, 1); EASValsSetLayer(OOFEG_VARPLOT_PATTERN_LAYER); EASValsSetMType(FILLED_CIRCLE_MARKER); go = CreateMarkerWD3D(p, val [ 0 ]); EGWithMaskChangeAttributes(LAYER_MASK | FILL_MASK | MTYPE_MASK, go); EMAddGraphicsToModel(ESIModel(), go); //} } }
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 IntegrationPointTransformation::Transform (const IntegrationRule &ir1, IntegrationRule &ir2) { int i, n; n = ir1.GetNPoints(); for (i = 0; i < n; i++) { Transform (ir1.IntPoint(i), ir2.IntPoint(i)); } }
void Tr1Darcy :: NodalAveragingRecoveryMI_computeNodalValue(FloatArray &answer, int node, InternalStateType type, TimeStep *tStep) { GaussPoint *gp; TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material); IntegrationRule *iRule = integrationRulesArray [ 0 ]; gp = iRule->getIntegrationPoint(0); mat->giveIPValue(answer, gp, type, tStep); }
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); } }
IntegrationRule * FEI3dWedgeLin :: giveIntegrationRule(int order) { IntegrationRule *iRule = new GaussIntegrationRule(1, NULL); ///@todo This function below isn't supported for wedges. We must decide how we should do this. //int points = iRule->getRequiredNumberOfIntegrationPoints(_Wedge, order); OOFEM_WARNING("Warning.. ignoring 'order' argument: FIXME"); int pointsZeta = 1; int pointsTriangle = 1; iRule->SetUpPointsOnWedge(pointsTriangle, pointsZeta, _Unknown); return iRule; }
void NonlocalMaterialExtensionInterface :: manipulateWeight(double &weight, GaussPoint *gp, GaussPoint *jGp) { Element *ielem = jGp->giveElement(); IntegrationRule *iRule = ielem->giveDefaultIntegrationRulePtr(); if ( ielem->giveMaterial()->hasProperty(AVERAGING_TYPE, jGp) ) { if ( ielem->giveMaterial()->give(AVERAGING_TYPE, jGp) == 1 ) { weight = 1. / ( iRule->giveNumberOfIntegrationPoints() ); //assign the same weights over the whole element } } }
void CoupledFieldsElement :: computeStiffnessMatrixGen(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep, void (*Nfunc)(GaussPoint*, FloatMatrix), void (*Bfunc)(GaussPoint*, FloatMatrix), void (*NStiffness)(FloatMatrix, MatResponseMode, GaussPoint*, TimeStep*), void (*BStiffness)(FloatMatrix, MatResponseMode, GaussPoint*, TimeStep*), double (*volumeAround)(GaussPoint*) ) { FloatMatrix B, DB, N, DN, D_B, D_N; IntegrationRule *iRule = this->giveIntegrationRule(0); bool matStiffSymmFlag = this->giveCrossSection()->isCharacteristicMtrxSymmetric(rMode); answer.resize(0,0); for ( int j = 0; j < iRule->giveNumberOfIntegrationPoints(); j++ ) { GaussPoint *gp = iRule->getIntegrationPoint(j); double dV = this->computeVolumeAround(gp); // compute int_V ( N^t * D_N * N )dV if ( NStiffness && Nfunc ) { Nfunc(gp, N); NStiffness(D_N, rMode, gp, tStep); DN.beProductOf(D_N, N); if ( matStiffSymmFlag ) { answer.plusProductSymmUpper(N, DN, dV); } else { answer.plusProductUnsym(N, DN, dV); } } // compute int_V ( B^t * D_B * B )dV if ( BStiffness && Bfunc ) { Bfunc(gp, B); BStiffness(D_B, rMode, gp, tStep); DB.beProductOf(D_B, B); if ( matStiffSymmFlag ) { answer.plusProductSymmUpper(B, DB, dV); } else { answer.plusProductUnsym(B, DB, dV); } } } if ( matStiffSymmFlag ) { answer.symmetrized(); } }
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; }
double QTrPlaneStrain :: DirectErrorIndicatorRCI_giveCharacteristicSize() { IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr(); GaussPoint *gp; double volume = 0.0; for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) { gp = iRule->getIntegrationPoint(i); volume += this->computeVolumeAround(gp); } return sqrt( volume * 2.0 / this->giveCrossSection()->give(CS_Thickness) ); }
double Lattice2d :: giveOldNormalStress() { LatticeMaterialStatus *status; IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr(); GaussPoint *gp = iRule->getIntegrationPoint(0); status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() ); double normalStress = 0; normalStress = status->giveOldNormalStress(); return normalStress; }
double Lattice2d_mt :: givePressure() { LatticeTransportMaterialStatus *status; GaussPoint *gp; IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ]; gp = iRule->getIntegrationPoint(0); Material *mat = this->giveMaterial(); status = ( LatticeTransportMaterialStatus * ) mat->giveStatus(gp); return status->givePressure(); }
IntegrationRule * FEI3dWedgeLin :: giveBoundaryIntegrationRule(int order, int boundary) { IntegrationRule *iRule = new GaussIntegrationRule(1, NULL); if ( boundary <= 2 ) { int points = iRule->getRequiredNumberOfIntegrationPoints(_Triangle, order + 0); iRule->SetUpPointsOnTriangle(points, _Unknown); } else { int points = iRule->getRequiredNumberOfIntegrationPoints(_Square, order + 2); iRule->SetUpPointsOnSquare(points, _Unknown); } return iRule; }
double Lattice2d :: giveOldCrackWidth() { LatticeMaterialStatus *status; IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr(); GaussPoint *gp = iRule->getIntegrationPoint(0); status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() ); double crackWidth = 0; crackWidth = status->giveOldCrackWidth(); return crackWidth; }
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 FluxFluxBoundary<D> :: T_CalcElementMatrix (const FiniteElement & base_fel, const ElementTransformation & eltrans, FlatMatrix<SCAL> elmat, LocalHeap & lh) const { const CompoundFiniteElement & cfel // product space = dynamic_cast<const CompoundFiniteElement&> (base_fel); // This FE is already multiplied by normal: const HDivNormalFiniteElement<D-1> & fel_q = // q.n space dynamic_cast<const HDivNormalFiniteElement<D-1>&> (cfel[GetInd1()]); const HDivNormalFiniteElement<D-1> & fel_r = // r.n space dynamic_cast<const HDivNormalFiniteElement<D-1>&> (cfel[GetInd2()]); elmat = SCAL(0.0); IntRange rq = cfel.GetRange(GetInd1()); IntRange rr = cfel.GetRange(GetInd2()); int ndofq = rq.Size(); int ndofr = rr.Size(); FlatMatrix<SCAL> submat(ndofr, ndofq, lh); submat = SCAL(0.0); FlatVector<> qshape(fel_q.GetNDof(), lh); FlatVector<> rshape(fel_r.GetNDof(), lh); const IntegrationRule ir(fel_q.ElementType(), fel_q.Order() + fel_r.Order()); for (int i = 0 ; i < ir.GetNIP(); i++) { MappedIntegrationPoint<D-1,D> mip(ir[i], eltrans); SCAL cc = coeff_c -> T_Evaluate<SCAL>(mip); fel_r.CalcShape (ir[i], rshape); fel_q.CalcShape (ir[i], qshape); // mapped q.n-shape is simply reference q.n-shape / measure qshape *= 1.0/mip.GetMeasure(); rshape *= 1.0/mip.GetMeasure(); // [ndofr x 1] [1 x ndofq] submat += (cc*mip.GetWeight()) * rshape * Trans(qshape); } elmat.Rows(rr).Cols(rq) += submat; if (GetInd1() != GetInd2()) elmat.Rows(rq).Cols(rr) += Conj(Trans(submat)); }
double Lattice2d :: giveNormalStress() { LatticeMaterialStatus *status; GaussPoint *gp; IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ]; gp = iRule->getIntegrationPoint(0); status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() ); double normalStress = 0; normalStress = status->giveNormalStress(); return normalStress; }
void IntElPoint :: drawScalar(oofegGraphicContext &gc, TimeStep *tStep) { int indx, result = 0; IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr(); FloatArray gcoord(3), v1; WCRec p [ 1 ]; GraphicObj *go; double val [ 1 ]; if ( !gc.testElementGraphicActivity(this) ) { return; } if ( gc.getInternalVarsDefGeoFlag() ) { double defScale = gc.getDefScale(); p [ 0 ].x = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(1, tStep, defScale) + this->giveNode(2)->giveUpdatedCoordinate(1, tStep, defScale) ); p [ 0 ].y = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(2, tStep, defScale) + this->giveNode(2)->giveUpdatedCoordinate(2, tStep, defScale) ); p [ 0 ].z = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(3, tStep, defScale) + this->giveNode(2)->giveUpdatedCoordinate(3, tStep, defScale) ); } else { p [ 0 ].x = ( FPNum ) ( this->giveNode(1)->giveCoordinate(1) ); p [ 0 ].y = ( FPNum ) ( this->giveNode(1)->giveCoordinate(2) ); p [ 0 ].z = ( FPNum ) ( this->giveNode(1)->giveCoordinate(3) ); } result += giveIPValue(v1, iRule->getIntegrationPoint(0), gc.giveIntVarType(), tStep); for ( GaussPoint *gp: *iRule ) { result = 0; result += giveIPValue(v1, gp, gc.giveIntVarType(), tStep); if ( result != 1 ) { continue; } indx = gc.giveIntVarIndx(); val [ 0 ] = v1.at(indx); gc.updateFringeTableMinMax(val, 1); EASValsSetLayer(OOFEG_VARPLOT_PATTERN_LAYER); EASValsSetMType(FILLED_CIRCLE_MARKER); go = CreateMarkerWD3D(p, val [ 0 ]); EGWithMaskChangeAttributes(LAYER_MASK | FILL_MASK | MTYPE_MASK, go); EMAddGraphicsToModel(ESIModel(), go); //} } }
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 :: 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; }
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; }
void IntegrationRule::DefineIntegrationRuleLine(IntegrationRule & integrationRule, int ruleOrder) { // we use a ready function, which provides a one-dimensional integration rule Vector x, w; GetIntegrationRule(x, w, ruleOrder); integrationRule.integrationPoints.SetLen(x.Length()); for (int i = 1; i <= x.GetLen(); i++) { integrationRule.integrationPoints(i).x = x(i); integrationRule.integrationPoints(i).y = 0.; integrationRule.integrationPoints(i).z = 0.; integrationRule.integrationPoints(i).weight = w(i); } }
int InverseElementTransformation::FindClosestPhysPoint( const Vector& pt, const IntegrationRule &ir) { MFEM_VERIFY(T != NULL, "invalid ElementTransformation"); MFEM_VERIFY(pt.Size() == T->GetSpaceDim(), "invalid point"); DenseMatrix physPts; T->Transform(ir, physPts); // Initialize distance and index of closest point int minIndex = -1; double minDist = std::numeric_limits<double>::max(); // Check all integration points in ir const int npts = ir.GetNPoints(); for (int i = 0; i < npts; ++i) { double dist = pt.DistanceTo(physPts.GetColumn(i)); if (dist < minDist) { minDist = dist; minIndex = i; } } return minIndex; }
void ScalarFiniteElement<D> :: CalcShape (const IntegrationRule & ir, SliceMatrix<> shape) const { for (int i = 0; i < ir.Size(); i++) CalcShape (ir[i], shape.Col(i)); }
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; }