loggingparametertree.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
//
// SPDX-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
#ifndef DUMUX_LOGGING_PARAMETER_TREE_HH
#define DUMUX_LOGGING_PARAMETER_TREE_HH
 
#include <iomanip>
#include <iostream>
#include <string>
#include <memory>
#include <mutex>
 
#include <dune/common/parametertree.hh>
#include <dumux/common/exceptions.hh>
 
namespace Dumux {
 
class LoggingParameterTree
{
 
public:
    /*
     * \brief A logging parameter tree is always attached to an existingparameter tree
     */
    LoggingParameterTree() = delete;
 
    /*
     * \brief Create LoggingParameterTree from ParameterTree
     */
    LoggingParameterTree(const Dune::ParameterTree& params, const Dune::ParameterTree& defaultParams)
    : params_(params)
    , defaultParams_(defaultParams)
    , usedRuntimeParams_(std::make_unique<Dune::ParameterTree>())
    , usedDefaultParams_(std::make_unique<Dune::ParameterTree>())
    {}
 
    bool hasKey(const std::string& key) const
    { return params_.hasKey(key); }
 
    bool hasKeyInGroup(const std::string& key,
                       const std::string& groupPrefix) const
    {
        if (groupPrefix.empty())
            return hasKey(key);
 
        if (hasKey(key))
            return true;
 
        auto compoundKey = groupPrefix + "." + key;
        if (params_.hasKey(compoundKey))
            return true;
 
        compoundKey = findKeyInGroup(params_, key, groupPrefix);
        if (compoundKey != "")
            return true;
 
        return false;
    }
 
    std::vector<std::string> getSubGroups(const std::string& subGroupName,
                                          std::string groupPrefix) const
    {
        std::vector<std::string> groupNames;
 
        if (!groupPrefix.empty())
        {
            auto compoundGroup = groupPrefix + "." + subGroupName;
            for (std::string::size_type dotPos = 0; dotPos != std::string::npos; dotPos = groupPrefix.rfind("."))
            {
                if (params_.hasSub(compoundGroup) || defaultParams_.hasSub(compoundGroup))
                    groupNames.push_back(compoundGroup);
 
                groupPrefix = groupPrefix.substr(0, dotPos);
                compoundGroup = groupPrefix + "." + subGroupName;
            }
        }
 
        if (params_.hasSub(subGroupName) || defaultParams_.hasSub(subGroupName))
            groupNames.push_back(subGroupName);
 
        return groupNames;
    }
 
    void report(std::ostream& stream = std::cout) const
    { params_.report(stream); }
 
    void reportAll(std::ostream& stream = std::cout) const
    {
        stream << "\n# Runtime-specified parameters used:" << std::endl;
        usedRuntimeParams_->report(stream);
 
        stream << "\n# Global default parameters used:" << std::endl;
        usedDefaultParams_->report(stream);
 
        const auto unusedParams = getUnusedKeys();
        if (!unusedParams.empty())
        {
            stream << "\n# Unused parameters:" << std::endl;
            for (const auto& key : unusedParams)
                stream << key << " = \"" << params_[key] << "\"" << std::endl;
        }
    }
 
    std::string findKeyInGroup(const Dune::ParameterTree& tree,
                               const std::string& key,
                               const std::string& groupPrefix) const
    {
        // search backwards until key is found
        std::string prefix = groupPrefix;
        auto dot = prefix.rfind(".");
        while (dot != std::string::npos)
        {
            prefix = prefix.substr(0, dot);
            std::string compoundKey = prefix + "." + key;
 
            if (tree.hasKey(compoundKey))
                return compoundKey;
 
            // look for the next dot in the current prefix
            dot = prefix.rfind(".");
 
        }
 
        // the key was not found
        return "";
    }
 
    std::string get(const std::string& key, const std::string& defaultValue) const
    {
        if (params_.hasKey(key))
        {
            // log that we used this parameter
            const auto returnValue = params_[key];
            logUsedRuntimeParam_(key, returnValue);
            return returnValue;
        }
 
        return defaultValue;
    }
 
    std::string getFromGroup(const std::string& groupPrefix,
                             const std::string& key,
                             const std::string& defaultValue) const
    {
        if (groupPrefix.empty())
            return get(key, defaultValue);
 
        // first, look for the compound key
        std::string compoundKey = groupPrefix + "." + key;
        if (params_.hasKey(compoundKey))
        {
            // log that we used this parameter
            const auto returnValue = params_[compoundKey];
            logUsedRuntimeParam_(compoundKey, returnValue);
            return returnValue;
        }
 
        // search backwards until key is found
        compoundKey = findKeyInGroup(params_, key, groupPrefix);
        if (compoundKey != "")
        {
            // log that we used this parameter
            const auto returnValue = params_[compoundKey];
            logUsedRuntimeParam_(compoundKey, returnValue);
            return returnValue;
        }
 
        // finally, look for the key without prefix
        return get(key, defaultValue);
    }
 
    std::string get(const std::string& key, const char* defaultValue) const
    {
        const std::string dv = defaultValue;
        return get(key, dv);
    }
 
    std::string getFromGroup(const std::string& groupPrefix,
                             const std::string& key,
                             const char* defaultValue) const
    {
        const std::string dv = defaultValue;
        return getFromGroup(groupPrefix, key, dv);
    }
 
 
    template<typename T>
    T get(const std::string& key, const T& defaultValue) const
    {
        if (params_.hasKey(key))
        {
            // log that we used this parameter
            logUsedRuntimeParam_(key, params_[key]);
            return params_.template get<T>(key);
        }
 
        return defaultValue;
    }
 
