GeoSetup.cxx

Go to the documentation of this file.

#include "GeoSetup.h"
 
#include "BmnNewFieldMap.h"
#include "FairModule.h"
#include "FairRunAna.h"
#include "TGeoBBox.h"
#include "TGeoBoolNode.h"
#include "TGeoCompositeShape.h"
#include "TGeoCone.h"
#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TGeoTrd2.h"
#include "TGeoTube.h"
#include "TKey.h"
#include "TSQLResult.h"
#include "TSQLRow.h"
#include "TSQLiteServer.h"
#include "TSystem.h"
#include "TXMLEngine.h"
 
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <filesystem>
#include <iostream>
#include <stdexcept>
#include <sys/stat.h> /* stat */
#include <time.h>     /* time */
#include <unistd.h>   /* access, getpid */
 
bool GeoSetup::exists_file(const char* name)
{
    return (access(name, F_OK) != -1);
}
 
bool ichar_equals(char a, char b)
{
    return std::tolower(static_cast<unsigned char>(a)) == std::tolower(static_cast<unsigned char>(b));
}
 
// TSQLRow::GetField() returns nullptr for a NULL field and the server answers are not trusted,
// so all conversions below tolerate a missing or malformed value instead of crashing or throwing
static int FieldToInt(const char* field, int defaultValue = 0)
{
    if (field == nullptr)
        return defaultValue;
    char* end = nullptr;
    long value = strtol(field, &end, 10);
    return (end == field) ? defaultValue : static_cast<int>(value);
}
 
static uint64_t FieldToUInt64(const char* field, uint64_t defaultValue = 0)
{
    if (field == nullptr)
        return defaultValue;
    char* end = nullptr;
    unsigned long long value = strtoull(field, &end, 10);
    return (end == field) ? defaultValue : static_cast<uint64_t>(value);
}
 
static double FieldToDouble(const char* field, double defaultValue = 0.)
{
    if (field == nullptr)
        return defaultValue;
    char* end = nullptr;
    double value = strtod(field, &end);
    return (end == field) ? defaultValue : value;
}
 
// setup tags are put into shell command lines, so only the characters used in tag names are allowed
static bool IsSafeTag(const string& tag)
{
    if (tag.empty())
        return false;
    for (char c : tag)
        if (!std::isalnum(static_cast<unsigned char>(c)) && c != '_' && c != '.' && c != '-')
            return false;
 
    return true;
}
 
// double the single quotes to safely put the value into an SQL string literal
static string SqlEscape(string_view value)
{
    string escaped;
    escaped.reserve(value.size());
    for (char c : value) {
        escaped += c;
        if (c == '\'')
            escaped += c;
    }
 
    return escaped;
}
 
// unique name of a temporary file in the /tmp/$USER/ folder
TString GeoSetup::GetTmpFileName(const char* baseName)
{
    return GetTmpPath() + TString::Format("%s_%d", baseName, gSystem->GetPid());
}
 
unsigned long int GeoSetup::GetServerRevision(const char* url)
{
    unsigned long int serverRev = 0;
    // a unique file name in the temporary folder: several jobs can run in the same working directory
    TString fileName = GetTmpFileName("server_revision.txt");
    gSystem->Exec(TString::Format("wget -O %s \"%s/get_cur_timestamp.php\" > /dev/null 2>&1", fileName.Data(), url));
    std::ifstream myFile_Handler;
    std::string myLine;
    myFile_Handler.open(fileName.Data());
    if (myFile_Handler.is_open()) {
        char* ptr;
        while (getline(myFile_Handler, myLine)) {
            serverRev = strtoul(myLine.c_str(), &ptr, 10);
            break;
        }
        myFile_Handler.close();
        std::remove(fileName.Data());
    }
    return serverRev;
}
string GeoSetup::GetLastApprovedSetupTag(string_view pattern)
{
    std::pair<int, string> res = GetTagName4PatternServer(pattern);
    if (res.first == 1)
        return res.second;
    CloseDB();
    TString localDbPath = GetLocalDbPath().c_str();
    res = GetTagName4PatternLocal(pattern, localDbPath);
    CloseDB();
    if (res.first == 1)
        return res.second;
    string message = "Setup not found for pattern: " + std::string(pattern);
    LOG(error) << message;
    throw std::invalid_argument(message);
}
std::pair<int, string> GeoSetup::GetTagName4PatternServer(string_view pattern_tag, const char* url)
{
    std::pair<int, string> res = std::make_pair<int, string>(0, "");
    // the pattern is put into a shell command line, so it has to be checked; a string_view is not
    // necessarily null-terminated, hence the copy
    std::string pattern(pattern_tag);
    if (!IsSafeTag(pattern)) {
        LOG(error) << "ERROR: the setup tag pattern contains forbidden characters: `" << pattern << "`";
        return res;
    }
    // a unique file name in the temporary folder: several jobs can run in the same working directory
    TString fileName = GetTmpFileName("setup_name.txt");
    std::remove(fileName.Data());
    TString command = TString::Format("wget -O %s \"%s/get_setup_name.php?tag=%s\" > /dev/null 2>&1", fileName.Data(),
                                      url, pattern.c_str());
    gSystem->Exec(command);
    std::ifstream myFile_Handler;
    std::string myLine;
    myFile_Handler.open(fileName.Data());
    if (myFile_Handler.is_open()) {
        getline(myFile_Handler, myLine);
        myFile_Handler.close();
        // the server answer is read, the downloaded file is not needed any more
        std::remove(fileName.Data());
        std::size_t found = myLine.find(";");
        if (found == std::string::npos) {
            return res;
        }
        vector<string> results;
        istringstream f(myLine);
        std::string token;
        while (getline(f, token, ':')) {
            results.push_back(token);
        }
        if (results.size() != 3)
            return res;
        res = std::make_pair<int, string>(1, results[0].c_str());
    }
    return res;
}
 
std::pair<int, uint64_t> GeoSetup::CheckTagOnServer(string_view setup_tag, const char* url)
{
    int retval = -1;
    // a unique file name in the temporary folder: several jobs can run in the same working directory
    TString fileName = GetTmpFileName("server_setup_list.txt");
    gSystem->Exec(TString::Format("wget -O %s \"%s/get_setup_list.php\" > /dev/null 2>&1", fileName.Data(), url));
    std::ifstream myFile_Handler;
    std::string myLine;
    std::string sTag(setup_tag);
    myFile_Handler.open(fileName.Data());
    if (myFile_Handler.is_open()) {
        while (getline(myFile_Handler, myLine)) {
            istringstream f(myLine);
            string s;
            while (getline(f, s, ';')) {
                vector<string> results;
                std::string token;
                std::istringstream input;
                input.str(s);
                while (getline(input, token, ':')) {   // Specify the delimiter
                    results.push_back(token);
                }
                if (results.size() < 2)
                    continue;   // wrong format
                std::string tag = results[0];
                std::string status = results[1];
                uint64_t upTime = 0;
                if (results.size() > 2) {
                    // the server answer is not trusted: a non-numeric value must not throw
                    upTime = FieldToUInt64(results[2].c_str());
                }
                bool bb = std::equal(tag.begin(), tag.end(), sTag.begin(), sTag.end(), ichar_equals);
                if (tag.size() == sTag.size() && bb) {
                    myFile_Handler.close();
                    std::remove(fileName.Data());
                    return std::make_pair(FieldToInt(status.c_str(), -1), upTime);
                }
            }
            break;
        }
        myFile_Handler.close();
        std::remove(fileName.Data());
    }
    return std::make_pair(retval, 0);
}
 
