OGS
ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim > Class Template Reference

Detailed Description

template<typename ShapeFunction, int GlobalDim>
class ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >

Definition at line 206 of file ComponentTransportFEM.h.

#include <ComponentTransportFEM.h>

Inheritance diagram for ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >:
[legend]
Collaboration diagram for ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >:
[legend]

Public Member Functions

 LocalAssemblerData (MeshLib::Element const &element, std::size_t const local_matrix_size, NumLib::GenericIntegrationMethod const &integration_method, bool is_axially_symmetric, ComponentTransportProcessData const &process_data, std::vector< std::reference_wrapper< ProcessVariable > > const &transport_process_variables)
void setChemicalSystemID (std::size_t const) override
void initializeChemicalSystemConcrete (Eigen::VectorXd const &local_x, double const t) override
void setChemicalSystemConcrete (Eigen::VectorXd const &local_x, double const t, double dt) override
void postSpeciationCalculation (std::size_t const ele_id, double const t, double const dt) override
void assemble (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data) override
void assembleBlockMatrices (GlobalDimVectorType const &b, int const component_id, double const t, double const dt, Eigen::Ref< const NodalVectorType > const &C_nodal_values, Eigen::Ref< const NodalVectorType > const &p_nodal_values, Eigen::Ref< LocalBlockMatrixType > KCC, Eigen::Ref< LocalBlockMatrixType > MCC, Eigen::Ref< LocalBlockMatrixType > MCp, Eigen::Ref< LocalBlockMatrixType > MpC, Eigen::Ref< LocalBlockMatrixType > Kpp, Eigen::Ref< LocalBlockMatrixType > Mpp, Eigen::Ref< LocalSegmentVectorType > Bp)
void assembleKCmCn (int const component_id, double const t, double const dt, Eigen::Ref< LocalBlockMatrixType > KCmCn, double const stoichiometric_coefficient, double const kinetic_prefactor)
void assembleForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data) override
void assembleHydraulicEquation (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
void assembleHeatTransportEquation (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &)
void assembleComponentTransportEquation (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &, int const transport_process_id)
void assembleWithJacobianForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, int const process_id, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data) override
void assembleWithJacobianHydraulicEquation (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
void assembleWithJacobianComponentTransportEquation (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data, int const component_id)
void assembleReactionEquationConcrete (double const t, double const dt, Eigen::VectorXd const &local_x, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data, int const transport_process_id) override
std::vector< double > const & getIntPtDarcyVelocity (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::vector< double > &cache) const override
std::vector< double > const & calculateIntPtDarcyVelocity (const double t, Eigen::Ref< const NodalVectorType > const &p_nodal_values, Eigen::Ref< const NodalVectorType > const &C_nodal_values, Eigen::Ref< const NodalVectorType > const &T_nodal_values, std::vector< double > &cache) const
Eigen::Map< const Eigen::RowVectorXd > getShapeMatrix (const unsigned integration_point) const override
 Provides the shape matrix at the given integration point.
Eigen::Vector3d getFlux (MathLib::Point3d const &pnt_local_coords, double const t, std::vector< double > const &local_x) const override
void computeSecondaryVariableConcrete (double const t, double const, Eigen::VectorXd const &local_x, Eigen::VectorXd const &) override
void computeReactionRelatedSecondaryVariable (std::size_t const ele_id) override
std::vector< double > const & getIntPtMolarFlux (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< double > &cache, int const component_id) const override
void postTimestepConcrete (Eigen::VectorXd const &, Eigen::VectorXd const &, double const, double const, int const) override
Public Member Functions inherited from ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface
 ComponentTransportLocalAssemblerInterface ()=default
void initializeChemicalSystem (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t)
void setChemicalSystem (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, double const dt)
void assembleReactionEquation (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, double const dt, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, int const process_id)
Public Member Functions inherited from ProcessLib::LocalAssemblerInterface
virtual ~LocalAssemblerInterface ()=default
virtual void setInitialConditions (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, int const process_id)
virtual void initialize (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)
virtual void preAssemble (double const, double const, std::vector< double > const &)
virtual void assembleWithJacobian (double const t, double const dt, std::vector< double > const &local_x, std::vector< double > const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
virtual void computeSecondaryVariable (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id)
virtual void preTimestep (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double const t, double const delta_t)
virtual void postTimestep (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
void postNonLinearSolver (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, double const t, double const dt, int const process_id)
virtual Eigen::Vector3d getFlux (MathLib::Point3d const &, double const, std::vector< std::vector< double > > const &) const
 Fits to staggered scheme.
virtual std::optional< VectorSegment > getVectorDeformationSegment () const
Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual ~ExtrapolatableElement ()=default

Private Types

using ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>
using ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
using LocalBlockMatrixType
using LocalSegmentVectorType
using LocalMatrixType
using LocalVectorType = Eigen::Matrix<double, Eigen::Dynamic, 1>
using NodalVectorType = typename ShapeMatricesType::NodalVectorType
using NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType
using GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType
using GlobalDimNodalMatrixType
using GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType

Private Member Functions

double getHeatEnergyCoefficient (MaterialPropertyLib::VariableArray const &vars, const double porosity, const double fluid_density, const double specific_heat_capacity_fluid, ParameterLib::SpatialPosition const &pos, double const t, double const dt)
GlobalDimMatrixType getThermalConductivityDispersivity (MaterialPropertyLib::VariableArray const &vars, const double fluid_density, const double specific_heat_capacity_fluid, const GlobalDimVectorType &velocity, ParameterLib::SpatialPosition const &pos, double const t, double const dt)
NodalVectorType getLocalTemperature (double const t, Eigen::VectorXd const &local_x) const

Private Attributes

const int temperature_index = -1
const int first_concentration_index = -1
MeshLib::Element const & _element
ComponentTransportProcessData const & _process_data
NumLib::GenericIntegrationMethod const & _integration_method
std::vector< std::reference_wrapper< ProcessVariable > > const _transport_process_variables
std::vector< IntegrationPointData< GlobalDimNodalMatrixType > > _ip_data

Static Private Attributes

static const int pressure_index = 0
static const int pressure_size = ShapeFunction::NPOINTS
static const int temperature_size = ShapeFunction::NPOINTS
static const int concentration_size

Member Typedef Documentation

◆ GlobalDimMatrixType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::GlobalDimMatrixType = typename ShapeMatricesType::GlobalDimMatrixType
private

Definition at line 238 of file ComponentTransportFEM.h.

◆ GlobalDimNodalMatrixType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::GlobalDimNodalMatrixType
private
Initial value:
typename ShapeMatricesType::GlobalDimNodalMatrixType
EigenFixedShapeMatrixPolicy::GlobalDimNodalMatrixType
MatrixType< GlobalDim, ShapeFunction::NPOINTS > GlobalDimNodalMatrixType
Definition ShapeMatrixPolicy.h:82

Definition at line 236 of file ComponentTransportFEM.h.

◆ GlobalDimVectorType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType
private

Definition at line 235 of file ComponentTransportFEM.h.

◆ LocalBlockMatrixType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalBlockMatrixType
private
Initial value:
typename ShapeMatricesType::template MatrixType<pressure_size,
pressure_size>

Definition at line 222 of file ComponentTransportFEM.h.

◆ LocalMatrixType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalMatrixType
private
Initial value:
Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>

Definition at line 228 of file ComponentTransportFEM.h.

◆ LocalSegmentVectorType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalSegmentVectorType
private
Initial value:
typename ShapeMatricesType::template VectorType<pressure_size>

Definition at line 225 of file ComponentTransportFEM.h.

◆ LocalVectorType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalVectorType = Eigen::Matrix<double, Eigen::Dynamic, 1>
private

Definition at line 230 of file ComponentTransportFEM.h.

◆ NodalRowVectorType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::NodalRowVectorType = typename ShapeMatricesType::NodalRowVectorType
private

Definition at line 233 of file ComponentTransportFEM.h.

◆ NodalVectorType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType
private

Definition at line 232 of file ComponentTransportFEM.h.

◆ ShapeMatrices

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
private

Definition at line 220 of file ComponentTransportFEM.h.

◆ ShapeMatricesType

template<typename ShapeFunction, int GlobalDim>
using ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, GlobalDim>
private

Definition at line 219 of file ComponentTransportFEM.h.

Constructor & Destructor Documentation

◆ LocalAssemblerData()

template<typename ShapeFunction, int GlobalDim>
ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::LocalAssemblerData ( MeshLib::Element const & element,
std::size_t const local_matrix_size,
NumLib::GenericIntegrationMethod const & integration_method,
bool is_axially_symmetric,
ComponentTransportProcessData const & process_data,
std::vector< std::reference_wrapper< ProcessVariable > > const & transport_process_variables )
inline

Definition at line 241 of file ComponentTransportFEM.h.

249 : temperature_index(process_data.isothermal ? -1
250 : ShapeFunction::NPOINTS),
251 first_concentration_index(process_data.isothermal
252 ? ShapeFunction::NPOINTS
253 : 2 * ShapeFunction::NPOINTS),
254 _element(element),
255 _process_data(process_data),
256 _integration_method(integration_method),
257 _transport_process_variables(transport_process_variables)
258 {
259 (void)local_matrix_size;
260
261 unsigned const n_integration_points =
262 _integration_method.getNumberOfPoints();
263 _ip_data.reserve(n_integration_points);
264
265 ParameterLib::SpatialPosition pos;
266 pos.setElementID(_element.getID());
267
268 double const aperture_size = _process_data.aperture_size(0.0, pos)[0];
269
270 auto const shape_matrices =
271 NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
272 GlobalDim>(element, is_axially_symmetric,
273 _integration_method);
274 auto const& medium =
275 *_process_data.media_map.getMedium(_element.getID());
276 for (unsigned ip = 0; ip < n_integration_points; ip++)
277 {
278 _ip_data.emplace_back(
279 shape_matrices[ip].dNdx,
280 _integration_method.getWeightedPoint(ip).getWeight() *
281 shape_matrices[ip].integralMeasure *
282 shape_matrices[ip].detJ * aperture_size);
283
284 _ip_data[ip].porosity =
285 medium[MaterialPropertyLib::PropertyType::porosity]
286 .template initialValue<double>(
287 pos, std::numeric_limits<double>::quiet_NaN() /*t*/);
288
289 _ip_data[ip].pushBackState();
290 }
291 }
ProcessLib::ComponentTransport::LocalAssemblerData::_integration_method
NumLib::GenericIntegrationMethod const & _integration_method
Definition ComponentTransportFEM.h:2066
ProcessLib::ComponentTransport::LocalAssemblerData::_ip_data
std::vector< IntegrationPointData< GlobalDimNodalMatrixType > > _ip_data
Definition ComponentTransportFEM.h:2070
ProcessLib::ComponentTransport::LocalAssemblerData::_process_data
ComponentTransportProcessData const & _process_data
Definition ComponentTransportFEM.h:2064
ProcessLib::ComponentTransport::LocalAssemblerData::ShapeMatricesType
ShapeMatrixPolicyType< ShapeFunction, GlobalDim > ShapeMatricesType
Definition ComponentTransportFEM.h:219
ProcessLib::ComponentTransport::LocalAssemblerData::_transport_process_variables
std::vector< std::reference_wrapper< ProcessVariable > > const _transport_process_variables
Definition ComponentTransportFEM.h:2068

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, first_concentration_index, NumLib::initShapeMatrices(), MaterialPropertyLib::porosity, ParameterLib::SpatialPosition::setElementID(), and temperature_index.

Member Function Documentation

◆ assemble()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assemble ( double const t,
double const dt,
std::vector< double > const & local_x,
std::vector< double > const & ,
std::vector< double > & local_M_data,
std::vector< double > & local_K_data,
std::vector< double > & local_b_data )
inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 458 of file ComponentTransportFEM.h.

464 {
465 auto const local_matrix_size = local_x.size();
466 // Nodal DOFs include pressure
467 int const num_nodal_dof = 1 + _transport_process_variables.size();
468 // This assertion is valid only if all nodal d.o.f. use the same shape
469 // matrices.
470 assert(local_matrix_size == ShapeFunction::NPOINTS * num_nodal_dof);
471
472 auto local_M = MathLib::createZeroedMatrix<LocalMatrixType>(
473 local_M_data, local_matrix_size, local_matrix_size);
474 auto local_K = MathLib::createZeroedMatrix<LocalMatrixType>(
475 local_K_data, local_matrix_size, local_matrix_size);
476 auto local_b = MathLib::createZeroedVector<LocalVectorType>(
477 local_b_data, local_matrix_size);
478
479 // Get block matrices
480 auto Kpp = local_K.template block<pressure_size, pressure_size>(
481 pressure_index, pressure_index);
482 auto Mpp = local_M.template block<pressure_size, pressure_size>(
483 pressure_index, pressure_index);
484 auto Bp = local_b.template segment<pressure_size>(pressure_index);
485
486 auto local_p = Eigen::Map<const NodalVectorType>(
487 &local_x[pressure_index], pressure_size);
488
489 auto const& b =
490 _process_data
491 .projected_specific_body_force_vectors[_element.getID()];
492
493 auto const number_of_components = num_nodal_dof - 1;
494 for (int component_id = 0; component_id < number_of_components;
495 ++component_id)
496 {
497 /* Partitioned assembler matrix
498 * | pp | pc1 | pc2 | pc3 |
499 * |-----|-----|-----|-----|
500 * | c1p | c1c1| 0 | 0 |
501 * |-----|-----|-----|-----|
502 * | c2p | 0 | c2c2| 0 |
503 * |-----|-----|-----|-----|
504 * | c3p | 0 | 0 | c3c3|
505 */
506 auto concentration_index =
507 pressure_size + component_id * concentration_size;
508
509 auto KCC =
510 local_K.template block<concentration_size, concentration_size>(
511 concentration_index, concentration_index);
512 auto MCC =
513 local_M.template block<concentration_size, concentration_size>(
514 concentration_index, concentration_index);
515 auto MCp =
516 local_M.template block<concentration_size, pressure_size>(
517 concentration_index, pressure_index);
518 auto MpC =
519 local_M.template block<pressure_size, concentration_size>(
520 pressure_index, concentration_index);
521
522 auto local_C = Eigen::Map<const NodalVectorType>(
523 &local_x[concentration_index], concentration_size);
524
525 assembleBlockMatrices(b, component_id, t, dt, local_C, local_p, KCC,
526 MCC, MCp, MpC, Kpp, Mpp, Bp);
527
528 if (_process_data.chemical_solver_interface)
529 {
530 auto const stoichiometric_matrix =
531 _process_data.chemical_solver_interface
532 ->getStoichiometricMatrix();
533
534 assert(stoichiometric_matrix);
535
536 for (Eigen::SparseMatrix<double>::InnerIterator it(
537 *stoichiometric_matrix, component_id);
538 it;
539 ++it)
540 {
541 auto const stoichiometric_coefficient = it.value();
542 auto const coupled_component_id = it.row();
543 auto const kinetic_prefactor =
544 _process_data.chemical_solver_interface
545 ->getKineticPrefactor(coupled_component_id);
546
547 auto const concentration_index =
548 pressure_size + component_id * concentration_size;
549 auto const coupled_concentration_index =
550 pressure_size +
551 coupled_component_id * concentration_size;
552 auto KCmCn = local_K.template block<concentration_size,
553 concentration_size>(
554 concentration_index, coupled_concentration_index);
555
556 // account for the coupling between components
557 assembleKCmCn(component_id, t, dt, KCmCn,
558 stoichiometric_coefficient,
559 kinetic_prefactor);
560 }
561 }
562 }
563 }
ProcessLib::ComponentTransport::LocalAssemblerData::assembleBlockMatrices
void assembleBlockMatrices(GlobalDimVectorType const &b, int const component_id, double const t, double const dt, Eigen::Ref< const NodalVectorType > const &C_nodal_values, Eigen::Ref< const NodalVectorType > const &p_nodal_values, Eigen::Ref< LocalBlockMatrixType > KCC, Eigen::Ref< LocalBlockMatrixType > MCC, Eigen::Ref< LocalBlockMatrixType > MCp, Eigen::Ref< LocalBlockMatrixType > MpC, Eigen::Ref< LocalBlockMatrixType > Kpp, Eigen::Ref< LocalBlockMatrixType > Mpp, Eigen::Ref< LocalSegmentVectorType > Bp)
Definition ComponentTransportFEM.h:565
ProcessLib::ComponentTransport::LocalAssemblerData::assembleKCmCn
void assembleKCmCn(int const component_id, double const t, double const dt, Eigen::Ref< LocalBlockMatrixType > KCmCn, double const stoichiometric_coefficient, double const kinetic_prefactor)
Definition ComponentTransportFEM.h:758
MathLib::createZeroedVector
Eigen::Map< Vector > createZeroedVector(std::vector< double > &data, Eigen::VectorXd::Index size)
Definition EigenMapTools.h:153
MathLib::createZeroedMatrix
Eigen::Map< Matrix > createZeroedMatrix(std::vector< double > &data, Eigen::MatrixXd::Index rows, Eigen::MatrixXd::Index cols)
Definition EigenMapTools.h:32

References _element, _process_data, _transport_process_variables, assembleBlockMatrices(), assembleKCmCn(), concentration_size, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), pressure_index, and pressure_size.

◆ assembleBlockMatrices()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleBlockMatrices ( GlobalDimVectorType const & b,
int const component_id,
double const t,
double const dt,
Eigen::Ref< const NodalVectorType > const & C_nodal_values,
Eigen::Ref< const NodalVectorType > const & p_nodal_values,
Eigen::Ref< LocalBlockMatrixType > KCC,
Eigen::Ref< LocalBlockMatrixType > MCC,
Eigen::Ref< LocalBlockMatrixType > MCp,
Eigen::Ref< LocalBlockMatrixType > MpC,
Eigen::Ref< LocalBlockMatrixType > Kpp,
Eigen::Ref< LocalBlockMatrixType > Mpp,
Eigen::Ref< LocalSegmentVectorType > Bp )
inline

Definition at line 565 of file ComponentTransportFEM.h.

577 {
578 unsigned const n_integration_points =
579 _integration_method.getNumberOfPoints();
580
581 ParameterLib::SpatialPosition pos;
582 pos.setElementID(_element.getID());
583
584 MaterialPropertyLib::VariableArray vars;
585
586 // Get material properties
587 auto const& medium =
588 *_process_data.media_map.getMedium(_element.getID());
589 // Select the only valid for component transport liquid phase.
590 auto const& phase = medium.phase("AqueousLiquid");
591
592 // Assume that the component name is the same as the process variable
593 // name. Components are shifted by one because the first one is always
594 // pressure.
595 auto const& component = phase.component(
596 _transport_process_variables[component_id].get().getName());
597
598 LocalBlockMatrixType KCC_Laplacian =
599 LocalBlockMatrixType::Zero(concentration_size, concentration_size);
600
601 std::vector<GlobalDimVectorType> ip_flux_vector;
602 double average_velocity_norm = 0.0;
603 if (!_process_data.non_advective_form)
604 {
605 ip_flux_vector.reserve(n_integration_points);
606 }
607
608 auto const& Ns =
609 _process_data.shape_matrix_cache
610 .NsHigherOrder<typename ShapeFunction::MeshElement>();
611
612 for (unsigned ip(0); ip < n_integration_points; ++ip)
613 {
614 auto& ip_data = _ip_data[ip];
615 auto const& dNdx = ip_data.dNdx;
616 auto const& N = Ns[ip];
617 auto const& w = ip_data.integration_weight;
618 auto& porosity = ip_data.porosity;
619
620 double C_int_pt = 0.0;
621 double p_int_pt = 0.0;
622
623 NumLib::shapeFunctionInterpolate(C_nodal_values, N, C_int_pt);
624 NumLib::shapeFunctionInterpolate(p_nodal_values, N, p_int_pt);
625
626 // set position with N as the shape matrix at the current
627 // integration point
628 pos.setCoordinates(MathLib::Point3d(
629 NumLib::interpolateCoordinates<ShapeFunction,
630 ShapeMatricesType>(_element,
631 N)));
632
633 vars.concentration = C_int_pt;
634 vars.liquid_phase_pressure = p_int_pt;
635
636 // update according to a particular porosity model
637 porosity = medium[MaterialPropertyLib::PropertyType::porosity]
638 .template value<double>(vars, pos, t, dt);
639 vars.porosity = porosity;
640
641 auto const& retardation_factor =
642 component[MaterialPropertyLib::PropertyType::retardation_factor]
643 .template value<double>(vars, pos, t, dt);
644
645 auto const& solute_dispersivity_transverse = medium.template value<
646 double>(
647 MaterialPropertyLib::PropertyType::transversal_dispersivity);
648
649 auto const& solute_dispersivity_longitudinal =
650 medium.template value<double>(
651 MaterialPropertyLib::PropertyType::
652 longitudinal_dispersivity);
653
654 // Use the fluid density model to compute the density
655 // TODO (renchao): concentration of which component as the argument
656 // for calculation of fluid density
657 auto const density =
658 phase[MaterialPropertyLib::PropertyType::density]
659 .template value<double>(vars, pos, t, dt);
660
661 auto const decay_rate =
662 component[MaterialPropertyLib::PropertyType::decay_rate]
663 .template value<double>(vars, pos, t, dt);
664
665 auto const& pore_diffusion_coefficient =
666 MaterialPropertyLib::formEigenTensor<GlobalDim>(
667 component[MaterialPropertyLib::PropertyType::pore_diffusion]
668 .value(vars, pos, t, dt));
669
670 auto const& K = MaterialPropertyLib::formEigenTensor<GlobalDim>(
671 medium[MaterialPropertyLib::PropertyType::permeability].value(
672 vars, pos, t, dt));
673
674 // Use the viscosity model to compute the viscosity
675 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
676 .template value<double>(vars, pos, t, dt);
677
678 GlobalDimMatrixType const K_over_mu = K / mu;
679 GlobalDimVectorType const velocity =
680 _process_data.has_gravity
681 ? GlobalDimVectorType(-K_over_mu *
682 (dNdx * p_nodal_values - density * b))
683 : GlobalDimVectorType(-K_over_mu * dNdx * p_nodal_values);
684
685 const double drho_dp =
686 phase[MaterialPropertyLib::PropertyType::density]
687 .template dValue<double>(
688 vars,
689 MaterialPropertyLib::Variable::liquid_phase_pressure,
690 pos, t, dt);
691
692 const double drho_dC =
693 phase[MaterialPropertyLib::PropertyType::density]
694 .template dValue<double>(
695 vars, MaterialPropertyLib::Variable::concentration, pos,
696 t, dt);
697
698 GlobalDimMatrixType const hydrodynamic_dispersion =
699 NumLib::computeHydrodynamicDispersion(
700 _process_data.stabilizer, _element.getID(),
701 pore_diffusion_coefficient, velocity, porosity,
702 solute_dispersivity_transverse,
703 solute_dispersivity_longitudinal);
704
705 const double R_times_phi(retardation_factor * porosity);
706 GlobalDimVectorType const mass_density_flow = velocity * density;
707 auto const N_t_N = (N.transpose() * N).eval();
708
709 if (_process_data.non_advective_form)
710 {
711 MCp.noalias() += N_t_N * (C_int_pt * R_times_phi * drho_dp * w);
712 MCC.noalias() += N_t_N * (C_int_pt * R_times_phi * drho_dC * w);
713 KCC.noalias() -= dNdx.transpose() * mass_density_flow * N * w;
714 }
715 else
716 {
717 ip_flux_vector.emplace_back(mass_density_flow);
718 average_velocity_norm += velocity.norm();
719 }
720 MCC.noalias() += N_t_N * (R_times_phi * density * w);
721 KCC.noalias() += N_t_N * (decay_rate * R_times_phi * density * w);
722 KCC_Laplacian.noalias() +=
723 dNdx.transpose() * hydrodynamic_dispersion * dNdx * density * w;
724
725 MpC.noalias() += N_t_N * (porosity * drho_dC * w);
726
727 // Calculate Mpp, Kpp, and bp in the first loop over components
728 if (component_id == 0)
729 {
730 Mpp.noalias() += N_t_N * (porosity * drho_dp * w);
731 Kpp.noalias() +=
732 dNdx.transpose() * K_over_mu * dNdx * (density * w);
733
734 if (_process_data.has_gravity)
735 {
736 Bp.noalias() += dNdx.transpose() * K_over_mu * b *
737 (density * density * w);
738 }
739 }
740 }
741
742 if (!_process_data.non_advective_form)
743 {
744 NumLib::assembleAdvectionMatrix<
745 typename ShapeFunction::MeshElement>(
746 _process_data.stabilizer,
747 _ip_data,
748 _process_data.shape_matrix_cache,
749 ip_flux_vector,
750 average_velocity_norm /
751 static_cast<double>(n_integration_points),
752 KCC_Laplacian);
753 }
754
755 KCC.noalias() += KCC_Laplacian;
756 }
getName
std::string getName(std::string const &line)
Returns the name/title from the "Zone"-description.
Definition TecPlotTools.cpp:62
ProcessLib::ComponentTransport::LocalAssemblerData::GlobalDimVectorType
typename ShapeMatricesType::GlobalDimVectorType GlobalDimVectorType
Definition ComponentTransportFEM.h:235
ProcessLib::ComponentTransport::LocalAssemblerData::LocalBlockMatrixType
typename ShapeMatricesType::template MatrixType< pressure_size, pressure_size > LocalBlockMatrixType
Definition ComponentTransportFEM.h:222
ProcessLib::ComponentTransport::LocalAssemblerData::GlobalDimMatrixType
typename ShapeMatricesType::GlobalDimMatrixType GlobalDimMatrixType
Definition ComponentTransportFEM.h:238
MaterialPropertyLib::formEigenTensor
Eigen::Matrix< double, GlobalDim, GlobalDim > formEigenTensor(MaterialPropertyLib::PropertyDataType const &values)
Definition FormEigenTensor.cpp:126
NumLib::detail::shapeFunctionInterpolate
void shapeFunctionInterpolate(const NodalValues &, const ShapeMatrix &)
Definition Interpolation.h:27
NumLib::computeHydrodynamicDispersion
Eigen::MatrixXd computeHydrodynamicDispersion(NumericalStabilization const &stabilizer, std::size_t const element_id, Eigen::MatrixXd const &pore_diffusion_coefficient, Eigen::VectorXd const &velocity, double const porosity, double const solute_dispersivity_transverse, double const solute_dispersivity_longitudinal)
Definition HydrodynamicDispersion.h:71

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, NumLib::detail::assembleAdvectionMatrix(), NumLib::computeHydrodynamicDispersion(), MaterialPropertyLib::concentration, MaterialPropertyLib::VariableArray::concentration, concentration_size, MaterialPropertyLib::decay_rate, MaterialPropertyLib::density, MaterialPropertyLib::formEigenTensor(), getName(), NumLib::interpolateCoordinates(), MaterialPropertyLib::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::pore_diffusion, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, MaterialPropertyLib::retardation_factor, ParameterLib::SpatialPosition::setCoordinates(), ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::transversal_dispersivity, and MaterialPropertyLib::viscosity.

Referenced by assemble().

◆ assembleComponentTransportEquation()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleComponentTransportEquation ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const & local_x_prev,
std::vector< double > & local_M_data,
std::vector< double > & local_K_data,
std::vector< double > & ,
int const transport_process_id )
inline

Definition at line 1101 of file ComponentTransportFEM.h.

1106 {
1107 assert(static_cast<int>(local_x.size()) ==
1108 pressure_size +
1109 concentration_size *
1110 static_cast<int>(_transport_process_variables.size()) +
1111 (_process_data.isothermal ? 0 : temperature_size));
1112
1113 auto const local_p =
1114 local_x.template segment<pressure_size>(pressure_index);
1115
1116 NodalVectorType local_T = getLocalTemperature(t, local_x);
1117
1118 auto const local_C = local_x.template segment<concentration_size>(
1119 first_concentration_index +
1120 (transport_process_id - (_process_data.isothermal ? 1 : 2)) *
1121 concentration_size);
1122 auto const local_p_prev =
1123 local_x_prev.segment<pressure_size>(pressure_index);
1124
1125 auto local_M = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
1126 local_M_data, concentration_size, concentration_size);
1127 auto local_K = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
1128 local_K_data, concentration_size, concentration_size);
1129
1130 LocalBlockMatrixType KCC_Laplacian =
1131 LocalBlockMatrixType::Zero(concentration_size, concentration_size);
1132
1133 unsigned const n_integration_points =
1134 _integration_method.getNumberOfPoints();
1135
1136 std::vector<GlobalDimVectorType> ip_flux_vector;
1137 double average_velocity_norm = 0.0;
1138 if (!_process_data.non_advective_form)
1139 {
1140 ip_flux_vector.reserve(n_integration_points);
1141 }
1142
1143 ParameterLib::SpatialPosition pos;
1144 pos.setElementID(_element.getID());
1145
1146 auto const& b =
1147 _process_data
1148 .projected_specific_body_force_vectors[_element.getID()];
1149
1150 MaterialPropertyLib::VariableArray vars;
1151 MaterialPropertyLib::VariableArray vars_prev;
1152
1153 auto const& medium =
1154 *_process_data.media_map.getMedium(_element.getID());
1155 auto const& phase = medium.phase("AqueousLiquid");
1156 auto const component_id =
1157 transport_process_id - (_process_data.isothermal ? 1 : 2);
1158 auto const& component = phase.component(
1159 _transport_process_variables[component_id].get().getName());
1160
1161 auto const& Ns =
1162 _process_data.shape_matrix_cache
1163 .NsHigherOrder<typename ShapeFunction::MeshElement>();
1164
1165 for (unsigned ip(0); ip < n_integration_points; ++ip)
1166 {
1167 auto& ip_data = _ip_data[ip];
1168 auto const& dNdx = ip_data.dNdx;
1169 auto const& w = ip_data.integration_weight;
1170 auto const& N = Ns[ip];
1171 auto& porosity = ip_data.porosity;
1172 auto const& porosity_prev = ip_data.porosity_prev;
1173
1174 double const C_int_pt = N.dot(local_C);
1175 double const p_int_pt = N.dot(local_p);
1176 double const T_int_pt = N.dot(local_T);
1177
1178 vars.concentration = C_int_pt;
1179 vars.liquid_phase_pressure = p_int_pt;
1180 vars.temperature = T_int_pt;
1181
1182 if (_process_data.temperature)
1183 {
1184 vars.temperature = N.dot(local_T);
1185 }
1186
1187 // porosity
1188 {
1189 vars_prev.porosity = porosity_prev;
1190
1191 porosity =
1192 _process_data.chemically_induced_porosity_change
1193 ? porosity_prev
1194 : medium[MaterialPropertyLib::PropertyType::porosity]
1195 .template value<double>(vars, vars_prev, pos, t,
1196 dt);
1197
1198 vars.porosity = porosity;
1199 }
1200
1201 auto const& retardation_factor =
1202 component[MaterialPropertyLib::PropertyType::retardation_factor]
1203 .template value<double>(vars, pos, t, dt);
1204
1205 auto const& solute_dispersivity_transverse = medium.template value<
1206 double>(
1207 MaterialPropertyLib::PropertyType::transversal_dispersivity);
1208 auto const& solute_dispersivity_longitudinal =
1209 medium.template value<double>(
1210 MaterialPropertyLib::PropertyType::
1211 longitudinal_dispersivity);
1212
1213 // Use the fluid density model to compute the density
1214 auto const density =
1215 phase[MaterialPropertyLib::PropertyType::density]
1216 .template value<double>(vars, pos, t, dt);
1217 auto const decay_rate =
1218 component[MaterialPropertyLib::PropertyType::decay_rate]
1219 .template value<double>(vars, pos, t, dt);
1220
1221 auto const& pore_diffusion_coefficient =
1222 MaterialPropertyLib::formEigenTensor<GlobalDim>(
1223 component[MaterialPropertyLib::PropertyType::pore_diffusion]
1224 .value(vars, pos, t, dt));
1225
1226 auto const& K = MaterialPropertyLib::formEigenTensor<GlobalDim>(
1227 medium[MaterialPropertyLib::PropertyType::permeability].value(
1228 vars, pos, t, dt));
1229 // Use the viscosity model to compute the viscosity
1230 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
1231 .template value<double>(vars, pos, t, dt);
1232
1233 GlobalDimMatrixType const K_over_mu = K / mu;
1234 GlobalDimVectorType const velocity =
1235 _process_data.has_gravity
1236 ? GlobalDimVectorType(-K_over_mu *
1237 (dNdx * local_p - density * b))
1238 : GlobalDimVectorType(-K_over_mu * dNdx * local_p);
1239
1240 GlobalDimMatrixType const hydrodynamic_dispersion =
1241 NumLib::computeHydrodynamicDispersion(
1242 _process_data.stabilizer, _element.getID(),
1243 pore_diffusion_coefficient, velocity, porosity,
1244 solute_dispersivity_transverse,
1245 solute_dispersivity_longitudinal);
1246
1247 double const R_times_phi = retardation_factor * porosity;
1248 auto const N_t_N = (N.transpose() * N).eval();
1249
1250 if (_process_data.non_advective_form)
1251 {
1252 const double drho_dC =
1253 phase[MaterialPropertyLib::PropertyType::density]
1254 .template dValue<double>(
1255 vars, MaterialPropertyLib::Variable::concentration,
1256 pos, t, dt);
1257 local_M.noalias() +=
1258 N_t_N * (R_times_phi * C_int_pt * drho_dC * w);
1259 }
1260
1261 local_M.noalias() += N_t_N * (R_times_phi * density * w);
1262
1263 // coupling term
1264 if (_process_data.non_advective_form)
1265 {
1266 double const p_dot = (p_int_pt - N.dot(local_p_prev)) / dt;
1267
1268 const double drho_dp =
1269 phase[MaterialPropertyLib::PropertyType::density]
1270 .template dValue<double>(vars,
1271 MaterialPropertyLib::Variable::
1272 liquid_phase_pressure,
1273 pos, t, dt);
1274
1275 local_K.noalias() +=
1276 N_t_N * ((R_times_phi * drho_dp * p_dot) * w) -
1277 dNdx.transpose() * velocity * N * (density * w);
1278 }
1279 else
1280 {
1281 ip_flux_vector.emplace_back(velocity * density);
1282 average_velocity_norm += velocity.norm();
1283 }
1284 local_K.noalias() +=
1285 N_t_N * (decay_rate * R_times_phi * density * w);
1286
1287 KCC_Laplacian.noalias() += dNdx.transpose() *
1288 hydrodynamic_dispersion * dNdx *
1289 (density * w);
1290 }
1291
1292 if (!_process_data.non_advective_form)
1293 {
1294 NumLib::assembleAdvectionMatrix<
1295 typename ShapeFunction::MeshElement>(
1296 _process_data.stabilizer, _ip_data,
1297 _process_data.shape_matrix_cache, ip_flux_vector,
1298 average_velocity_norm /
1299 static_cast<double>(n_integration_points),
1300 KCC_Laplacian);
1301 }
1302 local_K.noalias() += KCC_Laplacian;
1303 }
ProcessLib::ComponentTransport::LocalAssemblerData::getLocalTemperature
NodalVectorType getLocalTemperature(double const t, Eigen::VectorXd const &local_x) const
Definition ComponentTransportFEM.h:2137
ProcessLib::ComponentTransport::LocalAssemblerData::NodalVectorType
typename ShapeMatricesType::NodalVectorType NodalVectorType
Definition ComponentTransportFEM.h:232

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, NumLib::detail::assembleAdvectionMatrix(), NumLib::computeHydrodynamicDispersion(), MaterialPropertyLib::concentration, MaterialPropertyLib::VariableArray::concentration, concentration_size, MathLib::createZeroedMatrix(), MaterialPropertyLib::decay_rate, MaterialPropertyLib::density, first_concentration_index, MaterialPropertyLib::formEigenTensor(), getLocalTemperature(), getName(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::pore_diffusion, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, pressure_index, pressure_size, MaterialPropertyLib::retardation_factor, ParameterLib::SpatialPosition::setElementID(), MaterialPropertyLib::VariableArray::temperature, temperature_size, MaterialPropertyLib::transversal_dispersivity, and MaterialPropertyLib::viscosity.

Referenced by assembleForStaggeredScheme().

◆ assembleForStaggeredScheme()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleForStaggeredScheme ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const & local_x_prev,
int const process_id,
std::vector< double > & local_M_data,
std::vector< double > & local_K_data,
std::vector< double > & local_b_data )
inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 812 of file ComponentTransportFEM.h.

