ToFLevel2/doc/ToFLevel2Ex.cxx

void ToFLevel2Ex(){

  /*
   *
   * This script shows how use ToFLevel2 output without using PamLevel2 software
   * Notice that here no selection on image tracks is applied
   * All methods and all variables usage are shown 
   *
   */


  /* Some plot just as example */

  // Beta versus Rigidity
  TH2F* BetaRig= new TH2F("BetaRig","Beta versus Rigidity",1000,0.1,10.,520,-1.3,1.3);
  
  // dEdx == adc_c measurement
  TH1F* ADChisto= new TH1F("ADChisto","ADChisto",10,0.,20.);

  TH1F* TestHisto = new TH1F("TestHisto","TestHisto",500,0.,5000.);
  
  gStyle->SetOptStat(111111);

  TrkLevel2*  trk_event = new TrkLevel2();
  ToFLevel2*  tof_event = new ToFLevel2();

  TChain *T = new TChain("Tracker");
  TChain *C = new TChain("ToF");

  T->Add("./8212.Level2.root");
  C->Add("./8212.Level2.root");

  T->SetBranchAddress("TrkLevel2", &trk_event);   // set tracker event adrss
  C->SetBranchAddress("ToFLevel2", &tof_event);   // set ToF event adrss
  T->AddFriend(C);                                // make the trees friends
  
  Int_t nevent = T->GetEntries();
  cout << " Events in Tracker Tree  " << nevent << endl;
  Int_t ntofevent = C->GetEntries();
  cout << " Events in ToF Tree  " << ntofevent << endl;
  
  int j  = 0;
  int k  = 0;
  
  //  for (Int_t ii=0; ii<nevent;ii++){
  for (Int_t ii=0; ii<1000;ii++){

    T->GetEntry(ii);

    /*  
     *  infos in ToFLevel2 class 
     *
    */
    
    // j flag: it's a decoded value (array wioth 6 elements); 
    // for each layer, it summed up if there 
    // are more than one hit per layer
    // tof11_j = tof11_j + 2**(i-1)

    for(Int_t i=0; i<6; i++)
      Int_t tof11_j = tof_event->tof_j_flag[i];
    
    /* 
     * if you need informations from ToF and Tracker, 
     * you have to read both the detector classes
     */
    
    /* ToFTrkVar is the track related class */

    for (Int_t it=0; it<tof_event->ntrk() ; it++){
      
      ToFTrkVar *tof = tof_event->GetToFTrkVar(it);      

      /* trkseqno = index to get ToF alone or ToF+Tracker informations */
      
      /*
       * trkseqno ==-1 -> ToF alone informations
       * trkseqno !=-1 correspond to the Tracker track index 
       */

      //      cout << " Index " << tof->trkseqno << endl;

      /*  Get Tracker information if it exist  */
      
      Int_t trkgood = 0;

      if(tof->trkseqno != -1){
        TrkTrack  *trk = trk_event->GetStoredTrack(tof->trkseqno);      

        /* Select "good" Tracker tracks" */ 

        if(trk->chi2 > 0    && 
           trk->chi2 < 100  &&
           trk->GetNX() >= 4  &&
           trk->GetNY() >= 3 &&
           trk->xgood[0] &&
           (trk->xgood[5] || trk->xgood[4]) &&
           trk->al[4] != 0.)
          {
          
            trkgood = 1;

          }
        
      }
    
            
      // Beta measurement based on ToF alone
      
      /*
       * beta is an array with 13 elements; 
       * 12 correspond to the several planes combinations as described below;
       * the last one is a mean value
       */

      /*
       *
       * S11 - S31 = tof->beta[0]
       * S11 - S32 = tof->beta[1]
       * S12 - S31 = tof->beta[2]
       * S12 - S32 = tof->beta[3]
       * S21 - S31 = tof->beta[4]
       * S21 - S32 = tof->beta[5]
       * S22 - S31 = tof->beta[6]
       * S22 - S32 = tof->beta[7]
       * S11 - S21 = tof->beta[8]
       * S11 - S22 = tof->beta[9]
       * S12 - S21 = tof->beta[10]
       * S12 - S22 = tof->beta[11]
       *
       */


      Int_t ll = 0;
      Int_t mm = 0;

      /*
       * to get the same information for tracks from Tracker set:
       * if(tof->trkseqno==0) for the first tracker track;
       * if(tof->trkseqno==1) for the second tracker track;
       */

      if(tof->trkseqno == -1){
        for (Int_t k=0; k<13 ; k++){
          Float_t Beta = tof->beta[k];
          //      cout << "Beta " <<  Beta << endl;
        }
      }


      /*
       * read the pmtid for the tdc used in evaluate beta 
       * for the first tracker track    
       */

      Float_t tdcflagm[4][12];

        for (Int_t j=0; j<4; j++){
        for (Int_t k=0; k<12; k++){
        tdcflagm[j][k]=0;
                                 }
                                 }


      if(tof->trkseqno == 0){
        // npmttdc = number of pmt used for beta evaluation
        for (Int_t ipmtt=0; ipmtt<tof->npmttdc; ipmtt++){
          // you can read the pmtid for the tdc used in evaluate beta
          Int_t pmttdc = tof->pmttdc[ipmtt];
          // printf("pmttdc %d\n",pmttdc);
          Int_t tdcflag = tof->tdcflag[ipmtt];
  if(tdcflag!=0) {
//       cout << " TDC " << tof->tdcflag[ipmtt] << " " << tdcflag << " " << pmttdc  << endl;
      ll=0;
      mm=0;      
      tof_event->GetPMTIndex(pmttdc,ll,mm);
      cout<<"pmttdc tdcflag  "<<pmttdc<<" "<<tdcflag<<endl; 
      tdcflagm[mm][ll]= tdcflag;
                        }

          /*
           * Method to get Plane Index from a pmtid;
           * here is shown for a pmtid corresponding to
           * the tdc used in beta evaluation
           */
          Int_t pmt_plane=tof_event->GetPlaneIndex(pmttdc);
          
        }
      }


       ll = 0;
       mm = 0;

      /*
       * dEdx for each PMT with signal;
       * this value coprresponds to the signal from a single pmt
       */

      Float_t adc2[4][12];
      
      if(tof->trkseqno == 0){
        // npmtadc = number of pmt used for dEdx evaluation
        for (Int_t ipmta=0; ipmta<tof->npmtadc; ipmta++){
          // dedx = adc_c
          Float_t dEdx = tof->dedx[ipmta];
          // printf("dEdx %f %f\n",tof->dedx[ipmta],dEdx);
          
          // you can read the pmtid for the adc used in evaluate dedx=adc_c
          Int_t pmtadc = tof->pmtadc[ipmta];
          // printf("pmtadc %d\n",tof->pmtadc[ipmta]);
          
          Int_t adcflag = tof->adcflag[ipmta];
// cout << " ADC " << adcflag << " " << pmtadc << " " << dEdx << endl;
          

          if(ipmta == 1) {
            ADChisto->Fill(tof->dedx[ipmta]);
          }


          /* 
             to get pmt index in terms of matrix index 
             from pmtid
          */
          tof_event->GetPMTIndex(pmtadc,ll,mm);
          adc2[mm][ll] = tof->dedx[ipmta];


          /* 
             to get pmt index from matrix index
          */
          tof_event->GetPMTid(ll,mm);
          Int_t ind = tof_event->GetPMTid(ll,mm);

          
          /* 
             to get pmt name from pmtid
          */
          tof_event->GetPMTName(pmtadc);
          // cout << tof_event->GetPMTName(pmtadc) << endl;

        }
      }

      // Position measurement based on ToF hits
      
      /*
       * to get the same information for tracks from Tracker set:
       * if(tof->trkseqno==0) for the first tracker track;
       * if(tof->trkseqno==1) for the second tracker track;
       */
      
      if(tof->trkseqno==-1){
        for (Int_t j=0; j<3; j++){
          Float_t xtofpos = tof->xtofpos[j];
          Float_t ytofpos = tof->ytofpos[j];
          // printf("xtofpos %f %f %d\n",xtofpos,tof->xtofpos[j],ii);
          // printf("ytofpos %f %f %d\n",ytofpos,tof->ytofpos[j],ii);
        }
      }

      // Beta versus Rigidity
      
      /*
       * for the first tracker track tof->trkseqno == 0
       * for the second tracker track tof->trkseqno == 1
       * and so on...
       */
      
      if(tof->trkseqno == 0 && trkgood==1){ 
        BetaRig->Fill( trk->GetRigidity(), tof->beta[4]);
      }


      /*
       * Method to get the dEdx on a ToF plane.
       * It is evaluated as sum of all adc signals on the plane 
       * after corrections; its usage is not advised;
       * This method will be modified in the next ToFLevel2 release
       */

      if(tof->trkseqno == 0 && trkgood==1){ 
        for (Int_t plane=0; plane<13; plane++){ 
          Float_t MethoddEdx=tof_event->GetdEdx(it,plane); // it is the index for 
                                                           // tof_event->ntrk()
        }
      }
      

  // fill adc and tdc using getmatrix
      Float_t adc[4][12];
      Float_t tdc[4][12];
      tof_event->GetMatrix(it,adc,tdc);  // it is the index for tof_event->ntrk$

        for (Int_t j=0; j<4; j++){
        for (Int_t k=0; k<12; k++){
        Int_t ind = tof_event->GetPMTid(j,k);

        if (tdc[j][k] < 4095) cout<<ind<<" "<<tdc[j][k]<<" "<<tdcflagm[j][k]<<endl;
                                 }
                                 }

        cout<<"==================="<<endl;


    } // end loop over tracks
    
    Int_t nnpmt = tof_event->npmt();

    Float_t adct[48];
    Float_t tdct[48];
    
    /* 
     * ToFPMT is the PMT related class
     */
    

      for (Int_t ipmt=0; ipmt<tof_event->npmt() ; ipmt++){
        /*
          tof_event->npmt() is the number of PMT with at least a TDC signal
        */
        
        ToFPMT *tofpmt = tof_event->GetToFPMT(ipmt);
        // for each PMT with a signal, tofpmt->adc gives the raw adc
        adct[ipmt]=tofpmt->adc;
        // for each PMT with a signal, tofpmt->tdc_tw gives the tdc after Time-walk correction
        tdct[ipmt]=tofpmt->tdc_tw;
        TestHisto->Fill(adct[2]);       
      }

    
    /*
     * Some useful Methods (Examples):
     */
    
    Int_t nplane = 6;
    Int_t npaddle = 8;
    
    for (Int_t idpl=0; idpl< nplane; idpl++){
        
      /*
       * Method to get the number of hit paddles on a ToF plane.
       * @param plane Plane ID (11, 12, 21, 22, 31, 32) or Plane index (0,1,2,3,4,5).
       * it is evaluated for each event in the run
       */
      Int_t NHit = tof_event->GetNHitPaddles(idpl);            
      //      printf("Number of Hit, idPlane %d %d %d %d\n",NHit,idpl,ii,it);
      
      /**
       * Method to get the plane ID (11 12 21 22 31 32) from the plane index (0 1 2 3 4 5)
       */
      Int_t ToFPlaneID=tof_event->GetToFPlaneID(idpl);
      //      printf("ToFPlaneID, idPlane %d %d\n",ToFPlaneID,idpl);
    }
    
    
    /*
     * Method to know if a given ToF paddle was hit, that is there is a TDC signal 
     * from both PMTs
     * @param plane Plane ID (11, 12, 21, 22, 31, 32) or Plane index (0,1,2,3,4,5).
     * @param paddle_id Paddle ID.
     * @return 1 if the paddle was hit.
     */
    
    for (Int_t idpad=0; idpad< npaddle; idpad++){
      Int_t HitPad = tof_event->HitPaddle(idpl,idpad);
      // printf("Hit Pad %d %d %d\n",HitPad,idpl,idpad);
    }
    
    /**
     * Method to get the plane index (0 1 2 3 4 5) from the plane ID (11 12 21 22 31 32)
     */
    
    Int_t plane_id=11;
    Int_t ToFPlaneIndex = tof_event->GetToFPlaneIndex(plane_id);
    //    printf("Plane Index %d %d\n",ToFPlaneIndex,plane_id); 
    
    
  } // end loop over events

  TCanvas *BetaRigCanvas = new TCanvas("BetaRigCanvas","BetaRigCanvas", 700, 800);
  BetaRigCanvas->cd();
  BetaRig->Draw();
  
  TCanvas *SCanvas = new TCanvas("SCanvas","SCanvas", 700, 800);
  SCanvas->cd();
  ADChisto->Draw();

  TCanvas *TestCanvas = new TCanvas("TestCanvas","TestCanvas", 700, 800);
  TestCanvas->cd();
  TestHisto->Draw();
}
1	pam-de	1.1	void ToFLevel2Ex(){
2
3			/*
4			*
5			* This script shows how use ToFLevel2 output without using PamLevel2 software
6			* Notice that here no selection on image tracks is applied
7			* All methods and all variables usage are shown
8			*
9			*/
10
11
12			/* Some plot just as example */
13
14			// Beta versus Rigidity
15			TH2F* BetaRig= new TH2F("BetaRig","Beta versus Rigidity",1000,0.1,10.,520,-1.3,1.3);
16
17			// dEdx == adc_c measurement
18			TH1F* ADChisto= new TH1F("ADChisto","ADChisto",10,0.,20.);
19
20			TH1F* TestHisto = new TH1F("TestHisto","TestHisto",500,0.,5000.);
21
22			gStyle->SetOptStat(111111);
23
24			TrkLevel2* trk_event = new TrkLevel2();
25			ToFLevel2* tof_event = new ToFLevel2();
26
27			TChain *T = new TChain("Tracker");
28			TChain *C = new TChain("ToF");
29
30			T->Add("./8212.Level2.root");
31			C->Add("./8212.Level2.root");
32
33			T->SetBranchAddress("TrkLevel2", &trk_event); // set tracker event adrss
34			C->SetBranchAddress("ToFLevel2", &tof_event); // set ToF event adrss
35			T->AddFriend(C); // make the trees friends
36
37			Int_t nevent = T->GetEntries();
38			cout << " Events in Tracker Tree " << nevent << endl;
39			Int_t ntofevent = C->GetEntries();
40			cout << " Events in ToF Tree " << ntofevent << endl;
41
42			int j = 0;
43			int k = 0;
44
45			// for (Int_t ii=0; ii<nevent;ii++){
46			for (Int_t ii=0; ii<1000;ii++){
47
48			T->GetEntry(ii);
49
50			/*
51			* infos in ToFLevel2 class
52			*
53			*/
54
55			// j flag: it's a decoded value (array wioth 6 elements);
56			// for each layer, it summed up if there
57			// are more than one hit per layer
58			// tof11_j = tof11_j + 2**(i-1)
59
60			for(Int_t i=0; i<6; i++)
61			Int_t tof11_j = tof_event->tof_j_flag[i];
62
63			/*
64			* if you need informations from ToF and Tracker,
65			* you have to read both the detector classes
66			*/
67
68			/* ToFTrkVar is the track related class */
69
70			for (Int_t it=0; it<tof_event->ntrk() ; it++){
71
72			ToFTrkVar *tof = tof_event->GetToFTrkVar(it);
73
74			/* trkseqno = index to get ToF alone or ToF+Tracker informations */
75
76			/*
77			* trkseqno ==-1 -> ToF alone informations
78			* trkseqno !=-1 correspond to the Tracker track index
79			*/
80
81			// cout << " Index " << tof->trkseqno << endl;
82
83			/* Get Tracker information if it exist */
84
85			Int_t trkgood = 0;
86
87			if(tof->trkseqno != -1){
88			TrkTrack *trk = trk_event->GetStoredTrack(tof->trkseqno);
89
90			/* Select "good" Tracker tracks" */
91
92			if(trk->chi2 > 0 &&
93			trk->chi2 < 100 &&
94			trk->GetNX() >= 4 &&
95			trk->GetNY() >= 3 &&
96			trk->xgood[0] &&
97			(trk->xgood[5] \|\| trk->xgood[4]) &&
98			trk->al[4] != 0.)
99			{
100
101			trkgood = 1;
102
103			}
104
105			}
106
107
108			// Beta measurement based on ToF alone
109
110			/*
111			* beta is an array with 13 elements;
112			* 12 correspond to the several planes combinations as described below;
113			* the last one is a mean value
114			*/
115
116			/*
117			*
118			* S11 - S31 = tof->beta[0]
119			* S11 - S32 = tof->beta[1]
120			* S12 - S31 = tof->beta[2]
121			* S12 - S32 = tof->beta[3]
122			* S21 - S31 = tof->beta[4]
123			* S21 - S32 = tof->beta[5]
124			* S22 - S31 = tof->beta[6]
125			* S22 - S32 = tof->beta[7]
126			* S11 - S21 = tof->beta[8]
127			* S11 - S22 = tof->beta[9]
128			* S12 - S21 = tof->beta[10]
129			* S12 - S22 = tof->beta[11]
130			*
131			*/
132
133
134			Int_t ll = 0;
135			Int_t mm = 0;
136
137			/*
138			* to get the same information for tracks from Tracker set:
139			* if(tof->trkseqno==0) for the first tracker track;
140			* if(tof->trkseqno==1) for the second tracker track;
141			*/
142
143			if(tof->trkseqno == -1){
144			for (Int_t k=0; k<13 ; k++){
145			Float_t Beta = tof->beta[k];
146			// cout << "Beta " << Beta << endl;
147			}
148			}
149
150
151			/*
152			* read the pmtid for the tdc used in evaluate beta
153			* for the first tracker track
154			*/
155
156			Float_t tdcflagm[4][12];
157
158			for (Int_t j=0; j<4; j++){
159			for (Int_t k=0; k<12; k++){
160			tdcflagm[j][k]=0;
161			}
162			}
163
164
165
166			if(tof->trkseqno == 0){
167			// npmttdc = number of pmt used for beta evaluation
168			for (Int_t ipmtt=0; ipmtt<tof->npmttdc; ipmtt++){
169			// you can read the pmtid for the tdc used in evaluate beta
170			Int_t pmttdc = tof->pmttdc[ipmtt];
171			// printf("pmttdc %d\n",pmttdc);
172			Int_t tdcflag = tof->tdcflag[ipmtt];
173			if(tdcflag!=0) {
174			// cout << " TDC " << tof->tdcflag[ipmtt] << " " << tdcflag << " " << pmttdc << endl;
175			ll=0;
176			mm=0;
177			tof_event->GetPMTIndex(pmttdc,ll,mm);
178			cout<<"pmttdc tdcflag "<<pmttdc<<" "<<tdcflag<<endl;
179			tdcflagm[mm][ll]= tdcflag;
180			}
181
182			/*
183			* Method to get Plane Index from a pmtid;
184			* here is shown for a pmtid corresponding to
185			* the tdc used in beta evaluation
186			*/
187			Int_t pmt_plane=tof_event->GetPlaneIndex(pmttdc);
188
189			}
190			}
191
192
193			ll = 0;
194			mm = 0;
195
196			/*
197			* dEdx for each PMT with signal;
198			* this value coprresponds to the signal from a single pmt
199			*/
200
201			Float_t adc2[4][12];
202
203			if(tof->trkseqno == 0){
204			// npmtadc = number of pmt used for dEdx evaluation
205			for (Int_t ipmta=0; ipmta<tof->npmtadc; ipmta++){
206			// dedx = adc_c
207			Float_t dEdx = tof->dedx[ipmta];
208			// printf("dEdx %f %f\n",tof->dedx[ipmta],dEdx);
209
210			// you can read the pmtid for the adc used in evaluate dedx=adc_c
211			Int_t pmtadc = tof->pmtadc[ipmta];
212			// printf("pmtadc %d\n",tof->pmtadc[ipmta]);
213
214			Int_t adcflag = tof->adcflag[ipmta];
215			// cout << " ADC " << adcflag << " " << pmtadc << " " << dEdx << endl;
216
217
218			if(ipmta == 1) {
219			ADChisto->Fill(tof->dedx[ipmta]);
220			}
221
222
223			/*
224			to get pmt index in terms of matrix index
225			from pmtid
226			*/
227			tof_event->GetPMTIndex(pmtadc,ll,mm);
228			adc2[mm][ll] = tof->dedx[ipmta];
229
230
231			/*
232			to get pmt index from matrix index
233			*/
234			tof_event->GetPMTid(ll,mm);
235			Int_t ind = tof_event->GetPMTid(ll,mm);
236
237
238			/*
239			to get pmt name from pmtid
240			*/
241			tof_event->GetPMTName(pmtadc);
242			// cout << tof_event->GetPMTName(pmtadc) << endl;
243
244			}
245			}
246
247			// Position measurement based on ToF hits
248
249			/*
250			* to get the same information for tracks from Tracker set:
251			* if(tof->trkseqno==0) for the first tracker track;
252			* if(tof->trkseqno==1) for the second tracker track;
253			*/
254
255			if(tof->trkseqno==-1){
256			for (Int_t j=0; j<3; j++){
257			Float_t xtofpos = tof->xtofpos[j];
258			Float_t ytofpos = tof->ytofpos[j];
259			// printf("xtofpos %f %f %d\n",xtofpos,tof->xtofpos[j],ii);
260			// printf("ytofpos %f %f %d\n",ytofpos,tof->ytofpos[j],ii);
261			}
262			}
263
264			// Beta versus Rigidity
265
266			/*
267			* for the first tracker track tof->trkseqno == 0
268			* for the second tracker track tof->trkseqno == 1
269			* and so on...
270			*/
271
272			if(tof->trkseqno == 0 && trkgood==1){
273			BetaRig->Fill( trk->GetRigidity(), tof->beta[4]);
274			}
275
276
277			/*
278			* Method to get the dEdx on a ToF plane.
279			* It is evaluated as sum of all adc signals on the plane
280			* after corrections; its usage is not advised;
281			* This method will be modified in the next ToFLevel2 release
282			*/
283
284			if(tof->trkseqno == 0 && trkgood==1){
285			for (Int_t plane=0; plane<13; plane++){
286			Float_t MethoddEdx=tof_event->GetdEdx(it,plane); // it is the index for
287			// tof_event->ntrk()
288			}
289			}
290
291
292			// fill adc and tdc using getmatrix
293			Float_t adc[4][12];
294			Float_t tdc[4][12];
295			tof_event->GetMatrix(it,adc,tdc); // it is the index for tof_event->ntrk$
296
297			for (Int_t j=0; j<4; j++){
298			for (Int_t k=0; k<12; k++){
299			Int_t ind = tof_event->GetPMTid(j,k);
300
301			if (tdc[j][k] < 4095) cout<<ind<<" "<<tdc[j][k]<<" "<<tdcflagm[j][k]<<endl;
302			}
303			}
304
305			cout<<"==================="<<endl;
306
307
308
309			} // end loop over tracks
310
311			Int_t nnpmt = tof_event->npmt();
312
313			Float_t adct[48];
314			Float_t tdct[48];
315
316			/*
317			* ToFPMT is the PMT related class
318			*/
319
320
321			for (Int_t ipmt=0; ipmt<tof_event->npmt() ; ipmt++){
322			/*
323			tof_event->npmt() is the number of PMT with at least a TDC signal
324			*/
325
326			ToFPMT *tofpmt = tof_event->GetToFPMT(ipmt);
327			// for each PMT with a signal, tofpmt->adc gives the raw adc
328			adct[ipmt]=tofpmt->adc;
329			// for each PMT with a signal, tofpmt->tdc_tw gives the tdc after Time-walk correction
330			tdct[ipmt]=tofpmt->tdc_tw;
331			TestHisto->Fill(adct[2]);
332			}
333
334
335			/*
336			* Some useful Methods (Examples):
337			*/
338
339			Int_t nplane = 6;
340			Int_t npaddle = 8;
341
342			for (Int_t idpl=0; idpl< nplane; idpl++){
343
344			/*
345			* Method to get the number of hit paddles on a ToF plane.
346			* @param plane Plane ID (11, 12, 21, 22, 31, 32) or Plane index (0,1,2,3,4,5).
347			* it is evaluated for each event in the run
348			*/
349			Int_t NHit = tof_event->GetNHitPaddles(idpl);
350			// printf("Number of Hit, idPlane %d %d %d %d\n",NHit,idpl,ii,it);
351
352			/**
353			* Method to get the plane ID (11 12 21 22 31 32) from the plane index (0 1 2 3 4 5)
354			*/
355			Int_t ToFPlaneID=tof_event->GetToFPlaneID(idpl);
356			// printf("ToFPlaneID, idPlane %d %d\n",ToFPlaneID,idpl);
357			}
358
359
360			/*
361			* Method to know if a given ToF paddle was hit, that is there is a TDC signal
362			* from both PMTs
363			* @param plane Plane ID (11, 12, 21, 22, 31, 32) or Plane index (0,1,2,3,4,5).
364			* @param paddle_id Paddle ID.
365			* @return 1 if the paddle was hit.
366			*/
367
368			for (Int_t idpad=0; idpad< npaddle; idpad++){
369			Int_t HitPad = tof_event->HitPaddle(idpl,idpad);
370			// printf("Hit Pad %d %d %d\n",HitPad,idpl,idpad);
371			}
372
373			/**
374			* Method to get the plane index (0 1 2 3 4 5) from the plane ID (11 12 21 22 31 32)
375			*/
376
377			Int_t plane_id=11;
378			Int_t ToFPlaneIndex = tof_event->GetToFPlaneIndex(plane_id);
379			// printf("Plane Index %d %d\n",ToFPlaneIndex,plane_id);
380
381
382
383			} // end loop over events
384
385			TCanvas *BetaRigCanvas = new TCanvas("BetaRigCanvas","BetaRigCanvas", 700, 800);
386			BetaRigCanvas->cd();
387			BetaRig->Draw();
388
389			TCanvas *SCanvas = new TCanvas("SCanvas","SCanvas", 700, 800);
390			SCanvas->cd();
391			ADChisto->Draw();
392
393			TCanvas *TestCanvas = new TCanvas("TestCanvas","TestCanvas", 700, 800);
394			TestCanvas->cd();
395			TestHisto->Draw();
396			}