ProcessLib::HeatTransportBHE::HeatTransportBHEProcess Class Reference

Detailed Description

Definition at line 24 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)
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, GlobalMatrix &M, GlobalMatrix &K, 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::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)
Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual std::vector< std::string >	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes)
virtual	~SubmeshAssemblySupport ()=default

ODESystem interface
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::unique_ptr< MeshLib::MeshSubset const >	_mesh_subset_soil_nodes
const BHEMeshData	_bheMeshData
bool	isLinear () const override
void	computeSecondaryVariableConcrete (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_prev, int const process_id) override
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().
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, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) override
void	createBHEBoundaryConditionTopBottom (std::vector< std::vector< MeshLib::Node * > > const &all_bhe_nodes)
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
NumLib::IterationResult	postIterationConcreteProcess (GlobalVector const &x) override

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

Definition at line 27 of file HeatTransportBHEProcess.cpp.

    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
              integration_order, std::move(process_variables),
              std::move(secondary_variables)),
      _process_data(std::move(process_data)),
      _bheMeshData(getBHEDataInMesh(mesh))
{
    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 _bheMeshData, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_map_materialID_to_BHE_ID, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_mesh_prop_materialIDs, _process_data, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_vec_BHE_property, ProcessLib::HeatTransportBHE::BHEMeshData::BHE_mat_IDs, MeshLib::materialIDs(), and OGS_FATAL.

Member Function Documentation

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 161 of file HeatTransportBHEProcess.cpp.

{
    DBUG("Assemble HeatTransportBHE process.");
 
    ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
        pv.getActiveElementIDs(), dof_table, t, dt, x, x_prev, process_id, M, K,
        b);
}

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::Process::getProcessVariables().

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, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b, GlobalMatrix & Jac )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 179 of file HeatTransportBHEProcess.cpp.

{
    DBUG("AssembleWithJacobian HeatTransportBHE process.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
    ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, pv.getActiveElementIDs(), dof_table, t, dt, x,
        x_prev, process_id, M, K, b, Jac);
}

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::Process::getProcessVariables().

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 197 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(); });
 
    ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &HeatTransportBHELocalAssemblerInterface::computeSecondaryVariable,
        _local_assemblers, pv.getActiveElementIDs(), dof_tables, t, dt, x,
        x_prev, process_id);
}

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

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 70 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, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_vec_BHE_property, ProcessLib::HeatTransportBHE::BHEMeshData::BHE_elements, ProcessLib::HeatTransportBHE::BHEMeshData::BHE_mat_IDs, ProcessLib::HeatTransportBHE::BHEMeshData::BHE_nodes, NumLib::BY_COMPONENT, MeshLib::Mesh::getElements(), and MeshLib::Mesh::getNodes().

createBHEBoundaryConditionTopBottom()

void ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom ( std::vector< std::vector< MeshLib::Node * > > const & all_bhe_nodes )

private

Definition at line 347 of file HeatTransportBHEProcess.cpp.