819 {
820 if (process_id == _process_data.hydraulic_process_id)
821 {
822 assembleHydraulicEquation(t, dt, local_x, local_x_prev,
823 local_M_data, local_K_data, local_b_data);
824 }
825 else if (process_id == _process_data.thermal_process_id)
826 {
827 assembleHeatTransportEquation(t, dt, local_x, local_x_prev,
828 local_M_data, local_K_data,
829 local_b_data);
830 }
831 else
832 {
833 // Go for assembling in an order of transport process id.
834 assembleComponentTransportEquation(t, dt, local_x, local_x_prev,
835 local_M_data, local_K_data,
836 local_b_data, process_id);
837 }
838 }
ProcessLib::ComponentTransport::LocalAssemblerData::assembleHeatTransportEquation
void assembleHeatTransportEquation(double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &)
Definition ComponentTransportFEM.h:966
ProcessLib::ComponentTransport::LocalAssemblerData::assembleHydraulicEquation
void assembleHydraulicEquation(double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)
Definition ComponentTransportFEM.h:840
ProcessLib::ComponentTransport::LocalAssemblerData::assembleComponentTransportEquation
void assembleComponentTransportEquation(double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &, int const transport_process_id)
Definition ComponentTransportFEM.h:1101

References _process_data, assembleComponentTransportEquation(), assembleHeatTransportEquation(), and assembleHydraulicEquation().

