Scifi.h

Go to the documentation of this file.

#ifndef Scifi_H
#define Scifi_H
 
 
#include "FairModule.h"                 // for FairModule
#include "FairDetector.h"
#include "SNDLHCEventHeader.h"
#include "Rtypes.h"                     // for ShipMuonShield::Class, Bool_t, etc
 
#include <string>                       // for string
 
#include "TVector3.h"
#include "TLorentzVector.h"
 
class ScifiPoint;
class FairVolume;
class TClonesArray;
 
class Scifi : public FairDetector
{
public:
    Scifi(const char* name, Bool_t Active, const char* Title = "Scifi");
    Scifi();
    virtual ~Scifi();
 
    
    void ConstructGeometry();
 
    void GetPosition(Int_t id, TVector3& vLeft, TVector3& vRight); // or top and bottom
    TVector3 GetLocalPos(Int_t id, TVector3* glob);
    void GetSiPMPosition(Int_t SiPMChan, TVector3& A, TVector3& B) ;
    Double_t GetCorrectedTime(Int_t fDetectorID, Double_t rawTime, Double_t L);
    Double_t ycross(Double_t a,Double_t R,Double_t x);
    Double_t integralSqrt(Double_t ynorm);
    Double_t fraction(Double_t R,Double_t x,Double_t y);
    Double_t area(Double_t a,Double_t R,Double_t xL,Double_t xR);
    void SiPMmapping();
    std::map<Int_t,std::map<Int_t,std::array<float, 2>>> GetSiPMmap(){return fibresSiPM;}
    std::map<Int_t,std::map<Int_t,std::array<float, 2>>> GetFibresMap(){return siPMFibres;}
    std::map<Int_t,float> GetSiPMPos(){return SiPMPos;}
    virtual void SiPMOverlap();
    void SetConfPar(TString name, Float_t value){conf_floats[name]=value;}
    void SetConfPar(TString name, Int_t value){conf_ints[name]=value;}
    void SetConfPar(TString name, TString value){conf_strings[name]=value;}
    Float_t  GetConfParF(TString name){return conf_floats[name];} 
    Int_t       GetConfParI(TString name){return conf_ints[name];}
    TString  GetConfParS(TString name){return conf_strings[name];}
    void InitEvent(SNDLHCEventHeader *e);
 
    virtual void Initialize();
    
    virtual Bool_t ProcessHits( FairVolume* v=0);
    
    virtual void   Register();
    
    virtual TClonesArray* GetCollection(Int_t iColl) const ;
    
    virtual void   Reset();
    
    ScifiPoint* AddHit(Int_t trackID, Int_t detID,
                       TVector3 pos, TVector3 mom,
                       Double_t time, Double_t length,
                       Double_t eLoss, Int_t pdgCode);
    
    virtual void   CopyClones( TClonesArray* cl1,  TClonesArray* cl2 ,
                              Int_t offset) {;}
    virtual void   SetSpecialPhysicsCuts() {;}
    virtual void   EndOfEvent();
    virtual void   FinishPrimary() {;}
    virtual void   FinishRun() {;}
    virtual void   BeginPrimary() {;}
    virtual void   PostTrack() {;}
    virtual void   PreTrack() {;}
    virtual void   BeginEvent() {;}
    
    
    Scifi(const Scifi&);
    Scifi& operator=(const Scifi&);
    
    ClassDef(Scifi,3)
    
private:
    
    Int_t          fTrackID;           
    Int_t          fVolumeID;          
    TLorentzVector fPos;               
    TLorentzVector fMom;               
    Double32_t     fTime;              
    Double32_t     fLength;            
    Double32_t     fELoss;             
    std::map<Int_t,std::map<Int_t,std::array<float, 2>>> fibresSiPM;  
    std::map<Int_t,std::map<Int_t,std::array<float, 2>>> siPMFibres;  
    std::map<Int_t,float> SiPMPos;  
    TClonesArray*  fScifiPointCollection;
    std::map<TString,Float_t> conf_floats;
    std::map<TString,Int_t> conf_ints;
    std::map<TString,TString> conf_strings;
    SNDLHCEventHeader *eventHeader;
 
    // Vector to store runs covered in the geometry file.
    std::vector<int> covered_runs_time_alignment;
    std::vector<int> covered_runs_position_alignment;
    int last_run_time, last_run_pos;
    TString last_time_alignment_tag;
    TString last_position_alignment_tag;
    bool alignment_init;
protected:
    
    Int_t InitMedium(const char* name);
    
};
 
#endif