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);
//}
}
}
void Tr1Darcy :: computeInternalForcesVector(FloatArray &answer, TimeStep *atTime)
{
FloatArray *lcoords, w, a, gradP, I;
FloatMatrix BT;
GaussPoint *gp;
TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
this->computeVectorOf(EID_ConservationEquation, VM_Total, atTime, a);
answer.resize(3);
answer.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = this->interpolation_lin.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) );
this->interpolation_lin.evaldNdx( BT, * lcoords, FEIElementGeometryWrapper(this) );
gradP.beTProductOf(BT, a);
mat->giveFluxVector(w, gp, gradP, atTime);
I.beProductOf(BT, w);
answer.add(- gp->giveWeight() * detJ, I);
}
}
void Tr1Darcy :: computeStiffnessMatrix(FloatMatrix &answer, TimeStep *atTime)
{
/*
* Return Ke = integrate(B^T K B)
*/
FloatMatrix B, BT, K, KB;
FloatArray *lcoords;
GaussPoint *gp;
TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
answer.resize(3, 3);
answer.zero();
for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
double detJ = this->interpolation_lin.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) );
this->interpolation_lin.evaldNdx( BT, * lcoords, FEIElementGeometryWrapper(this) );
mat->giveCharacteristicMatrix(K, FullForm, TangentStiffness, gp, atTime);
B.beTranspositionOf(BT);
KB.beProductOf(K, B);
answer.plusProductUnsym(B, KB, detJ * gp->giveWeight() ); // Symmetric part is just a single value, not worth it.
}
}
void
LIBeam2dNL :: computeInitialStressMatrix(FloatMatrix &answer, TimeStep *tStep)
{
int i, j, n;
double dV;
GaussPoint *gp;
IntegrationRule *iRule;
FloatArray stress;
FloatMatrix A;
Material *mat = this->giveMaterial();
answer.resize(6, 6);
answer.zero();
iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
// assemble initial stress matrix
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = this->computeVolumeAround(gp);
stress = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveStressVector();
n = stress.giveSize();
if ( n ) {
for ( j = 1; j <= n; j++ ) {
// loop over each component of strain vector
this->computeNLBMatrixAt(A, gp, j);
if ( A.isNotEmpty() ) {
A.times(stress.at(j) * dV);
answer.add(A);
}
}
}
}
}
void
LIBeam3dNL :: giveInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
int i, j;
Material *mat = this->giveMaterial();
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
GaussPoint *gp = iRule->getIntegrationPoint(0);
FloatArray nm(6), TotalStressVector(6);
FloatMatrix x;
double s1, s2;
// update temp triad
this->updateTempTriad(tStep);
if ( useUpdatedGpRecord == 1 ) {
TotalStressVector = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )
->giveStressVector();
} else {
this->computeStressVector(TotalStressVector, gp, tStep);
}
for ( i = 1; i <= 3; i++ ) {
s1 = s2 = 0.0;
for ( j = 1; j <= 3; j++ ) {
s1 += tempTc.at(i, j) * TotalStressVector.at(j);
s2 += tempTc.at(i, j) * TotalStressVector.at(j + 3);
}
nm.at(i) = s1;
nm.at(i + 3) = s2;
}
this->computeXMtrx(x, tStep);
answer.beProductOf(x, nm);
}
void Tr21Stokes :: giveIntegratedVelocity(FloatMatrix &answer, TimeStep *tStep )
{
/*
* Integrate velocity over element
*/
IntegrationRule *iRule = integrationRulesArray [ 0 ];
FloatMatrix v, v_gamma, ThisAnswer, boundaryV, Nmatrix;
double detJ;
FloatArray *lcoords, N;
int i, j, k=0;
Dof *d;
GaussPoint *gp;
v.resize(12,1);
v.zero();
boundaryV.resize(2,1);
for (i=1; i<=this->giveNumberOfDofManagers(); i++) {
for (j=1; j<=this->giveDofManager(i)->giveNumberOfDofs(); j++) {
d = this->giveDofManager(i)->giveDof(j);
if ((d->giveDofID()==V_u) || (d->giveDofID()==V_v)) {
k=k+1;
v.at(k,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
/*} else if (d->giveDofID()==A_x) {
boundaryV.at(1,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);
} else if (d->giveDofID()==A_y) {
boundaryV.at(2,1)=d->giveUnknown(EID_ConservationEquation, VM_Total, tStep);*/
}
}
}
answer.resize(2,1);
answer.zero();
Nmatrix.resize(2,12);
for (i=0; i<iRule->getNumberOfIntegrationPoints(); i++) {
gp = iRule->getIntegrationPoint(i);
lcoords = gp->giveCoordinates();
this->interpolation_quad.evalN(N, *lcoords, FEIElementGeometryWrapper(this));
detJ = this->interpolation_quad.giveTransformationJacobian(*lcoords, FEIElementGeometryWrapper(this));
N.times(detJ*gp->giveWeight());
for (j=1; j<=6;j++) {
Nmatrix.at(1,j*2-1)=N.at(j);
Nmatrix.at(2,j*2)=N.at(j);
}
ThisAnswer.beProductOf(Nmatrix,v);
answer.add(ThisAnswer);
}
}
void Tr21Stokes :: computeBodyLoadVectorAt(FloatArray &answer, Load *load, TimeStep *tStep)
{
IntegrationRule *iRule = this->integrationRulesArray [ 0 ];
GaussPoint *gp;
FloatArray N, gVector, *lcoords, temparray(15);
double dA, detJ, rho;
load->computeComponentArrayAt(gVector, tStep, VM_Total);
temparray.zero();
if ( gVector.giveSize() ) {
for ( int k = 0; k < iRule->getNumberOfIntegrationPoints(); k++ ) {
gp = iRule->getIntegrationPoint(k);
lcoords = gp->giveCoordinates();
rho = this->giveMaterial()->giveCharacteristicValue(MRM_Density, gp, tStep);
detJ = fabs( this->interpolation_quad.giveTransformationJacobian(* lcoords, FEIElementGeometryWrapper(this)) );
dA = detJ * gp->giveWeight();
this->interpolation_quad.evalN(N, * lcoords, FEIElementGeometryWrapper(this));
for ( int j = 0; j < 6; j++ ) {
temparray(2 * j) += N(j) * rho * gVector(0) * dA;
temparray(2 * j + 1) += N(j) * rho * gVector(1) * dA;
}
}
}
answer.resize(15);
answer.zero();
answer.assemble( temparray, this->ordering );
}
void
Quad1MindlinShell3D :: giveInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord)
{
// We need to overload this for practical reasons (this 3d shell has all 9 dofs, but the shell part only cares for the first 8)
// This elements adds an additional stiffness for the so called drilling dofs, meaning we need to work with all 9 components.
FloatMatrix b, d;
FloatArray n, strain, stress;
FloatArray shellUnknowns(20), drillUnknowns(4), unknowns;
this->computeVectorOf(EID_MomentumBalance, VM_Total, tStep, unknowns);
// Split this for practical reasons into normal shell dofs and drilling dofs
for ( int i = 0; i < 4; ++i ) {
shellUnknowns(0 + i*5) = unknowns(0 + i*6);
shellUnknowns(1 + i*5) = unknowns(1 + i*6);
shellUnknowns(2 + i*5) = unknowns(2 + i*6);
shellUnknowns(3 + i*5) = unknowns(3 + i*6);
shellUnknowns(4 + i*5) = unknowns(4 + i*6);
drillUnknowns(i) = unknowns(5 + i*6);
}
FloatArray shellForces(20), drillMoment(4);
shellForces.zero();
drillMoment.zero();
StructuralCrossSection *cs = this->giveStructuralCrossSection();
double drillCoeff = cs->give(CS_DrillingStiffness);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
for ( int i = 0; i < iRule->giveNumberOfIntegrationPoints(); i++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(i);
this->computeBmatrixAt(gp, b);
double dV = this->computeVolumeAround(gp);
if ( useUpdatedGpRecord ) {
stress = static_cast< StructuralMaterialStatus * >( this->giveMaterial()->giveStatus(gp) )->giveStressVector();
} else {
strain.beProductOf(b, shellUnknowns);
cs->giveRealStress_Shell(stress, gp, strain, tStep);
}
shellForces.plusProduct(b, stress, dV);
// Drilling stiffness is here for improved numerical properties
if (drillCoeff > 0.) {
this->interp.evalN(n, *gp->giveCoordinates(), FEIVoidCellGeometry());
for ( int j = 0; j < 4; j++) {
n(j) -= 0.25;
}
double dtheta = n.dotProduct(drillUnknowns);
drillMoment.add(drillCoeff * dV * dtheta, n); ///@todo Decide on how to alpha should be defined.
}
}
answer.resize(24);
answer.zero();
answer.assemble(shellForces, this->shellOrdering);
if (drillCoeff > 0.) {
answer.assemble(drillMoment, this->drillOrdering);
}
}
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);
}
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
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);
}
}
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!
}
}
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();
}
}
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();
}
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;
}
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
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);
}
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;
}
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);
//}
}
}
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;
}
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 :: 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;
}
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;
}
void
ErrorCheckingExportModule :: writeCheck(Domain *domain, TimeStep *tStep)
{
if ( tStep->isTheFirstStep() ) {
std :: cout << "#%BEGIN_CHECK% tolerance 1.e-3\n";
}
for ( auto &dman : domain->giveDofManagers() ) {
for ( Dof *dof: *dman ) {
if ( dof->giveEqn() < 0 ) {
continue;
}
std :: cout << "#NODE tStep " << tStep->giveNumber();
std :: cout << " number " << dman->giveNumber();
std :: cout << " dof " << dof->giveDofID();
std :: cout << " unknown " << 'd';
std :: cout << " value " << dof->giveUnknown(VM_Total, tStep);
std :: cout << std :: endl;
}
}
for ( auto &element : domain->giveElements() ) {
IntegrationRule *iRule = element->giveDefaultIntegrationRulePtr();
FloatArray ipval;
for ( int ist: this->writeIST ) {
for ( int gpnum = 0; gpnum < iRule->giveNumberOfIntegrationPoints(); ++gpnum ) {
GaussPoint *gp = iRule->getIntegrationPoint(gpnum);
element->giveIPValue(ipval, gp, (InternalStateType)ist, tStep);
for ( int component = 1; component <= ipval.giveSize(); ++component ) {
std :: cout << "#ELEMENT tStep " << tStep->giveNumber();
std :: cout << " number " << element->giveNumber();
std :: cout << " gp " << gpnum+1;
std :: cout << " keyword " << ist; ///@note This writes IST number and not "stresses"
std :: cout << " component " << component;
std :: cout << " value " << ipval.at(component);
std :: cout << std :: endl;
}
}
}
}
if ( !tStep->isNotTheLastStep() ) {
std :: cout << "#%END_CHECK%" << std :: endl;
}
}
void
Lattice2d_mt :: computeCapacityMatrix(FloatMatrix &answer, TimeStep *tStep)
{
double dV, c;
FloatMatrix n;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ 0 ];
gp = iRule->getIntegrationPoint(0);
answer.resize(2, 2);
answer.zero();
answer.at(1, 1) = 2.;
answer.at(1, 2) = 1.;
answer.at(2, 1) = 1.;
answer.at(2, 2) = 2.;
c = static_cast< TransportMaterial * >( this->giveMaterial() )->giveCharacteristicValue(Capacity, gp, tStep);
dV = this->computeVolumeAround(gp) / ( 6.0 * this->dimension );
answer.times(c * dV);
}
double
Lattice2d_mt :: giveMass()
{
LatticeTransportMaterialStatus *status;
GaussPoint *gp;
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
gp = iRule->getIntegrationPoint(0);
Material *mat = this->giveMaterial();
status = ( LatticeTransportMaterialStatus * ) mat->giveStatus(gp);
double mass = 0;
mass = status->giveMass();
//multiply with volume
mass *= this->length * this->width / 2.;
return mass;
}
void
Quad1MindlinShell3D :: computeStiffnessMatrix(FloatMatrix &answer, MatResponseMode rMode, TimeStep *tStep)
{
// We need to overload this for practical reasons (this 3d shell has all 9 dofs, but the shell part only cares for the first 8)
// This elements adds an additional stiffness for the so called drilling dofs, meaning we need to work with all 9 components.
FloatMatrix d, b, db;
FloatArray n;
FloatMatrix shellStiffness(20, 20), drillStiffness(4, 4);
shellStiffness.zero();
drillStiffness.zero();
double drillCoeff = this->giveStructuralCrossSection()->give(CS_DrillingStiffness);
IntegrationRule *iRule = integrationRulesArray [ 0 ];
for ( int i = 0; i < iRule->giveNumberOfIntegrationPoints(); i++ ) {
GaussPoint *gp = iRule->getIntegrationPoint(i);
this->computeBmatrixAt(gp, b);
double dV = this->computeVolumeAround(gp);
this->computeConstitutiveMatrixAt(d, rMode, gp, tStep);
db.beProductOf(d, b);
shellStiffness.plusProductSymmUpper(b, db, dV);
// Drilling stiffness is here for improved numerical properties
if (drillCoeff > 0.) {
this->interp.evalN(n, *gp->giveCoordinates(), FEIVoidCellGeometry());
for ( int j = 0; j < 4; j++) {
n(j) -= 0.25;
}
drillStiffness.plusDyadSymmUpper(n, drillCoeff * dV);
}
}
shellStiffness.symmetrized();
answer.resize(24, 24);
answer.zero();
answer.assemble(shellStiffness, this->shellOrdering);
if (drillCoeff > 0.) {
drillStiffness.symmetrized();
answer.assemble(drillStiffness, this->drillOrdering);
}
}
void
LIBeam3dNL :: computeTempCurv(FloatArray &answer, TimeStep *tStep)
{
Material *mat = this->giveMaterial();
IntegrationRule *iRule = integrationRulesArray [ giveDefaultIntegrationRule() ];
GaussPoint *gp = iRule->getIntegrationPoint(0);
;
FloatArray ui(3), xd(3), curv(3), ac(3), PrevEpsilon;
FloatMatrix sc(3, 3), tmid(3, 3);
answer.resize(3);
// update curvature at midpoint
// first, compute Tmid
// ask increments
this->computeVectorOf(EID_MomentumBalance, VM_Incremental, tStep, ui);
ac.at(1) = 0.5 * ( ui.at(10) - ui.at(4) );
ac.at(2) = 0.5 * ( ui.at(11) - ui.at(5) );
ac.at(3) = 0.5 * ( ui.at(12) - ui.at(6) );
this->computeSMtrx(sc, ac);
sc.times(1. / 2.);
// compute I+sc
sc.at(1, 1) += 1.0;
sc.at(2, 2) += 1.0;
sc.at(3, 3) += 1.0;
tmid.beProductOf(sc, this->tc);
// update curvature at centre
ac.at(1) = ( ui.at(10) - ui.at(4) );
ac.at(2) = ( ui.at(11) - ui.at(5) );
ac.at(3) = ( ui.at(12) - ui.at(6) );
answer.beTProductOf(tmid, ac);
answer.times(1 / this->l0);
// ask for previous kappa
PrevEpsilon = ( ( StructuralMaterialStatus * ) mat->giveStatus(gp) )->giveStrainVector();
if ( PrevEpsilon.giveSize() ) {
answer.at(1) += PrevEpsilon.at(4);
answer.at(2) += PrevEpsilon.at(5);
answer.at(3) += PrevEpsilon.at(6);
}
}