◆ assembleHeatTransportEquation()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleHeatTransportEquation ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const & ,
std::vector< double > & local_M_data,
std::vector< double > & local_K_data,
std::vector< double > &  )
inline

Definition at line 966 of file ComponentTransportFEM.h.

972 {
973 // In the staggered HTC process, number of components might be non-zero.
974 assert(local_x.size() ==
975 pressure_size + temperature_size +
976 concentration_size *
977 static_cast<int>(_transport_process_variables.size()));
978
979 auto const local_p =
980 local_x.template segment<pressure_size>(pressure_index);
981 auto const local_T = getLocalTemperature(t, local_x);
982
983 auto local_M = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
984 local_M_data, temperature_size, temperature_size);
985 auto local_K = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
986 local_K_data, temperature_size, temperature_size);
987
988 ParameterLib::SpatialPosition pos;
989 pos.setElementID(this->_element.getID());
990
991 auto const& process_data = this->_process_data;
992 auto const& medium =
993 *process_data.media_map.getMedium(this->_element.getID());
994 auto const& liquid_phase = medium.phase("AqueousLiquid");
995
996 auto const& b =
997 _process_data
998 .projected_specific_body_force_vectors[_element.getID()];
999
1000 MaterialPropertyLib::VariableArray vars;
1001
1002 unsigned const n_integration_points =
1003 this->_integration_method.getNumberOfPoints();
1004
1005 std::vector<GlobalDimVectorType> ip_flux_vector;
1006 double average_velocity_norm = 0.0;
1007 ip_flux_vector.reserve(n_integration_points);
1008
1009 auto const& Ns =
1010 _process_data.shape_matrix_cache
1011 .NsHigherOrder<typename ShapeFunction::MeshElement>();
1012
1013 for (unsigned ip(0); ip < n_integration_points; ip++)
1014 {
1015 auto const& ip_data = this->_ip_data[ip];
1016 auto const& dNdx = ip_data.dNdx;
1017 auto const& w = ip_data.integration_weight;
1018 auto const& N = Ns[ip];
1019
1020 ParameterLib::SpatialPosition const pos(
1021 {}, this->_element.getID(),
1022 MathLib::Point3d(
1023 NumLib::interpolateCoordinates<ShapeFunction,
1024 ShapeMatricesType>(_element,
1025 N)));
1026
1027 double p_at_xi = 0.;
1028 NumLib::shapeFunctionInterpolate(local_p, N, p_at_xi);
1029 double T_at_xi = 0.;
1030 NumLib::shapeFunctionInterpolate(local_T, N, T_at_xi);
1031
1032 vars.temperature = T_at_xi;
1033 vars.liquid_phase_pressure = p_at_xi;
1034
1035 vars.liquid_saturation = 1.0;
1036
1037 auto const porosity =
1038 medium.property(MaterialPropertyLib::PropertyType::porosity)
1039 .template value<double>(vars, pos, t, dt);
1040 vars.porosity = porosity;
1041
1042 // Use the fluid density model to compute the density
1043 auto const fluid_density =
1044 liquid_phase
1045 .property(MaterialPropertyLib::PropertyType::density)
1046 .template value<double>(vars, pos, t, dt);
1047 vars.density = fluid_density;
1048 auto const specific_heat_capacity_fluid =
1049 liquid_phase
1050 .property(MaterialPropertyLib::specific_heat_capacity)
1051 .template value<double>(vars, pos, t, dt);
1052
1053 // Assemble mass matrix
1054 local_M.noalias() += w *
1055 this->getHeatEnergyCoefficient(
1056 vars, porosity, fluid_density,
1057 specific_heat_capacity_fluid, pos, t, dt) *
1058 N.transpose() * N;
1059
1060 // Assemble Laplace matrix
1061 auto const viscosity =
1062 liquid_phase
1063 .property(MaterialPropertyLib::PropertyType::viscosity)
1064 .template value<double>(vars, pos, t, dt);
1065
1066 auto const intrinsic_permeability =
1067 MaterialPropertyLib::formEigenTensor<GlobalDim>(
1068 medium
1069 .property(
1070 MaterialPropertyLib::PropertyType::permeability)
1071 .value(vars, pos, t, dt));
1072
1073 GlobalDimMatrixType const K_over_mu =
1074 intrinsic_permeability / viscosity;
1075 GlobalDimVectorType const velocity =
1076 process_data.has_gravity
1077 ? GlobalDimVectorType(-K_over_mu *
1078 (dNdx * local_p - fluid_density * b))
1079 : GlobalDimVectorType(-K_over_mu * dNdx * local_p);
1080
1081 GlobalDimMatrixType const thermal_conductivity_dispersivity =
1082 this->getThermalConductivityDispersivity(
1083 vars, fluid_density, specific_heat_capacity_fluid, velocity,
1084 pos, t, dt);
1085
1086 local_K.noalias() +=
1087 w * dNdx.transpose() * thermal_conductivity_dispersivity * dNdx;
1088
1089 ip_flux_vector.emplace_back(velocity * fluid_density *
1090 specific_heat_capacity_fluid);
1091 average_velocity_norm += velocity.norm();
1092 }
1093
1094 NumLib::assembleAdvectionMatrix<typename ShapeFunction::MeshElement>(
1095 process_data.stabilizer, this->_ip_data,
1096 _process_data.shape_matrix_cache, ip_flux_vector,
1097 average_velocity_norm / static_cast<double>(n_integration_points),
1098 local_K);
1099 }
ProcessLib::ComponentTransport::LocalAssemblerData::getThermalConductivityDispersivity
GlobalDimMatrixType getThermalConductivityDispersivity(MaterialPropertyLib::VariableArray const &vars, const double fluid_density, const double specific_heat_capacity_fluid, const GlobalDimVectorType &velocity, ParameterLib::SpatialPosition const &pos, double const t, double const dt)
Definition ComponentTransportFEM.h:2096
ProcessLib::ComponentTransport::LocalAssemblerData::getHeatEnergyCoefficient
double getHeatEnergyCoefficient(MaterialPropertyLib::VariableArray const &vars, const double porosity, const double fluid_density, const double specific_heat_capacity_fluid, ParameterLib::SpatialPosition const &pos, double const t, double const dt)
Definition ComponentTransportFEM.h:2072
NumLib::detail::assembleAdvectionMatrix
void assembleAdvectionMatrix(IPData const &ip_data_vector, NumLib::ShapeMatrixCache const &shape_matrix_cache, std::vector< FluxVectorType > const &ip_flux_vector, Eigen::MatrixBase< Derived > &laplacian_matrix)
Definition AdvectionMatrixAssembler.h:28

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, NumLib::detail::assembleAdvectionMatrix(), concentration_size, MathLib::createZeroedMatrix(), MaterialPropertyLib::density, MaterialPropertyLib::VariableArray::density, MaterialPropertyLib::formEigenTensor(), getHeatEnergyCoefficient(), getLocalTemperature(), getThermalConductivityDispersivity(), NumLib::interpolateCoordinates(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_saturation, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, pressure_index, pressure_size, ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::specific_heat_capacity, MaterialPropertyLib::VariableArray::temperature, temperature_size, and MaterialPropertyLib::viscosity.

Referenced by assembleForStaggeredScheme().

◆ assembleHydraulicEquation()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleHydraulicEquation ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const & local_x_prev,
std::vector< double > & local_M_data,
std::vector< double > & local_K_data,
std::vector< double > & local_b_data )
inline

