EicDetector.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file EicDetector.h

//
// AYK (ayk@bnl.gov), 2013/06/12
//
//  Basic EIC detector class;
//

#include <ostream> 

#ifndef _EIC_DETECTOR_
#define _EIC_DETECTOR_

#include <TLorentzVector.h>
#include "TVector3.h"
class TClonesArray;

class FairVolume;
#include "FairDetector.h"

#include <PndDetectorList.h>

#include <EicBlackHole.h>
#include <EicEnergyMonitor.h>
#include <EicDetName.h>
#include <EicNamePatternHub.h>
#include <EicGeoPar.h>
#include <EicContFact.h>
#include <EicGeoParData.h>
#include <EicMoCaPoint.h>
//#include <EicFakeMoCaPoint.h>
//#include <EicFakeMoCaPointDbEntry.h>

enum EicDetectorId {qDUMMY, qTPC, qFST, qFGT, qBST, qCEMC, qBEMC, qFEMC, qVST, qBGT, qFHAC, qBHAC};

enum SteppingType {qSteppingTypeUndefined = 0, qOneStepOneHit, qMergeStepsInOneHit, qSteppingTypeDefault};


class EicDetector : public FairDetector {
  friend class EicMCApplication;

public:
  EicDetector(const char *Name, const char *geometryName, EicDetectorId dType = qDUMMY, 
        SteppingType stType = qSteppingTypeUndefined, Bool_t Active  = kTRUE);

  EicDetector() { 
    //printf("Entering default constructor ...\n"); //exit(0);
    ResetVars(); 
  };
  
  void ResetVars() {
    dname = 0; eicContFact = 0; //fEicFakeMoCaPointCollection = 0; 
    fEicMoCaPointCollection = 0;

    fTime = fELoss = fStep = fLength = 0.0;

    mPrintGeometryInfoFlag = false;

    mAllVolumesSensitiveFlag = false;
    fListOfGeantSensitives = 0;
    gptr = 0; vptr = 0; 

    //dbEntry = 0; dbFile = 0; dbTree = 0; _fCutOffMap = 0;

    mKillerVolumes = 0;
  };

  ~EicDetector();
  
  virtual void Initialize();

  virtual void FinishRun();

  virtual Bool_t ProcessHits( FairVolume *v=0);

  virtual void Register();

  virtual void Print() const;
  
  virtual void   Reset();
  
  // May be called from more than one detector; does not hurt;
  virtual void   BeginEvent() { 
    if (gptr && gptr->GetBlackHoleVolumes().size()) EicBlackHole::ResetTrackList(); 
  };

  virtual void ConstructGeometry();
    
  void DeclareAllVolumesSensitive() { mAllVolumesSensitiveFlag = true; };
  int DeclareGeantSensitiveVolume(const char *name, SteppingType stType = qSteppingTypeDefault);
  int DeclareGeantSensitiveVolumePrefix(const char *name, SteppingType stType = qSteppingTypeDefault);
  bool CheckIfSensitive(std::string name);

  ULong64_t GetNodeMultiIndex();

  virtual TClonesArray* GetCollection(Int_t iColl) const ;

  void ResetSteppingVariables();

  virtual void AddMoCaPoint(Int_t trackID, Int_t primaryMotherID, Int_t secondaryMotherID, Int_t detID, 
          ULong64_t multiIndex,
          TVector3 PosIn, TVector3 PosOut,
          TVector3 MomIn, TVector3 MomOut, 
          Double_t time, Double_t length,
          Double_t eLoss, Double_t step) {
    new((*fEicMoCaPointCollection)[fEicMoCaPointCollection->GetEntriesFast()])
      EicMoCaPoint(trackID, primaryMotherID, secondaryMotherID, detID, 
       multiIndex, 
       PosIn, PosOut, MomIn, MomOut, time, length, eLoss, step);
  }

  //virtual void AddFakeMoCaPoint(Int_t trackID, Int_t primaryMotherId, Int_t PDG, Int_t detID, 
  //        TString volumePath, ULong64_t multiIndex, 
  //        TVector3 PosIn, TVector3 MomIn,
  //        Double_t time, Double_t length) {
  //new((*fEicFakeMoCaPointCollection)[fEicFakeMoCaPointCollection->GetEntriesFast()]) 
  //  EicFakeMoCaPoint(trackID, primaryMotherId, PDG, detID, volumePath, multiIndex, PosIn, 
  //           MomIn, time, length);
  //}

