/[PAMELA software]/DarthVader/ToFLevel2/src/ToFLevel2.cpp
ViewVC logotype

Diff of /DarthVader/ToFLevel2/src/ToFLevel2.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.16 by mocchiut, Mon Apr 30 15:46:30 2007 UTC revision 1.43 by mocchiut, Thu Feb 26 11:27:35 2015 UTC
# Line 1  Line 1 
1  /**  /**
2   * \file ToFLevel2.cpp   * \file ToFLevel2.cpp
3   * \author Gianfranca DeRosa, Wolfgang Menn   * \author Gianfranca DeRosa, Wolfgang Menn
4     *
5     * WM dec 2008: Description of "GetdEdx" changed
6     * WM dec 2008: "GetdEdxPaddle" modified: Now includes saturation limit
7     *              PMTs higher than the saturation limit are not used for dEdx
8     * WM apr 2009: bug found by Nicola in method "GetPaddlePlane"
9   */   */
10    
 #include <TObject.h>  
11  #include <ToFLevel2.h>  #include <ToFLevel2.h>
 #include <iostream>  
12  using namespace std;  using namespace std;
13  ClassImp(ToFPMT);  ClassImp(ToFPMT);
14    ClassImp(ToFdEdx);
15    ClassImp(ToFGeom);
16  ClassImp(ToFTrkVar);  ClassImp(ToFTrkVar);
17  ClassImp(ToFLevel2);  ClassImp(ToFLevel2);
18    
# Line 15  ToFPMT::ToFPMT(){ Line 20  ToFPMT::ToFPMT(){
20    pmt_id = 0;    pmt_id = 0;
21    adc = 0.;    adc = 0.;
22    tdc_tw = 0.;    tdc_tw = 0.;
23      tdc = 0.;
24      l0flag_adc = 0.;
25      l0flag_tdc = 0.;
26  }  }
27    
28  ToFPMT::ToFPMT(const ToFPMT &t){  ToFPMT::ToFPMT(const ToFPMT &t){
29    pmt_id = t.pmt_id;    pmt_id = t.pmt_id;
30    adc = t.adc;    adc = t.adc;
31    tdc_tw = t.tdc_tw;    tdc_tw = t.tdc_tw;
32      tdc = t.tdc;
33  }  }
34    
35  void ToFPMT::Clear(){  void ToFPMT::Clear(Option_t *t){
36    pmt_id = 0;    pmt_id = 0;
37    adc = 0.;    adc = 0.;
38    tdc_tw = 0.;    tdc_tw = 0.;
39      tdc = 0.;
40  }  }
41    
42    
# Line 50  ToFTrkVar::ToFTrkVar() { Line 60  ToFTrkVar::ToFTrkVar() {
60    //    //
61  };  };
62    
63  void ToFTrkVar::Clear() {  void ToFTrkVar::Clear(Option_t *t) {
64    trkseqno = 0;    trkseqno = 0;
65    npmttdc = 0;    npmttdc = 0;
66    npmtadc = 0;    npmtadc = 0;
# Line 103  void ToFLevel2::Set(){//ELENA Line 113  void ToFLevel2::Set(){//ELENA
113      if(!PMT)PMT = new TClonesArray("ToFPMT",12); //ELENA      if(!PMT)PMT = new TClonesArray("ToFPMT",12); //ELENA
114      if(!ToFTrk)ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA      if(!ToFTrk)ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA
115  }//ELENA  }//ELENA
116    //--------------------------------------
117    //
118    //
119    //--------------------------------------
120    void ToFLevel2::SetTrackArray(TClonesArray *track){//ELENA
121        if(track && strcmp(track->GetClass()->GetName(),"ToFTrkVar")==0){
122            if(ToFTrk)ToFTrk->Clear("C");
123            ToFTrk = track;
124        }
125    }
126    
127  void ToFLevel2::Clear(){  void ToFLevel2::Clear(Option_t *t){
128    //    //
129    if(ToFTrk)ToFTrk->Delete(); //ELENA    if(ToFTrk)ToFTrk->Delete(); //ELENA
130    if(PMT)PMT->Delete(); //ELENA    if(PMT)PMT->Delete(); //ELENA
131    memset(tof_j_flag, 0, 6*sizeof(Int_t));    memset(tof_j_flag, 0, 6*sizeof(Int_t));
132    unpackError = 0;    unpackError = 0;
133      unpackWarning = 0;
134    //    //
135  };  };
136    
137  void ToFLevel2::Delete(){ //ELENA  void ToFLevel2::Delete(Option_t *t){ //ELENA
138    //    //
139    if(ToFTrk){    if(ToFTrk){
140        ToFTrk->Delete(); //ELENA        ToFTrk->Delete(); //ELENA
# Line 140  ToFTrkVar *ToFLevel2::GetToFTrkVar(Int_t Line 161  ToFTrkVar *ToFLevel2::GetToFTrkVar(Int_t
161    return toftrack;    return toftrack;
162  }  }
163    
164    /**
165     * Retrieves the tof track matching the seqno-th tracker stored track.
166     *
167     */
168    ToFTrkVar *ToFLevel2::GetToFStoredTrack(int seqno){
169    
170      if( ntrk()==0 ){
171        printf("ToFLevel2::GetToFStoredTrack(int) : requested tracker SeqNo %i but no ToFrimeter tracks are stored\n",seqno);
172        return NULL;
173      };
174      
175      ToFTrkVar *c = 0;
176      Int_t it_tof=0;
177        
178      do {
179        c = GetToFTrkVar(it_tof);
180        it_tof++;
181      } while( c && seqno != c->trkseqno && it_tof < ntrk());      
182      
183      if(!c || seqno != c->trkseqno){
184        c = 0;
185        if(seqno!=-1 ) printf("ToFLevel2::GetToFStoredTrack(int) : requested tracker SeqNo %i does not match ToFrimeter stored tracks\n",seqno);
186      };
187      return c;
188        
189    }
190    
191    
192  ToFPMT *ToFLevel2::GetToFPMT(Int_t ihit){  ToFPMT *ToFLevel2::GetToFPMT(Int_t ihit){
193    //        //    
194    if(ihit >= npmt()){    if(ihit >= npmt()){
# Line 203  ToFPMT *ToFLevel2::GetToFPMT(Int_t ihit) Line 252  ToFPMT *ToFLevel2::GetToFPMT(Int_t ihit)
252         false) return true;         false) return true;
253      else return false;      else return false;
254  };  };
255    
256  /**  /**
257   * Method to get the number of hit paddles on a ToF plane.   * Strict method to get the number of hit paddles on a ToF plane.
258     * The method uses "HitPaddle" which checks if there is a TDC signal
259     * from both PMTs.
260   * @param plane Plane ID (11, 12, 21, 22, 31, 32) or Plane index (0,1,2,3,4,5).   * @param plane Plane ID (11, 12, 21, 22, 31, 32) or Plane index (0,1,2,3,4,5).
261   */   */
262  Int_t ToFLevel2::GetNHitPaddles(Int_t plane){  Int_t ToFLevel2::GetNHitPaddles(Int_t plane){
# Line 213  Int_t ToFLevel2::GetNHitPaddles(Int_t pl Line 265  Int_t ToFLevel2::GetNHitPaddles(Int_t pl
265      return npad;      return npad;
266  };  };
267    
268    /**
269     * Optional method to get the number of hit paddles on a ToF plane.
270     * The method does NOT check if there is a signal from both PMTs, it only
271     * checks if there is some PMT signal in a paddle
272     * @param plane Plane ID (11, 12, 21, 22, 31, 32) or Plane index (0,1,2,3,4,5).
273     */
274    Int_t ToFLevel2::GetTrueNHitPaddles(Int_t plane){
275        Int_t npad=0;
276        TClonesArray* Pmt = this->PMT;
277        int paddle[24];
278        memset(paddle,0, 24*sizeof(int));
279        for(int i=0; i<Pmt->GetEntries(); i++) {  //loop per vedere quale TOF è colpito
280          ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
281          int pplane = -1;
282          int ppaddle = -1;
283          GetPMTPaddle(pmthit->pmt_id,pplane,ppaddle);
284          if ( pplane == plane ) paddle[ppaddle]++;
285        }
286        for(int i=0;i<24;i++) if ( paddle[i]>0 ) npad++;
287    
288        return npad;
289    };
290    
291    //new, wm Feb 15
292    //wm Nov 08
293  //gf Apr 07  //gf Apr 07
294  /**  /**
295   * Method to get the mean dEdx from a given ToF plane. This current version   * Method to get the mean dEdx from a ToF layer
296   * is just summing up all PMT signals, which will not give proper results,   * By definition there should be PMTs with dEdx values only in one paddle of a layer
297   *  and needs a revision.   * (the paddle hitted by the track), this method looks for the hitted paddle
298     * and gives the mean dEdx of that paddle as the output
299     * The method was modified for the "ToF-standalone" part in february 2015
300     * The "adcfl" option is not very useful (an artificial dEdx is per
301     * definition= 1 mip and not a real measurement), anyway left in the code
302   * @param notrack Track Number   * @param notrack Track Number
303   * @param plane Plane index (0,1,2,3,4,5)   * @param plane Plane index (0,1,2,3,4,5)
304   * @param adcflag in the plane (100<-> independent of the adcflag; !=0&&!=100 <-> at least one PMT with adcflag!=0; )   * @param adcflag in the plane (100<-> independent of the adcflag; !=0&&!=100 <-> at least one PMT with adcflag!=0; )
305   */   */
306  Float_t ToFLevel2::GetdEdx(Int_t notrack, Int_t plane, Int_t adcfl){  Float_t ToFLevel2::GetdEdx(Int_t notrack, Int_t plane, Int_t adcfl){
307      ToFTrkVar *trk = GetToFTrkVar(notrack);
308      return this->GetdEdx(trk, plane, adcfl);
309    }
310    
311    //new, wm Feb 15
312    //wm Nov 08
313    //gf Apr 07
314    /**
315     * Method to get the mean dEdx from a ToF layer
316     * By definition there should be PMTs with dEdx values only in one paddle of a layer
317     * (the paddle hitted by the track), this method looks for the hitted paddle
318     * and gives the mean dEdx of that paddle as the output
319     * The method was modified for the "ToF-standalone" part in february 2015
320     * The "adcfl" option is not very useful (an artificial dEdx is per
321     * definition= 1 mip and not a real measurement), anyway left in the code
322     * @param trk Pointer to TofTrkVar class
323     * @param plane Plane index (0,1,2,3,4,5)
324     * @param adcflag in the plane (100<-> independent of the adcflag; !=0&&!=100 <-> at least one PMT with adcflag!=0; )
325     */
326    Float_t ToFLevel2::GetdEdx(ToFTrkVar *trk, Int_t plane, Int_t adcfl){
327      
328    Float_t dedx = 0.;    Float_t dedx = 0.;
329    Float_t PadEdx =0.;    Float_t PadEdx =0.;
330    Int_t SatWarning;    Int_t SatWarning;
331    Int_t pad=-1;    Int_t pad=-1;
332    //    //
   ToFTrkVar *trk = GetToFTrkVar(notrack);  
333    if(!trk) return 0; //ELENA    if(!trk) return 0; //ELENA
334    //    //
335    for (Int_t ii=0; ii<GetNPaddle(plane); ii++){    // ToF standalone part
     Int_t paddleid=ii;  
     pad = GetPaddleid(plane,paddleid);  
     GetdEdxPaddle(notrack, pad, adcfl, PadEdx, SatWarning);  
     dedx += PadEdx;  
   };  
336    //    //
337      if ( trk->trkseqno == -1 ){
338        
339        ToFTrkVar *t_tof = trk;
340        
341        // Find the hitted paddle  (two good TDC values) using the tof_j_flag (from tofl2com.for)
342        
343        Int_t Ipaddle=-1;
344        // if tof_j_flag == 0: no paddle was hitted. Otherwise decode tof_j_flag to get the paddle
345        if (this->tof_j_flag[plane] > 0)  Ipaddle = (Int_t)log2(this->tof_j_flag[plane]) ;
346        
347        Ipaddle =  (Int_t)log2(this->tof_j_flag[plane]) ;
348        
349        // Get the dEdx of this paddle using "GetdEdxPaddle"
350        if (Ipaddle>-1) {
351          Int_t pad = GetPaddleid(plane,Ipaddle);
352          GetdEdxPaddle(notrack, pad, adcfl, PadEdx, SatWarning);
353          dedx = PadEdx;
354        }
355        
356        // If there was no correct hitted paddle, but there was one (and only one) paddle with some
357        // PMT entries in the PMT-class (found with "GetTrueNHitPaddles", use the dEdx of this paddle
358        
359        if ((Ipaddle<0) && (GetTrueNHitPaddles(plane)==1)) {
360          // find the paddle by looping over the paddles in each layer
361          // since GetTrueNHitPaddles==1 this is OK
362          for (Int_t ii=0; ii<GetNPaddle(plane); ii++){
363            Int_t paddleid=ii;
364            Int_t pad = GetPaddleid(plane,paddleid);
365            GetdEdxPaddle(notrack, pad, adcfl, PadEdx, SatWarning);
366            dedx += PadEdx;
367          }
368        }
369      } else {
370        // track dependent dEdx: simple, there will be only one paddle hitted in    each layer
371        // so just loop over the paddles in each layer
372        for (Int_t ii=0; ii<GetNPaddle(plane); ii++){
373          Int_t paddleid=ii;
374          pad = GetPaddleid(plane,paddleid);
375          GetdEdxPaddle(notrack, pad, adcfl, PadEdx, SatWarning);
376          dedx += PadEdx;
377        }
378      }
379      //
380    return(dedx);    return(dedx);
381  };  }
382    
383  /**  /**
384   * Method to fill the ADC_C 4x12 matrix with the dEdx values and the TDC 4x12 matrix   * Method to fill the ADC_C 4x12 matrix with the dEdx values and the TDC 4x12 matrix
# Line 378  void ToFLevel2::GetPMTIndex(Int_t ind, I Line 515  void ToFLevel2::GetPMTIndex(Int_t ind, I
515    
516    
517    
518    //  wm Nov 08 revision - saturation values included
519  /// gf Apr 07  /// gf Apr 07
   
520  /**  /**
521   * Method to get the dEdx from a given ToF paddle.   * Method to get the dEdx from a given ToF paddle.
522     * If two PMTs are good, the mean dEdx of both PMTs is taken, otherwise
523     * just the dEdx of the "good" PMT. If both PMTs are above saturation => dEdx=1000
524   * @param notrack Track Number   * @param notrack Track Number
525   * @param Paddle index (0,1,...,23).   * @param Paddle index (0,1,...,23).
526   * @param adcflag in the paddle (100<-> independent of the adcflag; !=0&&!=100 <-> at least one PMT with adcflag!=0; )   * @param adcflag in the paddle (100<-> independent of the adcflag; !=0&&!=100 <-> at least one PMT with adcflag!=0; )
# Line 391  void ToFLevel2::GetPMTIndex(Int_t ind, I Line 529  void ToFLevel2::GetPMTIndex(Int_t ind, I
529   */   */
530  void ToFLevel2::GetdEdxPaddle(Int_t notrack, Int_t paddleid, Int_t adcfl, Float_t &PadEdx, Int_t &SatWarning){  void ToFLevel2::GetdEdxPaddle(Int_t notrack, Int_t paddleid, Int_t adcfl, Float_t &PadEdx, Int_t &SatWarning){
531    
532      /*
533        Float_t  PMTsat[48] = {
534        3162.14, 3165.48, 3153.85, 3085.73, 3089.65, 3107.64, 3097.52, 3078.37,
535        3130.05, 3087.07, 3112.22, 3102.92, 3080.58, 3092.55, 3087.94, 3125.03,
536        3094.09, 3143.16, 3125.51, 3181.27, 3092.09, 3124.98, 3069.3, 3095.53,
537        3097.11, 3133.53, 3114.73, 3113.01, 3091.19, 3097.99, 3033.84, 3134.98,
538        3081.37, 3111.04, 3066.77, 3108.17, 3133, 3111.06, 3052.52, 3140.66,
539        3106.33, 3094.85, 3150.85, 3118.8, 3096.24, 3118.47,3111.36, 3117.11 } ;
540      */
541    
542      // new values from Napoli dec 2008
543      Float_t  PMTsat[48] = {
544        3176.35,3178.19,3167.38,3099.73,3117.00,3126.29,3111.44,3092.27,
545        3146.48,3094.41,3132.13,3115.37,3099.32,3110.97,3111.80,3143.14,
546        3106.72,3153.44,3136.00,3188.96,3104.73,3140.45,3073.18,3106.62,
547        3112.48,3146.92,3127.24,3136.52,3109.59,3112.89,3045.15,3147.26,
548        3095.92,3121.05,3083.25,3123.62,3150.92,3125.30,3067.60,3160.18,
549        3119.36,3108.92,3164.77,3133.64,3111.47,3131.98,3128.87,3135.56 };
550    
551      for (Int_t i=0; i<48;i++) PMTsat[i] = PMTsat[i] - 5.;  // safety margin
552    
553    
554    PadEdx = 0.;    PadEdx = 0.;
555    SatWarning = 1000;    //  SatWarning = 1000;
556      SatWarning = 0;   // 0=good, increase for each bad PMT
557    
558    Float_t dEdx[48] = {0};    Float_t dEdx[48] = {0};
559    Int_t pmt_id = -1;    Int_t pmt_id = -1;
# Line 424  void ToFLevel2::GetdEdxPaddle(Int_t notr Line 585  void ToFLevel2::GetdEdxPaddle(Int_t notr
585        adcraw[pmtright] = pmt->adc;        adcraw[pmtright] = pmt->adc;
586      }      }
587    }    }
588    
589        
590    for (Int_t i=0; i<trk->npmtadc; i++){    for (Int_t i=0; i<trk->npmtadc; i++){
591    
# Line 436  void ToFLevel2::GetdEdxPaddle(Int_t notr Line 598  void ToFLevel2::GetdEdxPaddle(Int_t notr
598      }      }
599    }    }
600    
601    if( adcraw[pmtleft] >3000 || adcraw[pmtright] >3000)SatWarning=1;  
602      //  if( adcraw[pmtleft] >3000 || adcraw[pmtright] >3000)SatWarning=1;  //old version
603    
604      // Increase SatWarning Counter for each PMT>Sat
605      if( adcraw[pmtleft] > PMTsat[pmtleft])SatWarning++;  
606      if( adcraw[pmtright] > PMTsat[pmtright])SatWarning++;
607    
608      // if ADC  > sat set dEdx=1000
609      if( adcraw[pmtleft] > PMTsat[pmtleft]) dEdx[pmtleft] = 1000.;
610      if( adcraw[pmtright] > PMTsat[pmtright]) dEdx[pmtright] = 1000. ;
611    
612      // if two PMT are good, take mean dEdx, otherwise only the good dEdx
613      if(dEdx[pmtleft]<1000 && dEdx[pmtright]<1000) PadEdx = (dEdx[pmtleft]+dEdx[pmtright])*0.5;
614      if(dEdx[pmtleft]==1000 && dEdx[pmtright]<1000) PadEdx = dEdx[pmtright];  
615      if(dEdx[pmtleft]<1000 && dEdx[pmtright]==1000) PadEdx = dEdx[pmtleft];
616      
617    };
618    
619    //
620    //  wm Nov 08 revision - saturation values included
621    /// gf Apr 07
622    /**
623     * Method to get the dEdx from a given ToF paddle.
624     * If two PMTs are good, the mean dEdx of both PMTs is taken, otherwise
625     * just the dEdx of the "good" PMT. If both PMTs are above saturation => dEdx=1000
626     * @param notrack Track Number
627     * @param Paddle index (0,1,...,23).
628     * @param adcflag in the paddle (100<-> independent of the adcflag; !=0&&!=100 <-> at least one PMT with adcflag!=0; )
629     * @param PadEdx dEdx from a given ToF paddle
630     * @param SatWarning 1 if the PMT ios near saturation region (adcraw ~3000)
631     */
632    void ToFLevel2::GetdEdxPaddle(ToFTrkVar *trk, Int_t paddleid, Int_t adcfl, Float_t &PadEdx, Int_t &SatWarning){
633    
634      /*
635        Float_t  PMTsat[48] = {
636        3162.14, 3165.48, 3153.85, 3085.73, 3089.65, 3107.64, 3097.52, 3078.37,
637        3130.05, 3087.07, 3112.22, 3102.92, 3080.58, 3092.55, 3087.94, 3125.03,
638        3094.09, 3143.16, 3125.51, 3181.27, 3092.09, 3124.98, 3069.3, 3095.53,
639        3097.11, 3133.53, 3114.73, 3113.01, 3091.19, 3097.99, 3033.84, 3134.98,
640        3081.37, 3111.04, 3066.77, 3108.17, 3133, 3111.06, 3052.52, 3140.66,
641        3106.33, 3094.85, 3150.85, 3118.8, 3096.24, 3118.47,3111.36, 3117.11 } ;
642      */
643    
644      // new values from Napoli dec 2008
645      Float_t  PMTsat[48] = {
646        3176.35,3178.19,3167.38,3099.73,3117.00,3126.29,3111.44,3092.27,
647        3146.48,3094.41,3132.13,3115.37,3099.32,3110.97,3111.80,3143.14,
648        3106.72,3153.44,3136.00,3188.96,3104.73,3140.45,3073.18,3106.62,
649        3112.48,3146.92,3127.24,3136.52,3109.59,3112.89,3045.15,3147.26,
650        3095.92,3121.05,3083.25,3123.62,3150.92,3125.30,3067.60,3160.18,
651        3119.36,3108.92,3164.77,3133.64,3111.47,3131.98,3128.87,3135.56 };
652    
653      for (Int_t i=0; i<48;i++) PMTsat[i] = PMTsat[i] - 5.;  // safety margin
654    
655    
656      PadEdx = 0.;
657      //  SatWarning = 1000;
658      SatWarning = 0;   // 0=good, increase for each bad PMT
659    
660      Float_t dEdx[48] = {0};
661      Int_t pmt_id = -1;
662      Float_t adcraw[48];
663      //
664      if(!trk) return; //ELENA
665      //
666    
667      Int_t pmtleft=-1;
668      Int_t pmtright=-1;
669      GetPaddlePMT(paddleid, pmtleft, pmtright);
670    
671      adcraw[pmtleft] = 4095;
672      adcraw[pmtright] = 4095;
673    
674      
675      for (Int_t jj=0; jj<npmt(); jj++){
676            
677    if(dEdx[pmtleft]!=0 && dEdx[pmtright]!=0){      ToFPMT *pmt = GetToFPMT(jj);
678      PadEdx = (dEdx[pmtleft]+dEdx[pmtright])*0.5;      if(!pmt)break; //ELENA
679    }      
680    if(dEdx[pmtleft]==0 && dEdx[pmtright]!=0){      pmt_id = pmt->pmt_id;
681      PadEdx = dEdx[pmtright];      if(pmt_id==pmtleft){
682          adcraw[pmtleft] = pmt->adc;
683        }
684        
685        if(pmt_id==pmtright){
686          adcraw[pmtright] = pmt->adc;
687        }
688    }    }
689    if(dEdx[pmtleft]!=0 && dEdx[pmtright]==0){  
690      PadEdx = dEdx[pmtleft];    
691      for (Int_t i=0; i<trk->npmtadc; i++){
692    
693        if((trk->adcflag).At(i)==0 || adcfl==100){
694          if((trk->pmtadc).At(i) == pmtleft)dEdx[pmtleft] = (trk->dedx).At(i);
695          if((trk->pmtadc).At(i) == pmtright)dEdx[pmtright] = (trk->dedx).At(i);
696        }else{
697          if((trk->pmtadc).At(i) == pmtleft)dEdx[pmtleft] = 0.;
698          if((trk->pmtadc).At(i) == pmtright)dEdx[pmtright] = 0.;
699        }
700    }    }
701    
702    
703      //  if( adcraw[pmtleft] >3000 || adcraw[pmtright] >3000)SatWarning=1;  //old version
704    
705      // Increase SatWarning Counter for each PMT>Sat
706      if( adcraw[pmtleft] > PMTsat[pmtleft])SatWarning++;  
707      if( adcraw[pmtright] > PMTsat[pmtright])SatWarning++;
708    
709      // if ADC  > sat set dEdx=1000
710      if( adcraw[pmtleft] > PMTsat[pmtleft]) dEdx[pmtleft] = 1000.;
711      if( adcraw[pmtright] > PMTsat[pmtright]) dEdx[pmtright] = 1000. ;
712    
713      // if two PMT are good, take mean dEdx, otherwise only the good dEdx
714      if(dEdx[pmtleft]<1000 && dEdx[pmtright]<1000) PadEdx = (dEdx[pmtleft]+dEdx[pmtright])*0.5;
715      if(dEdx[pmtleft]==1000 && dEdx[pmtright]<1000) PadEdx = dEdx[pmtright];  
716      if(dEdx[pmtleft]<1000 && dEdx[pmtright]==1000) PadEdx = dEdx[pmtleft];
717        
   return;  
718  };  };
 //  
   