Definition at line 840 of file ComponentTransportFEM.h.

847 {
848 auto const local_p =
849 local_x.template segment<pressure_size>(pressure_index);
850 auto const local_C = local_x.template segment<concentration_size>(
851 first_concentration_index);
852 auto const local_C_prev =
853 local_x_prev.segment<concentration_size>(first_concentration_index);
854
855 NodalVectorType local_T = getLocalTemperature(t, local_x);
856
857 auto local_M = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
858 local_M_data, pressure_size, pressure_size);
859 auto local_K = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
860 local_K_data, pressure_size, pressure_size);
861 auto local_b = MathLib::createZeroedVector<LocalSegmentVectorType>(
862 local_b_data, pressure_size);
863
864 unsigned const n_integration_points =
865 _integration_method.getNumberOfPoints();
866
867 ParameterLib::SpatialPosition pos;
868 pos.setElementID(_element.getID());
869
870 auto const& b =
871 _process_data
872 .projected_specific_body_force_vectors[_element.getID()];
873
874 auto const& medium =
875 *_process_data.media_map.getMedium(_element.getID());
876 auto const& phase = medium.phase("AqueousLiquid");
877
878 MaterialPropertyLib::VariableArray vars;
879 MaterialPropertyLib::VariableArray vars_prev;
880
881 auto const& Ns =
882 _process_data.shape_matrix_cache
883 .NsHigherOrder<typename ShapeFunction::MeshElement>();
884
885 for (unsigned ip(0); ip < n_integration_points; ++ip)
886 {
887 auto& ip_data = _ip_data[ip];
888 auto const& dNdx = ip_data.dNdx;
889 auto const& w = ip_data.integration_weight;
890 auto const& N = Ns[ip];
891 auto& porosity = ip_data.porosity;
892 auto const& porosity_prev = ip_data.porosity_prev;
893
894 double const C_int_pt = N.dot(local_C);
895 double const p_int_pt = N.dot(local_p);
896 double const T_int_pt = N.dot(local_T);
897
898 vars.concentration = C_int_pt;
899 vars.liquid_phase_pressure = p_int_pt;
900 vars.temperature = T_int_pt;
901
902 // porosity
903 {
904 vars_prev.porosity = porosity_prev;
905
906 porosity =
907 _process_data.chemically_induced_porosity_change
908 ? porosity_prev
909 : medium[MaterialPropertyLib::PropertyType::porosity]
910 .template value<double>(vars, vars_prev, pos, t,
911 dt);
912
913 vars.porosity = porosity;
914 }
915
916 // Use the fluid density model to compute the density
917 // TODO: Concentration of which component as one of arguments for
918 // calculation of fluid density
919 auto const density =
920 phase[MaterialPropertyLib::PropertyType::density]
921 .template value<double>(vars, pos, t, dt);
922
923 auto const& K = MaterialPropertyLib::formEigenTensor<GlobalDim>(
924 medium[MaterialPropertyLib::PropertyType::permeability].value(
925 vars, pos, t, dt));
926
927 // Use the viscosity model to compute the viscosity
928 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
929 .template value<double>(vars, pos, t, dt);
930
931 GlobalDimMatrixType const K_over_mu = K / mu;
932
933 const double drho_dp =
934 phase[MaterialPropertyLib::PropertyType::density]
935 .template dValue<double>(
936 vars,
937 MaterialPropertyLib::Variable::liquid_phase_pressure,
938 pos, t, dt);
939 const double drho_dC =
940 phase[MaterialPropertyLib::PropertyType::density]
941 .template dValue<double>(
942 vars, MaterialPropertyLib::Variable::concentration, pos,
943 t, dt);
944
945 // matrix assembly
946 local_M.noalias() += w * N.transpose() * porosity * drho_dp * N;
947 local_K.noalias() +=
948 w * dNdx.transpose() * density * K_over_mu * dNdx;
949
950 if (_process_data.has_gravity)
951 {
952 local_b.noalias() +=
953 w * density * density * dNdx.transpose() * K_over_mu * b;
954 }
955
956 // coupling term
957 {
958 double const C_dot = (C_int_pt - N.dot(local_C_prev)) / dt;
959
960 local_b.noalias() -=
961 w * N.transpose() * porosity * drho_dC * C_dot;
962 }
963 }
964 }

References _element, _integration_method, _ip_data, _process_data, MaterialPropertyLib::concentration, MaterialPropertyLib::VariableArray::concentration, concentration_size, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, first_concentration_index, MaterialPropertyLib::formEigenTensor(), getLocalTemperature(), MaterialPropertyLib::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, pressure_index, pressure_size, ParameterLib::SpatialPosition::setElementID(), MaterialPropertyLib::VariableArray::temperature, and MaterialPropertyLib::viscosity.

Referenced by assembleForStaggeredScheme().

◆ assembleKCmCn()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleKCmCn ( int const component_id,
double const t,
double const dt,
Eigen::Ref< LocalBlockMatrixType > KCmCn,
double const stoichiometric_coefficient,
double const kinetic_prefactor )
inline

Definition at line 758 of file ComponentTransportFEM.h.

762 {
763 unsigned const n_integration_points =
764 _integration_method.getNumberOfPoints();
765
766 ParameterLib::SpatialPosition pos;
767 pos.setElementID(_element.getID());
768
769 MaterialPropertyLib::VariableArray vars;
770
771 auto const& medium =
772 *_process_data.media_map.getMedium(_element.getID());
773 auto const& phase = medium.phase("AqueousLiquid");
774 auto const& component = phase.component(
775 _transport_process_variables[component_id].get().getName());
776
777 auto const& Ns =
778 _process_data.shape_matrix_cache
779 .NsHigherOrder<typename ShapeFunction::MeshElement>();
780
781 for (unsigned ip(0); ip < n_integration_points; ++ip)
782 {
783 auto& ip_data = _ip_data[ip];
784 auto const& w = ip_data.integration_weight;
785 auto const& N = Ns[ip];
786 auto& porosity = ip_data.porosity;
787
788 // set position with N as the shape matrix at the current
789 // integration point
790 pos.setCoordinates(MathLib::Point3d(
791 NumLib::interpolateCoordinates<ShapeFunction,
792 ShapeMatricesType>(_element,
793 N)));
794
795 auto const retardation_factor =
796 component[MaterialPropertyLib::PropertyType::retardation_factor]
797 .template value<double>(vars, pos, t, dt);
798
799 porosity = medium[MaterialPropertyLib::PropertyType::porosity]
800 .template value<double>(vars, pos, t, dt);
801
802 auto const density =
803 phase[MaterialPropertyLib::PropertyType::density]
804 .template value<double>(vars, pos, t, dt);
805
806 KCmCn.noalias() -= w * N.transpose() * stoichiometric_coefficient *
807 kinetic_prefactor * retardation_factor *
808 porosity * density * N;
809 }
810 }

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, MaterialPropertyLib::density, getName(), NumLib::interpolateCoordinates(), MaterialPropertyLib::porosity, MaterialPropertyLib::retardation_factor, ParameterLib::SpatialPosition::setCoordinates(), and ParameterLib::SpatialPosition::setElementID().

Referenced by assemble().

◆ assembleReactionEquationConcrete()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleReactionEquationConcrete ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
std::vector< double > & local_M_data,
std::vector< double > & local_K_data,
std::vector< double > & local_b_data,
int const transport_process_id )
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 1580 of file ComponentTransportFEM.h.

