Detailed Description

template<typename ShapeFunction, typename BHEType>
class ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >

Definition at line 21 of file HeatTransportBHELocalAssemblerBHE.h.

#include <HeatTransportBHELocalAssemblerBHE.h>

Inheritance diagram for ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >:

[legend]

Collaboration diagram for ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >:

[legend]

Public Types
using	ShapeMatricesType
using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices
using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType
using	NodalVectorType = typename ShapeMatricesType::NodalVectorType
using	BheLocalMatrixType
using	BheLocalVectorType

Public Member Functions
	HeatTransportBHELocalAssemblerBHE (HeatTransportBHELocalAssemblerBHE const &)=delete
	HeatTransportBHELocalAssemblerBHE (HeatTransportBHELocalAssemblerBHE &&)=delete
	HeatTransportBHELocalAssemblerBHE (MeshLib::Element const &e, NumLib::GenericIntegrationMethod const &integration_method, BHEType const &bhe, bool const is_axially_symmetric, HeatTransportBHEProcessData &process_data, BHEMeshData const &bhe_mesh_data)
void	assemble (double const, double const, std::vector< double > const &, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &) override
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_rhs_data, std::vector< double > &local_Jac_data) override
Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point.
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	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)
virtual 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)
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< double > const &) const
virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< std::vector< double > > const &) const
	Fits to staggered scheme.
virtual int	getNumberOfVectorElementsForDeformation () const
Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Private Attributes
HeatTransportBHEProcessData &	_process_data
std::vector< IntegrationPointDataBHE< ShapeMatricesType >, Eigen::aligned_allocator< IntegrationPointDataBHE< ShapeMatricesType > > >	_ip_data
NumLib::GenericIntegrationMethod const &	_integration_method
BHEType const &	_bhe
std::size_t const	_element_id
BHEMeshData const &	_bhe_mesh_data
SecondaryData< typename ShapeMatrices::ShapeType >	_secondary_data
Eigen::Vector3d	_element_direction
int	_section_index = 0
ShapeMatricesType::template MatrixType< bhe_unknowns_size, bhe_unknowns_size >	_R_matrix
ShapeMatricesType::template MatrixType< soil_temperature_size, soil_temperature_size >	_R_s_matrix
ShapeMatricesType::template MatrixType< bhe_unknowns_size, soil_temperature_size >	_R_pi_s_matrix

Static Private Attributes
static constexpr int	bhe_unknowns = BHEType::number_of_unknowns
static constexpr int	single_bhe_unknowns_size = ShapeFunction::NPOINTS
static constexpr int	soil_temperature_size = ShapeFunction::NPOINTS
static constexpr int	soil_temperature_index = 0
static constexpr int	bhe_unknowns_size
static constexpr int	bhe_unknowns_index = ShapeFunction::NPOINTS
static constexpr int	local_matrix_size

Member Typedef Documentation

◆ BheLocalMatrixType

template<typename ShapeFunction, typename BHEType>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::BheLocalMatrixType

Initial value:

 
        typename ShapeMatricesType::template MatrixType<local_matrix_size,
                                                        local_matrix_size>

Definition at line 42 of file HeatTransportBHELocalAssemblerBHE.h.

◆ BheLocalVectorType

template<typename ShapeFunction, typename BHEType>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::BheLocalVectorType

Initial value:

typename ShapeMatricesType::template VectorType<local_matrix_size>

Definition at line 45 of file HeatTransportBHELocalAssemblerBHE.h.

◆ NodalMatrixType

template<typename ShapeFunction, typename BHEType>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

Definition at line 38 of file HeatTransportBHELocalAssemblerBHE.h.

◆ NodalVectorType

template<typename ShapeFunction, typename BHEType>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

Definition at line 39 of file HeatTransportBHELocalAssemblerBHE.h.

◆ ShapeMatrices

template<typename ShapeFunction, typename BHEType>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 37 of file HeatTransportBHELocalAssemblerBHE.h.

◆ ShapeMatricesType

template<typename ShapeFunction, typename BHEType>

using ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::ShapeMatricesType

Initial value:

ShapeMatrixPolicyType<ShapeFunction, 3 >

ShapeMatrixPolicyType

