ProcessLib::HeatTransportBHE::HeatTransportBHEProcess Class Reference

Detailed Description

Definition at line 18 of file HeatTransportBHEProcess.h.

#include <HeatTransportBHEProcess.h>

Inheritance diagram for ProcessLib::HeatTransportBHE::HeatTransportBHEProcess:

Collaboration diagram for ProcessLib::HeatTransportBHE::HeatTransportBHEProcess:

Public Member Functions
	HeatTransportBHEProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&process_variables, HeatTransportBHEProcessData &&process_data, SecondaryVariableCollection &&secondary_variables, BHEMeshData &&bhe_mesh_data)
void	computeSecondaryVariableConcrete (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id) override
ODESystem interface
bool	isLinear () const override
bool	requiresNormalization () const override
Public Member Functions inherited from ProcessLib::Process
	Process (std::string name_, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&process_variables, SecondaryVariableCollection &&secondary_variables, const bool use_monolithic_scheme=true)
void	preTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id)
	Preprocessing before starting assembly for new timestep.
void	postTimestep (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double delta_t, int const process_id)
	Postprocessing after a complete timestep.
void	postNonLinearSolver (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, double const dt, int const process_id)
void	preIteration (const unsigned iter, GlobalVector const &x) final
void	computeSecondaryVariable (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id)
	compute secondary variables for the coupled equations or for output.
NumLib::IterationResult	postIteration (GlobalVector const &x) final
void	initialize (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
void	setInitialConditions (std::vector< GlobalVector * > &process_solutions, std::vector< GlobalVector * > const &process_solutions_prev, double const t, int const process_id)
MathLib::MatrixSpecifications	getMatrixSpecifications (const int process_id) const override
void	updateDeactivatedSubdomains (double const time, const int process_id)
virtual bool	isMonolithicSchemeUsed () const
virtual void	extrapolateIntegrationPointValuesToNodes (const double, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > &)
void	preAssemble (const double t, double const dt, GlobalVector const &x) final
void	assemble (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) final
void	assembleWithJacobian (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac) final
void	preOutput (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)
std::vector< NumLib::IndexValueVector< GlobalIndexType > > const *	getKnownSolutions (double const t, GlobalVector const &x, int const process_id) const final
virtual NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int) const
MeshLib::Mesh &	getMesh () const
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > const &	getProcessVariables () const
std::vector< std::reference_wrapper< ProcessVariable > > const &	getProcessVariables (const int process_id) const
std::vector< std::size_t > const &	getActiveElementIDs () const
SecondaryVariableCollection const &	getSecondaryVariables () const
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const &	getIntegrationPointWriters () const
virtual Eigen::Vector3d	getFlux (std::size_t, MathLib::Point3d const &, double const, std::vector< GlobalVector * > const &) const
virtual void	solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int const)
bool	requiresNormalization () const override
Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual	~SubmeshAssemblySupport ()=default

Private Member Functions
void	constructDofTable () override
void	initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order) override
	Process specific initialization called by initialize().
std::vector< std::vector< std::string > >	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes) override
void	assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) override
void	assembleWithJacobianConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac) override
void	createBHEEndpointBoundaryConditions ()
void	preTimestepConcreteProcess (std::vector< GlobalVector * > const &x, const double t, const double dt, int const process_id) override
void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double dt, int const process_id) override
void	algebraicBcConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b)
NumLib::IterationResult	postIterationConcreteProcess (GlobalVector const &x) override
Private Member Functions inherited from ProcessLib::AssemblyMixin< HeatTransportBHEProcess >
void	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &submeshes, std::vector< std::vector< std::string > > const &residuum_names)
void	updateActiveElements ()
void	assemble (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, std::vector< std::size_t > const *const sorted_element_subset=nullptr, bool const copy_residua_to_mesh=false)
void	assembleWithJacobian (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac, std::vector< std::size_t > const *const sorted_element_subset=nullptr, bool const copy_residua_to_mesh=false)
void	preOutput (double const t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)

Private Attributes
HeatTransportBHEProcessData	_process_data
std::vector< std::unique_ptr< HeatTransportBHELocalAssemblerInterface > >	local_assemblers_
std::vector< std::unique_ptr< MeshLib::MeshSubset const > >	_mesh_subset_BHE_nodes
std::vector< std::unique_ptr< MeshLib::MeshSubset const > >	_mesh_subset_BHE_soil_nodes
std::vector< std::tuple< std::size_t, GlobalIndexType, GlobalIndexType > >	vec_inflow_BHE_node_indices_
std::vector< std::tuple< std::size_t, GlobalIndexType, GlobalIndexType > >	vec_outflow_BHE_node_indices_
std::unique_ptr< MeshLib::MeshSubset const >	_mesh_subset_soil_nodes
const BHEMeshData	_bheMeshData
std::vector< std::size_t >	_bhes_element_ids
std::vector< std::size_t >	_soil_element_ids

Friends
class	AssemblyMixin< HeatTransportBHEProcess >