std::pair<int, string> GeoSetup::GetTagName4PatternLocal(string_view pattern_tag, TString& localDbPath)
{
    std::pair<int, string> res = std::make_pair<int, string>(0, "");
    if (exists_file(localDbPath)) {
        std::ostringstream stringStream;
        stringStream << "sqlite://" << localDbPath;
        TSQLiteServer db(stringStream.str().c_str());
        stringStream.str("");
        if (db.IsConnected()) {
            stringStream << "SELECT setup_tag, status, creation_date FROM setup where status=1 and setup_tag like '"
                         << SqlEscape(pattern_tag) << "%' order by creation_date DESC limit 1;";
            TSQLResult* resQ = db.Query(stringStream.str().c_str());
            if (resQ != 0) {
                TSQLRow* row = resQ->Next();
                if (row != NULL) {
                    const char* name = row->GetField(0);
                    if (name != NULL)
                        res = std::make_pair<int, string>(1, name);
                }
            }
        }
    }
    return res;
}
unsigned long int GeoSetup::GetLocalRevision(TString& localDbPath)
{
    unsigned long int localRev = 0;
    // char type;
    if (exists_file(localDbPath)) {
        std::ostringstream stringStream;
        stringStream << "sqlite://" << localDbPath;
        TSQLiteServer db(stringStream.str().c_str());
        stringStream.str("");
        if (db.IsConnected()) {
            stringStream << "select value_field from config where key_field='config_time';";
            // cout << stringStream.str().c_str() << std::endl;
            TSQLResult* resQ = db.Query(stringStream.str().c_str());
            if (resQ != 0) {
                TSQLRow* row = resQ->Next();
                if (row != NULL) {
                    const char* ch_time = row->GetField(0);
                    char* ptr;
                    if (ch_time != NULL)
                        localRev = strtoul(ch_time, &ptr, 10);
                }
            }
        }
    }
    return localRev;
}
 
// check that the directory can be modified to install the Local Geometry DB (e.g. in case of CVMFS)
bool GeoSetup::IsWritableDir(const char* path)
{
    return (access(path, W_OK | X_OK) == 0);
}
 
// the unique folder, where the Local Geometry Database is installed by this process
// instead of the read-only directory, and the process owning the folder
static string gWritableDbDir;
static pid_t gWritableDbPid = 0;
 
// remove the unique folder of the installed database at the process exit
static void RemoveWritableDbDir()
{
    // a forked child process must not remove the folder, which is still used by the parent process
    if (gWritableDbDir.empty() || getpid() != gWritableDbPid)
        return;
 
    error_code ec;
    filesystem::remove_all(gWritableDbDir, ec);
}
 
// prepare a writable directory to install the Local Geometry Database to, when the directory of the
// DBL_FILE_PATH value is read-only. A unique folder is created in the DBL_CACHE_PATH directory, if it is set,
// otherwise in $TMPDIR or in /tmp/$USER
TString GeoSetup::PrepareWritableDbDir()
{
    TString baseDir;
    const char* env_p = getenv("DBL_CACHE_PATH");
    if (env_p != nullptr) {
        baseDir = env_p;
        if (gSystem->ExpandPathName(baseDir)) {
            LOG(error) << "Cannot expand the DBL_CACHE_PATH value: " << env_p;
            return "";
        }
    } else {
        const char* tmp_p = getenv("TMPDIR");
        baseDir = (tmp_p != nullptr && IsWritableDir(tmp_p)) ? TString(tmp_p) : GetTmpPath();
    }
    // the folder is unique for the process: jobs installing the database at the same time must not overwrite
    // the files of each other, also the jobs on different nodes sharing the same directory, e.g. DBL_CACHE_PATH
    TString dirName = TString::Format("geo_db_%s_%d", gSystem->HostName(), gSystem->GetPid());
    gSystem->PrependPathName(baseDir.Data(), dirName);
 
    if (!exists_file(dirName.Data()) && gSystem->mkdir(dirName, true) != 0) {
        LOG(error) << "ERROR: cannot create the folder for the geometry database: " << dirName;
        return "";
    }
    if (!IsWritableDir(dirName.Data())) {
        LOG(error) << "ERROR: the folder for the geometry database is not writable: " << dirName;
        return "";
    }
 
    return dirName;
}
 
int GeoSetup::installLocalDB(string_view setup_tag, const char* url)
{
    CloseDB();
    TString localDbPath = GetLocalDbPath().c_str();
    if (localDbPath == "") {
        LOG(error)
            << "DBL_FILE_PATH is not set. Please, set DBL_FILE_PATH as a path to the local database file (default, "
               "'local.db')"
            << endl;
        return -1;
    }
    FileStat_t file_stat;
    gSystem->GetPathInfo(localDbPath.Data(), file_stat);
    if (R_ISDIR(file_stat.fMode)) {
        LOG(error)
            << "DBL_FILE_PATH is a path to a folder. Please, set DBL_FILE_PATH as a path to the local database file "
               "(default, 'local.db')"
            << endl;
        return -2;
    }
 
    TString dirName(gSystem->DirName(localDbPath.Data()));
    TString fileName(gSystem->BaseName(localDbPath.Data()));
    // the database is installed to a writable directory instead of the read-only one given by DBL_FILE_PATH
    bool isMovedDb = false;
    if (!exists_file(dirName.Data())) {
        if (gSystem->mkdir(dirName, true) != 0) {
            LOG(error) << "ERROR: cannot create folder: " << dirName << endl;
            return -3;
        }
    } else if (!IsWritableDir(dirName.Data())) {
        // the database directory is read-only (on CVMFS, for example), so the database
        // is installed to a writable directory, which is used by this process from now on
        LOG(info) << "The directory of the Local Geometry Database is read-only: " << dirName
                  << ". The database will be installed to a writable directory";
        TString writableDir = PrepareWritableDbDir();
        if (writableDir.Length() == 0)
            return -3;
        // the folder is removed at the process exit, also if the installation fails below
        if (gWritableDbPid != getpid()) {
            gWritableDbDir = writableDir.Data();
            gWritableDbPid = getpid();
            atexit(RemoveWritableDbDir);
        }
        dirName = writableDir;
        fileName = "local.db";
        localDbPath = dirName + "/" + fileName;
        isMovedDb = true;
    }
    // a unique file name in the temporary folder: several jobs can run in the same working directory
    TString tarName = GetTmpFileName("geo_db.tar");
    TString command;
    if (setup_tag.size() == 0)
        command = TString::Format("wget -O %s \"%s/download_file.php?type=all&tag=all\" > /dev/null 2>&1",
                                  tarName.Data(), url);
    else {
        std::string tag(setup_tag);
        if (!IsSafeTag(tag)) {
            LOG(error) << "ERROR: the setup tag contains forbidden characters: `" << tag << "`";
            return -7;
        }
        command = TString::Format("wget -O %s \"%s/download_file.php?type=s&tag=%s&rev=1\" > /dev/null 2>&1",
                                  tarName.Data(), url, tag.c_str());
    }
    gSystem->Exec(command);
    if (!exists_file(tarName.Data())) {
        LOG(error) << "ERROR: downloading the geometry database file failed, please, check url: " << url << endl;
        return -4;
    }
    gSystem->GetPathInfo(tarName.Data(), file_stat);
    if (file_stat.fSize == 0) {
        LOG(error) << "ERROR: downloaded geometry database file has 0 size, please, check url: " << url << endl;
        gSystem->Unlink(tarName.Data());
        return -5;
    }
    // untar archive with the database file
    int tarResult =
        gSystem->Exec(TString::Format("tar -xf %s -C \"%s/\" > /dev/null 2>&1", tarName.Data(), dirName.Data()));
    // remove temporary archive
    gSystem->Unlink(tarName.Data());
    if (tarResult != 0) {
        LOG(error) << "ERROR: cannot unpack the geometry database archive to the directory: " << dirName << endl;
        return -8;
    }
    if (fileName != "local.db") {
        gSystem->CopyFile(gSystem->ConcatFileName(dirName.Data(), "local.db"),
                          gSystem->ConcatFileName(dirName.Data(), fileName.Data()), kTRUE);
        gSystem->Unlink(gSystem->ConcatFileName(dirName.Data(), "local.db"));
    }
    // the archive is unpacked, but the database file itself can be absent in it
    if (!exists_file(localDbPath.Data())) {
        LOG(error) << "ERROR: no database file found after unpacking the archive: " << localDbPath << endl;
        return -9;
    }
    // the installed database is used by GetLocalDbPath(), GetRootPath() and by the magnetic field map as well;
    // the path is changed only now, so that the read-only database is still used if the installation failed
    TString previousDbPath;
    if (isMovedDb) {
        previousDbPath = ExpandDbFilePath().c_str();
        gSystem->Setenv("DBL_FILE_PATH", localDbPath.Data());
    }
    if (!OpenLocalGeoDatabase()) {
        if (isMovedDb)
            gSystem->Setenv("DBL_FILE_PATH", previousDbPath.Data());
        return -6;
    }
    LOG(info) << "The Local Geometry Database was successfully installed to the directory: " << dirName << endl;
    return 0;
}
 
