GeoSetup.h

Go to the documentation of this file.

#ifndef _GEO_SETUP_INCLUDED
#define _GEO_SETUP_INCLUDED
 
#include "BmnFieldMap.h"
#include "FairRunSim.h"
#include "TFile.h"
#include "TGeoVolume.h"
#include "TSQLRow.h"
#include "TSQLServer.h"
#include "TString.h"
#include "geo_db_settings.h"
 
#include <map>
#include <string>
#include <utility>
 
using namespace std;
 
typedef struct SETUPMODULE
{
    TString type;
    double xMove, yMove, zMove;
    bool enable;
    TString file_path = "";
} setup_module, *setup_module_ptr;
 
typedef struct MODULEREVISION
{
    TString class_name{""};
    int idmr{-1}, idm{-1}, rev{-1};
    bool active{true};
    TString args{""};
    TString file_path = "";
} module_r, *module_r_ptr;
 
/**
 *  GeoSetup class. It is used for loading necessary setup geometries from the Geometry Database.
 */
class GeoSetup
{
  public:
    // default constructor
    GeoSetup()
        : m_db(nullptr)
        , m_field(nullptr)
        , m_fid(-1)
        , m_sid(-1)
        , m_tmpFolder("")
    {}
 
    /**
     * Destructor method
     */
    ~GeoSetup();
 
    /**
     * Load selected geometry setup from the Local Geometry Database and create gGeoManager instance.
     * Use for Reconstruction and Analysis
     * @param setup_tag the name of the setup tag.
     * @return  0, if the setup is loaded. Error code, if the setup is not loaded.
     */
    int LoadSetupToGeoManager(string_view setup_tag);
 
    /**
     * Load selected geometry setup from the Local or Central (defined by url) Geometry Database and add it to the
     * FairRunSim instance. Use for Simulation
     * @param setupTag the name of the setup tag.
     * @param localSettings path to local setting file that can disable or move some detector in selected geometry.
     * @return  0, if the setup is loaded. Error code, if the setup is not loaded.
     */
    int LoadSetupToFairRunSim(string_view setupTag, const char* localSettings = nullptr);
 
    /**
     * Get magnetic field of the current setup geometry.
     * @param scale the scale of the field. Default value is -1 (any negative value), which means that the default scale
     * of the field from the Geometry Database is used. Zero value turns the magnetic field off.
     * @return  Instance of the magnetic field class inherited from FairField. nullptr if no field
     */
    FairField* GetMagneticField(double scale = -1);
 
    /**
     * Get path to parameter file for the given detector name of the current setup.
     * @param detector_name the name of the detector, for which the parameter file is needed.
     * @return  Path to parameter file. "" if file did not set.
     */
    string GetParameterFile(string_view detector_name);
 
    /**
     * Get the material file of the current setup, which defines the media of the setup geometry.
     * @return  Name of the material file in the Geometry Database. "" if the setup is not loaded or has no materials.
     */
    string GetMaterialFile();
 
    /**
     * Get tag for the last approved setup corresponding to the pattern.
     * @param tag_prefix The prefix string to match against approved setup tags.
     * @return  Tag of last approved setup corresponding to the prefix string.
     */
    string GetLastApprovedSetupTag(string_view tag_prefix);
    /**
     * Get tag for the loaded setup.
     * @return  The Tag of loaded setup.
     */
    string_view GetSetupTag() { return m_setupTag; }
 
  private:
    map<int, TString> m_modules_table;
    map<int, module_r_ptr> m_modules_revision_table;
    map<int, TString> m_loadedModule;
    map<TString, setup_module_ptr> m_moduleEdit;
    vector<module_r_ptr> m_moduleAdd;
 
    // connection to the Geometry Database
    TSQLServer* m_db;
    // magnetic field of the geometry setup
    FairField* m_field;
    // id of the current magnetic field
    int m_fid;
    // id of the current geometry setup
    int m_sid;
    // current tmp directory (/tmp/$USER/)
    TString m_tmpFolder;
    // tag name of setup
    string m_setupTag = "";
    // name of the material file of the setup in the Geometry Database
    string m_materialFile = "";
 
    unsigned long int GetServerRevision(const char* url = GEO_SERVER_HOST);
    std::pair<int, string> GetTagName4PatternServer(string_view pattern_tag, const char* url = GEO_SERVER_HOST);
    std::pair<int, uint64_t> CheckTagOnServer(string_view setup_tag, const char* url = GEO_SERVER_HOST);
    unsigned long int GetLocalRevision(TString& localDbPath);
    std::pair<int, string> GetTagName4PatternLocal(string_view pattern_tag, TString& localDbPath);
    int installLocalDB(string_view setup_tag, const char* url = GEO_SERVER_HOST);
    void CloseDB();
    bool AddModuleToFairRunSim(module_r_ptr module, FairRunSim* fRun);
 
    // create connection to the Local Geometry Database and fill the tables with modules and their revisions
    bool OpenLocalGeoDatabase();
    bool IsEqlMatrix(const char* fileName, TSQLRow* row);
    TGeoNode* ConstructRootGeometry(const char* fileName);
    static bool exists_file(const char* name);
    // check that the directory can be modified, e.g. it is not a part of a read-only file system
    static bool IsWritableDir(const char* path);
    // get a writable directory (a unique folder in $DBL_CACHE_PATH, $TMPDIR, /tmp/$USER) to install
    // the Local Geometry Database to, when the directory of the database is read-only
    TString PrepareWritableDbDir();
    // get path to the location of the Local Geometry Database
    string GetRootPath();
    string GetLocalDbPath();
    // get expanded value of the DBL_FILE_PATH environment variable; "" if not set or cannot be expanded
    string ExpandDbFilePath();
    // get path to a temporary directory (/tmp/$USER/), and create if absent
    TString& GetTmpPath();
    // get unique name of a temporary file in the temporary directory
    TString GetTmpFileName(const char* baseName);
    // get root volume in the TFile object
    TGeoVolume* GetRootVolume(TFile* f);
 
    // get module name by index; return "Unknown" if not found
    TString GetModuleName(int dbModuleUndex);
    // get module index by name; return -1 if not found
    int GetModuleIndex(TString& name);
    // get module ID by revision number; return -1 if not found
    int GetModuleId(int dbModuleRev);
    // get module type by revision number
    TString GetModuleType(int dbModuleRev);
    // get module_r_ptr (pointer to the module revision) by revision number
    module_r_ptr GetModuleRevision(int dbModuleRev);
 
    // load local settings from the file for all setup modules
    bool LoadLocalSettings(const char* fileName);
 
    // load module from the Geometry Database and add to the FairRunSim instance
    int LoadModuleToFairRunSim(int idsm, FairRunSim* fRun);
    // add FairModule defined by revision number and geometry file path to the FairRunSim instance
    bool AddModuleToFairRunSim(int dbModuleRev, const char* path, FairRunSim* fRun);
 
    // fill map with modules from the Geometry Database
    int PutModules();
    // fill map with module revisions from the Geometry Database
    int PutModuleRevisions();
};
 
#endif