/[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.21 by mocchiut, Fri Apr 18 18:55:53 2008 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    
11  #include <ToFLevel2.h>  #include <ToFLevel2.h>
   
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 16  ToFPMT::ToFPMT(){ Line 21  ToFPMT::ToFPMT(){
21    adc = 0.;    adc = 0.;
22    tdc_tw = 0.;    tdc_tw = 0.;
23    tdc = 0.;    tdc = 0.;
24      l0flag_adc = 0.;
25      l0flag_tdc = 0.;
26  }  }
27    
28  ToFPMT::ToFPMT(const ToFPMT &t){  ToFPMT::ToFPMT(const ToFPMT &t){
# Line 106  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(Option_t *t){  void ToFLevel2::Clear(Option_t *t){
128    //    //
# Line 113  void ToFLevel2::Clear(Option_t *t){ Line 130  void ToFLevel2::Clear(Option_t *t){
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    
# Line 143  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 206  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 216  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 381  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 394  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 427  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 439  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 508  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 541  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 559  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 577  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 594  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 611  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 628  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 697  void ToFLevel2::GetPMTPaddle(Int_t pmt_i Line 962  void ToFLevel2::GetPMTPaddle(Int_t pmt_i
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;    pmtleft=paddle*2;
965    pmtright= pmtleft+1;    pmtright= pmtleft+1;  
966    return;    return;
967  }  }
968    
# Line 821  Int_t ToFLevel2::GetPaddleid(Int_t plane Line 1086  Int_t ToFLevel2::GetPaddleid(Int_t plane
1086    }    }
1087    padid=paddle+somma;    padid=paddle+somma;
1088    return padid;    return padid;
1089    
1090  }  }
1091    
1092    
# Line 849  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 904  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  /// wm feb 08
1176    
1177  /**  /**
# Line 1050  Int_t ibot[12] = {4,5,4,5,4,5,4,5,2,3,2, Line 1318  Int_t ibot[12] = {4,5,4,5,4,5,4,5,2,3,2,
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).
1323   */   */
# Line 1106  Int_t ToFLevel2::Process(TrkLevel2 *trk, Line 1373  Int_t ToFLevel2::Process(TrkLevel2 *trk,
1373    //    //
1374    // Copiare qui qualcosa di simile a calonuclei per evitare di riprocessare sempre tutto    // 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    // structures to communicate with F77    // Set arrays and initialize structure
1858    //    //  eDEDXpmt.Set(48);    eDEDXpmt.Reset(-1);   // Set array size  and reset structure
1859    extern struct ToFInput  tofinput_;    eDEDXpmt->Set(48);    eDEDXpmt->Reset(-1);   // Set array size  and reset structure
   extern struct ToFOutput tofoutput_;  
   //  
   // DB connection  
   //  
   TString host;  
   TString user;  
   TString psw;  
   const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");  
   const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");  
   const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");  
   if ( !pamdbhost ) pamdbhost = "";  
   if ( !pamdbuser ) pamdbuser = "";  
   if ( !pamdbpsw ) pamdbpsw = "";  
   if ( strcmp(pamdbhost,"") ) host = pamdbhost;  
   if ( strcmp(pamdbuser,"") ) user = pamdbuser;  
   if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;  
   //  
   //  
   TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());  
   if ( !dbc->IsConnected() ) return 1;  
   stringstream myquery;  
   myquery.str("");  
   myquery << "SET time_zone='+0:00'";  
   dbc->Query(myquery.str().c_str());  
   GL_PARAM *glparam = new GL_PARAM();  
   glparam->Query_GL_PARAM(1,1,dbc); // parameters stored in DB in GL_PRAM table  
   trk->LoadField(glparam->PATH+glparam->NAME);  
   //  
   Bool_t defcal = true;  
   Int_t error=glparam->Query_GL_PARAM(run->RUNHEADER_TIME,201,dbc); // parameters stored in DB in GL_PRAM table  
   if ( error<0 ) {  
     return(1);  
   };  
   printf(" Reading ToF parameter file: %s \n",(glparam->PATH+glparam->NAME).Data());  
   if ( (UInt_t)glparam->TO_TIME != (UInt_t)4294967295UL ) defcal = false;  