Additional Inherited Members
Public Attributes inherited from ProcessLib::Process
std::string const	name
Static Public Attributes inherited from ProcessLib::Process
static PROCESSLIB_EXPORT const std::string	constant_one_parameter_name = "constant_one"
Protected Member Functions inherited from ProcessLib::Process
std::vector< NumLib::LocalToGlobalIndexMap const * >	getDOFTables (int const number_of_processes) const
NumLib::Extrapolator &	getExtrapolator () const
NumLib::LocalToGlobalIndexMap const &	getSingleComponentDOFTable () const
void	initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
void	constructMonolithicProcessDofTable ()
void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_process_id)
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const
std::vector< GlobalIndexType >	getIndicesOfResiduumWithoutInitialCompensation () const override
void	setReleaseNodalForces (GlobalVector const *r_neq, int const process_id) override
Protected Attributes inherited from ProcessLib::Process
MeshLib::Mesh &	_mesh
std::unique_ptr< MeshLib::MeshSubset const >	_mesh_subset_all_nodes
std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map
SecondaryVariableCollection	_secondary_variables
CellAverageData	cell_average_data_
std::unique_ptr< ProcessLib::AbstractJacobianAssembler >	_jacobian_assembler
VectorMatrixAssembler	_global_assembler
const bool	_use_monolithic_scheme
unsigned const	_integration_order
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > >	_integration_point_writer
GlobalSparsityPattern	_sparsity_pattern
std::vector< std::vector< std::reference_wrapper< ProcessVariable > > >	_process_variables
std::vector< BoundaryConditionCollection >	_boundary_conditions

Constructor & Destructor Documentation

HeatTransportBHEProcess()

ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::HeatTransportBHEProcess	(	std::string	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		unsigned const	integration_order,
		std::vector< std::vector< std::reference_wrapper< ProcessVariable > > > &&	process_variables,
		HeatTransportBHEProcessData &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		BHEMeshData &&	bhe_mesh_data )

Definition at line 22 of file HeatTransportBHEProcess.cpp.

    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
              integration_order, std::move(process_variables),
              std::move(secondary_variables)),
      AssemblyMixin<HeatTransportBHEProcess>{*_jacobian_assembler,
                                             process_data._is_linear,
                                             true /*use_monolithic_scheme*/},
      _process_data(std::move(process_data)),
      _bheMeshData(std::move(bhe_mesh_data))
{
    // For numerical Jacobian assembler
    this->_jacobian_assembler->setNonDeformationComponentIDs(
        {0, 1} /* for two temperature variables */);
 
    if (_bheMeshData.BHE_mat_IDs.size() !=
        _process_data._vec_BHE_property.size())
    {
        OGS_FATAL(
            "The number of the given BHE properties ({:d}) are not consistent "
            "with the number of BHE groups in the mesh ({:d}).",
            _process_data._vec_BHE_property.size(),
            _bheMeshData.BHE_mat_IDs.size());
    }
 
    auto material_ids = MeshLib::materialIDs(mesh);
    if (material_ids == nullptr)
    {
        OGS_FATAL("Not able to get material IDs! ");
    }
 
    _process_data._mesh_prop_materialIDs = material_ids;
 
    // create a map from a material ID to a BHE ID
    for (int i = 0; i < static_cast<int>(_bheMeshData.BHE_mat_IDs.size()); i++)
    {
        // fill in the map structure
        _process_data._map_materialID_to_BHE_ID[_bheMeshData.BHE_mat_IDs[i]] =
            i;
    }
}

References HeatTransportBHEProcess(), ProcessLib::Process::Process(), ProcessLib::Process::_jacobian_assembler, and ProcessLib::Process::name.

Referenced by HeatTransportBHEProcess(), and AssemblyMixin< HeatTransportBHEProcess >.

Member Function Documentation

algebraicBcConcreteProcess()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::algebraicBcConcreteProcess ( const double t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & xdot, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b )

private

Definition at line 465 of file HeatTransportBHEProcess.cpp.

