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_TPC_Detector_H_
#define AliceO2_TPC_Detector_H_
 
#include "DetectorsBase/Detector.h" // for Detector
#include "Rtypes.h"                 // for Int_t, Double32_t, Double_t, Bool_t, etc
#include "TLorentzVector.h"         // for TLorentzVector
#include "TString.h"
 
#include "TPCSimulation/Point.h"
#include "TPCBase/Sector.h"
#include "DataFormatsTPC/BetheBlochAleph.h"
 
class FairVolume; // lines 10-10
 
namespace o2
{
namespace tpc
{
 
class Detector : public o2::base::DetImpl<Detector>
{
 
 public:
  enum EMedium {
    kAir = 0,
    kDriftGas1 = 1,
    kDriftGas2 = 2,
    kCO2 = 3,
    kDriftGas3 = 20,
    kAl = 4,
    kKevlar = 5,
    kNomex = 6,
    kMakrolon = 7,
    kMylar = 8,
    kTedlar = 9,
    kPrepreg1 = 10,
    kPrepreg2 = 11,
    kPrepreg3 = 12,
    kEpoxy = 13,
    kCu = 14,
    kSi = 15,
    kG10 = 16,
    kPlexiglas = 17,
    kSteel = 18,
    kPeek = 19,
    kAlumina = 21,
    kWater = 22,
    kBrass = 23,
    kEpoxyfm = 24,
    kEpoxy1 = 25,
    kAlumina1 = 26
  };
  Detector(Bool_t Active);
 
  // Factory method
  static o2::base::Detector* create(bool active)
  {
    return new Detector(active);
  }
 
  Detector();
 
  ~Detector() override;
 
  void InitializeO2Detector() override;
 
  //     virtual Bool_t ProcessHitsOrig( FairVolume* v=0);
  Bool_t ProcessHits(FairVolume* v = nullptr) override;
 
  void Register() override;
 
  std::vector<HitGroup>* getHits(Int_t iColl) const
  {
    if (iColl >= 0 && iColl < Sector::MAXSECTOR) {
      return mHitsPerSectorCollection[iColl];
    }
    return nullptr;
  }
 
  std::string getHitBranchNames(int coll) const override;
 
  void Reset() override;
 
  void ConstructGeometry() override;
 
  Point* addHit(float x, float y, float z, float time, float nElectrons, float trackID, float detID);
 
 
  template <typename T>
  static T BetheBlochAleph(T bg, T kp1, T kp2, T kp3, T kp4, T kp5)
  {
    return o2::tpc::BetheBlochAleph(bg, kp1, kp2, kp3, kp4, kp5);
  }
 
  Double_t Gamma(Double_t k);
 
  void EndOfEvent() override;
  void FinishPrimary() override { ; }
  void FinishRun() override { ; }
  void BeginPrimary() override { ; }
  void PostTrack() override { ; }
  void PreTrack() override { ; }
 
  void SetSpecialPhysicsCuts() override;
 
  void SetGeoFileName(const TString file) { mGeoFileName = file; }
  const TString& GetGeoFileName() const { return mGeoFileName; }
 
 private:
  int mHitCounter = 0;
  int mElectronCounter = 0;
  int mStepCounter = 0;
  ElementalHit mHitLast{}; 
  HitGroup* mCurrentGroup = nullptr; 
  int mOldTrackId = -1;              
  int mOldSectorId = -1;             
  int mGroupCounter = 0;             
 
  virtual void CreateMaterials();
 
  void GeantHack();
 
  void LoadGeometryFromFile();
  void ConstructTPCGeometry();
 
  void defineSensitiveVolumes();
 
  // needed by base implementation
  bool setHits(Int_t iColl, std::vector<HitGroup>* ptr)
  {
    if (iColl >= 0 && iColl < Sector::MAXSECTOR) {
      mHitsPerSectorCollection[iColl] = ptr;
      // more entries to set?
      if (iColl < Sector::MAXSECTOR - 1) {
        return true;
      }
    }
    return false;
  }
 
  std::vector<HitGroup>* mHitsPerSectorCollection[Sector::MAXSECTOR]; 
 
  TString mGeoFileName; 
  // size_t mEventNr;                       //!< current event number
  // Events are not successive in MT mode
 
  Detector(const Detector& rhs);
  Detector& operator=(const Detector&);
 
  template <typename Det>
  friend class o2::base::DetImpl;
  ClassDefOverride(Detector, 1);
};
 
} // namespace tpc
} // namespace o2
 
#ifdef USESHM
namespace o2
{
namespace base
{
template <>
struct UseShm<o2::tpc::Detector> {
  static constexpr bool value = true;
};
} // namespace base
} // namespace o2
#endif
 
#endif // AliceO2_TPC_Detector_H_