CbmSetup.cxx

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] */
 
#
#include "CbmSetup.h"
 
#include "CbmAddress.h"
#include "CbmFieldMap.h"
#include "CbmFieldMapData.h"
#include "CbmFieldMapSym2.h"
#include "CbmFieldMapSym3.h"
#include "FairModule.h"
#include "FairRunSim.h"
#include "TFile.h"
#include "TGeoMatrix.h"
#include "TGeoNode.h"
#include "TGeoVolume.h"
#include "TKey.h"
#include "TSystem.h"
 
#include <Logger.h>
 
#include <iomanip>
#include <sstream>
#include <string>  // for std::hash<string_view>
 
using std::string;
using std::stringstream;
 
// -----   Initialise static instance   ------------------------------------
CbmSetup* CbmSetup::fgInstance = NULL;
// -------------------------------------------------------------------------
 
 
// -----   Clear the setup   -----------------------------------------------
void CbmSetup::Clear(Option_t*) { fProvider->Reset(); }
// -------------------------------------------------------------------------
 
// -----   Load a stored/exchanged copy of the setup   ---------------------
void CbmSetup::LoadStoredSetup(CbmSetupStorable* setupIn)
{
  CbmGeoSetupRepoProvider* ptrRepoProv = setupIn->GetRepoProvPtr();
  if (nullptr == ptrRepoProv) {
    CbmGeoSetupDbProvider* ptrDbProv = setupIn->GetDbProvPtr();
    if (nullptr == ptrDbProv) {
      LOG(error) << "Could not  leod event as storable even does not contain any provider";
    }
    else {
      SetProvider(ptrDbProv);
    }
  }
  else {
    SetProvider(ptrRepoProv);
  }
}
// -------------------------------------------------------------------------
 
