loadGeometry.cc

Go to the documentation of this file.

 
// gsystem
#include "systemCadFactory.h"
#include "gsystemConventions.h"
 
// gemc
#include "gutilities.h"
 
// sqlite
#include "sqlite3.h"
 
// c++
#include <filesystem>
#include <unordered_map>
 
using namespace std;
 
namespace {
    bool numeric_value(const std::string& value) {
        try {
            size_t parsed = 0;
            // Only the parsed length matters here (is the whole string numeric?); discard the value.
            static_cast<void>(std::stod(value, &parsed));
            return parsed == value.size();
        }
        catch (const std::exception&) { return false; }
    }
 
    void set_resolved_cad_mesh(std::vector<std::string>& row, const std::string& resolved) {
        constexpr int PARAMETERS_INDEX  = 2;
        constexpr int DESCRIPTION_INDEX = 19;
        const auto values =
            gutilities::getStringVectorFromStringWithDelimiter(row[PARAMETERS_INDEX], ",");
        if (values.empty() ||
            (values.size() == 1 && (values[0] == "NULL" || numeric_value(values[0])))) {
            row[DESCRIPTION_INDEX] = resolved;
            return;
        }
 
        const auto delimiter = row[PARAMETERS_INDEX].find(',');
        const auto suffix = delimiter == std::string::npos ? "" : row[PARAMETERS_INDEX].substr(delimiter);
        row[PARAMETERS_INDEX] = resolved + suffix;
    }

    bool geometry_column_exists(sqlite3* db, const std::string& column_name) {
        sqlite3_stmt* stmt = nullptr;
        if (sqlite3_prepare_v2(db, "SELECT name FROM PRAGMA_TABLE_INFO('geometry')", -1, &stmt, nullptr) != SQLITE_OK) {
            return false;
        }
        bool exists = false;
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            const unsigned char* colText = sqlite3_column_text(stmt, 0);
            if (colText != nullptr && column_name == reinterpret_cast<const char*>(colText)) {
                exists = true;
                break;
            }
        }
        sqlite3_finalize(stmt);
        return exists;
    }
}
 
void GSystemCADFactory::loadGeometry(GSystem* s) {
    // skip ROOT system
    if (s->getName() == gsystem::ROOTWORLDGVOLUMENAME) { return; }
 
    // Resolve the directory holding the CAD meshes.
    const auto dirLocation = gutilities::searchForDirInLocations(s->getFilePath(), possibleLocationOfFiles);
    if (!dirLocation) {
        log->error(gsystem::ERR_GDIRNOTFOUND, "CAD Directory >%1< not found.", s->getFilePath());
    }
 
    // Map each available mesh file to its stem (filename without extension), which is the volume name.
    unordered_map<string, string> meshByName;
    for (const auto& cf : gutilities::getListOfFilesInDirectory(dirLocation->string(), {".stl", ".ply"})) {
        meshByName[filesystem::path(cf).stem().string()] = cf;
    }
 
    // The list of volumes to load - and their metadata - comes from the sqlite database, not from the
    // directory listing: only meshes that have a matching row in the geometry table are imported.
    string dbhost = s->get_dbhost();
    if (dbhost.empty() || dbhost == "na") { dbhost = gsystem::GSYSTEMSQLITETDEFAULTFILE; }
 
    vector<string> dirs = {
        ".",
        gutilities::gemc_root().string(),
        (gutilities::gemc_root() / "examples").string()
    };
    auto dbPath = gutilities::searchForFileInLocations(dirs, dbhost);
    if (!dbPath) {
        log->error(gsystem::ERR_GSQLITEERROR, "CAD factory: sqlite database <%1> not found.", dbhost);
        return;
    }
 
    sqlite3* db = nullptr;
    if (sqlite3_open_v2(dbPath.value().c_str(), &db, SQLITE_OPEN_READONLY, nullptr) != SQLITE_OK) {
        sqlite3_close(db);
        log->error(gsystem::ERR_GSQLITEERROR, "CAD factory: failed to open sqlite database <%1>.", dbhost);
        return;
    }
    log->info(1, "CAD factory: reading definitions from sqlite database %1", dbPath.value());
 
    const string placement_column = geometry_column_exists(db, "g4placement_type")
                                    ? "g4placement_type"
                                    : "'" + string(gsystem::DEFAULTG4PLACEMENTTYPE) +
                                      "' AS g4placement_type";
    const string sql_query =
        "SELECT DISTINCT name, solid, parameters, material, mother, position, rotations, " +
        placement_column +
        ", mfield, visible, style, color, opacity, digitization, identifier, copyOf, solidsOpr, mirror, "
        "exist, description FROM geometry WHERE experiment = ? AND system = ? AND variation = ? AND run = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db, sql_query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
        log->error(gsystem::ERR_GSQLITEERROR, "CAD factory: error preparing query: %1", sqlite3_errmsg(db));
        sqlite3_close(db);
        return;
    }
 
    string experiment  = s->getExperiment();
    string system_name = s->getName();
    string variation   = s->getVariation();
    int    runno       = s->getRunno();
 
    sqlite3_bind_text(stmt, 1, experiment.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, system_name.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, variation.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, 4, runno);
 
    int loaded = 0;
    int rc;
    while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
        vector<string> gvolumePars;
        const int      colCount = sqlite3_column_count(stmt);
        for (int i = 0; i < colCount; i++) {
            const unsigned char* colText = sqlite3_column_text(stmt, i);
            gvolumePars.emplace_back(colText ? reinterpret_cast<const char*>(colText) : "");
        }
 
        const string& volumeName = gvolumePars[0];
        const string& solidType  = gvolumePars[1];
 
        // Only CAD volumes are resolved against the mesh directory. A CAD volume defined in the
        // database but missing its mesh file is skipped with a warning.
        if (solidType == gsystem::GSYSTEMCADTFACTORYLABEL) {
            auto it = meshByName.find(volumeName);
            if (it == meshByName.end()) {
                log->warning(
                    "CAD factory: volume <%1> is defined in the database but no mesh file was found in <%2>; "
                    "skipping.", volumeName, dirLocation->string());
                continue;
            }
            set_resolved_cad_mesh(gvolumePars, (*dirLocation / it->second).string());
        }
 
        s->addGVolume(gvolumePars);
        loaded++;
    }
 
    if (rc != SQLITE_DONE) {
        log->error(
            gsystem::ERR_GSQLITEERROR, "CAD factory: sqlite error while reading geometry: %1",
            sqlite3_errmsg(db));
    }
 
    sqlite3_finalize(stmt);
    sqlite3_close(db);
 
    log->info(
        0,
        "CAD factory: loaded %1 volume(s) for system <%2>, variation <%3>, run %4 (%5 mesh file(s) present "
        "in <%6>).", loaded, system_name, variation, runno, meshByName.size(), dirLocation->string());
}