/[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.26 by carbone, Fri Nov 20 11:05:21 2009 UTC revision 1.45 by pam-fi, Tue Mar 24 11:09:54 2015 UTC
# Line 21  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 111  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 118  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 148  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 211  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 221  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  //wm Nov 08
293  //gf Apr 07  //gf Apr 07
294  /**  /**
295   * Method to get the mean dEdx from a ToF layer - ATTENTION:   * Method to get the mean dEdx from a ToF layer
296   * It will sum up the dEdx of all the paddles, but since by definition   * By definition there should be PMTs with dEdx values only in one paddle of a layer
297   * only the paddle hitted by the track gets a dEdx value and the other   * (the paddle hitted by the track), this method looks for the hitted paddle
298   * paddles are set to zero, the output is just the dEdx of the hitted   * and gives the mean dEdx of that paddle as the output
299   * paddle in each layer!   * 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   * 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   * definition= 1 mip and not a real measurement), anyway left in the code
302   * @param notrack Track Number   * @param notrack Track Number
# Line 236  Int_t ToFLevel2::GetNHitPaddles(Int_t pl Line 304  Int_t ToFLevel2::GetNHitPaddles(Int_t pl
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 object
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(trk, 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(trk, 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(trk, 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 328  Int_t ToFLevel2::GetPlaneIndex(Int_t pmt Line 453  Int_t ToFLevel2::GetPlaneIndex(Int_t pmt
453   */   */
454  Int_t ToFLevel2::GetPMTid(Int_t hh, Int_t kk){  Int_t ToFLevel2::GetPMTid(Int_t hh, Int_t kk){
455    //    //
456    short tof[4][24] = {    static const short tof[4][24] = {
457      {4, 4,  4,  4,  1,  1, 2, 2,  3,  3, 3, 3,  3,  3, 1, 1,  1,  1, 2, 3,  3, 3, 3,  4},      {4, 4,  4,  4,  1,  1, 2, 2,  3,  3, 3, 3,  3,  3, 1, 1,  1,  1, 2, 3,  3, 3, 3,  4},
458      {1, 3,  5,  7, 10, 12, 2, 4,  2,  4, 6, 8, 10, 12, 1, 5,  3,  9, 7, 9, 11, 1, 5,  9},      {1, 3,  5,  7, 10, 12, 2, 4,  2,  4, 6, 8, 10, 12, 1, 5,  3,  9, 7, 9, 11, 1, 5,  9},
459      {2, 2,  2,  2,  1,  1, 1, 1,  4,  4, 4, 4,  4,  4, 2, 1,  2,  1, 2, 2,  2, 3, 3,  4},      {2, 2,  2,  2,  1,  1, 1, 1,  4,  4, 4, 4,  4,  4, 2, 1,  2,  1, 2, 2,  2, 3, 3,  4},
# Line 364  Int_t ToFLevel2::GetPMTid(Int_t hh, Int_ Line 489  Int_t ToFLevel2::GetPMTid(Int_t hh, Int_
489   */   */
490  void ToFLevel2::GetPMTIndex(Int_t ind, Int_t &hb, Int_t &ch){  void ToFLevel2::GetPMTIndex(Int_t ind, Int_t &hb, Int_t &ch){
491    //    //
492    short tof[4][24] = {    static const short tof[4][24] = {
493      {4, 4,  4,  4,  1,  1, 2, 2,  3,  3, 3, 3,  3,  3, 1, 1,  1,  1, 2, 3,  3, 3, 3,  4},      {4, 4,  4,  4,  1,  1, 2, 2,  3,  3, 3, 3,  3,  3, 1, 1,  1,  1, 2, 3,  3, 3, 3,  4},
494      {1, 3,  5,  7, 10, 12, 2, 4,  2,  4, 6, 8, 10, 12, 1, 5,  3,  9, 7, 9, 11, 1, 5,  9},      {1, 3,  5,  7, 10, 12, 2, 4,  2,  4, 6, 8, 10, 12, 1, 5,  3,  9, 7, 9, 11, 1, 5,  9},
495      {2, 2,  2,  2,  1,  1, 1, 1,  4,  4, 4, 4,  4,  4, 2, 1,  2,  1, 2, 2,  2, 3, 3,  4},      {2, 2,  2,  2,  1,  1, 1, 1,  4,  4, 4, 4,  4,  4, 2, 1,  2,  1, 2, 2,  2, 3, 3,  4},
# Line 404  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  /*    ToFTrkVar *trk = GetToFTrkVar(notrack);
533  Float_t  PMTsat[48] = {    this->GetdEdxPaddle(trk, paddleid, adcfl, PadEdx, SatWarning);
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,  //  wm Nov 08 revision - saturation values included
539  3106.33, 3094.85, 3150.85, 3118.8, 3096.24, 3118.47,3111.36, 3117.11 } ;  /// gf Apr 07
540  */  /**
541     * Method to get the dEdx from a given ToF paddle.
542  // new values from Napoli dec 2008   * If two PMTs are good, the mean dEdx of both PMTs is taken, otherwise
543  Float_t  PMTsat[48] = {   * just the dEdx of the "good" PMT. If both PMTs are above saturation => dEdx=1000
544  3176.35,3178.19,3167.38,3099.73,3117.00,3126.29,3111.44,3092.27,   * @param notrack Track Number
545  3146.48,3094.41,3132.13,3115.37,3099.32,3110.97,3111.80,3143.14,   * @param Paddle index (0,1,...,23).
546  3106.72,3153.44,3136.00,3188.96,3104.73,3140.45,3073.18,3106.62,   * @param adcflag in the paddle (100<-> independent of the adcflag; !=0&&!=100 <-> at least one PMT with adcflag!=0; )
547  3112.48,3146.92,3127.24,3136.52,3109.59,3112.89,3045.15,3147.26,   * @param PadEdx dEdx from a given ToF paddle
548  3095.92,3121.05,3083.25,3123.62,3150.92,3125.30,3067.60,3160.18,   * @param SatWarning 1 if the PMT ios near saturation region (adcraw ~3000)
549  3119.36,3108.92,3164.77,3133.64,3111.47,3131.98,3128.87,3135.56 };   */
550    void ToFLevel2::GetdEdxPaddle(ToFTrkVar *trk, Int_t paddleid, Int_t adcfl, Float_t &PadEdx, Int_t &SatWarning){
551    
552      /*
553        Float_t  PMTsat[48] = {
554        3162.14, 3165.48, 3153.85, 3085.73, 3089.65, 3107.64, 3097.52, 3078.37,
555        3130.05, 3087.07, 3112.22, 3102.92, 3080.58, 3092.55, 3087.94, 3125.03,
556        3094.09, 3143.16, 3125.51, 3181.27, 3092.09, 3124.98, 3069.3, 3095.53,
557        3097.11, 3133.53, 3114.73, 3113.01, 3091.19, 3097.99, 3033.84, 3134.98,
558        3081.37, 3111.04, 3066.77, 3108.17, 3133, 3111.06, 3052.52, 3140.66,
559        3106.33, 3094.85, 3150.85, 3118.8, 3096.24, 3118.47,3111.36, 3117.11 } ;
560      */
561    
562  for (Int_t i=0; i<48;i++) PMTsat[i] = PMTsat[i] - 5.;  // safety margin    // new values from Napoli dec 2008
563      Float_t  PMTsat[48] = {
564        3176.35,3178.19,3167.38,3099.73,3117.00,3126.29,3111.44,3092.27,
565        3146.48,3094.41,3132.13,3115.37,3099.32,3110.97,3111.80,3143.14,
566        3106.72,3153.44,3136.00,3188.96,3104.73,3140.45,3073.18,3106.62,
567        3112.48,3146.92,3127.24,3136.52,3109.59,3112.89,3045.15,3147.26,
568        3095.92,3121.05,3083.25,3123.62,3150.92,3125.30,3067.60,3160.18,
569        3119.36,3108.92,3164.77,3133.64,3111.47,3131.98,3128.87,3135.56 };
570    
571      for (Int_t i=0; i<48;i++) PMTsat[i] = PMTsat[i] - 5.;  // safety margin
572    
573    
574    PadEdx = 0.;    PadEdx = 0.;
575  //  SatWarning = 1000;    //  SatWarning = 1000;
576    SatWarning = 0;   // 0=good, increase for each bad PMT    SatWarning = 0;   // 0=good, increase for each bad PMT
577    
578    Float_t dEdx[48] = {0};    Float_t dEdx[48] = {0};
579    Int_t pmt_id = -1;    Int_t pmt_id = -1;
580    Float_t adcraw[48];    Float_t adcraw[48];
581    //    //
   ToFTrkVar *trk = GetToFTrkVar(notrack);  
582    if(!trk) return; //ELENA    if(!trk) return; //ELENA
583    //    //
584    
# Line 474  for (Int_t i=0; i<48;i++) PMTsat[i] = PM Line 618  for (Int_t i=0; i<48;i++) PMTsat[i] = PM
618    }    }
619    
620    
621  //  if( adcraw[pmtleft] >3000 || adcraw[pmtright] >3000)SatWarning=1;  //old version    //  if( adcraw[pmtleft] >3000 || adcraw[pmtright] >3000)SatWarning=1;  //old version
622    
623  // Increase SatWarning Counter for each PMT>Sat    // Increase SatWarning Counter for each PMT>Sat
624    if( adcraw[pmtleft] > PMTsat[pmtleft])SatWarning++;      if( adcraw[pmtleft] > PMTsat[pmtleft])SatWarning++;  
625    if( adcraw[pmtright] > PMTsat[pmtright])SatWarning++;    if( adcraw[pmtright] > PMTsat[pmtright])SatWarning++;
626    
627  // if ADC  > sat set dEdx=1000    // if ADC  > sat set dEdx=1000
628    if( adcraw[pmtleft] > PMTsat[pmtleft]) dEdx[pmtleft] = 1000.;    if( adcraw[pmtleft] > PMTsat[pmtleft]) dEdx[pmtleft] = 1000.;
629    if( adcraw[pmtright] > PMTsat[pmtright]) dEdx[pmtright] = 1000. ;    if( adcraw[pmtright] > PMTsat[pmtright]) dEdx[pmtright] = 1000. ;
630    
631  // if two PMT are good, take mean dEdx, otherwise only the good dEdx    // if two PMT are good, take mean dEdx, otherwise only the good dEdx
632    if(dEdx[pmtleft]<1000 && dEdx[pmtright]<1000) PadEdx = (dEdx[pmtleft]+dEdx[pmtright])*0.5;    if(dEdx[pmtleft]<1000 && dEdx[pmtright]<1000) PadEdx = (dEdx[pmtleft]+dEdx[pmtright])*0.5;
633    if(dEdx[pmtleft]==1000 && dEdx[pmtright]<1000) PadEdx = dEdx[pmtright];      if(dEdx[pmtleft]==1000 && dEdx[pmtright]<1000) PadEdx = dEdx[pmtright];  
634    if(dEdx[pmtleft]<1000 && dEdx[pmtright]==1000) PadEdx = dEdx[pmtleft];    if(dEdx[pmtleft]<1000 && dEdx[pmtright]==1000) PadEdx = dEdx[pmtleft];
635        
636  };  };
 //  
   
637    
638  // gf Apr 07  // gf Apr 07
639    
# Line 507  TString ToFLevel2::GetPMTName(Int_t ind, Line 649  TString ToFLevel2::GetPMTName(Int_t ind,
649        
650    TString pmtname = " ";    TString pmtname = " ";
651        
652    TString photoS[48] = {    static const TString photoS[48] = {
653      "S11_1A", "S11_1B", "S11_2A", "S11_2B", "S11_3A", "S11_3B", "S11_4A",      "S11_1A", "S11_1B", "S11_2A", "S11_2B", "S11_3A", "S11_3B", "S11_4A",
654      "S11_4B",      "S11_4B",
655      "S11_5A", "S11_5B", "S11_6A", "S11_6B", "S11_7A", "S11_7B", "S11_8A",      "S11_5A", "S11_5B", "S11_6A", "S11_6B", "S11_7A", "S11_7B", "S11_8A",
# Line 967  Int_t ToFLevel2::GetNPaddle(Int_t plane) Line 1109  Int_t ToFLevel2::GetNPaddle(Int_t plane)
1109   * @param cut on chi2   * @param cut on chi2
1110   */   */
1111    
 Float_t ToFLevel2::CalcBeta(Int_t notrack, Float_t resmax, Float_t qualitycut, Float_t chi2cut){  
1112    
1113  //  cout<<" in CalcBeta "<<resmax<<" "<<chi2cut<<" "<<qualitycut<<endl;  Float_t ToFTrkVar::CalcBeta( Float_t resmax, Float_t qualitycut, Float_t chi2cut){
1114    
1115    
1116    Float_t bxx = 100.;    Float_t bxx = 100.;
1117    //    //
1118    ToFTrkVar *trk = GetToFTrkVar(notrack);    ToFTrkVar *trk = this;
   if(!trk) return 0; //ELENA  
1119    
1120    
1121    Float_t chi2,xhelp,beta_mean;    Float_t chi2,xhelp,beta_mean;
# Line 1001  Float_t  w_il[6]; Line 1142  Float_t  w_il[6];
1142    for (Int_t i=0; i<trk->npmttdc; i++){    for (Int_t i=0; i<trk->npmttdc; i++){
1143      //      //
1144      pmt_id = (trk->pmttdc).At(i);      pmt_id = (trk->pmttdc).At(i);
1145      pmt_plane = GetPlaneIndex(pmt_id);      pmt_plane = ToFLevel2::GetPlaneIndex(pmt_id);
1146      tdcfl = (trk->tdcflag).At(i);      tdcfl = (trk->tdcflag).At(i);
1147      if (w_il[pmt_plane] != 1.) w_il[pmt_plane] = tdcfl; //tdcflag      if (w_il[pmt_plane] != 1.) w_il[pmt_plane] = tdcfl; //tdcflag
1148                                       };                                       };
# Line 1088  Int_t ibot[12] = {4,5,4,5,4,5,4,5,2,3,2, Line 1229  Int_t ibot[12] = {4,5,4,5,4,5,4,5,2,3,2,
1229    //    //
1230    return(bxx);    return(bxx);
1231  };  };
1232    ////////////////////////////////////////////////////
1233    ////////////////////////////////////////////////////
1234    /**
1235     * See ToFTrkVar::CalcBeta(Float_t,Float_t, Float_t).
1236     */
1237    Float_t ToFLevel2::CalcBeta(Int_t notrack, Float_t resmax, Float_t qualitycut, Float_t chi2cut){
1238    
1239    //  cout<<" in CalcBeta "<<resmax<<" "<<chi2cut<<" "<<qualitycut<<endl;
1240    
1241      ToFTrkVar *trk = GetToFTrkVar(notrack);
1242      if(!trk) return 0; //ELENA
1243    
1244      return trk->CalcBeta(resmax,qualitycut,chi2cut);
1245    
1246    };
1247    
1248    
1249  ////////////////////////////////////////////////////  ////////////////////////////////////////////////////
# Line 1149  Int_t ToFLevel2::Process(TrkLevel2 *trk, Line 1305  Int_t ToFLevel2::Process(TrkLevel2 *trk,
1305    //    //
1306    // 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
1307    //    //
1308      printf("\n\n\n ERROR: NOT IMPLEMENTED ANYMORE, write Emiliano if you need this method (Emiliano.Mocchiutti@ts.infn.it) \n\n\n");
1309      return(-1);
1310      //   //
1311      //   // structures to communicate with F77
1312    //    //   //
1313    // structures to communicate with F77    //   extern struct ToFInput  tofinput_;
1314    //  //   extern struct ToFOutput tofoutput_;
1315    extern struct ToFInput  tofinput_;  //   //
1316    extern struct ToFOutput tofoutput_;  //   // DB connection
1317    //  //   //
1318    // DB connection  //   TString host;
1319    //  //   TString user;
1320    TString host;  //   TString psw;
1321    TString user;  //   const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
1322    TString psw;  //   const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
1323    const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");  //   const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
1324    const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");  //   if ( !pamdbhost ) pamdbhost = "";
1325    const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");  //   if ( !pamdbuser ) pamdbuser = "";
1326    if ( !pamdbhost ) pamdbhost = "";  //   if ( !pamdbpsw ) pamdbpsw = "";
1327    if ( !pamdbuser ) pamdbuser = "";  //   if ( strcmp(pamdbhost,"") ) host = pamdbhost;
1328    if ( !pamdbpsw ) pamdbpsw = "";  //   if ( strcmp(pamdbuser,"") ) user = pamdbuser;
1329    if ( strcmp(pamdbhost,"") ) host = pamdbhost;  //   if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;
1330    if ( strcmp(pamdbuser,"") ) user = pamdbuser;  //   //
1331    if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;  //   //
1332    //  //   TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
1333    //  //   if ( !dbc->IsConnected() ) return 1;
1334    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());  //   stringstream myquery;
1335    if ( !dbc->IsConnected() ) return 1;  //   myquery.str("");
1336    stringstream myquery;  //   myquery << "SET time_zone='+0:00';";
1337    myquery.str("");  //   dbc->Query(myquery.str().c_str());
1338    myquery << "SET time_zone='+0:00'";  //   delete dbc->Query("SET sql_mode = 'NO_UNSIGNED_SUBTRACTION';");
1339    dbc->Query(myquery.str().c_str());  //   GL_PARAM *glparam = new GL_PARAM();
1340    GL_PARAM *glparam = new GL_PARAM();  //   glparam->Query_GL_PARAM(1,1,dbc); // parameters stored in DB in GL_PRAM table
1341    glparam->Query_GL_PARAM(1,1,dbc); // parameters stored in DB in GL_PRAM table  //   trk->LoadField(glparam->PATH+glparam->NAME);
1342    trk->LoadField(glparam->PATH+glparam->NAME);  //   //
1343    //  //   Bool_t defcal = true;
1344    Bool_t defcal = true;  //   Int_t error=glparam->Query_GL_PARAM(run->RUNHEADER_TIME,201,dbc); // parameters stored in DB in GL_PRAM table
1345    Int_t error=glparam->Query_GL_PARAM(run->RUNHEADER_TIME,201,dbc); // parameters stored in DB in GL_PRAM table  //   if ( error<0 ) {
1346    if ( error<0 ) {  //     return(1);
1347      return(1);  //   };
1348    };  //   printf(" Reading ToF parameter file: %s \n",(glparam->PATH+glparam->NAME).Data());
1349    printf(" Reading ToF parameter file: %s \n",(glparam->PATH+glparam->NAME).Data());  //   if ( (UInt_t)glparam->TO_TIME != (UInt_t)4294967295UL ) defcal = false;
1350    if ( (UInt_t)glparam->TO_TIME != (UInt_t)4294967295UL ) defcal = false;  //   //
1351    //  //   Int_t nlen = (Int_t)(glparam->PATH+glparam->NAME).Length();
1352    Int_t nlen = (Int_t)(glparam->PATH+glparam->NAME).Length();  //   rdtofcal((char *)(glparam->PATH+glparam->NAME).Data(),&nlen);
1353    rdtofcal((char *)(glparam->PATH+glparam->NAME).Data(),&nlen);  //   //
1354    //  //   Int_t adc[4][12];
1355    Int_t adc[4][12];  //   Int_t tdc[4][12];
1356    Int_t tdc[4][12];  //   Float_t tdcc[4][12];
1357    Float_t tdcc[4][12];  //   //
1358    //  //   // process tof data
1359    // process tof data  //   //
1360    //  //   for (Int_t hh=0; hh<12;hh++){
1361    for (Int_t hh=0; hh<12;hh++){  //     for (Int_t kk=0; kk<4;kk++){
1362      for (Int_t kk=0; kk<4;kk++){  //            adc[kk][hh] = 4095;
1363             adc[kk][hh] = 4095;  //            tdc[kk][hh] = 4095;
1364             tdc[kk][hh] = 4095;  //            tdcc[kk][hh] = 4095.;
1365             tdcc[kk][hh] = 4095.;  //            tofinput_.adc[hh][kk] = 4095;
1366             tofinput_.adc[hh][kk] = 4095;  //            tofinput_.tdc[hh][kk] = 4095;
1367             tofinput_.tdc[hh][kk] = 4095;  //     };
1368      };  //   };
1369    };  //   Int_t ntrkentry = 0;
1370    Int_t ntrkentry = 0;  //   Int_t npmtentry = 0;
1371    Int_t npmtentry = 0;  //   Int_t gg = 0;
1372    Int_t gg = 0;  //   Int_t hh = 0;
1373    Int_t hh = 0;  //   Int_t adcf[48];
1374    Int_t adcf[48];  //   memset(adcf, 0, 48*sizeof(Int_t));
1375    memset(adcf, 0, 48*sizeof(Int_t));  //   Int_t tdcf[48];
1376    Int_t tdcf[48];  //   memset(tdcf, 0, 48*sizeof(Int_t));
1377    memset(tdcf, 0, 48*sizeof(Int_t));  //   for (Int_t pm=0; pm < this->ntrk() ; pm++){
1378    for (Int_t pm=0; pm < this->ntrk() ; pm++){  //      ToFTrkVar *ttf = this->GetToFTrkVar(pm);
1379       ToFTrkVar *ttf = this->GetToFTrkVar(pm);  //      for ( Int_t nc=0; nc < ttf->npmttdc; nc++){
1380       for ( Int_t nc=0; nc < ttf->npmttdc; nc++){  //             if ( (ttf->tdcflag).At(nc) != 0 ) tdcf[(ttf->pmttdc).At(nc)] = 1;
1381              if ( (ttf->tdcflag).At(nc) != 0 ) tdcf[(ttf->pmttdc).At(nc)] = 1;  //      };
1382       };  //      for ( Int_t nc=0; nc < ttf->npmtadc; nc++){
1383       for ( Int_t nc=0; nc < ttf->npmtadc; nc++){  //             if ( (ttf->adcflag).At(nc) != 0 ) adcf[(ttf->pmtadc).At(nc)] = 1;
1384              if ( (ttf->adcflag).At(nc) != 0 ) adcf[(ttf->pmtadc).At(nc)] = 1;  //      };
1385       };  //   };
1386    };  //   //
1387    //  //   for (Int_t pm=0; pm < this->npmt() ; pm++){
1388    for (Int_t pm=0; pm < this->npmt() ; pm++){  //      ToFPMT *pmt = this->GetToFPMT(pm);
1389       ToFPMT *pmt = this->GetToFPMT(pm);  //      this->GetPMTIndex(pmt->pmt_id, gg, hh);
1390       this->GetPMTIndex(pmt->pmt_id, gg, hh);  //      if ( adcf[pmt->pmt_id] == 0 ){
1391       if ( adcf[pmt->pmt_id] == 0 ){  //              tofinput_.adc[gg][hh] = (int)pmt->adc;
1392               tofinput_.adc[gg][hh] = (int)pmt->adc;  //              adc[hh][gg] = (int)pmt->adc;
1393               adc[hh][gg] = (int)pmt->adc;  //      };
1394       };  //      if ( tdcf[pmt->pmt_id] == 0 ){
1395       if ( tdcf[pmt->pmt_id] == 0 ){  //              tofinput_.tdc[gg][hh] = (int)pmt->tdc;
1396               tofinput_.tdc[gg][hh] = (int)pmt->tdc;  //              tdc[hh][gg] = (int)pmt->tdc;
1397               tdc[hh][gg] = (int)pmt->tdc;  //      };
1398       };  //      tdcc[hh][gg] = (float)pmt->tdc_tw;
1399       tdcc[hh][gg] = (float)pmt->tdc_tw;  //      // Int_t pppid = this->GetPMTid(hh,gg);
1400       // 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);
1401       //      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);  //   };
1402    };  //   //
1403    //  //   Int_t unpackError = this->unpackError;
1404    Int_t unpackError = this->unpackError;  //   //
1405    //  //   for (Int_t hh=0; hh<5;hh++){
1406    for (Int_t hh=0; hh<5;hh++){  //      tofinput_.patterntrig[hh]=trg->patterntrig[hh];
1407       tofinput_.patterntrig[hh]=trg->patterntrig[hh];  //   };
1408    };  //   //
1409    //  //   this->Clear();
1410    this->Clear();  //   //
1411    //  //       Int_t pmt_id = 0;
1412        Int_t pmt_id = 0;  //       ToFPMT *t_pmt = new ToFPMT();
1413        ToFPMT *t_pmt = new ToFPMT();  //       if(!(this->PMT)) this->PMT = new TClonesArray("ToFPMT",12); //ELENA
1414        if(!(this->PMT)) this->PMT = new TClonesArray("ToFPMT",12); //ELENA  //       TClonesArray &tpmt = *this->PMT;
1415        TClonesArray &tpmt = *this->PMT;  //       ToFTrkVar *t_tof = new ToFTrkVar();
1416        ToFTrkVar *t_tof = new ToFTrkVar();  //       if(!(this->ToFTrk)) this->ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA
1417        if(!(this->ToFTrk)) this->ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA  //       TClonesArray &t = *this->ToFTrk;
1418        TClonesArray &t = *this->ToFTrk;  //       //
1419        //  //       //
1420        //  //       // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract common and track-related  variables.
1421        // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract common and track-related  variables.  //       //
1422        //  //       npmtentry = 0;
1423        npmtentry = 0;  //       //
1424        //  //       ntrkentry = 0;
1425        ntrkentry = 0;  //       //
1426        //  //       // Calculate tracks informations from ToF alone
1427        // Calculate tracks informations from ToF alone  //       //
1428        //  //       tofl2com();
1429        tofl2com();  //       //
1430        //  //       memcpy(this->tof_j_flag,tofoutput_.tof_j_flag,6*sizeof(Int_t));
1431        memcpy(this->tof_j_flag,tofoutput_.tof_j_flag,6*sizeof(Int_t));  //       //
1432        //  //       t_tof->trkseqno = -1;
1433        t_tof->trkseqno = -1;  //       //
1434        //  //       // and now we must copy from the output structure to the level2 class:
1435        // and now we must copy from the output structure to the level2 class:  //       //
1436        //  //       t_tof->npmttdc = 0;
1437        t_tof->npmttdc = 0;  //       //
1438        //  //       for (Int_t hh=0; hh<12;hh++){
1439        for (Int_t hh=0; hh<12;hh++){  //         for (Int_t kk=0; kk<4;kk++){
1440          for (Int_t kk=0; kk<4;kk++){  //           if ( tofoutput_.tofmask[hh][kk] != 0 ){
1441            if ( tofoutput_.tofmask[hh][kk] != 0 ){  //             pmt_id = this->GetPMTid(kk,hh);
1442              pmt_id = this->GetPMTid(kk,hh);  //             t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
1443              t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);  //             t_tof->tdcflag.AddAt(tofoutput_.tdcflagtof[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
1444              t_tof->tdcflag.AddAt(tofoutput_.tdcflagtof[hh][kk],t_tof->npmttdc); // gf: Jan 09/07  //             t_tof->npmttdc++;
1445              t_tof->npmttdc++;  //           };
1446            };  //         };
1447          };  //       };
1448        };  //       for (Int_t kk=0; kk<13;kk++){
1449        for (Int_t kk=0; kk<13;kk++){  //         t_tof->beta[kk] = tofoutput_.betatof_a[kk];
1450          t_tof->beta[kk] = tofoutput_.betatof_a[kk];  //       }
1451        }  //       //
1452        //  //       t_tof->npmtadc = 0;
1453        t_tof->npmtadc = 0;  //       for (Int_t hh=0; hh<12;hh++){
1454        for (Int_t hh=0; hh<12;hh++){  //         for (Int_t kk=0; kk<4;kk++){
1455          for (Int_t kk=0; kk<4;kk++){  //           if ( tofoutput_.adctof_c[hh][kk] < 1000 ){
1456            if ( tofoutput_.adctof_c[hh][kk] < 1000 ){  //             t_tof->dedx.AddAt(tofoutput_.adctof_c[hh][kk],t_tof->npmtadc);
1457              t_tof->dedx.AddAt(tofoutput_.adctof_c[hh][kk],t_tof->npmtadc);  //             pmt_id = this->GetPMTid(kk,hh);
1458              pmt_id = this->GetPMTid(kk,hh);  //             t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
1459              t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);  //             t_tof->adcflag.AddAt(tofoutput_.adcflagtof[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
1460              t_tof->adcflag.AddAt(tofoutput_.adcflagtof[hh][kk],t_tof->npmtadc); // gf: Jan 09/07  //             t_tof->npmtadc++;
1461              t_tof->npmtadc++;  //           };
1462            };  //         };
1463          };  //       };
1464        };  //       //
1465        //  //       memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
1466        memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));  //       memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
1467        memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));  //       memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
1468        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));
1469        memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));  //       //
1470        //  //       new(t[ntrkentry]) ToFTrkVar(*t_tof);
1471        new(t[ntrkentry]) ToFTrkVar(*t_tof);  //       ntrkentry++;
1472        ntrkentry++;  //       t_tof->Clear();
1473        t_tof->Clear();  //       //
1474        //  //       //
1475        //  //       //
1476        //  //       t_pmt->Clear();
1477        t_pmt->Clear();  //       //
1478        //  //       for (Int_t hh=0; hh<12;hh++){
1479        for (Int_t hh=0; hh<12;hh++){  //         for (Int_t kk=0; kk<4;kk++){
1480          for (Int_t kk=0; kk<4;kk++){  //          // new WM
1481           // new WM  //           if ( tofoutput_.tdc_c[hh][kk] < 4095 || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){
1482            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 ){
1483  //          if ( tdcc[kk][hh] < 4095. || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){  //             //
1484              //  //             t_pmt->pmt_id = this->GetPMTid(kk,hh);
1485              t_pmt->pmt_id = this->GetPMTid(kk,hh);  //             t_pmt->tdc_tw = tofoutput_.tdc_c[hh][kk];
1486              t_pmt->tdc_tw = tofoutput_.tdc_c[hh][kk];  //             t_pmt->adc = (Float_t)adc[kk][hh];
1487              t_pmt->adc = (Float_t)adc[kk][hh];  //             t_pmt->tdc = (Float_t)tdc[kk][hh];
1488              t_pmt->tdc = (Float_t)tdc[kk][hh];  //             //
1489              //  //             new(tpmt[npmtentry]) ToFPMT(*t_pmt);
1490              new(tpmt[npmtentry]) ToFPMT(*t_pmt);  //             npmtentry++;
1491              npmtentry++;  //             t_pmt->Clear();
1492              t_pmt->Clear();  //           };
1493            };  //         };
1494          };  //       };
1495        };  //       //
1496        //  //       // Calculate track-related variables
1497        // Calculate track-related variables  //       //
1498        //  //       if ( trk->ntrk() > 0 ){
1499        if ( trk->ntrk() > 0 ){  //         //
1500          //  //         // We have at least one track
1501          // We have at least one track  //         //
1502          //  //         //
1503          //  //         // Run over tracks
1504          // Run over tracks  //         //
1505          //  //         for(Int_t nt=0; nt < trk->ntrk(); nt++){
1506          for(Int_t nt=0; nt < trk->ntrk(); nt++){  //           //
1507            //  //           TrkTrack *ptt = trk->GetStoredTrack(nt);
1508            TrkTrack *ptt = trk->GetStoredTrack(nt);  //           //
1509            //  //           // Copy the alpha vector in the input structure
1510            // Copy the alpha vector in the input structure  //           //
1511            //  //           for (Int_t e = 0; e < 5 ; e++){
1512            for (Int_t e = 0; e < 5 ; e++){  //             tofinput_.al_pp[e] = ptt->al[e];
1513              tofinput_.al_pp[e] = ptt->al[e];  //           };
1514            };  //           //
1515            //  //           // Get tracker related variables for this track
1516            // Get tracker related variables for this track  //           //
1517            //  //           toftrk();
1518            toftrk();  //           //
1519            //  //           // Copy values in the class from the structure (we need to use a temporary class to store variables).
1520            // Copy values in the class from the structure (we need to use a temporary class to store variables).  //           //
1521            //  //           t_tof->npmttdc = 0;
1522            t_tof->npmttdc = 0;  //           for (Int_t hh=0; hh<12;hh++){
1523            for (Int_t hh=0; hh<12;hh++){  //             for (Int_t kk=0; kk<4;kk++){
1524              for (Int_t kk=0; kk<4;kk++){  //               if ( tofoutput_.tofmask[hh][kk] != 0 ){
1525                if ( tofoutput_.tofmask[hh][kk] != 0 ){  //                 pmt_id = this->GetPMTid(kk,hh);
1526                  pmt_id = this->GetPMTid(kk,hh);  //                 t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
1527                  t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);  //                 t_tof->tdcflag.AddAt(tofoutput_.tdcflag[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
1528                  t_tof->tdcflag.AddAt(tofoutput_.tdcflag[hh][kk],t_tof->npmttdc); // gf: Jan 09/07  //                 t_tof->npmttdc++;
1529                  t_tof->npmttdc++;  //               };
1530                };  //             };
1531              };  //           };
1532            };  //           for (Int_t kk=0; kk<13;kk++){
1533            for (Int_t kk=0; kk<13;kk++){  //             t_tof->beta[kk] = tofoutput_.beta_a[kk];
1534              t_tof->beta[kk] = tofoutput_.beta_a[kk];  //           };
1535            };  //           //
1536            //  //           t_tof->npmtadc = 0;
1537            t_tof->npmtadc = 0;  //           for (Int_t hh=0; hh<12;hh++){
1538            for (Int_t hh=0; hh<12;hh++){  //             for (Int_t kk=0; kk<4;kk++){
1539              for (Int_t kk=0; kk<4;kk++){  //               if ( tofoutput_.adc_c[hh][kk] < 1000 ){
1540                if ( tofoutput_.adc_c[hh][kk] < 1000 ){  //                 t_tof->dedx.AddAt(tofoutput_.adc_c[hh][kk],t_tof->npmtadc);
1541                  t_tof->dedx.AddAt(tofoutput_.adc_c[hh][kk],t_tof->npmtadc);  //                 pmt_id = this->GetPMTid(kk,hh);
1542                  pmt_id = this->GetPMTid(kk,hh);  //                 t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
1543                  t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);  //                 t_tof->adcflag.AddAt(tofoutput_.adcflag[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
1544                  t_tof->adcflag.AddAt(tofoutput_.adcflag[hh][kk],t_tof->npmtadc); // gf: Jan 09/07  //                 t_tof->npmtadc++;
1545                  t_tof->npmtadc++;  //               };
1546                };  //             };
1547              };  //           };
1548            };  //           //
1549            //  //           memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
1550            memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));  //           memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
1551            memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));  //           memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
1552            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));
1553            memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));  //           //
1554            //  //           // Store the tracker track number in order to be sure to have shyncronized data during analysis
1555            // Store the tracker track number in order to be sure to have shyncronized data during analysis  //           //
1556            //  //           t_tof->trkseqno = nt;
1557            t_tof->trkseqno = nt;  //           //
1558            //  //           // create a new object for this event with track-related variables
1559            // create a new object for this event with track-related variables  //           //
1560            //  //           new(t[ntrkentry]) ToFTrkVar(*t_tof);
1561            new(t[ntrkentry]) ToFTrkVar(*t_tof);  //           ntrkentry++;
1562            ntrkentry++;  //           t_tof->Clear();
1563            t_tof->Clear();  //           //
1564            //  //         }; // loop on all the tracks
1565          }; // loop on all the tracks  //       //
1566        //  //       this->unpackError = unpackError;
1567        this->unpackError = unpackError;  //       if ( defcal ){
1568        if ( defcal ){  //         this->default_calib = 1;
1569          this->default_calib = 1;  //       } else {
1570        } else {  //         this->default_calib = 0;
1571          this->default_calib = 0;  //       };
1572        };  //};
1573   };  //  return(0);
1574    }
1575    
1576    bool ToFLevel2::bit(int decimal, char pos){
1577    return(0);    return( (decimal>>pos)%2 );
1578    }
1579    
1580    bool ToFLevel2::checkPMT(TString givenpmt){
1581      TClonesArray* Pmt = this->PMT;
1582      //  printf(" ou %s entries %i \n",givenpmt.Data(),Pmt->GetEntries());
1583      for(int i=0; i<Pmt->GetEntries(); i++) {  
1584        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1585        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1586        //    printf(" name %s \n",pmtname.Data());
1587        if ( !strcmp(pmtname.Data(),givenpmt.Data()) )
1588          return true;
1589      }
1590      //  printf(" PMT %s missing \n",givenpmt.Data());
1591      return false;
1592    }
1593    
1594    bool ToFLevel2::checkPMTpatternPMThit(TrigLevel2 *trg, int &pmtpattern, int &pmtnosignal){
1595      UInt_t *patterntrig = trg->patterntrig;
1596      pmtpattern = 0;
1597      pmtnosignal = 0;
1598      bool good = true;
1599      //S3
1600      if ( this->bit(patterntrig[2],0) ){ pmtpattern++;  if ( !this->checkPMT("S31_1A")){ pmtnosignal++; good = false;}}
1601      if ( this->bit(patterntrig[2],1) ){ pmtpattern++;  if ( !this->checkPMT("S31_2A")){ pmtnosignal++; good = false;}}
1602      if ( this->bit(patterntrig[2],2) ){ pmtpattern++;  if ( !this->checkPMT("S31_3A")){ pmtnosignal++; good = false;}}
1603      if ( this->bit(patterntrig[2],3) ){ pmtpattern++;  if ( !this->checkPMT("S31_1B")){ pmtnosignal++; good = false;}}
1604      if ( this->bit(patterntrig[2],4) ){ pmtpattern++;  if ( !this->checkPMT("S31_2B")){ pmtnosignal++; good = false;}}
1605      if ( this->bit(patterntrig[2],5) ){ pmtpattern++;  if ( !this->checkPMT("S31_3B")){ pmtnosignal++; good = false;}}      
1606      if ( this->bit(patterntrig[2],6) ){ pmtpattern++;  if ( !this->checkPMT("S32_1A")){ pmtnosignal++; good = false;}}
1607      if ( this->bit(patterntrig[2],7) ){ pmtpattern++;  if ( !this->checkPMT("S32_2A")){ pmtnosignal++; good = false;}}
1608      if ( this->bit(patterntrig[2],8) ){ pmtpattern++;  if ( !this->checkPMT("S32_3A")){ pmtnosignal++; good = false;}}
1609      if ( this->bit(patterntrig[2],9) ){ pmtpattern++;  if ( !this->checkPMT("S32_1B")){ pmtnosignal++; good = false;}}
1610      if ( this->bit(patterntrig[2],10) ){ pmtpattern++;  if ( !this->checkPMT("S32_2B")){ pmtnosignal++; good = false;}}
1611      if ( this->bit(patterntrig[2],11) ){ pmtpattern++;  if ( !this->checkPMT("S32_3B")){ pmtnosignal++; good = false;}}      
1612      //S2
1613      if ( this->bit(patterntrig[3],0) ){ pmtpattern++;  if ( !this->checkPMT("S21_1A")){ pmtnosignal++; good = false;}}
1614      if ( this->bit(patterntrig[3],1) ){ pmtpattern++;  if ( !this->checkPMT("S21_2A")){ pmtnosignal++; good = false;}}
1615      if ( this->bit(patterntrig[3],2) ){ pmtpattern++;  if ( !this->checkPMT("S21_1B")){ pmtnosignal++; good = false;}}
1616      if ( this->bit(patterntrig[3],3) ){ pmtpattern++;  if ( !this->checkPMT("S21_2B")){ pmtnosignal++; good = false;}}      
1617      if ( this->bit(patterntrig[3],4) ){ pmtpattern++;  if ( !this->checkPMT("S22_1A")){ pmtnosignal++; good = false;}}
1618      if ( this->bit(patterntrig[3],5) ){ pmtpattern++;  if ( !this->checkPMT("S22_2A")){ pmtnosignal++; good = false;}}
1619      if ( this->bit(patterntrig[3],6) ){ pmtpattern++;  if ( !this->checkPMT("S22_1B")){ pmtnosignal++; good = false;}}
1620      if ( this->bit(patterntrig[3],7) ){ pmtpattern++;  if ( !this->checkPMT("S22_2B")){ pmtnosignal++; good = false;}}      
1621      //S12
1622      if ( this->bit(patterntrig[4],0) ){ pmtpattern++;  if ( !this->checkPMT("S12_1A")){ pmtnosignal++; good = false;}}
1623      if ( this->bit(patterntrig[4],1) ){ pmtpattern++;  if ( !this->checkPMT("S12_2A")){ pmtnosignal++; good = false;}}
1624      if ( this->bit(patterntrig[4],2) ){ pmtpattern++;  if ( !this->checkPMT("S12_3A")){ pmtnosignal++; good = false;}}
1625      if ( this->bit(patterntrig[4],3) ){ pmtpattern++;  if ( !this->checkPMT("S12_4A")){ pmtnosignal++; good = false;}}
1626      if ( this->bit(patterntrig[4],4) ){ pmtpattern++;  if ( !this->checkPMT("S12_5A")){ pmtnosignal++; good = false;}}
1627      if ( this->bit(patterntrig[4],5) ){ pmtpattern++;  if ( !this->checkPMT("S12_6A")){ pmtnosignal++; good = false;}}      
1628      if ( this->bit(patterntrig[4],6) ){ pmtpattern++;  if ( !this->checkPMT("S12_1A")){ pmtnosignal++; good = false;}}
1629      if ( this->bit(patterntrig[4],7) ){ pmtpattern++;  if ( !this->checkPMT("S12_2A")){ pmtnosignal++; good = false;}}
1630      if ( this->bit(patterntrig[4],8) ){ pmtpattern++;  if ( !this->checkPMT("S12_3A")){ pmtnosignal++; good = false;}}
1631      if ( this->bit(patterntrig[4],9) ){ pmtpattern++;  if ( !this->checkPMT("S12_4B")){ pmtnosignal++; good = false;}}
1632      if ( this->bit(patterntrig[4],10) ){ pmtpattern++; if ( !this->checkPMT("S12_5B")){ pmtnosignal++; good = false;}}
1633      if ( this->bit(patterntrig[4],11) ){ pmtpattern++; if ( !this->checkPMT("S12_6B")){ pmtnosignal++; good = false;}}      
1634      //S11
1635      if ( this->bit(patterntrig[5],0) ){ pmtpattern++;  if ( !this->checkPMT("S11_1A")){ pmtnosignal++; good = false;}}
1636      if ( this->bit(patterntrig[5],1) ){ pmtpattern++;  if ( !this->checkPMT("S11_2A")){ pmtnosignal++; good = false;}}
1637      if ( this->bit(patterntrig[5],2) ){ pmtpattern++;  if ( !this->checkPMT("S11_3A")){ pmtnosignal++; good = false;}}
1638      if ( this->bit(patterntrig[5],3) ){ pmtpattern++;  if ( !this->checkPMT("S11_4A")){ pmtnosignal++; good = false;}}
1639      if ( this->bit(patterntrig[5],4) ){ pmtpattern++;  if ( !this->checkPMT("S11_5A")){ pmtnosignal++; good = false;}}
1640      if ( this->bit(patterntrig[5],5) ){ pmtpattern++;  if ( !this->checkPMT("S11_6A")){ pmtnosignal++; good = false;}}
1641      if ( this->bit(patterntrig[5],6) ){ pmtpattern++;  if ( !this->checkPMT("S11_7A")){ pmtnosignal++; good = false;}}
1642      if ( this->bit(patterntrig[5],7) ){ pmtpattern++;  if ( !this->checkPMT("S11_8A")){ pmtnosignal++; good = false;}}      
1643      if ( this->bit(patterntrig[5],8) ){ pmtpattern++;  if ( !this->checkPMT("S11_1B")){ pmtnosignal++; good = false;}}
1644      if ( this->bit(patterntrig[5],9) ){ pmtpattern++;  if ( !this->checkPMT("S11_2B")){ pmtnosignal++; good = false;}}
1645      if ( this->bit(patterntrig[5],10) ){ pmtpattern++; if ( !this->checkPMT("S11_3B")){ pmtnosignal++; good = false;}}
1646      if ( this->bit(patterntrig[5],11) ){ pmtpattern++; if ( !this->checkPMT("S11_4B")){ pmtnosignal++; good = false;}}
1647      if ( this->bit(patterntrig[5],12) ){ pmtpattern++; if ( !this->checkPMT("S11_5B")){ pmtnosignal++; good = false;}}
1648      if ( this->bit(patterntrig[5],13) ){ pmtpattern++; if ( !this->checkPMT("S11_6B")){ pmtnosignal++; good = false;}}
1649      if ( this->bit(patterntrig[5],14) ){ pmtpattern++; if ( !this->checkPMT("S11_7B")){ pmtnosignal++; good = false;}}
1650      if ( this->bit(patterntrig[5],15) ){ pmtpattern++; if ( !this->checkPMT("S11_8B")){ pmtnosignal++; good = false;}}
1651    
1652      return good;
1653    }
1654    
1655    bool ToFLevel2::checkPMTpmttrig(TrigLevel2 *trg){
1656      //  UInt_t *patterntrig = trg->patterntrig;
1657      int rS11 = 0;
1658      int rS12 = 0;
1659      int rS21 = 0;
1660      int rS22 = 0;
1661      int rS31 = 0;
1662      int rS32 = 0;
1663    
1664      // trigger configuration for the event from saved pmts
1665      TClonesArray* Pmt = this->PMT;
1666      for(int i=0; i<Pmt->GetEntries(); i++) {  
1667        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1668        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1669        if ( pmtname.Contains("S11") ) rS11++;
1670        if ( pmtname.Contains("S12") ) rS12++;
1671        if ( pmtname.Contains("S21") ) rS21++;
1672        if ( pmtname.Contains("S22") ) rS22++;
1673        if ( pmtname.Contains("S31") ) rS31++;
1674        if ( pmtname.Contains("S32") ) rS32++;
1675      }
1676      int rTOF1 = (rS11 + rS12) * (rS21 + rS22) * (rS31 + rS32);
1677      int rTOF2 = (rS11 * rS12) * (rS21 * rS22) * (rS31 * rS32);
1678    
1679      int rTOF3 = (rS21 + rS22) * (rS31 + rS32);
1680      int rTOF4 = (rS21 * rS22) * (rS31 * rS32);
1681    
1682      int rTOF5 = rS12 * (rS21 * rS22);
1683    
1684      int rTOF6 = (rS11 + rS12) * (rS31 + rS32);
1685      int rTOF7 = (rS11 * rS12) * (rS31 * rS32);
1686    
1687    
1688      // trigger configuration of the run
1689      bool TCTOF1 = false;
1690      bool TCTOF2 = false;
1691      bool TCTOF3 = false;
1692      bool TCTOF4 = false;
1693      bool TCTOF5 = false;
1694      bool TCTOF6 = false;
1695      bool TCTOF7 = false;
1696      if ( trg->trigconf & (1<<0) ) TCTOF1 = true;
1697      if ( trg->trigconf & (1<<1) ) TCTOF2 = true;
1698      if ( trg->trigconf & (1<<2) ) TCTOF3 = true;
1699      if ( trg->trigconf & (1<<3) ) TCTOF4 = true;
1700      if ( trg->trigconf & (1<<4) ) TCTOF5 = true;
1701      if ( trg->trigconf & (1<<5) ) TCTOF6 = true;
1702      if ( trg->trigconf & (1<<6) ) TCTOF7 = true;
1703    
1704      // do patterntrig pmts match the trigger configuration?
1705      bool pmtsconf_trigconf_match = true;
1706      if ( rTOF1 == 0 && TCTOF1 ) pmtsconf_trigconf_match = false;
1707      if ( rTOF2 == 0 && TCTOF2 ) pmtsconf_trigconf_match = false;
1708      if ( rTOF3 == 0 && TCTOF3 ) pmtsconf_trigconf_match = false;
1709      if ( rTOF4 == 0 && TCTOF4 ) pmtsconf_trigconf_match = false;
1710      if ( rTOF5 == 0 && TCTOF5 ) pmtsconf_trigconf_match = false;
1711      if ( rTOF6 == 0 && TCTOF6 ) pmtsconf_trigconf_match = false;
1712      if ( rTOF7 == 0 && TCTOF7 ) pmtsconf_trigconf_match = false;
1713    
1714      return pmtsconf_trigconf_match;
1715    }
1716    
1717    void ToFLevel2::printPMT(){
1718      TClonesArray* Pmt = this->PMT;
1719      for(int i=0; i<Pmt->GetEntries(); i++) {  
1720        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1721        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1722        printf(" PMT hit: %s \n",pmtname.Data());
1723      }
1724  }  }
1725    
1726    
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
1727  ToFdEdx::ToFdEdx()  ToFdEdx::ToFdEdx()
1728  {  {
1729    memset(conn,0,12*sizeof(Bool_t));    memset(conn,0,12*sizeof(Bool_t));
1730    memset(ts,0,12*sizeof(UInt_t));    memset(ts,0,12*sizeof(UInt_t));
1731    memset(te,0,12*sizeof(UInt_t));    memset(te,0,12*sizeof(UInt_t));
1732      eDEDXpmt = new TArrayF(48);
1733    Define_PMTsat();    Define_PMTsat();
1734    Clear();    Clear();
1735  }  }
1736    
1737    ToFdEdx::~ToFdEdx(){
1738      Clear();
1739      Delete();
1740    }
1741    
1742    void ToFdEdx::Delete(Option_t *option){
1743      if ( eDEDXpmt ){
1744        eDEDXpmt->Set(0);
1745        if ( eDEDXpmt) delete eDEDXpmt;
1746      }
1747    }
1748    
1749  //------------------------------------------------------------------------  //------------------------------------------------------------------------
1750  void ToFdEdx::CheckConnectors(UInt_t atime, GL_PARAM *glparam, TSQLServer *dbc)  void ToFdEdx::CheckConnectors(UInt_t atime, GL_PARAM *glparam, TSQLServer *dbc)
1751  {  {
# Line 1493  void ToFdEdx::Clear(Option_t *option) Line 1787  void ToFdEdx::Clear(Option_t *option)
1787  {  {
1788    //    //
1789    // Set arrays and initialize structure    // Set arrays and initialize structure
1790      //  eDEDXpmt.Set(48);    eDEDXpmt.Reset(-1);   // Set array size  and reset structure
1791    eDEDXpmt.Set(48);    eDEDXpmt.Reset(-1);   // Set array size  and reset structure    eDEDXpmt->Set(48);    eDEDXpmt->Reset(-1);   // Set array size  and reset structure
   eZpmt.Set(48);       eZpmt.Reset(-1);  
   eDEDXpad.Set(24);    eDEDXpad.Reset(-1);  
   eZpad.Set(24);       eZpad.Reset(-1);  
   eDEDXlayer.Set(6);   eDEDXlayer.Reset(-1);  
   eZlayer.Set(6);      eZlayer.Reset(-1);  
   eDEDXplane.Set(3);   eDEDXplane.Reset(-1);  
   eZplane.Set(3);      eZplane.Reset(-1);  
   INFOpmt.Set(48);     INFOpmt.Reset(0);  
   INFOlayer.Set(6);    INFOlayer.Reset(0);  
1792    //    //
1793  };  };
1794    
# Line 1515  void ToFdEdx::Print(Option_t *option) Line 1800  void ToFdEdx::Print(Option_t *option)
1800    
1801  };  };
1802    
   