{
    const int process_id = 0;
    auto& bcs = _boundary_conditions[process_id];
 
    int const n_BHEs = static_cast<int>(_process_data._vec_BHE_property.size());
 
    // for each BHE
    for (int bhe_i = 0; bhe_i < n_BHEs; bhe_i++)
    {
        auto const& bhe_nodes = all_bhe_nodes[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;
 
        std::vector<MeshLib::Node*> bhe_boundary_nodes;
 
        // cherry-pick the boundary nodes according to
        // the number of connected line elements.
        for (auto const& bhe_node : bhe_nodes)
        {
            // Count number of 1d elements connected with every BHE node.
            auto const& connected_elements =
                _mesh.getElementsConnectedToNode(*bhe_node);
            const std::size_t n_line_elements = std::count_if(
                connected_elements.begin(), connected_elements.end(),
                [](MeshLib::Element const* elem)
                { return (elem->getDimension() == 1); });
 
            if (n_line_elements == 1)
            {
                bhe_boundary_nodes.push_back(bhe_node);
            }
        }
 
        if (bhe_boundary_nodes.size() != 2)
        {
            OGS_FATAL(
                "Error!!! The BHE boundary nodes are not correctly found, "
                "for every single BHE, there should be 2 boundary nodes.");
        }
 
        // For 1U, 2U, CXC, CXA type BHE, the node order in the boundary nodes
        // vector should be rearranged according to its z coordinate in
        // descending order. In these BHE types, the z coordinate on the top and
        // bottom node is different. The BHE top node with a higher z coordinate
        // should be placed at the first, while the BHE bottom node with a lower
        // z coordinate should be placed at the second. For other horizontal BHE
        // types e.g. 1P-type BHE, the z coordinate on the top and bottom node
        // is identical. Thus the node order in the boundary nodes vector can
        // not be rearranged according to its z coordinate. For these BHE types,
        // the boundary node order is according to the default node id order in
        // the model mesh.
        // for 1P-type BHE
        if ((*bhe_boundary_nodes[0])[2] == (*bhe_boundary_nodes[1])[2])
        {
            INFO(
                "For 1P-type BHE, the BHE inflow and outflow "
                "nodes are identified according to their mesh node id in "
                "ascending order");
        }
        // for 1U, 2U, CXC, CXA type BHE
        else
        {
            // swap the boundary nodes if the z coordinate of the
            // first node is lower than it on the second node
            if ((*bhe_boundary_nodes[0])[2] < (*bhe_boundary_nodes[1])[2])
            {
                std::swap(bhe_boundary_nodes[0], bhe_boundary_nodes[1]);
            }
        }
 
        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 createBCs =
            [&, bc_top_node_id = bhe_boundary_nodes[0]->getID(),
             bc_bottom_node_id = bhe_boundary_nodes[1]->getID()](auto& bhe)
        {
            for (auto const& in_out_component_id :
                 bhe.inflow_outflow_bc_component_ids)
            {
                if (bhe.use_python_bcs ||
                    _process_data._use_server_communication)
                // call BHEPythonBoundarycondition
                {
                    if (_process_data.py_bc_object)  // the bc object exist
                    {
                        // apply the customized top, inflow BC.
                        bcs.addBoundaryCondition(
                            ProcessLib::createBHEInflowPythonBoundaryCondition(
                                get_global_bhe_bc_indices(
                                    bhe.getBHEInflowDirichletBCNodesAndComponents(
                                        bc_top_node_id, bc_bottom_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
                {
                    // Top, inflow, normal case
                    bcs.addBoundaryCondition(
                        createBHEInflowDirichletBoundaryCondition(
                            get_global_bhe_bc_indices(
                                bhe.getBHEInflowDirichletBCNodesAndComponents(
                                    bc_top_node_id, bc_bottom_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_bottom_node_id,
                        in_out_component_id.first,
                        in_out_component_id.second);
 
                if (bottom_nodes_and_components)
                {
                    // Bottom, outflow, all cases
                    bcs.addBoundaryCondition(
                        createBHEBottomDirichletBoundaryCondition(
                            get_global_bhe_bc_indices(
                                {{{bc_bottom_node_id,
                                   in_out_component_id.first},
                                  {bc_bottom_node_id,
                                   in_out_component_id.second}}})));
                }
            }
        };
        visit(createBCs, _process_data._vec_BHE_property[bhe_i]);
    }
}

References ProcessLib::Process::_boundary_conditions, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, _process_data, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_use_server_communication, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_vec_BHE_property, ProcessLib::HeatTransportBHE::createBHEBottomDirichletBoundaryCondition(), ProcessLib::HeatTransportBHE::createBHEInflowDirichletBoundaryCondition(), ProcessLib::createBHEInflowPythonBoundaryCondition(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getID(), INFO(), MeshLib::Node, OGS_FATAL, and ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::py_bc_object.

Referenced by initializeConcreteProcess().

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 132 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
    createBHEBoundaryConditionTopBottom(_bheMeshData.BHE_nodes);
}

References _bheMeshData, _local_assemblers, _process_data, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_vec_BHE_property, ProcessLib::HeatTransportBHE::BHEMeshData::BHE_elements, ProcessLib::HeatTransportBHE::BHEMeshData::BHE_nodes, createBHEBoundaryConditionTopBottom(), ProcessLib::HeatTransportBHE::createLocalAssemblers(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), and MeshLib::Mesh::isAxiallySymmetric().

isLinear()

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

inlineoverride

Definition at line 42 of file HeatTransportBHEProcess.h.

{ return false; }

postIterationConcreteProcess()

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

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 215 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 == true)
        return NumLib::IterationResult::SUCCESS;
 
    return NumLib::IterationResult::REPEAT_ITERATION;
}

References _process_data, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_use_tespy, ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::dataframe_network, DBUG(), ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::isOverriddenTespy(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::py_bc_object, NumLib::REPEAT_ITERATION, NumLib::SUCCESS, and ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::tespySolver().

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 308 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, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_use_server_communication, ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::dataframe_network, DBUG(), ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::isOverriddenServerCommunicationPostTimestep(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::py_bc_object, and ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::serverCommunicationPostTimestep().

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 259 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 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, ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::_use_server_communication, ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::dataframe_network, DBUG(), ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::isOverriddenServerCommunicationPreTimestep(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcessData::py_bc_object, and ProcessLib::BHEInflowPythonBoundaryConditionPythonSideInterface::serverCommunicationPreTimestep().

Member Data Documentation

_bheMeshData

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

private

Definition at line 96 of file HeatTransportBHEProcess.h.

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

_local_assemblers

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

private

Definition at line 86 of file HeatTransportBHEProcess.h.

Referenced by assembleConcreteProcess(), assembleWithJacobianConcreteProcess(), computeSecondaryVariableConcrete(), 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 89 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 92 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 94 of file HeatTransportBHEProcess.h.

Referenced by constructDofTable().

_process_data

HeatTransportBHEProcessData ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::_process_data

private

Definition at line 83 of file HeatTransportBHEProcess.h.

Referenced by HeatTransportBHEProcess(), constructDofTable(), createBHEBoundaryConditionTopBottom(), initializeConcreteProcess(), postIterationConcreteProcess(), postTimestepConcreteProcess(), and preTimestepConcreteProcess().

---

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

• ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.h
• ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.cpp