EigenFixedShapeMatrixPolicy< ShapeFunction, GlobalDim > ShapeMatrixPolicyType

Definition ShapeMatrixPolicy.h:134

Definition at line 35 of file HeatTransportBHELocalAssemblerBHE.h.

Constructor & Destructor Documentation

◆ HeatTransportBHELocalAssemblerBHE() [1/3]

template<typename ShapeFunction, typename BHEType>

ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::HeatTransportBHELocalAssemblerBHE ( HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType > const & )

delete

References HeatTransportBHELocalAssemblerBHE().

Referenced by HeatTransportBHELocalAssemblerBHE(), and HeatTransportBHELocalAssemblerBHE().

◆ HeatTransportBHELocalAssemblerBHE() [2/3]

template<typename ShapeFunction, typename BHEType>

ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::HeatTransportBHELocalAssemblerBHE ( HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType > && )

delete

References HeatTransportBHELocalAssemblerBHE().

◆ HeatTransportBHELocalAssemblerBHE() [3/3]

template<typename ShapeFunction, typename BHEType>

ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::HeatTransportBHELocalAssemblerBHE	(	MeshLib::Element const &	e,
		NumLib::GenericIntegrationMethod const &	integration_method,
		BHEType const &	bhe,
		bool const	is_axially_symmetric,
		HeatTransportBHEProcessData &	process_data,
		BHEMeshData const &	bhe_mesh_data )

Definition at line 18 of file HeatTransportBHELocalAssemblerBHE-impl.h.

    : _process_data(process_data),
      _integration_method(integration_method),
      _bhe(bhe),
      _element_id(e.getID()),
      _bhe_mesh_data(bhe_mesh_data)
{
    // need to make sure that the BHE elements are one-dimensional
    assert(e.getDimension() == 1);
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    _ip_data.reserve(n_integration_points);
    _secondary_data.N.resize(n_integration_points);
 
    auto const shape_matrices =
        NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                  3 /* GlobalDim */>(e, is_axially_symmetric,
                                                     _integration_method);
 
    // ip data initialization
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& sm = shape_matrices[ip];
        // create the class IntegrationPointDataBHE in place
        _ip_data.push_back(
            {sm.N, sm.dNdx,
             _integration_method.getWeightedPoint(ip).getWeight() *
                 sm.integralMeasure * sm.detJ});
 
        _secondary_data.N[ip] = sm.N;
    }
 
    // calculate the element direction vector
    auto const& p0 = e.getNode(0)->asEigenVector3d();
    auto const& p1 = e.getNode(1)->asEigenVector3d();
 
    _element_direction = (p1 - p0).normalized();
 
    auto const section_it =
        _bhe_mesh_data.BHE_element_section_indices.find(_element_id);
    if (section_it == _bhe_mesh_data.BHE_element_section_indices.end())
    {
        OGS_FATAL(
            "Could not read BHE element section index for element id "
            "{:d}.",
            _element_id);
    }
 
    _section_index = section_it->second;
    if (_section_index < 0)
    {
        OGS_FATAL(
            "Invalid BHE section index for element id {:d}. Check BHE mesh "
            "data initialisation.",
            _element_id);
    }
 
    _R_matrix.setZero(bhe_unknowns_size, bhe_unknowns_size);
    _R_pi_s_matrix.setZero(bhe_unknowns_size, soil_temperature_size);
    _R_s_matrix.setZero(soil_temperature_size, soil_temperature_size);
    static constexpr int max_num_thermal_exchange_terms = 5;
    // Formulate the local BHE R matrix.
    // Only unknowns with thermal exchange terms need resistance assembly.
    // In CXA/CXC there are 3 exchange terms (= number of unknowns),
    // in 1U there are 4 (= number of unknowns),
    // in 2U there are 5 but 8 unknowns — unknowns 5-7 (extra grout zones)
    // have no exchange terms. See Diersch (2013) FEFLOW, M.127-M.128.
    for (int idx_bhe_unknowns = 0;
         idx_bhe_unknowns <
         std::min(bhe_unknowns, max_num_thermal_exchange_terms);
         idx_bhe_unknowns++)
    {
        typename ShapeMatricesType::template MatrixType<
            single_bhe_unknowns_size, single_bhe_unknowns_size>
            matBHE_loc_R = ShapeMatricesType::template MatrixType<
                single_bhe_unknowns_size,
                single_bhe_unknowns_size>::Zero(single_bhe_unknowns_size,
                                                single_bhe_unknowns_size);
        // Loop over Gauss points
        for (unsigned ip = 0; ip < n_integration_points; ip++)
        {
            auto const& N = _ip_data[ip].N;
            auto const& w = _ip_data[ip].integration_weight;
 
            // Get thermal resistance for this element's section
            auto const& R = _bhe.thermalResistanceAtSection(idx_bhe_unknowns,
                                                            _section_index);
            // calculate mass matrix for current unknown
            matBHE_loc_R += N.transpose() * N * (1 / R) * w;
        }  // end of loop over integration point
 
        _bhe.template assembleRMatrices<ShapeFunction::NPOINTS>(
            idx_bhe_unknowns, matBHE_loc_R, _R_matrix, _R_pi_s_matrix,
            _R_s_matrix);
    }  // end of loop over BHE unknowns
}

