MaterialManager.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEO2_BASE_MATERIALMANAGER_H_
#define ALICEO2_BASE_MATERIALMANAGER_H_
 
#include "Rtypes.h"
#include <map>
#include <unordered_map>
#include <initializer_list>
#include <iosfwd>
 
class TGeoMedium;
 
namespace o2
{
namespace base
{
// put processes and cuts in namespace to make them available from there
enum class EProc { kPAIR = 0,
                   kCOMP,
                   kPHOT,
                   kPFIS,
                   kDRAY,
                   kANNI,
                   kBREM,
                   kHADR,
                   kMUNU,
                   kDCAY,
                   kLOSS,
                   kMULS,
                   kCKOV,
                   kLABS,
                   kRAYL
};
 
enum class ECut { kCUTGAM = 0,
                  kCUTELE,
                  kCUTNEU,
                  kCUTHAD,
                  kCUTMUO,
                  kBCUTE,
                  kBCUTM,
                  kDCUTE,
                  kDCUTM,
                  kPPCUTM,
                  kTOFMAX };
// Central class managing creation of material, mixtures, mediums through
// the VMC interface. All material creations should go through this class.
// Also manages material indices and offers ways to retrieve them
// given a name (such as a given module name).
class MaterialManager
{
 public:
  static MaterialManager& Instance()
  {
    static MaterialManager inst;
    return inst;
  }
 
  // Module composition
  void Material(const char* modname, Int_t imat, const char* name, Float_t a, Float_t z, Float_t dens, Float_t radl,
                Float_t absl, Float_t* buf = nullptr, Int_t nwbuf = 0);
 
  void Mixture(const char* modname, Int_t imat, const char* name, Float_t* a, Float_t* z, Float_t dens, Int_t nlmat,
               Float_t* wmat);
 
  void Medium(const char* modname, Int_t numed, const char* name, Int_t nmat, Int_t isvol, Int_t ifield, Float_t fieldm,
              Float_t tmaxfd, Float_t stemax, Float_t deemax, Float_t epsil, Float_t stmin, Float_t* ubuf = nullptr,
              Int_t nbuf = 0);
 
  //
  enum class ESpecial : bool { kTRUE = true,
                               kFALSE = false };
  void DefaultProcesses(const std::initializer_list<std::pair<EProc, int>>& parIDValMap)
  {
    Processes(ESpecial::kFALSE, -1, parIDValMap);
  }
  void SpecialProcesses(const char* modname, int localindex,
                        const std::initializer_list<std::pair<EProc, int>>& parIDValMap)
  {
    int globalindex = getMediumID(modname, localindex);
    if (globalindex != -1) {
      Processes(ESpecial::kTRUE, globalindex, parIDValMap);
    }
  }
  void DefaultProcess(EProc parID, int val) { Process(ESpecial::kFALSE, -1, parID, val); }
 
  void SpecialProcess(const char* modname, int localindex, EProc parID, int val);
 
  void DefaultCuts(const std::initializer_list<std::pair<ECut, Float_t>>& parIDValMap)
  {
    Cuts(ESpecial::kFALSE, -1, parIDValMap);
  }
 
  void SpecialCuts(const char* modname, int localindex,
                   const std::initializer_list<std::pair<ECut, Float_t>>& parIDValMap);
 
  void DefaultCut(ECut parID, Float_t val) { Cut(ESpecial::kFALSE, -1, parID, val); }
 
  void SpecialCut(const char* modname, int localindex, ECut parID, Float_t val);
 
  void SetLowEnergyNeutronTransport(bool flag) { mLowNeut = flag; }
 
  void loadCutsAndProcessesFromFile(const char* modname, const char* filename);
  void loadCutsAndProcessesFromJSON(ESpecial special = ESpecial::kFALSE, std::string const& filename = "");
  void writeCutsAndProcessesToJSON(std::string const& filename = "");
 
  void enableSpecialProcesses(bool val = true) { mApplySpecialProcesses = val; }
  bool specialProcessesEnabled() const { return mApplySpecialProcesses; }
  void enableSpecialCuts(bool val = true) { mApplySpecialCuts = val; }
  bool specialCutsEnabled() const { return mApplySpecialCuts; }
 
  // returns global material ID given a "local" material ID for this detector
  // returns -1 in case local ID not found
  int getMaterialID(const char* modname, int imat) const;
 
  // returns global medium ID given a "local" medium ID for this detector
  // returns -1 in case local ID not found
  int getMediumID(const char* modname, int imed) const;
 
  // various methods to get the TGeoMedium instance
  TGeoMedium* getTGeoMedium(const std::string& modname, int localid);
  TGeoMedium* getTGeoMedium(const char* mediumname);
 
