beamtime/cern-oct12/go4/RICH/TRICHProc.h (r4864/r4735)

Go to the documentation of this file.

#ifndef TRICHPROC_H
#define TRICHPROC_H

#include "TRocProc.h"
#include "TTrbEvent.h"
#include "TRICHEvent.h"
#include "TTriglogEvent.h"
#include "TBeamMonitorEvent.h"
#include "TMbsCrateEvent.h"
#include "TRICHParam.h"
#include "TGo4Picture.h"
#include "TH1.h"
#include "TH2.h"
#include "TGo4WinCond.h"
#include "TGo4PolyCond.h"
#include "TCBMBeamtimeProc.h"
#include "MAPMT_Cell.h"
#include "TEpicsEvent.h"
#include "TFiberHodEvent.h"

//ring fitter
class CbmRichRingFitterCOP;
class CbmRichRingFitterEllipseTau;
class CbmRichRingFinderHoughImpl;
class CbmRichRingLight;
class CbmRichHitLight;
class TEllipse;
class TLatex;


class TRICHProc : public TCBMBeamtimeProc {
   friend class TCBMBeamtimeProc; // may call protected process methods
   
   public:
   TRICHProc();
   TRICHProc(const char* name);
   virtual ~TRICHProc();
   
   virtual void InitEvent(TGo4EventElement*); 
   
   /* this is the main processing function here*/
   virtual void FinalizeEvent();
   
   
protected:
   // local subroutines      
   bool ReadMapmtGeometry(const char* fname);
   void ProcessRICH();
   void ProcessLedPulser();   
   
   void FillCircleFitHistograms(
                   Int_t hIndex,
                   CbmRichRingLight* ring,
                   int nofEventHits);

   void FillEllipseFitHistograms(
                   Int_t hIndex,
                   CbmRichRingLight* ring,
                   int nofEventHits);
   
   void DoAnalysis(
                   const vector<CbmRichHitLight>&,
                   bool isElectron,
                   bool isPion,
                   bool isMuon);

   void DrawRingHits(
                   CbmRichRingLight* ring,
                   Int_t sedNum);

   void DrawEventHits(
                   const vector<CbmRichHitLight>&,
                   Int_t sedNum);

   void DrawCircles(
                   const vector<CbmRichRingLight*>& rings,
                   Int_t sedNum);

   void DrawEllipses(
                   const vector<CbmRichRingLight*>& rings,
                   Int_t sedNum);
   
   void SaveParameters();

   void SetParticleIdentificationConditions();
   
   void CrTalkResults();
   
   void ReadGainPerPixel();

   TRICHParam * fPar;
   
   TRocEvent* fRocInputEvent;
   TTrbEvent* fTrbInputEvent;
   TRICHEvent* fOutputEvent;
   TFiberHodEvent* fHodo1;
   TFiberHodEvent* fHodo2;
   TTriglogEvent* fTriglogEvent;
   TBeamMonitorEvent* fBeamEvent;
   TMbsCrateEvent* fMbsEvent;
   TEpicsEvent* fEpicsEvent;
   
   //ring finders and fitters
   CbmRichRingFitterCOP* fRingFitter;
   CbmRichRingFitterEllipseTau* fEllipseFitter;
   CbmRichRingFinderHoughImpl* fRingFinder;
   
   TH2* hEntries2dIntegral;
   TH2* hEntries2dMean;
   TH1* hEntriesperPMT;
   TH2* hEntriesperPMT2D;
   TH1* hADCall;
   
   TH1* hHittime;
   TH1* hHitMultperPMT[17];
   
   //Circle fitter histograms
   //[0] is electron, [1] is pion, [2] is muon, [3] is all
   TH1* hCircleFitRadius[4];
   TH1* hCircleFitRadius_cor[4];        // corrected for temperature and pressure
   TH2* hCircleFitCenter[4];
   TH1* hCircleFitChi2[4];
   TH1* hCircleFitDR[4];
   
   //ellipse fitter histograms
   //[0] is electron, [1] is pion, [2] is muon, [3] is all
   TH1* hEllipseFitAaxis[4];
   TH1* hEllipseFitBaxis[4];
   TH1* hEllipseFitPhi[4];
   TH1* hEllipseFitBoverA[4];
   TH2* hEllipseFitCenter[4];
   TH1* hEllipseFitChi2[4];
   
   // efficiency historams vs. nof hits
   //[0] is electron, [1] is pion, [2] is muon, [3] is all
   TH1* hNofHitsEvAll[4];
   TH1* hNofHitsEvRingFinder[4];
   TH1* hNofHitsEvCircleFit[4];
   TH1* hNofHitsEvEllipseFit[4];
   TH1* hNofHitsEvRingFinderEff[4];
   TH1* hNofHitsEvCircleFitEff[4];
   TH1* hNofHitsEvEllipseFitEff[4];

   TH1* hNofHitsRingFinder[4]; // number of hits in found ring after ring finder
   TH1* hNofHitsRingFinder_cor;
   TH1* hNofHitsRingFinder_cor2;
   TH1* hNofHitsRingFinder_cor3;
   
   TH1* hNofHitsInHodo; //Number of hits in hodoscope
   TH2* hHodoADCvsNofHitInEv; // Hodoscope ADC vs number of hits in ring
   TH2* hNotAssignedHitsXY; // XY position of the hits not assigned to the ring

