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 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 :: 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
Lattice2d_mt :: updateInternalState(TimeStep *tStep)
// Updates the receiver at end of step.
{
FloatArray f, r;
FloatMatrix n;
TransportMaterial *mat = static_cast< TransportMaterial * >( this->giveMaterial() );
// force updating ip values
for ( auto &iRule: integrationRulesArray ) {
for ( GaussPoint *gp: *iRule ) {
this->computeNmatrixAt( n, gp->giveNaturalCoordinates() );
this->computeVectorOf({P_f}, VM_Total, tStep, r);
f.beProductOf(n, r);
mat->updateInternalState(f, gp, tStep);
}
}
}
// needed for CemhydMat
void
NonStationaryTransportProblem :: averageOverElements(TimeStep *tStep)
{
Domain *domain = this->giveDomain(1);
int ielem, i;
int nelem = domain->giveNumberOfElements();
double dV;
TransportElement *element;
IntegrationRule *iRule;
GaussPoint *gp;
FloatArray vecTemperature;
TransportMaterial *mat;
for ( ielem = 1; ielem <= nelem; ielem++ ) {
element = ( TransportElement * ) domain->giveElement(ielem);
mat = ( TransportMaterial * ) element->giveMaterial();
if ( mat->giveClassID() == CemhydMatClass ) {
iRule = element->giveDefaultIntegrationRulePtr();
for ( i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) {
gp = iRule->getIntegrationPoint(i);
dV = element->computeVolumeAround(gp);
element->giveIPValue(vecTemperature, gp, IST_Temperature, tStep);
//mat->IP_volume += dV;
//mat->average_temp += vecState.at(1) * dV;
}
}
}
for ( i = 1; i <= domain->giveNumberOfMaterialModels(); i++ ) {
mat = ( TransportMaterial * ) domain->giveMaterial(i);
if ( mat->giveClassID() == CemhydMatClass ) {
//mat->average_temp /= mat->IP_volume;
}
}
}
void
Lattice2d_mt :: updateInternalState(TimeStep *stepN)
// Updates the receiver at end of step.
{
int i, j;
IntegrationRule *iRule;
FloatArray f, r;
FloatMatrix n;
TransportMaterial *mat = ( ( TransportMaterial * ) this->giveMaterial() );
GaussPoint *gp;
// force updating ip values
for ( i = 0; i < numberOfIntegrationRules; i++ ) {
iRule = integrationRulesArray [ i ];
for ( j = 0; j < iRule->giveNumberOfIntegrationPoints(); j++ ) {
gp = iRule->getIntegrationPoint(j);
this->computeNmatrixAt( n, *gp->giveCoordinates() );
this->computeVectorOf(EID_ConservationEquation, VM_Total, stepN, r);
f.beProductOf(n, r);
mat->updateInternalState(f, gp, stepN);
}
}
}