void GeoSetup::CloseDB()
{
    m_modules_table.clear();
    m_modules_revision_table.clear();
    if (m_db != nullptr) {
        m_db->Close();
        delete m_db;
        m_db = nullptr;
    }
}
 
// GeoSetup destructor
GeoSetup::~GeoSetup()
{
    // CloseDB();
}
 
// create connection to the Local Geometry Database and fill the tables with modules and their revisions
bool GeoSetup::OpenLocalGeoDatabase()
{
    string fPath = GetLocalDbPath();
    // const char* env_p = GetDbPath().c_str();//getenv("DBL_FILE_PATH");
    // LOG(error) <<"OpenLocalGeoDatabase env_p="<<env_p;
    if (fPath.size() == 0) {
        LOG(error) << "Please, set DBL_FILE_PATH environment variable before using the Geometry Database";
        return false;
    }
    if (!exists_file(fPath.c_str())) {
        LOG(error) << "No Database found in " << fPath;
        return false;
    }
    ostringstream stringStream;
    stringStream << "sqlite://" << fPath;
 
    LOG(debug1) << "Connecting the Local Geometry Database at path: " << stringStream.str().c_str();
    // std::cerr<<"Connecting the Local Geometry Database at path: "<<stringStream.str().c_str()<<std::endl;
    m_db = new TSQLiteServer(stringStream.str().c_str());
    if (PutModules() != 0) {
        LOG(error) << "Cannot load detector geometry, please, check DBL_FILE_PATH environment variable";
        return false;
    }
    if (PutModuleRevisions() != 0) {
        LOG(error) << "Cannot load detector geometry, please, check DBL_FILE_PATH environment variable";
        return false;
    }
 
    return true;
}
 
// the shape of an assembly volume is owned by the volume itself, but setups built with FairRoot keep these
// shapes in the list of shapes as well, where they are deleted the second time, when the geometry is deleted
static void RemoveAssemblyShapes(TGeoManager* geoManager)
{
    TObjArray* shapes = geoManager->GetListOfShapes();
    TIter nextVolume(geoManager->GetListOfVolumes());
    int removedCount = 0;
    while (TGeoVolume* volume = (TGeoVolume*)nextVolume())
        if (volume->IsAssembly() && shapes->Remove(volume->GetShape()) != nullptr)
            removedCount++;
 
    // the setup files built with the fixed FairRoot have no assembly shapes in the list
    if (removedCount > 0) {
        shapes->Compress();
        LOG(info) << removedCount << " assembly shapes were removed from the list of shapes of the geometry";
    }
}
 
//-1 problem to load DB. Require to check DBL_FILE_PATH environment variable.
//-2 No geometry setup found for the given tag
//-3 Setup is damaged.
// load selected geometry setup from the Local Geometry Database and create gGeoManager instance
int GeoSetup::LoadSetupToGeoManager(string_view setup_tag)
{
    if (GetLocalDbPath().empty()) {
        LOG(error) << "Please, set DBL_FILE_PATH environment variable before using the Geometry Database";
        return -1;
    }
    bool isOpen = false;
    if (OpenLocalGeoDatabase())
        isOpen = true;
    TSQLResult* resQ = nullptr;
    TSQLRow* row = nullptr;
    ostringstream stringStream;
    string tag = SqlEscape(setup_tag);
    // if (revision == nullptr)
    stringStream << "select setup_id,status,material_id,field_id,file_name,modified_date from setup where "
                    "lower(setup_tag)=lower('"
                 << tag << "') order by creation_date desc;";
    int sStatus = 0;
    uint64_t sUpTime = 0;
    std::pair<int, uint64_t> status;
    // else
    //     stringStream<<"select idsd,status,idma,idfi,rfile from setup where lower(stag)=lower('"<<setupTag<<"') and
    //     TRIM(revision)=TRIM('"<<revision<<"') order by sdate desc;";
    if (isOpen) {
        resQ = m_db->Query(stringStream.str().c_str());
        if (resQ == nullptr) {
            // temporary, for support of old database versions without the modified_date column
            stringStream.str("");
            stringStream << "select setup_id,status,material_id,field_id,file_name, creation_date from setup where "
                            "lower(setup_tag)=lower('"
                         << tag << "') order by creation_date desc;";
            resQ = m_db->Query(stringStream.str().c_str());
            if (resQ == nullptr)
                LOG(error) << "SQL query was failed while searching the given tag: `" << setup_tag
                           << "`. Setup will download from server.";
            else
                row = resQ->Next();
        } else
            row = resQ->Next();
    }
    if (row != nullptr) {
        sStatus = FieldToInt(row->GetField(1));
        sUpTime = FieldToUInt64(row->GetField(5));
    }
    if (sStatus == 0) {
        status = CheckTagOnServer(setup_tag);
    }
    if (row == nullptr || (sStatus == 0 && status.second > sUpTime)) {
        LOG(error) << "No geometry setup found in the local database for `" << setup_tag << "` tag.";
        delete resQ;
        resQ = nullptr;
        if (row != nullptr) {
            delete row;
            row = nullptr;
        }
        if (status.first >= 0) {
            int isUpload = -1;
            if (status.first == 1) {
                LOG(info) << "Approved geometry setup found on the geometry server:`" << GEO_SERVER_HOST
                          << "`. Downloading...";
                isUpload = installLocalDB("");
            } else {
                LOG(info) << "Not approved geometry setup found on the geometry server:`" << GEO_SERVER_HOST
                          << "`. Downloading";
                isUpload = installLocalDB(setup_tag);
            }
            if (isUpload >= 0) {
                // In this case do not set modified time for support old DB
                stringStream.str("");
                stringStream
                    << "select setup_id,status,material_id,field_id,file_name from setup where lower(setup_tag)=lower('"
                    << tag << "') order by creation_date desc;";
                resQ = m_db->Query(stringStream.str().c_str());
                if (resQ == nullptr)
                    LOG(error) << "SQL query was failed while searching the given tag: `" << setup_tag << "`";
                else
                    row = resQ->Next();
            } else {
                LOG(error) << "Cannot download the geometry setup from the server:`" << GEO_SERVER_HOST << "`.";
                return -2;
            }
        } else
            LOG(error) << "No geometry setup found on the geometry server:`" << GEO_SERVER_HOST << "`.";
        if (row == nullptr) {
            LOG(error) << "The geometry setup `" << setup_tag << "` is absent in the Geometry Database";
            delete resQ;
            return -2;
        }
    }
 
    m_sid = FieldToInt(row->GetField(0));
    // int idma = FieldToInt(row->GetField(2));
    m_fid = FieldToInt(row->GetField(3), -1);
    TString geoFileField = row->GetField(4) != nullptr ? row->GetField(4) : "";
    geoFileField = geoFileField.Strip(TString::kBoth);
    delete row;
    delete resQ;
 
    // the setup can be defined only by separate modules (for simulation) without a file with the full geometry
    if (geoFileField.IsNull()) {
        LOG(error) << "The geometry setup `" << setup_tag
                   << "` has no ROOT file with the full geometry in the Geometry Database";
        return -3;
    }
    TString geoFileName = GetRootPath() + geoFileField;
 
    TFile* geoFile = new TFile(geoFileName, "READ");
    if (geoFile->IsZombie() || !geoFile->IsOpen()) {
        LOG(error) << "ERROR: could not open ROOT file with geometry: " + geoFileName;
        delete geoFile;
        return -3;
    }
    TList* keyList = geoFile->GetListOfKeys();
    TIter next(keyList);
    TKey* key = (TKey*)next();
    if (key == nullptr || !TString(key->GetClassName()).BeginsWith("TGeoManager")) {
        LOG(error) << "ERROR: TGeoManager is not top element in geometry file " + geoFileName;
        delete geoFile;
        return -3;
    }
    // the read geometry registers itself as gGeoManager, so the file can be closed (as TGeoManager::Import does)
    key->ReadObj();
    delete geoFile;
    if (gGeoManager != nullptr)
        RemoveAssemblyShapes(gGeoManager);
 
    m_setupTag = string(setup_tag);
    return 0;
}
 
