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 SurfaceTensionBoundaryCondition :: computeLoadVectorFromElement(FloatArray &answer, Element *e, int side, TimeStep *tStep)
{
FEInterpolation *fei = e->giveInterpolation();
if ( !fei ) {
OOFEM_ERROR("No interpolation or default integration available for element.");
}
std :: unique_ptr< IntegrationRule > iRule( fei->giveBoundaryIntegrationRule(fei->giveInterpolationOrder()-1, side) );
int nsd = e->giveDomain()->giveNumberOfSpatialDimensions();
if ( side == -1 ) {
side = 1;
}
answer.clear();
if ( nsd == 2 ) {
FEInterpolation2d *fei2d = static_cast< FEInterpolation2d * >(fei);
///@todo More of this grunt work should be moved to the interpolation classes
IntArray bnodes;
fei2d->boundaryGiveNodes(bnodes, side);
int nodes = bnodes.giveSize();
FloatMatrix xy(2, nodes);
for ( int i = 1; i <= nodes; i++ ) {
Node *node = e->giveNode(bnodes.at(i));
///@todo This should rely on the xindex and yindex in the interpolator..
xy.at(1, i) = node->giveCoordinate(1);
xy.at(2, i) = node->giveCoordinate(2);
}
FloatArray tmp; // Integrand
FloatArray es; // Tangent vector to curve
FloatArray dNds;
if ( e->giveDomain()->isAxisymmetric() ) {
FloatArray N;
FloatArray gcoords;
for ( GaussPoint *gp: *iRule ) {
fei2d->edgeEvaldNds( dNds, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
fei->boundaryEvalN( N, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
double J = fei->boundaryGiveTransformationJacobian( side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
fei->boundaryLocal2Global( gcoords, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
double r = gcoords(0); // First coordinate is the radial coord.
es.beProductOf(xy, dNds);
tmp.resize( 2 * nodes);
for ( int i = 0; i < nodes; i++ ) {
tmp(2 * i) = dNds(i) * es(0) * r + N(i);
tmp(2 * i + 1) = dNds(i) * es(1) * r;
}
answer.add(- 2 * M_PI * gamma * J * gp->giveWeight(), tmp);
}
} else {
for ( GaussPoint *gp: *iRule ) {
double t = e->giveCrossSection()->give(CS_Thickness, gp);
fei2d->edgeEvaldNds( dNds, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
double J = fei->boundaryGiveTransformationJacobian( side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
es.beProductOf(xy, dNds);
tmp.resize( 2 * nodes);
for ( int i = 0; i < nodes; i++ ) {
tmp(2 * i) = dNds(i) * es(0);
tmp(2 * i + 1) = dNds(i) * es(1);
//B.at(1, 1+i*2) = B.at(2, 2+i*2) = dNds(i);
}
//tmp.beTProductOf(B, es);
answer.add(- t * gamma * J * gp->giveWeight(), tmp);
}
}
} else if ( nsd == 3 ) {
FEInterpolation3d *fei3d = static_cast< FEInterpolation3d * >(fei);
FloatArray n, surfProj;
FloatMatrix dNdx, B;
for ( GaussPoint *gp: *iRule ) {
fei3d->surfaceEvaldNdx( dNdx, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
double J = fei->boundaryEvalNormal( n, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
// [I - n(x)n] in voigt form:
surfProj = {1. - n(0)*n(0), 1. - n(1)*n(1), 1. - n(2)*n(2),
- n(1)*n(2), - n(0)*n(2), - n(0)*n(1),
};
// Construct B matrix of the surface nodes
B.resize(6, 3 * dNdx.giveNumberOfRows());
for ( int i = 1; i <= dNdx.giveNumberOfRows(); i++ ) {
B.at(1, 3 * i - 2) = dNdx.at(i, 1);
B.at(2, 3 * i - 1) = dNdx.at(i, 2);
B.at(3, 3 * i - 0) = dNdx.at(i, 3);
B.at(5, 3 * i - 2) = B.at(4, 3 * i - 1) = dNdx.at(i, 3);
B.at(6, 3 * i - 2) = B.at(4, 3 * i - 0) = dNdx.at(i, 2);
B.at(6, 3 * i - 1) = B.at(5, 3 * i - 0) = dNdx.at(i, 1);
}
answer.plusProduct(B, surfProj, -gamma * J * gp->giveWeight() );
}
}
}
void SurfaceTensionBoundaryCondition :: computeTangentFromElement(FloatMatrix &answer, Element *e, int side, TimeStep *tStep)
{
FEInterpolation *fei = e->giveInterpolation();
if ( !fei ) {
OOFEM_ERROR("No interpolation available for element.");
}
std :: unique_ptr< IntegrationRule > iRule( fei->giveBoundaryIntegrationRule(fei->giveInterpolationOrder()-1, side) );
int nsd = e->giveDomain()->giveNumberOfSpatialDimensions();
int nodes = e->giveNumberOfNodes();
if ( side == -1 ) {
side = 1;
}
answer.clear();
if ( nsd == 2 ) {
FEInterpolation2d *fei2d = static_cast< FEInterpolation2d * >(fei);
///@todo More of this grunt work should be moved to the interpolation classes
FloatMatrix xy(2, nodes);
Node *node;
for ( int i = 1; i <= nodes; i++ ) {
node = e->giveNode(i);
xy.at(1, i) = node->giveCoordinate(1);
xy.at(2, i) = node->giveCoordinate(2);
}
FloatArray tmpA(2 *nodes);
FloatArray es; // Tangent vector to curve
FloatArray dNds;
FloatMatrix B(2, 2 *nodes);
B.zero();
if ( e->giveDomain()->isAxisymmetric() ) {
FloatArray N;
FloatArray gcoords;
FloatArray tmpB(2 *nodes);
for ( GaussPoint *gp: *iRule ) {
fei2d->edgeEvaldNds( dNds, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
fei->boundaryEvalN( N, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
double J = fei->boundaryGiveTransformationJacobian( side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
fei->boundaryLocal2Global( gcoords, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
double r = gcoords(0); // First coordinate is the radial coord.
es.beProductOf(xy, dNds);
// Construct the different matrices in the integrand;
for ( int i = 0; i < nodes; i++ ) {
tmpA(i * 2 + 0) = dNds(i) * es(0);
tmpA(i * 2 + 1) = dNds(i) * es(1);
tmpB(i * 2 + 0) = N(i);
tmpB(i * 2 + 1) = 0;
B(i * 2, 0) = B(i * 2 + 1, 1) = dNds(i);
}
double dV = 2 *M_PI *gamma *J *gp->giveWeight();
answer.plusDyadUnsym(tmpA, tmpB, dV);
answer.plusDyadUnsym(tmpB, tmpA, dV);
answer.plusProductSymmUpper(B, B, r * dV);
answer.plusDyadUnsym(tmpA, tmpA, -r * dV);
}
} else {
for ( GaussPoint *gp: *iRule ) {
double t = e->giveCrossSection()->give(CS_Thickness, gp); ///@todo The thickness is not often relevant or used in FM.
fei2d->edgeEvaldNds( dNds, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
double J = fei->boundaryGiveTransformationJacobian( side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
es.beProductOf(xy, dNds);
// Construct the different matrices in the integrand;
for ( int i = 0; i < nodes; i++ ) {
tmpA(i * 2 + 0) = dNds(i) * es(0);
tmpA(i * 2 + 1) = dNds(i) * es(1);
B(i * 2, 0) = B(i * 2 + 1, 1) = dNds(i);
}
double dV = t * gamma * J * gp->giveWeight();
answer.plusProductSymmUpper(B, B, dV);
answer.plusDyadSymmUpper(tmpA, -dV);
}
}
answer.symmetrized();
} else if ( nsd == 3 ) {
FEInterpolation3d *fei3d = static_cast< FEInterpolation3d * >(fei);
OOFEM_ERROR("3D tangents not implemented yet.");
//FloatMatrix tmp(3 *nodes, 3 *nodes);
FloatMatrix dNdx;
FloatArray n;
for ( GaussPoint *gp: *iRule ) {
fei3d->surfaceEvaldNdx( dNdx, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
/*double J = */ fei->boundaryEvalNormal( n, side, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(e) );
//double dV = gamma * J * gp->giveWeight();
for ( int i = 0; i < nodes; i++ ) {
//tmp(3*i+0) = dNdx(i,0) - (dNdx(i,0)*n(0)* + dNdx(i,1)*n(1) + dNdx(i,2)*n(2))*n(0);
//tmp(3*i+1) = dNdx(i,1) - (dNdx(i,0)*n(0)* + dNdx(i,1)*n(1) + dNdx(i,2)*n(2))*n(1);
//tmp(3*i+2) = dNdx(i,2) - (dNdx(i,0)*n(0)* + dNdx(i,1)*n(1) + dNdx(i,2)*n(2))*n(2);
}
//answer.plusProductSymmUpper(A,B, dV);
///@todo Derive expressions for this.
}
} else {
OOFEM_WARNING("Only 2D or 3D is possible!");
}
}
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;
}
void
SolutionbasedShapeFunction :: computeCorrectionFactors(modeStruct &myMode, IntArray *Dofs, double *am, double *ap)
{
/*
* *Compute c0, cp, cm, Bp, Bm, Ap and Am
*/
double A0p = 0.0, App = 0.0, A0m = 0.0, Amm = 0.0, Bp = 0.0, Bm = 0.0, c0 = 0.0, cp = 0.0, cm = 0.0;
EngngModel *m = myMode.myEngngModel;
Set *mySet = m->giveDomain(1)->giveSet(externalSet);
IntArray BoundaryList = mySet->giveBoundaryList();
for ( int i = 0; i < BoundaryList.giveSize() / 2; i++ ) {
int ElementID = BoundaryList(2 * i);
int Boundary = BoundaryList(2 * i + 1);
Element *thisElement = m->giveDomain(1)->giveElement(ElementID);
FEInterpolation *geoInterpolation = thisElement->giveInterpolation();
IntArray bnodes, zNodes, pNodes, mNodes;
FloatMatrix nodeValues;
geoInterpolation->boundaryGiveNodes(bnodes, Boundary);
nodeValues.resize( this->dofs.giveSize(), bnodes.giveSize() );
nodeValues.zero();
// Change to global ID for bnodes and identify the intersection of bnodes and the zero boundary
splitBoundaryNodeIDs(myMode, * thisElement, bnodes, pNodes, mNodes, zNodes, nodeValues);
std :: unique_ptr< IntegrationRule >iRule(geoInterpolation->giveBoundaryIntegrationRule(order, Boundary));
for ( GaussPoint *gp: *iRule ) {
FloatArray *lcoords = gp->giveCoordinates();
FloatArray gcoords, normal, N;
FloatArray Phi;
double detJ = fabs( geoInterpolation->boundaryGiveTransformationJacobian( Boundary, * lcoords, FEIElementGeometryWrapper(thisElement) ) ) * gp->giveWeight();
geoInterpolation->boundaryEvalNormal( normal, Boundary, * lcoords, FEIElementGeometryWrapper(thisElement) );
geoInterpolation->boundaryEvalN( N, Boundary, * lcoords, FEIElementGeometryWrapper(thisElement) );
geoInterpolation->boundaryLocal2Global( gcoords, Boundary, * lcoords, FEIElementGeometryWrapper(thisElement) );
FloatArray pPhi, mPhi, zPhi;
pPhi.resize( Dofs->giveSize() );
pPhi.zero();
mPhi.resize( Dofs->giveSize() );
mPhi.zero();
zPhi.resize( Dofs->giveSize() );
zPhi.zero();
// Build phi (analytical averaging, not projected onto the mesh)
computeBaseFunctionValueAt(Phi, gcoords, * Dofs, * myMode.myEngngModel);
// Build zPhi for this DofID
for ( int l = 1; l <= zNodes.giveSize(); l++ ) {
int nodeID = zNodes.at(l);
for ( int m = 1; m <= this->dofs.giveSize(); m++ ) {
zPhi.at(m) = zPhi.at(m) + N.at(nodeID) * nodeValues.at(m, nodeID);
}
}
// Build pPhi for this DofID
for ( int l = 1; l <= pNodes.giveSize(); l++ ) {
int nodeID = pNodes.at(l);
for ( int m = 1; m <= this->dofs.giveSize(); m++ ) {
pPhi.at(m) = pPhi.at(m) + N.at(nodeID) * nodeValues.at(m, nodeID);
}
}
// Build mPhi for this DofID
for ( int l = 1; l <= mNodes.giveSize(); l++ ) {
int nodeID = mNodes.at(l);
for ( int m = 1; m <= this->dofs.giveSize(); m++ ) {
mPhi.at(m) = mPhi.at(m) + N.at(nodeID) * nodeValues.at(m, nodeID);
}
}
c0 = c0 + zPhi.dotProduct(normal, 3) * detJ;
cp = cp + pPhi.dotProduct(normal, 3) * detJ;
cm = cm + mPhi.dotProduct(normal, 3) * detJ;
App = App + pPhi.dotProduct(pPhi, 3) * detJ;
Amm = Amm + mPhi.dotProduct(mPhi, 3) * detJ;
A0p = A0p + zPhi.dotProduct(pPhi, 3) * detJ;
A0m = A0m + zPhi.dotProduct(mPhi, 3) * detJ;
Bp = Bp + Phi.dotProduct(pPhi, 3) * detJ;
Bm = Bm + Phi.dotProduct(mPhi, 3) * detJ;
}
}
* am = -( A0m * cp * cp - Bm * cp * cp - A0p * cm * cp + App * c0 * cm + Bp * cm * cp ) / ( App * cm * cm + Amm * cp * cp );
* ap = -( A0p * cm * cm - Bp * cm * cm - A0m * cm * cp + Amm * c0 * cp + Bm * cm * cp ) / ( App * cm * cm + Amm * cp * cp );
}
void
PrescribedMean :: assemble(SparseMtrx &answer, TimeStep *tStep, CharType type,
const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s)
{
if ( type != TangentStiffnessMatrix && type != StiffnessMatrix ) {
return;
}
computeDomainSize();
IntArray c_loc, r_loc;
lambdaDman->giveLocationArray(lambdaIDs, r_loc, r_s);
lambdaDman->giveLocationArray(lambdaIDs, c_loc, c_s);
for ( int i=1; i<=elements.giveSize(); i++ ) {
int elementID = elements.at(i);
Element *thisElement = this->giveDomain()->giveElement(elementID);
FEInterpolation *interpolator = thisElement->giveInterpolation(DofIDItem(dofid));
IntegrationRule *iRule = (elementEdges) ? (interpolator->giveBoundaryIntegrationRule(3, sides.at(i))) :
(interpolator->giveIntegrationRule(3));
for ( GaussPoint * gp: * iRule ) {
FloatArray lcoords = gp->giveNaturalCoordinates();
FloatArray N; //, a;
FloatMatrix temp, tempT;
double detJ = 0.0;
IntArray boundaryNodes, dofids= {(DofIDItem) this->dofid}, r_Sideloc, c_Sideloc;
if (elementEdges) {
// Compute boundary integral
interpolator->boundaryGiveNodes( boundaryNodes, sides.at(i) );
interpolator->boundaryEvalN(N, sides.at(i), lcoords, FEIElementGeometryWrapper(thisElement));
detJ = fabs ( interpolator->boundaryGiveTransformationJacobian(sides.at(i), lcoords, FEIElementGeometryWrapper(thisElement)) );
// Retrieve locations for dofs on boundary
thisElement->giveBoundaryLocationArray(r_Sideloc, boundaryNodes, dofids, r_s);
thisElement->giveBoundaryLocationArray(c_Sideloc, boundaryNodes, dofids, c_s);
} else {
interpolator->evalN(N, lcoords, FEIElementGeometryWrapper(thisElement));
detJ = fabs ( interpolator->giveTransformationJacobian(lcoords, FEIElementGeometryWrapper(thisElement) ) );
IntArray DofIDStemp, rloc, cloc;
thisElement->giveLocationArray(rloc, r_s, &DofIDStemp);
thisElement->giveLocationArray(cloc, c_s, &DofIDStemp);
r_Sideloc.clear();
c_Sideloc.clear();
for (int j=1; j<=DofIDStemp.giveSize(); j++) {
if (DofIDStemp.at(j)==dofids.at(1)) {
r_Sideloc.followedBy({rloc.at(j)});
c_Sideloc.followedBy({cloc.at(j)});
}
}
}
// delta p part:
temp = N*detJ*gp->giveWeight()*(1.0/domainSize);
tempT.beTranspositionOf(temp);
answer.assemble(r_Sideloc, c_loc, temp);
answer.assemble(r_loc, c_Sideloc, tempT);
}
delete iRule;
}
}
void
PrescribedMean :: giveInternalForcesVector(FloatArray &answer, TimeStep *tStep,
CharType type, ValueModeType mode,
const UnknownNumberingScheme &s, FloatArray *eNorm)
{
computeDomainSize();
// Fetch unknowns of this boundary condition
IntArray lambdaLoc;
FloatArray lambda;
lambdaDman->giveUnknownVector(lambda, lambdaIDs, mode, tStep);
lambdaDman->giveLocationArray(lambdaIDs, lambdaLoc, s);
for ( int i=1; i<=elements.giveSize(); i++ ) {
int elementID = elements.at(i);
Element *thisElement = this->giveDomain()->giveElement(elementID);
FEInterpolation *interpolator = thisElement->giveInterpolation(DofIDItem(dofid));
IntegrationRule *iRule = (elementEdges) ? (interpolator->giveBoundaryIntegrationRule(3, sides.at(i))) :
(interpolator->giveIntegrationRule(3));
for ( GaussPoint * gp: * iRule ) {
FloatArray lcoords = gp->giveNaturalCoordinates();
FloatArray a, N, pressureEqns, lambdaEqns;
IntArray boundaryNodes, dofids= {(DofIDItem) this->dofid}, locationArray;
double detJ=0.0;
if (elementEdges) {
// Compute integral
interpolator->boundaryGiveNodes( boundaryNodes, sides.at(i) );
thisElement->computeBoundaryVectorOf(boundaryNodes, dofids, VM_Total, tStep, a);
interpolator->boundaryEvalN(N, sides.at(i), lcoords, FEIElementGeometryWrapper(thisElement));
detJ = fabs ( interpolator->boundaryGiveTransformationJacobian(sides.at(i), lcoords, FEIElementGeometryWrapper(thisElement)) );
// Retrieve locations for dofs with dofids
thisElement->giveBoundaryLocationArray(locationArray, boundaryNodes, dofids, s);
} else {
thisElement->computeVectorOf(dofids, VM_Total, tStep, a);
interpolator->evalN(N, lcoords, FEIElementGeometryWrapper(thisElement));
detJ = fabs ( interpolator->giveTransformationJacobian(lcoords, FEIElementGeometryWrapper(thisElement)));
IntArray DofIDStemp, loc;
thisElement->giveLocationArray(loc, s, &DofIDStemp);
locationArray.clear();
for (int j=1; j<=DofIDStemp.giveSize(); j++) {
if (DofIDStemp.at(j)==dofids.at(1)) {
locationArray.followedBy({loc.at(j)});
}
}
}
// delta p part:
pressureEqns = N*detJ*gp->giveWeight()*lambda.at(1)*(1.0/domainSize);
// delta lambda part
lambdaEqns.resize(1);
lambdaEqns.at(1) = N.dotProduct(a);
lambdaEqns.times(detJ*gp->giveWeight()*1.0/domainSize);
lambdaEqns.at(1) = lambdaEqns.at(1);
// delta p part
answer.assemble(pressureEqns, locationArray);
// delta lambda part
answer.assemble(lambdaEqns, lambdaLoc);
}
delete iRule;
}
}