{
#ifndef USE_PETSC
    auto M_normal = M.getRawMatrix();
    auto K_normal = K.getRawMatrix();
    auto n_original_rows = K_normal.rows();
    auto const n_BHE_outflow_pairs = vec_outflow_BHE_node_indices_.size();
    auto const n_BHE_inflow_pairs = vec_inflow_BHE_node_indices_.size();
 
    // apply weighting factor based on the max value from column wise inner
    // product and scale it with user defined value
    const double w_val = _process_data._algebraic_BC_Setting._weighting_factor;
 
    M_normal.conservativeResize(
        M_normal.rows() + n_BHE_outflow_pairs + n_BHE_inflow_pairs,
        M_normal.cols());
    K_normal.conservativeResize(
        K_normal.rows() + n_BHE_outflow_pairs + n_BHE_inflow_pairs,
        K_normal.cols());
 
    for (std::size_t i = 0; i < n_BHE_outflow_pairs; i++)
    {
        Eigen::SparseVector<double> M_Plus(M_normal.cols());
        M_Plus.setZero();
        M_normal.row(n_original_rows + i) = M_Plus;
 
        Eigen::SparseVector<double> K_Plus(K_normal.cols());
        K_Plus.setZero();
 
        auto const [bhe_idx, first_BHE_bottom_index, second_BHE_bottom_index] =
            vec_outflow_BHE_node_indices_[i];
 
        K_Plus.insert(first_BHE_bottom_index) = w_val;
        K_Plus.insert(second_BHE_bottom_index) = -w_val;
 
        K_normal.row(n_original_rows + i) = K_Plus;
    }
 
    auto b_normal = b.getRawVector();
    Eigen::SparseVector<double> b_Plus(b_normal.rows() + n_BHE_outflow_pairs +
                                       n_BHE_inflow_pairs);
    b_Plus.setZero();
 
    // Copy values from the original column vector to the modified one
    for (int i = 0; i < b_normal.innerSize(); ++i)
    {
        b_Plus.insert(i) = b_normal.coeff(i);
    }
 
    for (std::size_t i = 0; i < n_BHE_inflow_pairs; i++)
    {
        Eigen::SparseVector<double> M_Plus(M_normal.cols());
        M_Plus.setZero();
        M_normal.row(n_original_rows + n_BHE_outflow_pairs + i) = M_Plus;
 
        Eigen::SparseVector<double> K_Plus(K_normal.cols());
        K_Plus.setZero();
 
        auto const [bhe_idx, first_BHE_top_index, second_BHE_top_index] =
            vec_inflow_BHE_node_indices_[i];
 
        auto first_BHE_top_index_pair = first_BHE_top_index;
        auto second_BHE_top_index_pair = second_BHE_top_index;
 
        K_Plus.insert(first_BHE_top_index_pair) =
            w_val;  // for power BC, the inflow node must be positive
        K_Plus.insert(second_BHE_top_index_pair) =
            -w_val;  // for power BC, the outflow node must be negative
 
        K_normal.row(n_original_rows + n_BHE_outflow_pairs + i) = K_Plus;
 
        // get the delta_T value here
        double const T_out = (*x[0])[second_BHE_top_index_pair];
 
        auto calculate_delta_T = [&](auto& bhe)
        {
            auto const T_in = bhe.updateFlowRateAndTemperature(T_out, t);
            return T_in - T_out;
        };
        auto delta_T = std::visit(calculate_delta_T,
                                  _process_data._vec_BHE_property[bhe_idx]);
 
        b_Plus.insert(n_original_rows + n_BHE_outflow_pairs + i) =
            delta_T * w_val;
    }
 
    M.getRawMatrix() = M_normal;
    K.getRawMatrix() = K_normal;
    b.getRawVector() = b_Plus;
#else
    OGS_FATAL(
        "The Algebraic Boundary Condition is not implemented for use with "
        "PETsc Library! Simulation will be terminated.");
#endif
}

References _process_data, OGS_FATAL, vec_inflow_BHE_node_indices_, and vec_outflow_BHE_node_indices_.

Referenced by assembleConcreteProcess().

assembleConcreteProcess()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess ( const double t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 249 of file HeatTransportBHEProcess.cpp.

{
    DBUG("Assemble HeatTransportBHE process.");
 
    if (_process_data._is_linear)
    {
        if (!getActiveElementIDs().empty())
        {
            OGS_FATAL(
                "Domain Deactivation is currently not implemented with "
                "linear optimization.");
        }
 
        // assemble only soil elements/use cache
        // note: soil element ids are sorted!
        AssemblyMixin<HeatTransportBHEProcess>::assemble(
            t, dt, x, x_prev, process_id, M, K, b, &_soil_element_ids);
 
        // reset the sparsity pattern for better performance in the BHE assembly
        auto const& spec = getMatrixSpecifications(process_id);
        MathLib::setMatrixSparsity(M, *spec.sparsity_pattern);
        MathLib::setMatrixSparsity(K, *spec.sparsity_pattern);
 
        // assemble BHE elements
        std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
            _local_to_global_index_map.get()};
        GlobalExecutor::executeSelectedMemberDereferenced(
            _global_assembler, &VectorMatrixAssembler::assemble,
            local_assemblers_, _bhes_element_ids, dof_table, t, dt, x, x_prev,
            process_id, &M, &K, &b);
    }
    else
    {
        // assemble all elements
        AssemblyMixin<HeatTransportBHEProcess>::assemble(t, dt, x, x_prev,
                                                         process_id, M, K, b);
    }
 
    // Algebraic BC procedure.
    if (_process_data._algebraic_BC_Setting._use_algebraic_bc)
    {
        algebraicBcConcreteProcess(t, dt, x, x_prev, process_id, M, K, b);
    }
 
    //_global_output(t, process_id, M, K, b);
}

References _bhes_element_ids, ProcessLib::Process::_global_assembler, ProcessLib::Process::_local_to_global_index_map, _process_data, _soil_element_ids, algebraicBcConcreteProcess(), ProcessLib::AssemblyMixin< Process >::assemble(), ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::Process::getActiveElementIDs(), ProcessLib::Process::getMatrixSpecifications(), local_assemblers_, OGS_FATAL, and MathLib::setMatrixSparsity().

assembleWithJacobianConcreteProcess()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess ( const double t, double const dt, std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, int const process_id, GlobalVector & b, GlobalMatrix & Jac )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 299 of file HeatTransportBHEProcess.cpp.