1585 {
1586 auto const local_C = local_x.template segment<concentration_size>(
1587 first_concentration_index +
1588 (transport_process_id - 1) * concentration_size);
1589
1590 auto local_M = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
1591 local_M_data, concentration_size, concentration_size);
1592 auto local_K = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
1593 local_K_data, concentration_size, concentration_size);
1594 auto local_b = MathLib::createZeroedVector<LocalVectorType>(
1595 local_b_data, concentration_size);
1596
1597 unsigned const n_integration_points =
1598 _integration_method.getNumberOfPoints();
1599
1600 ParameterLib::SpatialPosition pos;
1601 pos.setElementID(_element.getID());
1602
1603 MaterialPropertyLib::VariableArray vars;
1604 MaterialPropertyLib::VariableArray vars_prev;
1605
1606 auto const& medium =
1607 *_process_data.media_map.getMedium(_element.getID());
1608 auto const component_id = transport_process_id - 1;
1609
1610 auto const& Ns =
1611 _process_data.shape_matrix_cache
1612 .NsHigherOrder<typename ShapeFunction::MeshElement>();
1613
1614 for (unsigned ip(0); ip < n_integration_points; ++ip)
1615 {
1616 auto& ip_data = _ip_data[ip];
1617 auto const w = ip_data.integration_weight;
1618 auto const& N = Ns[ip];
1619 auto& porosity = ip_data.porosity;
1620 auto const& porosity_prev = ip_data.porosity_prev;
1621 auto const chemical_system_id = ip_data.chemical_system_id;
1622
1623 double C_int_pt = 0.0;
1624 NumLib::shapeFunctionInterpolate(local_C, N, C_int_pt);
1625
1626 vars.concentration = C_int_pt;
1627
1628 auto const porosity_dot = (porosity - porosity_prev) / dt;
1629
1630 // porosity
1631 {
1632 vars_prev.porosity = porosity_prev;
1633
1634 porosity =
1635 _process_data.chemically_induced_porosity_change
1636 ? porosity_prev
1637 : medium[MaterialPropertyLib::PropertyType::porosity]
1638 .template value<double>(vars, vars_prev, pos, t,
1639 dt);
1640 }
1641
1642 local_M.noalias() += w * N.transpose() * porosity * N;
1643
1644 local_K.noalias() += w * N.transpose() * porosity_dot * N;
1645
1646 if (chemical_system_id == -1)
1647 {
1648 continue;
1649 }
1650
1651 auto const C_post_int_pt =
1652 _process_data.chemical_solver_interface->getConcentration(
1653 component_id, chemical_system_id);
1654
1655 local_b.noalias() +=
1656 w * N.transpose() * porosity * (C_post_int_pt - C_int_pt) / dt;
1657 }
1658 }

References _element, _integration_method, _ip_data, _process_data, MaterialPropertyLib::VariableArray::concentration, concentration_size, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), first_concentration_index, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, ParameterLib::SpatialPosition::setElementID(), and NumLib::detail::shapeFunctionInterpolate().

◆ assembleWithJacobianComponentTransportEquation()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobianComponentTransportEquation ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const & local_x_prev,
std::vector< double > & local_b_data,
std::vector< double > & local_Jac_data,
int const component_id )
inline

Definition at line 1432 of file ComponentTransportFEM.h.

1436 {
1437 auto const concentration_index =
1438 first_concentration_index + component_id * concentration_size;
1439
1440 auto const p = local_x.template segment<pressure_size>(pressure_index);
1441 auto const c =
1442 local_x.template segment<concentration_size>(concentration_index);
1443 auto const c_prev =
1444 local_x_prev.segment<concentration_size>(concentration_index);
1445
1446 NodalVectorType T;
1447 if (_process_data.temperature)
1448 {
1449 T = _process_data.temperature->getNodalValuesOnElement(_element, t);
1450 }
1451
1452 auto local_Jac = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
1453 local_Jac_data, concentration_size, concentration_size);
1454 auto local_rhs = MathLib::createZeroedVector<LocalSegmentVectorType>(
1455 local_b_data, concentration_size);
1456
1457 LocalBlockMatrixType KCC_Laplacian =
1458 LocalBlockMatrixType::Zero(concentration_size, concentration_size);
1459
1460 unsigned const n_integration_points =
1461 _integration_method.getNumberOfPoints();
1462
1463 std::vector<GlobalDimVectorType> ip_flux_vector;
1464 double average_velocity_norm = 0.0;
1465 ip_flux_vector.reserve(n_integration_points);
1466
1467 ParameterLib::SpatialPosition pos;
1468 pos.setElementID(_element.getID());
1469
1470 auto const& b =
1471 _process_data
1472 .projected_specific_body_force_vectors[_element.getID()];
1473
1474 MaterialPropertyLib::VariableArray vars;
1475 MaterialPropertyLib::VariableArray vars_prev;
1476
1477 auto const& medium =
1478 *_process_data.media_map.getMedium(_element.getID());
1479 auto const& phase = medium.phase("AqueousLiquid");
1480 auto const& component = phase.component(
1481 _transport_process_variables[component_id].get().getName());
1482
1483 auto const& Ns =
1484 _process_data.shape_matrix_cache
1485 .NsHigherOrder<typename ShapeFunction::MeshElement>();
1486
1487 for (unsigned ip(0); ip < n_integration_points; ++ip)
1488 {
1489 auto& ip_data = _ip_data[ip];
1490 auto const& dNdx = ip_data.dNdx;
1491 auto const& w = ip_data.integration_weight;
1492 auto const& N = Ns[ip];
1493 auto& phi = ip_data.porosity;
1494 auto const& phi_prev = ip_data.porosity_prev;
1495
1496 double const p_ip = N.dot(p);
1497 double const c_ip = N.dot(c);
1498
1499 vars.liquid_phase_pressure = p_ip;
1500 vars.concentration = c_ip;
1501
1502 if (_process_data.temperature)
1503 {
1504 vars.temperature = N.dot(T);
1505 }
1506
1507 // porosity
1508 {
1509 vars_prev.porosity = phi_prev;
1510
1511 phi = _process_data.chemically_induced_porosity_change
1512 ? phi_prev
1513 : medium[MaterialPropertyLib::PropertyType::porosity]
1514 .template value<double>(vars, vars_prev, pos, t,
1515 dt);
1516
1517 vars.porosity = phi;
1518 }
1519
1520 auto const R =
1521 component[MaterialPropertyLib::PropertyType::retardation_factor]
1522 .template value<double>(vars, pos, t, dt);
1523
1524 auto const alpha_T = medium.template value<double>(
1525 MaterialPropertyLib::PropertyType::transversal_dispersivity);
1526 auto const alpha_L = medium.template value<double>(
1527 MaterialPropertyLib::PropertyType::longitudinal_dispersivity);
1528
1529 auto const rho = phase[MaterialPropertyLib::PropertyType::density]
1530 .template value<double>(vars, pos, t, dt);
1531 // first-order decay constant
1532 auto const alpha =
1533 component[MaterialPropertyLib::PropertyType::decay_rate]
1534 .template value<double>(vars, pos, t, dt);
1535
1536 auto const Dp = MaterialPropertyLib::formEigenTensor<GlobalDim>(
1537 component[MaterialPropertyLib::PropertyType::pore_diffusion]
1538 .value(vars, pos, t, dt));
1539
1540 auto const k = MaterialPropertyLib::formEigenTensor<GlobalDim>(
1541 medium[MaterialPropertyLib::PropertyType::permeability].value(
1542 vars, pos, t, dt));
1543 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
1544 .template value<double>(vars, pos, t, dt);
1545 // Darcy flux
1546 GlobalDimVectorType const q =
1547 _process_data.has_gravity
1548 ? GlobalDimVectorType(-k / mu * (dNdx * p - rho * b))
1549 : GlobalDimVectorType(-k / mu * dNdx * p);
1550
1551 GlobalDimMatrixType const D = NumLib::computeHydrodynamicDispersion(
1552 _process_data.stabilizer, _element.getID(), Dp, q, phi, alpha_T,
1553 alpha_L);
1554
1555 // matrix assembly
1556 local_Jac.noalias() +=
1557 w * rho * N.transpose() * phi * R * (alpha + 1 / dt) * N;
1558
1559 KCC_Laplacian.noalias() += w * rho * dNdx.transpose() * D * dNdx;
1560
1561 auto const cdot = (c - c_prev) / dt;
1562 local_rhs.noalias() -=
1563 w * rho * N.transpose() * phi * R * N * (cdot + alpha * c);
1564
1565 ip_flux_vector.emplace_back(q * rho);
1566 average_velocity_norm += q.norm();
1567 }
1568
1569 NumLib::assembleAdvectionMatrix<typename ShapeFunction::MeshElement>(
1570 _process_data.stabilizer, _ip_data,
1571 _process_data.shape_matrix_cache, ip_flux_vector,
1572 average_velocity_norm / static_cast<double>(n_integration_points),
1573 KCC_Laplacian);
1574
1575 local_rhs.noalias() -= KCC_Laplacian * c;
1576
1577 local_Jac.noalias() += KCC_Laplacian;
1578 }

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, NumLib::detail::assembleAdvectionMatrix(), NumLib::computeHydrodynamicDispersion(), MaterialPropertyLib::VariableArray::concentration, concentration_size, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::decay_rate, MaterialPropertyLib::density, first_concentration_index, MaterialPropertyLib::formEigenTensor(), getName(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::longitudinal_dispersivity, MaterialPropertyLib::permeability, MaterialPropertyLib::pore_diffusion, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, pressure_index, MaterialPropertyLib::retardation_factor, ParameterLib::SpatialPosition::setElementID(), MaterialPropertyLib::VariableArray::temperature, MaterialPropertyLib::transversal_dispersivity, and MaterialPropertyLib::viscosity.

Referenced by assembleWithJacobianForStaggeredScheme().

◆ assembleWithJacobianForStaggeredScheme()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobianForStaggeredScheme ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const & local_x_prev,
int const process_id,
std::vector< double > & local_b_data,
std::vector< double > & local_Jac_data )
inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 1305 of file ComponentTransportFEM.h.

1310 {
1311 if (process_id == _process_data.hydraulic_process_id)
1312 {
1313 assembleWithJacobianHydraulicEquation(t, dt, local_x, local_x_prev,
1314 local_b_data, local_Jac_data);
1315 }
1316 else
1317 {
1318 int const component_id = process_id - 1;
1319 assembleWithJacobianComponentTransportEquation(
1320 t, dt, local_x, local_x_prev, local_b_data, local_Jac_data,
1321 component_id);
1322 }
1323 }
ProcessLib::ComponentTransport::LocalAssemblerData::assembleWithJacobianHydraulicEquation
void assembleWithJacobianHydraulicEquation(double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)
Definition ComponentTransportFEM.h:1325
ProcessLib::ComponentTransport::LocalAssemblerData::assembleWithJacobianComponentTransportEquation
void assembleWithJacobianComponentTransportEquation(double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data, int const component_id)
Definition ComponentTransportFEM.h:1432

References _process_data, assembleWithJacobianComponentTransportEquation(), and assembleWithJacobianHydraulicEquation().

◆ assembleWithJacobianHydraulicEquation()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::assembleWithJacobianHydraulicEquation ( double const t,
double const dt,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const & local_x_prev,
std::vector< double > & local_b_data,
std::vector< double > & local_Jac_data )
inline

Definition at line 1325 of file ComponentTransportFEM.h.

1329 {
1330 auto const p = local_x.template segment<pressure_size>(pressure_index);
1331 auto const c = local_x.template segment<concentration_size>(
1332 first_concentration_index);
1333
1334 auto const p_prev = local_x_prev.segment<pressure_size>(pressure_index);
1335 auto const c_prev =
1336 local_x_prev.segment<concentration_size>(first_concentration_index);
1337
1338 auto local_Jac = MathLib::createZeroedMatrix<LocalBlockMatrixType>(
1339 local_Jac_data, pressure_size, pressure_size);
1340 auto local_rhs = MathLib::createZeroedVector<LocalSegmentVectorType>(
1341 local_b_data, pressure_size);
1342
1343 unsigned const n_integration_points =
1344 _integration_method.getNumberOfPoints();
1345
1346 ParameterLib::SpatialPosition pos;
1347 pos.setElementID(_element.getID());
1348 auto const& b =
1349 _process_data
1350 .projected_specific_body_force_vectors[_element.getID()];
1351
1352 auto const& medium =
1353 *_process_data.media_map.getMedium(_element.getID());
1354 auto const& phase = medium.phase("AqueousLiquid");
1355
1356 MaterialPropertyLib::VariableArray vars;
1357 MaterialPropertyLib::VariableArray vars_prev;
1358
1359 auto const& Ns =
1360 _process_data.shape_matrix_cache
1361 .NsHigherOrder<typename ShapeFunction::MeshElement>();
1362
1363 for (unsigned ip(0); ip < n_integration_points; ++ip)
1364 {
1365 auto& ip_data = _ip_data[ip];
1366 auto const& dNdx = ip_data.dNdx;
1367 auto const& w = ip_data.integration_weight;
1368 auto const& N = Ns[ip];
1369 auto& phi = ip_data.porosity;
1370 auto const& phi_prev = ip_data.porosity_prev;
1371
1372 double const p_ip = N.dot(p);
1373 double const c_ip = N.dot(c);
1374
1375 double const cdot_ip = (c_ip - N.dot(c_prev)) / dt;
1376
1377 vars.liquid_phase_pressure = p_ip;
1378 vars.concentration = c_ip;
1379
1380 // porosity
1381 {
1382 vars_prev.porosity = phi_prev;
1383
1384 phi = _process_data.chemically_induced_porosity_change
1385 ? phi_prev
1386 : medium[MaterialPropertyLib::PropertyType::porosity]
1387 .template value<double>(vars, vars_prev, pos, t,
1388 dt);
1389
1390 vars.porosity = phi;
1391 }
1392
1393 auto const rho = phase[MaterialPropertyLib::PropertyType::density]
1394 .template value<double>(vars, pos, t, dt);
1395
1396 auto const k = MaterialPropertyLib::formEigenTensor<GlobalDim>(
1397 medium[MaterialPropertyLib::PropertyType::permeability].value(
1398 vars, pos, t, dt));
1399
1400 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
1401 .template value<double>(vars, pos, t, dt);
1402
1403 auto const drho_dp =
1404 phase[MaterialPropertyLib::PropertyType::density]
1405 .template dValue<double>(
1406 vars,
1407 MaterialPropertyLib::Variable::liquid_phase_pressure,
1408 pos, t, dt);
1409 auto const drho_dc =
1410 phase[MaterialPropertyLib::PropertyType::density]
1411 .template dValue<double>(
1412 vars, MaterialPropertyLib::Variable::concentration, pos,
1413 t, dt);
1414
1415 // matrix assembly
1416 local_Jac.noalias() += w * N.transpose() * phi * drho_dp / dt * N +
1417 w * dNdx.transpose() * rho * k / mu * dNdx;
1418
1419 local_rhs.noalias() -=
1420 w * N.transpose() * phi *
1421 (drho_dp * N * p_prev + drho_dc * cdot_ip) +
1422 w * rho * dNdx.transpose() * k / mu * dNdx * p;
1423
1424 if (_process_data.has_gravity)
1425 {
1426 local_rhs.noalias() +=
1427 w * rho * dNdx.transpose() * k / mu * rho * b;
1428 }
1429 }
1430 }

