// TODO: FIX OOFEG implementation
void TrPlaneStress2dXFEM :: drawRawGeometry(oofegGraphicContext &context)
{
if ( !context.testElementGraphicActivity(this) ) {
return;
}
XfemManager *xf = this->giveDomain()->giveXfemManager();
if ( !xf->isElementEnriched(this) ) {
TrPlaneStress2d :: drawRawGeometry(context);
} else {
if ( numberOfIntegrationRules > 1 ) {
int i;
// PatchIntegrationRule *iRule;
for ( i = 0; i < numberOfIntegrationRules; i++ ) {
// TODO: Implement visualization.
/*
iRule = dynamic_cast< PatchIntegrationRule * >( integrationRulesArray [ i ] );
if ( iRule ) {
iRule->givePatch()->draw(context);
}
*/
}
} else {
TrPlaneStress2d :: drawRawGeometry(context);
}
}
}
// TODO: FIX OOFEG implementation
void TrPlaneStress2dXFEM :: drawRawGeometry(oofegGraphicContext &gc, TimeStep *tStep)
{
if ( !gc.testElementGraphicActivity(this) ) {
return;
}
XfemManager *xf = this->giveDomain()->giveXfemManager();
if ( !xf->isElementEnriched(this) ) {
TrPlaneStress2d :: drawRawGeometry(gc, tStep);
} else {
if ( integrationRulesArray.size() > 1 ) {
#if 0
for ( auto &ir: integrationRulesArray ) {
// TODO: Implement visualization.
PatchIntegrationRule *iRule = dynamic_cast< PatchIntegrationRule * >( ir );
if ( iRule ) {
iRule->givePatch()->draw(gc);
}
}
#endif
} else {
TrPlaneStress2d :: drawRawGeometry(gc, tStep);
}
}
}
Element_Geometry_Type
TrPlaneStress2dXFEM :: giveGeometryType() const
{
if ( this->giveDomain()->hasXfemManager() ) {
XfemManager *xMan = this->giveDomain()->giveXfemManager();
if ( xMan->isElementEnriched(this) ) {
return EGT_Composite;
} else {
return EGT_Composite;
}
} else {
return EGT_triangle_1;
}
}
void TrPlaneStress2dXFEM :: computeGaussPoints()
{
if ( giveDomain()->hasXfemManager() ) {
XfemManager *xMan = giveDomain()->giveXfemManager();
if ( xMan->isElementEnriched(this) ) {
if ( !this->XfemElementInterface_updateIntegrationRule() ) {
TrPlaneStress2d :: computeGaussPoints();
}
} else {
TrPlaneStress2d :: computeGaussPoints();
}
} else {
TrPlaneStress2d :: computeGaussPoints();
}
}
void TrPlaneStress2dXFEM :: drawScalar(oofegGraphicContext &context)
{
if ( !context.testElementGraphicActivity(this) ) {
return;
}
XfemManager *xf = this->giveDomain()->giveXfemManager();
if ( !xf->isElementEnriched(this) ) {
TrPlaneStress2d :: drawScalar(context);
} else {
if ( context.giveIntVarMode() == ISM_local ) {
int indx;
double val;
FloatArray s(3), v;
indx = context.giveIntVarIndx();
TimeStep *tStep = this->giveDomain()->giveEngngModel()->giveCurrentStep();
PatchIntegrationRule *iRule;
for ( int i = 0; i < numberOfIntegrationRules; i++ ) {
iRule = dynamic_cast< PatchIntegrationRule * >( integrationRulesArray [ i ] );
#if 0
val = iRule->giveMaterial();
#else
val = 0.0;
for ( int j = 0; j < iRule->giveNumberOfIntegrationPoints(); j++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(0);
giveIPValue(v, gp, context.giveIntVarType(), tStep);
val += v.at(indx);
}
val /= iRule->giveNumberOfIntegrationPoints();
#endif
s.at(1) = s.at(2) = s.at(3) = val;
// TODO: Implement visualization.
// iRule->givePatch()->drawWD(context, s);
}
} else {
TrPlaneStress2d :: drawScalar(context);
}
}
}
void TrPlaneStress2dXFEM :: drawScalar(oofegGraphicContext &gc, TimeStep *tStep)
{
if ( !gc.testElementGraphicActivity(this) ) {
return;
}
XfemManager *xf = this->giveDomain()->giveXfemManager();
if ( !xf->isElementEnriched(this) ) {
TrPlaneStress2d :: drawScalar(gc, tStep);
} else {
if ( gc.giveIntVarMode() == ISM_local ) {
int indx;
double val;
FloatArray s(3), v;
indx = gc.giveIntVarIndx();
for ( auto &ir: integrationRulesArray ) {
PatchIntegrationRule *iRule = dynamic_cast< PatchIntegrationRule * >(ir);
#if 0
val = iRule->giveMaterial();
#else
val = 0.0;
for ( GaussPoint *gp: *iRule ) {
giveIPValue(v, gp, gc.giveIntVarType(), tStep);
val += v.at(indx);
}
val /= iRule->giveNumberOfIntegrationPoints();
#endif
s.at(1) = s.at(2) = s.at(3) = val;
// TODO: Implement visualization.
// iRule->givePatch()->drawWD(gc, s);
}
} else {
TrPlaneStress2d :: drawScalar(gc, tStep);
}
}
}
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 ]);
}
}
std::vector<std::unique_ptr<EnrichmentItem>> NCPrincipalStress::nucleateEnrichmentItems() {
SpatialLocalizer *octree = this->mpDomain->giveSpatialLocalizer();
XfemManager *xMan = mpDomain->giveXfemManager();
std::vector<std::unique_ptr<EnrichmentItem>> eiList;
// Center coordinates of newly inserted cracks
std::vector<FloatArray> center_coord_inserted_cracks;
// Loop over all elements and all bulk GP.
for(auto &el : mpDomain->giveElements() ) {
int numIR = el->giveNumberOfIntegrationRules();
int csNum = el->giveCrossSection()->giveNumber();
if(csNum == mCrossSectionInd || true) {
for(int irInd = 0; irInd < numIR; irInd++) {
IntegrationRule *ir = el->giveIntegrationRule(irInd);
int numGP = ir->giveNumberOfIntegrationPoints();
for(int gpInd = 0; gpInd < numGP; gpInd++) {
GaussPoint *gp = ir->getIntegrationPoint(gpInd);
// int csNum = gp->giveCrossSection()->giveNumber();
// printf("csNum: %d\n", csNum);
StructuralMaterialStatus *ms = dynamic_cast<StructuralMaterialStatus*>(gp->giveMaterialStatus());
if(ms != NULL) {
const FloatArray &stress = ms->giveTempStressVector();
FloatArray principalVals;
FloatMatrix principalDirs;
StructuralMaterial::computePrincipalValDir(principalVals, principalDirs, stress, principal_stress);
if(principalVals[0] > mStressThreshold) {
// printf("\nFound GP with stress above threshold.\n");
// printf("principalVals: "); principalVals.printYourself();
FloatArray crackNormal;
crackNormal.beColumnOf(principalDirs, 1);
// printf("crackNormal: "); crackNormal.printYourself();
FloatArray crackTangent = {-crackNormal(1), crackNormal(0)};
crackTangent.normalize();
// printf("crackTangent: "); crackTangent.printYourself();
// Create geometry
FloatArray pc = {gp->giveGlobalCoordinates()(0), gp->giveGlobalCoordinates()(1)};
// printf("Global coord: "); pc.printYourself();
FloatArray ps = pc;
ps.add(-0.5*mInitialCrackLength, crackTangent);
FloatArray pe = pc;
pe.add(0.5*mInitialCrackLength, crackTangent);
if(mCutOneEl) {
// If desired, ensure that the crack cuts exactly one element.
Line line(ps, pe);
std::vector<FloatArray> intersecPoints;
// line.computeIntersectionPoints(el.get(), intersecPoints);
for ( int i = 1; i <= el->giveNumberOfDofManagers(); i++ ) {
// int n1 = i;
// int n2 = 0;
// if ( i < el->giveNumberOfDofManagers() ) {
// n2 = i + 1;
// } else {
// n2 = 1;
// }
// const FloatArray &p1 = *(el->giveDofManager(n1)->giveCoordinates());
// const FloatArray &p2 = *(el->giveDofManager(n2)->giveCoordinates());
}
// printf("intersecPoints.size(): %lu\n", intersecPoints.size());
if(intersecPoints.size() == 2) {
ps = std::move(intersecPoints[0]);
pe = std::move(intersecPoints[1]);
}
else {
OOFEM_ERROR("intersecPoints.size() != 2")
}
}
FloatArray points = {ps(0), ps(1), pc(0), pc(1), pe(0), pe(1)};
// double diffX = 0.5*(ps(0) + pe(0)) - pc(0);
// printf("diffX: %e\n", diffX);
// double diffY = 0.5*(ps(1) + pe(1)) - pc(1);
// printf("diffY: %e\n", diffY);
// TODO: Check if nucleation is allowed, by checking for already existing cracks close to the GP.
// Idea: Nucleation is not allowed if we are within an enriched element. In this way, branching is not
// completely prohibited, but we avoid initiating multiple similar cracks.
bool insertionAllowed = true;
Element *el_s = octree->giveElementContainingPoint(ps);
if(el_s) {
if( xMan->isElementEnriched(el_s) ) {
insertionAllowed = false;
}
}
Element *el_c = octree->giveElementContainingPoint(pc);
if(el_c) {
if( xMan->isElementEnriched(el_c) ) {
insertionAllowed = false;
}
}
Element *el_e = octree->giveElementContainingPoint(pe);
if(el_e) {
if( xMan->isElementEnriched(el_e) ) {
insertionAllowed = false;
}
}
for(const auto &x: center_coord_inserted_cracks) {
if( x.distance(pc) < 2.0*mInitialCrackLength) {
insertionAllowed = false;
break;
printf("Preventing insertion.\n");
}
}
if(insertionAllowed) {
int n = xMan->giveNumberOfEnrichmentItems() + 1;
std::unique_ptr<Crack> crack = std::make_unique<Crack>(n, xMan, mpDomain);
// Geometry
std::unique_ptr<BasicGeometry> geom = std::make_unique<PolygonLine>();
geom->insertVertexBack(ps);
geom->insertVertexBack(pc);
geom->insertVertexBack(pe);
crack->setGeometry(std::move(geom));
// Enrichment function
EnrichmentFunction *ef = new HeavisideFunction(1, mpDomain);
crack->setEnrichmentFunction(ef);
// Enrichment fronts
// EnrichmentFront *efStart = new EnrFrontLinearBranchFuncOneEl();
EnrichmentFront *efStart = new EnrFrontCohesiveBranchFuncOneEl();
crack->setEnrichmentFrontStart(efStart);
// EnrichmentFront *efEnd = new EnrFrontLinearBranchFuncOneEl();
EnrichmentFront *efEnd = new EnrFrontCohesiveBranchFuncOneEl();
crack->setEnrichmentFrontEnd(efEnd);
///////////////////////////////////////
// Propagation law
// Options
// double radius = 0.5*mInitialCrackLength, angleInc = 10.0, incrementLength = 0.5*mInitialCrackLength, hoopStressThreshold = 0.0;
// bool useRadialBasisFunc = true;
// PLHoopStressCirc *pl = new PLHoopStressCirc();
// pl->setRadius(radius);
// pl->setAngleInc(angleInc);
// pl->setIncrementLength(incrementLength);
// pl->setHoopStressThreshold(hoopStressThreshold);
// pl->setUseRadialBasisFunc(useRadialBasisFunc);
// PLDoNothing *pl = new PLDoNothing();
PLMaterialForce *pl = new PLMaterialForce();
pl->setRadius(mMatForceRadius);
pl->setIncrementLength(mIncrementLength);
// pl->setIncrementLength(0.25);
// pl->setCrackPropThreshold(0.25);
pl->setCrackPropThreshold(mCrackPropThreshold);
crack->setPropagationLaw(pl);
crack->updateDofIdPool();
center_coord_inserted_cracks.push_back(pc);
eiList.push_back( std::unique_ptr<EnrichmentItem>(std::move(crack)) );
// printf("Nucleating a crack in NCPrincipalStress::nucleateEnrichmentItems.\n");
// printf("el->giveGlobalNumber(): %d\n", el->giveGlobalNumber() );
// We only introduce one crack per element in a single time step.
break;
}
}
}
}
}
} // If correct csNum
}