{
    DBUG("AssembleWithJacobian HeatTransportBHE process.");
 
    AssemblyMixin<HeatTransportBHEProcess>::assembleWithJacobian(
        t, dt, x, x_prev, process_id, b, Jac);
}

References ProcessLib::AssemblyMixin< Process >::assembleWithJacobian(), and DBUG().

computeSecondaryVariableConcrete()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::computeSecondaryVariableConcrete ( double const t, double const dt, std::vector< GlobalVector * > const & x, GlobalVector const & x_prev, int const process_id )

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 310 of file HeatTransportBHEProcess.cpp.

{
    DBUG("Compute heat flux for HeatTransportBHE process.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
    dof_tables.reserve(x.size());
    std::generate_n(std::back_inserter(dof_tables), x.size(),
                    [&]() { return _local_to_global_index_map.get(); });
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &HeatTransportBHELocalAssemblerInterface::computeSecondaryVariable,
        local_assemblers_, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id);
}

References ProcessLib::LocalAssemblerInterface::computeSecondaryVariable(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), and local_assemblers_.

constructDofTable()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable ( )

overrideprivatevirtual

This function is for general cases, in which all equations of the coupled processes have the same number of unknowns. For the general cases with the staggered scheme, all equations of the coupled processes share one DOF table hold by _local_to_global_index_map. Other cases can be considered by overloading this member function in the derived class.

Reimplemented from ProcessLib::Process.

Definition at line 73 of file HeatTransportBHEProcess.cpp.

{
    // Create single component dof in every of the mesh's nodes.
    _mesh_subset_all_nodes =
        std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
 
    //
    // Soil temperature variable defined on the whole mesh.
    //
    _mesh_subset_soil_nodes =
        std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
    std::vector<MeshLib::MeshSubset> all_mesh_subsets{*_mesh_subset_soil_nodes};
 
    std::vector<std::vector<MeshLib::Element*> const*> vec_var_elements;
    vec_var_elements.push_back(&(_mesh.getElements()));
 
    std::vector<int> vec_n_components{
        1};  // one component for the soil temperature variable.
 
    //
    // BHE nodes with BHE type dependent number of variables.
    //
    int const n_BHEs = _process_data._vec_BHE_property.size();
    assert(n_BHEs == static_cast<int>(_bheMeshData.BHE_mat_IDs.size()));
    assert(n_BHEs == static_cast<int>(_bheMeshData.BHE_nodes.size()));
    assert(n_BHEs == static_cast<int>(_bheMeshData.BHE_elements.size()));
 
    // the BHE nodes need to be cherry-picked from the vector
    for (int i = 0; i < n_BHEs; i++)
    {
        auto const number_of_unknowns =
            visit([](auto const& bhe) { return bhe.number_of_unknowns; },
                  _process_data._vec_BHE_property[i]);
        auto const& bhe_nodes = _bheMeshData.BHE_nodes[i];
        auto const& bhe_elements = _bheMeshData.BHE_elements[i];
 
        // All the BHE nodes have additional variables.
        _mesh_subset_BHE_nodes.push_back(
            std::make_unique<MeshLib::MeshSubset const>(_mesh, bhe_nodes));
 
        std::generate_n(std::back_inserter(all_mesh_subsets),
                        // Here the number of components equals to the
                        // number of unknowns on the BHE
                        number_of_unknowns,
                        [&ms = _mesh_subset_BHE_nodes.back()]()
                        { return *ms; });
 
        vec_n_components.push_back(number_of_unknowns);
        vec_var_elements.push_back(&bhe_elements);
    }
 
    _local_to_global_index_map =
        std::make_unique<NumLib::LocalToGlobalIndexMap>(
            std::move(all_mesh_subsets),
            vec_n_components,
            vec_var_elements,
            NumLib::ComponentOrder::BY_COMPONENT);
 
    // in case of debugging the dof table, activate the following line
    // std::cout << *_local_to_global_index_map << "\n";
}

References _bheMeshData, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, ProcessLib::Process::_mesh_subset_all_nodes, _mesh_subset_BHE_nodes, _mesh_subset_soil_nodes, _process_data, and NumLib::BY_COMPONENT.

createBHEEndpointBoundaryConditions()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEEndpointBoundaryConditions ( )

private

Definition at line 566 of file HeatTransportBHEProcess.cpp.