References _element, _integration_method, _ip_data, _process_data, MaterialPropertyLib::concentration, MaterialPropertyLib::VariableArray::concentration, concentration_size, MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), MaterialPropertyLib::density, first_concentration_index, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::liquid_phase_pressure, MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, pressure_index, pressure_size, ParameterLib::SpatialPosition::setElementID(), and MaterialPropertyLib::viscosity.

Referenced by assembleWithJacobianForStaggeredScheme().

◆ calculateIntPtDarcyVelocity()

template<typename ShapeFunction, int GlobalDim>
std::vector< double > const & ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::calculateIntPtDarcyVelocity ( const double t,
Eigen::Ref< const NodalVectorType > const & p_nodal_values,
Eigen::Ref< const NodalVectorType > const & C_nodal_values,
Eigen::Ref< const NodalVectorType > const & T_nodal_values,
std::vector< double > & cache ) const
inline

Definition at line 1735 of file ComponentTransportFEM.h.

1741 {
1742 auto const n_integration_points =
1743 _integration_method.getNumberOfPoints();
1744
1745 cache.clear();
1746 auto cache_mat = MathLib::createZeroedMatrix<
1747 Eigen::Matrix<double, GlobalDim, Eigen::Dynamic, Eigen::RowMajor>>(
1748 cache, GlobalDim, n_integration_points);
1749
1750 ParameterLib::SpatialPosition pos;
1751 pos.setElementID(_element.getID());
1752
1753 auto const& b =
1754 _process_data
1755 .projected_specific_body_force_vectors[_element.getID()];
1756
1757 MaterialPropertyLib::VariableArray vars;
1758
1759 auto const& medium =
1760 *_process_data.media_map.getMedium(_element.getID());
1761 auto const& phase = medium.phase("AqueousLiquid");
1762
1763 auto const& Ns =
1764 _process_data.shape_matrix_cache
1765 .NsHigherOrder<typename ShapeFunction::MeshElement>();
1766
1767 for (unsigned ip = 0; ip < n_integration_points; ++ip)
1768 {
1769 auto const& ip_data = _ip_data[ip];
1770 auto const& dNdx = ip_data.dNdx;
1771 auto const& N = Ns[ip];
1772 auto const& porosity = ip_data.porosity;
1773
1774 double C_int_pt = 0.0;
1775 double p_int_pt = 0.0;
1776 double T_int_pt = 0.0;
1777
1778 NumLib::shapeFunctionInterpolate(C_nodal_values, N, C_int_pt);
1779 NumLib::shapeFunctionInterpolate(p_nodal_values, N, p_int_pt);
1780 NumLib::shapeFunctionInterpolate(T_nodal_values, N, T_int_pt);
1781
1782 vars.concentration = C_int_pt;
1783 vars.liquid_phase_pressure = p_int_pt;
1784 vars.porosity = porosity;
1785 vars.temperature = T_int_pt;
1786
1787 // TODO (naumov) Temporary value not used by current material
1788 // models. Need extension of secondary variables interface.
1789 double const dt = std::numeric_limits<double>::quiet_NaN();
1790 auto const& K = MaterialPropertyLib::formEigenTensor<GlobalDim>(
1791 medium[MaterialPropertyLib::PropertyType::permeability].value(
1792 vars, pos, t, dt));
1793 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
1794 .template value<double>(vars, pos, t, dt);
1795 GlobalDimMatrixType const K_over_mu = K / mu;
1796
1797 cache_mat.col(ip).noalias() = -K_over_mu * dNdx * p_nodal_values;
1798 if (_process_data.has_gravity)
1799 {
1800 auto const rho_w =
1801 phase[MaterialPropertyLib::PropertyType::density]
1802 .template value<double>(vars, pos, t, dt);
1803 // here it is assumed that the vector b is directed 'downwards'
1804 cache_mat.col(ip).noalias() += K_over_mu * rho_w * b;
1805 }
1806 }
1807
1808 return cache;
1809 }

References _element, _integration_method, _ip_data, _process_data, MaterialPropertyLib::VariableArray::concentration, MathLib::createZeroedMatrix(), MaterialPropertyLib::density, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, MaterialPropertyLib::VariableArray::porosity, ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), MaterialPropertyLib::VariableArray::temperature, and MaterialPropertyLib::viscosity.

Referenced by computeSecondaryVariableConcrete(), and getIntPtDarcyVelocity().

◆ computeReactionRelatedSecondaryVariable()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::computeReactionRelatedSecondaryVariable ( std::size_t const ele_id)
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 1910 of file ComponentTransportFEM.h.

1912 {
1913 auto const n_integration_points =
1914 _integration_method.getNumberOfPoints();
1915
1916 if (_process_data.chemically_induced_porosity_change)
1917 {
1918 auto const& medium = *_process_data.media_map.getMedium(ele_id);
1919
1920 for (auto& ip_data : _ip_data)
1921 {
1922 ip_data.porosity = ip_data.porosity_prev;
1923
1924 _process_data.chemical_solver_interface
1925 ->updatePorosityPostReaction(ip_data.chemical_system_id,
1926 medium, ip_data.porosity);
1927 }
1928
1929 (*_process_data.mesh_prop_porosity)[ele_id] =
1930 std::accumulate(_ip_data.begin(), _ip_data.end(), 0.,
1931 [](double const s, auto const& ip)
1932 { return s + ip.porosity; }) /
1933 n_integration_points;
1934 }
1935
1936 std::vector<GlobalIndexType> chemical_system_indices;
1937 chemical_system_indices.reserve(n_integration_points);
1938 std::transform(_ip_data.begin(), _ip_data.end(),
1939 std::back_inserter(chemical_system_indices),
1940 [](auto const& ip_data)
1941 { return ip_data.chemical_system_id; });
1942
1943 _process_data.chemical_solver_interface->computeSecondaryVariable(
1944 ele_id, chemical_system_indices);
1945 }

References _integration_method, _ip_data, and _process_data.

◆ computeSecondaryVariableConcrete()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::computeSecondaryVariableConcrete ( double const t,
double const ,
Eigen::VectorXd const & local_x,
Eigen::VectorXd const &  )
inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 1883 of file ComponentTransportFEM.h.

1888 {
1889 auto const local_p =
1890 local_x.template segment<pressure_size>(pressure_index);
1891 auto const local_C = local_x.template segment<concentration_size>(
1892 first_concentration_index);
1893 auto const local_T = getLocalTemperature(t, local_x);
1894
1895 std::vector<double> ele_velocity;
1896 calculateIntPtDarcyVelocity(t, local_p, local_C, local_T, ele_velocity);
1897
1898 auto const n_integration_points =
1899 _integration_method.getNumberOfPoints();
1900 auto const ele_velocity_mat =
1901 MathLib::toMatrix(ele_velocity, GlobalDim, n_integration_points);
1902
1903 auto const ele_id = _element.getID();
1904 Eigen::Map<LocalVectorType>(
1905 &(*_process_data.mesh_prop_velocity)[ele_id * GlobalDim],
1906 GlobalDim) =
1907 ele_velocity_mat.rowwise().sum() / n_integration_points;
1908 }
ProcessLib::ComponentTransport::LocalAssemblerData::calculateIntPtDarcyVelocity
std::vector< double > const & calculateIntPtDarcyVelocity(const double t, Eigen::Ref< const NodalVectorType > const &p_nodal_values, Eigen::Ref< const NodalVectorType > const &C_nodal_values, Eigen::Ref< const NodalVectorType > const &T_nodal_values, std::vector< double > &cache) const
Definition ComponentTransportFEM.h:1735
MathLib::toMatrix
Eigen::Map< const Matrix > toMatrix(std::vector< double > const &data, Eigen::MatrixXd::Index rows, Eigen::MatrixXd::Index cols)
Definition EigenMapTools.h:72

References _element, _integration_method, _process_data, calculateIntPtDarcyVelocity(), first_concentration_index, getLocalTemperature(), pressure_index, and MathLib::toMatrix().

◆ getFlux()

template<typename ShapeFunction, int GlobalDim>
Eigen::Vector3d ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getFlux ( MathLib::Point3d const & ,
double const ,
std::vector< double > const &  ) const
inlineoverridevirtual

Computes the flux in the point p_local_coords that is given in local coordinates using the values from local_x. Fits to monolithic scheme.

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 1821 of file ComponentTransportFEM.h.

1824 {
1825 auto const local_p = Eigen::Map<const NodalVectorType>(
1826 &local_x[pressure_index], pressure_size);
1827 auto const local_C = Eigen::Map<const NodalVectorType>(
1828 &local_x[first_concentration_index], concentration_size);
1829
1830 // Eval shape matrices at given point
1831 // Note: Axial symmetry is set to false here, because we only need dNdx
1832 // here, which is not affected by axial symmetry.
1833 auto const shape_matrices =
1834 NumLib::computeShapeMatrices<ShapeFunction, ShapeMatricesType,
1835 GlobalDim>(
1836 _element, false /*is_axially_symmetric*/,
1837 std::array{pnt_local_coords})[0];
1838
1839 ParameterLib::SpatialPosition pos;
1840 pos.setElementID(_element.getID());
1841 auto const& b =
1842 _process_data
1843 .projected_specific_body_force_vectors[_element.getID()];
1844
1845 MaterialPropertyLib::VariableArray vars;
1846
1847 auto const& medium =
1848 *_process_data.media_map.getMedium(_element.getID());
1849 auto const& phase = medium.phase("AqueousLiquid");
1850
1851 // local_x contains the local concentration and pressure values
1852 double c_int_pt;
1853 NumLib::shapeFunctionInterpolate(local_C, shape_matrices.N, c_int_pt);
1854 vars.concentration = c_int_pt;
1855
1856 double p_int_pt;
1857 NumLib::shapeFunctionInterpolate(local_p, shape_matrices.N, p_int_pt);
1858 vars.liquid_phase_pressure = p_int_pt;
1859
1860 // TODO (naumov) Temporary value not used by current material models.
1861 // Need extension of secondary variables interface.
1862 double const dt = std::numeric_limits<double>::quiet_NaN();
1863 auto const K = MaterialPropertyLib::formEigenTensor<GlobalDim>(
1864 medium[MaterialPropertyLib::PropertyType::permeability].value(
1865 vars, pos, t, dt));
1866
1867 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
1868 .template value<double>(vars, pos, t, dt);
1869 GlobalDimMatrixType const K_over_mu = K / mu;
1870
1871 GlobalDimVectorType q = -K_over_mu * shape_matrices.dNdx * local_p;
1872 auto const rho_w = phase[MaterialPropertyLib::PropertyType::density]
1873 .template value<double>(vars, pos, t, dt);
1874 if (_process_data.has_gravity)
1875 {
1876 q += K_over_mu * rho_w * b;
1877 }
1878 Eigen::Vector3d flux(0.0, 0.0, 0.0);
1879 flux.head<GlobalDim>() = rho_w * q;
1880 return flux;
1881 }

References _element, _process_data, NumLib::computeShapeMatrices(), MaterialPropertyLib::VariableArray::concentration, concentration_size, MaterialPropertyLib::density, first_concentration_index, MaterialPropertyLib::formEigenTensor(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::permeability, pressure_index, pressure_size, ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), and MaterialPropertyLib::viscosity.

◆ getHeatEnergyCoefficient()

template<typename ShapeFunction, int GlobalDim>
double ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getHeatEnergyCoefficient ( MaterialPropertyLib::VariableArray const & vars,
const double porosity,
const double fluid_density,
const double specific_heat_capacity_fluid,
ParameterLib::SpatialPosition const & pos,
double const t,
double const dt )
inlineprivate

Definition at line 2072 of file ComponentTransportFEM.h.