// load selected geometry for simulation application from the Geometry Database.
int GeoSetup::LoadSetupToFairRunSim(string_view setup_tag, const char* localSettings)
{
    if (localSettings != nullptr) {
        // the path can contain environment variables, e.g. "$VMCWORKDIR/my_setup.xml"
        TString localSettingsPath(localSettings);
        gSystem->ExpandPathName(localSettingsPath);
        LoadLocalSettings(localSettingsPath.Data());
    }
 
    // int random_variable;
    /*    if (url != nullptr)
        {
            srand(time(NULL));
            random_variable = rand();
            //cout<<random_variable<<endl;
            ostringstream stringStream;
            //  stringStream<<"wget -O test2.tar \""<<url<<"?type=s&tag="<<setupTag<<"&dirname="<<random_variable<<"\"";
       http://cbmdb.jinr.ru/geometry8/download_file.php?type=all&tag=all stringStream<<"wget -O test2.tar
       \""<<url<<"/download_file.php?type=all&tag=all&dirname="<<random_variable<<"\" >/dev/null ";
            system(stringStream.str().c_str());
 
            stringStream.str("");
            stringStream<<"tar -xf test2.tar >/dev/null";
            system(stringStream.str().c_str());
 
            stringStream.str("");
            stringStream<<"rm test2.tar";
            system(stringStream.str().c_str());
 
            stringStream.str("");
            stringStream<<gSystem->pwd()<<"/"<<random_variable<<"/storage/";
            gSystem->Setenv("DBL_ROOT_PATH", stringStream.str().c_str());
 
            stringStream.str("");
            stringStream<<gSystem->pwd()<<"/"<<random_variable<<"/local.db";
            gSystem->Setenv("DBL_FILE_PATH", stringStream.str().c_str());
        }*/
    /*    const char* env_p = GetDbPath().c_str();//getenv("DBL_FILE_PATH");
        if (env_p == nullptr) {
            LOG(error) << "Please, set DBL_FILE_PATH environment variable before using the Geometry Database";
            return -1;
        }*/
    bool isOpen = false;
    if (OpenLocalGeoDatabase())
        isOpen = true;
    TSQLResult* resQ = nullptr;
    TSQLRow* row = nullptr;
 
    ostringstream stringStream;
    string tag = SqlEscape(setup_tag);
    //    if (revision == nullptr)
    stringStream
        << "select setup_id,status,material_id,field_id,modified_date from setup where lower(setup_tag)=lower('" << tag
        << "') order by creation_date desc;";   // KG если я правильно понял, то нужно брать по-умолчанию,
                                                // самый новый релиз?
    //    else
    //        stringStream<<"select idsd,status,idma,idfi from setup where stag='"<<setupTag<<"' and
    //        TRIM(revision)=TRIM('"<<revision<<"') order by sdate desc;";
    LOG(debug1) << stringStream.str().c_str();
    int sStatus = 0;
    uint64_t sUpTime = 0;
    std::pair<int, uint64_t> status;
    if (isOpen) {
        resQ = m_db->Query(stringStream.str().c_str());
        if (resQ == nullptr) {
            // temprorary for support old versions
            stringStream.str("");
            stringStream
                << "select setup_id,status,material_id,field_id,creation_date from setup where lower(setup_tag)=lower('"
                << tag << "') order by creation_date desc;";
            resQ = m_db->Query(stringStream.str().c_str());
            if (resQ == nullptr)
                LOG(error) << "SQL query was failed while searching the given tag: `" << setup_tag
                           << "`. Setup will download from server.";
            else
                row = resQ->Next();
            // return -2;
        } else
            row = resQ->Next();
    }
    if (row != nullptr) {
        sStatus = FieldToInt(row->GetField(1));
        sUpTime = FieldToUInt64(row->GetField(4));
    }
    if (sStatus == 0) {
        status = CheckTagOnServer(setup_tag);
    }
    if (row == nullptr || (sStatus == 0 && status.second > sUpTime)) {
        LOG(error) << "No geometry setup found in the local database for `" << setup_tag << "` tag." << status.first;
        delete resQ;
        resQ = nullptr;
        if (status.first >= 0) {
            int isUpload = -1;
            if (status.first == 1) {
                LOG(info) << "Approved geometry setup found on the geometry server:`" << GEO_SERVER_HOST
                          << "`. Downloading...";
                isUpload = installLocalDB("");
            } else {
                LOG(info) << "Not approved geometry setup found on the geometry server:`" << GEO_SERVER_HOST
                          << "`. Downloading...";
                isUpload = installLocalDB(setup_tag);
            }
            if (isUpload >= 0) {
                // AE added for support old version
                stringStream.str("");
                stringStream
                    << "select setup_id,status,material_id,field_id,file_name from setup where lower(setup_tag)=lower('"
                    << tag << "') order by creation_date desc;";
 
                resQ = m_db->Query(stringStream.str().c_str());
                if (resQ == nullptr)
                    LOG(error) << "SQL query was failed while searching the given tag: `" << setup_tag << "`";
                else
                    row = resQ->Next();
            } else {
                LOG(error) << "Cannot download the geometry setup from the server:`" << GEO_SERVER_HOST << "`.";
                return -2;
            }
        } else
            LOG(error) << "No geometry setup found on the geometry server:`" << GEO_SERVER_HOST << "`.";
        if (row == nullptr) {
            LOG(error) << "The geometry setup `" << setup_tag << "` is absent in the Geometry Database";
            return -2;
        }
    }
 
    FairRunSim* fRun = FairRunSim::Instance();
    if (fRun == nullptr) {
        fRun = new FairRunSim();
        LOG(info) << "New FairRunSim instance has been created";
    }
 
    m_sid = FieldToInt(row->GetField(0));
    int idma = FieldToInt(row->GetField(2));
    m_fid = FieldToInt(row->GetField(3), -1);
    if (idma > 0) {
        delete row;
        delete resQ;
 
        stringStream.str("");
        stringStream << "select matag,file_name from material where material_id=" << idma << ";";
        resQ = m_db->Query(stringStream.str().c_str());
 
        if (resQ == 0 || resQ->GetRowCount() == 0) {
            LOG(info) << "Materials were not found";
            delete resQ;
        } else {
            row = resQ->Next();
            /*          const char* media_path = row->GetField(1);
 
                        TString Mat = getenv("GEOMPATH");
                        if (Mat.IsNull()) {
                            Mat = ((TString)getenv("VMCWORKDIR")) + "/geometry/";
                            Mat.ReplaceAll("//", "/");
                        } else {
                            Mat.ReplaceAll("//", "/");
                            if (!Mat.EndsWith("/"))
                                Mat += "/";
                        }
 
                        string workP(Mat.Data());
                        LOG(debug1) << "Working geometry directory: " << workP;
 
                        size_t found = workP.find('/');
                        TString in("");
                        if (found != string::npos) {
                            while ((found = workP.find('/', found + 1)) != string::npos) {
                                LOG(debug1) << "found:" << found;
                                in += "../";
                            }
                        }
                        in += GetRootPath() + media_path;
            */
            if (row == nullptr)
                LOG(info) << "Materials were not found";
            else {
                const char* materialFile = row->GetField(1);
                TString in = (materialFile != nullptr ? materialFile : "");
                fRun->SetMaterials(in.Data());
                m_materialFile = in.Data();
 
                delete row;
            }
            delete resQ;
        }
    } else {
        delete row;
        delete resQ;
    }
    LOG(info) << "Load geometry with tag=" << setup_tag << " from database";
    LOG(debug1) << "setup_id = " << m_sid << "; material_id = " << idma << "; filed_id = " << m_fid << endl;
    stringStream.str("");
    stringStream << "select setup_module_id from sms where setup_id=" << m_sid << ";";
    resQ = m_db->Query(stringStream.str().c_str());
    if (resQ == 0 || resQ->GetRowCount() == 0) {
        LOG(error) << "ERROR: no modules found";
        return -3;
    }
    while ((row = resQ->Next()) != nullptr) {
        stringStream.str("");
        const char* idsm = row->GetField(0);
        int idsmI = FieldToInt(idsm);
        LOG(debug1) << "module=" << idsmI << std::endl;
        // if (subSetup < 0 || subSetup == idsmI){ //check subset
        int res = LoadModuleToFairRunSim(idsmI, fRun);
        if (res == -1) {
            LOG(error) << "ERROR: no file for the setup module " << idsmI << " was found";
            return -3;
        }
        delete row;
    }
    delete resQ;
    for (const auto& item : m_moduleAdd) {
        AddModuleToFairRunSim(item, fRun);
        // std::cout << item << " ";
    }
 
    /*   if (url != nullptr)
       {
           stringStream.str("");
           stringStream<<"rm -rf "<<random_variable<<"/local.db";
           system(stringStream.str().c_str());
 
           stringStream.str("");
           stringStream<<"rm -rf "<<random_variable;
           system(stringStream.str().c_str());
 
           cout<<"DBL_ROOT_PATH="<<getRootPath()<<endl; //KG should be DBL_PATH variables restored?
       }*/
    m_setupTag = string(setup_tag);
    return 0;
}
 
