BHECommon.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause

 
#pragma once
 
#include <algorithm>
#include <vector>
 
#include "BaseLib/Error.h"
#include "BoreholeGeometry.h"
#include "FlowAndTemperatureControl.h"
#include "GroutParameters.h"
#include "RefrigerantProperties.h"
 
namespace ProcessLib
{
namespace HeatTransportBHE
{
namespace BHE
{
inline double checkedGroutArea(double const borehole_area_fraction,
                               double const pipe_outside_area,
                               int const section_index)
{
    double const grout_area = borehole_area_fraction - pipe_outside_area;
    if (grout_area <= 0)
    {
        OGS_FATAL(
            "Non-positive grout cross-sectional area at section {:d}. "
            "Borehole diameter is too small for the pipe dimensions.",
            section_index);
    }
    return grout_area;
}
 
class BHECommon
{
public:
    BHECommon(BoreholeGeometry const& borehole_geometry_,
              RefrigerantProperties const& refrigerant_,
              GroutParameters const& grout_,
              FlowAndTemperatureControl const& flowAndTemperatureControl_,
              bool const use_python_bcs_)
        : borehole_geometry(borehole_geometry_),
          refrigerant(refrigerant_),
          grout(grout_),
          flowAndTemperatureControl(flowAndTemperatureControl_),
          use_python_bcs(use_python_bcs_)
    {
    }
 
    BoreholeGeometry const borehole_geometry;
    RefrigerantProperties const refrigerant;
    GroutParameters const grout;
    FlowAndTemperatureControl const flowAndTemperatureControl;
    bool const use_python_bcs;
    constexpr bool isPowerBC() const
    {
        return std::visit([](auto const& ftc) { return ftc.is_power_bc; },
                          flowAndTemperatureControl);
    }

    int getNumberOfSections() const
    {
        return borehole_geometry.sections.getNumberOfSections();
    }

    std::vector<double> const& getSectionBoundaries() const
    {
        return borehole_geometry.sections.section_boundaries;
    }

    double thermalResistanceAtSection(int const unknown_index,
                                      int const section_index) const
    {
        auto const& thermal_resistances =
            getThermalResistancesAtSection(section_index);
        if (unknown_index < 0 ||
            unknown_index >= static_cast<int>(thermal_resistances.size()))
        {
            OGS_FATAL("Invalid unknown index {:d} for section {:d}.",
                      unknown_index, section_index);
        }
        return thermal_resistances[unknown_index];
    }
 
protected:
    template <typename Fn>
    void recomputeSectionalResistances(Fn&& calcForSection)
    {
        int const n = getNumberOfSections();
        _sectional_thermal_resistances.clear();
        _sectional_thermal_resistances.reserve(n);
        for (int i = 0; i < n; ++i)
        {
            _sectional_thermal_resistances.push_back(calcForSection(i));
        }
    }

    std::vector<double> _flow_velocities;

    double getClampedFlowVelocity(int const section_index) const
    {
        return _flow_velocities.empty()
                   ? 0.0
                   : _flow_velocities[std::min(
                         section_index,
                         static_cast<int>(_flow_velocities.size()) - 1)];
    }

    std::vector<std::vector<double>> _sectional_thermal_resistances;

    std::vector<double> const& getThermalResistancesAtSection(
        int const section_index) const
    {
        if (section_index < 0 ||
            section_index >=
                static_cast<int>(_sectional_thermal_resistances.size()))
        {
            OGS_FATAL("Invalid section index: {:d}", section_index);
        }
        return _sectional_thermal_resistances[section_index];
    }
};
}  // end of namespace BHE
}  // end of namespace HeatTransportBHE
}  // end of namespace ProcessLib