loadGeometry.cc

Go to the documentation of this file.

 
// gsystem
#include "systemSqliteFactory.h"
#include "gsystemConventions.h"
 
// gemc
#include "gutilities.h"
 
// c++
#include <filesystem>
 
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; }
    }
 
    std::string cad_mesh_reference(const std::string& parameters, const std::string& description) {
        const auto values = gutilities::getStringVectorFromStringWithDelimiter(parameters, ",");
        if (values.empty() ||
            (values.size() == 1 && (values[0] == "NULL" || numeric_value(values[0])))) {
            return description;
        }
        return values[0];
    }
 
    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;
        int rc = sqlite3_prepare_v2(db, "SELECT name FROM PRAGMA_TABLE_INFO('geometry')", -1, &stmt, nullptr);
        if (rc != SQLITE_OK) { return false; }
 
        bool exists = false;
        while ((rc = 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 GSystemSQLiteFactory::loadGeometry(GSystem* system) {
    // skip ROOT system
    if (system->getName() == gsystem::ROOTWORLDGVOLUMENAME) { return; }
 
    // Initialize the DB if needed.
    if (db == nullptr) { initialize_sqlite_db(system); }
 
    // Check that db is valid.
    if (db == nullptr) {
        log->error(gsystem::ERR_GSQLITEERROR, "Database pointer is still null after initialization.");
    }
 
    const std::string placement_column = geometry_column_exists(db, "g4placement_type")
                                       ? "g4placement_type"
                                       : "'" + std::string(gsystem::DEFAULTG4PLACEMENTTYPE) +
                                         "' AS g4placement_type";
    const std::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;
    int           rc   = sqlite3_prepare_v2(db, sql_query.c_str(), -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        log->error(
            gsystem::ERR_GSQLITEERROR,
            "Sqlite error preparing count query in loadGeometry: %1 (%2) using query: %3", sqlite3_errmsg(db),
            rc, sql_query);
    }
 
    // Bind parameters.
    std::string experiment  = system->getExperiment();
    std::string system_name = system->getName();
    std::string variation   = system->getVariation();
    int         runno       = system->getRunno();
 
    rc = sqlite3_bind_text(stmt, 1, experiment.c_str(), -1, SQLITE_STATIC);
    if (rc != SQLITE_OK) {
        log->error(
            gsystem::ERR_GSQLITEERROR, "Error binding experiment: >%1<, %2", experiment, sqlite3_errmsg(db));
    }
    rc = sqlite3_bind_text(stmt, 2, system_name.c_str(), -1, SQLITE_STATIC);
    if (rc != SQLITE_OK) {
        log->error(
            gsystem::ERR_GSQLITEERROR, "Error binding system name: >%1<, %2", system_name, sqlite3_errmsg(db));
    }
    rc = sqlite3_bind_text(stmt, 3, variation.c_str(), -1, SQLITE_STATIC);
    if (rc != SQLITE_OK) {
        log->error(
            gsystem::ERR_GSQLITEERROR, "Error binding variation: >%1<, %2", variation, sqlite3_errmsg(db));
    }
    rc = sqlite3_bind_int(stmt, 4, runno);
    if (rc != SQLITE_OK) {
        log->error(gsystem::ERR_GSQLITEERROR, "Error binding run number: >%1<, %2", runno, sqlite3_errmsg(db));
    }
 
    // Log the expanded SQL for debugging (caller must free it).
    if (auto sql = sqlite3_expanded_sql(stmt)) {
        // returns char*
        log->info(2, "%1", sql);
        sqlite3_free(sql); // need to free the expanded SQL string
    }
 
    std::vector<std::string> gvolumePars;
    std::vector<std::string> cadSearchDirectories;
    for (const auto& location : possibleLocationOfFiles) {
        std::error_code ec;
        if (!std::filesystem::is_directory(location, ec)) { continue; }
 
        cadSearchDirectories.push_back(location);
        const auto systemLocation = std::filesystem::path(location) / system->getName();
        if (std::filesystem::is_directory(systemLocation, ec)) {
            cadSearchDirectories.push_back(systemLocation.string());
        }
    }
    while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
        int colCount = sqlite3_column_count(stmt);
        for (int i = 0; i < colCount; i++) {
            const char*          colName = sqlite3_column_name(stmt, i);
            const unsigned char* colText = sqlite3_column_text(stmt, i);
 
            log->info(
                2, "<sqlite> column: %1 = %2 (column %3)", (colName ? colName : "NULL"),
                (colText ? reinterpret_cast<const char*>(colText) : "NULL"), i);
 
            gvolumePars.emplace_back(colText ? reinterpret_cast<const char*>(colText) : "");
        }
 
        // CAD rows can coexist with native rows in a sqlite system. Resolve their database-authored
        // mesh path against the YAML and database locations before the Geant4 CAD builder sees it.
        if (gvolumePars[1] == gsystem::GSYSTEMCADTFACTORYLABEL) {
            const auto meshReference = cad_mesh_reference(gvolumePars[2], gvolumePars[19]);
            auto meshPath = gutilities::searchForFileInLocations(cadSearchDirectories,
                                                                 meshReference);
            if (!meshPath) {
                log->warning(
                    "SQLite factory: CAD volume <%1> references missing mesh <%2>; skipping.", gvolumePars[0],
                    meshReference);
                gvolumePars.clear();
                continue;
            }
            set_resolved_cad_mesh(gvolumePars, meshPath.value());
        }
 
        system->addGVolume(gvolumePars);
        gvolumePars.clear();
    }
 
    if (rc != SQLITE_DONE) {
        log->error(
            gsystem::ERR_GSQLITEERROR, "Sqlite database error in loadGeometry: %1 (%2)", sqlite3_errmsg(db),
            rc);
    }
 
    sqlite3_finalize(stmt);
}