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); } } }