// get field map of selected geometry
FairField* GeoSetup::GetMagneticField(double scale)
{
    // return magnetic field if exists
    if (m_field != nullptr)
        return m_field;
 
    if (m_db == nullptr) {
        LOG(error) << "Geometry Database is not loaded";
        return nullptr;
    }
    if (m_fid == -1) {
        LOG(debug1) << "Selected Geometry Database has no magnetic field";
        return nullptr;
    }
 
    // get field map for the current id from the Geometry Database
    ostringstream stringStream;
    stringStream << "select file_name,scale,x,y,z from field where field_id=" << m_fid << ";";
    TSQLResult* resQ = m_db->Query(stringStream.str().c_str());
    if (resQ == nullptr) {
        LOG(error) << "SQL query was failed while searching magnetic field for id: `" << m_fid << "`";
        return nullptr;
    }
    if (resQ->GetRowCount() == 0) {
        LOG(error) << "ERROR: no selected magnetic field in the Geometry Database for id=" << m_fid;
        delete resQ;
        return nullptr;
    }
 
    TSQLRow* row = resQ->Next();
    if (row == nullptr) {
        LOG(error) << "ERROR: no selected magnetic field in the Geometry Database for id=" << m_fid;
        delete resQ;
        return nullptr;
    }
 
    stringStream.str("");
    stringStream << (row->GetField(0) != nullptr ? row->GetField(0) : "");
    double sc = FieldToDouble(row->GetField(1));
    delete row;
    delete resQ;
 
    // to be changed to dynamic magnetic class got by the Geometry Database
    BmnNewFieldMap* pBmnNewFieldMap = new BmnNewFieldMap();
    pBmnNewFieldMap->SetFileName(stringStream.str().c_str());
    // scale the magnetic field: zero scale turns the field off, a negative one means the default scale of the database
    if (scale >= 0)
        pBmnNewFieldMap->SetScale(scale);
    else
        pBmnNewFieldMap->SetScale(sc);
 
    m_field = pBmnNewFieldMap;
    return m_field;
}
 
// get parameter file by given detector name
string GeoSetup::GetParameterFile(string_view name)
{
    if (name == "") {
        LOG(error) << "Detector name for the parameter file is not set";
        return "";
    }
    if (m_db == nullptr) {
        LOG(error) << "The Geometry Database is not connected";
        return "";
    }
 
    TString sname(name);
    int index = GetModuleIndex(sname);
    if (index < 0) {
        LOG(error) << "The detector name \'" << sname << "\'does not exist in the Geometry Database";
        return "";
    }
    LOG(debug1) << "The detector name \'" << sname << "\'exists in the Geometry Database";
 
    ostringstream stringStream;
    stringStream
        << "select sm.fpar from sms s INNER JOIN setup_module sm on s.idsm=sm.idsm INNER JOIN file f on sm.idf=f.idf "
           "INNER JOIN module_revision mr on f.idm=mr.idmr where idsd="
        << m_sid << " and mr.idm=" << index << ";";
    LOG(debug1) << "Request \'" << stringStream.str().c_str() << "\'.";
    TSQLResult* resQ = m_db->Query(stringStream.str().c_str());
    if (resQ == nullptr) {
        LOG(info) << "SQL query was failed while searching parameter file for detector `" << sname << "`";
        return "";
    }
    TSQLRow* row = resQ->Next();
    if (row == nullptr) {
        LOG(info) << "Parameter file for detector `" << sname << "` not found";
        delete resQ;
        return "";
    }
 
    // the field points to the memory owned by the row, so it has to be copied before the row is deleted
    const char* file = row->GetField(0);
    string parameterFile = (file != nullptr ? file : "");
    delete row;
    delete resQ;
 
    if (parameterFile.empty()) {
        LOG(info) << "Parameter file for detector `" << sname << "` does not exist in the Geometry Database";
        return "";
    }
 
    return parameterFile;
}
 
