Detector.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_EMCAL_DETECTOR_H_
#define ALICEO2_EMCAL_DETECTOR_H_
 
#include "DetectorsBase/Detector.h"
#include "EMCALBase/Hit.h"
#include "EMCALBase/GeometryBase.h"
#include "MathUtils/Cartesian.h"
#include "RStringView.h"
#include "Rtypes.h"
#include <vector>
#include <unordered_map>
 
class FairVolume;
class TClonesArray;
class TH2;
 
namespace o2
{
namespace emcal
{
class Hit;
class Geometry;
 
struct Parent {
  int mPDG;                
  double mEnergy;          
  bool mHasTrackReference; 
};
 
class Detector : public o2::base::DetImpl<Detector>
{
 public:
  enum MediumType_t { ID_AIR = 0,
                      ID_PB = 1,
                      ID_SC = 2,
                      ID_AL = 3,
                      ID_STEEL = 4,
                      ID_PAPER = 5 };
 
  Detector() = default;
 
  Detector(Bool_t isActive);
 
  ~Detector() override;
 
  void InitializeO2Detector() override;
 
  Bool_t ProcessHits(FairVolume* v = nullptr) final;
 
  Hit* AddHit(Int_t trackID, Int_t primary, Double_t initialEnergy, Int_t detID,
              const math_utils::Point3D<float>& pos, const math_utils::Vector3D<float>& mom, Double_t time, Double_t energyloss);
 
  Parent* AddSuperparent(Int_t trackID, Int_t pdg, Double_t energy);
 
  void Register() override;
 
  std::vector<Hit>* getHits(Int_t iColl) const
  {
    if (iColl == 0) {
      return mHits;
    }
    return nullptr;
  }
 
  void Reset() final;
 
  void EndOfEvent() final;
 
  Geometry* GetGeometry();
 
  void BeginPrimary() override;
 
  void FinishPrimary() override;
 
 protected:
  void CreateMaterials();
 
  void ConstructGeometry() override;
 
  void CreateEmcalEnvelope();
 
  void CreateShiskebabGeometry();
 
  void CreateSupermoduleGeometry(const std::string_view mother = "XEN1");
 
  void CreateEmcalModuleGeometry(const std::string_view mother = "SMOD", const std::string_view child = "EMOD");
 
  void CreateAlFrontPlate(const std::string_view mother = "EMOD", const std::string_view child = "ALFP");
 
  int CreateEMCALVolume(const std::string_view name, const std::string_view shape, MediumType_t mediumID, Double_t* shapeParams, Int_t nparams);
 
  Double_t CalculateLightYield(Double_t energydeposit, Double_t tracklength, Int_t charge) const;
 
  Hit* FindHit(Int_t cellID, Int_t parentID);
 
 private:
  Detector(const Detector& rhs);
 
  Int_t mBirkC0;    
  Double_t mBirkC1; 
  Double_t mBirkC2; 
 
  std::vector<std::string> mSensitive;                      
  std::unordered_map<int, EMCALSMType> mSMVolumeID;         
  std::unordered_map<std::string, EMCALSMType> mSMVolNames; 
  Int_t mVolumeIDScintillator;                              
  std::vector<Hit>* mHits;                                  
  Geometry* mGeometry;                                      
  std::unordered_map<int, int> mSuperParentsIndices;        
  std::unordered_map<int, Parent> mSuperParents;            
  Parent* mCurrentSuperparent;                              
 
  // Worker variables during hit creation
  Int_t mCurrentTrack;     
  Int_t mCurrentPrimaryID; 
  Int_t mCurrentParentID;  
 
  Double_t mSampleWidth;  
  Double_t mSmodPar0;     
  Double_t mSmodPar1;     
  Double_t mSmodPar2;     
  Double_t mInnerEdge;    
  Double_t mDCALInnerGap; 
  Double_t mParEMOD[5];   
 
  template <typename Det>
  friend class o2::base::DetImpl;
  ClassDefOverride(Detector, 1);
};
} // namespace emcal
} // namespace o2
 
#ifdef USESHM
namespace o2
{
namespace base
{
template <>
struct UseShm<o2::emcal::Detector> {
  static constexpr bool value = true;
};
} // namespace base
} // namespace o2
#endif
 
#endif