719    
720  // gf Apr 07  // gf Apr 07
721    
# Line 505  TString ToFLevel2::GetPMTName(Int_t ind) Line 769  TString ToFLevel2::GetPMTName(Int_t ind)
769        
770  };  };
771    
772    // wm jun 08
 // gf Apr 07  
773  Int_t ToFLevel2::GetPaddleIdOfTrack(Float_t xtr, Float_t ytr, Int_t plane){  Int_t ToFLevel2::GetPaddleIdOfTrack(Float_t xtr, Float_t ytr, Int_t plane){
774    return GetPaddleIdOfTrack(xtr ,ytr ,plane, 0.4);
775    }
776    
777    // gf Apr 07
778    Int_t ToFLevel2::GetPaddleIdOfTrack(Float_t xtr, Float_t ytr, Int_t plane, Float_t margin){
779      
780    Double_t xt,yt,xl,xh,yl,yh;    Double_t xt,yt,xl,xh,yl,yh;
781        
782    Float_t tof11_x[8] = {-17.85,-12.75,-7.65,-2.55,2.55,7.65,12.75,17.85};    Float_t tof11_x[8] = {-17.85,-12.75,-7.65,-2.55,2.55,7.65,12.75,17.85};
# Line 538  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa Line 806  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa
806      yh =  33.0/2. ;      yh =  33.0/2. ;
807      if ((yt>yl)&&(yt<yh)) {      if ((yt>yl)&&(yt<yh)) {
808        for (Int_t i1=0; i1<8;i1++){        for (Int_t i1=0; i1<8;i1++){
809          xl = tof11_x[i1] - (5.1-0.4)/2. ;          xl = tof11_x[i1] - (5.1-margin)/2. ;
810          xh = tof11_x[i1] + (5.1-0.4)/2. ;          xh = tof11_x[i1] + (5.1-margin)/2. ;
811          if ((xt>xl)&&(xt<xh))  paddleidoftrack=i1;          if ((xt>xl)&&(xt<xh))  paddleidoftrack=i1;
812        }        }
813      }      }
# Line 556  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa Line 824  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa
824            
825      if ((xt>xl)&&(xt<xh)) {      if ((xt>xl)&&(xt<xh)) {
826        for (Int_t i1=0; i1<6;i1++){        for (Int_t i1=0; i1<6;i1++){
827          yl = tof12_y[i1] - (5.5-0.4)/2. ;          yl = tof12_y[i1] - (5.5-margin)/2. ;
828          yh = tof12_y[i1] + (5.5-0.4)/2. ;          yh = tof12_y[i1] + (5.5-margin)/2. ;
829          if ((yt>yl)&&(yt<yh))  paddleidoftrack=i1;          if ((yt>yl)&&(yt<yh))  paddleidoftrack=i1;
830        }        }
831      }      }
# Line 574  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa Line 842  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa
842            
843      if ((xt>xl)&&(xt<xh)) {      if ((xt>xl)&&(xt<xh)) {
844        for (Int_t i1=0; i1<2;i1++){        for (Int_t i1=0; i1<2;i1++){
845          yl = tof21_y[i1] - (7.5-0.4)/2. ;          yl = tof21_y[i1] - (7.5-margin)/2. ;
846          yh = tof21_y[i1] + (7.5-0.4)/2. ;          yh = tof21_y[i1] + (7.5-margin)/2. ;
847          if ((yt>yl)&&(yt<yh))  paddleidoftrack=i1;          if ((yt>yl)&&(yt<yh))  paddleidoftrack=i1;
848        }        }
849      }      }
# Line 591  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa Line 859  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa
859            
860      if ((yt>yl)&&(yt<yh)) {      if ((yt>yl)&&(yt<yh)) {
861        for (Int_t i1=0; i1<2;i1++){        for (Int_t i1=0; i1<2;i1++){
862          xl = tof22_x[i1] - (9.0-0.4)/2. ;          xl = tof22_x[i1] - (9.0-margin)/2. ;
863          xh = tof22_x[i1] + (9.0-0.4)/2. ;          xh = tof22_x[i1] + (9.0-margin)/2. ;
864          if ((xt>xl)&&(xt<xh))  paddleidoftrack=i1;          if ((xt>xl)&&(xt<xh))  paddleidoftrack=i1;
865        }        }
866      }      }
# Line 608  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa Line 876  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa
876            
877      if ((yt>yl)&&(yt<yh)) {      if ((yt>yl)&&(yt<yh)) {
878        for (Int_t i1=0; i1<3;i1++){        for (Int_t i1=0; i1<3;i1++){
879          xl = tof31_x[i1] - (6.0-0.4)/2. ;          xl = tof31_x[i1] - (6.0-margin)/2. ;
880          xh = tof31_x[i1] + (6.0-0.4)/2. ;          xh = tof31_x[i1] + (6.0-margin)/2. ;
881          if ((xt>xl)&&(xt<xh))  paddleidoftrack=i1;          if ((xt>xl)&&(xt<xh))  paddleidoftrack=i1;
882        }        }
883      }      }
# Line 625  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa Line 893  Int_t ToFLevel2::GetPaddleIdOfTrack(Floa
893            
894      if ((xt>xl)&&(xt<xh)) {      if ((xt>xl)&&(xt<xh)) {
895        for (Int_t i1=0; i1<3;i1++){        for (Int_t i1=0; i1<3;i1++){
896          yl = tof32_y[i1] - (5.0-0.4)/2. ;          yl = tof32_y[i1] - (5.0-margin)/2. ;
897          yh = tof32_y[i1] + (5.0-0.4)/2. ;          yh = tof32_y[i1] + (5.0-margin)/2. ;
898          if ((yt>yl)&&(yt<yh)) paddleidoftrack=i1;          if ((yt>yl)&&(yt<yh)) paddleidoftrack=i1;
899        }        }
900      }      }
# Line 693  void ToFLevel2::GetPMTPaddle(Int_t pmt_i Line 961  void ToFLevel2::GetPMTPaddle(Int_t pmt_i
961  // gf Apr 07  // gf Apr 07
962    
963  void ToFLevel2::GetPaddlePMT(Int_t paddle, Int_t &pmtleft, Int_t &pmtright){  void ToFLevel2::GetPaddlePMT(Int_t paddle, Int_t &pmtleft, Int_t &pmtright){
964      pmtleft=paddle*2;
965    if(paddle==0){    pmtright= pmtleft+1;  
     pmtleft=0;  
     pmtright=1;  
   }  
   
   if(paddle==1){  
     pmtleft=2;  
     pmtright=3;  
   }  
   
   if(paddle==2){  
     pmtleft=4;  
     pmtright=5;  
   }  
   
   if(paddle==3){  
     pmtleft=6;  
     pmtright=7;  
   }  
   
   if(paddle==4){  
     pmtleft=8;  
     pmtright=9;  
   }  
   
   if(paddle==5){  
     pmtleft=10;  
     pmtright=11;  
   }  
   
   if(paddle==6){  
     pmtleft=12;  
     pmtright=13;  
   }  
   
   if(paddle==7){  
     pmtleft=14;  
     pmtright=15;  
   }  
   
   if(paddle==8){  
     pmtleft=16;  
     pmtright=17;  
   }  
   
   if(paddle==9){  
     pmtleft=18;  
     pmtright=19;  
   }  
   
   if(paddle==10){  
     pmtleft=20;  
     pmtright=21;  
   }  
   
   if(paddle==11){  
     pmtleft=22;  
     pmtright=23;  
   }  
   
   if(paddle==12){  
     pmtleft=24;  
     pmtright=25;  
   }  
   
   if(paddle==13){  
     pmtleft=26;  
     pmtright=27;  
   }  
   
   if(paddle==14){  
     pmtleft=28;  
     pmtright=29;  
   }  
   
   if(paddle==15){  
     pmtleft=30;  
     pmtright=31;  
   }  
   
   if(paddle==16){  
     pmtleft=32;  
     pmtright=33;  
   }  
   
   if(paddle==17){  
     pmtleft=34;  
     pmtright=35;  
   }  
   
   if(paddle==18){  
     pmtleft=36;  
     pmtright=37;  
   }  
   
   if(paddle==19){  
     pmtleft=38;  
     pmtright=39;  
   }  
   
   if(paddle==20){  
     pmtleft=40;  
     pmtright=41;  
   }  
   
   if(paddle==21){  
     pmtleft=42;  
     pmtright=43;  
   }  
   
   if(paddle==22){  
     pmtleft=44;  
     pmtright=45;  
   }  
   
   if(paddle==23){  
     pmtleft=46;  
     pmtright=47;  
   }  
     
966    return;    return;
967  }  }
968    
# Line 927  void ToFLevel2::GetPaddleGeometry(Int_t Line 1076  void ToFLevel2::GetPaddleGeometry(Int_t
1076   */   */
1077  Int_t ToFLevel2::GetPaddleid(Int_t plane, Int_t paddle)  Int_t ToFLevel2::GetPaddleid(Int_t plane, Int_t paddle)
1078  {  {
   
1079    Int_t padid=-1;    Int_t padid=-1;
1080    Int_t pads11=8;    Int_t pads[6]={8,6,2,2,3,3};
   Int_t pads12=6;  
   Int_t pads21=2;  
   Int_t pads22=2;  
   Int_t pads31=3;  
   //  Int_t pads32=3;  
1081    
1082      int somma=0;
1083    if(plane == 0){    int np=plane;
1084      padid=paddle;    for(Int_t j=0; j<np; j++){
1085    }      somma+=pads[j];
   
   if(plane == 1){  
     padid=pads11+paddle;  
   }  
   
   if(plane == 2){  
     padid=pads11+pads12+paddle;  
   }  
   
   if(plane == 3){  
     padid=pads11+pads12+pads21+paddle;  
1086    }    }
1087      padid=paddle+somma;
   if(plane == 4){  
     padid=pads11+pads12+pads21+pads22+paddle;  
   }  
   
   if(plane == 5){  
     padid=pads11+pads12+pads21+pads22+pads31+paddle;  
   }  
   
1088    return padid;    return padid;
1089    
1090  }  }
# Line 991  void ToFLevel2::GetPaddlePlane(Int_t pad Line 1115  void ToFLevel2::GetPaddlePlane(Int_t pad
1115      return;      return;
1116    }    }
1117    
1118    if(7<pad<14){    if((7<pad)&&(pad<14)){
1119      plane=1;      plane=1;
1120      paddle=pad-pads11;      paddle=pad-pads11;
1121      return;      return;
1122    }    }
1123        
1124    if(13<pad<16){    if((13<pad)&&(pad<16)){
1125      plane=2;      plane=2;
1126      paddle=pad-pads11-pads12;      paddle=pad-pads11-pads12;
1127      return;      return;
1128    }    }
1129    
1130    if(15<pad<18){    if((15<pad)&&(pad<18)){
1131      plane=3;      plane=3;
1132      paddle=pad-pads11-pads12-pads21;      paddle=pad-pads11-pads12-pads21;
1133      return;      return;
1134    }    }
1135    
1136    if(17<pad<21){    if((17<pad)&&(pad<21)){
1137      plane=4;      plane=4;
1138      paddle=pad-pads11-pads12-pads21-pads22;      paddle=pad-pads11-pads12-pads21-pads22;
1139      return;      return;
1140    }    }
1141    
1142    if(20<pad<24){    if((20<pad)&&(pad<24)){
1143      plane=5;      plane=5;
1144      paddle=pad-pads11-pads12-pads21-pads22-pads31;      paddle=pad-pads11-pads12-pads21-pads22-pads31;
1145      return;      return;
# Line 1046  Int_t ToFLevel2::GetNPaddle(Int_t plane) Line 1170  Int_t ToFLevel2::GetNPaddle(Int_t plane)
1170    
1171  }  }
1172    
 ////////////////////////////////////////////////////  
