OMSimInputData.hh

Go to the documentation of this file.

 
#pragma once
 
#include "OMSimLogger.hh"
#include "OMSimOpBoundaryProcess.hh"
#include <G4SystemOfUnits.hh>
#include <boost/property_tree/json_parser.hpp>
 
namespace pt = boost::property_tree;
 
class ParameterTable
{
public:
    ParameterTable(){};
 
    template <typename T>
    T getValue(G4String pKey, G4String pParameter)
    {
        log_trace("Fetching parameter {} in key {}", pParameter, pKey);
        try
        {
            const T lValue = m_table.at(pKey).get<T>(pParameter);
            return lValue;
        }
 
        catch (const std::exception &e)
        {
            log_error("Fetching parameter {} in key {} from table failed!", pParameter, pKey);
            throw std::runtime_error("Fetching parameter failed");
        }
    }
 
    G4bool checkIfTreeNameInTable(G4String pKey);
    G4bool checkIfKeyInTree(G4String p_treeName, G4String p_key);
    G4double getValueWithUnit(G4String pKey, G4String pParameter);
    pt::ptree appendAndReturnTree(G4String pFileName);
    pt::ptree getJSONTree(G4String pKey);
 
    template <typename T>
    void parseKeyContentToVector(std::vector<T> &pVector, pt::ptree pTree,
                                 std::basic_string<char> pKey, G4double pScaling,
                                 bool pInverse)
    {
        log_trace("Parsing content in key {} to a vector", pKey);
        for (pt::ptree::value_type &ridx : pTree.get_child(
                 pKey))
        { // get array from element with key "pKey" of the json
            if (pInverse)
            { // if we need 1/x
                pVector.push_back(pScaling / ridx.second.get_value<T>());
            }
            else
            { // otherwise we only by scaling factor
                pVector.push_back(ridx.second.get_value<T>() * pScaling);
            }
        }
    };
 
    template <typename T>
    void parseKeyContentToVector(std::vector<T> &pVector,
                                 std::basic_string<char> p_MapKey,
                                 std::basic_string<char> pKey, G4double pScaling,
                                 bool pInverse)
    {
        log_trace("Parsing content in key {} to a vector", pKey);
 
        // Get the JSON tree
        boost::property_tree::ptree lTree = getJSONTree(p_MapKey);
 
        // Check if the tree is empty
        if (lTree.empty())
        {
            log_warning("JSON tree is empty for key {}", p_MapKey);
            return;
        }
 
        // Access the child node with the key "pKey"
        auto lChildNode = lTree.get_child_optional(pKey);
 
        // Check if the child node exists
        if (!lChildNode)
        {
            log_warning("Child node with key {} not found in JSON tree", pKey);
            return;
        }
 
        // Iterate over the child nodes and parse the content
        for (const auto &ridx : *lChildNode)
        {
            if (pInverse)
            {
                // if we need 1/x
                pVector.push_back(pScaling / ridx.second.get_value<T>());
            }
            else
            {
                // otherwise we only multiply by scaling factor
                pVector.push_back(ridx.second.get_value<T>() * pScaling);
            }
        }
    };
 
private:
    std::map<G4String, boost::property_tree::ptree> m_table; 
    std::map<G4String, G4String> m_keyToFileName;            
};
 
class OMSimInputData : public ParameterTable
{
public:
    static void init();
    static void shutdown();
    static OMSimInputData& getInstance();
    G4Material *getMaterial(G4String pName);
    G4OpticalSurface *getOpticalSurface(G4String pName);
    void searchFolders();
    std::map<G4String, G4OpticalSurface *> m_opticalSurfaceMap; 
 
private:
    enum class FileType {
        IceCubeICE,
        Scintillator,
        Extra,
        Table,
        Surface,
        Material
    };
 
    static const std::unordered_map<std::string, FileType> fileTypePrefixes;
    FileType getFileType(const std::string& fileName) const;
 
    OMSimInputData() = default;
    ~OMSimInputData() = default;
    OMSimInputData(const OMSimInputData&) = delete;
    OMSimInputData& operator=(const OMSimInputData&) = delete;
    void scannDataDirectory();
    void processFile(const std::string &filePath, const std::string &fileName);
    G4String m_dataDirectory; 
};
 
inline OMSimInputData* g_OMSimInputData = nullptr;