1860    //    //
1861    Int_t nlen = (Int_t)(glparam->PATH+glparam->NAME).Length();  };
1862    rdtofcal((char *)(glparam->PATH+glparam->NAME).Data(),&nlen);  
1863    //------------------------------------------------------------------------
1864    void ToFdEdx::Print(Option_t *option)
1865    {
1866    //    //
1867    Int_t adc[4][12];    printf("========================================================================\n");
1868    Int_t tdc[4][12];  
1869    Float_t tdcc[4][12];  };
1870    //  
1871    // process tof data  //------------------------------------------------------------------------
1872    //  void ToFdEdx::Init(pamela::tof::TofEvent *tofl0)
1873    for (Int_t hh=0; hh<12;hh++){  {
     for (Int_t kk=0; kk<4;kk++){  
            adc[kk][hh] = 4095;  
            tdc[kk][hh] = 4095;  
            tdcc[kk][hh] = 4095.;  
            tofinput_.adc[hh][kk] = 4095;  
            tofinput_.tdc[hh][kk] = 4095;  
     };  
   };  
   Int_t ntrkentry = 0;  
   Int_t npmtentry = 0;  
   Int_t gg = 0;  
   Int_t hh = 0;  
   Int_t adcf[48];  
   memset(adcf, 0, 48*sizeof(Int_t));  
   Int_t tdcf[48];  
   memset(tdcf, 0, 48*sizeof(Int_t));  
   for (Int_t pm=0; pm < this->ntrk() ; pm++){  
      ToFTrkVar *ttf = this->GetToFTrkVar(pm);  
      for ( Int_t nc=0; nc < ttf->npmttdc; nc++){  
             if ( (ttf->tdcflag).At(nc) != 0 ) tdcf[(ttf->pmttdc).At(nc)] = 1;  
      };  
      for ( Int_t nc=0; nc < ttf->npmtadc; nc++){  
             if ( (ttf->adcflag).At(nc) != 0 ) adcf[(ttf->pmtadc).At(nc)] = 1;  
      };  
   };  
1874    //    //
1875    for (Int_t pm=0; pm < this->npmt() ; pm++){    ToFLevel2 tf;
1876       ToFPMT *pmt = this->GetToFPMT(pm);    for (Int_t gg=0; gg<4;gg++){
1877       this->GetPMTIndex(pmt->pmt_id, gg, hh);      for (Int_t hh=0; hh<12;hh++){
1878       if ( adcf[pmt->pmt_id] == 0 ){        //          tofinput_.tdc[hh][gg]=tofEvent->tdc[gg][hh];          
1879               tofinput_.adc[gg][hh] = (int)pmt->adc;        int mm = tf.GetPMTid(gg,hh);        
1880               adc[hh][gg] = (int)pmt->adc;        adc[mm]= (0xFFF & tofl0->adc[gg][hh]); // EM, exclude warning bits
1881       };      };      
      if ( tdcf[pmt->pmt_id] == 0 ){  
              tofinput_.tdc[gg][hh] = (int)pmt->tdc;  
              tdc[hh][gg] = (int)pmt->tdc;  
      };  
      tdcc[hh][gg] = (float)pmt->tdc_tw;  
      // Int_t pppid = this->GetPMTid(hh,gg);  
      //      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);  
1882    };    };
1883      
1884    };
1885    
1886    //------------------------------------------------------------------------
1887    void ToFdEdx::Init(Int_t gg, Int_t hh, Float_t adce)
1888    {
1889    //    //
1890    Int_t unpackError = this->unpackError;    ToFLevel2 tf;
1891    //    //  for (Int_t gg=0; gg<4;gg++){
1892    for (Int_t hh=0; hh<5;hh++){    //    for (Int_t hh=0; hh<12;hh++){
1893       tofinput_.patterntrig[hh]=trg->patterntrig[hh];    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    this->Clear();    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        Int_t pmt_id = 0;    // input: id - pmt [0:47}
2269        ToFPMT *t_pmt = new ToFPMT();    //             pl_x - coord x of the tof plane
2270        if(!(this->PMT)) this->PMT = new TClonesArray("ToFPMT",12); //ELENA    //             pl_y - coord y
2271        TClonesArray &tpmt = *this->PMT;  
2272        ToFTrkVar *t_tof = new ToFTrkVar();    adc_he = 0;
2273        if(!(this->ToFTrk)) this->ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA    if( eGeom.GetXY(id)==1 )  adc_he = f_att( (parAtt[id]), pl_x[eGeom.GetPlane(id)] );
2274        TClonesArray &t = *this->ToFTrk;    if( eGeom.GetXY(id)==2 )  adc_he = f_att( (parAtt[id]), pl_y[eGeom.GetPlane(id)] );
2275        //    return adc_he;
2276        //  }
       // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract common and track-related  variables.  
       //  
       npmtentry = 0;  
       //  
       ntrkentry = 0;  
       //  
       // Calculate tracks informations from ToF alone  
       //  
       tofl2com();  
       //  
       memcpy(this->tof_j_flag,tofoutput_.tof_j_flag,6*sizeof(Int_t));  
       //  
       t_tof->trkseqno = -1;  
       //  
       // and now we must copy from the output structure to the level2 class:  
       //  
       t_tof->npmttdc = 0;  
       //  
       for (Int_t hh=0; hh<12;hh++){  
         for (Int_t kk=0; kk<4;kk++){  
           if ( tofoutput_.tofmask[hh][kk] != 0 ){  
             pmt_id = this->GetPMTid(kk,hh);  
             t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);  
             t_tof->tdcflag.AddAt(tofoutput_.tdcflagtof[hh][kk],t_tof->npmttdc); // gf: Jan 09/07  
             t_tof->npmttdc++;  
           };  
         };  
       };  
       for (Int_t kk=0; kk<13;kk++){  
         t_tof->beta[kk] = tofoutput_.betatof_a[kk];  
       }  
       //  
       t_tof->npmtadc = 0;  
       for (Int_t hh=0; hh<12;hh++){  
         for (Int_t kk=0; kk<4;kk++){  
           if ( tofoutput_.adctof_c[hh][kk] < 1000 ){  
             t_tof->dedx.AddAt(tofoutput_.adctof_c[hh][kk],t_tof->npmtadc);  
             pmt_id = this->GetPMTid(kk,hh);  
             t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);  
             t_tof->adcflag.AddAt(tofoutput_.adcflagtof[hh][kk],t_tof->npmtadc); // gf: Jan 09/07  
             t_tof->npmtadc++;  
           };  
         };  
       };  
       //  
       memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));  
       memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));  
       memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));  
       memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));  
       //  
       new(t[ntrkentry]) ToFTrkVar(*t_tof);  
       ntrkentry++;  
       t_tof->Clear();  
       //  
       //  
       //  
       t_pmt->Clear();  
       //  
       for (Int_t hh=0; hh<12;hh++){  
         for (Int_t kk=0; kk<4;kk++){  
          // new WM  
           if ( tofoutput_.tdc_c[hh][kk] < 4095 || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){  
 //          if ( tdcc[kk][hh] < 4095. || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){  
             //  
             t_pmt->pmt_id = this->GetPMTid(kk,hh);  
             t_pmt->tdc_tw = tofoutput_.tdc_c[hh][kk];  
             t_pmt->adc = (Float_t)adc[kk][hh];  
             t_pmt->tdc = (Float_t)tdc[kk][hh];  
             //  
             new(tpmt[npmtentry]) ToFPMT(*t_pmt);  
             npmtentry++;  
             t_pmt->Clear();  
           };  
         };  
       };  
       //  
       // Calculate track-related variables  
       //  
       if ( trk->ntrk() > 0 ){  
         //  
         // We have at least one track  
         //  
         //  
         // Run over tracks  
         //  
         for(Int_t nt=0; nt < trk->ntrk(); nt++){  
           //  
           TrkTrack *ptt = trk->GetStoredTrack(nt);  
           //  
           // Copy the alpha vector in the input structure  
           //  
           for (Int_t e = 0; e < 5 ; e++){  
             tofinput_.al_pp[e] = ptt->al[e];  
           };  
           //  
           // Get tracker related variables for this track  
           //  
           toftrk();  
           //  
           // Copy values in the class from the structure (we need to use a temporary class to store variables).  
           //  
           t_tof->npmttdc = 0;  
           for (Int_t hh=0; hh<12;hh++){  
             for (Int_t kk=0; kk<4;kk++){  
               if ( tofoutput_.tofmask[hh][kk] != 0 ){  
                 pmt_id = this->GetPMTid(kk,hh);  
                 t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);  
                 t_tof->tdcflag.AddAt(tofoutput_.tdcflag[hh][kk],t_tof->npmttdc); // gf: Jan 09/07  
                 t_tof->npmttdc++;  
               };  
             };  
           };  
           for (Int_t kk=0; kk<13;kk++){  
             t_tof->beta[kk] = tofoutput_.beta_a[kk];  
           };  
           //  
           t_tof->npmtadc = 0;  
           for (Int_t hh=0; hh<12;hh++){  
             for (Int_t kk=0; kk<4;kk++){  
               if ( tofoutput_.adc_c[hh][kk] < 1000 ){  
                 t_tof->dedx.AddAt(tofoutput_.adc_c[hh][kk],t_tof->npmtadc);  
                 pmt_id = this->GetPMTid(kk,hh);  
                 t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);  
                 t_tof->adcflag.AddAt(tofoutput_.adcflag[hh][kk],t_tof->npmtadc); // gf: Jan 09/07  
                 t_tof->npmtadc++;  
               };  
             };  
           };  
           //  
           memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));  
           memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));  
           memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));  
           memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));  
           //  
           // Store the tracker track number in order to be sure to have shyncronized data during analysis  
           //  
           t_tof->trkseqno = nt;  
           //  
           // create a new object for this event with track-related variables  
           //  
           new(t[ntrkentry]) ToFTrkVar(*t_tof);  
           ntrkentry++;  
           t_tof->Clear();  
           //  
         }; // loop on all the tracks  
       //  
       this->unpackError = unpackError;  
       if ( defcal ){  
         this->default_calib = 1;  
       } else {  
         this->default_calib = 0;  
       };  
  };  
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    return(0);  //------------------------------------------------------------------------
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.21  
changed lines
  Added in v.1.43
  ViewVC Help
Powered by ViewVC 1.1.23