MuFilter.h

Go to the documentation of this file.

//  
//  MuFilter.h 
//  
//  by A. Buonaura
 
#ifndef MuFilter_H
#define MuFilter_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 "TString.h"
#include "TLorentzVector.h"
 
class MuFilterPoint;
class FairVolume;
class TClonesArray;
 
class MuFilter : public FairDetector
{
    public:
        MuFilter(const char* name, Bool_t Active, const char* Title="MuonFilter");
        MuFilter();
        virtual ~MuFilter();
 
        void ConstructGeometry();
 
                 void GetPosition(Int_t id, TVector3& vLeft, TVector3& vRight); // or top and bottom
                 void GetLocalPosition(Int_t id, TVector3& vLeft, TVector3& vRight);
                 Float_t GetCorrectedTime(Int_t id, Int_t c, Double_t t, Double_t L);
                 Int_t GetnSiPMs(Int_t detID);
                 Int_t GetnSides(Int_t detID);
 
                void InitEvent(SNDLHCEventHeader *e);
        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];}
 
        virtual void Initialize();
 
        virtual Bool_t ProcessHits( FairVolume* v=0);
 
        virtual void   Register();
 
        virtual TClonesArray* GetCollection(Int_t iColl) const ;
 
        virtual void   Reset();
 
        MuFilterPoint* 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() {;}
 
        MuFilter(const MuFilter&);
        MuFilter& operator=(const MuFilter&);
 
        ClassDef(MuFilter,4)
 
    private:
 
        Int_t          fTrackID;           
        Int_t          fVolumeID;          
        TLorentzVector fPos;               
        TLorentzVector fMom;               
        Double32_t     fTime;              
        Double32_t     fLength;            
        Double32_t     fELoss;             
 
        TClonesArray*  fMuFilterPointCollection;
 
        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;
                TString last_time_alignment_tag;
                int last_run_time, last_run_pos;
                bool alignment_init;
    protected:
 
            Int_t InitMedium(const char* name);
};
 
#endif