{
    const int process_id = 0;
    auto& bcs = _boundary_conditions[process_id];
 
    std::size_t const n_BHEs = _process_data._vec_BHE_property.size();
 
    // for each BHE
    for (std::size_t bhe_i = 0; bhe_i < n_BHEs; bhe_i++)
    {
        // find the variable ID
        // the soil temperature is 0-th variable
        // the BHE temperature is therefore bhe_i + 1
        const int variable_id = bhe_i + 1;
 
        // Derive the inflow/outflow endpoints from the BHE's line-element
        // chain, using the same node-0 -> node-1 convention that the local
        // assembler uses to build elem_direction. The inflow endpoint
        // receives the inflow Dirichlet BC; the outflow endpoint receives
        // the outflow BC. For canonical vertical BHEs meshed with node 0
        // at the surface this matches the previous z-coordinate-based
        // behaviour.
        auto const endpoints = findBHEEndpointsFromElementOrdering(
            _bheMeshData.BHE_elements[bhe_i]);
 
        auto get_global_index =
            [&](std::size_t const node_id, int const component)
        {
            return _local_to_global_index_map->getGlobalIndex(
                {_mesh.getID(), MeshLib::MeshItemType::Node, node_id},
                variable_id, component);
        };
 
        auto get_global_bhe_bc_indices =
            [&](std::array<
                std::pair<std::size_t /*node_id*/, int /*component*/>, 2>
                    nodes_and_components)
        {
            return std::make_pair(
                get_global_index(nodes_and_components[0].first,
                                 nodes_and_components[0].second),
                get_global_index(nodes_and_components[1].first,
                                 nodes_and_components[1].second));
        };
 
        auto get_global_bhe_bc_indices_with_bhe_idx =
            [&](std::size_t bhe_idx,
                std::array<
                    std::pair<std::size_t /*node_id*/, int /*component*/>, 2>
                    nodes_and_components)
        {
            return std::make_tuple(
                bhe_idx,
                get_global_index(nodes_and_components[0].first,
                                 nodes_and_components[0].second),
                get_global_index(nodes_and_components[1].first,
                                 nodes_and_components[1].second));
        };
 
        auto createBCs =
            [&, bc_inflow_node_id = endpoints.inlet->getID(),
             bc_outflow_node_id = endpoints.outlet->getID()](auto& bhe)
        {
            for (auto const& in_out_component_id :
                 bhe.inflow_outflow_bc_component_ids)
            {
                if (bhe.use_python_bcs ||
                    this->_process_data._use_server_communication)
                // call BHEPythonBoundarycondition
                {
                    if (this->_process_data
                            .py_bc_object)  // the bc object exist
                    {
                        // apply the customized inflow Dirichlet BC.
                        bcs.addBoundaryCondition(
                            ProcessLib::createBHEInflowPythonBoundaryCondition(
                                get_global_bhe_bc_indices(
                                    bhe.getBHEInflowDirichletBCNodesAndComponents(
                                        bc_inflow_node_id, bc_outflow_node_id,
                                        in_out_component_id.first)),
                                bhe,
                                *(_process_data.py_bc_object)));
                    }
                    else
                    {
                        OGS_FATAL(
                            "The Python Boundary Condition was switched on, "
                            "but the data object does not exist! ");
                    }
                }
                else
                {
                    if (this->_process_data._algebraic_BC_Setting
                            ._use_algebraic_bc &&
                        bhe.isPowerBC())
                    {
                        // for algebraic_bc method, record the pair of indices
                        // in a separate vector
                        vec_inflow_BHE_node_indices_.push_back(
                            get_global_bhe_bc_indices_with_bhe_idx(
                                bhe_i,
                                {{{bc_inflow_node_id,
                                   in_out_component_id.first},
                                  {bc_inflow_node_id,
                                   in_out_component_id.second}}}));
                    }
                    else
                    {
                        // Inflow, normal case
                        bcs.addBoundaryCondition(
                            createBHEInflowDirichletBoundaryCondition(
                                get_global_bhe_bc_indices(
                                    bhe.getBHEInflowDirichletBCNodesAndComponents(
                                        bc_inflow_node_id, bc_outflow_node_id,
                                        in_out_component_id.first)),
                                [&bhe](double const T, double const t)
                                {
                                    return bhe.updateFlowRateAndTemperature(T,
                                                                            t);
                                }));
                    }
                }
 
                auto const bottom_nodes_and_components =
                    bhe.getBHEBottomDirichletBCNodesAndComponents(
                        bc_outflow_node_id,
                        in_out_component_id.first,
                        in_out_component_id.second);
 
                if (bottom_nodes_and_components &&
                    !this->_process_data._algebraic_BC_Setting
                         ._use_algebraic_bc)
                {
                    // Outflow, all cases | not needed for algebraic_bc
                    // method
                    bcs.addBoundaryCondition(
                        createBHEBottomDirichletBoundaryCondition(
                            get_global_bhe_bc_indices(
                                {{{bc_outflow_node_id,
                                   in_out_component_id.first},
                                  {bc_outflow_node_id,
                                   in_out_component_id.second}}})));
                }
                else if (bottom_nodes_and_components &&
                         this->_process_data._algebraic_BC_Setting
                             ._use_algebraic_bc)
                {
                    // for algebraic_bc method, record the pair of indices in a
                    // separate vector
                    vec_outflow_BHE_node_indices_.push_back(
                        get_global_bhe_bc_indices_with_bhe_idx(
                            bhe_i,
                            {{{bc_outflow_node_id, in_out_component_id.first},
                              {bc_outflow_node_id,
                               in_out_component_id.second}}}));
                }
            }
        };
        visit(createBCs, _process_data._vec_BHE_property[bhe_i]);
    }
}