// get the material file of the current setup
string GeoSetup::GetMaterialFile()
{
    // the file name is read by LoadSetupToFairRunSim(), it is requested here only if the setup geometry
    // was loaded by another way, e.g. by LoadSetupToGeoManager()
    if (!m_materialFile.empty())
        return m_materialFile;
 
    if (m_sid == -1) {
        LOG(error) << "The geometry setup is not loaded";
        return "";
    }
    if (m_db == nullptr) {
        LOG(error) << "The Geometry Database is not connected";
        return "";
    }
 
    ostringstream stringStream;
    stringStream << "select m.file_name from setup s INNER JOIN material m on m.material_id=s.material_id where "
                    "s.setup_id="
                 << m_sid << ";";
    TSQLResult* resQ = m_db->Query(stringStream.str().c_str());
    if (resQ == nullptr) {
        LOG(info) << "SQL query was failed while searching the material file of the setup";
        return "";
    }
    TSQLRow* row = resQ->Next();
    if (row == nullptr) {
        LOG(info) << "Material file of the setup was not found in the Geometry Database";
        delete resQ;
        return "";
    }
 
    // the field points to the memory owned by the row, so it has to be copied before the row is deleted
    const char* file = row->GetField(0);
    m_materialFile = (file != nullptr ? file : "");
    delete row;
    delete resQ;
 
    return m_materialFile;
}
 
// expanded value of the DBL_FILE_PATH environment variable; "" if it is not set or cannot be expanded
string GeoSetup::ExpandDbFilePath()
{
    const char* env_p = getenv("DBL_FILE_PATH");
    if (env_p == nullptr) {
        LOG(debug1) << "DBL_FILE_PATH environment variable is not set";
        return "";
    }
    // the TString overload reports an error by the return value and, unlike the char* one,
    // does not allocate a buffer that has to be deleted by the caller
    TString path(env_p);
    if (gSystem->ExpandPathName(path)) {
        LOG(error) << "Cannot expand the DBL_FILE_PATH value: " << env_p;
        return "";
    }
 
    return string(path.Data());
}
 
// get path to the location of the Local Geometry Database
string GeoSetup::GetRootPath()
{
    string rootPath = ExpandDbFilePath();
    if (rootPath.empty())
        return "";
 
    struct stat st;
    if (stat(rootPath.c_str(), &st) == 0)
        if (!S_ISDIR(st.st_mode)) {
            TString dirName(gSystem->DirName(rootPath.c_str()));
            rootPath = dirName.Data();
        }
 
    rootPath += "/storage/";
 
    return rootPath;
}
 
string GeoSetup::GetLocalDbPath()
{
    string rootPath = ExpandDbFilePath();
    if (rootPath.empty())
        return "";
 
    struct stat st;
    if (stat(rootPath.c_str(), &st) == 0)
        if (!S_ISDIR(st.st_mode)) {
            return rootPath;
        }
 
    rootPath += "/local.db";
    return rootPath;
}
 
// get path to a temporary directory (/tmp/$USER/), and create if absent
TString& GeoSetup::GetTmpPath()
{
    if (m_tmpFolder.Length() != 0)
        return m_tmpFolder;
 
    UserGroup_t* user = gSystem->GetUserInfo();
    string login(user->fUser.Data());
    m_tmpFolder = "/tmp/" + login + "/";
    system("mkdir -p " + m_tmpFolder);
 
    return m_tmpFolder;
}
 
// load local settings from the file for all setup modules
bool GeoSetup::LoadLocalSettings(const char* fileName)
{
    LOG(info) << "Load local settings of geometry DB from '" << fileName << "'";
    TXMLEngine* xml = new TXMLEngine;
    XMLDocPointer_t xmldoc = xml->ParseFile(fileName);
    if (xmldoc == 0) {
        LOG(error) << "Selected file has not XML format: " << fileName;
        delete xml;
        return false;
    }
 
    m_moduleEdit.clear();
 
    XMLNodePointer_t mainnode = xml->DocGetRootElement(xmldoc);
    XMLNodePointer_t child = xml->GetChild(mainnode);
    while (child != 0) {
        TString chName = xml->GetNodeName(child);
        if (chName.CompareTo("editSetupModule") == 0) {
            setup_module_ptr sNode = new setup_module();
            sNode->xMove = 0;
            sNode->yMove = 0;
            sNode->zMove = 0;
            sNode->enable = true;
            sNode->type = TString("");
 
            XMLAttrPointer_t attr = xml->GetFirstAttr(child);
            while (attr != 0) {
                TString aName = xml->GetAttrName(attr);
                TString aValue = xml->GetAttrValue(attr);
                if (aName.CompareTo("tag") == 0) {
                    aValue.ToUpper();
                    sNode->type = aValue;
                } else if (aName.CompareTo("moveX") == 0) {
                    sNode->xMove = aValue.Atof();
                } else if (aName.CompareTo("moveY") == 0) {
                    sNode->yMove = aValue.Atof();
                } else if (aName.CompareTo("moveZ") == 0) {
                    sNode->zMove = aValue.Atof();
                } else if (aName.CompareTo("file_path") == 0) {
                    gSystem->ExpandPathName(aValue);
                    sNode->file_path = aValue;
                } else if ((aName.CompareTo("enable") == 0)
                           && (aValue.CompareTo("false") == 0 || aValue.CompareTo("False") == 0
                               || aValue.CompareTo("FALSE") == 0))
                    sNode->enable = false;
 
                LOG(debug1) << "attr: " << xml->GetAttrName(attr) << " value: " << xml->GetAttrValue(attr);
 
                attr = xml->GetNextAttr(attr);
            }
 
            // int ii = GetModuleIndex(sNode->type);
            // if(!sNode->enable)
            //  LOG(info)<<"Disable module with tag="<<sNode->type;//<<" and ModuleId="<<ii;
            m_moduleEdit.insert(pair<TString, setup_module_ptr>(sNode->type, sNode));
        } else if (chName.CompareTo("addSetupModule") == 0) {
            module_r_ptr module = new module_r();
            XMLAttrPointer_t attr = xml->GetFirstAttr(child);
            while (attr != 0) {
                TString aName = xml->GetAttrName(attr);
                TString aValue = xml->GetAttrValue(attr);
                if (aName.CompareTo("class_name") == 0)
                    module->class_name = aValue;
                else if (aName.CompareTo("file_path") == 0) {
                    gSystem->ExpandPathName(aValue);
                    module->file_path = aValue;
                } else if (aName.CompareTo("args") == 0)
                    module->args = aValue;
                if ((aName.CompareTo("active") == 0)
                    && (aValue.CompareTo("false") == 0 || aValue.CompareTo("False") == 0
                        || aValue.CompareTo("FALSE") == 0))
                    module->active = false;
                attr = xml->GetNextAttr(attr);
            }
            m_moduleAdd.push_back(module);
        }
        child = xml->GetNext(child);
    }
 
    xml->FreeDoc(xmldoc);
    delete xml;
    return true;
}
 
// get module name by index; return "Unknown" if not found
TString GeoSetup::GetModuleName(int dbModuleUndex)
{
    map<int, TString>::iterator it = m_modules_table.find(dbModuleUndex);
    if (it != m_modules_table.end())
        return it->second;
    else {
        LOG(error) << "Unknown module type with id=" << dbModuleUndex;
        return TString("Unknown");
    }
}
 
// get module index by name; return -1 if not found
int GeoSetup::GetModuleIndex(TString& name)
{
    map<int, TString>::iterator it;
    for (it = m_modules_table.begin(); it != m_modules_table.end(); ++it)
        if ((it->second).CompareTo(name, TString::ECaseCompare::kIgnoreCase) == 0)
            return it->first;
 
    return -1;
}
 
// get module_r_ptr (pointer to the module revision) by revision number
module_r_ptr GeoSetup::GetModuleRevision(int dbModuleRev)
{
    map<int, module_r_ptr>::iterator it = m_modules_revision_table.find(dbModuleRev);
    if (it != m_modules_revision_table.end())
        return it->second;   //.class_name;
 
    module_r_ptr mr = nullptr;
    return mr;
}
 