References _bhe, _bhe_mesh_data, _element_direction, _element_id, _integration_method, _ip_data, _process_data, _R_matrix, _R_pi_s_matrix, _R_s_matrix, _secondary_data, _section_index, MathLib::Point3d::asEigenVector3d(), bhe_unknowns, bhe_unknowns_size, MeshLib::Element::getDimension(), MeshLib::Element::getNode(), NumLib::initShapeMatrices(), OGS_FATAL, single_bhe_unknowns_size, and soil_temperature_size.

Member Function Documentation

◆ assemble()

template<typename ShapeFunction, typename BHEType>

void ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::assemble	(	double const	,
		double const	,
		std::vector< double > const &	,
		std::vector< double > const &	,
		std::vector< double > &	local_M_data,
		std::vector< double > &	local_K_data,
		std::vector< double > &	)

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 125 of file HeatTransportBHELocalAssemblerBHE-impl.h.

{
    auto local_M = MathLib::createZeroedMatrix<BheLocalMatrixType>(
        local_M_data, local_matrix_size, local_matrix_size);
    auto local_K = MathLib::createZeroedMatrix<BheLocalMatrixType>(
        local_K_data, local_matrix_size, local_matrix_size);
 
    unsigned const n_integration_points =
        _integration_method.getNumberOfPoints();
 
    auto const& pipe_heat_capacities = _bhe.pipeHeatCapacities();
    auto const& pipe_heat_conductions =
        _bhe.pipeHeatConductions(_section_index);
    auto const& pipe_advection_vectors =
        _bhe.pipeAdvectionVectors(_element_direction, _section_index);
    auto const& cross_section_areas = _bhe.crossSectionAreas(_section_index);
 
    // the mass and conductance matrix terms
    for (unsigned ip = 0; ip < n_integration_points; ip++)
    {
        auto const& ip_data = _ip_data[ip];
 
        auto const& w = ip_data.integration_weight;
        auto const& N = ip_data.N;
        auto const& dNdx = ip_data.dNdx;
 
        // looping over all unknowns.
        for (int idx_bhe_unknowns = 0; idx_bhe_unknowns < bhe_unknowns;
             idx_bhe_unknowns++)
        {
            // get coefficient of mass from corresponding BHE.
            auto const& mass_coeff = pipe_heat_capacities[idx_bhe_unknowns];
            auto const& lambda = pipe_heat_conductions[idx_bhe_unknowns];
            auto const& advection_vector =
                pipe_advection_vectors[idx_bhe_unknowns];
            auto const& A = cross_section_areas[idx_bhe_unknowns];
 
            int const single_bhe_unknowns_index =
                bhe_unknowns_index +
                single_bhe_unknowns_size * idx_bhe_unknowns;
            // local M
            local_M
                .template block<single_bhe_unknowns_size,
                                single_bhe_unknowns_size>(
                    single_bhe_unknowns_index, single_bhe_unknowns_index)
                .noalias() += N.transpose() * N * mass_coeff * A * w;
 
            // local K
            // laplace part
            local_K
                .template block<single_bhe_unknowns_size,
                                single_bhe_unknowns_size>(
                    single_bhe_unknowns_index, single_bhe_unknowns_index)
                .noalias() += dNdx.transpose() * dNdx * lambda * A * w;
            // advection part
            local_K
                .template block<single_bhe_unknowns_size,
                                single_bhe_unknowns_size>(
                    single_bhe_unknowns_index, single_bhe_unknowns_index)
                .noalias() +=
                N.transpose() * advection_vector.transpose() * dNdx * A * w;
        }
    }
 
    // add the R matrix to local_K
    local_K.template block<bhe_unknowns_size, bhe_unknowns_size>(
        bhe_unknowns_index, bhe_unknowns_index) += _R_matrix;
 
    // add the R_pi_s matrix to local_K
    local_K
        .template block<bhe_unknowns_size, soil_temperature_size>(
            bhe_unknowns_index, soil_temperature_index)
        .noalias() += _R_pi_s_matrix;
    local_K
        .template block<soil_temperature_size, bhe_unknowns_size>(
            soil_temperature_index, bhe_unknowns_index)
        .noalias() += _R_pi_s_matrix.transpose();
 
    // add the R_s matrix to local_K
    local_K
        .template block<soil_temperature_size, soil_temperature_size>(
            soil_temperature_index, soil_temperature_index)
        .noalias() += _bhe.number_of_grout_zones * _R_s_matrix;
}