  void getMediumIDMappingAsVector(const char* modname, std::vector<int>& mapping) const;
 
  const char* getProcessName(EProc process) const;
 
  const char* getCutName(ECut cut) const;
 
  const char* getModuleFromMediumID(int globalindex) const;
 
  const char* getMediumNameFromMediumID(int globalindex) const;
 
  void getMediaWithSpecialProcess(EProc process, std::vector<int>& mediumProcessVector) const;
 
  void getMediaWithSpecialCut(ECut cut, std::vector<Float_t>& mediumCutVector) const;
 
  void getDefaultProcesses(std::vector<std::pair<EProc, int>>& processVector);
 
  void getDefaultCuts(std::vector<std::pair<ECut, Float_t>>& cutVector);
 
  void getSpecialProcesses(int globalindex, std::vector<std::pair<EProc, int>>& processVector);
 
  void getSpecialProcesses(const char* modname, int localindex, std::vector<std::pair<EProc, int>>& processVector);
 
  void getSpecialCuts(int globalindex, std::vector<std::pair<ECut, Float_t>>& cutVector);
 
  void getSpecialCuts(const char* modname, int localindex, std::vector<std::pair<ECut, Float_t>>& cutVector);
 
  void printProcesses(std::ostream& stream) const;
  void printCuts(std::ostream& stream) const;
 
  // print out all registered materials
  void printMaterials() const;
 
  // print out all registered media
  void printMedia() const;
 
  static void printContainingMedia(std::string const& volumename);
 
 private:
  MaterialManager() = default;
 
  bool mDensityMapInitialized = false;
  std::unordered_map<std::string, float> mDensityMap;
 
  void initDensityMap();
  float getDensity(std::string const& modname);
 
  // Hide details by providing these private methods so it cannot happen that special settings
  // are applied as default settings by accident using a boolean flag
  void Processes(ESpecial special, int globalindex, const std::initializer_list<std::pair<EProc, int>>& parIDValMap);
  void Cuts(ESpecial special, int globalindex, const std::initializer_list<std::pair<ECut, Float_t>>& parIDValMap);
  void Process(ESpecial special, int globalindex, EProc parID, int val);
  void Cut(ESpecial special, int globalindex, ECut parID, Float_t val);
 
  // insert material name
  void insertMaterialName(const char* uniquename, int index);
  void insertMediumName(const char* uniquename, int index);
  void insertTGeoMedium(std::string modname, int localindex);
 
  // lookup structures
  std::map<std::string, std::map<int, int>>
    mMaterialMap;                                       // map of module name -> map of local index to global index for Materials
  std::map<std::string, std::map<int, int>> mMediumMap; // map of module name -> map of local index to global index for Media
 
  std::map<int, std::map<EProc, int>> mMediumProcessMap; // map of global medium id to parameter-value map of processes
  std::map<int, std::map<ECut, Float_t>> mMediumCutMap;  // map of global medium id to parameter-value map of cuts
  std::map<ECut, Float_t> mDefaultCutMap;                // map of global cuts
  std::map<EProc, int> mDefaultProcessMap;               // map of global processes
 
  // a map allowing to lookup TGeoMedia from detector name and local medium index
  std::map<std::pair<std::string, int>, TGeoMedium*> mTGeoMediumMap;
 
  // finally, we'd like to keep track of tracking parameters and processes activated per medium
 
  std::map<std::string, int> mMaterialNameToGlobalIndexMap; // map of unique material name to global index
  std::map<std::string, int> mMediumNameToGlobalIndexMap;   // map of unique material name to global index
 
  // \note Currently, the naming convention of GEANT4 v10.3.3 is used.
  // \note This might be overhead so far but makes the MaterialManager and therefore O2 finally capable of
  // forwarding cuts/processes to arbitrary engines.
  // \todo Is there a more elegant implementation?
  const static std::unordered_map<ECut, const char*> mCutIDToName;
  const static std::unordered_map<EProc, const char*> mProcessIDToName;
 
  bool mApplySpecialProcesses = true;
  bool mApplySpecialCuts = true;
  bool mLowNeut = false;
 
 public:
  ClassDefNV(MaterialManager, 0);
};
 
inline const char* MaterialManager::getProcessName(EProc process) const
{
  auto it = mProcessIDToName.find(process);
  if (it != mProcessIDToName.end()) {
    return it->second;
  }
  return "UNKNOWN";
}
 
inline const char* MaterialManager::getCutName(ECut cut) const
{
  auto it = mCutIDToName.find(cut);
  if (it != mCutIDToName.end()) {
    return it->second;
  }
  return "UNKNOWN";
}
 
} // namespace base
} // namespace o2
 
#endif