// get module ID by revision number; return -1 if not found
int GeoSetup::GetModuleId(int dbModuleRev)
{
    map<int, module_r_ptr>::iterator it = m_modules_revision_table.find(dbModuleRev);
    if (it != m_modules_revision_table.end())
        return it->second->idm;
 
    return -1;
}
 
// get module type by revision number
TString GeoSetup::GetModuleType(int dbModuleRev)
{
    return GetModuleName(GetModuleId(dbModuleRev));
}
 
// get root volume in the TFile object (first search for TGeoManager)
TGeoVolume* GeoSetup::GetRootVolume(TFile* f)
{
    TKey* key;
    TGeoManager* geoManager = nullptr;
    TList* l = f->GetListOfKeys();
    TIter next(l);
    while ((key = (TKey*)next())) {
        if (strcmp(key->GetClassName(), "TGeoManager") != 0)
            continue;
        geoManager = (TGeoManager*)key->ReadObj();
        geoManager->cd();
        TGeoNode* top = geoManager->GetNode(0);
        if (top == nullptr || top->GetNdaughters() == 0) {
            LOG(error) << "ERROR: geometry in the file " << f->GetName() << " has no daughter volume";
            return nullptr;
        }
        return (TGeoVolume*)top->GetDaughter(0)->GetVolume();
    }
 
    // if TGeoManager was not found in the file
    key = (TKey*)l->At(0);   // Get the first key in the list
    if (key == nullptr) {
        LOG(error) << "ERROR: no keys found in the geometry file " << f->GetName();
        return nullptr;
    }
    TGeoVolume* volume = dynamic_cast<TGeoVolume*>(key->ReadObj());
 
    return volume;
}
 
// add FairModule defined by revision number and geometry file path to the FairRunSim instance
bool GeoSetup::AddModuleToFairRunSim(int dbModuleRev, const char* path, FairRunSim* fRun)
{
    module_r_ptr mr = GetModuleRevision(dbModuleRev);
    if (mr == nullptr) {
        LOG(error) << "ERROR: no module revision with id=" << dbModuleRev << " in the Geometry Database";
        return false;
    }
 
    // TClass* cl = TClass::GetClass(mr->class_name);
    // FairModule* f_cl = (FairModule*) cl->New();
    // cout<<"TClass:"<<cl<<endl; f_cl->Dump();
 
    TString type_name;
    if (mr->args.Length() > 0) {
        type_name = mr->args;
        // f_cl->SetName(mr.args);
    } else {
        type_name = GetModuleType(dbModuleRev);
        // f_cl->SetName(getModuleType(dbModuleRev));
    }
 
    TString command = "new " + mr->class_name + "(\"" + type_name + "\"";
    if (mr->active)
        command += ",kTRUE)";
    else
        command += ")";
    LOG(debug1) << "command:" << command;
 
    FairModule* obj = (FairModule*)gInterpreter->Calc(command);
    if (obj == nullptr) {
        LOG(error) << "ERROR: cannot create the detector module by the command: " << command;
        return false;
    }
    obj->SetGeometryFileName(path);
    fRun->AddModule(obj);
 
    // cerr<<"dbModuleRev="<<dbModuleRev<<" idmr="<<mr.idmr<<" idm="<<mr.idm<<" class_name="<<typeid(f_cl).name()<<endl;
    return true;
}
bool GeoSetup::AddModuleToFairRunSim(module_r_ptr module, FairRunSim* fRun)
{
    if (module == nullptr)
        return false;
    TString command = "new " + module->class_name + "(\"" + module->args + "\"";
    if (module->active)
        command += ",kTRUE)";
    else
        command += ")";
    FairModule* obj = (FairModule*)gInterpreter->Calc(command);
    if (obj == nullptr) {
        LOG(error) << "ERROR: cannot create the detector module by the command: " << command;
        return false;
    }
    obj->SetGeometryFileName(module->file_path);
    fRun->AddModule(obj);
    LOG(info) << "\033[0;32mAdded external detector: file_path=" << module->file_path
              << " class_name=" << module->class_name << " isActive=" << module->active << "\033[0m";
    return true;
}
 
TGeoNode* GeoSetup::ConstructRootGeometry(const char* fileName)
{
    TGeoManager* NewGeo = 0;
    TGeoVolume* volume = 0;
    ;
    TFile* f = new TFile(fileName);
    if (f->IsZombie() || !f->IsOpen()) {
        LOG(error) << "ERROR: could not open ROOT file with geometry: " << fileName;
        delete f;
        return NULL;
    }
    TList* l = f->GetListOfKeys();
    TKey* key;
    TIter next(l);
    TGeoNode* n = 0;
    // TGeoVolume* v1=0;
    while ((key = (TKey*)next())) {
        if (strcmp(key->GetClassName(), "TGeoManager") != 0) {
            continue;
        }
        NewGeo = (TGeoManager*)key->ReadObj();
        break;
    }
    if (NewGeo != 0) {
        NewGeo->cd();
        n = NewGeo->GetNode(0);
        f->Close();
        delete f;
        return n;
    } else {
        key = (TKey*)l->At(0);   // Get the first key in the list
        if (key == nullptr) {
            LOG(error) << "ERROR: no keys found in the geometry file " << fileName;
            f->Close();
            delete f;
            return NULL;
        }
        volume = dynamic_cast<TGeoVolume*>(key->ReadObj());
        if (volume != 0) {
            f->Close();
            delete f;
            return volume->GetNode(0);
        }
        f->Close();
        delete f;
        return NULL;
    }
}
 