// -----   Get field map type   --------------------------------------------
CbmFieldMap* CbmSetup::CreateFieldMap()
{
  CbmGeoSetupField field = fProvider->GetSetup().GetField();
 
  // --- Open the map file
  TString fileName = field.GetFilePath();
  fileName         = TString(gSystem->Getenv("VMCWORKDIR")) + "/" + fileName;
 
  TFile mapFile(fileName);
  if (!mapFile.IsOpen()) {
    LOG(error) << "Could not open field map file " << fileName;
    return NULL;
  }
 
  // ---   Get map file type
  TString mapName = "field_";
  mapName += field.GetTag().c_str();
  CbmFieldMapData* data = NULL;
  mapFile.GetObject(mapName, data);
  if (!data) {
    LOG(error) << "Could not find CbmFieldMapData object " << mapName << " in file " << fileName;
    return NULL;
  }
  Int_t fieldType = data->GetType();
 
  // --- Instantiate field
  CbmFieldMap* fieldMap = NULL;
  switch (fieldType) {
    case 2: fieldMap = new CbmFieldMapSym2(mapName); break;
    case 3: fieldMap = new CbmFieldMapSym3(mapName); break;
    default: LOG(error) << "Unknown field type " << fieldType;
  }
 
  // --- Set scale and position of field map
  if (fieldMap) {
    fieldMap->SetScale(field.GetScale());
    fieldMap->SetPosition(field.GetMatrix().GetTranslation()[0], field.GetMatrix().GetTranslation()[1],
                          field.GetMatrix().GetTranslation()[2]);
  }
 
  return fieldMap;
}
// -------------------------------------------------------------------------
 
 
// -----  Get a geometry file name   ---------------------------------------
Bool_t CbmSetup::GetGeoFileName(ECbmModuleId moduleId, TString& fileName)
{
  auto& moduleMap = fProvider->GetSetup().GetModuleMap();
 
  if (moduleMap.find(moduleId) == moduleMap.end()) {
    fileName = "";
    return kFALSE;
  }
  fileName = moduleMap.at(moduleId).GetFilePath();
  return kTRUE;
}
// -------------------------------------------------------------------------
 
 
// -----  Get a geometry tag   ---------------------------------------------
Bool_t CbmSetup::GetGeoTag(ECbmModuleId moduleId, TString& tag)
{
  auto& moduleMap = fProvider->GetSetup().GetModuleMap();
 
  if (moduleMap.find(moduleId) == moduleMap.end()) {
    tag = "";
    return kFALSE;
  }
  tag = moduleMap.at(moduleId).GetTag();
  return kTRUE;
}
// -------------------------------------------------------------------------
 
 
// -----  Get a hash of the setup  -----------------------------------------
size_t CbmSetup::GetHash()
{
  // TODO: make all getters constant (up to the CbmGeoSetupModule and co. classes)
  std::string hashString{""};
  auto& moduleMap = fProvider->GetSetup().GetModuleMap();
  for (auto& entry : moduleMap) {
    if (!hashString.empty()) {
      hashString += ";";
    }
    hashString += entry.second.GetName() + ":" + entry.second.GetTag();
  }
  //LOG(info) << "CbmSetup::GetHash(): " << hashString;
  return std::hash<std::string>{}(hashString);
}
// -------------------------------------------------------------------------
 
 
// -----   Instance   ------------------------------------------------------
CbmSetup* CbmSetup::Instance()
{
  if (!fgInstance) fgInstance = new CbmSetup();
  return fgInstance;
}
// -------------------------------------------------------------------------
 
 
// -----  Get activity flag   ----------------------------------------------
Bool_t CbmSetup::IsActive(ECbmModuleId moduleId)
{
  auto& moduleMap = fProvider->GetSetup().GetModuleMap();
 
  if (moduleMap.find(moduleId) == moduleMap.end()) return kFALSE;
  return moduleMap.at(moduleId).GetActive();
}
// -------------------------------------------------------------------------
 
 
// -----   Remove a module   -----------------------------------------------
void CbmSetup::RemoveModule(ECbmModuleId moduleId) { fProvider->RemoveModule(moduleId); }
// -------------------------------------------------------------------------
 
 
// -----   Activate or deactivate a detector   -----------------------------
void CbmSetup::SetActive(ECbmModuleId moduleId, Bool_t active)
{
 
  auto& moduleMap = fProvider->GetSetup().GetModuleMap();
 
  // Check presence of module in current setup
  if (moduleMap.find(moduleId) == moduleMap.end()) {
    LOG(warn) << "Module " << moduleId << " does not exist in setup!";
    return;
  }
 
  // Set activity flag
  moduleMap.at(moduleId).SetActive(active);
}
// -------------------------------------------------------------------------
 
 
// -----   Set the field map   ---------------------------------------------
void CbmSetup::SetField(const char* tag, Double_t scale, Double_t xPos, Double_t yPos, Double_t zPos)
{
 
  LOG(warn) << GetName() << ": Overriding field map  " << fProvider->GetSetup().GetField().GetTag()
            << " (according to magnet geometry) with field map " << tag;
 
  CbmGeoSetupField field = fProvider->GetFieldByTag(tag);
  field.SetScale(scale);
  field.GetMatrix().SetTranslation(xPos, yPos, zPos);
  fProvider->GetSetup().SetField(field);
}
// -------------------------------------------------------------------------
 
 
// -----   Add or replace a module in the setup   --------------------------
void CbmSetup::SetModule(ECbmModuleId moduleId, const char* geoTag, Bool_t active)
{
 
  std::map<ECbmModuleId, CbmGeoSetupModule> modmap = fProvider->GetSetup().GetModuleMap();
 
  if (modmap.find(moduleId) != modmap.end()) {
 
    CbmGeoSetupModule& module = fProvider->GetSetup().GetModuleMap().at(moduleId);
    // Check presence of module in current setup
    LOG(debug) << GetName() << ": Changing module " << moduleId << ": " << module.GetTag() << " -> " << geoTag;
  }
  fProvider->SetModuleTag(moduleId, geoTag, active);
}
// -------------------------------------------------------------------------
 
 
// -----   Info to string   ------------------------------------------------
string CbmSetup::ToString() const
{
 
  stringstream ss;
  CbmGeoSetup& setup = fProvider->GetSetup();
  ss << std::left << "CBM setup: " << setup.GetName() << ", " << GetNofModules() << " modules \n";
  for (auto& it : setup.GetModuleMap()) {
    ECbmModuleId moduleId     = it.first;
    CbmGeoSetupModule& module = it.second;
    ss << "       " << std::setw(8) << CbmModuleList::GetModuleNameCaps(moduleId) << ":  " << std::setw(8)
       << module.GetTag();
    if (module.GetActive()) ss << "  *ACTIVE*  ";
    else
      ss << "            ";
    ss << " using " << module.GetFilePath() << "\n";
  }
 
  CbmGeoSetupField& field = setup.GetField();
  ss << "       Field   :  " << field.GetTag() << ", Position ( " << field.GetMatrix().GetTranslation()[0] << ", "
     << field.GetMatrix().GetTranslation()[1] << ", " << field.GetMatrix().GetTranslation()[2] << " ) cm, scaling "
     << field.GetScale() << "\n";
 
  return ss.str();
}
// -------------------------------------------------------------------------
 
 
// -----   Set the source the setup will be loaded from   -------------------
void CbmSetup::SetSetupSource(ECbmSetupSource setupSource)
{
  switch (setupSource) {
    case kRepo: SetProvider(new CbmGeoSetupRepoProvider()); break;
    case kDb: SetProvider(new CbmGeoSetupDbProvider()); break;
    default: LOG(fatal) << "Invalid value for geo setup provider source " << setupSource;
  }
}
// --------------------------------------------------------------------------
 
 
ClassImp(CbmSetup)