1803  //------------------------------------------------------------------------  //------------------------------------------------------------------------
1804  // void ToFdEdx::InitPar(TString parname, TString parfile)  void ToFdEdx::Init(pamela::tof::TofEvent *tofl0)
1805  // {  {
1806  //   // expensive function - call it once/run    //
1807      ToFLevel2 tf;
1808      for (Int_t gg=0; gg<4;gg++){
1809        for (Int_t hh=0; hh<12;hh++){
1810  //   ReadParAtt(            Form("%s/attenuation.txt"              , pardir) );        //          tofinput_.tdc[hh][gg]=tofEvent->tdc[gg][hh];          
1811  //   ReadParPos(            Form("%s/desaturation_position.txt"    , pardir) );        int mm = tf.GetPMTid(gg,hh);        
1812  //   ReadParBBneg(          Form("%s/BetheBloch.txt"               , pardir) );        adc[mm]= (0xFFF & tofl0->adc[gg][hh]); // EM, exclude warning bits
1813  //   ReadParBBpos(          Form("%s/BetheBloch_betagt1.txt"       , pardir) );      };      
1814  //   ReadParDesatBB(        Form("%s/desaturation_beta.txt"        , pardir) );    };
1815      
1816  // };  };
   
1817    
1818  //------------------------------------------------------------------------  //------------------------------------------------------------------------
1819  void ToFdEdx::Process(UInt_t atime, Float_t betamean, Float_t *xtr_tof, Float_t *ytr_tof, pamela::tof::TofEvent *tofl0 )  void ToFdEdx::Init(Int_t gg, Int_t hh, Float_t adce)
1820  {  {
1821      //
1822      ToFLevel2 tf;
1823      //  for (Int_t gg=0; gg<4;gg++){
1824      //    for (Int_t hh=0; hh<12;hh++){
1825      int mm = tf.GetPMTid(gg,hh);    
1826      adc[mm]=adce;
1827      
1828    };
1829    //------------------------------------------------------------------------
1830    void ToFdEdx::Process(UInt_t atime, Float_t betamean, Float_t *xtr_tof, Float_t *ytr_tof, Int_t exitat)
1831    {
1832      bool debug = false;
1833      if ( debug ) printf(" INSIDE TOFDEDX PROCESS \n");
1834    // the parameters should be already initialised by InitPar()    // the parameters should be already initialised by InitPar()
1835      //  printf(" in process \n");
   
1836    Clear();    Clear();
1837    
   
   
   //  Float_t betamean = fabs(trackTRK->GetToFTrack()->beta[12]);  
   
   if(betamean<0.05 || betamean>2){  
     for(int i=0;i<48;i++)INFOpmt[i]=1;  
   }  
   
1838   // define angle:     // define angle:  
1839    double dx   = xtr_tof[1] - xtr_tof[5];    double dx   = xtr_tof[1] - xtr_tof[5];
1840    double dy   = ytr_tof[0] - ytr_tof[4];    double dy   = ytr_tof[0] - ytr_tof[4];
1841    double dr   = sqrt(dx*dx+dy*dy);    double dr   = sqrt(dx*dx+dy*dy);
1842    double theta=atan(dr/76.81);    double theta=atan(dr/76.81);
1843      //
1844      if ( xtr_tof[1] > 99. ||  xtr_tof[5] > 99. || ytr_tof[0] > 99. ||  ytr_tof[4] > 99. ) theta = 0.;
1845      for (Int_t ii=0; ii<6; ii++){
1846    //  TArrayF adc;      if ( xtr_tof[ii] > 99. ) xtr_tof[ii] = 0.;
1847    Float_t adc[48];      if ( ytr_tof[ii] > 99. ) ytr_tof[ii] = 0.;
   
   ToFLevel2 tf;  
   
   for (Int_t gg=0; gg<4;gg++){  
     for (Int_t hh=0; hh<12;hh++){  
       //          tofinput_.tdc[hh][gg]=tofEvent->tdc[gg][hh];            
       int mm = tf.GetPMTid(gg,hh);          
       adc[mm]=tofl0->adc[gg][hh];  
     };        
1848    };    };
1849        //
1850        if ( debug ) printf(" theta %f \n",theta);
1851        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]);
1852        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]);
1853      //--------------------- TABLE OF PERIODS WITH HV PROBLEMS ----------------------------
1854      
1855      int Aconn=conn[0];    // PMT 0,20,22,24
1856      int Bconn=conn[1];    // PMT 6,12,26,34
1857      int Cconn=conn[2];    // PMT 4,14,28,32
1858      int Dconn=conn[3];    // PMT 2,8,10,30
1859      int Econn=conn[4];    // PMT 42,43,44,47
1860      int Fconn=conn[5];    // PMT 7,19,23,27
1861      int Gconn=conn[6];    // PMT 3,11,25,33
1862      int Hconn=conn[7];    // PMT 1,9,13,21
1863      int Iconn=conn[8];    // PMT 5,29,31,35
1864      int Lconn=conn[9];    // PMT 37,40,45,46
1865      int Mconn=conn[10];    // PMT 15,16,17,18
1866      int Nconn=conn[11];    // PMT 36,38,39,41
1867      if( false ) cout << Gconn << Iconn << Lconn <<endl; // to avoid compilation warnings
1868        
1869      //  printf(" size %i \n",eDEDXpmt.GetSize());
1870    for( int ii=0; ii<48; ii++ ) {    for( int ii=0; ii<48; ii++ ) {
1871      if( adc[ii] >= PMTsat[ii]-5 )  continue;      //
1872      if( adc[ii] <= 0. )            continue;      //    eDEDXpmt.SetAt(-1.,ii);
1873          //    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]);
1874      double adcpC   = f_adcPC( adc[ii] );    // - adc conversion in pC      if ( debug ) printf("II %i adc %f \n",ii,adc[ii]);
1875      double adccorr = adcpC*fabs(cos(theta));  
1876        if( adc[ii] >= 4095. ){
1877           if(adccorr<=0.)           continue;        //      eDEDXpmt[ii] = 0.;
1878          eDEDXpmt->AddAt(0.,ii);
1879          if ( debug ) printf(" %i adc>4095 \n",ii);
1880          continue; // EMILIANO
1881        };
1882    
1883      //--------------------- TABLE OF PERIODS WITH HV PROBLEMS ----------------------------      if( adc[ii] >= (PMTsat[ii]-5.) && adc[ii] < 4095. ){
1884          eDEDXpmt->AddAt(1000.,ii);
1885          if ( debug ) printf(" %i adc> pmtsat && adc<4095 \n",ii);
1886          continue; // EMILIANO
1887        };
1888    
1889      int Aconn=conn[0];    // PMT 0,20,22,24      if( adc[ii] <= 0. ) {
1890      int Bconn=conn[1];    // PMT 6,12,26,34        eDEDXpmt->AddAt(1500.,ii);
1891      int Cconn=conn[2];    // PMT 4,14,28,32        if ( debug ) printf(" %i adc<=0 \n",ii);
1892      int Dconn=conn[3];    // PMT 2,8,10,30        continue;
1893      int Econn=conn[4];    // PMT 42,43,44,47      };
1894      int Fconn=conn[5];    // PMT 7,19,23,27      //
1895      int Gconn=conn[6];    // PMT 3,11,25,33      double adcpC   = f_adcPC( adc[ii] );    // - adc conversion in pC
1896      int Hconn=conn[7];    // PMT 1,9,13,21      if ( exitat == 0 ){
1897      int Iconn=conn[8];    // PMT 5,29,31,35        eDEDXpmt->AddAt((Float_t)adcpC,ii);
1898      int Lconn=conn[9];    // PMT 37,40,45,46        continue;
1899      int Mconn=conn[10];    // PMT 15,16,17,18      }
1900      int Nconn=conn[11];    // PMT 36,38,39,41      //    printf(" e qua? \n");
1901    
1902        double adccorr = adcpC*fabs(cos(theta));    
1903        if ( debug ) printf(" adccorr %f \n",adccorr);
1904        if(adccorr<=0.){
1905          if ( debug ) printf(" %i adccorr<=0 \n",ii);
1906          //      eDEDXpmt->AddAt((Float_t)adcpC,ii);//?
1907          continue;
1908        }
1909        if ( exitat == 1 ){
1910          eDEDXpmt->AddAt((Float_t)adccorr,ii);
1911          continue;
1912        }
1913        //    printf(" e quo? \n");
1914    
1915      //    int standard=0;      //    int standard=0;
     if( false ) cout << Gconn << Iconn << Lconn <<endl;  
1916      int S115B_ok=0;      int S115B_ok=0;
1917      int S115B_break=0;      int S115B_break=0;
1918    
 //   if(atime>=1153660001 && atime<=1154375000)Dconn=1;  
 //     else if(atime>=1155850001 && atime<=1156280000){  
 //       Hconn=1;  
 //       Nconn=1;  
 //     }  
   
 //  else if(atime>=1168490001 && atime<=1168940000)Dconn=1;  
 //     else if(atime>=1168940001 && atime<=1169580000){  
 //       Fconn=1;  
 //       Mconn=1;  
 //     }  
   
 //  else if(atime>=1174665001 && atime<=1175000000)Bconn=1;  
 //     else if(atime>=1176120001 && atime<=1176800000)Hconn=1;  
 //     else if(atime>=1176800001 && atime<=1178330000)Econn=1;  
 //     else if(atime>=1178330001 && atime<=1181322000)Hconn=1;  
 //     else if(atime>=1182100001 && atime<=1183030000)Aconn=1;  
 //     else if(atime>=1184000001 && atime<=1184570000)Hconn=1;  
 //     else if(atime>=1185090001 && atime<=1185212000)Dconn=1;  
 //     else if(atime>=1191100001 && atime<=1191940000)Dconn=1;  
 //     else if(atime>=1196230001 && atime<=1196280000)Hconn=1;  
 //     else if(atime>=1206100001 && atime<=1206375600)Cconn=1;  
 //     else if(atime>=1217989201 && atime<=1218547800)Econn=1;  
 //     else if(atime>=1225789201 && atime<=1226566800)Econn=1;  
 //     else if(atime>=1229400901 && atime<=1229700000)Econn=1;  
 //     else if(atime>=1230318001 && atime<=1230415200)Econn=1;  
 //     else {  
 //       standard=1;  
 //     }  
1919      if(atime<1158720000)S115B_ok=1;      if(atime<1158720000)S115B_ok=1;
1920      else S115B_break=1;      else S115B_break=1;
1921    
1922    
1923   //------------------------------------------------------------------------      //------------------------------------------------------------------------
1924        //    printf(" e qui? \n");
1925  //---------------------------------------------------- Z reconstruction      //---------------------------------------------------- Z reconstruction
1926    
1927  double adcHe, adcnorm, adclin, dEdx, Zeta;      double adcHe, adcnorm, adclin, dEdx;//, Zeta; // EM GCC4.7
1928    
1929   adcHe=-2;      adcHe=-2;
1930   adcnorm=-2;      adcnorm=-2;
1931   adclin=-2;      adclin=-2;
1932   dEdx=-2;      dEdx=-2;
1933   Zeta=-2;      //    Zeta=-2;//EM GCC4.7
1934        Double_t correction = 1.;
   
 //  float ZetaH=-2;  
 //  float dEdxH=-2;  
   
 //  double day = (atime-1150000000)/84600;  
1935    
1936      if(Aconn==1 && (ii==0 || ii==20 || ii==22 || ii==24)){      if(Aconn==1 && (ii==0 || ii==20 || ii==22 || ii==24)){
1937         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.675;        correction = 1.675;
1938      }      }
1939      else if(Bconn==1 && (ii==6 || ii==12 || ii==26 || ii==34)){      else if(Bconn==1 && (ii==6 || ii==12 || ii==26 || ii==34)){
1940         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/2.482;        correction = 2.482;
1941      }      }
1942      else if(Cconn==1 && (ii==4 || ii==14 || ii==28 || ii==32)){      else if(Cconn==1 && (ii==4 || ii==14 || ii==28 || ii==32)){
1943        adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.464;        correction = 1.464;
1944      }      }
1945      else if(Dconn==1 && (ii==2 || ii==8 || ii==10 || ii==30)){      else if(Dconn==1 && (ii==2 || ii==8 || ii==10 || ii==30)){
1946         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.995;        correction = 1.995;
1947      }      }
1948      else if(Econn==1 && (ii==42 || ii==43 || ii==44 || ii==47)){      else if(Econn==1 && (ii==42 || ii==43 || ii==44 || ii==47)){
1949         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.273;        correction = 1.273;
1950      }      }
1951      else if(Fconn==1 && (ii==7 || ii==19 || ii==23 || ii==27)){      else if(Fconn==1 && (ii==7 || ii==19 || ii==23 || ii==27)){
1952         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.565;        correction = 1.565;
1953      }      }
1954      else if(Mconn==1 && (ii==15 || ii==16 || ii==17 || ii==18)){      else if(Mconn==1 && (ii==15 || ii==16 || ii==17 || ii==18)){
1955         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.565;        correction = 1.565;
1956      }      }
1957      else if(Nconn==1 && (ii==36 || ii==38 || ii==39 || ii==41)){      else if(Nconn==1 && (ii==36 || ii==38 || ii==39 || ii==41)){
1958         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.018;        correction = 1.018;
1959      }      }
1960      else if(Hconn==1 && (ii==1 || ii==13 || ii==21 || (ii==9&&S115B_ok==1))){      else if(Hconn==1 && (ii==1 || ii==13 || ii==21 || (ii==9&&S115B_ok==1))){
1961        adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.84;        correction = 1.84;
     }  
     else if(S115B_break==1 && ii==9 && Hconn==0){  
        adcHe   = f_att5B( ytr_tof[0] );   //N.B.: this function refers to the Carbon!!!  
1962      }      }
1963      else if(S115B_break==1 && ii==9 && Hconn==1){      else if(S115B_break==1 && ii==9 && Hconn==1){
1964         adcHe   = (f_att5B( ytr_tof[0] ))/1.64;        correction = 1.64;
1965        }
1966        else correction = 1.;
1967        
1968        if( ii==9 && S115B_break==1 ){
1969          adcHe   = f_att5B( ytr_tof[0] )/correction;
1970        } else {
1971          adcHe   = Get_adc_he(ii, xtr_tof, ytr_tof)/correction;
1972        };
1973        if(adcHe<=0){
1974          if ( debug ) printf(" %i adcHe<=0 \n",ii);
1975          //      eDEDXpmt->AddAt((Float_t)adccorr,ii); //?
1976          continue;
1977        }
1978        if ( exitat == 2 ){
1979          if(ii==9 && S115B_break==1)  eDEDXpmt->AddAt(36.*(Float_t)adccorr/adcHe,ii);
1980          else  adclin  = 4.*(Float_t)adccorr/adcHe;
1981          continue;
1982      }      }
     else  adcHe   = Get_adc_he(ii, xtr_tof, ytr_tof);  
   
     if(adcHe<=0)   continue;  
1983    
1984      if(ii==9 && S115B_break==1)  adcnorm = f_pos5B(adccorr);      if(ii==9 && S115B_break==1)  adcnorm = f_pos5B(adccorr);
1985      else adcnorm = f_pos( (parPos[ii]), adccorr);      else adcnorm = f_pos( (parPos[ii]), adccorr);
1986        if(adcnorm<=0){
1987      if(adcnorm<=0) continue;        if ( debug ) printf(" %i adcnorm<=0 \n",ii);
1988          //      eDEDXpmt->AddAt((Float_t)adccorr,ii);//?
1989          continue;
1990        }
1991        if ( debug ) printf(" adcnorm %f \n",adcnorm);
1992    
1993      if(ii==9 && S115B_break==1)  adclin  = 36.*adcnorm/adcHe;      if(ii==9 && S115B_break==1)  adclin  = 36.*adcnorm/adcHe;
1994      else  adclin  = 4.*adcnorm/adcHe;      else  adclin  = 4.*adcnorm/adcHe;
1995        if ( debug ) printf(" adclin %f \n",adclin);
1996      if(adclin<=0)  continue;      if(adclin<=0){
1997          if ( debug ) printf(" %i adclin<=0 \n",ii);
1998          //      eDEDXpmt->AddAt((Float_t)adccorr,ii);//?
1999          continue;
2000        }
2001        if ( exitat == 3 ){
2002          if(ii==9 && S115B_break==1)  eDEDXpmt->AddAt((Float_t)adclin,ii);
2003          else  eDEDXpmt->AddAt((Float_t)adclin,ii);
2004          continue;
2005        }
2006        //
2007        if ( betamean > 99. ){
2008          //      eDEDXpmt.AddAt((Float_t)adclin,ii);
2009          eDEDXpmt->AddAt((Float_t)adclin,ii);
2010          //      printf(" AAPMT IS %i dedx is %f vector is %f \n",ii,adclin,eDEDXpmt[ii]);
2011          if ( debug ) printf(" %i betamean > 99 \n",ii);
2012          continue;
2013        };
2014        //
2015      double dEdxHe=-2;      double dEdxHe=-2;
2016      if(ii==9 && S115B_break==1){      if(ii==9 && S115B_break==1){
2017        if( betamean <1. ) dEdxHe = f_BB5B( betamean );        if( betamean <1. ) dEdxHe = f_BB5B( betamean );
# Line 1709  double adcHe, adcnorm, adclin, dEdx, Zet Line 2020  double adcHe, adcnorm, adclin, dEdx, Zet
2020        if( betamean <1. ) dEdxHe = f_BB( (parBBneg[ii]), betamean );        if( betamean <1. ) dEdxHe = f_BB( (parBBneg[ii]), betamean );
2021        else                       dEdxHe = parBBpos[ii];        else                       dEdxHe = parBBpos[ii];
2022      }      }
   
     if(dEdxHe<=0)  continue;  
   
     if(ii==9 && S115B_break==1)  dEdx = f_desatBB5B( adclin );  
     else  dEdx = f_desatBB((parDesatBB[ii]), adclin );  
   
     if(dEdx<=0)    continue;  
   
     if(ii==9 && S115B_break==1)  Zeta = sqrt(36.*(dEdx/dEdxHe));  
     else  Zeta = sqrt(4.*(dEdx/dEdxHe));  
   
     if(Zeta<=0)    continue;  
   
 //--------------------- TIME DEPENDENCE ----------------------------------  
   
   
 //      TArrayF &binx = TDx[ii];  
 //      TArrayF &biny = TDy[ii];  
 //      for(int k=0; k<200; k++) {  
 //        if (day > binx[k]-2.5 && day<=binx[k]+2.5 && biny[k]>0)  {  
 //       ZetaH=Zeta/biny[k]*6;  
 //       dEdxH=dEdx/(pow(biny[k],2))*36;  
 //        }  
 //      }  
   
 //      if(ZetaH!=-2)eZpmt[ii]=(Float_t)ZetaH;  
 //      else eZpmt[ii]=(Float_t)Zeta;  
   
 //      if(dEdxH!=-2)eDEDXpmt[ii]=(Float_t)dEdxH;  
 //      else eDEDXpmt[ii]=(Float_t)dEdx;  
   
 //      printf("%5d %8.2f %8.2f %8.2f  %8.2f %8.2f  %8.2f %5.4f \n",               ii, adcpC,  adccorr, adcHe, dEdxHe, dEdx, Zeta, betamean );  
   
     eZpmt[ii]=(Float_t)Zeta;  
     eDEDXpmt[ii]=(Float_t)dEdx;  
   
   
  }  //end loop on 48 PMT  
   
 //---------------------------------------------------  paddle + layer --------------------  
   
   for(int j=0;j<48;j++){  
     int k=100;  
     if(j%2==0 || j==0)k=j/2;  
       
     double zpdl=-1;  
       
     if((j%2==0 || j==0) && eZpmt[j]!=-1 && eZpmt[j+1]!=-1){  
       zpdl=0.5*(eZpmt[j]+eZpmt[j+1]);  
     }else if((j%2==0 || j==0) && eZpmt[j]!=-1 && eZpmt[j+1]==-1){  
       zpdl=eZpmt[j];  
     }else if((j%2==0 || j==0) && eZpmt[j]==-1 && eZpmt[j+1]!=-1){  
       zpdl=eZpmt[j+1];  
     }  
2023            
2024      if(j%2==0 || j==0)eZpad[k]= (Float_t)zpdl;      if ( debug ) printf(" dEdxHe %f \n",dEdxHe);
2025            
2026      if((j%2==0 || j==0)&&eZpad[k]!=-1){      if(dEdxHe<=0){
2027        if(k>=0&&k<8)eZlayer[0]=eZpad[k];        eDEDXpmt->AddAt((Float_t)adclin,ii);
2028        if(k>=8&&k<14)eZlayer[1]=eZpad[k];        if ( debug ) printf(" %i dEdxHe<=0 \n",ii);
2029        if(k>=14&&k<16)eZlayer[2]=eZpad[k];        continue;
2030        if(k>=16&&k<18)eZlayer[3]=eZpad[k];      };
       if(k>=18&&k<21)eZlayer[4]=eZpad[k];  
       if(k>=21)eZlayer[5]=eZpad[k];  
     }  
   
     if(eZlayer[0]!=-1&&eZlayer[1]!=-1&&fabs(eZlayer[0]-eZlayer[1])<1.5)eZplane[0]=0.5*(eZlayer[0]+eZlayer[1]);  
     else if(eZlayer[0]!=-1&&eZlayer[1]==-1)eZplane[0]=eZlayer[0];  
     else if(eZlayer[1]!=-1&&eZlayer[0]==-1)eZplane[0]=eZlayer[1];  
   
     if(eZlayer[2]!=-1&&eZlayer[3]!=-1&&fabs(eZlayer[2]-eZlayer[3])<1.5)eZplane[1]=0.5*(eZlayer[2]+eZlayer[3]);  
     else if(eZlayer[2]!=-1&&eZlayer[3]==-1)eZplane[1]=eZlayer[2];  
     else if(eZlayer[3]!=-1&&eZlayer[2]==-1)eZplane[1]=eZlayer[3];  
2031    
2032      if(eZlayer[4]!=-1&&eZlayer[5]!=-1&&fabs(eZlayer[4]-eZlayer[5])<1.5)eZplane[2]=0.5*(eZlayer[4]+eZlayer[5]);      if(ii==9 && S115B_break==1)  dEdx = f_desatBB5B( adclin );
2033      else if(eZlayer[4]!=-1&&eZlayer[5]==-1)eZplane[2]=eZlayer[4];      else  dEdx = f_desatBB((parDesatBB[ii]), adclin );
     else if(eZlayer[5]!=-1&&eZlayer[4]==-1)eZplane[2]=eZlayer[5];  
2034    
2035    }      if(dEdx<=0){
2036          eDEDXpmt->AddAt((Float_t)adclin,ii);
2037          if ( debug ) printf(" %i dEdx<=0 \n",ii);
2038          continue;
2039        };
2040    
2041    for(int jj=0;jj<48;jj++){      if ( debug ) printf(" dEdx %f \n",dEdx);
2042      int k=100;      eDEDXpmt->AddAt((Float_t)dEdx,ii);
2043      if(jj%2==0 || jj==0)k=jj/2;      //    eDEDXpmt.AddAt((Float_t)dEdx,ii);
       
     double dedxpdl=-1;  
       
     if((jj%2==0 || jj==0) && eDEDXpmt[jj]!=-1 && eDEDXpmt[jj+1]!=-1){  
       dedxpdl=0.5*(eDEDXpmt[jj]+eDEDXpmt[jj+1]);  
     }else if((jj%2==0 || jj==0) && eDEDXpmt[jj]!=-1 && eDEDXpmt[jj+1]==-1){  
       dedxpdl=eDEDXpmt[jj];  
     }else if((jj%2==0 || jj==0) && eDEDXpmt[jj]==-1 && eDEDXpmt[jj+1]!=-1){  
       dedxpdl=eDEDXpmt[jj+1];  
     }  
       
     if(jj%2==0 || jj==0)eDEDXpad[k]= (Float_t)dedxpdl;  
       
     if((jj%2==0 || jj==0)&&eDEDXpad[k]!=-1){  
       if(k>=0&&k<8)eDEDXlayer[0]=eDEDXpad[k];  
       if(k>=8&&k<14)eDEDXlayer[1]=eDEDXpad[k];  
       if(k>=14&&k<16)eDEDXlayer[2]=eDEDXpad[k];  
       if(k>=16&&k<18)eDEDXlayer[3]=eDEDXpad[k];  
       if(k>=18&&k<21)eDEDXlayer[4]=eDEDXpad[k];  
       if(k>=21)eDEDXlayer[5]=eDEDXpad[k];  
     }  
   
     if(eDEDXlayer[0]!=-1&&eDEDXlayer[1]!=-1&&fabs(eDEDXlayer[0]-eDEDXlayer[1])<10)eDEDXplane[0]=0.5*(eDEDXlayer[0]+eDEDXlayer[1]);  
     else if(eDEDXlayer[0]!=-1&&eDEDXlayer[1]==-1)eDEDXplane[0]=eDEDXlayer[0];  
     else if(eDEDXlayer[1]!=-1&&eDEDXlayer[0]==-1)eDEDXplane[0]=eDEDXlayer[1];  
   
     if(eDEDXlayer[2]!=-1&&eDEDXlayer[3]!=-1&&fabs(eDEDXlayer[2]-eDEDXlayer[3])<10)eDEDXplane[1]=0.5*(eDEDXlayer[2]+eDEDXlayer[3]);  
     else if(eDEDXlayer[2]!=-1&&eDEDXlayer[3]==-1)eDEDXplane[1]=eDEDXlayer[2];  
     else if(eDEDXlayer[3]!=-1&&eDEDXlayer[2]==-1)eDEDXplane[1]=eDEDXlayer[3];  
   
     if(eDEDXlayer[4]!=-1&&eDEDXlayer[5]!=-1&&fabs(eDEDXlayer[4]-eDEDXlayer[5])<10)eDEDXplane[2]=0.5*(eDEDXlayer[4]+eDEDXlayer[5]);  
     else if(eDEDXlayer[4]!=-1&&eDEDXlayer[5]==-1)eDEDXplane[2]=eDEDXlayer[4];  
     else if(eDEDXlayer[5]!=-1&&eDEDXlayer[4]==-1)eDEDXplane[2]=eDEDXlayer[5];  
2044    
2045    }      //    printf(" PMT IS %i dedx is %f vector is %f \n",ii,dEdx,eDEDXpmt[ii]);
     