References _bhe, _element_direction, _integration_method, _ip_data, _R_matrix, _R_pi_s_matrix, _R_s_matrix, _section_index, bhe_unknowns, bhe_unknowns_index, MathLib::createZeroedMatrix(), local_matrix_size, single_bhe_unknowns_size, and soil_temperature_index.

Referenced by assembleWithJacobian().

◆ assembleWithJacobian()

template<typename ShapeFunction, typename BHEType>

void ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::assembleWithJacobian	(	double const	t,
		double const	dt,
		std::vector< double > const &	local_x,
		std::vector< double > const &	local_x_prev,
		std::vector< double > &	local_rhs_data,
		std::vector< double > &	local_Jac_data )

overridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 216 of file HeatTransportBHELocalAssemblerBHE-impl.h.

{
    auto const local_matrix_size = local_x.size();
    // initialize x and x_prev
    auto x =
        Eigen::Map<BheLocalVectorType const>(local_x.data(), local_matrix_size);
    auto x_prev = Eigen::Map<BheLocalVectorType const>(local_x_prev.data(),
                                                       local_matrix_size);
    // initialize local_Jac and local_rhs
    auto local_Jac = MathLib::createZeroedMatrix<BheLocalMatrixType>(
        local_Jac_data, local_matrix_size, local_matrix_size);
    auto local_rhs = MathLib::createZeroedVector<BheLocalVectorType>(
        local_rhs_data, local_matrix_size);
 
    std::vector<double> local_M_data;
    std::vector<double> local_K_data;
    assemble(t, dt, local_x, local_x_prev, local_M_data, local_K_data,
             local_rhs_data /*not going to be used*/);
 
    // convert to matrix
    auto local_M = MathLib::toMatrix<BheLocalMatrixType>(
        local_M_data, local_matrix_size, local_matrix_size);
    auto local_K = MathLib::toMatrix<BheLocalMatrixType>(
        local_K_data, local_matrix_size, local_matrix_size);
 
    // Jac matrix and rhs vector operation
    local_Jac.noalias() += local_K + local_M / dt;
    local_rhs.noalias() -= local_K * x + local_M * (x - x_prev) / dt;
 
    local_M.setZero();
    local_K.setZero();
}

References assemble(), MathLib::createZeroedMatrix(), MathLib::createZeroedVector(), local_matrix_size, and MathLib::toMatrix().

◆ getShapeMatrix()

template<typename ShapeFunction, typename BHEType>

Eigen::Map< const Eigen::RowVectorXd > ProcessLib::HeatTransportBHE::HeatTransportBHELocalAssemblerBHE< ShapeFunction, BHEType >::getShapeMatrix ( const unsigned integration_point ) const

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 74 of file HeatTransportBHELocalAssemblerBHE.h.

    {
        auto const& N = _secondary_data.N[integration_point];
 
        // assumes N is stored contiguously in memory
        return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
    }