    template<typename T>
    T getFromGroup(const std::string& groupPrefix,
                   const std::string& key,
                   const T& defaultValue) const
    {
        if (groupPrefix.empty())
            return get<T>(key, defaultValue);
 
        // first, look for the compound key
        std::string compoundKey = groupPrefix + "." + key;
        if (params_.hasKey(compoundKey))
        {
            // log that we used this parameter
            logUsedRuntimeParam_(compoundKey, params_[compoundKey]);
            return params_.template get<T>(compoundKey);
        }
 
        // search backwards until key is found
        compoundKey = findKeyInGroup(params_, key, groupPrefix);
        if (compoundKey != "")
        {
            // log that we used this parameter
            logUsedRuntimeParam_(compoundKey, params_[compoundKey]);
            return params_.template get<T>(compoundKey);
        }
 
        // finally, look for the key without prefix
        return get<T>(key, defaultValue);
    }
 
    template <class T>
    T get(const std::string& key) const
    {
        if (params_.hasKey(key))
        {
            // log that we used this parameter
            logUsedRuntimeParam_(key, params_[key]);
            return params_.template get<T>(key);
        }
 
        else if(defaultParams_.hasKey(key))
        {
            // use the default
            logUsedDefaultParam_(key, defaultParams_[key]);
            return defaultParams_.template get<T>(key);
        }
 
        DUNE_THROW(Dumux::ParameterException, "Key " << key << " not found in the parameter tree");
    }
 
    template<typename T>
    T getFromGroup(const std::string& groupPrefix,
                   const std::string& key) const
    {
        if (groupPrefix.empty())
            return get<T>(key);
 
        // first, look for the compound key
        std::string compoundKey = groupPrefix + "." + key;
        if (params_.hasKey(compoundKey))
        {
            // log that we used this parameter
            logUsedRuntimeParam_(compoundKey, params_[compoundKey]);
            return params_.template get<T>(compoundKey);
        }
 
        // search backwards until key is found
        compoundKey = findKeyInGroup(params_, key, groupPrefix);
        if (compoundKey != "")
        {
            // log that we used this parameter
            logUsedRuntimeParam_(compoundKey, params_[compoundKey]);
            return params_.template get<T>(compoundKey);
        }
 
        // reset the compoundKey
        compoundKey = groupPrefix + "." + key;
 
        // if the backward search did not succeed, try the bare key without any prefix
        if (params_.hasKey(key))
        {
            // log that we used this parameter
            logUsedRuntimeParam_(key, params_[key]);
            return params_.template get<T>(key);
        }
 
        // if this did not work, repeat the procedure using the default parameters
        else if(defaultParams_.hasKey(compoundKey))
        {
            // use the default
            logUsedDefaultParam_(compoundKey, defaultParams_[compoundKey]);
            return defaultParams_.template get<T>(compoundKey);
        }
 
        else
        {
            // search backwards until key is found
            compoundKey = findKeyInGroup(defaultParams_, key, groupPrefix);
            if (compoundKey != "")
            {
                // log that we used this parameter
                logUsedDefaultParam_(compoundKey, defaultParams_[compoundKey]);
                return defaultParams_.template get<T>(compoundKey);
            }
 
            if(defaultParams_.hasKey(key))
            {
                // use the default
                logUsedDefaultParam_(key, defaultParams_[key]);
                return defaultParams_.template get<T>(key);
            }
 
            DUNE_THROW(Dumux::ParameterException, "Key " << key << " not found in the parameter tree");
        }
    }
 
    std::vector<std::string> getUnusedKeys() const
    {
        std::vector<std::string> unusedParams;
        findUnusedKeys_(params_, unusedParams);
        return unusedParams;
    }
 
private:
    void findUnusedKeys_(const Dune::ParameterTree& tree,
                         std::vector<std::string>& unusedParams,
                         const std::string& prefix = "") const
    {
        // loop over all keys of the current tree
        // store keys which were not accessed
        const auto& keys = tree.getValueKeys();
        for (const auto& key : keys)
            if (key != "ParameterFile" && !usedRuntimeParams_->hasKey(prefix + key))
                unusedParams.push_back(prefix + key);
 
        // recursively loop over all subtrees
        const auto& subTreeKeys = tree.getSubKeys();
        for (const auto& key : subTreeKeys)
            findUnusedKeys_(tree.sub(key), unusedParams, prefix + key + ".");
    }
 
    void logUsedRuntimeParam_(const std::string& key, const std::string& value) const
    {
        std::scoped_lock lock{ usedRuntimeMutex_ };
        usedRuntimeParams_->operator[](key) = value;
    }
 
    void logUsedDefaultParam_(const std::string& key, const std::string& value) const
    {
        std::scoped_lock lock{ usedDefaultMutex_ };
        usedDefaultParams_->operator[](key) = value;
    }
 
    const Dune::ParameterTree& params_;
    const Dune::ParameterTree& defaultParams_;
 
    // logging caches (externally stored)
    std::unique_ptr<Dune::ParameterTree> usedRuntimeParams_;
    std::unique_ptr<Dune::ParameterTree> usedDefaultParams_;
 
    // access to the caches have to be protected for thread-safety
    mutable std::mutex usedRuntimeMutex_;
    mutable std::mutex usedDefaultMutex_;
};
 
} // end namespace Dumux
 
#endif