CreateBHECoaxial.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#include "CreateBHECoaxial.h"
 
#include "BHE_CXA.h"
#include "BHE_CXC.h"
#include "BaseLib/ConfigTree.h"
#include "BaseLib/Error.h"
#include "CreateFlowAndTemperatureControl.h"
namespace ProcessLib
{
namespace HeatTransportBHE
{
namespace BHE
{
static std::tuple<BoreholeGeometry, RefrigerantProperties, GroutParameters,
                  FlowAndTemperatureControl, PipeConfigurationCoaxial, bool>
parseBHECoaxialConfig(
    BaseLib::ConfigTree const& config,
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>>& parameters,
    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);
    DBUG("If using python boundary condition : {:s}",
         (bhe_if_use_python_bc_conf) ? "true" : "false");
 
    auto const borehole_geometry =
        createBoreholeGeometry(config.getConfigSubtree("borehole"), parameters);

    auto const& pipes_config = config.getConfigSubtree("pipes");
    Pipe const outer_pipe =
        createPipe(pipes_config.getConfigSubtree("outer"), parameters);
    Pipe const inner_pipe =
        createPipe(pipes_config.getConfigSubtree("inner"), parameters);
    const auto pipe_longitudinal_dispersion_length =
        pipes_config.getConfigParameter<double>(
            "longitudinal_dispersion_length");
    PipeConfigurationCoaxial const pipes{inner_pipe, outer_pipe,
                                         pipe_longitudinal_dispersion_length};
 
    double const annulus_diameter =
        coaxialPipesAnnulusDiameter(pipes.inner_pipe, pipes.outer_pipe);
    if (annulus_diameter <= 0)
    {
        OGS_FATAL(
            "Invalid coaxial pipe geometry: outer pipe inner diameter ({:g}) "
            "must be greater than inner pipe outside diameter ({:g}).",
            pipes.outer_pipe.diameter, pipes.inner_pipe.outsideDiameter());
    }

    auto const grout = createGroutParameters(config.getConfigSubtree("grout"));
 
    auto const refrigerant =
        createRefrigerantProperties(config.getConfigSubtree("refrigerant"));
 
    auto const flowAndTemperatureControl = createFlowAndTemperatureControl(
        config.getConfigSubtree("flow_and_temperature_control"),
        parameters,
        curves,
        refrigerant);
 
    return {borehole_geometry,         refrigerant, grout,
            flowAndTemperatureControl, pipes,       bhe_if_use_python_bc_conf};
}
 
template <typename T_BHE>
T_BHE createBHECoaxial(
    BaseLib::ConfigTree const& config,
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>>& parameters,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves)
{
    auto coaxial = parseBHECoaxialConfig(config, parameters, curves);
    return {std::get<0>(coaxial), std::get<1>(coaxial), std::get<2>(coaxial),
            std::get<3>(coaxial), std::get<4>(coaxial), std::get<5>(coaxial)};
}
 
template BHE_CXA createBHECoaxial<BHE_CXA>(
    BaseLib::ConfigTree const& config,
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>>& parameters,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves);
 
template BHE_CXC createBHECoaxial<BHE_CXC>(
    BaseLib::ConfigTree const& config,
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>>& parameters,
    std::map<std::string,
             std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
        curves);
}  // namespace BHE
}  // namespace HeatTransportBHE
}  // namespace ProcessLib