1173    
1174    
1175    /// wm feb 08
1176    
1177    /**
1178     * Method to calculate Beta from the 12 single measurements
1179     * we check the individual weights for artificial TDC values, then calculate
1180     * am mean beta for the first time. In a second step we loop again through
1181     * the single measurements, checking for the residual from the mean
1182     * The cut on the residual reject measurements > "x"-sigma. A chi2 value is
1183     * calculated, furthermore a "quality" value by adding the weights which
1184     * are finally used. If all measurements are taken, "quality" will be = 22.47.
1185     * A chi2 cut around 3-4 and a quality-cut > 20 is needed for clean beta
1186     * measurements like antiprotons etc.
1187     * The Level2 output is derived in the fortran routines using: 10.,10.,20.
1188     * @param notrack Track Number
1189     * @param cut on residual: difference between single measurement and mean
1190     * @param cut on "quality"
1191     * @param cut on chi2
1192     */
1193    
1194    Float_t ToFLevel2::CalcBeta(Int_t notrack, Float_t resmax, Float_t qualitycut, Float_t chi2cut){
1195    
1196    //  cout<<" in CalcBeta "<<resmax<<" "<<chi2cut<<" "<<qualitycut<<endl;
1197    
1198      Float_t bxx = 100.;
1199      //
1200      ToFTrkVar *trk = GetToFTrkVar(notrack);
1201      if(!trk) return 0; //ELENA
1202    
1203    
1204      Float_t chi2,xhelp,beta_mean;
1205      Float_t w_i[12],quality,sw,sxw,res,betachi,beta_mean_inv;
1206      Float_t b[12],tdcfl;
1207      Int_t  pmt_id,pmt_plane;
1208    
1209      for (Int_t i=0; i<12; i++){
1210        b[i] = trk->beta[i];
1211                                  }
1212          
1213    
1214    //========================================================================
1215    //---  Find out ToF layers with artificial TDC values & fill vector    ---
1216    //========================================================================
1217    
1218    Float_t  w_il[6];
1219    
1220         for (Int_t jj=0; jj<6;jj++) {
1221             w_il[jj] = 1000.;
1222                                     }
1223    
1224    
1225      for (Int_t i=0; i<trk->npmttdc; i++){
1226        //
1227        pmt_id = (trk->pmttdc).At(i);
1228        pmt_plane = GetPlaneIndex(pmt_id);
1229        tdcfl = (trk->tdcflag).At(i);
1230        if (w_il[pmt_plane] != 1.) w_il[pmt_plane] = tdcfl; //tdcflag
1231                                         };
1232      
1233    //========================================================================
1234    //---  Set weights for the 12 measurements using information for top and bottom:
1235    //---  if no measurements: weight = set to very high value=> not used
1236    //---  top or bottom artificial: weight*sqrt(2)
1237    //---  top and bottom artificial: weight*sqrt(2)*sqrt(2)
1238    //========================================================================
1239    
1240    Int_t itop[12] = {0,0,1,1,2,2,3,3,0,0,1,1};
1241    Int_t ibot[12] = {4,5,4,5,4,5,4,5,2,3,2,3};
1242    
1243         xhelp= 1E09;
1244      
1245         for (Int_t jj=0; jj<12;jj++) {
1246         if (jj<4)           xhelp = 0.11;    // S1-S3
1247         if ((jj>3)&&(jj<8)) xhelp = 0.18;    // S2-S3
1248         if (jj>7)           xhelp = 0.28;    // S1-S2
1249         if ((w_il[itop[jj]] == 1000.) && (w_il[ibot[jj]] == 1000.)) xhelp = 1E09;
1250         if ((w_il[itop[jj]] == 1) || (w_il[ibot[jj]] == 1.)) xhelp = xhelp*1.414 ;
1251         if ((w_il[itop[jj]] == 1) && (w_il[ibot[jj]] == 1.)) xhelp = xhelp*2. ;
1252    
1253         w_i[jj] = 1./xhelp;
1254                                      }
1255    
1256    
1257    //========================================================================
1258    //--- Calculate mean beta for the first time -----------------------------
1259    //--- We are using "1/beta" since its error is gaussian ------------------
1260    //========================================================================
1261    
1262          Int_t icount=0;
1263          sw=0.;
1264          sxw=0.;
1265          beta_mean=100.;
1266    
1267              for (Int_t jj=0; jj<12;jj++){
1268            if ((fabs(1./b[jj])>0.1)&&(fabs(1./b[jj])<15.))
1269             {
1270                icount= icount+1;
1271                sxw=sxw + (1./b[jj])*w_i[jj]*w_i[jj] ;
1272                sw =sw + w_i[jj]*w_i[jj] ;
1273    
1274             }
1275             }
1276    
1277          if (icount>0) beta_mean=1./(sxw/sw);
1278          beta_mean_inv = 1./beta_mean;
1279    
1280    //========================================================================
1281    //--- Calculate beta for the second time, use residuals of the single
1282    //--- measurements to get a chi2 value
1283    //========================================================================
1284    
1285          icount=0;
1286          sw=0.;
1287          sxw=0.;
1288          betachi = 100.;
1289          chi2 = 0.;
1290          quality=0.;
1291    
1292    
1293              for (Int_t jj=0; jj<12;jj++){
1294           if ((fabs(1./b[jj])>0.1)&&(fabs(1./b[jj])<15.)&&(w_i[jj]>0.01)) {
1295                res = beta_mean_inv - (1./b[jj]) ;
1296                if (fabs(res*w_i[jj])<resmax)          {;
1297                chi2 = chi2 + pow((res*w_i[jj]),2) ;
1298                icount= icount+1;
1299                sxw=sxw + (1./b[jj])*w_i[jj]*w_i[jj] ;
1300                sw =sw + w_i[jj]*w_i[jj] ;
1301                                                   }
1302                                                                            }
1303                                          }
1304          quality = sqrt(sw) ;
1305    
1306          if (icount==0) chi2 = 1000.;
1307          if (icount>0) chi2 = chi2/(icount) ;
1308          if (icount>0) betachi=1./(sxw/sw);
1309    
1310       bxx = 100.;
1311       if ((chi2 < chi2cut)&&(quality>qualitycut)) bxx = betachi;
1312      //
1313      return(bxx);
1314    };
1315    
1316    
1317    ////////////////////////////////////////////////////
1318    ////////////////////////////////////////////////////
1319    
1320    
1321  /**  /**
1322   * Fills a struct cToFLevel2 with values from a ToFLevel2 object (to put data into a F77 common).   * Fills a struct cToFLevel2 with values from a ToFLevel2 object (to put data into a F77 common).
# Line 1096  void ToFLevel2::GetLevel2Struct(cToFLeve Line 1364  void ToFLevel2::GetLevel2Struct(cToFLeve
1364        }        }
1365    } //ELENA    } //ELENA
1366  }  }
1367    
1368    
1369    //
1370    // Reprocessing tool // Emiliano 08/04/07
1371    //
1372    Int_t ToFLevel2::Process(TrkLevel2 *trk, TrigLevel2 *trg, GL_RUN *run, OrbitalInfo *orb, Bool_t force){
1373      //
1374      // Copiare qui qualcosa di simile a calonuclei per evitare di riprocessare sempre tutto
1375      //
1376      printf("\n\n\n ERROR: NOT IMPLEMENTED ANYMORE, write Emiliano if you need this method (Emiliano.Mocchiutti@ts.infn.it) \n\n\n");
1377      return(-1);
1378      //   //
1379      //   // structures to communicate with F77
1380      //   //
1381      //   extern struct ToFInput  tofinput_;
1382    //   extern struct ToFOutput tofoutput_;
1383    //   //
1384    //   // DB connection
1385    //   //
1386    //   TString host;
1387    //   TString user;
1388    //   TString psw;
1389    //   const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
1390    //   const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
1391    //   const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
1392    //   if ( !pamdbhost ) pamdbhost = "";
1393    //   if ( !pamdbuser ) pamdbuser = "";
1394    //   if ( !pamdbpsw ) pamdbpsw = "";
1395    //   if ( strcmp(pamdbhost,"") ) host = pamdbhost;
1396    //   if ( strcmp(pamdbuser,"") ) user = pamdbuser;
1397    //   if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;
1398    //   //
1399    //   //
1400    //   TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
1401    //   if ( !dbc->IsConnected() ) return 1;
1402    //   stringstream myquery;
1403    //   myquery.str("");
1404    //   myquery << "SET time_zone='+0:00';";
1405    //   dbc->Query(myquery.str().c_str());
1406    //   delete dbc->Query("SET sql_mode = 'NO_UNSIGNED_SUBTRACTION';");
1407    //   GL_PARAM *glparam = new GL_PARAM();
1408    //   glparam->Query_GL_PARAM(1,1,dbc); // parameters stored in DB in GL_PRAM table
1409    //   trk->LoadField(glparam->PATH+glparam->NAME);
1410    //   //
1411    //   Bool_t defcal = true;
1412    //   Int_t error=glparam->Query_GL_PARAM(run->RUNHEADER_TIME,201,dbc); // parameters stored in DB in GL_PRAM table
1413    //   if ( error<0 ) {
1414    //     return(1);
1415    //   };
1416    //   printf(" Reading ToF parameter file: %s \n",(glparam->PATH+glparam->NAME).Data());
1417    //   if ( (UInt_t)glparam->TO_TIME != (UInt_t)4294967295UL ) defcal = false;
1418    //   //
1419    //   Int_t nlen = (Int_t)(glparam->PATH+glparam->NAME).Length();
1420    //   rdtofcal((char *)(glparam->PATH+glparam->NAME).Data(),&nlen);
1421    //   //
1422    //   Int_t adc[4][12];
1423    //   Int_t tdc[4][12];
1424    //   Float_t tdcc[4][12];
1425    //   //
1426    //   // process tof data
1427    //   //
1428    //   for (Int_t hh=0; hh<12;hh++){
1429    //     for (Int_t kk=0; kk<4;kk++){
1430    //            adc[kk][hh] = 4095;
1431    //            tdc[kk][hh] = 4095;
1432    //            tdcc[kk][hh] = 4095.;
1433    //            tofinput_.adc[hh][kk] = 4095;
1434    //            tofinput_.tdc[hh][kk] = 4095;
1435    //     };
1436    //   };
1437    //   Int_t ntrkentry = 0;
1438    //   Int_t npmtentry = 0;
1439    //   Int_t gg = 0;
1440    //   Int_t hh = 0;
1441    //   Int_t adcf[48];
1442    //   memset(adcf, 0, 48*sizeof(Int_t));
1443    //   Int_t tdcf[48];
1444    //   memset(tdcf, 0, 48*sizeof(Int_t));
1445    //   for (Int_t pm=0; pm < this->ntrk() ; pm++){
1446    //      ToFTrkVar *ttf = this->GetToFTrkVar(pm);
1447    //      for ( Int_t nc=0; nc < ttf->npmttdc; nc++){
1448    //             if ( (ttf->tdcflag).At(nc) != 0 ) tdcf[(ttf->pmttdc).At(nc)] = 1;
1449    //      };
1450    //      for ( Int_t nc=0; nc < ttf->npmtadc; nc++){
1451    //             if ( (ttf->adcflag).At(nc) != 0 ) adcf[(ttf->pmtadc).At(nc)] = 1;
1452    //      };
1453    //   };
1454    //   //
1455    //   for (Int_t pm=0; pm < this->npmt() ; pm++){
1456    //      ToFPMT *pmt = this->GetToFPMT(pm);
1457    //      this->GetPMTIndex(pmt->pmt_id, gg, hh);
1458    //      if ( adcf[pmt->pmt_id] == 0 ){
1459    //              tofinput_.adc[gg][hh] = (int)pmt->adc;
1460    //              adc[hh][gg] = (int)pmt->adc;
1461    //      };
1462    //      if ( tdcf[pmt->pmt_id] == 0 ){
1463    //              tofinput_.tdc[gg][hh] = (int)pmt->tdc;
1464    //              tdc[hh][gg] = (int)pmt->tdc;
1465    //      };
1466    //      tdcc[hh][gg] = (float)pmt->tdc_tw;
1467    //      // Int_t pppid = this->GetPMTid(hh,gg);
1468    //      //      printf(" pm %i pmt_id %i pppid %i hh %i gg %i tdcc %f tdc %f adc %f \n",pm,pmt->pmt_id,pppid,hh,gg,pmt->tdc_tw,pmt->tdc,pmt->adc);
1469    //   };
1470    //   //
1471    //   Int_t unpackError = this->unpackError;
1472    //   //
1473    //   for (Int_t hh=0; hh<5;hh++){
1474    //      tofinput_.patterntrig[hh]=trg->patterntrig[hh];
1475    //   };
1476    //   //
1477    //   this->Clear();
1478    //   //
1479    //       Int_t pmt_id = 0;
1480    //       ToFPMT *t_pmt = new ToFPMT();
1481    //       if(!(this->PMT)) this->PMT = new TClonesArray("ToFPMT",12); //ELENA
1482    //       TClonesArray &tpmt = *this->PMT;
1483    //       ToFTrkVar *t_tof = new ToFTrkVar();
1484    //       if(!(this->ToFTrk)) this->ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA
1485    //       TClonesArray &t = *this->ToFTrk;
1486    //       //
1487    //       //
1488    //       // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract common and track-related  variables.
1489    //       //
1490    //       npmtentry = 0;
1491    //       //
1492    //       ntrkentry = 0;
1493    //       //
1494    //       // Calculate tracks informations from ToF alone
1495    //       //
1496    //       tofl2com();
1497    //       //
1498    //       memcpy(this->tof_j_flag,tofoutput_.tof_j_flag,6*sizeof(Int_t));
1499    //       //
1500    //       t_tof->trkseqno = -1;
1501    //       //
1502    //       // and now we must copy from the output structure to the level2 class:
1503    //       //
1504    //       t_tof->npmttdc = 0;
1505    //       //
1506    //       for (Int_t hh=0; hh<12;hh++){
1507    //         for (Int_t kk=0; kk<4;kk++){
1508    //           if ( tofoutput_.tofmask[hh][kk] != 0 ){
1509    //             pmt_id = this->GetPMTid(kk,hh);
1510    //             t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
1511    //             t_tof->tdcflag.AddAt(tofoutput_.tdcflagtof[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
1512    //             t_tof->npmttdc++;
1513    //           };
1514    //         };
1515    //       };
1516    //       for (Int_t kk=0; kk<13;kk++){
1517    //         t_tof->beta[kk] = tofoutput_.betatof_a[kk];
1518    //       }
1519    //       //
1520    //       t_tof->npmtadc = 0;
1521    //       for (Int_t hh=0; hh<12;hh++){
1522    //         for (Int_t kk=0; kk<4;kk++){
1523    //           if ( tofoutput_.adctof_c[hh][kk] < 1000 ){
1524    //             t_tof->dedx.AddAt(tofoutput_.adctof_c[hh][kk],t_tof->npmtadc);
1525    //             pmt_id = this->GetPMTid(kk,hh);
1526    //             t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
1527    //             t_tof->adcflag.AddAt(tofoutput_.adcflagtof[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
1528    //             t_tof->npmtadc++;
1529    //           };
1530    //         };
1531    //       };
1532    //       //
1533    //       memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
1534    //       memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
1535    //       memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
1536    //       memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));
1537    //       //
1538    //       new(t[ntrkentry]) ToFTrkVar(*t_tof);
1539    //       ntrkentry++;
1540    //       t_tof->Clear();
1541    //       //
1542    //       //
1543    //       //
1544    //       t_pmt->Clear();
1545    //       //
1546    //       for (Int_t hh=0; hh<12;hh++){
1547    //         for (Int_t kk=0; kk<4;kk++){
1548    //          // new WM
1549    //           if ( tofoutput_.tdc_c[hh][kk] < 4095 || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){
1550    // //          if ( tdcc[kk][hh] < 4095. || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){
1551    //             //
1552    //             t_pmt->pmt_id = this->GetPMTid(kk,hh);
1553    //             t_pmt->tdc_tw = tofoutput_.tdc_c[hh][kk];
1554    //             t_pmt->adc = (Float_t)adc[kk][hh];
1555    //             t_pmt->tdc = (Float_t)tdc[kk][hh];
1556    //             //
1557    //             new(tpmt[npmtentry]) ToFPMT(*t_pmt);
1558    //             npmtentry++;
1559    //             t_pmt->Clear();
1560    //           };
1561    //         };
1562    //       };
1563    //       //
1564    //       // Calculate track-related variables
1565    //       //
1566    //       if ( trk->ntrk() > 0 ){
1567    //         //
1568    //         // We have at least one track
1569    //         //
1570    //         //
1571    //         // Run over tracks
1572    //         //
1573    //         for(Int_t nt=0; nt < trk->ntrk(); nt++){
1574    //           //
1575    //           TrkTrack *ptt = trk->GetStoredTrack(nt);
1576    //           //
1577    //           // Copy the alpha vector in the input structure
1578    //           //
1579    //           for (Int_t e = 0; e < 5 ; e++){
1580    //             tofinput_.al_pp[e] = ptt->al[e];
1581    //           };
1582    //           //
1583    //           // Get tracker related variables for this track
1584    //           //
1585    //           toftrk();
1586    //           //
1587    //           // Copy values in the class from the structure (we need to use a temporary class to store variables).
1588    //           //
1589    //           t_tof->npmttdc = 0;
1590    //           for (Int_t hh=0; hh<12;hh++){
1591    //             for (Int_t kk=0; kk<4;kk++){
1592    //               if ( tofoutput_.tofmask[hh][kk] != 0 ){
1593    //                 pmt_id = this->GetPMTid(kk,hh);
1594    //                 t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
1595    //                 t_tof->tdcflag.AddAt(tofoutput_.tdcflag[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
1596    //                 t_tof->npmttdc++;
1597    //               };
1598    //             };
1599    //           };
1600    //           for (Int_t kk=0; kk<13;kk++){
1601    //             t_tof->beta[kk] = tofoutput_.beta_a[kk];
1602    //           };
1603    //           //
1604    //           t_tof->npmtadc = 0;
1605    //           for (Int_t hh=0; hh<12;hh++){
1606    //             for (Int_t kk=0; kk<4;kk++){
1607    //               if ( tofoutput_.adc_c[hh][kk] < 1000 ){
1608    //                 t_tof->dedx.AddAt(tofoutput_.adc_c[hh][kk],t_tof->npmtadc);
1609    //                 pmt_id = this->GetPMTid(kk,hh);
1610    //                 t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
1611    //                 t_tof->adcflag.AddAt(tofoutput_.adcflag[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
1612    //                 t_tof->npmtadc++;
1613    //               };
1614    //             };
1615    //           };
1616    //           //
1617    //           memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
1618    //           memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
1619    //           memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
1620    //           memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));
1621    //           //
1622    //           // Store the tracker track number in order to be sure to have shyncronized data during analysis
1623    //           //
1624    //           t_tof->trkseqno = nt;
1625    //           //
1626    //           // create a new object for this event with track-related variables
1627    //           //
1628    //           new(t[ntrkentry]) ToFTrkVar(*t_tof);
1629    //           ntrkentry++;
1630    //           t_tof->Clear();
1631    //           //
1632    //         }; // loop on all the tracks
1633    //       //
1634    //       this->unpackError = unpackError;
1635    //       if ( defcal ){
1636    //         this->default_calib = 1;
1637    //       } else {
1638    //         this->default_calib = 0;
1639    //       };
1640    //};
1641    //  return(0);
1642    }
1643    
1644    bool ToFLevel2::bit(int decimal, char pos){
1645      return( (decimal>>pos)%2 );
1646    }
1647    
1648    bool ToFLevel2::checkPMT(TString givenpmt){
1649      TClonesArray* Pmt = this->PMT;
1650      //  printf(" ou %s entries %i \n",givenpmt.Data(),Pmt->GetEntries());
1651      for(int i=0; i<Pmt->GetEntries(); i++) {  
1652        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1653        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1654        //    printf(" name %s \n",pmtname.Data());
1655        if ( !strcmp(pmtname.Data(),givenpmt.Data()) )
1656          return true;
1657      }
1658      //  printf(" PMT %s missing \n",givenpmt.Data());
1659      return false;
1660    }
1661    
1662    bool ToFLevel2::checkPMTpatternPMThit(TrigLevel2 *trg, int &pmtpattern, int &pmtnosignal){
1663      UInt_t *patterntrig = trg->patterntrig;
1664      pmtpattern = 0;
1665      pmtnosignal = 0;
1666      bool good = true;
1667      //S3
1668      if ( this->bit(patterntrig[2],0) ){ pmtpattern++;  if ( !this->checkPMT("S31_1A")){ pmtnosignal++; good = false;}}
1669      if ( this->bit(patterntrig[2],1) ){ pmtpattern++;  if ( !this->checkPMT("S31_2A")){ pmtnosignal++; good = false;}}
1670      if ( this->bit(patterntrig[2],2) ){ pmtpattern++;  if ( !this->checkPMT("S31_3A")){ pmtnosignal++; good = false;}}
1671      if ( this->bit(patterntrig[2],3) ){ pmtpattern++;  if ( !this->checkPMT("S31_1B")){ pmtnosignal++; good = false;}}
1672      if ( this->bit(patterntrig[2],4) ){ pmtpattern++;  if ( !this->checkPMT("S31_2B")){ pmtnosignal++; good = false;}}
1673      if ( this->bit(patterntrig[2],5) ){ pmtpattern++;  if ( !this->checkPMT("S31_3B")){ pmtnosignal++; good = false;}}      
1674      if ( this->bit(patterntrig[2],6) ){ pmtpattern++;  if ( !this->checkPMT("S32_1A")){ pmtnosignal++; good = false;}}
1675      if ( this->bit(patterntrig[2],7) ){ pmtpattern++;  if ( !this->checkPMT("S32_2A")){ pmtnosignal++; good = false;}}
1676      if ( this->bit(patterntrig[2],8) ){ pmtpattern++;  if ( !this->checkPMT("S32_3A")){ pmtnosignal++; good = false;}}
1677      if ( this->bit(patterntrig[2],9) ){ pmtpattern++;  if ( !this->checkPMT("S32_1B")){ pmtnosignal++; good = false;}}
1678      if ( this->bit(patterntrig[2],10) ){ pmtpattern++;  if ( !this->checkPMT("S32_2B")){ pmtnosignal++; good = false;}}
1679      if ( this->bit(patterntrig[2],11) ){ pmtpattern++;  if ( !this->checkPMT("S32_3B")){ pmtnosignal++; good = false;}}      
1680      //S2
1681      if ( this->bit(patterntrig[3],0) ){ pmtpattern++;  if ( !this->checkPMT("S21_1A")){ pmtnosignal++; good = false;}}
1682      if ( this->bit(patterntrig[3],1) ){ pmtpattern++;  if ( !this->checkPMT("S21_2A")){ pmtnosignal++; good = false;}}
1683      if ( this->bit(patterntrig[3],2) ){ pmtpattern++;  if ( !this->checkPMT("S21_1B")){ pmtnosignal++; good = false;}}
1684      if ( this->bit(patterntrig[3],3) ){ pmtpattern++;  if ( !this->checkPMT("S21_2B")){ pmtnosignal++; good = false;}}      
1685      if ( this->bit(patterntrig[3],4) ){ pmtpattern++;  if ( !this->checkPMT("S22_1A")){ pmtnosignal++; good = false;}}
1686      if ( this->bit(patterntrig[3],5) ){ pmtpattern++;  if ( !this->checkPMT("S22_2A")){ pmtnosignal++; good = false;}}
1687      if ( this->bit(patterntrig[3],6) ){ pmtpattern++;  if ( !this->checkPMT("S22_1B")){ pmtnosignal++; good = false;}}
1688      if ( this->bit(patterntrig[3],7) ){ pmtpattern++;  if ( !this->checkPMT("S22_2B")){ pmtnosignal++; good = false;}}      
1689      //S12
1690      if ( this->bit(patterntrig[4],0) ){ pmtpattern++;  if ( !this->checkPMT("S12_1A")){ pmtnosignal++; good = false;}}
1691      if ( this->bit(patterntrig[4],1) ){ pmtpattern++;  if ( !this->checkPMT("S12_2A")){ pmtnosignal++; good = false;}}
1692      if ( this->bit(patterntrig[4],2) ){ pmtpattern++;  if ( !this->checkPMT("S12_3A")){ pmtnosignal++; good = false;}}
1693      if ( this->bit(patterntrig[4],3) ){ pmtpattern++;  if ( !this->checkPMT("S12_4A")){ pmtnosignal++; good = false;}}
1694      if ( this->bit(patterntrig[4],4) ){ pmtpattern++;  if ( !this->checkPMT("S12_5A")){ pmtnosignal++; good = false;}}
1695      if ( this->bit(patterntrig[4],5) ){ pmtpattern++;  if ( !this->checkPMT("S12_6A")){ pmtnosignal++; good = false;}}      
1696      if ( this->bit(patterntrig[4],6) ){ pmtpattern++;  if ( !this->checkPMT("S12_1A")){ pmtnosignal++; good = false;}}
1697      if ( this->bit(patterntrig[4],7) ){ pmtpattern++;  if ( !this->checkPMT("S12_2A")){ pmtnosignal++; good = false;}}
1698      if ( this->bit(patterntrig[4],8) ){ pmtpattern++;  if ( !this->checkPMT("S12_3A")){ pmtnosignal++; good = false;}}
1699      if ( this->bit(patterntrig[4],9) ){ pmtpattern++;  if ( !this->checkPMT("S12_4B")){ pmtnosignal++; good = false;}}
1700      if ( this->bit(patterntrig[4],10) ){ pmtpattern++; if ( !this->checkPMT("S12_5B")){ pmtnosignal++; good = false;}}
1701      if ( this->bit(patterntrig[4],11) ){ pmtpattern++; if ( !this->checkPMT("S12_6B")){ pmtnosignal++; good = false;}}      
1702      //S11
1703      if ( this->bit(patterntrig[5],0) ){ pmtpattern++;  if ( !this->checkPMT("S11_1A")){ pmtnosignal++; good = false;}}
1704      if ( this->bit(patterntrig[5],1) ){ pmtpattern++;  if ( !this->checkPMT("S11_2A")){ pmtnosignal++; good = false;}}
1705      if ( this->bit(patterntrig[5],2) ){ pmtpattern++;  if ( !this->checkPMT("S11_3A")){ pmtnosignal++; good = false;}}
1706      if ( this->bit(patterntrig[5],3) ){ pmtpattern++;  if ( !this->checkPMT("S11_4A")){ pmtnosignal++; good = false;}}
1707      if ( this->bit(patterntrig[5],4) ){ pmtpattern++;  if ( !this->checkPMT("S11_5A")){ pmtnosignal++; good = false;}}
1708      if ( this->bit(patterntrig[5],5) ){ pmtpattern++;  if ( !this->checkPMT("S11_6A")){ pmtnosignal++; good = false;}}
1709      if ( this->bit(patterntrig[5],6) ){ pmtpattern++;  if ( !this->checkPMT("S11_7A")){ pmtnosignal++; good = false;}}
1710      if ( this->bit(patterntrig[5],7) ){ pmtpattern++;  if ( !this->checkPMT("S11_8A")){ pmtnosignal++; good = false;}}      
1711      if ( this->bit(patterntrig[5],8) ){ pmtpattern++;  if ( !this->checkPMT("S11_1B")){ pmtnosignal++; good = false;}}
1712      if ( this->bit(patterntrig[5],9) ){ pmtpattern++;  if ( !this->checkPMT("S11_2B")){ pmtnosignal++; good = false;}}
1713      if ( this->bit(patterntrig[5],10) ){ pmtpattern++; if ( !this->checkPMT("S11_3B")){ pmtnosignal++; good = false;}}
1714      if ( this->bit(patterntrig[5],11) ){ pmtpattern++; if ( !this->checkPMT("S11_4B")){ pmtnosignal++; good = false;}}
1715      if ( this->bit(patterntrig[5],12) ){ pmtpattern++; if ( !this->checkPMT("S11_5B")){ pmtnosignal++; good = false;}}
1716      if ( this->bit(patterntrig[5],13) ){ pmtpattern++; if ( !this->checkPMT("S11_6B")){ pmtnosignal++; good = false;}}
1717      if ( this->bit(patterntrig[5],14) ){ pmtpattern++; if ( !this->checkPMT("S11_7B")){ pmtnosignal++; good = false;}}
1718      if ( this->bit(patterntrig[5],15) ){ pmtpattern++; if ( !this->checkPMT("S11_8B")){ pmtnosignal++; good = false;}}
1719    
1720      return good;
1721    }
1722    
1723    bool ToFLevel2::checkPMTpmttrig(TrigLevel2 *trg){
1724      //  UInt_t *patterntrig = trg->patterntrig;
1725      int rS11 = 0;
1726      int rS12 = 0;
1727      int rS21 = 0;
1728      int rS22 = 0;
1729      int rS31 = 0;
1730      int rS32 = 0;
1731    
1732      // trigger configuration for the event from saved pmts
1733      TClonesArray* Pmt = this->PMT;
1734      for(int i=0; i<Pmt->GetEntries(); i++) {  
1735        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1736        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1737        if ( pmtname.Contains("S11") ) rS11++;
1738        if ( pmtname.Contains("S12") ) rS12++;
1739        if ( pmtname.Contains("S21") ) rS21++;
1740        if ( pmtname.Contains("S22") ) rS22++;
1741        if ( pmtname.Contains("S31") ) rS31++;
1742        if ( pmtname.Contains("S32") ) rS32++;
1743      }
1744      int rTOF1 = (rS11 + rS12) * (rS21 + rS22) * (rS31 + rS32);
1745      int rTOF2 = (rS11 * rS12) * (rS21 * rS22) * (rS31 * rS32);
1746    
1747      int rTOF3 = (rS21 + rS22) * (rS31 + rS32);
1748      int rTOF4 = (rS21 * rS22) * (rS31 * rS32);
1749    
1750      int rTOF5 = rS12 * (rS21 * rS22);
1751    
1752      int rTOF6 = (rS11 + rS12) * (rS31 + rS32);
1753      int rTOF7 = (rS11 * rS12) * (rS31 * rS32);
1754    
1755    
1756      // trigger configuration of the run
1757      bool TCTOF1 = false;
1758      bool TCTOF2 = false;
1759      bool TCTOF3 = false;
1760      bool TCTOF4 = false;
1761      bool TCTOF5 = false;
1762      bool TCTOF6 = false;
1763      bool TCTOF7 = false;
1764      if ( trg->trigconf & (1<<0) ) TCTOF1 = true;
1765      if ( trg->trigconf & (1<<1) ) TCTOF2 = true;
1766      if ( trg->trigconf & (1<<2) ) TCTOF3 = true;
1767      if ( trg->trigconf & (1<<3) ) TCTOF4 = true;
1768      if ( trg->trigconf & (1<<4) ) TCTOF5 = true;
1769      if ( trg->trigconf & (1<<5) ) TCTOF6 = true;
1770      if ( trg->trigconf & (1<<6) ) TCTOF7 = true;
1771    
1772      // do patterntrig pmts match the trigger configuration?
1773      bool pmtsconf_trigconf_match = true;
1774      if ( rTOF1 == 0 && TCTOF1 ) pmtsconf_trigconf_match = false;
1775      if ( rTOF2 == 0 && TCTOF2 ) pmtsconf_trigconf_match = false;
1776      if ( rTOF3 == 0 && TCTOF3 ) pmtsconf_trigconf_match = false;
1777      if ( rTOF4 == 0 && TCTOF4 ) pmtsconf_trigconf_match = false;
1778      if ( rTOF5 == 0 && TCTOF5 ) pmtsconf_trigconf_match = false;
1779      if ( rTOF6 == 0 && TCTOF6 ) pmtsconf_trigconf_match = false;
1780      if ( rTOF7 == 0 && TCTOF7 ) pmtsconf_trigconf_match = false;
1781    
1782      return pmtsconf_trigconf_match;
1783    }
1784    
1785    void ToFLevel2::printPMT(){
1786      TClonesArray* Pmt = this->PMT;
1787      for(int i=0; i<Pmt->GetEntries(); i++) {  
1788        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1789        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1790        printf(" PMT hit: %s \n",pmtname.Data());
1791      }
1792    }
1793    
1794    
1795    ToFdEdx::ToFdEdx()
1796    {
1797      memset(conn,0,12*sizeof(Bool_t));
1798      memset(ts,0,12*sizeof(UInt_t));
1799      memset(te,0,12*sizeof(UInt_t));
1800      eDEDXpmt = new TArrayF(48);
1801      Define_PMTsat();
1802      Clear();
1803    }
1804    
1805    ToFdEdx::~ToFdEdx(){
1806      Clear();
1807      Delete();
1808    }
1809    
1810    void ToFdEdx::Delete(Option_t *option){
1811      if ( eDEDXpmt ){
1812        eDEDXpmt->Set(0);
1813        if ( eDEDXpmt) delete eDEDXpmt;
1814      }
1815    }
1816    
1817    //------------------------------------------------------------------------
1818    void ToFdEdx::CheckConnectors(UInt_t atime, GL_PARAM *glparam, TSQLServer *dbc)
1819    {
1820      for(int i=0; i<12; i++){
1821        if(atime<=ts[i] || atime>te[i]){
1822          Int_t error=glparam->Query_GL_PARAM(atime,210+i,dbc); // parameters stored in DB in GL_PRAM table
1823          if ( error<0 ) {
1824            conn[i]=false;
1825            ts[i]=0;
1826            te[i]=numeric_limits<UInt_t>::max();
1827          };
1828          if ( !error ){
1829            conn[i]=true;
1830            ts[i]=glparam->FROM_TIME;
1831            te[i]=glparam->TO_TIME;
1832          }
1833          if ( error>0 ){
1834            conn[i]=false;
1835            ts[i]=glparam->TO_TIME;
1836            TSQLResult *pResult;
1837            TSQLRow *row;
1838            TString query= Form("SELECT FROM_TIME FROM GL_PARAM WHERE TYPE=%i AND FROM_TIME>=%i ORDER BY FROM_TIME ASC LIMIT 1;",210+i,atime);
1839            pResult=dbc->Query(query.Data());
1840            if(!pResult->GetRowCount()){
1841              te[i]=numeric_limits<UInt_t>::max();
1842            }else{
1843              row=pResult->Next();
1844              te[i]=(UInt_t)atoll(row->GetField(0));
1845            }
1846          }
1847          //
1848          
1849        }
1850      }
1851    
1852    }
1853    //------------------------------------------------------------------------
1854    void ToFdEdx::Clear(Option_t *option)
1855    {
1856      //
1857      // Set arrays and initialize structure
1858      //  eDEDXpmt.Set(48);    eDEDXpmt.Reset(-1);   // Set array size  and reset structure
1859      eDEDXpmt->Set(48);    eDEDXpmt->Reset(-1);   // Set array size  and reset structure
1860      //
1861    };
1862    
1863    //------------------------------------------------------------------------
1864    void ToFdEdx::Print(Option_t *option)
1865    {
1866      //
1867      printf("========================================================================\n");
1868    
1869    };
1870    
1871    //------------------------------------------------------------------------
1872    void ToFdEdx::Init(pamela::tof::TofEvent *tofl0)
1873    {
1874      //
1875      ToFLevel2 tf;
1876      for (Int_t gg=0; gg<4;gg++){
1877        for (Int_t hh=0; hh<12;hh++){
1878          //          tofinput_.tdc[hh][gg]=tofEvent->tdc[gg][hh];          
1879          int mm = tf.GetPMTid(gg,hh);        
1880          adc[mm]= (0xFFF & tofl0->adc[gg][hh]); // EM, exclude warning bits
1881        };      
1882      };
1883      
1884    };
1885    
1886    //------------------------------------------------------------------------
1887    void ToFdEdx::Init(Int_t gg, Int_t hh, Float_t adce)
1888    {
1889      //
1890      ToFLevel2 tf;
1891      //  for (Int_t gg=0; gg<4;gg++){
1892      //    for (Int_t hh=0; hh<12;hh++){
1893      int mm = tf.GetPMTid(gg,hh);    
1894      adc[mm]=adce;
1895      
1896    };
1897    //------------------------------------------------------------------------
1898    void ToFdEdx::Process(UInt_t atime, Float_t betamean, Float_t *xtr_tof, Float_t *ytr_tof, Int_t exitat)
1899    {
1900      bool debug = false;
1901      if ( debug ) printf(" INSIDE TOFDEDX PROCESS \n");
1902      // the parameters should be already initialised by InitPar()
1903      //  printf(" in process \n");
1904      Clear();
1905    
1906     // define angle:  
1907      double dx   = xtr_tof[1] - xtr_tof[5];
1908      double dy   = ytr_tof[0] - ytr_tof[4];
1909      double dr   = sqrt(dx*dx+dy*dy);
1910      double theta=atan(dr/76.81);
1911      //
1912      if ( xtr_tof[1] > 99. ||  xtr_tof[5] > 99. || ytr_tof[0] > 99. ||  ytr_tof[4] > 99. ) theta = 0.;
1913      for (Int_t ii=0; ii<6; ii++){
1914        if ( xtr_tof[ii] > 99. ) xtr_tof[ii] = 0.;
1915        if ( ytr_tof[ii] > 99. ) ytr_tof[ii] = 0.;
1916      };
1917      //
1918      if ( debug ) printf(" theta %f \n",theta);
1919      if ( debug ) printf(" xtr_tof %.1f %.1f %.1f %.1f %.1f %.1f \n",xtr_tof[0],xtr_tof[1],xtr_tof[2],xtr_tof[3],xtr_tof[4],xtr_tof[5]);
1920      if ( debug ) printf(" ytr_tof %.1f %.1f %.1f %.1f %.1f %.1f \n",ytr_tof[0],ytr_tof[1],ytr_tof[2],ytr_tof[3],ytr_tof[4],ytr_tof[5]);
1921      //--------------------- TABLE OF PERIODS WITH HV PROBLEMS ----------------------------
1922      
1923      int Aconn=conn[0];    // PMT 0,20,22,24
1924      int Bconn=conn[1];    // PMT 6,12,26,34
1925      int Cconn=conn[2];    // PMT 4,14,28,32
1926      int Dconn=conn[3];    // PMT 2,8,10,30
1927      int Econn=conn[4];    // PMT 42,43,44,47
1928      int Fconn=conn[5];    // PMT 7,19,23,27
1929      int Gconn=conn[6];    // PMT 3,11,25,33
1930      int Hconn=conn[7];    // PMT 1,9,13,21
1931      int Iconn=conn[8];    // PMT 5,29,31,35
1932      int Lconn=conn[9];    // PMT 37,40,45,46
1933      int Mconn=conn[10];    // PMT 15,16,17,18
1934      int Nconn=conn[11];    // PMT 36,38,39,41
1935      if( false ) cout << Gconn << Iconn << Lconn <<endl; // to avoid compilation warnings
1936        
1937      //  printf(" size %i \n",eDEDXpmt.GetSize());
1938      for( int ii=0; ii<48; ii++ ) {
1939        //
1940        //    eDEDXpmt.SetAt(-1.,ii);
1941        //    printf(" ii %i beta %f atime %u xtr 1 %f ytr 1 %f adc %f \n",ii,betamean,atime,xtr_tof[0],ytr_tof[0],adc[ii]);
1942        if ( debug ) printf("II %i adc %f \n",ii,adc[ii]);
1943    
1944        if( adc[ii] >= 4095. ){
1945          //      eDEDXpmt[ii] = 0.;
1946          eDEDXpmt->AddAt(0.,ii);
1947          if ( debug ) printf(" %i adc>4095 \n",ii);
1948          continue; // EMILIANO
1949        };
1950    
1951        if( adc[ii] >= (PMTsat[ii]-5.) && adc[ii] < 4095. ){
1952          eDEDXpmt->AddAt(1000.,ii);
1953          if ( debug ) printf(" %i adc> pmtsat && adc<4095 \n",ii);
1954          continue; // EMILIANO
1955        };
1956    
1957        if( adc[ii] <= 0. ) {
1958          eDEDXpmt->AddAt(1500.,ii);
1959          if ( debug ) printf(" %i adc<=0 \n",ii);
1960          continue;
1961        };
1962        //
1963        double adcpC   = f_adcPC( adc[ii] );    // - adc conversion in pC
1964        if ( exitat == 0 ){
1965          eDEDXpmt->AddAt((Float_t)adcpC,ii);
1966          continue;
1967        }
1968        //    printf(" e qua? \n");
1969    
1970        double adccorr = adcpC*fabs(cos(theta));    
1971        if ( debug ) printf(" adccorr %f \n",adccorr);
1972        if(adccorr<=0.){
1973          if ( debug ) printf(" %i adccorr<=0 \n",ii);
1974          //      eDEDXpmt->AddAt((Float_t)adcpC,ii);//?
1975          continue;
1976        }
1977        if ( exitat == 1 ){
1978          eDEDXpmt->AddAt((Float_t)adccorr,ii);
1979          continue;
1980        }
1981        //    printf(" e quo? \n");
1982    
1983        //    int standard=0;
1984        int S115B_ok=0;
1985        int S115B_break=0;
1986    
1987        if(atime<1158720000)S115B_ok=1;
1988        else S115B_break=1;
1989    
1990    
1991        //------------------------------------------------------------------------
1992        //    printf(" e qui? \n");
1993        //---------------------------------------------------- Z reconstruction
1994    
1995        double adcHe, adcnorm, adclin, dEdx;//, Zeta; // EM GCC4.7
1996    
1997        adcHe=-2;
1998        adcnorm=-2;
1999        adclin=-2;
2000        dEdx=-2;
2001        //    Zeta=-2;//EM GCC4.7
2002        Double_t correction = 1.;
2003    
2004        if(Aconn==1 && (ii==0 || ii==20 || ii==22 || ii==24)){
2005          correction = 1.675;
2006        }
2007        else if(Bconn==1 && (ii==6 || ii==12 || ii==26 || ii==34)){
2008          correction = 2.482;
2009        }
2010        else if(Cconn==1 && (ii==4 || ii==14 || ii==28 || ii==32)){
2011          correction = 1.464;
2012        }
2013        else if(Dconn==1 && (ii==2 || ii==8 || ii==10 || ii==30)){
2014          correction = 1.995;
2015        }
2016        else if(Econn==1 && (ii==42 || ii==43 || ii==44 || ii==47)){
2017          correction = 1.273;
2018        }
2019        else if(Fconn==1 && (ii==7 || ii==19 || ii==23 || ii==27)){
2020          correction = 1.565;
2021        }
2022        else if(Mconn==1 && (ii==15 || ii==16 || ii==17 || ii==18)){
2023          correction = 1.565;
2024        }
2025        else if(Nconn==1 && (ii==36 || ii==38 || ii==39 || ii==41)){
2026          correction = 1.018;
2027        }
2028        else if(Hconn==1 && (ii==1 || ii==13 || ii==21 || (ii==9&&S115B_ok==1))){
2029          correction = 1.84;
2030        }
2031        else if(S115B_break==1 && ii==9 && Hconn==1){
2032          correction = 1.64;
2033        }
2034        else correction = 1.;
2035        
2036        if( ii==9 && S115B_break==1 ){
2037          adcHe   = f_att5B( ytr_tof[0] )/correction;
2038        } else {
2039          adcHe   = Get_adc_he(ii, xtr_tof, ytr_tof)/correction;
2040        };
2041        if(adcHe<=0){
2042          if ( debug ) printf(" %i adcHe<=0 \n",ii);
2043          //      eDEDXpmt->AddAt((Float_t)adccorr,ii); //?
2044          continue;
2045        }
2046        if ( exitat == 2 ){
2047          if(ii==9 && S115B_break==1)  eDEDXpmt->AddAt(36.*(Float_t)adccorr/adcHe,ii);
2048          else  adclin  = 4.*(Float_t)adccorr/adcHe;
2049          continue;
2050        }
2051    
2052        if(ii==9 && S115B_break==1)  adcnorm = f_pos5B(adccorr);
2053        else adcnorm = f_pos( (parPos[ii]), adccorr);
2054        if(adcnorm<=0){
2055          if ( debug ) printf(" %i adcnorm<=0 \n",ii);
2056          //      eDEDXpmt->AddAt((Float_t)adccorr,ii);//?
2057          continue;
2058        }
2059        if ( debug ) printf(" adcnorm %f \n",adcnorm);
2060    
2061        if(ii==9 && S115B_break==1)  adclin  = 36.*adcnorm/adcHe;
2062        else  adclin  = 4.*adcnorm/adcHe;
2063        if ( debug ) printf(" adclin %f \n",adclin);
2064        if(adclin<=0){
2065          if ( debug ) printf(" %i adclin<=0 \n",ii);
2066          //      eDEDXpmt->AddAt((Float_t)adccorr,ii);//?
2067          continue;
2068        }
2069        if ( exitat == 3 ){
2070          if(ii==9 && S115B_break==1)  eDEDXpmt->AddAt((Float_t)adclin,ii);
2071          else  eDEDXpmt->AddAt((Float_t)adclin,ii);
2072          continue;
2073        }
2074        //
2075        if ( betamean > 99. ){
2076          //      eDEDXpmt.AddAt((Float_t)adclin,ii);
2077          eDEDXpmt->AddAt((Float_t)adclin,ii);
2078          //      printf(" AAPMT IS %i dedx is %f vector is %f \n",ii,adclin,eDEDXpmt[ii]);
2079          if ( debug ) printf(" %i betamean > 99 \n",ii);
2080          continue;
2081        };
2082        //
2083        double dEdxHe=-2;
2084        if(ii==9 && S115B_break==1){
2085          if( betamean <1. ) dEdxHe = f_BB5B( betamean );
2086          else                       dEdxHe = 33;
2087        } else {
2088          if( betamean <1. ) dEdxHe = f_BB( (parBBneg[ii]), betamean );
2089          else                       dEdxHe = parBBpos[ii];
2090        }
2091        
2092        if ( debug ) printf(" dEdxHe %f \n",dEdxHe);
2093        
2094        if(dEdxHe<=0){
2095          eDEDXpmt->AddAt((Float_t)adclin,ii);
2096          if ( debug ) printf(" %i dEdxHe<=0 \n",ii);
2097          continue;
2098        };
2099    
2100        if(ii==9 && S115B_break==1)  dEdx = f_desatBB5B( adclin );
2101        else  dEdx = f_desatBB((parDesatBB[ii]), adclin );
2102    
2103        if(dEdx<=0){
2104          eDEDXpmt->AddAt((Float_t)adclin,ii);
2105          if ( debug ) printf(" %i dEdx<=0 \n",ii);
2106          continue;
2107        };
2108    
2109        if ( debug ) printf(" dEdx %f \n",dEdx);
2110        eDEDXpmt->AddAt((Float_t)dEdx,ii);
2111        //    eDEDXpmt.AddAt((Float_t)dEdx,ii);
2112    
2113        //    printf(" PMT IS %i dedx is %f vector is %f \n",ii,dEdx,eDEDXpmt[ii]);
2114    
2115      }  //end loop on 48 PMT
2116    
2117    };
2118    
2119    
2120    //------------------------------------------------------------------------
2121    void ToFdEdx::Define_PMTsat()
2122    {
2123      Float_t  sat[48] = {
2124        3176.35,3178.19,3167.38,3099.73,3117.00,3126.29,3111.44,3092.27,
2125        3146.48,3094.41,3132.13,3115.37,3099.32,3110.97,3111.80,3143.14,
2126        3106.72,3153.44,3136.00,3188.96,3104.73,3140.45,3073.18,3106.62,
2127        3112.48,3146.92,3127.24,3136.52,3109.59,3112.89,3045.15,3147.26,
2128        3095.92,3121.05,3083.25,3123.62,3150.92,3125.30,3067.60,3160.18,
2129        3119.36,3108.92,3164.77,3133.64,3111.47,3131.98,3128.87,3135.56 };
2130      PMTsat.Set(48,sat);
2131    }
2132    
2133    //------------------------------------------------------------------------
2134    void ToFdEdx::ReadParBBpos( const char *fname )
2135    {
2136      //  printf("read %s\n",fname);
2137      parBBpos.Set(48);
2138      FILE *fattin = fopen( fname , "r" );
2139      for (int i=0; i<48; i++) {
2140        int   tid=0;
2141        float  tp;
2142        if(fscanf(fattin,"%d %f",
2143                  &tid, &tp )!=2) break;
2144        parBBpos[i]=tp;
2145      }
2146      fclose(fattin);
2147    }
2148    
2149    //------------------------------------------------------------------------
2150    void ToFdEdx::ReadParDesatBB( const char *fname )
2151    {
2152      //  printf("read %s\n",fname);
2153      FILE *fattin = fopen( fname , "r" );
2154      for (int i=0; i<48; i++) {
2155        int   tid=0;
2156        float  tp[3];
2157        if(fscanf(fattin,"%d %f %f %f",
2158                  &tid, &tp[0], &tp[1], &tp[2] )!=4) break;
2159        parDesatBB[i].Set(3,tp);
2160      }
2161      fclose(fattin);
2162    }
2163    
2164    
2165    //------------------------------------------------------------------------
2166    void ToFdEdx::ReadParBBneg( const char *fname )
2167    
2168    {
2169      //  printf("read %s\n",fname);
2170      FILE *fattin = fopen( fname , "r" );
2171      for (int i=0; i<48; i++) {
2172        int   tid=0;
2173        float  tp[3];
2174        if(fscanf(fattin,"%d %f %f %f",
2175                  &tid, &tp[0], &tp[1], &tp[2] )!=4) break;
2176        parBBneg[i].Set(3,tp);
2177      }
2178      fclose(fattin);
2179    }
2180    
2181    //------------------------------------------------------------------------
2182    void ToFdEdx::ReadParPos( const char *fname )
2183    {
2184      //  printf("read %s\n",fname);
2185      FILE *fattin = fopen( fname , "r" );
2186      for (int i=0; i<48; i++) {
2187        int   tid=0;
2188        float  tp[4];
2189        if(fscanf(fattin,"%d %f %f %f %f",
2190                  &tid, &tp[0], &tp[1], &tp[2], &tp[3])!=5) break;
2191        parPos[i].Set(4,tp);
2192      }
2193      fclose(fattin);
2194    }
2195    
2196    //------------------------------------------------------------------------
2197    void ToFdEdx::ReadParAtt( const char *fname )
2198    {
2199      //  printf("read %s\n",fname);
2200      FILE *fattin = fopen( fname , "r" );
2201      for (int i=0; i<48; i++) {
2202        int   tid=0;
2203        float  tp[6];
2204        if(fscanf(fattin,"%d %f %f %f %f %f %f",
2205                  &tid, &tp[0], &tp[1], &tp[2], &tp[3], &tp[4], &tp[5] )!=7) break;
2206        parAtt[i].Set(6,tp);
2207      }
2208      fclose(fattin);
2209    }
2210    
2211    
2212    
2213    
2214    
2215    
2216    double ToFdEdx::f_att( TArrayF &p, float x )
2217    {
2218      return
2219        p[0] +
2220        p[1]*x +
2221        p[2]*x*x +
2222        p[3]*x*x*x +
2223        p[4]*x*x*x*x +
2224        p[5]*x*x*x*x*x;
2225    }
2226    //------------------------------------------------------------------------
2227    double ToFdEdx::f_att5B( float x )
2228    {
2229      return
2230        101.9409 +
2231        6.643781*x +
2232        0.2765518*x*x +
2233        0.004617647*x*x*x +
2234        0.0006195132*x*x*x*x +
2235        0.00002813734*x*x*x*x*x;
2236    }
2237    
2238    
2239    double ToFdEdx::f_pos( TArrayF &p, float x )
2240    {
2241      return
2242        p[0] +
2243        p[1]*x +
2244        p[2]*x*x +
2245        p[3]*x*x*x;
2246    }
2247    
2248    double ToFdEdx::f_pos5B( float x )
2249    {
2250      return
2251        15.45132 +
2252        0.8369721*x +
2253        0.0005*x*x;
2254    }
2255    
2256    
2257    
2258    double ToFdEdx::f_adcPC( float x )
2259    {
2260      return 28.12+0.6312*x-5.647e-05*x*x+3.064e-08*x*x*x;
2261    }
2262    
2263    
2264    float ToFdEdx::Get_adc_he( int id, float pl_x[6], float pl_y[6])
2265    {
2266    
2267      //
2268      // input: id - pmt [0:47}
2269      //             pl_x - coord x of the tof plane
2270      //             pl_y - coord y
2271    
2272      adc_he = 0;
2273      if( eGeom.GetXY(id)==1 )  adc_he = f_att( (parAtt[id]), pl_x[eGeom.GetPlane(id)] );
2274      if( eGeom.GetXY(id)==2 )  adc_he = f_att( (parAtt[id]), pl_y[eGeom.GetPlane(id)] );
2275      return adc_he;
2276    }
2277    
2278    //------------------------------------------------------------------------
2279    double ToFdEdx::f_BB( TArrayF &p, float x )
2280    {
2281      return  p[0]/(x*x)*(log(x*x/(1-x*x)) - p[1]*x*x - p[2]);
2282    }
2283    
2284    //------------------------------------------------------------------------
2285    double ToFdEdx::f_BB5B( float x )
2286    {
2287      return  0.165797/(x*x)*(log(x*x/(1-x*x)) + 140.481*x*x + 52.9258);
2288    }
2289    //------------------------------------------------------------------------
2290    double ToFdEdx::f_desatBB( TArrayF &p, float x )
2291    {
2292      return
2293        p[0] +
2294        p[1]*x +
2295        p[2]*x*x;
2296    }
2297    
2298    //------------------------------------------------------------------------
2299    double ToFdEdx::f_desatBB5B( float x )
2300    {
2301      return
2302        -2.4 +
2303        0.75*x +
2304        0.009*x*x;
2305    }
2306    
Legend:
Removed from v.1.16  
changed lines
  Added in v.1.43
  ViewVC Help
Powered by ViewVC 1.1.23