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