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