2077 {
2078 auto const& medium =
2079 *_process_data.media_map.getMedium(this->_element.getID());
2080 auto const& solid_phase = medium.phase("Solid");
2081
2082 auto const specific_heat_capacity_solid =
2083 solid_phase
2084 .property(
2085 MaterialPropertyLib::PropertyType::specific_heat_capacity)
2086 .template value<double>(vars, pos, t, dt);
2087
2088 auto const solid_density =
2089 solid_phase.property(MaterialPropertyLib::PropertyType::density)
2090 .template value<double>(vars, pos, t, dt);
2091
2092 return solid_density * specific_heat_capacity_solid * (1 - porosity) +
2093 fluid_density * specific_heat_capacity_fluid * porosity;
2094 }

References _process_data, MaterialPropertyLib::density, MeshLib::Element::getID(), and MaterialPropertyLib::specific_heat_capacity.

Referenced by assembleHeatTransportEquation().

◆ getIntPtDarcyVelocity()

template<typename ShapeFunction, int GlobalDim>
std::vector< double > const & ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtDarcyVelocity ( const double t,
std::vector< GlobalVector * > const & x,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table,
std::vector< double > & cache ) const
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 1660 of file ComponentTransportFEM.h.

1665 {
1666 assert(x.size() == dof_table.size());
1667
1668 auto const n_processes = x.size();
1669 std::vector<std::vector<double>> local_x;
1670 local_x.reserve(n_processes);
1671
1672 for (std::size_t process_id = 0; process_id < n_processes; ++process_id)
1673 {
1674 auto const indices =
1675 NumLib::getIndices(_element.getID(), *dof_table[process_id]);
1676 assert(!indices.empty());
1677 local_x.push_back(x[process_id]->get(indices));
1678 }
1679
1680 // only one process, must be monolithic.
1681 if (n_processes == 1)
1682 {
1683 auto const local_p = Eigen::Map<const NodalVectorType>(
1684 &local_x[0][pressure_index], pressure_size);
1685 auto const local_C = Eigen::Map<const NodalVectorType>(
1686 &local_x[0][first_concentration_index], concentration_size);
1687 NodalVectorType local_T;
1688 local_T.setConstant(ShapeFunction::NPOINTS,
1689 std::numeric_limits<double>::quiet_NaN());
1690 int const temperature_index =
1691 _process_data.isothermal ? -1 : ShapeFunction::NPOINTS;
1692 if (temperature_index != -1)
1693 {
1694 local_T = Eigen::Map<const NodalVectorType>(
1695 &local_x[0][temperature_index], temperature_size);
1696 }
1697 return calculateIntPtDarcyVelocity(t, local_p, local_C, local_T,
1698 cache);
1699 }
1700
1701 // multiple processes, must be staggered.
1702 {
1703 constexpr int pressure_process_id = 0;
1704 int concentration_process_id = 1;
1705 // Normally temperature process is not there,
1706 // hence set the default temperature index to -1
1707 int temperature_process_id = -1;
1708
1709 // check whether temperature process exists
1710 if (!_process_data.isothermal)
1711 {
1712 // if temperature process exists, its id is 1
1713 temperature_process_id = 1;
1714 // then the concentration index shifts to 2
1715 concentration_process_id = 2;
1716 }
1717
1718 auto const local_p = Eigen::Map<const NodalVectorType>(
1719 &local_x[pressure_process_id][0], pressure_size);
1720 auto const local_C = Eigen::Map<const NodalVectorType>(
1721 &local_x[concentration_process_id][0], concentration_size);
1722 NodalVectorType local_T;
1723 local_T.setConstant(ShapeFunction::NPOINTS,
1724 std::numeric_limits<double>::quiet_NaN());
1725 if (temperature_process_id != -1)
1726 {
1727 local_T = Eigen::Map<const NodalVectorType>(
1728 &local_x[temperature_process_id][0], temperature_size);
1729 }
1730 return calculateIntPtDarcyVelocity(t, local_p, local_C, local_T,
1731 cache);
1732 }
1733 }
NumLib::getIndices
std::vector< GlobalIndexType > getIndices(std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)
Definition DOFTableUtil.cpp:112

References _element, _process_data, calculateIntPtDarcyVelocity(), concentration_size, first_concentration_index, NumLib::getIndices(), pressure_index, pressure_size, temperature_index, and temperature_size.

◆ getIntPtMolarFlux()

template<typename ShapeFunction, int GlobalDim>
std::vector< double > const & ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getIntPtMolarFlux ( const double t,
std::vector< GlobalVector * > const & x,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables,
std::vector< double > & cache,
int const component_id ) const
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 1947 of file ComponentTransportFEM.h.

1951 {
1952 std::vector<double> local_x_vec;
1953
1954 auto const n_processes = x.size();
1955 for (std::size_t process_id = 0; process_id < n_processes; ++process_id)
1956 {
1957 auto const indices =
1958 NumLib::getIndices(_element.getID(), *dof_tables[process_id]);
1959 assert(!indices.empty());
1960 auto const local_solution = x[process_id]->get(indices);
1961 local_x_vec.insert(std::end(local_x_vec),
1962 std::begin(local_solution),
1963 std::end(local_solution));
1964 }
1965 auto const local_x = MathLib::toVector(local_x_vec);
1966
1967 auto const p = local_x.template segment<pressure_size>(pressure_index);
1968 auto const c = local_x.template segment<concentration_size>(
1969 first_concentration_index + component_id * concentration_size);
1970
1971 auto const n_integration_points =
1972 _integration_method.getNumberOfPoints();
1973
1974 cache.clear();
1975 auto cache_mat = MathLib::createZeroedMatrix<
1976 Eigen::Matrix<double, GlobalDim, Eigen::Dynamic, Eigen::RowMajor>>(
1977 cache, GlobalDim, n_integration_points);
1978
1979 ParameterLib::SpatialPosition pos;
1980 pos.setElementID(_element.getID());
1981
1982 auto const& b =
1983 _process_data
1984 .projected_specific_body_force_vectors[_element.getID()];
1985
1986 MaterialPropertyLib::VariableArray vars;
1987
1988 auto const& medium =
1989 *_process_data.media_map.getMedium(_element.getID());
1990 auto const& phase = medium.phase("AqueousLiquid");
1991
1992 auto const& component = phase.component(
1993 _transport_process_variables[component_id].get().getName());
1994
1995 auto const& Ns =
1996 _process_data.shape_matrix_cache
1997 .NsHigherOrder<typename ShapeFunction::MeshElement>();
1998
1999 for (unsigned ip = 0; ip < n_integration_points; ++ip)
2000 {
2001 auto const& ip_data = _ip_data[ip];
2002 auto const& dNdx = ip_data.dNdx;
2003 auto const& N = Ns[ip];
2004 auto const& phi = ip_data.porosity;
2005
2006 double const p_ip = N.dot(p);
2007 double const c_ip = N.dot(c);
2008
2009 vars.concentration = c_ip;
2010 vars.liquid_phase_pressure = p_ip;
2011 vars.porosity = phi;
2012
2013 double const dt = std::numeric_limits<double>::quiet_NaN();
2014
2015 auto const& k = MaterialPropertyLib::formEigenTensor<GlobalDim>(
2016 medium[MaterialPropertyLib::PropertyType::permeability].value(
2017 vars, pos, t, dt));
2018 auto const mu = phase[MaterialPropertyLib::PropertyType::viscosity]
2019 .template value<double>(vars, pos, t, dt);
2020 auto const rho = phase[MaterialPropertyLib::PropertyType::density]
2021 .template value<double>(vars, pos, t, dt);
2022
2023 // Darcy flux
2024 GlobalDimVectorType const q =
2025 _process_data.has_gravity
2026 ? GlobalDimVectorType(-k / mu * (dNdx * p - rho * b))
2027 : GlobalDimVectorType(-k / mu * dNdx * p);
2028
2029 auto const alpha_T = medium.template value<double>(
2030 MaterialPropertyLib::PropertyType::transversal_dispersivity);
2031 auto const alpha_L = medium.template value<double>(
2032 MaterialPropertyLib::PropertyType::longitudinal_dispersivity);
2033 auto const Dp = MaterialPropertyLib::formEigenTensor<GlobalDim>(
2034 component[MaterialPropertyLib::PropertyType::pore_diffusion]
2035 .value(vars, pos, t, dt));
2036
2037 // Hydrodynamic dispersion
2038 GlobalDimMatrixType const D = NumLib::computeHydrodynamicDispersion(
2039 _process_data.stabilizer, _element.getID(), Dp, q, phi, alpha_T,
2040 alpha_L);
2041
2042 cache_mat.col(ip).noalias() = q * c_ip - D * dNdx * c;
2043 }
2044
2045 return cache;
2046 }
MathLib::toVector
Eigen::Map< const Vector > toVector(std::vector< double > const &data, Eigen::VectorXd::Index size)
Creates an Eigen mapped vector from the given data vector.
Definition EigenMapTools.h:167

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, NumLib::computeHydrodynamicDispersion(), MaterialPropertyLib::VariableArray::concentration, concentration_size, MathLib::createZeroedMatrix(), MaterialPropertyLib::density, first_concentration_index, MaterialPropertyLib::formEigenTensor(), NumLib::getIndices(), getName(), MaterialPropertyLib::VariableArray::liquid_phase_pressure, MaterialPropertyLib::longitudinal_dispersivity, MaterialPropertyLib::permeability, MaterialPropertyLib::pore_diffusion, MaterialPropertyLib::VariableArray::porosity, pressure_index, ParameterLib::SpatialPosition::setElementID(), MathLib::toVector(), MaterialPropertyLib::transversal_dispersivity, and MaterialPropertyLib::viscosity.

◆ getLocalTemperature()

template<typename ShapeFunction, int GlobalDim>
NodalVectorType ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getLocalTemperature ( double const t,
Eigen::VectorXd const & local_x ) const
inlineprivate

Definition at line 2137 of file ComponentTransportFEM.h.

2139 {
2140 NodalVectorType local_T;
2141 if (_process_data.isothermal)
2142 {
2143 if (_process_data.temperature)
2144 {
2145 local_T = _process_data.temperature->getNodalValuesOnElement(
2146 _element, t);
2147 }
2148 else
2149 {
2150 local_T = NodalVectorType::Zero(temperature_size);
2151 }
2152 }
2153 else
2154 {
2155 local_T =
2156 local_x.template segment<temperature_size>(temperature_index);
2157 }
2158 return local_T;
2159 }

References _element, _process_data, temperature_index, and temperature_size.

Referenced by assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleHydraulicEquation(), and computeSecondaryVariableConcrete().

◆ getShapeMatrix()

template<typename ShapeFunction, int GlobalDim>
Eigen::Map< const Eigen::RowVectorXd > ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getShapeMatrix ( const unsigned integration_point) const
inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 1811 of file ComponentTransportFEM.h.

1813 {
1814 auto const& N = _process_data.shape_matrix_cache.NsHigherOrder<
1815 typename ShapeFunction::MeshElement>()[integration_point];
1816
1817 // assumes N is stored contiguously in memory
1818 return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
1819 }

References _process_data.

◆ getThermalConductivityDispersivity()

template<typename ShapeFunction, int GlobalDim>
GlobalDimMatrixType ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::getThermalConductivityDispersivity ( MaterialPropertyLib::VariableArray const & vars,
const double fluid_density,
const double specific_heat_capacity_fluid,
const GlobalDimVectorType & velocity,
ParameterLib::SpatialPosition const & pos,
double const t,
double const dt )
inlineprivate

Definition at line 2096 of file ComponentTransportFEM.h.

2102 {
2103 auto const& medium =
2104 *_process_data.media_map.getMedium(_element.getID());
2105
2106 auto thermal_conductivity =
2107 MaterialPropertyLib::formEigenTensor<GlobalDim>(
2108 medium
2109 .property(
2110 MaterialPropertyLib::PropertyType::thermal_conductivity)
2111 .value(vars, pos, t, dt));
2112
2113 auto const thermal_dispersivity_transversal =
2114 medium
2115 .property(MaterialPropertyLib::PropertyType::
2116 thermal_transversal_dispersivity)
2117 .template value<double>();
2118
2119 auto const thermal_dispersivity_longitudinal =
2120 medium
2121 .property(MaterialPropertyLib::PropertyType::
2122 thermal_longitudinal_dispersivity)
2123 .template value<double>();
2124
2125 // Thermal conductivity is moved outside and zero matrix is passed
2126 // instead due to multiplication with fluid's density times specific
2127 // heat capacity.
2128 return thermal_conductivity +
2129 fluid_density * specific_heat_capacity_fluid *
2130 NumLib::computeHydrodynamicDispersion(
2131 _process_data.stabilizer, _element.getID(),
2132 GlobalDimMatrixType::Zero(GlobalDim, GlobalDim),
2133 velocity, 0 /* phi */, thermal_dispersivity_transversal,
2134 thermal_dispersivity_longitudinal);
2135 }

References _element, _process_data, NumLib::computeHydrodynamicDispersion(), MaterialPropertyLib::formEigenTensor(), and MaterialPropertyLib::thermal_conductivity.

Referenced by assembleHeatTransportEquation().

◆ initializeChemicalSystemConcrete()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::initializeChemicalSystemConcrete ( Eigen::VectorXd const & local_x,
double const t )
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 313 of file ComponentTransportFEM.h.

