int PetscSparseMtrx :: assemble(const IntArray &rloc, const IntArray &cloc, const FloatMatrix &mat) { #ifdef __PARALLEL_MODE if ( emodel->isParallel() ) { // translate eq numbers IntArray grloc( rloc.giveSize() ), gcloc( cloc.giveSize() ); emodel->givePetscContext(this->di, ut)->giveN2Gmap()->map2New(grloc, rloc, 0); emodel->givePetscContext(this->di, ut)->giveN2Gmap()->map2New(gcloc, cloc, 0); MatSetValues(this->mtrx, grloc.giveSize(), grloc.givePointer(), gcloc.giveSize(), gcloc.givePointer(), mat.givePointer(), ADD_VALUES); } else { #endif int i, rsize = rloc.giveSize(), csize = cloc.giveSize(); IntArray grloc(rsize), gcloc(csize); for ( i = 1; i <= rsize; i++ ) { grloc.at(i) = rloc.at(i) - 1; } for ( i = 1; i <= csize; i++ ) { gcloc.at(i) = cloc.at(i) - 1; } MatSetValues(this->mtrx, rsize, grloc.givePointer(), csize, gcloc.givePointer(), mat.givePointer(), ADD_VALUES); #ifdef __PARALLEL_MODE } #endif // increment version this->version++; this->newValues = true; return 1; }
int RCM2Material :: giveIntVarCompFullIndx(IntArray &answer, InternalStateType type, MaterialMode mmode) { if ( type == IST_CrackedFlag ) { answer.resize(1); answer.at(1) = 1; return 1; } else if ( type == IST_CrackDirs ) { answer.resize(9); for ( int i = 1; i <= 9; i++ ) { answer.at(i) = i; } return 1; } else if ( type == IST_CrackStatuses ) { answer.resize(3); for ( int i = 1; i <= 3; i++ ) { answer.at(i) = i; } return 1; } else { return StructuralMaterial :: giveIntVarCompFullIndx(answer, type, mmode); } }
void FloatArray :: beSubArrayOf(const FloatArray &src, const IntArray &indx) // // returns subVector from receiver // subVector size will be indx max val size // and on i-th position of subVector will be this->at(indx->at(i)) // { int i, ii, n, isize; n = indx.giveSize(); #ifdef DEBUG if ( src.size != n ) { OOFEM_ERROR("FloatArray :: beSubArrayOf - size mismatch"); } #endif for ( isize = 0, i = 1; i <= n; i++ ) { if ( indx.at(i) > isize ) { isize = indx.at(i); } } this->resize(isize); for ( i = 1; i <= n; i++ ) { ii = indx.at(i); if ( ii > 0 ) { this->at(ii) = src.at(i); } } }
void RCM2Material :: updateActiveCrackMap(GaussPoint *gp, const IntArray *activatedCracks) // // // updates mapping matrix of active cracks // { int i, indx = 1; RCM2MaterialStatus *status = ( RCM2MaterialStatus * ) this->giveStatus(gp); IntArray crackMap; status->giveCrackMap(crackMap); //if (crackMap == NULL) _error ("updateActiveCrackMap: NULL pointer encountered"); for ( i = 1; i <= 3; i++ ) { if ( status->isCrackActive(i) ) { crackMap.at(i) = indx++; } else if ( activatedCracks ) { if ( ( activatedCracks->at(i) != 0 ) ) { crackMap.at(i) = indx++; } } else { crackMap.at(i) = 0; } } // store modified map into status status->letCrackMapBe(crackMap); }
int DynCompCol :: assemble(const IntArray &loc, const FloatMatrix &mat) { int i, j, ii, jj, dim; # ifdef DEBUG dim = mat.giveNumberOfRows(); if ( dim != loc.giveSize() ) { OOFEM_ERROR("dimension of 'k' and 'loc' mismatch"); } # endif dim = mat.giveNumberOfRows(); for ( j = 1; j <= dim; j++ ) { jj = loc.at(j); if ( jj ) { for ( i = 1; i <= dim; i++ ) { ii = loc.at(i); if ( ii ) { this->at(ii, jj) += mat.at(i, j); } } } } // increment version this->version++; return 1; }
void RCM2Material :: checkIfClosedCracks(GaussPoint *gp, FloatArray &crackStrainVector, IntArray &crackMap) // // Check if crack closing occurs // if yes updates crackStrainVector and gp-status accordingly // { RCM2MaterialStatus *status = ( RCM2MaterialStatus * ) this->giveStatus(gp); int i, isClosing = 0; for ( i = 1; i <= 3; i++ ) { if ( crackMap.at(i) ) { if ( crackStrainVector.at(i) < 0. ) { // crack closing occur crackStrainVector.at(i) = 0.; crackMap.at(i) = 0; // status->giveTempCrackStatus()->at(i) = pscm_CLOSED; isClosing = 1; } } } status->letCrackMapBe(crackMap); if ( isClosing ) { this->updateActiveCrackMap(gp); } status->giveCrackMap(crackMap); // update crack Map }
void VTKXMLExportModule :: giveElementCell(IntArray &answer, Element *elem, int cell) { Element_Geometry_Type elemGT = elem->giveGeometryType(); int nelemNodes; if ( ( elemGT == EGT_point ) || ( elemGT == EGT_line_1 ) || ( elemGT == EGT_line_2 ) || ( elemGT == EGT_triangle_1 ) || ( elemGT == EGT_triangle_2 ) || ( elemGT == EGT_tetra_1 ) || ( elemGT == EGT_tetra_2 ) || ( elemGT == EGT_quad_1 ) || ( elemGT == EGT_quad_2 ) || ( elemGT == EGT_hexa_1 ) ) { nelemNodes = elem->giveNumberOfNodes(); answer.resize(nelemNodes); for ( int i = 1; i <= nelemNodes; i++ ) { answer.at(i) = elem->giveNode(i)->giveNumber() ; } } else if ( elemGT == EGT_hexa_2 ) { int HexaQuadNodeMapping [] = { 5, 8, 7, 6, 1, 4, 3, 2, 16, 15, 14, 13, 12, 11, 10, 9, 17, 20, 19, 18 }; nelemNodes = elem->giveNumberOfNodes(); answer.resize(nelemNodes); for ( int i = 1; i <= nelemNodes; i++ ) { answer.at(i) = elem->giveNode(HexaQuadNodeMapping [ i - 1 ])->giveNumber() ; } } else { OOFEM_ERROR("VTKXMLExportModule: unsupported element geometry type"); } }
int SymCompCol :: assemble(const IntArray &rloc, const IntArray &cloc, const FloatMatrix &mat) { int i, j, ii, jj, dim1, dim2; // this->checkSizeTowards(rloc, cloc); dim1 = mat.giveNumberOfRows(); dim2 = mat.giveNumberOfColumns(); for ( i = 1; i <= dim1; i++ ) { ii = rloc.at(i); if ( ii ) { for ( j = 1; j <= dim2; j++ ) { jj = cloc.at(j); if ( jj && ( ii >= jj ) ) { this->at(ii, jj) += mat.at(i, j); } } } } // increment version this->version++; return 1; }
void VTKXMLExportModule :: makeFullForm(FloatArray &answer, const FloatArray &reducedForm, InternalStateValueType type, const IntArray &redIndx) { answer.resize(9); answer.zero(); if ( type == ISVT_TENSOR_S3 ) { for (int i = 1; i <= redIndx.giveSize(); i++) { if (redIndx.at(i) > 0) { answer.at(redToFull.at(i)) = reducedForm.at(redIndx.at(i)); } } } else if ( type == ISVT_TENSOR_S3E ) { for (int i = 1; i <= redIndx.giveSize(); i++) { if (redIndx.at(i) > 3) { answer.at(redToFull.at(i)) = reducedForm.at(i)*0.5; } else if (redIndx.at(i) > 0) { answer.at(redToFull.at(i)) = reducedForm.at(i); } } } // Symmetrize answer.at(4) = answer.at(2); answer.at(7) = answer.at(3); answer.at(8) = answer.at(6); }
void StaggeredSolver :: giveTotalLocationArray(IntArray &condensedLocationArray, const UnknownNumberingScheme &s, Domain *d) { IntArray nodalArray, ids, locationArray; locationArray.clear(); for ( auto &dman : d->giveDofManagers() ) { dman->giveCompleteLocationArray(nodalArray, s); locationArray.followedBy(nodalArray); } for ( auto &elem : d->giveElements() ) { for ( int i = 1; i <= elem->giveNumberOfInternalDofManagers(); i++ ) { elem->giveInternalDofManDofIDMask(i, ids); elem->giveInternalDofManager(i)->giveLocationArray(ids, nodalArray, s); locationArray.followedBy(nodalArray); } } IntArray nonZeroMask; nonZeroMask.findNonzeros(locationArray); condensedLocationArray.resize(nonZeroMask.giveSize()); for ( int i = 1; i <= nonZeroMask.giveSize(); i++ ) { condensedLocationArray.at(i) = locationArray.at( nonZeroMask.at(i) ); } }
void SolutionbasedShapeFunction :: giveValueAtPoint(FloatArray &answer, const FloatArray &coords, IntArray &dofIDs, EngngModel &myEngngModel) { answer.resize( dofIDs.giveSize() ); FloatArray closest, lcoords, values; Element *elementAtCoords = myEngngModel.giveDomain(1)->giveSpatialLocalizer()->giveElementClosestToPoint(lcoords, closest, coords, 1); if ( elementAtCoords == NULL ) { OOFEM_WARNING("Cannot find element closest to point"); coords.pY(); } EIPrimaryUnknownMapperInterface *em = dynamic_cast< EIPrimaryUnknownMapperInterface * >( elementAtCoords->giveInterface(EIPrimaryUnknownMapperInterfaceType) ); IntArray eldofids; em->EIPrimaryUnknownMI_givePrimaryUnknownVectorDofID(eldofids); em->EIPrimaryUnknownMI_computePrimaryUnknownVectorAtLocal(VM_Total, thisTimestep, lcoords, values); for ( int i = 1; i <= dofIDs.giveSize(); i++ ) { for ( int j = 1; j <= eldofids.giveSize(); j++ ) { if ( dofIDs.at(i) == eldofids.at(j) ) { answer.at(i) = values.at(j); break; } } } }
void FEI3dTrQuad :: computeLocalEdgeMapping(IntArray &edgeNodes, int iedge) { int aNode = 0, bNode = 0, cNode = 0; edgeNodes.resize(3); if ( iedge == 1 ) { // edge between nodes 1 2 aNode = 1; bNode = 2; cNode = 4; } else if ( iedge == 2 ) { // edge between nodes 2 3 aNode = 2; bNode = 3; cNode = 5; } else if ( iedge == 3 ) { // edge between nodes 2 3 aNode = 3; bNode = 1; cNode = 6; } else { OOFEM_ERROR("Wrong edge number (%d)", iedge); } edgeNodes.at(1) = aNode; edgeNodes.at(2) = bNode; edgeNodes.at(3) = cNode; }
int FluidDynamicMaterial :: giveIntVarCompFullIndx(IntArray &answer, InternalStateType type, MaterialMode mmode) { if ( type == IST_DeviatoricStress ) { if ( mmode == _2dFlow ) { answer.setValues(3, 1, 2, 3); return 1; } else if ( mmode == _2dAxiFlow ) { answer.setValues(4, 1, 2, 3, 6); return 1; } else if ( mmode == _3dFlow ) { answer.resize(6); for ( int i = 1; i <= 6; i++ ) answer.at(i) = i; return 1; } else { OOFEM_ERROR ("FluidDynamicMaterial :: giveIntVarCompFullIndx: material mode not supported"); return 0; } } else if ( type == IST_Viscosity ) { answer.resize(1); answer.at(1) = 1; return 1; } else { return Material :: giveIntVarCompFullIndx(answer, type, mmode); } }
void TrPlanestressRotAllman :: computeEgdeNMatrixAt(FloatMatrix &answer, int iedge, GaussPoint *gp) { FloatArray lxy[6]; const FloatArray *lxyptr[]= {lxy, lxy+1, lxy+2, lxy+3, lxy+4, lxy+5}; FloatArray l, n; IntArray en; FEI2dTrQuad qi (1,2); this->computeLocalCoordinates(lxy); // get ready for tranformation into 3d qi.edgeEvalN( n, iedge, *gp->giveCoordinates(), FEIVertexListGeometryWrapper(6, lxyptr) ); qi.computeLocalEdgeMapping (en, iedge); // get edge mapping this->interp.edgeEvalN( l, iedge, *gp->giveCoordinates(), FEIElementGeometryWrapper(this) ); answer.resize(3,6); answer.at(1, 1) = answer.at(2,2) = n.at(1) + n.at(3)/2.0; answer.at(1, 4) = answer.at(2,5) = n.at(2) + n.at(3)/2.0; answer.at(1, 3) = n.at(3)*(lxy[en.at(2)-1].at(2)-lxy[en.at(1)-1].at(2))/8.0; answer.at(1, 6) = -answer.at(1, 3); answer.at(2, 3) = n.at(3)*(lxy[en.at(2)-1].at(1)-lxy[en.at(1)-1].at(1))/8.0; answer.at(2, 6) = -answer.at(2, 3); answer.at(3, 3) = l.at(1); answer.at(3, 6) = l.at(2); }
void SolutionbasedShapeFunction :: giveValueAtPoint(FloatArray &answer, const FloatArray &coords, IntArray &dofIDs, EngngModel &myEngngModel) { answer.resize( dofIDs.giveSize() ); FloatArray closest, lcoords, values; Element *elementAtCoords = myEngngModel.giveDomain(1)->giveSpatialLocalizer()->giveElementClosestToPoint(lcoords, closest, coords, 1); if ( elementAtCoords == NULL ) { OOFEM_WARNING("Cannot find element closest to point"); coords.pY(); return; } IntArray eldofids; elementAtCoords->giveElementDofIDMask(eldofids); elementAtCoords->computeField(VM_Total, thisTimestep, lcoords, values); for ( int i = 1; i <= dofIDs.giveSize(); i++ ) { for ( int j = 1; j <= eldofids.giveSize(); j++ ) { if ( dofIDs.at(i) == eldofids.at(j) ) { answer.at(i) = values.at(j); break; } } } }
int Line :: computeNumberOfIntersectionPoints(Element *element) { int numIntersec = 0; const double relTol = 1.0e-6; const double LineLength = giveLength(); const double absTol = relTol*std::max(LineLength, XfemTolerances::giveCharacteristicElementLength() ); const int numEdges = element->giveInterpolation()->giveNumberOfEdges(); for ( int edgeIndex = 1; edgeIndex <= numEdges; edgeIndex++ ) { IntArray bNodes; element->giveInterpolation()->boundaryGiveNodes(bNodes, edgeIndex); const int nsLoc = bNodes.at(1); const int neLoc = bNodes.at( bNodes.giveSize() ); const FloatArray &xS = *(element->giveNode(nsLoc)->giveCoordinates() ); const FloatArray &xE = *(element->giveNode(neLoc)->giveCoordinates() ); const double dist = BasicGeometry :: computeLineDistance(xS, xE, mVertices[0], mVertices[1]); if(dist < absTol) { numIntersec++; } } return numIntersec; }
void DofManager :: giveLocationArray(const IntArray &dofIDArry, IntArray &locationArray, const UnknownNumberingScheme &s) const { if ( !hasSlaveDofs ) { int size; // prevents some size problem when connecting different elements with // different number of dofs size = dofIDArry.giveSize(); locationArray.resize(size); for ( int i = 1; i <= size; i++ ) { auto pos = this->findDofWithDofId( ( DofIDItem ) dofIDArry.at(i) ); if ( pos == this->end() ) { OOFEM_ERROR("incompatible dof (%d) requested", dofIDArry.at(i)); } locationArray.at(i) = s.giveDofEquationNumber( *pos ); } } else { IntArray mstrEqNmbrs; locationArray.clear(); for ( int dofid: dofIDArry ) { auto pos = this->findDofWithDofId( ( DofIDItem ) dofid ); if ( pos == this->end() ) { OOFEM_ERROR("incompatible dof (%d) requested", dofid); } (*pos)->giveEquationNumbers(mstrEqNmbrs, s); locationArray.followedBy(mstrEqNmbrs); } } }
void QTrPlaneStrain :: SPRNodalRecoveryMI_giveSPRAssemblyPoints(IntArray &pap) { pap.resize(3); pap.at(1) = this->giveNode(1)->giveNumber(); pap.at(2) = this->giveNode(2)->giveNumber(); pap.at(3) = this->giveNode(3)->giveNumber(); }
void SimpleCrossSection :: giveReducedCharacteristicVector(FloatArray &answer, GaussPoint *gp, const FloatArray &charVector3d) // // returns reduced stressVector or strainVector from full 3d vector reduced // to vector required by gp->giveStressStrainMode() // { MaterialMode mode = gp->giveMaterialMode(); StructuralMaterial *mat = static_cast< StructuralMaterial * >( gp->giveElement()->giveMaterial() ); IntArray indx; int size = charVector3d.giveSize(); int i, j; if ( ( mode == _3dShell ) || ( mode == _3dBeam ) || ( mode == _2dPlate ) || ( mode == _2dBeam ) ) { if ( size != 12 ) { OOFEM_ERROR("SimpleCrossSection :: giveReducedCharacteristicVector - charVector3d size mismatch"); } mat->giveStressStrainMask( indx, ReducedForm, gp->giveMaterialMode() ); answer.resize( indx.giveSize() ); answer.zero(); for ( i = 1; i <= indx.giveSize(); i++ ) { if ( ( j = indx.at(i) ) ) { answer.at(i) = charVector3d.at(j); } } return; } else if ( mode == _3dBeam ) { if ( size != 6 ) { OOFEM_ERROR("SimpleCrossSection :: giveReducedCharacteristicVector - charVector3d size mismatch"); } answer = charVector3d; return; } else if ( mode == _PlaneStressRot ) { if ( size != 7 ) { OOFEM_ERROR("SimpleCrossSection :: giveReducedCharacteristicVector - charVector3d size mismatch"); } mat->giveStressStrainMask( indx, ReducedForm, gp->giveMaterialMode() ); answer.resize( indx.giveSize() ); answer.zero(); for ( i = 1; i <= indx.giveSize(); i++ ) { if ( ( j = indx.at(i) ) ) { answer.at(i) = charVector3d.at(j); } } return; } else { StructuralCrossSection :: giveReducedCharacteristicVector(answer, gp, charVector3d); return; } }
void PetscNatural2LocalOrdering :: map2Old(IntArray &answer, const IntArray &src, int baseOffset) { int i, n = src.giveSize(); answer.resize(n); for ( i = 1; i <= n; i++ ) { answer.at(i) = giveOldEq( src.at(i) ) - baseOffset; } }
void LTRSpace :: SPRNodalRecoveryMI_giveSPRAssemblyPoints(IntArray &pap) { pap.resize(4); pap.at(1) = this->giveNode(1)->giveNumber(); pap.at(2) = this->giveNode(2)->giveNumber(); pap.at(3) = this->giveNode(3)->giveNumber(); pap.at(4) = this->giveNode(4)->giveNumber(); }
void NonLinearDynamic :: timesMtrx(FloatArray &vec, FloatArray &answer, CharType type, Domain *domain, TimeStep *tStep) { int nelem = domain->giveNumberOfElements(); //int neq = this->giveNumberOfDomainEquations(EID_MomentumBalance); int jj, kk, n; FloatMatrix charMtrx; IntArray loc; Element *element; EModelDefaultEquationNumbering en; answer.resize( this->giveNumberOfDomainEquations(domain->giveNumber(), en) ); answer.zero(); for ( int i = 1; i <= nelem; i++ ) { element = domain->giveElement(i); #ifdef __PARALLEL_MODE // Skip remote elements (these are used as mirrors of remote elements on other domains // when nonlocal constitutive models are used. They introduction is necessary to // allow local averaging on domains without fine grain communication between domains). if ( element->giveParallelMode() == Element_remote ) { continue; } #endif element->giveLocationArray(loc, EID_MomentumBalance, en); element->giveCharacteristicMatrix(charMtrx, type, tStep); // // assemble it manually // #ifdef DEBUG if ( ( n = loc.giveSize() ) != charMtrx.giveNumberOfRows() ) { _error("solveYourselfAt : dimension mismatch"); } #endif n = loc.giveSize(); for ( int j = 1; j <= n; j++ ) { jj = loc.at(j); if ( jj ) { for ( int k = 1; k <= n; k++ ) { kk = loc.at(k); if ( kk ) { answer.at(jj) += charMtrx.at(j, k) * vec.at(kk); } } } } } #ifdef __PARALLEL_MODE this->updateSharedDofManagers(answer, MassExchangeTag); #endif }
const IntArray &Set :: giveNodeList() { // Lazy evaluation, we compute the unique set of nodes if needed (and store it). if ( this->totalNodes.giveSize() == 0 ) { IntArray afflictedNodes( this->domain->giveNumberOfDofManagers() ); afflictedNodes.zero(); for ( int ielem = 1; ielem <= this->elements.giveSize(); ++ielem ) { Element *e = this->domain->giveElement( this->elements.at(ielem) ); for ( int inode = 1; inode <= e->giveNumberOfNodes(); ++inode ) { afflictedNodes.at( e->giveNode(inode)->giveNumber() ) = 1; } } /* boundary entities are obsolete, use edges and/or surfaces instead */ IntArray bNodes; for ( int ibnd = 1; ibnd <= this->elementBoundaries.giveSize() / 2; ++ibnd ) { Element *e = this->domain->giveElement( this->elementBoundaries.at(ibnd * 2 - 1) ); int boundary = this->elementBoundaries.at(ibnd * 2); FEInterpolation *fei = e->giveInterpolation(); fei->boundaryGiveNodes(bNodes, boundary); for ( int inode = 1; inode <= bNodes.giveSize(); ++inode ) { afflictedNodes.at( e->giveNode( bNodes.at(inode) )->giveNumber() ) = 1; } } IntArray eNodes; for ( int iedge = 1; iedge <= this->elementEdges.giveSize() / 2; ++iedge ) { Element *e = this->domain->giveElement( this->elementEdges.at(iedge * 2 - 1) ); int edge = this->elementEdges.at(iedge * 2); FEInterpolation *fei = e->giveInterpolation(); fei->boundaryEdgeGiveNodes(eNodes, edge); for ( int inode = 1; inode <= eNodes.giveSize(); ++inode ) { afflictedNodes.at( e->giveNode( eNodes.at(inode) )->giveNumber() ) = 1; } } for ( int isurf = 1; isurf <= this->elementSurfaces.giveSize() / 2; ++isurf ) { Element *e = this->domain->giveElement( this->elementSurfaces.at(isurf * 2 - 1) ); int surf = this->elementSurfaces.at(isurf * 2); FEInterpolation *fei = e->giveInterpolation(); fei->boundarySurfaceGiveNodes(eNodes, surf); for ( int inode = 1; inode <= eNodes.giveSize(); ++inode ) { afflictedNodes.at( e->giveNode( eNodes.at(inode) )->giveNumber() ) = 1; } } for ( int inode = 1; inode <= this->nodes.giveSize(); ++inode ) { afflictedNodes.at( this->nodes.at(inode) ) = 1; } totalNodes.findNonzeros(afflictedNodes); } return this->totalNodes; }
void TrPlanestressRotAllman :: giveEdgeDofMapping(IntArray &answer, int iEdge) const { /* * provides dof mapping of local edge dofs (only nonzero are taken into account) * to global element dofs */ answer.resize(6); if ( iEdge == 1 ) { // edge between nodes 1,2 answer.at(1) = 1; answer.at(2) = 2; answer.at(3) = 3; answer.at(4) = 4; answer.at(5) = 5; answer.at(6) = 6; } else if ( iEdge == 2 ) { // edge between nodes 2 3 answer.at(1) = 4; answer.at(2) = 5; answer.at(3) = 6; answer.at(4) = 7; answer.at(5) = 8; answer.at(6) = 9; } else if ( iEdge == 3 ) { // edge between nodes 3 1 answer.at(1) = 7; answer.at(2) = 8; answer.at(3) = 9; answer.at(4) = 1; answer.at(5) = 2; answer.at(6) = 3; } else { _error("giveEdgeDofMapping: wrong edge number"); } }
int ProblemCommunicator :: quickSortPartition( IntArray &map, int l, int r, int ( ProblemCommunicator :: *cmp ) (int, int) ) { int i = l - 1, j = r; int v = map.at(r); int swap; for ( ; ; ) { while ( ( ( this->*cmp )(map.at(++i), v) ) < 0 ) { ; } while ( ( ( this->*cmp )( v, map.at(--j) ) ) < 0 ) { if ( j == l ) { break; } } if ( i >= j ) { break; } swap = map.at(i); map.at(i) = map.at(j); map.at(j) = swap; } swap = map.at(i); map.at(i) = map.at(r); map.at(r) = swap; return i; }
void PrescribedMean :: computeDomainSize() { if (domainSize > 0.0) return; if (elementEdges) { IntArray setList = ((GeneralBoundaryCondition *)this)->giveDomain()->giveSet(set)->giveBoundaryList(); elements.resize(setList.giveSize() / 2); sides.resize(setList.giveSize() / 2); for (int i=1; i<=setList.giveSize(); i=i+2) { elements.at(i/2+1) = setList.at(i); sides.at(i/2+1) = setList.at(i+1); } } else { IntArray setList = ((GeneralBoundaryCondition *)this)->giveDomain()->giveSet(set)->giveElementList(); elements = setList; } domainSize = 0.0; for ( int i=1; i<=elements.giveSize(); i++ ) { int elementID = elements.at(i); Element *thisElement = this->giveDomain()->giveElement(elementID); FEInterpolation *interpolator = thisElement->giveInterpolation(DofIDItem(dofid)); IntegrationRule *iRule; if (elementEdges) { iRule = interpolator->giveBoundaryIntegrationRule(3, sides.at(i)); } else { iRule = interpolator->giveIntegrationRule(3); } for ( GaussPoint * gp: * iRule ) { FloatArray lcoords = gp->giveNaturalCoordinates(); double detJ; if (elementEdges) { detJ = fabs ( interpolator->boundaryGiveTransformationJacobian(sides.at(i), lcoords, FEIElementGeometryWrapper(thisElement)) ); } else { detJ = fabs ( interpolator->giveTransformationJacobian(lcoords, FEIElementGeometryWrapper(thisElement)) ); } domainSize = domainSize + detJ*gp->giveWeight(); } delete iRule; } printf("%f\n", domainSize); }
void FEI3dHexaQuad :: computeGlobalSurfaceMapping(IntArray &surfNodes, IntArray &elemNodes, int iSurf) { IntArray nodes; surfNodes.resize(8); computeLocalSurfaceMapping(nodes, iSurf); for ( int i = 1; i <= 8; i++ ) { surfNodes.at(i) = elemNodes.at( nodes.at(i) ); } }
void RCM2Material :: giveNormalElasticStiffnessMatrix(FloatMatrix &answer, MatResponseForm form, MatResponseMode rMode, GaussPoint *gp, TimeStep *atTime, const FloatMatrix &dir) // // return Elastic Stiffness matrix for normal Stresses // taking into account the directions of normal stresses // (not supported now) // { StructuralMaterial *lMat = static_cast< StructuralMaterial * >( this->giveLinearElasticMaterial() ); FloatMatrix de, fullAnswer(3, 3); IntArray mask; int i, j, sd; lMat->giveCharacteristicMatrix(de, FullForm, rMode, gp, atTime); // copy first 3x3 submatrix to answer for ( i = 1; i <= 3; i++ ) { for ( j = 1; j <= 3; j++ ) { fullAnswer.at(i, j) = de.at(i, j); } } if ( form == FullForm ) { // 3x3 full form required answer = fullAnswer; } else { // reduced form for only // nonzero normal stresses // // first find spatial dimension of problem sd = 0; for ( i = 1; i <= 3; i++ ) { if ( ( this->giveStressStrainComponentIndOf(FullForm, gp->giveMaterialMode(), i) ) ) { sd++; } } answer.resize(sd, sd); answer.zero(); // copy fullAnswer to reduced one this->giveStressStrainMask( mask, FullForm, gp->giveMaterialMode() ); for ( i = 1; i <= 3; i++ ) { for ( j = 1; j <= 3; j++ ) { if ( mask.at(i) && mask.at(j) ) { answer.at( mask.at(i), mask.at(j) ) = fullAnswer.at(i, j); } } } return; } }
int Skyline :: assemble(const IntArray &loc, const FloatMatrix &mat) { // Assembles the elemental matrix 'mat' to the receiver, using 'loc' as a // location array. The values in ke corresponding to a zero coefficient // in loc are not assembled. // int ielem,i,j,ac,ac1,ac2,ndofe; // Domain* domain = eModel->giveDomain(); int i, j, ac, ac1, ac2, ndofe; /* * int nelem = domain -> giveNumberOfElements (); * for ( ielem = 1; ielem <= nelem ; ielem++ ) { * domain -> giveElement(ielem) -> giveLocationArray (loc); * eModel->giveElementCharacteristicMatrix(mat, ielem, type, tStep ); */ # ifdef DEBUG int dim = mat.giveNumberOfRows(); if ( dim != loc.giveSize() ) { OOFEM_ERROR("Skyline::assemble : dimension of 'mat' and 'loc' mismatch"); } # endif ndofe = mat.giveNumberOfRows(); for ( i = 1; i <= ndofe; i++ ) { ac1 = loc.at(i); if ( ac1 == 0 ) { continue; } for ( j = 1; j <= ndofe; j++ ) { ac2 = loc.at(j); if ( ac2 == 0 ) { continue; } if ( ac1 > ac2 ) { continue; } ac = adr->at(ac2) + ac2 - ac1; mtrx [ ac ] += mat.at(i, j); } } // increment vesion this->version++; return 1; }
void QTRSpace :: giveDofManDofIDMask(int inode, EquationID ut, IntArray &answer) const // returns DofId mask array for inode element node. // DofId mask array determines the dof ordering requsted from node. // DofId mask array contains the DofID constants (defined in cltypes.h) // describing physical meaning of particular DOFs. { answer.resize(3); answer.at(1) = D_u; answer.at(2) = D_v; answer.at(3) = D_w; }