bool GeoSetup::IsEqlMatrix(const char* fileName, TSQLRow* row)
{
    if (row == NULL || fileName == NULL)
        return false;
    bool res = true;
    try {
        // cerr<<"Start compare fileName:"<<fileName<<endl;
        TGeoNode* node = ConstructRootGeometry(fileName);
        if (node == NULL)
            return false;
        const Double_t* tran = node->GetMatrix()->GetTranslation();   // 3
        // const Double_t * sc = node->GetMatrix()->GetScale();//3
        const Double_t* rot = node->GetMatrix()->GetRotationMatrix();   // 9
        unsigned int i;
        for (i = 0; i < 3; i++) {
            double t = FieldToDouble(row->GetField(3 + i));
            if (tran[i] != t) {
                LOG(debug1) << " for i=" << i << " tran[i]=" << tran[i] << " t=" << t << endl;
                res = false;
            }
        }
        for (i = 0; i < 9; i++) {
            double t = FieldToDouble(row->GetField(6 + i));
            if (rot[i] != t) {
                LOG(debug1) << " for i=" << i << " rot[i]=" << rot[i] << " t=" << t << endl;
                res = false;
            }
        }
    } catch (...) {
        return false;
    }
    return res;
}
// load one module from the Geometry Database and add to the FairRunSim instance
int GeoSetup::LoadModuleToFairRunSim(int idsm, FairRunSim* fRun)
{
    map<int, TString>::iterator it = m_loadedModule.find(idsm);
    if (it != m_loadedModule.end())
        return 0;
    // mark the module as being loaded to break possible parent_id loops in the database
    m_loadedModule.insert(pair<int, TString>(idsm, ""));
 
    LOG(debug1) << "Start load setup_module_id=" << idsm;
    ostringstream stringStream;
    stringStream << "select "
                    "f.module_id,f.file_name,sm.parent_id,sm.tx,sm.ty,sm.tz,r11,r12,r13,r21,r22,r23,r31,r32,r33,sm."
                    "setup_module_tag "
                    "from setup_module sm INNER JOIN geometry_file f ON f.file_id=sm.file_id where sm.setup_module_id="
                 << idsm << ";";
 
    TSQLResult* resQ = m_db->Query(stringStream.str().c_str());
    if (resQ == 0 || resQ->GetRowCount() == 0) {
        LOG(error) << "ERROR: no file for the setup module (" << idsm << ") was found";
        delete resQ;
        return -1;
    }
 
    TSQLRow* row = resQ->Next();
    if (row == nullptr) {
        LOG(error) << "ERROR: no file for the setup module (" << idsm << ") was found";
        delete resQ;
        return -1;
    }
    int dbModuleIndex = FieldToInt(row->GetField(0));
    int idP = FieldToInt(row->GetField(2), -1);
    LOG(debug1) << "idP=" << idP;
    if (idP != -1) {
        int res = LoadModuleToFairRunSim(idP, fRun);
        if (res < 0) {
            delete row;
            delete resQ;
            return res;
        }
    }
 
    stringStream.str("");
    LOG(debug1) << row->GetField(1);
    stringStream << GetRootPath().c_str() << (row->GetField(1) != nullptr ? row->GetField(1) : "");
 
    TString mName = GetModuleType(dbModuleIndex), out = "";
    mName.ToUpper();
    bool isEnable = true;
    TString smTag = row->GetField(15);
    TString file_path = stringStream.str().c_str();
    smTag.ToUpper();
 
    if (mName == TString("CAVE") || ((TString)stringStream.str()).EndsWith(".geo")) {
        map<TString, setup_module_ptr>::iterator itr = m_moduleEdit.find(smTag);
        if (itr != m_moduleEdit.end()) {
            LOG(debug1) << "detector was found";
            isEnable = itr->second->enable;
        }
        if (isEnable) {
            // a second cave replaces the top volume, so all the detectors are left outside the setup geometry
            bool isDuplicateCave = false;
            if (mName == TString("CAVE")) {
                TIter nextModule(fRun->GetListOfModules());
                while (TObject* module = nextModule())
                    if (module->InheritsFrom("FairCave")) {
                        isDuplicateCave = true;
                        break;
                    }
            }
            if (isDuplicateCave)
                LOG(warning) << "The cave has been already added, so the duplicate cave module with tag=" << smTag
                             << " is skipped. Please, remove it from the setup in the Geometry Database";
            else {
                LOG(info) << "Loading module with tag=" << smTag;
                AddModuleToFairRunSim(dbModuleIndex, stringStream.str().c_str(), fRun);
            }
        } else
            LOG(info) << "\033[0;31mDisable module with tag=" << smTag << " use local settings.\033[0m";
    } else {
        double mx = 0, my = 0, mz = 0;
        map<TString, setup_module_ptr>::iterator itr = m_moduleEdit.find(smTag);
        LOG(debug1) << "detector " << dbModuleIndex;
        if (itr != m_moduleEdit.end()) {
            LOG(debug1) << "detector was found";
            isEnable = itr->second->enable;
            if (isEnable) {
                mx = itr->second->xMove;
                my = itr->second->yMove;
                mz = itr->second->zMove;
                if (itr->second->file_path.Length() > 0)
                    file_path = itr->second->file_path;
                LOG(debug1) << "Move detector " << dbModuleIndex << " to x:" << mx << " to y:" << my << " to z:" << mz;
            }
        }
        if (isEnable && mx == 0 && my == 0 && mz == 0 && IsEqlMatrix(stringStream.str().c_str(), row)) {
            LOG(debug1) << "The same matrix for file=" << stringStream.str().c_str() << endl;
            LOG(info) << "Loading module with tag=" << smTag;
            AddModuleToFairRunSim(dbModuleIndex, file_path, fRun);
        } else if (isEnable) {
            TGeoManager* geom = new TGeoManager(mName, TString::Format("Geometry of the %s module", mName.Data()));
            LOG(debug1) << "import file" << file_path << endl;
            TFile* f = new TFile(file_path);
            if (f->IsZombie() || !f->IsOpen()) {
                LOG(error) << "ERROR: could not open ROOT file with the module geometry: " << file_path;
                delete f;
                delete geom;
                delete row;
                delete resQ;
                return -1;
            }
            TGeoVolume* root_volume = GetRootVolume(f);
            if (root_volume == nullptr || root_volume->GetNode(0) == nullptr) {
                LOG(error) << "ERROR: no geometry volume found in the file: " << file_path;
                f->Close();
                delete f;
                delete geom;
                delete row;
                delete resQ;
                return -1;
            }
            double tx = FieldToDouble(row->GetField(3)) + mx;
            double ty = FieldToDouble(row->GetField(4)) + my;
            double tz = FieldToDouble(row->GetField(5)) + mz;
            TGeoRotation rotM;
            TGeoGenTrans* newMatrix = new TGeoGenTrans(tx, ty, tz, 1, 1, 1, &rotM);
            if (strcmp(root_volume->GetNode(0)->ClassName(), "TGeoNodeMatrix") == 0) {
                TGeoNodeMatrix* v = (TGeoNodeMatrix*)root_volume->GetNode(0);
                v->SetMatrix(newMatrix);
            }
 
            out = GetTmpPath() + GetModuleName(GetModuleId(dbModuleIndex)) + ".root";
            root_volume->Export(out.Data());
            LOG(info) << "Loading module with tag=" << smTag;
            AddModuleToFairRunSim(dbModuleIndex, out.Data(), fRun);
            LOG(debug1) << "Exporting geometry to ROOT file: " << out;
 
            delete geom;
            f->Close();
            delete f;
        } else
            LOG(info) << "\033[0;31mDisable module with tag=" << smTag << " use local settings.\033[0m";
    }
    m_loadedModule[idsm] = out;
 
    delete row;
    delete resQ;
    return 0;
}
 
// fill table with modules (m_modules_table) from the Geometry Database
int GeoSetup::PutModules()
{
    TSQLResult* resQ = m_db->Query("select module_id,module_name from module;");
    if (resQ == nullptr) {
        LOG(error) << "ERROR: SQL query was failed. Please, check connection to the Geometry Database and "
                      "DBL_FILE_PATH variable is correct";
        return -1;
    }
    if (resQ->GetRowCount() == 0) {
        LOG(error) << "ERROR: no modules in the Geometry Database";
        delete resQ;
        return -2;
    }
 
    TSQLRow* row;
    while ((row = resQ->Next()) != 0) {
        int id = FieldToInt(row->GetField(0));
        TString name(row->GetField(1));
        m_modules_table.insert(make_pair(id, name));
        delete row;
    }
 
    delete resQ;
    return 0;
}
 
// fill table with module revisions (m_modules_revision_table) from the Geometry Database
int GeoSetup::PutModuleRevisions()
{
    TSQLResult* resQ = m_db->Query("select module_class_id,mc.module_id,class_name,revision,active,object_name from "
                                   "module_class as mc INNER JOIN module as m ON  mc.module_id=m.module_id;");
    if (resQ == nullptr) {
        LOG(error) << "ERROR: SQL query was failed. Please, check connection to the Geometry Database and "
                      "DBL_FILE_PATH variable is correct";
        return -1;
    }
    if (resQ->GetRowCount() == 0) {
        LOG(error) << "ERROR: no module revisions in the geometry database";
        delete resQ;
        return -2;
    }
 
    TSQLRow* row;
    while ((row = resQ->Next()) != 0) {
        module_r_ptr mr = new module_r();
        mr->idmr = FieldToInt(row->GetField(0));
        mr->idm = FieldToInt(row->GetField(1));
        mr->class_name = row->GetField(2);
        mr->rev = FieldToInt(row->GetField(3));
        if (FieldToInt(row->GetField(4)) == 0)
            mr->active = false;
        else
            mr->active = true;
        mr->args = row->GetField(5);
 
        m_modules_revision_table.insert(make_pair(mr->idmr, mr));
        delete row;
    }
 
    delete resQ;
    return 0;
}