   //Number of entries 2D
   //[0] is electron, [1] is pion, [2] is muon, [3] is all
   TH2* hEntries2d[4];

   //Number of found rings per event
   TH1* hNofFoundRings;

   TH1* hTimespread;
   
   // additional histos for hodoscope correlation
   TH2* hMAPMT_hcor2d_s1;
   TH2* hMAPMT_hcor2d_s2;
   TH2* hMAPMT_hcor2d_s3;
   TH2* hMAPMT_hcor2d_s4;
   TH2* hMAPMT_hcor2d_s5;
   
   // conditions on ADC, time
   TGo4WinCond* fMAPMT_cond;
   TGo4WinCond* fMAPMT_tcond;
   
   // conditions for electons, muons and pions
   TGo4PolyCond  *fElectronCondc1c2;  
   TGo4PolyCond  *fMuonCondc1c2;      
   TGo4PolyCond  *fPionCondc1c2;      
   
   // event display 
   vector<TGo4Picture*> fCirclePicture;
   vector<vector<TEllipse*> > fCircle;
   vector<TLatex*> fCircleText;
   vector<vector<TEllipse*> > fEllipse;
   vector<TLatex*> fEllipseText;
   vector<vector<TEllipse*> > fRingHits;
   vector<vector<TEllipse*> > fEventHits;
   vector<TH2*> hSED;
   const static int fMaxNofHitsInEventDraw = 100;
   
   // variables and data structures
   MAPMT_Cell fMAPMTCells[NUM_MAPMP_CELLS];
   
   MAPMT_Cell* fTRBindex[TRB_TDC3_NUMBOARDS*64];
   TH2* hMAP_from_TRB;
   TH2* hEntries_TRBROC;

   TH1* hLedPulserEntriesPerChannel;
   TH2* hLedPulserEntries2d;
   TH2* hLedPulserHitVsMapmt;
   TH2* hLedPulserADCvsPixel[25];  // again hard-coded number of mapmt's = 24

   TH1* hSinglePhotonSpectra[25];       
   
   int fEventNr;
   int fEventTime;
   Double_t fO2level;
   Double_t fH2Olevel;
   Double_t fTT1;
   Double_t fPTB;
   Double_t fPress0;
   Double_t fTemp0;
   
   int fNrSED;
   
   // crosstalk histograms
   TH1* hitPMT;
   TH1* hitPMTmore;
   TH1* hNEdge;
   TH1* hNCorner;
   TH1* hNCenter;
   TH1* hHitMultperPMT_CrTalk[25];
   TH2* hEntries2dperPMT[25];
   TH1* hHitDist[25];
   TH1* hHitDist_py[25];
   TH2* hCrTalkDist[25];
   TH2* hCrTalkDist_allPMTs;
   TH2* hEntries2dAll;
   int fEventNr_1stloop;
   int fEventNr_2ndloop;
   int nof2hitevents;
   // simulated crosstalk for testing
   TH1* hHitDist_sim[25];
   TH1* hHitDist_sim_py[25];
   
  TGo4Picture* pic_ct[25];
  TGo4Picture* pic_ct_zones[25];
   // histograms for single hits
   TH1* hLEDPulserADC_1hit[25];
   TH2* hLEDPulserADC_1hit_perPixel[25];
   TH1* hLEDPulserADC_ctHits[25];
   TH1* hLEDPulserADC_nofph[25]; // single-photon spectra with dependence on number of photons instead ADC values   
   TH2* hLEDPulserADC_nofphPP[25]; // single-photon spectra with dependence on number of photons instead ADC values for each pixel
   TH1* hLEDPulserADC_nofph_mct[25]; // single-photon spectra with dependence on number of photons instead ADC values for each pixel MINUS crosstalk
   TH1* hLEDPulserADC_nofph_1hitpMA[25]; // single-photon spectra with dependence on number of photons instead ADC values for each pixel only for events with 1 hit per mapmt
   // array for GainPerPixel values
   Double_t gain_per_pixel[25][65];
   Double_t gain_mean[25];
   // gain_per_pixel-corrected histograms
   TH1* hLEDPulserADCcor_1hit[25];
   // just testing
   TH1* SP_ADC_all[25];         // complete single-photon spectra
   TH1* SP_ADC_ct[25];          // only crosstalk hits (<10% sp-peak for each channel)
   TH1* SP_ADC_1hit[25];        // only hits with no hit in 8 neighbouring pixel
   TH1* SP_ADC_ctmain[25];      // only hits, which have crosstalk
   TH1* SP_ADC_noct[25];        // all hits, which are no crosstalk hits
   
   TH1* SP_norm_all[25];        // complete single-photon spectra
   TH1* SP_norm_ct[25];         // only crosstalk hits (<10% sp-peak for each channel)
   TH1* SP_norm_1hit[25];       // only hits with no hit in 8 neighbouring pixel
   TH1* SP_norm_ctmain[25];     // only hits, which have crosstalk
   TH1* SP_norm_noct[25];       // all hits, which are no crosstalk hits
   
   Int_t crosstalk[25][2];
   TH1* crosstalk_results[25];
   
   

   ClassDef(TRICHProc,1)

};

#endif //TUNPACKPROCESSOR_H