References _bheMeshData, ProcessLib::Process::_boundary_conditions, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, _process_data, ProcessLib::HeatTransportBHE::createBHEBottomDirichletBoundaryCondition(), ProcessLib::HeatTransportBHE::createBHEInflowDirichletBoundaryCondition(), ProcessLib::createBHEInflowPythonBoundaryCondition(), ProcessLib::HeatTransportBHE::findBHEEndpointsFromElementOrdering(), MeshLib::Node, OGS_FATAL, vec_inflow_BHE_node_indices_, and vec_outflow_BHE_node_indices_.

Referenced by initializeConcreteProcess().

initializeAssemblyOnSubmeshes()

std::vector< std::vector< std::string > > ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::initializeAssemblyOnSubmeshes ( std::vector< std::reference_wrapper< MeshLib::Mesh > > const & meshes )

overrideprivatevirtual

Initializes the assembly on submeshes

Parameters

meshes

the submeshes on whom the assembly shall proceed.

Attention

meshes must be a must be a non-overlapping cover of the entire simulation domain (bulk mesh)!

Returns

The names of the residuum vectors that will be assembled for each process: outer vector of size 1 for monolithic schemes and greater for staggered schemes.

Reimplemented from ProcessLib::SubmeshAssemblySupport.

Definition at line 213 of file HeatTransportBHEProcess.cpp.

{
    DBUG("T-BHE process initializeSubmeshOutput().");
 
    namespace R = ranges;
    namespace RV = ranges::views;
 
    auto get_residuum_name =
        [](ProcessLib::ProcessVariable const& pv) -> std::string
    {
        std::string const& pv_name = pv.getName();
        if (pv_name.starts_with("temperature_"))
        {
            using namespace std::literals;
            auto const len_temp = "temperature_"s.size();
            // TODO is that the correct name?
            return "HeatFlowRate_" + pv_name.substr(len_temp);
        }
 
        OGS_FATAL("Unexpected process variable name '{}'.", pv_name);
    };
 
    auto get_residuum_names = [get_residuum_name](auto const& pvs)
    { return pvs | RV::transform(get_residuum_name); };
 
    auto residuum_names = _process_variables |
                          RV::transform(get_residuum_names) |
                          R::to<std::vector<std::vector<std::string>>>();
 
    AssemblyMixin<HeatTransportBHEProcess>::initializeAssemblyOnSubmeshes(
        meshes, residuum_names);
 
    return residuum_names;
}

References ProcessLib::Process::_process_variables, DBUG(), ProcessLib::AssemblyMixin< Process >::initializeAssemblyOnSubmeshes(), and OGS_FATAL.

initializeConcreteProcess()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::initializeConcreteProcess ( NumLib::LocalToGlobalIndexMap const & dof_table, MeshLib::Mesh const & mesh, unsigned const integration_order )

overrideprivatevirtual

Process specific initialization called by initialize().

Implements ProcessLib::Process.

Definition at line 135 of file HeatTransportBHEProcess.cpp.

{
    // Quick access map to BHE's through element ids.
    std::unordered_map<std::size_t, BHE::BHETypes*> element_to_bhe_map;
    int const n_BHEs = _process_data._vec_BHE_property.size();
    for (int i = 0; i < n_BHEs; i++)
    {
        auto const& bhe_elements = _bheMeshData.BHE_elements[i];
        for (auto const& e : bhe_elements)
        {
            element_to_bhe_map[e->getID()] =
                &_process_data._vec_BHE_property[i];
        }
    }
 
    assert(mesh.getDimension() == 3);
    ProcessLib::HeatTransportBHE::createLocalAssemblers<
        HeatTransportBHELocalAssemblerSoil, HeatTransportBHELocalAssemblerBHE>(
        mesh.getElements(), dof_table, local_assemblers_,
        NumLib::IntegrationOrder{integration_order}, element_to_bhe_map,
        mesh.isAxiallySymmetric(), _process_data);
 
    // Create BHE boundary conditions for each of the BHEs
    createBHEEndpointBoundaryConditions();
 
    // Store BHE and soil elements to split the assembly and use the matrix
    // cache in the linear case only for soil elements
    if (_process_data._is_linear)
    {
        _bhes_element_ids = _bheMeshData.BHE_elements | ranges::views::join |
                            MeshLib::views::ids | ranges::to<std::vector>;
 
        // sort bhe elements if needed
        if (!std::is_sorted(_bhes_element_ids.begin(), _bhes_element_ids.end()))
        {
            std::sort(_bhes_element_ids.begin(), _bhes_element_ids.end());
        }
 
        _soil_element_ids = mesh.getElements() | MeshLib::views::ids |
                            ranges::to<std::vector>();
 
        // sort soil elements if needed
        if (!std::is_sorted(_soil_element_ids.begin(), _soil_element_ids.end()))
        {
            std::sort(_soil_element_ids.begin(), _soil_element_ids.end());
        }
 
        _soil_element_ids = ranges::views::set_difference(_soil_element_ids,
                                                          _bhes_element_ids) |
                            ranges::to<std::vector>();
    }
 
    if (_process_data._mass_lumping)
    {
        std::vector<std::size_t> const bhes_node_ids =
            _bheMeshData.BHE_nodes | ranges::views::join |
            ranges::views::transform([](auto const* const node)
                                     { return node->getID(); }) |
            ranges::to<std::vector>;
 
        // all connected soil elements and also the BHE elements.
        MeshLib::ElementSearch es{mesh};
        es.searchByNodeIDs(bhes_node_ids);
 
        assert(_process_data.mass_lumping_soil_elements.empty());
        _process_data.mass_lumping_soil_elements.resize(
            mesh.getNumberOfElements(), false);
        for (auto const id : es.getSearchedElementIDs())
        {
            _process_data.mass_lumping_soil_elements[id] = true;
        }
    }
}

