void Node2NodeContact :: giveLocationArray(IntArray &answer, const UnknownNumberingScheme &s) { // should return location array for the master and the slave node // TODO this whole thing should be rewritten answer.resize(6); answer.zero(); //TODO should use a proper unknownnumberingscheme IntArray dofIdArray = {D_u, D_v, D_w}; // master node for ( int i = 1; i <= dofIdArray.giveSize(); i++ ) { if ( this->masterNode->hasDofID( (DofIDItem)dofIdArray.at(i) ) ) { // add corresponding number Dof *dof= this->masterNode->giveDofWithID( (DofIDItem)dofIdArray.at(i) ); answer.at(i) = s.giveDofEquationNumber( dof ); } } // slave node for ( int i = 1; i <= dofIdArray.giveSize(); i++ ) { if ( this->slaveNode->hasDofID( (DofIDItem)dofIdArray.at(i) ) ) { // add corresponding number Dof *dof= this->slaveNode->giveDofWithID( (DofIDItem)dofIdArray.at(i) ); answer.at(3 + i) = s.giveDofEquationNumber( dof ); } } }
void Tria1PlateSubSoil :: giveSurfaceDofMapping(IntArray &answer, int iSurf) const { answer.resize(3); answer.zero(); if ( iSurf == 1 ) { for (int i = 1; i<=3; i++) { answer.at(i) = i; } } else { OOFEM_ERROR("wrong surface number"); } }
void CCTPlate3d :: giveSurfaceDofMapping(IntArray &answer, int iSurf) const { answer.resize(18); answer.zero(); if ( iSurf == 1 ) { answer.at(3) = 1; // node 1 answer.at(4) = 2; answer.at(5) = 3; answer.at(9) = 4; // node 2 answer.at(10) = 5; answer.at(11) = 6; answer.at(15) = 7; // node 3 answer.at(16) = 8; answer.at(17) = 9; } else { OOFEM_ERROR("wrong surface number"); } }
int NodalAveragingRecoveryModel :: recoverValues(InternalStateType type, TimeStep *tStep) { int ireg, nregions = this->giveNumberOfVirtualRegions(); int ielem, nelem = domain->giveNumberOfElements(); int inode, nnodes = domain->giveNumberOfDofManagers(); int elemNodes; int regionValSize; int elementNode, node; int regionDofMans; int i, neq, eq; Element *element; NodalAveragingRecoveryModelInterface *interface; IntArray skipRegionMap(nregions), regionRecSize(nregions); IntArray regionNodalNumbers(nnodes); IntArray regionDofMansConnectivity; FloatArray lhs, val; if ( ( this->valType == type ) && ( this->stateCounter == tStep->giveSolutionStateCounter() ) ) { return 1; } #ifdef __PARALLEL_MODE bool parallel = this->domain->giveEngngModel()->isParallel(); if (parallel) this->initCommMaps(); #endif // clear nodal table this->clear(); // init region table indicating regions to skip this->initRegionMap(skipRegionMap, regionRecSize, type); #ifdef __PARALLEL_MODE if (parallel) { // synchronize skipRegionMap over all cpus IntArray temp_skipRegionMap(skipRegionMap); MPI_Allreduce(temp_skipRegionMap.givePointer(), skipRegionMap.givePointer(), nregions, MPI_INT, MPI_LOR, MPI_COMM_WORLD); } #endif // loop over regions for ( ireg = 1; ireg <= nregions; ireg++ ) { // skip regions if ( skipRegionMap.at(ireg) ) { continue; } // loop over elements and determine local region node numbering and determine and check nodal values size if ( this->initRegionNodeNumbering(regionNodalNumbers, regionDofMans, ireg) == 0 ) { break; } regionValSize = regionRecSize.at(ireg); neq = regionDofMans * regionValSize; lhs.resize(neq); lhs.zero(); regionDofMansConnectivity.resize(regionDofMans); regionDofMansConnectivity.zero(); // assemble element contributions for ( ielem = 1; ielem <= nelem; ielem++ ) { element = domain->giveElement(ielem); #ifdef __PARALLEL_MODE if ( element->giveParallelMode() != Element_local ) { continue; } #endif if ( this->giveElementVirtualRegionNumber(ielem) != ireg ) { continue; } // If an element doesn't implement the interface, it is ignored. if ( ( interface = ( NodalAveragingRecoveryModelInterface * ) element->giveInterface(NodalAveragingRecoveryModelInterfaceType) ) == NULL ) { //abort(); continue; } elemNodes = element->giveNumberOfDofManagers(); // ask element contributions for ( elementNode = 1; elementNode <= elemNodes; elementNode++ ) { node = element->giveDofManager(elementNode)->giveNumber(); interface->NodalAveragingRecoveryMI_computeNodalValue(val, elementNode, type, tStep); // if the element cannot evaluate this variable, it is ignored if ( val.giveSize() == 0 ) { continue; } eq = ( regionNodalNumbers.at(node) - 1 ) * regionValSize; for ( i = 1; i <= regionValSize; i++ ) { lhs.at(eq + i) += val.at(i); } regionDofMansConnectivity.at( regionNodalNumbers.at(node) )++; } } // end assemble element contributions #ifdef __PARALLEL_MODE if (parallel) this->exchangeDofManValues(ireg, lhs, regionDofMansConnectivity, regionNodalNumbers, regionValSize); #endif // solve for recovered values of active region for ( inode = 1; inode <= nnodes; inode++ ) { if ( regionNodalNumbers.at(inode) ) { eq = ( regionNodalNumbers.at(inode) - 1 ) * regionValSize; for ( i = 1; i <= regionValSize; i++ ) { if ( regionDofMansConnectivity.at( regionNodalNumbers.at(inode) ) > 0 ) { lhs.at(eq + i) /= regionDofMansConnectivity.at( regionNodalNumbers.at(inode) ); } else { OOFEM_WARNING2("NodalAveragingRecoveryModel::recoverValues: values of dofmanager %d undetermined", inode); lhs.at(eq + i) = 0.0; } } } } // update recovered values this->updateRegionRecoveredValues(ireg, regionNodalNumbers, regionValSize, lhs); } // end loop over regions this->valType = type; this->stateCounter = tStep->giveSolutionStateCounter(); return 1; }
void NodalAveragingRecoveryModel :: initRegionMap(IntArray ®ionMap, IntArray ®ionValSize, InternalStateType type) { int nregions = this->giveNumberOfVirtualRegions(); int ielem, nelem = domain->giveNumberOfElements(); int i, elemVR, regionsSkipped = 0; Element *element; NodalAveragingRecoveryModelInterface *interface; regionMap.resize(nregions); regionMap.zero(); regionValSize.resize(nregions); regionValSize.zero(); // loop over elements and check if implement interface for ( ielem = 1; ielem <= nelem; ielem++ ) { element = domain->giveElement(ielem); if ( !element-> isActivated(domain->giveEngngModel()->giveCurrentStep()) ) { //skip inactivated elements continue; } #ifdef __PARALLEL_MODE if ( element->giveParallelMode() != Element_local ) { continue; } #endif if ( ( interface = ( NodalAveragingRecoveryModelInterface * ) element-> giveInterface(NodalAveragingRecoveryModelInterfaceType) ) == NULL ) { // If an element doesn't implement the interface, it is ignored. //regionsSkipped = 1; //regionMap.at( element->giveRegionNumber() ) = 1; continue; } else { if ((elemVR = this->giveElementVirtualRegionNumber(ielem))) { // test if elemVR is nonzero if ( regionValSize.at(elemVR) ) { if ( regionValSize.at(elemVR) != interface->NodalAveragingRecoveryMI_giveDofManRecordSize(type) ) { // This indicates a size mis-match between different elements, no choice but to skip the region. regionMap.at(elemVR) = 1; regionsSkipped = 1; } } else { regionValSize.at(elemVR) = interface-> NodalAveragingRecoveryMI_giveDofManRecordSize(type); } } } } if ( regionsSkipped ) { OOFEM_LOG_RELEVANT("NodalAveragingRecoveryModel :: initRegionMap: skipping regions for InternalStateType %s\n", __InternalStateTypeToString(type) ); for ( i = 1; i <= nregions; i++ ) { if ( regionMap.at(i) ) { OOFEM_LOG_RELEVANT("%d ", i); } } OOFEM_LOG_RELEVANT("\n"); } }
int SPRNodalRecoveryModel :: recoverValues(Set elementSet, InternalStateType type, TimeStep *tStep) { int nnodes = domain->giveNumberOfDofManagers(); IntArray regionNodalNumbers(nnodes); IntArray patchElems, dofManToDetermine, pap; FloatMatrix a; FloatArray dofManValues; IntArray dofManPatchCount; if ( ( this->valType == type ) && ( this->stateCounter == tStep->giveSolutionStateCounter() ) ) { return 1; } #ifdef __PARALLEL_MODE this->initCommMaps(); #endif // clear nodal table this->clear(); int regionValSize; int regionDofMans; regionValSize = 0; // loop over elements and determine local region node numbering and determine and check nodal values size if ( this->initRegionNodeNumbering(regionNodalNumbers, regionDofMans, elementSet) == 0 ) { return 0; } SPRPatchType regType = this->determinePatchType(elementSet); dofManPatchCount.resize(regionDofMans); dofManPatchCount.zero(); //pap = patch assembly points this->determinePatchAssemblyPoints(pap, regType, elementSet); int npap = pap.giveSize(); for ( int ipap = 1; ipap <= npap; ipap++ ) { int papNumber = pap.at(ipap); int oldSize = regionValSize; this->initPatch(patchElems, dofManToDetermine, pap, papNumber, elementSet); this->computePatch(a, patchElems, regionValSize, regType, type, tStep); if ( oldSize == 0 ) { dofManValues.resize(regionDofMans * regionValSize); dofManValues.zero(); } this->determineValuesFromPatch(dofManValues, dofManPatchCount, regionNodalNumbers, dofManToDetermine, a, regType); } #ifdef __PARALLEL_MODE this->exchangeDofManValues(dofManValues, dofManPatchCount, regionNodalNumbers, regionValSize); #endif // average recovered values of active region bool abortFlag = false; for ( int i = 1; i <= nnodes; i++ ) { if ( regionNodalNumbers.at(i) && ( ( domain->giveDofManager(i)->giveParallelMode() == DofManager_local ) || ( domain->giveDofManager(i)->giveParallelMode() == DofManager_shared ) ) ) { int eq = ( regionNodalNumbers.at(i) - 1 ) * regionValSize; if ( dofManPatchCount.at( regionNodalNumbers.at(i) ) ) { for ( int j = 1; j <= regionValSize; j++ ) { dofManValues.at(eq + j) /= dofManPatchCount.at( regionNodalNumbers.at(i) ); } } else { OOFEM_WARNING("values of %s in dofmanager %d undetermined", __InternalStateTypeToString(type), i); for ( int j = 1; j <= regionValSize; j++ ) { dofManValues.at(eq + j) = 0.0; } //abortFlag = true; } } if ( abortFlag ) { abort(); } // update recovered values this->updateRegionRecoveredValues(regionNodalNumbers, regionValSize, dofManValues); } this->valType = type; this->stateCounter = tStep->giveSolutionStateCounter(); return 1; }
int NodalAveragingRecoveryModel :: recoverValues(Set elementSet, InternalStateType type, TimeStep *tStep) { int nnodes = domain->giveNumberOfDofManagers(); IntArray regionNodalNumbers(nnodes); IntArray regionDofMansConnectivity; FloatArray lhs, val; if ( ( this->valType == type ) && ( this->stateCounter == tStep->giveSolutionStateCounter() ) ) { return 1; } #ifdef __PARALLEL_MODE bool parallel = this->domain->giveEngngModel()->isParallel(); if ( parallel ) { this->initCommMaps(); } #endif // clear nodal table this->clear(); int regionValSize = 0; int regionDofMans; // loop over elements and determine local region node numbering and determine and check nodal values size if ( this->initRegionNodeNumbering(regionNodalNumbers, regionDofMans, elementSet) == 0 ) { return 0; } regionDofMansConnectivity.resize(regionDofMans); regionDofMansConnectivity.zero(); IntArray elements = elementSet.giveElementList(); // assemble element contributions for ( int i = 1; i <= elements.giveSize(); i++ ) { int ielem = elements.at(i); NodalAveragingRecoveryModelInterface *interface; Element *element = domain->giveElement(ielem); if ( element->giveParallelMode() != Element_local ) { continue; } // If an element doesn't implement the interface, it is ignored. if ( ( interface = static_cast< NodalAveragingRecoveryModelInterface * > ( element->giveInterface(NodalAveragingRecoveryModelInterfaceType) ) ) == NULL ) { //abort(); continue; } int elemNodes = element->giveNumberOfDofManagers(); // ask element contributions for ( int elementNode = 1; elementNode <= elemNodes; elementNode++ ) { int node = element->giveDofManager(elementNode)->giveNumber(); interface->NodalAveragingRecoveryMI_computeNodalValue(val, elementNode, type, tStep); // if the element cannot evaluate this variable, it is ignored if ( val.giveSize() == 0 ) { continue; } else if ( regionValSize == 0 ) { regionValSize = val.giveSize(); lhs.resize(regionDofMans * regionValSize); lhs.zero(); } else if ( val.giveSize() != regionValSize ) { OOFEM_LOG_RELEVANT("NodalAveragingRecoveryModel :: size mismatch for InternalStateType %s, ignoring all elements that doesn't use the size %d\n", __InternalStateTypeToString(type), regionValSize); continue; } int eq = ( regionNodalNumbers.at(node) - 1 ) * regionValSize; for ( int j = 1; j <= regionValSize; j++ ) { lhs.at(eq + j) += val.at(j); } regionDofMansConnectivity.at( regionNodalNumbers.at(node) )++; } } // end assemble element contributions #ifdef __PARALLEL_MODE if ( parallel ) { this->exchangeDofManValues(lhs, regionDofMansConnectivity, regionNodalNumbers, regionValSize); } #endif // solve for recovered values of active region for ( int inode = 1; inode <= nnodes; inode++ ) { if ( regionNodalNumbers.at(inode) ) { int eq = ( regionNodalNumbers.at(inode) - 1 ) * regionValSize; for ( int i = 1; i <= regionValSize; i++ ) { if ( regionDofMansConnectivity.at( regionNodalNumbers.at(inode) ) > 0 ) { lhs.at(eq + i) /= regionDofMansConnectivity.at( regionNodalNumbers.at(inode) ); } else { OOFEM_WARNING("values of dofmanager %d undetermined", inode); lhs.at(eq + i) = 0.0; } } } } // update recovered values this->updateRegionRecoveredValues(regionNodalNumbers, regionValSize, lhs); this->valType = type; this->stateCounter = tStep->giveSolutionStateCounter(); return 1; }
int VTKXMLExportModule :: initRegionNodeNumbering(IntArray ®ionG2LNodalNumbers, IntArray ®ionL2GNodalNumbers, int ®ionDofMans, int ®ionSingleCells, Domain *domain, int reg) { // regionG2LNodalNumbers is array with mapping from global numbering to local region numbering. // The i-th value contains the corresponding local region number (or zero, if global numbar is not in region). // regionL2GNodalNumbers is array with mapping from local to global numbering. // The i-th value contains the corresponding global node number. int nelem = domain->giveNumberOfElements(); int nnodes = domain->giveNumberOfDofManagers(); int elemNodes; int elementNode, node; int currOffset = 1; Element *element; regionG2LNodalNumbers.resize(nnodes); regionG2LNodalNumbers.zero(); regionDofMans = 0; regionSingleCells = 0; for ( int ielem = 1; ielem <= nelem; ielem++ ) { element = domain->giveElement(ielem); if ( ( reg > 0 ) && ( this->smoother->giveElementVirtualRegionNumber(ielem) != reg ) ) { continue; } if ( this->isElementComposite(element) ) { continue; // composite cells exported individually } if ( !element-> isActivated(domain->giveEngngModel()->giveCurrentStep()) ) { //skip inactivated elements continue; } #ifdef __PARALLEL_MODE if ( element->giveParallelMode() != Element_local ) { continue; } #endif regionSingleCells++; elemNodes = element->giveNumberOfNodes(); // elemSides = element->giveNumberOfSides(); // determine local region node numbering for ( elementNode = 1; elementNode <= elemNodes; elementNode++ ) { node = element->giveNode(elementNode)->giveNumber(); if ( regionG2LNodalNumbers.at(node) == 0 ) { // assign new number /* mark for assignment. This is done later, as it allows to preserve * natural node numbering. */ regionG2LNodalNumbers.at(node) = 1; regionDofMans++; } } } regionL2GNodalNumbers.resize(regionDofMans); for ( int i = 1; i <= nnodes; i++ ) { if ( regionG2LNodalNumbers.at(i) ) { regionG2LNodalNumbers.at(i) = currOffset++; regionL2GNodalNumbers.at( regionG2LNodalNumbers.at(i) ) = i; } } return 1; }
void RCM2Material :: checkForNewActiveCracks(IntArray &answer, GaussPoint *gp, const FloatArray &crackStrain, const FloatArray &princStressVector, FloatArray &crackStressVector, const FloatArray &princStrainVector) // // returns int_array flag showing if some crack // is newly activated or // closed crack is reopened // return 0 if no crack is activated or reactivated. // modifies crackStressVector for newly activated crack. // { double initStress, Le = 0.0; int i, j, upd, activationFlag = 0; RCM2MaterialStatus *status = ( RCM2MaterialStatus * ) this->giveStatus(gp); FloatArray localStress; FloatMatrix tempCrackDirs; IntArray crackMap; answer.resize(3); answer.zero(); status->giveCrackMap(crackMap); localStress = princStressVector; // // local stress is updated according to reached local crack strain // for ( i = 1; i <= 3; i++ ) { // loop over each possible crack plane // test previous status of each possible crack plane upd = 0; if ( ( crackMap.at(i) == 0 ) && ( this->giveStressStrainComponentIndOf(FullForm, gp->giveMaterialMode(), i) ) ) { if ( status->giveTempMaxCrackStrain(i) > 0. ) { // if (status->giveTempCrackStatus()->at(i) != pscm_NONE) { // // previously cracked direction // initStress = 0.; } else { // newer cracked, so we compute principal stresses // and compare them with reduced tension strength // as a criterion for crack initiation FloatArray crackPlaneNormal(3); status->giveTempCrackDirs(tempCrackDirs); for ( j = 1; j <= 3; j++ ) { crackPlaneNormal.at(j) = tempCrackDirs.at(j, i); } // Le = gp->giveElement()->giveCharacteristicLenght (gp, &crackPlaneNormal); Le = this->giveCharacteristicElementLenght(gp, crackPlaneNormal); initStress = this->computeStrength(gp, Le); upd = 1; } if ( localStress.at(i) > initStress ) { crackStressVector.at(i) = initStress; answer.at(i) = 1; activationFlag = 1; if ( upd ) { this->updateStatusForNewCrack(gp, i, Le); } } } // end of tested crack } // end of loop over are possible directions if ( activationFlag ) { return; } answer.resize(0); }