PndDrc.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

// -------------------------------------------------------------------------
// -----                       PndDrc header file                      -----
// -----               Created 11/10/06 by Annalisa Cecchi             -----
// -----                                                               -----
// -------------------------------------------------------------------------

#ifndef PNDDRC_H
#define PNDDRC_H

#include <array>

#include "TLorentzVector.h"
#include "FairDetector.h"
#include "TGraph.h"
#include "TRandom.h"
#include "TArrayI.h"
#include "PndGeoHandling.h"

class TClonesArray;
class PndDrcPDPoint;
class PndDrcBarPoint;
class FairVolume;
class PndGeoDrc;
class PndDrcEVPoint;
class TClonesArray;

class PndDrc : public FairDetector {

 public:
  PndDrc();

  PndDrc(const char *name, Bool_t active);

  virtual ~PndDrc();

  void StopSecondaries(Bool_t ss = kFALSE) { fStopSecondaries = ss; }

  void StopChargedTrackAfterDIRC(Bool_t sctad = kTRUE) { fStopChargedTrackAfterDIRC = sctad; }

  void SetDetEffId(Int_t val = 2) { fDetEffId = val; }

  void SetDetEffAtProduction(Bool_t dep = kFALSE) { fDetEffAtProduction = dep; }

  void SetTransportEffAtProduction(Bool_t tra = kFALSE) { fTransportEffAtProduction = tra; }

  void SetMirrorReal(Bool_t mir = kTRUE) { fTakeRealReflectivity = mir; }

  void SetBlackLensSides(Bool_t lesi = kFALSE) { fSetBlackLens = lesi; }

  void SetStopTime(Double_t ti = -1.)
  {
    fPhoMaxTime = ti;
    if (fPhoMaxTime > 0.) {
      fStopTime = kTRUE;
    }
    if (fPhoMaxTime <= 0.) {
      fStopTime = kFALSE;
    }
  }

  void SetOptionForLUT(Bool_t oplu = kFALSE) { fOptionForLUT = oplu; }

  virtual void Initialize();
  void SetPersistency(Bool_t v = kTRUE) { fPersistency = v; }

  virtual Bool_t ProcessHits(FairVolume *vol = 0);

  virtual void FinishPrimary();

  virtual void EndOfEvent();

  virtual void BeginEvent();
  virtual void Register();

  virtual TClonesArray *GetCollection(Int_t iColl) const;

  virtual void Print() const;

  virtual void Reset();

  virtual void CopyClones(TClonesArray *clPD1, TClonesArray *clPD2, TClonesArray *clBar1, TClonesArray *clBar2,
                          /*TClonesArray* clSdsPD1, TClonesArray* clSdsPD2, TClonesArray* clSdsBar1, TClonesArray* clSdsBar2, */ Int_t offset);

  // Int_t GetSensorId(TString);

  void FinishRun();

  virtual void ConstructGeometry();
  virtual void ConstructOpGeometry();
  //  void ConstructASCIIGeometry();
  //  virtual void ConstructRootGeometry();
  std::vector<std::string> fListOfSensitives;
  bool CheckIfSensitive(std::string name);

  void NumberOfBounces(TVector3, TVector3, Int_t, Int_t *, Int_t *, Double_t *, Double_t *);
  Double_t FindOutPoint(Double_t, Double_t, Double_t, Double_t *, Bool_t);

  PndDrcPDPoint *
  AddHit(Int_t trackID, Int_t copyNo, Int_t mcpId, TVector3 pos, TVector3 mom, TVector3 momAtEV, Double_t timeAtEV, Double_t time, Double_t length, Int_t pdgCode, Int_t eventID);

  PndDrcEVPoint *AddEVHit(Int_t trackID, Int_t copyNo, TVector3 pos, TVector3 mom, Double_t time, Double_t length, Int_t pdgCode, Int_t eventID, Double_t timestart,
                          Double_t timestartEV, Double_t VeloPhoton, TVector3 normal);

  PndDrcBarPoint *
  AddBarHit(Int_t trackID, Int_t copyNo, TVector3 pos, TVector3 mom, Double_t time, Double_t length, Int_t pdgCode, Double_t thetaC, Int_t nBar, Int_t eventID, Double_t mass);

  void SetRunCherenkov(Bool_t ch) { fRunCherenkov = ch; };

 private:
  Bool_t fPersistency;

  // basic parameters of DIRC
  Double_t fpi;
  Double_t fzup;
  Double_t fzdown;
  Double_t fradius;
  Double_t fhthick;
  Double_t fpipehAngle;
  Double_t fbbGap;

  Double_t fbbnum;
  Double_t fbarnum;
  Double_t fphi0;
  Double_t fdphi;
  Double_t fbarwidth;

  PndGeoHandling *fGeoH;

  Bool_t fRunCherenkov; //  Switch ON/OFF Cherenkov propagation
  Int_t fTrackID;       //  track index
  Int_t fBarId;
  TLorentzVector fPos; //  position
  TLorentzVector fMom; //  momentum
  Double32_t fTime;    //  time
  Double32_t fLength;  //  length
  Double32_t fLengthEV;
  Double_t fAngIn;
  Int_t fNBar;
  Int_t fPosIndex;
  Int_t volDetector; // MC volume ID of drc
  Double_t fMass;
  TLorentzVector fMomAtEV;
  TLorentzVector fAna_point;
  Double_t fTimeAtEV;
  Double_t fTimeAtEVEntrance;
  Double_t fTimeStart;
  Double_t fVeloPhoton;
  Int_t fEVreflections;

  std::array<TGraph, 2> fDetEff; // Detector Efficiency as a function of photon wavelength
  Int_t fDetEffId;
  Bool_t fDetEffAtProduction;
  Bool_t fTransportEffAtProduction;

  Bool_t fStopTime;
  Double_t fPhoMaxTime;
  Bool_t fTakeRealReflectivity;
  Bool_t fStopSecondaries;
  Bool_t fStopChargedTrackAfterDIRC;
  Bool_t fSetBlackLens;
  Bool_t fOptionForLUT;

  PndGeoDrc *fGeo; // Pointer to basic DRC geometry data

  Int_t fPdgCode;
  Double_t fThetaC;

  TClonesArray *fDrcPDCollection;  // Hit collection
  TClonesArray *fDrcEVCollection;  // Hit collection
  TClonesArray *fDrcBarCollection; // Hit collection in the bar

  Int_t fEventID;

  ClassDef(PndDrc, 0)
};

#endif