CbmSetup.h

Go to the documentation of this file.

/* Copyright (C) 2013-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese, Florian Uhlig [committer] */
 
#ifndef CBMSETUP_H
#define CBMSETUP_H 1
 
 
#include "CbmDefs.h"
#include "CbmGeoSetupDbProvider.h"
#include "CbmGeoSetupProvider.h"
#include "CbmGeoSetupRepoProvider.h"
#include "CbmModuleList.h"
 
#include <Logger.h>
 
#include "TNamed.h"
#include "TString.h"
#include "TVector3.h"
 
#include <map>
 
class FairModule;
class FairRunSim;
class CbmFieldMap;
class CbmSetupStorable;
 
enum ECbmSetupSource
{
  kRepo,
  kDb
};
 
// TODO: This class is a singleton, so it can be used when including
// a ROOT macro from another one. Since this is the only reason,
// the singleton nature shall be removed once not needed any longer.
 
class CbmSetup : public TNamed {
public:
  ~CbmSetup() {};
 
 
  virtual void Clear(Option_t* opt = "");
 
  void LoadStoredSetup(CbmSetupStorable* setupIn);
 
  void LoadSetup(const char* setupName) { fProvider->LoadSetup(setupName); }
 
  void RegisterSetup() { fProvider->RegisterSetup(); }
 
  std::string GetMediaFilePath() { return fProvider->GetSetup().GetMedia().GetFilePath(); }
 
  void SetMediaFilePath(std::string filePath) { fProvider->GetSetup().GetMedia().SetFilePath(filePath); }
 
  CbmFieldMap* CreateFieldMap();
 
 
  Bool_t GetGeoTag(ECbmModuleId moduleId, TString& tag);
 
 
  Bool_t GetGeoFileName(ECbmModuleId moduleId, TString& fileName);
 
 
  size_t GetHash();
 
 
  Int_t GetNofModules() const { return fProvider->GetSetup().GetModuleMap().size(); }
 
 
  static CbmSetup* Instance();
 
 
  Bool_t IsActive(ECbmModuleId moduleId);
 
 
  Bool_t IsEmpty() const { return (GetNofModules() == 0); }
 
 
  virtual void Print(Option_t* /*opt*/ = "") const { LOG(info) << ToString(); }
 
 
  void RemoveModule(ECbmModuleId moduleId);
 
 
  void SetActive(ECbmModuleId moduleId, Bool_t active = kTRUE);
 
 
  void SetField(const char* tag, Double_t scale = 1., Double_t xPos = 0., Double_t yPos = 0., Double_t zPos = 0.);
 
 
  void SetFieldScale(Double_t scale) { fProvider->GetSetup().GetField().SetScale(scale); }
 
 
  void SetModule(ECbmModuleId moduleId, const char* geoTag, Bool_t active = kTRUE);
 
 
  std::string ToString() const;
 
 
  void SetSetupSource(ECbmSetupSource setupSource);
 
 
  CbmGeoSetupProvider* GetProvider() { return fProvider; };
 
 
  void SetProvider(CbmGeoSetupProvider* value)
  {
    delete fProvider;
    fProvider = value;
  };
 
private:
  static CbmSetup* fgInstance;  
 
  CbmGeoSetupProvider* fProvider {new CbmGeoSetupRepoProvider()};  
 
 
  CbmSetup() : TNamed("CBM Setup", "") {};
 
  CbmSetup(const CbmSetup&);
  CbmSetup operator=(const CbmSetup&);
 
 
  ClassDef(CbmSetup, 3);
};
 
 
class CbmSetupStorable : public TNamed {
public:
  CbmSetupStorable() : TNamed("CBM Setup", "") {};
 
  ~CbmSetupStorable() {};
 
  CbmSetupStorable(const CbmSetupStorable& rhs) : TNamed(rhs)
  {
    if (nullptr != rhs.fProviderRepo) {
      fProviderRepo = new CbmGeoSetupRepoProvider(*(rhs.fProviderRepo));
    }
    else if (nullptr != fProviderDb) {
      fProviderDb = new CbmGeoSetupDbProvider(*(rhs.fProviderDb));
    }
  }
 
  CbmSetupStorable(CbmSetup* rawSetup)
  {
    CbmGeoSetupProvider* ptrGenProv      = rawSetup->GetProvider();
    CbmGeoSetupRepoProvider* ptrRepoProv = dynamic_cast<CbmGeoSetupRepoProvider*>(ptrGenProv);
    if (nullptr == ptrRepoProv) {
      CbmGeoSetupDbProvider* ptrDbProv = dynamic_cast<CbmGeoSetupDbProvider*>(ptrGenProv);
      if (nullptr != ptrDbProv) {
        fProviderDb = new CbmGeoSetupDbProvider(*ptrDbProv);
      }
    }
    else {
      fProviderRepo = new CbmGeoSetupRepoProvider(*ptrRepoProv);
    }
  }
 
  CbmGeoSetupRepoProvider* GetRepoProvPtr() { return fProviderRepo; }
  CbmGeoSetupDbProvider* GetDbProvPtr() { return fProviderDb; }
 
private:
  CbmGeoSetupRepoProvider* fProviderRepo = nullptr;
  CbmGeoSetupDbProvider* fProviderDb     = nullptr;
 
  ClassDef(CbmSetupStorable, 1);
};
#endif /* CBMSETUP_H */