void MixedGradientPressureWeakPeriodic :: computeStress(FloatArray &sigmaDev, FloatArray &tractions, double rve_size)
{
FloatMatrix mMatrix;
FloatArray normal, coords, t;
int nsd = domain->giveNumberOfSpatialDimensions();
Set *set = this->giveDomain()->giveSet(this->set);
const IntArray &boundaries = set->giveBoundaryList();
// Reminder: sigma = int t * n dA, where t = sum( C_i * n t_i ).
// This loop will construct sigma in matrix form.
FloatMatrix sigma;
for ( int pos = 1; pos <= boundaries.giveSize() / 2; ++pos ) {
Element *el = this->giveDomain()->giveElement( boundaries.at(pos * 2 - 1) );
int boundary = boundaries.at(pos * 2);
FEInterpolation *interp = el->giveInterpolation(); // Geometry interpolation. The displacements or velocities must have the same interpolation scheme (on the boundary at least).
int maxorder = this->order + interp->giveInterpolationOrder() * 3;
std :: unique_ptr< IntegrationRule >ir( interp->giveBoundaryIntegrationRule(maxorder, boundary) );
for ( GaussPoint *gp: *ir ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
FEIElementGeometryWrapper cellgeo(el);
double detJ = interp->boundaryEvalNormal(normal, boundary, lcoords, cellgeo);
// Compute v_m = d_dev . x
interp->boundaryLocal2Global(coords, boundary, lcoords, cellgeo);
this->constructMMatrix(mMatrix, coords, normal);
t.beProductOf(mMatrix, tractions);
sigma.plusDyadUnsym(t, coords, detJ * gp->giveWeight());
}
}
sigma.times(1. / rve_size);
double pressure = 0.;
for ( int i = 1; i <= nsd; i++ ) {
pressure += sigma.at(i, i);
}
pressure /= 3; // Not 100% sure about this for 2D cases.
if ( nsd == 3 ) {
sigmaDev.resize(6);
sigmaDev.at(1) = sigma.at(1, 1) - pressure;
sigmaDev.at(2) = sigma.at(2, 2) - pressure;
sigmaDev.at(3) = sigma.at(3, 3) - pressure;
sigmaDev.at(4) = 0.5 * ( sigma.at(2, 3) + sigma.at(3, 2) );
sigmaDev.at(5) = 0.5 * ( sigma.at(1, 3) + sigma.at(3, 1) );
sigmaDev.at(6) = 0.5 * ( sigma.at(1, 2) + sigma.at(2, 1) );
} else if ( nsd == 2 ) {
sigmaDev.resize(3);
sigmaDev.at(1) = sigma.at(1, 1) - pressure;
sigmaDev.at(2) = sigma.at(2, 2) - pressure;
sigmaDev.at(3) = 0.5 * ( sigma.at(1, 2) + sigma.at(2, 1) );
} else {
sigmaDev.resize(1);
sigmaDev.at(1) = sigma.at(1, 1) - pressure;
}
}
void MixedGradientPressureWeakPeriodic :: integrateTractionXTangent(FloatMatrix &answer, Element *el, int boundary)
{
// Computes the integral: int dt . dx_m dA
FloatMatrix mMatrix;
FloatArray normal, coords, vM_vol;
FEInterpolation *interp = el->giveInterpolation(); // Geometry interpolation. The displacements or velocities must have the same interpolation scheme (on the boundary at least).
int maxorder = this->order + interp->giveInterpolationOrder() * 3;
std :: unique_ptr< IntegrationRule >ir( interp->giveBoundaryIntegrationRule(maxorder, boundary) );
FloatArray tmpAnswer;
for ( GaussPoint *gp: *ir ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
FEIElementGeometryWrapper cellgeo(el);
double detJ = interp->boundaryEvalNormal(normal, boundary, lcoords, cellgeo);
interp->boundaryLocal2Global(coords, boundary, lcoords, cellgeo);
vM_vol.beScaled(1.0/3.0, coords);
this->constructMMatrix(mMatrix, coords, normal);
tmpAnswer.plusProduct(mMatrix, vM_vol, detJ * gp->giveWeight());
}
answer.resize(tmpAnswer.giveSize(), 1);
answer.setColumn(tmpAnswer, 1);
}
void MixedGradientPressureWeakPeriodic :: integrateTractionDev(FloatArray &answer, Element *el, int boundary, const FloatMatrix &ddev)
{
// Computes the integral: int dt . dx dA
FloatMatrix mMatrix;
FloatArray normal, coords, vM_dev;
FEInterpolation *interp = el->giveInterpolation(); // Geometry interpolation. The displacements or velocities must have the same interpolation scheme (on the boundary at least).
int maxorder = this->order + interp->giveInterpolationOrder() * 3;
std :: unique_ptr< IntegrationRule >ir( interp->giveBoundaryIntegrationRule(maxorder, boundary) );
answer.clear();
for ( GaussPoint *gp: *ir ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
FEIElementGeometryWrapper cellgeo(el);
double detJ = interp->boundaryEvalNormal(normal, boundary, lcoords, cellgeo);
// Compute v_m = d_dev . x
interp->boundaryLocal2Global(coords, boundary, lcoords, cellgeo);
vM_dev.beProductOf(ddev, coords);
this->constructMMatrix(mMatrix, coords, normal);
answer.plusProduct(mMatrix, vM_dev, detJ * gp->giveWeight());
}
}
void MixedGradientPressureWeakPeriodic :: integrateTractionVelocityTangent(FloatMatrix &answer, Element *el, int boundary)
{
// Computes the integral: int dt . dv dA
FloatArray normal, n, coords;
FloatMatrix nMatrix, mMatrix;
FEInterpolation *interp = el->giveInterpolation(); // Geometry interpolation. The displacements or velocities must have the same interpolation scheme (on the boundary at least).
int maxorder = this->order + interp->giveInterpolationOrder() * 3;
std :: unique_ptr< IntegrationRule >ir( interp->giveBoundaryIntegrationRule(maxorder, boundary) );
int nsd = this->giveDomain()->giveNumberOfSpatialDimensions();
answer.clear();
for ( GaussPoint *gp: *ir ) {
const FloatArray &lcoords = gp->giveNaturalCoordinates();
FEIElementGeometryWrapper cellgeo(el);
double detJ = interp->boundaryEvalNormal(normal, boundary, lcoords, cellgeo);
interp->boundaryEvalN(n, boundary, lcoords, cellgeo);
interp->boundaryLocal2Global(coords, boundary, lcoords, cellgeo);
// Construct the basis functions for the tractions:
this->constructMMatrix(mMatrix, coords, normal);
nMatrix.beNMatrixOf(n, nsd);
answer.plusProductUnsym( mMatrix, nMatrix, detJ * gp->giveWeight() );
}
}
void PrescribedGradientBCNeumann :: integrateTangent(FloatMatrix &oTangent, Element *e, int iBndIndex)
{
FloatArray normal, n;
FloatMatrix nMatrix, E_n;
FloatMatrix contrib;
Domain *domain = e->giveDomain();
XfemElementInterface *xfemElInt = dynamic_cast< XfemElementInterface * >( e );
FEInterpolation *interp = e->giveInterpolation(); // Geometry interpolation
int nsd = e->giveDomain()->giveNumberOfSpatialDimensions();
// Interpolation order
int order = interp->giveInterpolationOrder();
IntegrationRule *ir = NULL;
IntArray edgeNodes;
FEInterpolation2d *interp2d = dynamic_cast< FEInterpolation2d * >( interp );
if ( interp2d == NULL ) {
OOFEM_ERROR("failed to cast to FEInterpolation2d.")
}
interp2d->computeLocalEdgeMapping(edgeNodes, iBndIndex);
const FloatArray &xS = * ( e->giveDofManager( edgeNodes.at(1) )->giveCoordinates() );
const FloatArray &xE = * ( e->giveDofManager( edgeNodes.at( edgeNodes.giveSize() ) )->giveCoordinates() );
if ( xfemElInt != NULL && domain->hasXfemManager() ) {
std :: vector< Line >segments;
std :: vector< FloatArray >intersecPoints;
xfemElInt->partitionEdgeSegment(iBndIndex, segments, intersecPoints);
MaterialMode matMode = e->giveMaterialMode();
ir = new DiscontinuousSegmentIntegrationRule(1, e, segments, xS, xE);
int numPointsPerSeg = 1;
ir->SetUpPointsOnLine(numPointsPerSeg, matMode);
} else {
ir = interp->giveBoundaryIntegrationRule(order, iBndIndex);
}
oTangent.clear();
for ( GaussPoint *gp: *ir ) {
FloatArray &lcoords = * gp->giveNaturalCoordinates();
FEIElementGeometryWrapper cellgeo(e);
// Evaluate the normal;
double detJ = interp->boundaryEvalNormal(normal, iBndIndex, lcoords, cellgeo);
interp->boundaryEvalN(n, iBndIndex, lcoords, cellgeo);
// If cracks cross the edge, special treatment is necessary.
// Exploit the XfemElementInterface to minimize duplication of code.
if ( xfemElInt != NULL && domain->hasXfemManager() ) {
// Compute global coordinates of Gauss point
FloatArray globalCoord;
interp->boundaryLocal2Global(globalCoord, iBndIndex, lcoords, cellgeo);
// Compute local coordinates on the element
FloatArray locCoord;
e->computeLocalCoordinates(locCoord, globalCoord);
xfemElInt->XfemElementInterface_createEnrNmatrixAt(nMatrix, locCoord, * e, false);
} else {
// Evaluate the velocity/displacement coefficients
nMatrix.beNMatrixOf(n, nsd);
}
if ( nsd == 3 ) {
OOFEM_ERROR("not implemented for nsd == 3.")
} else if ( nsd == 2 ) {
E_n.resize(4, 2);
E_n.at(1, 1) = normal.at(1);
E_n.at(1, 2) = 0.0;
E_n.at(2, 1) = 0.0;
E_n.at(2, 2) = normal.at(2);
E_n.at(3, 1) = normal.at(2);
E_n.at(3, 2) = 0.0;
E_n.at(4, 1) = 0.0;
E_n.at(4, 2) = normal.at(1);
} else {
E_n.clear();
}
contrib.beProductOf(E_n, nMatrix);
oTangent.add(detJ * gp->giveWeight(), contrib);
}
delete ir;
}
