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_FOCAL_DETECTOR_H_
#define ALICEO2_FOCAL_DETECTOR_H_
 
#include <vector>
 
#include "DetectorsBase/Detector.h"
#include "FOCALBase/Hit.h"
#include "FOCALBase/Geometry.h"
 
class FairVolume;
 
namespace o2::focal
{
 
class Hit;
class Geometry;
 
struct Parent {
  int mPDG;                
  double mEnergy;          
  bool mHasTrackReference; 
};
 
class Detector : public o2::base::DetImpl<Detector>
{
 public:
  enum MediumType_t { ID_TUNGSTEN = 0,
                      ID_SIPAD = 1,
                      ID_SIPIX = 2,
                      ID_G10 = 3,
                      ID_COPPER = 4,
                      ID_STEEL = 5,
                      ID_ALLOY = 6,
                      ID_CERAMIC = 7,
                      ID_PB = 8,
                      ID_SC = 9,
                      ID_SIINSENS = 10,
                      ID_ALUMINIUM = 11,
                      ID_VAC = 12,
                      ID_AIR = 13 };
  Detector() = default;
 
  Detector(Bool_t isActive, std::string geofilename = "default");
 
  ~Detector() override;
 
  void InitializeO2Detector() override;
 
  Bool_t ProcessHits(FairVolume* v = nullptr) final;
 
  Hit* AddHit(int trackID, int primary, double initialEnergy, int detID, o2::focal::Hit::Subsystem_t subsystem,
              const math_utils::Point3D<float>& pos, double time, double energyloss);
 
  void Register() override;
 
  std::vector<Hit>* getHits(Int_t iColl) const
  {
    if (iColl == 0) {
      return mHits;
    }
    return nullptr;
  }
 
  void Reset() final;
 
  void EndOfEvent() final;
 
  void BeginPrimary() override;
 
  void FinishPrimary() override;
 
  Geometry* getGeometry(std::string name = "");
 
  Hit* FindHit(int parentID, int col, int row, int layer);
 
 protected:
  void CreateMaterials();
 
  virtual void addAlignableVolumes() const override;
  void addAlignableVolumesHCAL() const;
  void addAlignableVolumesECAL() const;
 
  void ConstructGeometry() override;
 
  virtual void CreateHCALSpaghetti();
  virtual void CreateHCALSandwich();
 
  void CreateECALGeometry();
 
  Parent* AddSuperparent(int trackID, int pdg, double energy);
 
  bool ProcessHitsEPad(FairVolume* v = nullptr);
 
  bool ProcessHitsEPix(FairVolume* v = nullptr);
 
  bool ProcessHitsHCAL(FairVolume* v = nullptr);
 
 private:
  Detector(const Detector& rhs);
 
  Geometry* mGeometry; 
 
  int mMedSensHCal = 0;    
  int mMedSensECalPad = 0; 
  int mMedSensECalPix = 0; 
 
  std::vector<const Composition*> mGeoCompositions; 
 
  std::vector<o2::focal::Hit>* mHits;                                              
  std::unordered_map<Hit::HitID, unsigned int, Hit::HitIDHasher> mHitIndexMapping; 
 
  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;  
 
  std::vector<std::string> mSensitive; 
  int mVolumeIDScintillator = -1;      
 
  template <typename Det>
  friend class o2::base::DetImpl;
  ClassDefOverride(Detector, 1);
};
} // namespace o2::focal
 
#ifdef USESHM
namespace o2
{
namespace base
{
template <>
struct UseShm<o2::focal::Detector> {
  static constexpr bool value = true;
};
} // namespace base
} // namespace o2
#endif
 
#endif // ALICEO2_FOCAL_DETECTOR_H_