void TrPlaneStress2dXFEM :: computeGaussPoints()
{
XfemManager *xMan = this->giveDomain()->giveXfemManager();
for(int i = 1; i <= xMan->giveNumberOfEnrichmentItems(); i++)
{
std::vector<FloatArray> intersecPoints;
EnrichmentItem *ei = xMan->giveEnrichmentItem(i);
std::vector< int > intersecEdgeInd;
ei->computeIntersectionPoints(intersecPoints, intersecEdgeInd, this);
int numIntersecPoints = intersecPoints.size();
if ( numIntersecPoints > 0 )
{
this->XfemElementInterface_updateIntegrationRule();
} else
{
TrPlaneStress2d ::computeGaussPoints();
}
}
// this->XfemElementInterface_updateIntegrationRule();
}
void
TrPlaneStress2dXFEM :: giveDofManDofIDMask(int inode, IntArray &answer) const
{
// Continuous part
TrPlaneStress2d :: giveDofManDofIDMask(inode, answer);
// Discontinuous part
if( this->giveDomain()->hasXfemManager() ) {
DofManager *dMan = giveDofManager(inode);
XfemManager *xMan = giveDomain()->giveXfemManager();
const std::vector<int> &nodeEiIndices = xMan->giveNodeEnrichmentItemIndices( dMan->giveGlobalNumber() );
for ( size_t i = 0; i < nodeEiIndices.size(); i++ ) {
EnrichmentItem *ei = xMan->giveEnrichmentItem(nodeEiIndices[i]);
if ( ei->isDofManEnriched(* dMan) ) {
IntArray eiDofIdArray;
ei->computeEnrichedDofManDofIdArray(eiDofIdArray, *dMan);
answer.followedBy(eiDofIdArray);
}
}
}
}
bool XfemStructuralElementInterface :: XfemElementInterface_updateIntegrationRule()
{
const double tol2 = 1.0e-18;
bool partitionSucceeded = false;
if ( mpCZMat != NULL ) {
mpCZIntegrationRules.clear();
mCZEnrItemIndices.clear();
mCZTouchingEnrItemIndices.clear();
}
XfemManager *xMan = this->element->giveDomain()->giveXfemManager();
if ( xMan->isElementEnriched(element) ) {
if ( mpCZMat == NULL && mCZMaterialNum > 0 ) {
initializeCZMaterial();
}
MaterialMode matMode = element->giveMaterialMode();
bool firstIntersection = true;
std :: vector< std :: vector< FloatArray > >pointPartitions;
mSubTri.clear();
std :: vector< int >enrichingEIs;
int elPlaceInArray = xMan->giveDomain()->giveElementPlaceInArray( element->giveGlobalNumber() );
xMan->giveElementEnrichmentItemIndices(enrichingEIs, elPlaceInArray);
for ( size_t p = 0; p < enrichingEIs.size(); p++ ) {
// Index of current ei
int eiIndex = enrichingEIs [ p ];
// Indices of other ei interaction with this ei through intersection enrichment fronts.
std :: vector< int >touchingEiIndices;
giveIntersectionsTouchingCrack(touchingEiIndices, enrichingEIs, eiIndex, * xMan);
if ( firstIntersection ) {
// Get the points describing each subdivision of the element
double startXi, endXi;
bool intersection = false;
this->XfemElementInterface_prepareNodesForDelaunay(pointPartitions, startXi, endXi, eiIndex, intersection);
if ( intersection ) {
firstIntersection = false;
// Use XfemElementInterface_partitionElement to subdivide the element
for ( int i = 0; i < int ( pointPartitions.size() ); i++ ) {
// Triangulate the subdivisions
this->XfemElementInterface_partitionElement(mSubTri, pointPartitions [ i ]);
}
if ( mpCZMat != NULL ) {
Crack *crack = dynamic_cast< Crack * >( xMan->giveEnrichmentItem(eiIndex) );
if ( crack == NULL ) {
OOFEM_ERROR("Cohesive zones are only available for cracks.")
}
// We have xi_s and xi_e. Fetch sub polygon.
std :: vector< FloatArray >crackPolygon;
crack->giveSubPolygon(crackPolygon, startXi, endXi);
///////////////////////////////////
// Add cohesive zone Gauss points
size_t numSeg = crackPolygon.size() - 1;
for ( size_t segIndex = 0; segIndex < numSeg; segIndex++ ) {
int czRuleNum = 1;
mpCZIntegrationRules.emplace_back( new GaussIntegrationRule(czRuleNum, element) );
// Add index of current ei
mCZEnrItemIndices.push_back(eiIndex);
// Add indices of other ei, that cause interaction through
// intersection enrichment fronts
mCZTouchingEnrItemIndices.push_back(touchingEiIndices);
// Compute crack normal
FloatArray crackTang;
crackTang.beDifferenceOf(crackPolygon [ segIndex + 1 ], crackPolygon [ segIndex ]);
if ( crackTang.computeSquaredNorm() > tol2 ) {
crackTang.normalize();
}
FloatArray crackNormal = {
-crackTang.at(2), crackTang.at(1)
};
mpCZIntegrationRules [ segIndex ]->SetUpPointsOn2DEmbeddedLine(mCSNumGaussPoints, matMode,
crackPolygon [ segIndex ], crackPolygon [ segIndex + 1 ]);
for ( GaussPoint *gp: *mpCZIntegrationRules [ segIndex ] ) {
double gw = gp->giveWeight();
double segLength = crackPolygon [ segIndex ].distance(crackPolygon [ segIndex + 1 ]);
gw *= 0.5 * segLength;
gp->setWeight(gw);
// Fetch material status and set normal
StructuralInterfaceMaterialStatus *ms = dynamic_cast< StructuralInterfaceMaterialStatus * >( mpCZMat->giveStatus(gp) );
if ( ms == NULL ) {
OOFEM_ERROR("Failed to fetch material status.");
}
ms->letNormalBe(crackNormal);
// Give Gauss point reference to the enrichment item
// to simplify post processing.
crack->AppendCohesiveZoneGaussPoint(gp);
}
}
}
partitionSucceeded = true;
}
} // if(firstIntersection)
else {
// Loop over triangles
std :: vector< Triangle >allTriCopy;
for ( size_t triIndex = 0; triIndex < mSubTri.size(); triIndex++ ) {
// Call alternative version of XfemElementInterface_prepareNodesForDelaunay
std :: vector< std :: vector< FloatArray > >pointPartitionsTri;
double startXi, endXi;
bool intersection = false;
XfemElementInterface_prepareNodesForDelaunay(pointPartitionsTri, startXi, endXi, mSubTri [ triIndex ], eiIndex, intersection);
if ( intersection ) {
// Use XfemElementInterface_partitionElement to subdivide triangle j
for ( int i = 0; i < int ( pointPartitionsTri.size() ); i++ ) {
this->XfemElementInterface_partitionElement(allTriCopy, pointPartitionsTri [ i ]);
}
// Add cohesive zone Gauss points
if ( mpCZMat != NULL ) {
Crack *crack = dynamic_cast< Crack * >( xMan->giveEnrichmentItem(eiIndex) );
if ( crack == NULL ) {
OOFEM_ERROR("Cohesive zones are only available for cracks.")
}
// We have xi_s and xi_e. Fetch sub polygon.
std :: vector< FloatArray >crackPolygon;
crack->giveSubPolygon(crackPolygon, startXi, endXi);
int numSeg = crackPolygon.size() - 1;
for ( int segIndex = 0; segIndex < numSeg; segIndex++ ) {
int czRuleNum = 1;
mpCZIntegrationRules.emplace_back( new GaussIntegrationRule(czRuleNum, element) );
size_t newRuleInd = mpCZIntegrationRules.size() - 1;
mCZEnrItemIndices.push_back(eiIndex);
mCZTouchingEnrItemIndices.push_back(touchingEiIndices);
// Compute crack normal
FloatArray crackTang;
crackTang.beDifferenceOf(crackPolygon [ segIndex + 1 ], crackPolygon [ segIndex ]);
if ( crackTang.computeSquaredNorm() > tol2 ) {
crackTang.normalize();
}
FloatArray crackNormal = {
-crackTang.at(2), crackTang.at(1)
};
mpCZIntegrationRules [ newRuleInd ]->SetUpPointsOn2DEmbeddedLine(mCSNumGaussPoints, matMode,
crackPolygon [ segIndex ], crackPolygon [ segIndex + 1 ]);
for ( GaussPoint *gp: *mpCZIntegrationRules [ newRuleInd ] ) {
double gw = gp->giveWeight();
double segLength = crackPolygon [ segIndex ].distance(crackPolygon [ segIndex + 1 ]);
gw *= 0.5 * segLength;
gp->setWeight(gw);
// Fetch material status and set normal
StructuralInterfaceMaterialStatus *ms = dynamic_cast< StructuralInterfaceMaterialStatus * >( mpCZMat->giveStatus(gp) );
if ( ms == NULL ) {
OOFEM_ERROR("Failed to fetch material status.");
}
ms->letNormalBe(crackNormal);
// Give Gauss point reference to the enrichment item
// to simplify post processing.
crack->AppendCohesiveZoneGaussPoint(gp);
}
}
}
} else {
allTriCopy.push_back(mSubTri [ triIndex ]);
}
}
void GnuplotExportModule::doOutput(TimeStep *tStep, bool forcedOutput)
{
if (!(testTimeStepOutput(tStep) || forcedOutput)) {
return;
}
// Export the sum of reaction forces for each Dirichlet BC
if(mExportReactionForces) {
outputReactionForces(tStep);
}
Domain *domain = emodel->giveDomain(1);
// Export output from boundary conditions
if(mExportBoundaryConditions) {
int numBC = domain->giveNumberOfBoundaryConditions();
for(int i = 1; i <= numBC; i++) {
PrescribedGradient *presGradBC = dynamic_cast<PrescribedGradient*>( domain->giveBc(i) );
if(presGradBC != NULL) {
outputBoundaryCondition(*presGradBC, tStep);
}
PrescribedGradientBCNeumann *presGradBCNeumann = dynamic_cast<PrescribedGradientBCNeumann*>( domain->giveBc(i) );
if(presGradBCNeumann != NULL) {
outputBoundaryCondition(*presGradBCNeumann, tStep);
}
PrescribedGradientBCWeak *presGradBCWeak = dynamic_cast<PrescribedGradientBCWeak*>( domain->giveBc(i) );
if(presGradBCWeak != NULL) {
outputBoundaryCondition(*presGradBCWeak, tStep);
}
}
}
mTimeHist.push_back( tStep->giveTargetTime() );
if(mExportXFEM) {
if(domain->hasXfemManager()) {
XfemManager *xMan = domain->giveXfemManager();
int numEI = xMan->giveNumberOfEnrichmentItems();
std::vector< std::vector<FloatArray> > points;
for(int i = 1; i <= numEI; i++) {
EnrichmentItem *ei = xMan->giveEnrichmentItem(i);
ei->callGnuplotExportModule(*this, tStep);
GeometryBasedEI *geoEI = dynamic_cast<GeometryBasedEI*>(ei);
if(geoEI != NULL) {
std::vector<FloatArray> eiPoints;
geoEI->giveSubPolygon(eiPoints, 0.0, 1.0);
points.push_back(eiPoints);
}
}
outputXFEMGeometry(points);
}
}
if(mExportMesh) {
outputMesh(*domain);
}
if(mMonitorNodeIndex != -1) {
DofManager *dMan = domain->giveDofManager(mMonitorNodeIndex);
outputNodeDisp(*dMan, tStep);
}
}
void
TrPlaneStress2dXFEM :: giveCompositeExportData(std::vector< VTKPiece > &vtkPieces, IntArray &primaryVarsToExport, IntArray &internalVarsToExport, IntArray cellVarsToExport, TimeStep *tStep)
{
vtkPieces.resize(1);
const int numCells = mSubTri.size();
if(numCells == 0) {
// Enriched but uncut element
// Visualize as a quad
vtkPieces[0].setNumberOfCells(1);
int numTotalNodes = 3;
vtkPieces[0].setNumberOfNodes(numTotalNodes);
// Node coordinates
std :: vector< FloatArray >nodeCoords;
for(int i = 1; i <= 3; i++) {
FloatArray &x = *(giveDofManager(i)->giveCoordinates());
nodeCoords.push_back(x);
vtkPieces[0].setNodeCoords(i, x);
}
// Connectivity
IntArray nodes1 = {1, 2, 3};
vtkPieces[0].setConnectivity(1, nodes1);
// Offset
int offset = 3;
vtkPieces[0].setOffset(1, offset);
// Cell types
vtkPieces[0].setCellType(1, 5); // Linear triangle
// Export nodal variables from primary fields
vtkPieces[0].setNumberOfPrimaryVarsToExport(primaryVarsToExport.giveSize(), numTotalNodes);
for ( int fieldNum = 1; fieldNum <= primaryVarsToExport.giveSize(); fieldNum++ ) {
UnknownType type = ( UnknownType ) primaryVarsToExport.at(fieldNum);
for ( int nodeInd = 1; nodeInd <= numTotalNodes; nodeInd++ ) {
if ( type == DisplacementVector ) { // compute displacement
FloatArray u = {0.0, 0.0, 0.0};
// Fetch global coordinates (in undeformed configuration)
const FloatArray &x = nodeCoords[nodeInd-1];
// Compute local coordinates
FloatArray locCoord;
computeLocalCoordinates(locCoord, x);
// Compute displacement in point
FloatMatrix NMatrix;
computeNmatrixAt(locCoord, NMatrix);
FloatArray solVec;
computeVectorOf(VM_Total, tStep, solVec);
FloatArray uTemp;
uTemp.beProductOf(NMatrix, solVec);
if(uTemp.giveSize() == 3) {
u = uTemp;
}
else {
u = {uTemp[0], uTemp[1], 0.0};
}
vtkPieces[0].setPrimaryVarInNode(fieldNum, nodeInd, u);
} else {
printf("fieldNum: %d\n", fieldNum);
// TODO: Implement
// ZZNodalRecoveryMI_recoverValues(values, layer, ( InternalStateType ) 1, tStep); // does not work well - fix
// for ( int j = 1; j <= numCellNodes; j++ ) {
// vtkPiece.setPrimaryVarInNode(fieldNum, nodeNum, values [ j - 1 ]);
// nodeNum += 1;
// }
}
}
}
// Export nodal variables from internal fields
vtkPieces[0].setNumberOfInternalVarsToExport(0, numTotalNodes);
// Export cell variables
vtkPieces[0].setNumberOfCellVarsToExport(cellVarsToExport.giveSize(), 1);
for ( int i = 1; i <= cellVarsToExport.giveSize(); i++ ) {
InternalStateType type = ( InternalStateType ) cellVarsToExport.at(i);
FloatArray average;
std :: unique_ptr< IntegrationRule > &iRule = integrationRulesArray [ 0 ];
VTKXMLExportModule :: computeIPAverage(average, iRule.get(), this, type, tStep);
FloatArray averageV9(9);
averageV9.at(1) = average.at(1);
averageV9.at(5) = average.at(2);
averageV9.at(9) = average.at(3);
averageV9.at(6) = averageV9.at(8) = average.at(4);
averageV9.at(3) = averageV9.at(7) = average.at(5);
averageV9.at(2) = averageV9.at(4) = average.at(6);
vtkPieces[0].setCellVar( i, 1, averageV9 );
}
// Export of XFEM related quantities
if ( domain->hasXfemManager() ) {
XfemManager *xMan = domain->giveXfemManager();
int nEnrIt = xMan->giveNumberOfEnrichmentItems();
vtkPieces[0].setNumberOfInternalXFEMVarsToExport(xMan->vtkExportFields.giveSize(), nEnrIt, numTotalNodes);
const int nDofMan = giveNumberOfDofManagers();
for ( int field = 1; field <= xMan->vtkExportFields.giveSize(); field++ ) {
XFEMStateType xfemstype = ( XFEMStateType ) xMan->vtkExportFields [ field - 1 ];
for ( int enrItIndex = 1; enrItIndex <= nEnrIt; enrItIndex++ ) {
EnrichmentItem *ei = xMan->giveEnrichmentItem(enrItIndex);
for ( int nodeInd = 1; nodeInd <= numTotalNodes; nodeInd++ ) {
const FloatArray &x = nodeCoords[nodeInd-1];
FloatArray locCoord;
computeLocalCoordinates(locCoord, x);
FloatArray N;
FEInterpolation *interp = giveInterpolation();
interp->evalN( N, locCoord, FEIElementGeometryWrapper(this) );
if ( xfemstype == XFEMST_LevelSetPhi ) {
double levelSet = 0.0, levelSetInNode = 0.0;
for(int elNodeInd = 1; elNodeInd <= nDofMan; elNodeInd++) {
DofManager *dMan = giveDofManager(elNodeInd);
ei->evalLevelSetNormalInNode(levelSetInNode, dMan->giveGlobalNumber(), *(dMan->giveCoordinates()) );
levelSet += N.at(elNodeInd)*levelSetInNode;
}
FloatArray valueArray = {levelSet};
vtkPieces[0].setInternalXFEMVarInNode(field, enrItIndex, nodeInd, valueArray);
} else if ( xfemstype == XFEMST_LevelSetGamma ) {
double levelSet = 0.0, levelSetInNode = 0.0;
for(int elNodeInd = 1; elNodeInd <= nDofMan; elNodeInd++) {
DofManager *dMan = giveDofManager(elNodeInd);
ei->evalLevelSetTangInNode(levelSetInNode, dMan->giveGlobalNumber(), *(dMan->giveCoordinates()) );
levelSet += N.at(elNodeInd)*levelSetInNode;
}
FloatArray valueArray = {levelSet};
vtkPieces[0].setInternalXFEMVarInNode(field, enrItIndex, nodeInd, valueArray);
} else if ( xfemstype == XFEMST_NodeEnrMarker ) {
double nodeEnrMarker = 0.0, nodeEnrMarkerInNode = 0.0;
for(int elNodeInd = 1; elNodeInd <= nDofMan; elNodeInd++) {
DofManager *dMan = giveDofManager(elNodeInd);
ei->evalNodeEnrMarkerInNode(nodeEnrMarkerInNode, dMan->giveGlobalNumber() );
nodeEnrMarker += N.at(elNodeInd)*nodeEnrMarkerInNode;
}
FloatArray valueArray = {nodeEnrMarker};
vtkPieces[0].setInternalXFEMVarInNode(field, enrItIndex, nodeInd, valueArray);
}
}
}
}
}
}
else {
// Enriched and cut element
XfemStructuralElementInterface::giveSubtriangulationCompositeExportData(vtkPieces, primaryVarsToExport, internalVarsToExport, cellVarsToExport, tStep);
}
}