IntegrationRule *
Brick1_ht :: GetSurfaceIntegrationRule(int approxOrder)
{
IntegrationRule *iRule = new GaussIntegrationRule(1, this, 1, 1);
int npoints = iRule->getRequiredNumberOfIntegrationPoints(_Square, approxOrder);
iRule->SetUpPointsOnSquare(npoints, _Unknown);
return iRule;
}
IntegrationRule *
DKTPlate :: GetSurfaceIntegrationRule(int approxOrder)
{
IntegrationRule *iRule = new GaussIntegrationRule(1, this, 1, 1);
int npoints = iRule->getRequiredNumberOfIntegrationPoints(_Triangle, approxOrder);
iRule->SetUpPointsOnTriangle(npoints, _Unknown);
return iRule;
}
IntegrationRule *
FEI2dTrQuad :: giveIntegrationRule(int order)
{
IntegrationRule *iRule = new GaussIntegrationRule(1, NULL);
int points = iRule->getRequiredNumberOfIntegrationPoints(_Triangle, order + 2);
iRule->SetUpPointsOnTriangle(points, _Unknown);
return iRule;
}
void
TR_SHELL01 :: printOutputAt(FILE *file, TimeStep *tStep)
// Performs end-of-step operations.
{
FloatArray v, aux;
GaussPoint *membraneGP;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
fprintf( file, "element %d (%8d) :\n", this->giveLabel(), this->giveNumber() );
for ( GaussPoint *gp: *iRule ) {
fprintf( file, " GP %2d.%-2d :", iRule->giveNumber(), gp->giveNumber() );
membraneGP = membrane->giveDefaultIntegrationRulePtr()->getIntegrationPoint(gp->giveNumber() - 1);
// Strain - Curvature
plate->giveIPValue(v, gp, IST_ShellStrainTensor, tStep);
membrane->giveIPValue(aux, membraneGP, IST_ShellStrainTensor, tStep);
v.add(aux);
fprintf(file, " strains ");
// eps_x, eps_y, eps_z, eps_yz, eps_xz, eps_xy (global)
fprintf( file,
" % .4e % .4e % .4e % .4e % .4e % .4e ",
v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) );
plate->giveIPValue(v, gp, IST_ShellCurvatureTensor, tStep);
membrane->giveIPValue(aux, membraneGP, IST_ShellCurvatureTensor, tStep);
v.add(aux);
fprintf(file, "\n curvatures ");
// k_x, k_y, k_z, k_yz, k_xz, k_xy (global)
fprintf( file,
" % .4e % .4e % .4e % .4e % .4e % .4e ",
v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) );
// Forces - Moments
plate->giveIPValue(v, gp, IST_ShellForceTensor, tStep);
membrane->giveIPValue(aux, membraneGP, IST_ShellForceTensor, tStep);
v.add(aux);
fprintf(file, "\n stresses ");
// n_x, n_y, n_z, v_yz, v_xz, v_xy (global)
fprintf( file,
" % .4e % .4e % .4e % .4e % .4e % .4e ",
v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) );
plate->giveIPValue(v, gp, IST_ShellMomentumTensor, tStep);
membrane->giveIPValue(aux, membraneGP, IST_ShellMomentumTensor, tStep);
v.add(aux);
fprintf(file, "\n moments ");
// m_x, m_y, m_z, m_yz, m_xz, m_xy (global)
fprintf( file,
" % .4e % .4e % .4e % .4e % .4e % .4e ",
v.at(1), v.at(5), v.at(9), v.at(6), v.at(3), v.at(2) );
fprintf(file, "\n");
}
}
void InterfaceElem1d :: drawScalar(oofegGraphicContext &context)
{
int i, indx, result = 0;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
TimeStep *tStep = this->giveDomain()->giveEngngModel()->giveCurrentStep();
FloatArray gcoord(3), v1;
WCRec p [ 1 ];
IntArray map;
GraphicObj *go;
double val [ 1 ];
if ( !context.testElementGraphicActivity(this) ) {
return;
}
if ( context.getInternalVarsDefGeoFlag() ) {
double defScale = context.getDefScale();
p [ 0 ].x = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(1, tStep, EID_MomentumBalance, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(1, tStep, EID_MomentumBalance, defScale) );
p [ 0 ].y = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(2, tStep, EID_MomentumBalance, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(2, tStep, EID_MomentumBalance, defScale) );
p [ 0 ].z = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(3, tStep, EID_MomentumBalance, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(3, tStep, EID_MomentumBalance, defScale) );
} else {
p [ 0 ].x = ( FPNum )( this->giveNode(1)->giveCoordinate(1) );
p [ 0 ].y = ( FPNum )( this->giveNode(1)->giveCoordinate(2) );
p [ 0 ].z = ( FPNum )( this->giveNode(1)->giveCoordinate(3) );
}
result += giveIPValue(v1, iRule->getIntegrationPoint(0), context.giveIntVarType(), tStep);
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
result = 0;
gp = iRule->getIntegrationPoint(i);
result += giveIPValue(v1, gp, context.giveIntVarType(), tStep);
result += this->giveIntVarCompFullIndx( map, context.giveIntVarType() );
if ( result != 2 ) {
continue;
}
if ( ( indx = map.at( context.giveIntVarIndx() ) ) == 0 ) {
return;
}
val [ 0 ] = v1.at(indx);
context.updateFringeTableMinMax(val, 1);
EASValsSetLayer(OOFEG_VARPLOT_PATTERN_LAYER);
EASValsSetMType(FILLED_CIRCLE_MARKER);
go = CreateMarkerWD3D(p, val [ 0 ]);
EGWithMaskChangeAttributes(LAYER_MASK | FILL_MASK | MTYPE_MASK, go);
EMAddGraphicsToModel(ESIModel(), go);
//}
}
}
double
Lattice2d_mt :: givePressure()
{
LatticeTransportMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeTransportMaterialStatus * >( gp->giveMaterialStatus() );
return status->givePressure();
}
void IntegrationPointTransformation::Transform (const IntegrationRule &ir1,
IntegrationRule &ir2)
{
int i, n;
n = ir1.GetNPoints();
for (i = 0; i < n; i++)
{
Transform (ir1.IntPoint(i), ir2.IntPoint(i));
}
}
void
Tr1Darcy :: NodalAveragingRecoveryMI_computeNodalValue(FloatArray &answer, int node,
InternalStateType type, TimeStep *tStep)
{
GaussPoint *gp;
TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
gp = iRule->getIntegrationPoint(0);
mat->giveIPValue(answer, gp, type, tStep);
}
void
Quad1MindlinShell3D :: computeBodyLoadVectorAt(FloatArray &answer, Load *forLoad, TimeStep *stepN, ValueModeType mode)
{
// Only gravity load
double dV, density;
GaussPoint *gp;
FloatArray forceX, forceY, forceZ, glob_gravity, gravity, n;
if ( ( forLoad->giveBCGeoType() != BodyLoadBGT ) || ( forLoad->giveBCValType() != ForceLoadBVT ) ) {
_error("computeBodyLoadVectorAt: unknown load type");
}
// note: force is assumed to be in global coordinate system.
forLoad->computeComponentArrayAt(glob_gravity, stepN, mode);
// Transform the load into the local c.s.
gravity.beProductOf(this->lcsMatrix, glob_gravity); ///@todo Check potential transpose here.
if ( gravity.giveSize() ) {
IntegrationRule *ir = integrationRulesArray [ 0 ];
for ( int i = 0; i < ir->giveNumberOfIntegrationPoints(); ++i) {
gp = ir->getIntegrationPoint(i);
this->interp.evalN(n, *gp->giveCoordinates(), FEIVoidCellGeometry());
dV = this->computeVolumeAround(gp) * this->giveCrossSection()->give(CS_Thickness);
density = this->giveMaterial()->give('d', gp);
forceX.add(density * gravity.at(1) * dV, n);
forceY.add(density * gravity.at(2) * dV, n);
forceZ.add(density * gravity.at(3) * dV, n);
}
answer.resize(24);
answer.zero();
answer.at(1) = forceX.at(1);
answer.at(2) = forceY.at(1);
answer.at(3) = forceZ.at(1);
answer.at(7) = forceX.at(2);
answer.at(8) = forceY.at(2);
answer.at(9) = forceZ.at(2);
answer.at(13) = forceX.at(3);
answer.at(14) = forceY.at(3);
answer.at(15) = forceZ.at(3);
answer.at(19) = forceX.at(4);
answer.at(20) = forceY.at(4);
answer.at(21) = forceZ.at(4);
} else {
answer.resize(0);
}
}
IntegrationRule *
FEI3dWedgeLin :: giveIntegrationRule(int order)
{
IntegrationRule *iRule = new GaussIntegrationRule(1, NULL);
///@todo This function below isn't supported for wedges. We must decide how we should do this.
//int points = iRule->getRequiredNumberOfIntegrationPoints(_Wedge, order);
OOFEM_WARNING("Warning.. ignoring 'order' argument: FIXME");
int pointsZeta = 1;
int pointsTriangle = 1;
iRule->SetUpPointsOnWedge(pointsTriangle, pointsZeta, _Unknown);
return iRule;
}
void
NonlocalMaterialExtensionInterface :: manipulateWeight(double &weight, GaussPoint *gp, GaussPoint *jGp)
{
Element *ielem = jGp->giveElement();
IntegrationRule *iRule = ielem->giveDefaultIntegrationRulePtr();
if ( ielem->giveMaterial()->hasProperty(AVERAGING_TYPE, jGp) ) {
if ( ielem->giveMaterial()->give(AVERAGING_TYPE, jGp) == 1 ) {
weight = 1. / ( iRule->giveNumberOfIntegrationPoints() ); //assign the same weights over the whole element
}
}
}
void
CoupledFieldsElement :: computeStiffnessMatrixGen(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep,
void (*Nfunc)(GaussPoint*, FloatMatrix),
void (*Bfunc)(GaussPoint*, FloatMatrix),
void (*NStiffness)(FloatMatrix, MatResponseMode, GaussPoint*, TimeStep*),
void (*BStiffness)(FloatMatrix, MatResponseMode, GaussPoint*, TimeStep*),
double (*volumeAround)(GaussPoint*) )
{
FloatMatrix B, DB, N, DN, D_B, D_N;
IntegrationRule *iRule = this->giveIntegrationRule(0);
bool matStiffSymmFlag = this->giveCrossSection()->isCharacteristicMtrxSymmetric(rMode);
answer.resize(0,0);
for ( int j = 0; j < iRule->giveNumberOfIntegrationPoints(); j++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(j);
double dV = this->computeVolumeAround(gp);
// compute int_V ( N^t * D_N * N )dV
if ( NStiffness && Nfunc ) {
Nfunc(gp, N);
NStiffness(D_N, rMode, gp, tStep);
DN.beProductOf(D_N, N);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(N, DN, dV);
} else {
answer.plusProductUnsym(N, DN, dV);
}
}
// compute int_V ( B^t * D_B * B )dV
if ( BStiffness && Bfunc ) {
Bfunc(gp, B);
BStiffness(D_B, rMode, gp, tStep);
DB.beProductOf(D_B, B);
if ( matStiffSymmFlag ) {
answer.plusProductSymmUpper(B, DB, dV);
} else {
answer.plusProductUnsym(B, DB, dV);
}
}
}
if ( matStiffSymmFlag ) {
answer.symmetrized();
}
}
void Line2SurfaceTension :: computeLoadVector(FloatArray &answer, ValueModeType mode, TimeStep *tStep)
{
///@todo Support axisymm.
//domainType dt = this->giveDomain()->giveDomainType();
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
double t = 1, gamma_s;
///@todo Should i use this? Not used in FM module (but perhaps it should?) / Mikael.
//t = this->giveDomain()->giveCrossSection(1)->give(CS_Thickness);
gamma_s = this->giveMaterial()->give('g', NULL);
FloatMatrix xy(2, 3);
Node *node;
for ( int i = 1; i <= 3; i++ ) {
node = giveNode(i);
xy.at(1, i) = node->giveCoordinate(1);
xy.at(2, i) = node->giveCoordinate(2);
}
FloatArray A;
FloatArray dNdxi(3);
FloatArray es(2); // tangent vector to curve
FloatMatrix BJ(2, 6);
BJ.zero();
answer.resize(6);
answer.zero();
for ( int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(k);
//interpolation.evaldNdx(dN, domain, dofManArray, * gp->giveCoordinates(), 0.0);
double xi = gp->giveCoordinate(1);
// Some simplifications can be performed, since the mapping J is a scalar.
dNdxi.at(1) = -0.5 + xi;
dNdxi.at(2) = 0.5 + xi;
dNdxi.at(3) = -2.0 * xi;
es.beProductOf(xy, dNdxi);
double J = es.computeNorm();
es.times(1 / J); //es.normalize();
// dNds = dNdxi/J
// B.at(1,1) = dNds.at(1); and so on.
BJ.at(1, 1) = BJ.at(2, 2) = dNdxi.at(1);
BJ.at(1, 3) = BJ.at(2, 4) = dNdxi.at(2);
BJ.at(1, 5) = BJ.at(2, 6) = dNdxi.at(3);
A.beTProductOf(BJ, es);
answer.add( - gamma_s * t * gp->giveWeight(), A); // Note! Negative sign!
}
}
int
Lattice2d :: hasBeenUpdated()
{
LatticeMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
int updateFlag = 0;
updateFlag = status->hasBeenUpdated();
return updateFlag;
}
double
QTrPlaneStrain :: DirectErrorIndicatorRCI_giveCharacteristicSize() {
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp;
double volume = 0.0;
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
volume += this->computeVolumeAround(gp);
}
return sqrt( volume * 2.0 / this->giveCrossSection()->give(CS_Thickness) );
}
double
Lattice2d :: giveOldNormalStress()
{
LatticeMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double normalStress = 0;
normalStress = status->giveOldNormalStress();
return normalStress;
}
double
Lattice2d_mt :: givePressure()
{
LatticeTransportMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
Material *mat = this->giveMaterial();
status = ( LatticeTransportMaterialStatus * ) mat->giveStatus(gp);
return status->givePressure();
}
IntegrationRule *
FEI3dWedgeLin :: giveBoundaryIntegrationRule(int order, int boundary)
{
IntegrationRule *iRule = new GaussIntegrationRule(1, NULL);
if ( boundary <= 2 ) {
int points = iRule->getRequiredNumberOfIntegrationPoints(_Triangle, order + 0);
iRule->SetUpPointsOnTriangle(points, _Unknown);
} else {
int points = iRule->getRequiredNumberOfIntegrationPoints(_Square, order + 2);
iRule->SetUpPointsOnSquare(points, _Unknown);
}
return iRule;
}
double
Lattice2d :: giveOldCrackWidth()
{
LatticeMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double crackWidth = 0;
crackWidth = status->giveOldCrackWidth();
return crackWidth;
}
void Tr21Stokes :: computeInternalForcesVector(FloatArray &answer, TimeStep *tStep)
{
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FluidDynamicMaterial *mat = ( FluidDynamicMaterial * ) this->domain->giveMaterial(this->material);
FloatArray a_pressure, a_velocity, devStress, epsp, BTs, Nh, dNv(12);
double r_vol, pressure;
FloatMatrix dN, B(3, 12);
B.zero();
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, a_velocity);
this->computeVectorOf(EID_ConservationEquation, VM_Total, tStep, a_pressure);
FloatArray momentum(12), conservation(3);
momentum.zero();
conservation.zero();
GaussPoint *gp;
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
FloatArray *lcoords = gp->giveCoordinates();
double detJ = fabs(this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)));
this->interpolation_quad.evaldNdx(dN, * lcoords, FEIElementGeometryWrapper(this));
this->interpolation_lin.evalN(Nh, * lcoords, FEIElementGeometryWrapper(this));
double dA = detJ * gp->giveWeight();
for ( int j = 0, k = 0; j < 6; j++, k += 2 ) {
dNv(k) = B(0, k) = B(2, k + 1) = dN(j, 0);
dNv(k + 1) = B(1, k + 1) = B(2, k) = dN(j, 1);
}
pressure = Nh.dotProduct(a_pressure);
epsp.beProductOf(B, a_velocity);
mat->computeDeviatoricStressVector(devStress, r_vol, gp, epsp, pressure, tStep);
BTs.beTProductOf(B, devStress);
momentum.add(dA, BTs);
momentum.add(-pressure*dA, dNv);
conservation.add(r_vol*dA, Nh);
}
FloatArray temp(15);
temp.zero();
temp.addSubVector(momentum, 1);
temp.addSubVector(conservation, 13);
answer.resize(15);
answer.zero();
answer.assemble(temp, this->ordering);
}
void FluxFluxBoundary<D> ::
T_CalcElementMatrix (const FiniteElement & base_fel,
const ElementTransformation & eltrans,
FlatMatrix<SCAL> elmat,
LocalHeap & lh) const {
const CompoundFiniteElement & cfel // product space
= dynamic_cast<const CompoundFiniteElement&> (base_fel);
// This FE is already multiplied by normal:
const HDivNormalFiniteElement<D-1> & fel_q = // q.n space
dynamic_cast<const HDivNormalFiniteElement<D-1>&> (cfel[GetInd1()]);
const HDivNormalFiniteElement<D-1> & fel_r = // r.n space
dynamic_cast<const HDivNormalFiniteElement<D-1>&> (cfel[GetInd2()]);
elmat = SCAL(0.0);
IntRange rq = cfel.GetRange(GetInd1());
IntRange rr = cfel.GetRange(GetInd2());
int ndofq = rq.Size();
int ndofr = rr.Size();
FlatMatrix<SCAL> submat(ndofr, ndofq, lh);
submat = SCAL(0.0);
FlatVector<> qshape(fel_q.GetNDof(), lh);
FlatVector<> rshape(fel_r.GetNDof(), lh);
const IntegrationRule ir(fel_q.ElementType(),
fel_q.Order() + fel_r.Order());
for (int i = 0 ; i < ir.GetNIP(); i++) {
MappedIntegrationPoint<D-1,D> mip(ir[i], eltrans);
SCAL cc = coeff_c -> T_Evaluate<SCAL>(mip);
fel_r.CalcShape (ir[i], rshape);
fel_q.CalcShape (ir[i], qshape);
// mapped q.n-shape is simply reference q.n-shape / measure
qshape *= 1.0/mip.GetMeasure();
rshape *= 1.0/mip.GetMeasure();
// [ndofr x 1] [1 x ndofq]
submat += (cc*mip.GetWeight()) * rshape * Trans(qshape);
}
elmat.Rows(rr).Cols(rq) += submat;
if (GetInd1() != GetInd2())
elmat.Rows(rq).Cols(rr) += Conj(Trans(submat));
}
double
Lattice2d :: giveNormalStress()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double normalStress = 0;
normalStress = status->giveNormalStress();
return normalStress;
}
void IntElPoint :: drawScalar(oofegGraphicContext &gc, TimeStep *tStep)
{
int indx, result = 0;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
FloatArray gcoord(3), v1;
WCRec p [ 1 ];
GraphicObj *go;
double val [ 1 ];
if ( !gc.testElementGraphicActivity(this) ) {
return;
}
if ( gc.getInternalVarsDefGeoFlag() ) {
double defScale = gc.getDefScale();
p [ 0 ].x = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(1, tStep, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(1, tStep, defScale) );
p [ 0 ].y = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(2, tStep, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(2, tStep, defScale) );
p [ 0 ].z = ( FPNum ) 0.5 * ( this->giveNode(1)->giveUpdatedCoordinate(3, tStep, defScale) +
this->giveNode(2)->giveUpdatedCoordinate(3, tStep, defScale) );
} else {
p [ 0 ].x = ( FPNum ) ( this->giveNode(1)->giveCoordinate(1) );
p [ 0 ].y = ( FPNum ) ( this->giveNode(1)->giveCoordinate(2) );
p [ 0 ].z = ( FPNum ) ( this->giveNode(1)->giveCoordinate(3) );
}
result += giveIPValue(v1, iRule->getIntegrationPoint(0), gc.giveIntVarType(), tStep);
for ( GaussPoint *gp: *iRule ) {
result = 0;
result += giveIPValue(v1, gp, gc.giveIntVarType(), tStep);
if ( result != 1 ) {
continue;
}
indx = gc.giveIntVarIndx();
val [ 0 ] = v1.at(indx);
gc.updateFringeTableMinMax(val, 1);
EASValsSetLayer(OOFEG_VARPLOT_PATTERN_LAYER);
EASValsSetMType(FILLED_CIRCLE_MARKER);
go = CreateMarkerWD3D(p, val [ 0 ]);
EGWithMaskChangeAttributes(LAYER_MASK | FILL_MASK | MTYPE_MASK, go);
EMAddGraphicsToModel(ESIModel(), go);
//}
}
}
int
Lattice2d :: giveCrackFlag()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
int crackFlag = 0;
crackFlag = status->giveCrackFlag();
return crackFlag;
}
double
Lattice2d :: giveDeltaDissipation()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double deltaDissipation = 0;
deltaDissipation = status->giveDeltaDissipation();
return deltaDissipation;
}
double
Lattice2d :: giveCrackWidth()
{
LatticeMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeMaterialStatus * >( gp->giveMaterialStatus() );
double crackWidth = 0;
crackWidth = status->giveCrackWidth();
return crackWidth;
}
void IntegrationRule::DefineIntegrationRuleLine(IntegrationRule & integrationRule, int ruleOrder)
{
// we use a ready function, which provides a one-dimensional integration rule
Vector x, w;
GetIntegrationRule(x, w, ruleOrder);
integrationRule.integrationPoints.SetLen(x.Length());
for (int i = 1; i <= x.GetLen(); i++)
{
integrationRule.integrationPoints(i).x = x(i);
integrationRule.integrationPoints(i).y = 0.;
integrationRule.integrationPoints(i).z = 0.;
integrationRule.integrationPoints(i).weight = w(i);
}
}
int InverseElementTransformation::FindClosestPhysPoint(
const Vector& pt, const IntegrationRule &ir)
{
MFEM_VERIFY(T != NULL, "invalid ElementTransformation");
MFEM_VERIFY(pt.Size() == T->GetSpaceDim(), "invalid point");
DenseMatrix physPts;
T->Transform(ir, physPts);
// Initialize distance and index of closest point
int minIndex = -1;
double minDist = std::numeric_limits<double>::max();
// Check all integration points in ir
const int npts = ir.GetNPoints();
for (int i = 0; i < npts; ++i)
{
double dist = pt.DistanceTo(physPts.GetColumn(i));
if (dist < minDist)
{
minDist = dist;
minIndex = i;
}
}
return minIndex;
}
void ScalarFiniteElement<D> ::
CalcShape (const IntegrationRule & ir,
SliceMatrix<> shape) const
{
for (int i = 0; i < ir.Size(); i++)
CalcShape (ir[i], shape.Col(i));
}
double
Lattice2d_mt :: giveMass()
{
LatticeTransportMaterialStatus *status;
IntegrationRule *iRule = this->giveDefaultIntegrationRulePtr();
GaussPoint *gp = iRule->getIntegrationPoint(0);
status = static_cast< LatticeTransportMaterialStatus * >( gp->giveMaterialStatus() );
double mass = 0;
mass = status->giveMass();
//multiply with volume
mass *= this->length * this->width / 2.;
return mass;
}