315 {
316 assert(_process_data.chemical_solver_interface);
317
318 auto const& medium =
319 *_process_data.media_map.getMedium(_element.getID());
320
321 ParameterLib::SpatialPosition pos;
322 pos.setElementID(_element.getID());
323
324 auto const& Ns =
325 _process_data.shape_matrix_cache
326 .NsHigherOrder<typename ShapeFunction::MeshElement>();
327
328 unsigned const n_integration_points =
329 _integration_method.getNumberOfPoints();
330
331 for (unsigned ip = 0; ip < n_integration_points; ip++)
332 {
333 auto& ip_data = _ip_data[ip];
334 auto const& N = Ns[ip];
335 auto const& chemical_system_id = ip_data.chemical_system_id;
336
337 // set position with N as the shape matrix at the current
338 // integration point
339 pos.setCoordinates(MathLib::Point3d(
340 NumLib::interpolateCoordinates<ShapeFunction,
341 ShapeMatricesType>(_element,
342 N)));
343
344 auto const n_component = _transport_process_variables.size();
345 std::vector<double> C_int_pt(n_component);
346 for (unsigned component_id = 0; component_id < n_component;
347 ++component_id)
348 {
349 auto const concentration_index =
350 first_concentration_index +
351 component_id * concentration_size;
352 auto const local_C =
353 local_x.template segment<concentration_size>(
354 concentration_index);
355
356 NumLib::shapeFunctionInterpolate(local_C, N,
357 C_int_pt[component_id]);
358 }
359
360 _process_data.chemical_solver_interface
361 ->initializeChemicalSystemConcrete(C_int_pt, chemical_system_id,
362 medium, pos, t);
363 }
364 }

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, concentration_size, first_concentration_index, NumLib::interpolateCoordinates(), ParameterLib::SpatialPosition::setCoordinates(), ParameterLib::SpatialPosition::setElementID(), and NumLib::detail::shapeFunctionInterpolate().

◆ postSpeciationCalculation()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::postSpeciationCalculation ( std::size_t const ele_id,
double const t,
double const dt )
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 431 of file ComponentTransportFEM.h.

433 {
434 if (!_process_data.chemically_induced_porosity_change)
435 {
436 return;
437 }
438
439 auto const& medium = *_process_data.media_map.getMedium(ele_id);
440
441 ParameterLib::SpatialPosition pos;
442 pos.setElementID(ele_id);
443
444 for (auto& ip_data : _ip_data)
445 {
446 ip_data.porosity = ip_data.porosity_prev;
447
448 _process_data.chemical_solver_interface
449 ->updateVolumeFractionPostReaction(ip_data.chemical_system_id,
450 medium, pos,
451 ip_data.porosity, t, dt);
452
453 _process_data.chemical_solver_interface->updatePorosityPostReaction(
454 ip_data.chemical_system_id, medium, ip_data.porosity);
455 }
456 }

References _ip_data, _process_data, and ParameterLib::SpatialPosition::setElementID().

◆ postTimestepConcrete()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::postTimestepConcrete ( Eigen::VectorXd const & ,
Eigen::VectorXd const & ,
double const ,
double const ,
int const  )
inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 2048 of file ComponentTransportFEM.h.

2052 {
2053 unsigned const n_integration_points =
2054 _integration_method.getNumberOfPoints();
2055
2056 for (unsigned ip = 0; ip < n_integration_points; ip++)
2057 {
2058 _ip_data[ip].pushBackState();
2059 }
2060 }

References _integration_method, and _ip_data.

◆ setChemicalSystemConcrete()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::setChemicalSystemConcrete ( Eigen::VectorXd const & local_x,
double const t,
double dt )
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 366 of file ComponentTransportFEM.h.

368 {
369 assert(_process_data.chemical_solver_interface);
370
371 auto const& medium =
372 _process_data.media_map.getMedium(_element.getID());
373
374 MaterialPropertyLib::VariableArray vars;
375 MaterialPropertyLib::VariableArray vars_prev;
376
377 ParameterLib::SpatialPosition pos;
378 pos.setElementID(_element.getID());
379
380 auto const& Ns =
381 _process_data.shape_matrix_cache
382 .NsHigherOrder<typename ShapeFunction::MeshElement>();
383
384 unsigned const n_integration_points =
385 _integration_method.getNumberOfPoints();
386
387 for (unsigned ip = 0; ip < n_integration_points; ip++)
388 {
389 auto& ip_data = _ip_data[ip];
390 auto const& N = Ns[ip];
391 auto& porosity = ip_data.porosity;
392 auto const& porosity_prev = ip_data.porosity_prev;
393 auto const& chemical_system_id = ip_data.chemical_system_id;
394
395 auto const n_component = _transport_process_variables.size();
396 std::vector<double> C_int_pt(n_component);
397 for (unsigned component_id = 0; component_id < n_component;
398 ++component_id)
399 {
400 auto const concentration_index =
401 first_concentration_index +
402 component_id * concentration_size;
403 auto const local_C =
404 local_x.template segment<concentration_size>(
405 concentration_index);
406
407 NumLib::shapeFunctionInterpolate(local_C, N,
408 C_int_pt[component_id]);
409 }
410
411 {
412 vars_prev.porosity = porosity_prev;
413
414 porosity =
415 _process_data.chemically_induced_porosity_change
416 ? porosity_prev
417 : medium
418 ->property(
419 MaterialPropertyLib::PropertyType::porosity)
420 .template value<double>(vars, vars_prev, pos, t,
421 dt);
422
423 vars.porosity = porosity;
424 }
425
426 _process_data.chemical_solver_interface->setChemicalSystemConcrete(
427 C_int_pt, chemical_system_id, medium, vars, pos, t, dt);
428 }
429 }

References _element, _integration_method, _ip_data, _process_data, _transport_process_variables, concentration_size, first_concentration_index, MaterialPropertyLib::porosity, MaterialPropertyLib::VariableArray::porosity, ParameterLib::SpatialPosition::setElementID(), and NumLib::detail::shapeFunctionInterpolate().

◆ setChemicalSystemID()

template<typename ShapeFunction, int GlobalDim>
void ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::setChemicalSystemID ( std::size_t const )
inlineoverridevirtual

Implements ProcessLib::ComponentTransport::ComponentTransportLocalAssemblerInterface.

Definition at line 293 of file ComponentTransportFEM.h.

294 {
295 assert(_process_data.chemical_solver_interface);
296 // chemical system index map
297 auto& chemical_system_index_map =
298 _process_data.chemical_solver_interface->chemical_system_index_map;
299
300 unsigned const n_integration_points =
301 _integration_method.getNumberOfPoints();
302 for (unsigned ip = 0; ip < n_integration_points; ip++)
303 {
304 _ip_data[ip].chemical_system_id =
305 chemical_system_index_map.empty()
306 ? 0
307 : chemical_system_index_map.back() + 1;
308 chemical_system_index_map.push_back(
309 _ip_data[ip].chemical_system_id);
310 }
311 }

References _integration_method, _ip_data, and _process_data.

Member Data Documentation

◆ _element

template<typename ShapeFunction, int GlobalDim>
MeshLib::Element const& ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::_element
private

Definition at line 2063 of file ComponentTransportFEM.h.

Referenced by LocalAssemblerData(), assemble(), assembleBlockMatrices(), assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleHydraulicEquation(), assembleKCmCn(), assembleReactionEquationConcrete(), assembleWithJacobianComponentTransportEquation(), assembleWithJacobianHydraulicEquation(), calculateIntPtDarcyVelocity(), computeSecondaryVariableConcrete(), getFlux(), getIntPtDarcyVelocity(), getIntPtMolarFlux(), getLocalTemperature(), getThermalConductivityDispersivity(), initializeChemicalSystemConcrete(), and setChemicalSystemConcrete().

◆ _integration_method

template<typename ShapeFunction, int GlobalDim>
NumLib::GenericIntegrationMethod const& ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::_integration_method
private

Definition at line 2066 of file ComponentTransportFEM.h.

Referenced by LocalAssemblerData(), assembleBlockMatrices(), assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleHydraulicEquation(), assembleKCmCn(), assembleReactionEquationConcrete(), assembleWithJacobianComponentTransportEquation(), assembleWithJacobianHydraulicEquation(), calculateIntPtDarcyVelocity(), computeReactionRelatedSecondaryVariable(), computeSecondaryVariableConcrete(), getIntPtMolarFlux(), initializeChemicalSystemConcrete(), postTimestepConcrete(), setChemicalSystemConcrete(), and setChemicalSystemID().

◆ _ip_data

template<typename ShapeFunction, int GlobalDim>
std::vector<IntegrationPointData<GlobalDimNodalMatrixType> > ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::_ip_data
private

Definition at line 2070 of file ComponentTransportFEM.h.

Referenced by LocalAssemblerData(), assembleBlockMatrices(), assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleHydraulicEquation(), assembleKCmCn(), assembleReactionEquationConcrete(), assembleWithJacobianComponentTransportEquation(), assembleWithJacobianHydraulicEquation(), calculateIntPtDarcyVelocity(), computeReactionRelatedSecondaryVariable(), getIntPtMolarFlux(), initializeChemicalSystemConcrete(), postSpeciationCalculation(), postTimestepConcrete(), setChemicalSystemConcrete(), and setChemicalSystemID().

◆ _process_data

template<typename ShapeFunction, int GlobalDim>
ComponentTransportProcessData const& ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::_process_data
private

Definition at line 2064 of file ComponentTransportFEM.h.

Referenced by LocalAssemblerData(), assemble(), assembleBlockMatrices(), assembleComponentTransportEquation(), assembleForStaggeredScheme(), assembleHeatTransportEquation(), assembleHydraulicEquation(), assembleKCmCn(), assembleReactionEquationConcrete(), assembleWithJacobianComponentTransportEquation(), assembleWithJacobianForStaggeredScheme(), assembleWithJacobianHydraulicEquation(), calculateIntPtDarcyVelocity(), computeReactionRelatedSecondaryVariable(), computeSecondaryVariableConcrete(), getFlux(), getHeatEnergyCoefficient(), getIntPtDarcyVelocity(), getIntPtMolarFlux(), getLocalTemperature(), getShapeMatrix(), getThermalConductivityDispersivity(), initializeChemicalSystemConcrete(), postSpeciationCalculation(), setChemicalSystemConcrete(), and setChemicalSystemID().

◆ _transport_process_variables

template<typename ShapeFunction, int GlobalDim>
std::vector<std::reference_wrapper<ProcessVariable> > const ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::_transport_process_variables
private

Definition at line 2068 of file ComponentTransportFEM.h.

Referenced by LocalAssemblerData(), assemble(), assembleBlockMatrices(), assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleKCmCn(), assembleWithJacobianComponentTransportEquation(), getIntPtMolarFlux(), initializeChemicalSystemConcrete(), and setChemicalSystemConcrete().

◆ concentration_size

template<typename ShapeFunction, int GlobalDim>
const int ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::concentration_size
staticprivate
Initial value:
=
ShapeFunction::NPOINTS

Definition at line 216 of file ComponentTransportFEM.h.

Referenced by assemble(), assembleBlockMatrices(), assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleHydraulicEquation(), assembleReactionEquationConcrete(), assembleWithJacobianComponentTransportEquation(), assembleWithJacobianHydraulicEquation(), getFlux(), getIntPtDarcyVelocity(), getIntPtMolarFlux(), initializeChemicalSystemConcrete(), and setChemicalSystemConcrete().

◆ first_concentration_index

template<typename ShapeFunction, int GlobalDim>
const int ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::first_concentration_index = -1
private

Definition at line 212 of file ComponentTransportFEM.h.

Referenced by LocalAssemblerData(), assembleComponentTransportEquation(), assembleHydraulicEquation(), assembleReactionEquationConcrete(), assembleWithJacobianComponentTransportEquation(), assembleWithJacobianHydraulicEquation(), computeSecondaryVariableConcrete(), getFlux(), getIntPtDarcyVelocity(), getIntPtMolarFlux(), initializeChemicalSystemConcrete(), and setChemicalSystemConcrete().

◆ pressure_index

template<typename ShapeFunction, int GlobalDim>
const int ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::pressure_index = 0
staticprivate

Definition at line 210 of file ComponentTransportFEM.h.

Referenced by assemble(), assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleHydraulicEquation(), assembleWithJacobianComponentTransportEquation(), assembleWithJacobianHydraulicEquation(), computeSecondaryVariableConcrete(), getFlux(), getIntPtDarcyVelocity(), and getIntPtMolarFlux().

◆ pressure_size

template<typename ShapeFunction, int GlobalDim>
const int ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::pressure_size = ShapeFunction::NPOINTS
staticprivate

Definition at line 214 of file ComponentTransportFEM.h.

Referenced by assemble(), assembleComponentTransportEquation(), assembleHeatTransportEquation(), assembleHydraulicEquation(), assembleWithJacobianHydraulicEquation(), getFlux(), and getIntPtDarcyVelocity().

◆ temperature_index

template<typename ShapeFunction, int GlobalDim>
const int ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::temperature_index = -1
private

Definition at line 211 of file ComponentTransportFEM.h.

Referenced by LocalAssemblerData(), getIntPtDarcyVelocity(), and getLocalTemperature().

◆ temperature_size

template<typename ShapeFunction, int GlobalDim>
const int ProcessLib::ComponentTransport::LocalAssemblerData< ShapeFunction, GlobalDim >::temperature_size = ShapeFunction::NPOINTS
staticprivate

Definition at line 215 of file ComponentTransportFEM.h.

Referenced by assembleComponentTransportEquation(), assembleHeatTransportEquation(), getIntPtDarcyVelocity(), and getLocalTemperature().

The documentation for this class was generated from the following file: