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_TOF_DETECTOR_H_
#define ALICEO2_TOF_DETECTOR_H_
 
#include "DetectorsBase/Detector.h"
#include "TOFBase/Geo.h"
 
#include "SimulationDataFormat/BaseHits.h"
#include "CommonUtils/ShmAllocator.h"
 
#include <array>
#include <map>
#include <vector>
 
class TGeoVolume;
 
class FairVolume;
 
namespace o2
{
namespace tof
{
class HitType : public o2::BasicXYZEHit<float>
{
 public:
  using BasicXYZEHit<float>::BasicXYZEHit;
};
} // namespace tof
} // namespace o2
 
#ifdef USESHM
namespace std
{
template <>
class allocator<o2::tof::HitType> : public o2::utils::ShmAllocator<o2::tof::HitType>
{
};
} // namespace std
#endif
 
namespace o2
{
namespace tof
{
 
class Detector : public o2::base::DetImpl<Detector>
{
 public:
  enum TOFMaterial {
    kAir = 1,
    kNomex = 2,
    kG10 = 3,
    kFiberGlass = 4,
    kAlFrame = 5,
    kHoneycomb = 6,
    kFre = 7,
    kCuS = 8,
    kGlass = 9,
    kWater = 10,
    kCable = 11,
    kCableTubes = 12,
    kCopper = 13,
    kPlastic = 14,
    kCrates = 15,
    kHoneyHoles = 16
  };
 
  Detector() = default;
 
  Detector(Bool_t active);
 
  ~Detector() override;
 
  void InitializeO2Detector() final;
 
  Bool_t ProcessHits(FairVolume* v = nullptr) final;
 
  void Register() override;
 
  std::vector<HitType>* getHits(int iColl) const
  {
    if (iColl == 0) {
      return mHits;
    }
    return nullptr;
  }
 
  void Reset() final;
  void EndOfEvent() final;
 
  void CreateMaterials();
  void ConstructGeometry() final;
  void addAlignableVolumes() const override;
 
  void setTOFholes(Bool_t flag = kTRUE) { mTOFHoles = flag; }
 
 protected:
  virtual void DefineGeometry(Double_t xtof, Double_t ytof, Double_t zlenA) final;
  virtual void MaterialMixer(Float_t* p, const Float_t* const a, const Float_t* const m, Int_t n) const final;
 
 private:
  Detector(const Detector& rhs);
 
  void createModules(Double_t xtof, Double_t ytof, Double_t zlenA, Double_t xFLT, Double_t yFLT, Double_t zFLTA) const;
  void makeStripsInModules(Double_t ytof, Double_t zlenA) const;
  void createModuleCovers(Double_t xtof, Double_t zlenA) const;
  void createBackZone(Double_t xtof, Double_t ytof, Double_t zlenA) const;
  void makeFrontEndElectronics(Double_t xtof) const;
  void makeFEACooling(Double_t xtof) const;
  void makeNinoMask(Double_t xtof) const;
  void makeSuperModuleCooling(Double_t xtof, Double_t ytof, Double_t zlenA) const;
  struct FEAContainer {
    Double_t z;
    Int_t row;
    Bool_t rotated;
  };
  std::vector<FEAContainer> feaContainers(Double_t zlenA, Bool_t holes) const;
  void makeCentralFEAContainer(Double_t ytof) const;
  TGeoVolume* coolingBarPiece(Double_t dx, Double_t dy, Double_t dz) const;
  void placeCoolingBar(const char* mother, const std::vector<FEAContainer>& cont, Double_t crateDZ,
                       Double_t crateY0, Double_t crateY1, Double_t xcoor, Double_t dx, Double_t ycoor,
                       Double_t dy, Double_t zcoor, Double_t dz, Int_t& copy) const;
  void makeSuperModuleServices(Double_t xtof, Double_t ytof, Double_t zlenA) const;
  void makeReadoutCrates(Double_t ytof) const;
 
  void makeModulesInBTOFvolumes(Double_t ytof, Double_t zlenA) const;
  void makeCoversInBTOFvolumes() const;
  void makeBackInBTOFvolumes(Double_t ytof) const;
 
  bool isMergable(HitType hit1, HitType hit2)
  {
    if (hit1.GetTrackID() != hit2.GetTrackID()) {
      return false;
    }
 
    if (std::abs(hit1.GetTime() - hit2.GetTime()) > 1.0 /*1 ns*/) {
      return false;
    }
 
    return true;
  }
 
  Int_t mEventNr; // event count
  Int_t mTOFSectors[o2::tof::Geo::NSECTORS];
  Bool_t mTOFHoles;          // flag to allow for holes in front of the PHOS
  Int_t mLastChannelID = -1; 
 
  std::vector<HitType>* mHits; 
 
  mutable std::map<std::array<Double_t, 3>, TGeoVolume*> mBarPieces; 
 
  template <typename Det>
  friend class o2::base::DetImpl;
  ClassDefOverride(Detector, 1);
};
} // namespace tof
} // namespace o2
 
#ifdef USESHM
namespace o2
{
namespace base
{
template <>
struct UseShm<o2::tof::Detector> {
  static constexpr bool value = true;
};
} // namespace base
} // namespace o2
#endif
 
#endif