  //int SetEnergyCutOff(Int_t PDG, Double_t cutMin, Double_t cutMax); 

  void EndOfEvent();

  EicDetectorId GetType() { return fDetType;} ;
  
  virtual FairParSet* EicGeoParAllocator(FairContainer *c);

  EicDetName *GetDname() { return dname; };

  int createFakeMoCaDatabase(const char *outFileName);

  // NB: can not print anything at initialization stage in simulation.C since respective 
  // EicGeoParData block is not imported yet -> just book printout;
  void RequestGeometryInfoPrintout(const char *option = 0) {
    mPrintGeometryInfoFlag   = true;
    mPrintGeometryInfoOption = option;
  };

  void RequestAttachedFilePrintout(const char *fileName, const char *option = 0) {
    mAttachedFilePrintoutRequestName = TString(fileName);
    mAttachedFilePrintoutOption      = option;
  };

  EicEnergyMonitor *AddEnergyMonitorVolume(const char *volumeName, Int_t PDG, 
             char *histogramName, double histogramMin, 
             double histogramMax, unsigned histogramBinNum = 1000) {
    EicEnergyMonitor *monitor = new EicEnergyMonitor(volumeName, PDG, 
                 histogramName, histogramMin, 
                 histogramMax, histogramBinNum);

    mEnergyMonitorVolumes.push_back(monitor);

    return monitor;
  };

 protected:
  EicDetName *dname; 

  EicContFact *eicContFact; 

  TClonesArray  *fEicMoCaPointCollection; 

  //TClonesArray  *fEicFakeMoCaPointCollection; //!

  // Geometry printout request flag and respective option; 
  bool mPrintGeometryInfoFlag; 
  TString mPrintGeometryInfoOption; 

  TString mAttachedFilePrintoutRequestName; 
  TString mAttachedFilePrintoutOption;      

  //
  // Working variables; 
  //
  TLorentzVector fPosIn;             

  TLorentzVector fMomIn;             

  Double32_t     fTime;              

  Double32_t     fLength;            

  Double32_t     fELoss;             

  Double32_t     fStep;              

  virtual void SetGeometryFileName(TString fname, TString geoVer="0");

  void AddKillerVolume(TGeoVolume *volume) {
    if (!mKillerVolumes) mKillerVolumes = new EicNamePatternHub<unsigned>();

    // I guess no double-counting check is really needed here?;
    mKillerVolumes->AddExactMatch(volume->GetName());
  };
 public:
  void AddKillerVolume(const char *vname) {
    if (!mKillerVolumes) mKillerVolumes = new EicNamePatternHub<unsigned>();

    // I guess no double-counting check is really needed here?;
    mKillerVolumes->AddExactMatch(vname);
  };
 protected:
  bool IsKillerVolume(const char *name);

  void CheckEnergyMonitors(const char *name, Int_t trackID, 
         Int_t PDG, bool isPrimary, bool isEntering, bool isExiting, 
         double energy);
  
 private: 
  EicGeoParData *gptr;    

  TGeoVolume *vptr;       

  EicDetectorId fDetType; 

  SteppingType fStType;   

  TString fPathUponEntry; 

  //std::vector<std::string> fListOfGeantSensitives; //!
  Bool_t mAllVolumesSensitiveFlag;
  EicNamePatternHub<SteppingType> *fListOfGeantSensitives;

  //std::map<Int_t, std::pair<Double_t,Double_t> > *_fCutOffMap; //!
  //
  // May want to clean up here (move to local variables in respective routines)?;
  //
  //TString fFakeMoCaDatabaseFile;    //!
  //EicFakeMoCaPointDbEntry *dbEntry; //!
  //TFile *dbFile;                    //!
  //TTree *dbTree;                    //! 

  // Let it be unsigned here; not used anyway;
  EicNamePatternHub<unsigned> *mKillerVolumes; // list of volumes which kill particles upon entry

  // May want to declare some of the volumes as energy measuring ones for particles upon 
  // entrance(exit); may want to extend this formalism to other quantities later; 
  std::vector<EicEnergyMonitor*> mEnergyMonitorVolumes; 

  ClassDef(EicDetector,49)   
};

class EicDummyDetector : public EicDetector {
public: 
 EicDummyDetector(const char *Name, const char *geometryName): 
  EicDetector(Name, geometryName, qDUMMY, qOneStepOneHit, kFALSE) {};

 EicDummyDetector() {};
  
 ~EicDummyDetector() {};

 private:

  ClassDef(EicDummyDetector,7)   
};

#endif