gutilities.h

Go to the documentation of this file.

#pragma once
 
// c++
#include <vector>
#include <string>
#include <map>
#include <string_view>
#include <optional>
 
// geant4
#include "G4Colour.hh"
#include "G4SystemOfUnits.hh"
#include "G4UnitsTable.hh"
 
namespace gemc_units {
    inline constexpr G4double milligray = 1.e-3 * gray;
    inline constexpr G4double microgray = 1.e-6 * gray;
    inline constexpr G4double nanogray = 1.e-9 * gray;
    inline constexpr G4double picogray = 1.e-12 * gray;
}
 
 
 
namespace gutilities {
using std::string;
using std::vector;
using std::map;
 
std::string removeLeadingAndTrailingSpacesFromString(const std::string& input);
 
std::string_view removeLeadingAndTrailingSpacesFromString(const std::string_view input);
 
std::string removeAllSpacesFromString(const std::string& str);
 
std::vector<std::string> getStringVectorFromString(const std::string& input);
 
std::string replaceCharInStringWithChars(const std::string& input, const std::string& toReplace,
                                         const std::string& replacement);
 
 
string replaceAllStringsWithString(const string& source, const string& from, const string& to);
 
string fillDigits(const string& word, const string& c, int ndigits);
 
std::string getFileFromPath(const std::string& path);
 
std::string getDirFromPath(const std::string& path);
 
std::optional<std::string> searchForFileInLocations(
    const std::vector<std::string>& locations,
    std::string_view                filename);
 
bool directoryExists(const std::string& path);
 
string searchForDirInLocations(const string& dirName, const vector<string>& possibleLocations);
 
bool hasExtension(const string& filename, const vector<string>& extensions);
 
vector<string> getListOfFilesInDirectory(const string& dirName, const vector<string>& extensions);
 
double getG4Number(const string& v, bool warnIfNotUnit = false);
 
double getG4Number(double input, const string& unit);
 
vector<double> getG4NumbersFromStringVector(const vector<string>& vstring, bool warnIfNotUnit = false);
 
vector<double> getG4NumbersFromString(const string& vstring, bool warnIfNotUnit = false);
 
string parseFileAndRemoveComments(const string& filename, const string& commentChars = "#", int verbosity = 0);
 
 
string retrieveStringBetweenChars(const string& input, const string& firstDelimiter, const string& secondDelimiter);
 
 
vector<string> getStringVectorFromStringWithDelimiter(const string& input, const string& x);
 
string convertToLowercase(const string& str);
 
template <class KEY, class VALUE>
vector<KEY> getKeys(const map<KEY, VALUE>& map);
 
enum randomModel
{
    uniform,  
    gaussian, 
    cosine,   
    sphere    
};
 
randomModel stringToRandomModel(const std::string& str);
 
inline constexpr const char* to_string(randomModel m) noexcept {
    switch (m) {
    case uniform: return "uniform";
    case gaussian: return "gaussian";
    case cosine: return "cosine";
    case sphere: return "sphere";
    }
    return "<unknown>";
}
 
G4Colour makeG4Colour(std::string_view code, double opacity);
 
};
 
 
#include <filesystem>
 
#if defined(__APPLE__)
#include <mach-o/dyld.h>   // _NSGetExecutablePath
#elif defined(__linux__)
#include <unistd.h>        // readlink
#include <limits.h>
#elif defined(_WIN32)
#include <windows.h>
#include <vector>
#else
#error "Unsupported platform"
#endif
 
namespace gutilities {
inline std::filesystem::path executable_path() {
#if defined(__APPLE__)
    char     buf[PATH_MAX];
    uint32_t sz = sizeof(buf);
    if (_NSGetExecutablePath(buf, &sz) != 0) {
        // buffer too small
        std::string big(sz, '\0');
        if (_NSGetExecutablePath(big.data(), &sz) != 0)
            throw std::runtime_error("_NSGetExecutablePath failed");
        return std::filesystem::canonical(big);
    }
    return std::filesystem::canonical(buf);
 
#elif defined(__linux__)
    char    buf[PATH_MAX];
    ssize_t len = ::readlink("/proc/self/exe", buf, sizeof(buf) - 1);
    if (len == -1)
        throw std::runtime_error("readlink(/proc/self/exe) failed");
    buf[len] = '\0';
    return std::filesystem::canonical(buf);
 
#elif defined(_WIN32)
    std::wstring buf(MAX_PATH, L'\0');
    DWORD        len = ::GetModuleFileNameW(nullptr, buf.data(), buf.size());
    if (len == 0)
        throw std::runtime_error("GetModuleFileNameW failed");
    // If the path is longer than MAX_PATH the buffer is truncated;
    // do a second call with the returned length to get the full path.
    if (len == buf.size()) {
        buf.resize(len * 2);
        len = ::GetModuleFileNameW(nullptr, buf.data(), buf.size());
    }
    buf.resize(len);
    return std::filesystem::canonical(std::filesystem::path(buf));
#endif
}
 
inline std::filesystem::path gemc_root() {
    const auto exe_dir = executable_path().parent_path();
 
    std::filesystem::path root;
 
    // Case 1: executable came from ../bin or (for tests) build
    if (exe_dir.filename() == "bin" || exe_dir.filename() == "build") {
        root = exe_dir.parent_path();
    }
    // else {
    //     // Case 2: use GEMC environment variable
    //     const char* env = std::getenv("GEMC");
    //     if (!env || std::string(env).empty()) {
    //         throw std::runtime_error(
    //             "GEMC executable not in <.../bin>. Environment variable GEMC is required."
    //         );
    //     }
    //     root = std::filesystem::path(env);
    // }
 
    // Sanity check
    if (!std::filesystem::exists(root / "api")) {
        throw std::runtime_error(
            "Cannot locate directory <api> under " + root.string() +
            ". Check installation layout or GEMC environment variable."
        );
    }
 
    return root;
}
 
 
bool is_unset(std::string_view s);
 
inline std::string success_or_fail(bool condition) { return condition ? "success" : "fail"; }
 
void apply_uimanager_commands(const std::string& commands);
}