ParameterLib/Utils.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 <vector>
 
#include "BaseLib/CompilerWorkarounds.h"
#include "BaseLib/ConfigTree.h"
#include "BaseLib/Error.h"
#include "Parameter.h"
 
namespace ParameterLib
{
ParameterBase* findParameterByName(
    std::string const& parameter_name,
    std::vector<std::unique_ptr<ParameterBase>> const& parameters);

template <typename ParameterDataType>
Parameter<ParameterDataType>* findParameterOptional(
    std::string const& parameter_name,
    std::vector<std::unique_ptr<ParameterBase>> const& parameters,
    int const num_components, MeshLib::Mesh const* const mesh = nullptr)
{
    // Find corresponding parameter by name.
    ParameterBase* parameter_ptr =
        findParameterByName(parameter_name, parameters);
    if (parameter_ptr == nullptr)
    {
        return nullptr;
    }
 
    // Check the type correctness of the found parameter.
    auto* const parameter =
        dynamic_cast<Parameter<ParameterDataType>*>(parameter_ptr);
    if (!parameter)
    {
        OGS_FATAL("The read parameter `{:s}' is of incompatible type.",
                  parameter_name);
    }
 
    if (num_components != 0 &&
        parameter->getNumberOfGlobalComponents() != num_components)
    {
        OGS_FATAL(
            "The read parameter `{:s}' has the wrong number of components "
            "({:d} instead of {:d}).",
            parameter_name, parameter->getNumberOfGlobalComponents(),
            num_components);
    }
 
    // Test the parameter's mesh only if there is a "test"-mesh provided.
    if (mesh != nullptr)
    {
        if (auto const error = isDefinedOnSameMesh(*parameter, *mesh))
        {
            OGS_FATAL(
                "The found parameter is not suitable for the use on the "
                "required mesh.\n{:s}",
                error->c_str());
        }
    }
 
    return parameter;
}

template <typename ParameterDataType>
OGS_NO_DANGLING Parameter<ParameterDataType>& findParameter(
    std::string const& parameter_name,
    std::vector<std::unique_ptr<ParameterBase>> const& parameters,
    int const num_components,
    MeshLib::Mesh const* const mesh = nullptr)
{
    auto* parameter = findParameterOptional<ParameterDataType>(
        parameter_name, parameters, num_components, mesh);
 
    if (!parameter)
    {
        OGS_FATAL(
            "Could not find parameter `{:s}' in the provided parameters list.",
            parameter_name);
    }
    return *parameter;
}

template <typename ParameterDataType>
OGS_NO_DANGLING Parameter<ParameterDataType>& findParameter(
    BaseLib::ConfigTree const& process_config,
    std::string const& tag,
    std::vector<std::unique_ptr<ParameterBase>> const& parameters,
    int const num_components,
    MeshLib::Mesh const* const mesh = nullptr)
{
    // Find parameter name in process config.
    auto const name = process_config.getConfigParameter<std::string>(tag);
 
    return findParameter<ParameterDataType>(name, parameters, num_components,
                                            mesh);
}

template <typename ParameterDataType>
Parameter<ParameterDataType>* findOptionalTagParameter(
    BaseLib::ConfigTree const& process_config, std::string const& tag,
    std::vector<std::unique_ptr<ParameterBase>> const& parameters,
    int const num_components, MeshLib::Mesh const* const mesh = nullptr)
{
    // Find parameter name in process config.
    auto const name =
        process_config.getConfigParameterOptional<std::string>(tag);
 
    if (!name)
    {
        return nullptr;
    }
    return &findParameter<ParameterDataType>(*name, parameters, num_components,
                                             mesh);
}
}  // namespace ParameterLib