2046    
2047      }  //end loop on 48 PMT
2048    
2049  };  };
2050    
2051    
2052  //------------------------------------------------------------------------  //------------------------------------------------------------------------
 void ToFdEdx::PrintTD()  
 {  
   for(int i=0; i<48; i++) {    
     TArrayF &binx = TDx[i];  
     TArrayF &biny = TDy[i];  
     for(int k=0; k<200; k++) {  // bin temporali  
       printf("%d %d %f %f", i,k, binx[k], biny[k]);  
         
     }  
   }  
 }  
   
   
 //------------------------------------------------------------------------  
2053  void ToFdEdx::Define_PMTsat()  void ToFdEdx::Define_PMTsat()
2054  {  {
2055    Float_t  sat[48] = {    Float_t  sat[48] = {
# Line 1861  void ToFdEdx::Define_PMTsat() Line 2063  void ToFdEdx::Define_PMTsat()
2063  }  }
2064    
2065  //------------------------------------------------------------------------  //------------------------------------------------------------------------
 // void ToFdEdx::ReadParTD( Int_t ipmt, const char *fname )  
 // {  
 //   printf("read %s\n",fname);  
 //   if(ipmt<0)  return;  
 //   if(ipmt>47) return;  
 //   FILE *fattin = fopen( fname , "r" );  
 //   Float_t yTD[200],xTD[200];  
 //   for(int j=0;j<200;j++){  
 //     float x,y,ym,e;  
 //     if(fscanf(fattin,"%f %f %f %f",  
 //            &x, &y, &ym, &e )!=4) break;  
 //     xTD[j]=x;  
 //     if(ym>0&&fabs(y-ym)>1)  yTD[j]=ym;  
 //     else                    yTD[j]=y;  
 //   }  
 //   TDx[ipmt].Set(200,xTD);  
 //   TDy[ipmt].Set(200,yTD);  
 //   fclose(fattin);  
 // }  
   
 //------------------------------------------------------------------------  
2066  void ToFdEdx::ReadParBBpos( const char *fname )  void ToFdEdx::ReadParBBpos( const char *fname )
2067  {  {
2068    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2069    parBBpos.Set(48);    parBBpos.Set(48);
2070    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2071    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
# Line 1900  void ToFdEdx::ReadParBBpos( const char * Line 2081  void ToFdEdx::ReadParBBpos( const char *
2081  //------------------------------------------------------------------------  //------------------------------------------------------------------------
2082  void ToFdEdx::ReadParDesatBB( const char *fname )  void ToFdEdx::ReadParDesatBB( const char *fname )
2083  {  {
2084    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2085    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2086    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2087      int   tid=0;      int   tid=0;
# Line 1917  void ToFdEdx::ReadParDesatBB( const char Line 2098  void ToFdEdx::ReadParDesatBB( const char
2098  void ToFdEdx::ReadParBBneg( const char *fname )  void ToFdEdx::ReadParBBneg( const char *fname )
2099    
2100  {  {
2101    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2102    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2103    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2104      int   tid=0;      int   tid=0;
# Line 1932  void ToFdEdx::ReadParBBneg( const char * Line 2113  void ToFdEdx::ReadParBBneg( const char *
2113  //------------------------------------------------------------------------  //------------------------------------------------------------------------
2114  void ToFdEdx::ReadParPos( const char *fname )  void ToFdEdx::ReadParPos( const char *fname )
2115  {  {
2116    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2117    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2118    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2119      int   tid=0;      int   tid=0;
# Line 1947  void ToFdEdx::ReadParPos( const char *fn Line 2128  void ToFdEdx::ReadParPos( const char *fn
2128  //------------------------------------------------------------------------  //------------------------------------------------------------------------
2129  void ToFdEdx::ReadParAtt( const char *fname )  void ToFdEdx::ReadParAtt( const char *fname )
2130  {  {
2131    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2132    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2133    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2134      int   tid=0;      int   tid=0;
# Line 2020  float ToFdEdx::Get_adc_he( int id, float Line 2201  float ToFdEdx::Get_adc_he( int id, float
2201    //             pl_x - coord x of the tof plane    //             pl_x - coord x of the tof plane
2202    //             pl_y - coord y    //             pl_y - coord y
2203    
2204     adc_he = 0;    adc_he = 0;
2205    if( eGeom.GetXY(id)==1 )  adc_he = f_att( (parAtt[id]), pl_x[eGeom.GetPlane(id)] );    if( eGeom.GetXY(id)==1 )  adc_he = f_att( (parAtt[id]), pl_x[eGeom.GetPlane(id)] );
2206    if( eGeom.GetXY(id)==2 )  adc_he = f_att( (parAtt[id]), pl_y[eGeom.GetPlane(id)] );    if( eGeom.GetXY(id)==2 )  adc_he = f_att( (parAtt[id]), pl_y[eGeom.GetPlane(id)] );
2207    return adc_he;    return adc_he;
# Line 2055  double ToFdEdx::f_desatBB5B( float x ) Line 2236  double ToFdEdx::f_desatBB5B( float x )
2236      0.009*x*x;      0.009*x*x;
2237  }  }
2238    
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
Legend:
Removed from v.1.26  
changed lines
  Added in v.1.45
  ViewVC Help
Powered by ViewVC 1.1.23