CreateBHE1PType.cpp

Go to the documentation of this file.

 
#include "BHE_1P.h"
#include "BaseLib/ConfigTree.h"
#include "CreateBHEUType.h"
#include "CreateFlowAndTemperatureControl.h"
 
namespace ProcessLib
{
namespace HeatTransportBHE
{
namespace BHE
{
static std::tuple<BoreholeGeometry,
                  RefrigerantProperties,
                  GroutParameters,
                  FlowAndTemperatureControl,
                  PipeConfiguration1PType,
                  bool>
parseBHE1PTypeConfig(
    BaseLib::ConfigTree const& config,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves)
{
    // if the BHE is using python boundary condition
    auto const bhe_if_use_python_bc_conf =
        config.getConfigParameter<bool>("use_bhe_pipe_network", false);
 
    if (bhe_if_use_python_bc_conf)
    {
        DBUG("BHE 1P using python boundary conditions.");
    }
 
    auto const borehole_geometry =
        createBoreholeGeometry(config.getConfigSubtree("borehole"));
 
    auto const& pipes_config = config.getConfigSubtree("pipes");
    Pipe const inlet_pipe = createPipe(pipes_config.getConfigSubtree("inlet"));
 
    const auto pipe_longitudinal_dispersion_length =
        pipes_config.getConfigParameter<double>(
            "longitudinal_dispersion_length");
    PipeConfiguration1PType const pipes{inlet_pipe,
                                        pipe_longitudinal_dispersion_length};
 
    auto const grout = createGroutParameters(config.getConfigSubtree("grout"));
 
    auto const refrigerant =
        createRefrigerantProperties(config.getConfigSubtree("refrigerant"));
 
    auto const flowAndTemperatureControl = createFlowAndTemperatureControl(
        config.getConfigSubtree("flow_and_temperature_control"),
        curves,
        refrigerant);
 
    return {borehole_geometry,         refrigerant, grout,
            flowAndTemperatureControl, pipes,       bhe_if_use_python_bc_conf};
}
 
template <typename T_BHE>
T_BHE createBHE1PType(
    BaseLib::ConfigTree const& config,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves)
{
    auto SinglePipeType = parseBHE1PTypeConfig(config, curves);
    return {std::get<0>(SinglePipeType), std::get<1>(SinglePipeType),
            std::get<2>(SinglePipeType), std::get<3>(SinglePipeType),
            std::get<4>(SinglePipeType), std::get<5>(SinglePipeType)};
}
 
template BHE_1P createBHE1PType<BHE_1P>(
    BaseLib::ConfigTree const& config,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves);
}  // namespace BHE
}  // namespace HeatTransportBHE
}  // namespace ProcessLib