References _bheMeshData, _bhes_element_ids, _process_data, _soil_element_ids, createBHEEndpointBoundaryConditions(), ProcessLib::HeatTransportBHE::createLocalAssemblers(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNumberOfElements(), MeshLib::views::ids, MeshLib::Mesh::isAxiallySymmetric(), local_assemblers_, and MeshLib::ElementSearch::searchByNodeIDs().

isLinear()

bool ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::isLinear ( ) const

inlineoverride

Definition at line 41 of file HeatTransportBHEProcess.h.

    {
        // Linear Solver is called only once - valid only with
        // _use_algebraic_bc and _is_linear
        return _process_data._algebraic_BC_Setting._use_algebraic_bc &&
               _process_data._is_linear;
    }

References _process_data.

postIterationConcreteProcess()

NumLib::IterationResult ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::postIterationConcreteProcess ( GlobalVector const & x )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 327 of file HeatTransportBHEProcess.cpp.

{
    // if the process use python boundary condition
    if (_process_data.py_bc_object == nullptr || !(_process_data._use_tespy))
    {
        return NumLib::IterationResult::SUCCESS;
    }
 
    // Here the task is to get current time flowrate and flow temperature from
    // TESPy and determine whether it converges.
    auto const Tout_nodes_id =
        std::get<3>(_process_data.py_bc_object->dataframe_network);
    const std::size_t n_bc_nodes = Tout_nodes_id.size();
 
    for (std::size_t i = 0; i < n_bc_nodes; i++)
    {
        // read the T_out and store them in dataframe
        std::get<2>(_process_data.py_bc_object->dataframe_network)[i] =
            x[Tout_nodes_id[i]];
    }
    // Transfer Tin and Tout to TESPy and return the results
    auto const tespy_result = _process_data.py_bc_object->tespySolver(
        std::get<0>(_process_data.py_bc_object->dataframe_network),   // t
        std::get<1>(_process_data.py_bc_object->dataframe_network),   // T_in
        std::get<2>(_process_data.py_bc_object->dataframe_network));  // T_out
    if (!_process_data.py_bc_object->isOverriddenTespy())
    {
        DBUG("Method `tespySolver' not overridden in Python script.");
    }
 
    // update the Tin and flow rate
    for (std::size_t i = 0; i < n_bc_nodes; i++)
    {
        std::get<1>(_process_data.py_bc_object->dataframe_network)[i] =
            std::get<2>(tespy_result)[i];
        std::get<4>(_process_data.py_bc_object->dataframe_network)[i] =
            std::get<3>(tespy_result)[i];
    }
    auto const tespy_has_converged = std::get<1>(tespy_result);
    if (tespy_has_converged)
    {
        return NumLib::IterationResult::SUCCESS;
    }
 
    return NumLib::IterationResult::REPEAT_ITERATION;
}

References _process_data, DBUG(), NumLib::REPEAT_ITERATION, and NumLib::SUCCESS.

postTimestepConcreteProcess()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::postTimestepConcreteProcess ( std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, const double t, const double dt, int const process_id )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 426 of file HeatTransportBHEProcess.cpp.

{
    if (_process_data.py_bc_object == nullptr ||
        !_process_data._use_server_communication)
    {
        return;
    }
 
    auto& [time, Tin_value, Tout_value, Tout_nodes_ids, flowrate] =
        _process_data.py_bc_object->dataframe_network;
 
    // We found the problem that time != t, but it always equals the last
    // step. The following line is to correct this, although we do not use
    // it for server communication.
    time = t;
 
    auto const& solution = *x[process_id];
 
    // Iterate through each BHE
    const std::size_t n_bc_nodes = Tout_nodes_ids.size();
    for (std::size_t i = 0; i < n_bc_nodes; i++)
    {
        // read the T_out and store them in dataframe
        Tout_value[i] = solution[Tout_nodes_ids[i]];
    }
 
    // Transfer T_out to server_Communication
    _process_data.py_bc_object->serverCommunicationPostTimestep(
        t, dt, Tin_value, Tout_value, flowrate);
    if (!_process_data.py_bc_object
             ->isOverriddenServerCommunicationPostTimestep())
    {
        DBUG("Method `serverCommunication' not overridden in Python script.");
    }
}

References _process_data, and DBUG().

preTimestepConcreteProcess()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::preTimestepConcreteProcess ( std::vector< GlobalVector * > const & x, const double t, const double dt, int const process_id )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 375 of file HeatTransportBHEProcess.cpp.

{
    AssemblyMixin<HeatTransportBHEProcess>::updateActiveElements();
 
    if (_process_data.py_bc_object == nullptr ||
        !_process_data._use_server_communication)
    {
        return;
    }
 
    auto& [time, Tin_value, Tout_value, Tout_nodes_ids, flowrate] =
        _process_data.py_bc_object->dataframe_network;
 
    // We found the problem that time != t, but it always equals the last
    // step. The following line is to correct this, although we do not use
    // it for server communication.
    time = t;
 
    auto const& solution = *x[process_id];
 
    // Iterate through each BHE
    const std::size_t n_bc_nodes = Tout_nodes_ids.size();
    for (std::size_t i = 0; i < n_bc_nodes; i++)
    {
        // read the T_out and store them in dataframe
        Tout_value[i] = solution[Tout_nodes_ids[i]];
    }
 
    // Transfer T_out to server_Communication and get back T_in and flowrate
    auto const server_communication_result =
        _process_data.py_bc_object->serverCommunicationPreTimestep(
            t, dt, Tin_value, Tout_value, flowrate);
    if (!_process_data.py_bc_object
             ->isOverriddenServerCommunicationPreTimestep())
    {
        DBUG("Method `serverCommunication' not overridden in Python script.");
    }
 
    auto const& [server_communication_Tin_value,
                 server_communication_flowrate] = server_communication_result;
 
    std::copy(begin(server_communication_Tin_value),
              end(server_communication_Tin_value),
              begin(Tin_value));
    std::copy(begin(server_communication_flowrate),
              end(server_communication_flowrate),
              begin(flowrate));
}

References _process_data, DBUG(), and ProcessLib::AssemblyMixin< Process >::updateActiveElements().

requiresNormalization()

bool ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::requiresNormalization ( ) const

inlineoverride

Definition at line 49 of file HeatTransportBHEProcess.h.

    {
        // In the current setup, when using algebraic bc,
        // then normalization is always required
        return _process_data._algebraic_BC_Setting._use_algebraic_bc;
    }

References _process_data.

Friends And Related Symbol Documentation

AssemblyMixin< HeatTransportBHEProcess >

friend class AssemblyMixin< HeatTransportBHEProcess >

friend

Definition at line 18 of file HeatTransportBHEProcess.h.

References HeatTransportBHEProcess(), ProcessLib::Process::Process(), and ProcessLib::Process::name.

Member Data Documentation

_bheMeshData

const BHEMeshData ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_bheMeshData

private

Definition at line 127 of file HeatTransportBHEProcess.h.

Referenced by constructDofTable(), createBHEEndpointBoundaryConditions(), and initializeConcreteProcess().

_bhes_element_ids

std::vector<std::size_t> ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_bhes_element_ids

private

Definition at line 129 of file HeatTransportBHEProcess.h.

Referenced by assembleConcreteProcess(), and initializeConcreteProcess().

_mesh_subset_BHE_nodes

std::vector<std::unique_ptr<MeshLib::MeshSubset const> > ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_mesh_subset_BHE_nodes

private

Definition at line 110 of file HeatTransportBHEProcess.h.

Referenced by constructDofTable().

_mesh_subset_BHE_soil_nodes

std::vector<std::unique_ptr<MeshLib::MeshSubset const> > ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_mesh_subset_BHE_soil_nodes

private

Definition at line 113 of file HeatTransportBHEProcess.h.

_mesh_subset_soil_nodes

std::unique_ptr<MeshLib::MeshSubset const> ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_mesh_subset_soil_nodes

private

Definition at line 125 of file HeatTransportBHEProcess.h.

Referenced by constructDofTable().

_process_data

HeatTransportBHEProcessData ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_process_data

private

Definition at line 104 of file HeatTransportBHEProcess.h.

Referenced by algebraicBcConcreteProcess(), assembleConcreteProcess(), constructDofTable(), createBHEEndpointBoundaryConditions(), initializeConcreteProcess(), isLinear(), postIterationConcreteProcess(), postTimestepConcreteProcess(), preTimestepConcreteProcess(), and requiresNormalization().

_soil_element_ids

std::vector<std::size_t> ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_soil_element_ids

private

Definition at line 131 of file HeatTransportBHEProcess.h.

Referenced by assembleConcreteProcess(), and initializeConcreteProcess().

local_assemblers_

std::vector<std::unique_ptr<HeatTransportBHELocalAssemblerInterface> > ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::local_assemblers_

private

Definition at line 107 of file HeatTransportBHEProcess.h.

Referenced by assembleConcreteProcess(), computeSecondaryVariableConcrete(), and initializeConcreteProcess().

vec_inflow_BHE_node_indices_

std::vector<std::tuple<std::size_t, GlobalIndexType, GlobalIndexType> > ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::vec_inflow_BHE_node_indices_

private

Definition at line 119 of file HeatTransportBHEProcess.h.

Referenced by algebraicBcConcreteProcess(), and createBHEEndpointBoundaryConditions().

vec_outflow_BHE_node_indices_

std::vector<std::tuple<std::size_t, GlobalIndexType, GlobalIndexType> > ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::vec_outflow_BHE_node_indices_

private

Definition at line 123 of file HeatTransportBHEProcess.h.

Referenced by algebraicBcConcreteProcess(), and createBHEEndpointBoundaryConditions().

---

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

• HeatTransportBHEProcess.h
• HeatTransportBHEProcess.cpp