/[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.44 by mocchiut, Thu Feb 26 14:35:01 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 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(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 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 1149  Int_t ToFLevel2::Process(TrkLevel2 *trk, Line 1291  Int_t ToFLevel2::Process(TrkLevel2 *trk,
1291    //    //
1292    // 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
1293    //    //
1294      printf("\n\n\n ERROR: NOT IMPLEMENTED ANYMORE, write Emiliano if you need this method (Emiliano.Mocchiutti@ts.infn.it) \n\n\n");
1295      return(-1);
1296      //   //
1297      //   // structures to communicate with F77
1298    //    //   //
1299    // structures to communicate with F77    //   extern struct ToFInput  tofinput_;
1300    //  //   extern struct ToFOutput tofoutput_;
1301    extern struct ToFInput  tofinput_;  //   //
1302    extern struct ToFOutput tofoutput_;  //   // DB connection
1303    //  //   //
1304    // DB connection  //   TString host;
1305    //  //   TString user;
1306    TString host;  //   TString psw;
1307    TString user;  //   const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
1308    TString psw;  //   const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
1309    const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");  //   const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
1310    const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");  //   if ( !pamdbhost ) pamdbhost = "";
1311    const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");  //   if ( !pamdbuser ) pamdbuser = "";
1312    if ( !pamdbhost ) pamdbhost = "";  //   if ( !pamdbpsw ) pamdbpsw = "";
1313    if ( !pamdbuser ) pamdbuser = "";  //   if ( strcmp(pamdbhost,"") ) host = pamdbhost;
1314    if ( !pamdbpsw ) pamdbpsw = "";  //   if ( strcmp(pamdbuser,"") ) user = pamdbuser;
1315    if ( strcmp(pamdbhost,"") ) host = pamdbhost;  //   if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;
1316    if ( strcmp(pamdbuser,"") ) user = pamdbuser;  //   //
1317    if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;  //   //
1318    //  //   TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
1319    //  //   if ( !dbc->IsConnected() ) return 1;
1320    TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());  //   stringstream myquery;
1321    if ( !dbc->IsConnected() ) return 1;  //   myquery.str("");
1322    stringstream myquery;  //   myquery << "SET time_zone='+0:00';";
1323    myquery.str("");  //   dbc->Query(myquery.str().c_str());
1324    myquery << "SET time_zone='+0:00'";  //   delete dbc->Query("SET sql_mode = 'NO_UNSIGNED_SUBTRACTION';");
1325    dbc->Query(myquery.str().c_str());  //   GL_PARAM *glparam = new GL_PARAM();
1326    GL_PARAM *glparam = new GL_PARAM();  //   glparam->Query_GL_PARAM(1,1,dbc); // parameters stored in DB in GL_PRAM table
1327    glparam->Query_GL_PARAM(1,1,dbc); // parameters stored in DB in GL_PRAM table  //   trk->LoadField(glparam->PATH+glparam->NAME);
1328    trk->LoadField(glparam->PATH+glparam->NAME);  //   //
1329    //  //   Bool_t defcal = true;
1330    Bool_t defcal = true;  //   Int_t error=glparam->Query_GL_PARAM(run->RUNHEADER_TIME,201,dbc); // parameters stored in DB in GL_PRAM table
1331    Int_t error=glparam->Query_GL_PARAM(run->RUNHEADER_TIME,201,dbc); // parameters stored in DB in GL_PRAM table  //   if ( error<0 ) {
1332    if ( error<0 ) {  //     return(1);
1333      return(1);  //   };
1334    };  //   printf(" Reading ToF parameter file: %s \n",(glparam->PATH+glparam->NAME).Data());
1335    printf(" Reading ToF parameter file: %s \n",(glparam->PATH+glparam->NAME).Data());  //   if ( (UInt_t)glparam->TO_TIME != (UInt_t)4294967295UL ) defcal = false;
1336    if ( (UInt_t)glparam->TO_TIME != (UInt_t)4294967295UL ) defcal = false;  //   //
1337    //  //   Int_t nlen = (Int_t)(glparam->PATH+glparam->NAME).Length();
1338    Int_t nlen = (Int_t)(glparam->PATH+glparam->NAME).Length();  //   rdtofcal((char *)(glparam->PATH+glparam->NAME).Data(),&nlen);
1339    rdtofcal((char *)(glparam->PATH+glparam->NAME).Data(),&nlen);  //   //
1340    //  //   Int_t adc[4][12];
1341    Int_t adc[4][12];  //   Int_t tdc[4][12];
1342    Int_t tdc[4][12];  //   Float_t tdcc[4][12];
1343    Float_t tdcc[4][12];  //   //
1344    //  //   // process tof data
1345    // process tof data  //   //
1346    //  //   for (Int_t hh=0; hh<12;hh++){
1347    for (Int_t hh=0; hh<12;hh++){  //     for (Int_t kk=0; kk<4;kk++){
1348      for (Int_t kk=0; kk<4;kk++){  //            adc[kk][hh] = 4095;
1349             adc[kk][hh] = 4095;  //            tdc[kk][hh] = 4095;
1350             tdc[kk][hh] = 4095;  //            tdcc[kk][hh] = 4095.;
1351             tdcc[kk][hh] = 4095.;  //            tofinput_.adc[hh][kk] = 4095;
1352             tofinput_.adc[hh][kk] = 4095;  //            tofinput_.tdc[hh][kk] = 4095;
1353             tofinput_.tdc[hh][kk] = 4095;  //     };
1354      };  //   };
1355    };  //   Int_t ntrkentry = 0;
1356    Int_t ntrkentry = 0;  //   Int_t npmtentry = 0;
1357    Int_t npmtentry = 0;  //   Int_t gg = 0;
1358    Int_t gg = 0;  //   Int_t hh = 0;
1359    Int_t hh = 0;  //   Int_t adcf[48];
1360    Int_t adcf[48];  //   memset(adcf, 0, 48*sizeof(Int_t));
1361    memset(adcf, 0, 48*sizeof(Int_t));  //   Int_t tdcf[48];
1362    Int_t tdcf[48];  //   memset(tdcf, 0, 48*sizeof(Int_t));
1363    memset(tdcf, 0, 48*sizeof(Int_t));  //   for (Int_t pm=0; pm < this->ntrk() ; pm++){
1364    for (Int_t pm=0; pm < this->ntrk() ; pm++){  //      ToFTrkVar *ttf = this->GetToFTrkVar(pm);
1365       ToFTrkVar *ttf = this->GetToFTrkVar(pm);  //      for ( Int_t nc=0; nc < ttf->npmttdc; nc++){
1366       for ( Int_t nc=0; nc < ttf->npmttdc; nc++){  //             if ( (ttf->tdcflag).At(nc) != 0 ) tdcf[(ttf->pmttdc).At(nc)] = 1;
1367              if ( (ttf->tdcflag).At(nc) != 0 ) tdcf[(ttf->pmttdc).At(nc)] = 1;  //      };
1368       };  //      for ( Int_t nc=0; nc < ttf->npmtadc; nc++){
1369       for ( Int_t nc=0; nc < ttf->npmtadc; nc++){  //             if ( (ttf->adcflag).At(nc) != 0 ) adcf[(ttf->pmtadc).At(nc)] = 1;
1370              if ( (ttf->adcflag).At(nc) != 0 ) adcf[(ttf->pmtadc).At(nc)] = 1;  //      };
1371       };  //   };
1372    };  //   //
1373    //  //   for (Int_t pm=0; pm < this->npmt() ; pm++){
1374    for (Int_t pm=0; pm < this->npmt() ; pm++){  //      ToFPMT *pmt = this->GetToFPMT(pm);
1375       ToFPMT *pmt = this->GetToFPMT(pm);  //      this->GetPMTIndex(pmt->pmt_id, gg, hh);
1376       this->GetPMTIndex(pmt->pmt_id, gg, hh);  //      if ( adcf[pmt->pmt_id] == 0 ){
1377       if ( adcf[pmt->pmt_id] == 0 ){  //              tofinput_.adc[gg][hh] = (int)pmt->adc;
1378               tofinput_.adc[gg][hh] = (int)pmt->adc;  //              adc[hh][gg] = (int)pmt->adc;
1379               adc[hh][gg] = (int)pmt->adc;  //      };
1380       };  //      if ( tdcf[pmt->pmt_id] == 0 ){
1381       if ( tdcf[pmt->pmt_id] == 0 ){  //              tofinput_.tdc[gg][hh] = (int)pmt->tdc;
1382               tofinput_.tdc[gg][hh] = (int)pmt->tdc;  //              tdc[hh][gg] = (int)pmt->tdc;
1383               tdc[hh][gg] = (int)pmt->tdc;  //      };
1384       };  //      tdcc[hh][gg] = (float)pmt->tdc_tw;
1385       tdcc[hh][gg] = (float)pmt->tdc_tw;  //      // Int_t pppid = this->GetPMTid(hh,gg);
1386       // 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);
1387       //      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);  //   };
1388    };  //   //
1389    //  //   Int_t unpackError = this->unpackError;
1390    Int_t unpackError = this->unpackError;  //   //
1391    //  //   for (Int_t hh=0; hh<5;hh++){
1392    for (Int_t hh=0; hh<5;hh++){  //      tofinput_.patterntrig[hh]=trg->patterntrig[hh];
1393       tofinput_.patterntrig[hh]=trg->patterntrig[hh];  //   };
1394    };  //   //
1395    //  //   this->Clear();
1396    this->Clear();  //   //
1397    //  //       Int_t pmt_id = 0;
1398        Int_t pmt_id = 0;  //       ToFPMT *t_pmt = new ToFPMT();
1399        ToFPMT *t_pmt = new ToFPMT();  //       if(!(this->PMT)) this->PMT = new TClonesArray("ToFPMT",12); //ELENA
1400        if(!(this->PMT)) this->PMT = new TClonesArray("ToFPMT",12); //ELENA  //       TClonesArray &tpmt = *this->PMT;
1401        TClonesArray &tpmt = *this->PMT;  //       ToFTrkVar *t_tof = new ToFTrkVar();
1402        ToFTrkVar *t_tof = new ToFTrkVar();  //       if(!(this->ToFTrk)) this->ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA
1403        if(!(this->ToFTrk)) this->ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA  //       TClonesArray &t = *this->ToFTrk;
1404        TClonesArray &t = *this->ToFTrk;  //       //
1405        //  //       //
1406        //  //       // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract common and track-related  variables.
1407        // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract common and track-related  variables.  //       //
1408        //  //       npmtentry = 0;
1409        npmtentry = 0;  //       //
1410        //  //       ntrkentry = 0;
1411        ntrkentry = 0;  //       //
1412        //  //       // Calculate tracks informations from ToF alone
1413        // Calculate tracks informations from ToF alone  //       //
1414        //  //       tofl2com();
1415        tofl2com();  //       //
1416        //  //       memcpy(this->tof_j_flag,tofoutput_.tof_j_flag,6*sizeof(Int_t));
1417        memcpy(this->tof_j_flag,tofoutput_.tof_j_flag,6*sizeof(Int_t));  //       //
1418        //  //       t_tof->trkseqno = -1;
1419        t_tof->trkseqno = -1;  //       //
1420        //  //       // and now we must copy from the output structure to the level2 class:
1421        // and now we must copy from the output structure to the level2 class:  //       //
1422        //  //       t_tof->npmttdc = 0;
1423        t_tof->npmttdc = 0;  //       //
1424        //  //       for (Int_t hh=0; hh<12;hh++){
1425        for (Int_t hh=0; hh<12;hh++){  //         for (Int_t kk=0; kk<4;kk++){
1426          for (Int_t kk=0; kk<4;kk++){  //           if ( tofoutput_.tofmask[hh][kk] != 0 ){
1427            if ( tofoutput_.tofmask[hh][kk] != 0 ){  //             pmt_id = this->GetPMTid(kk,hh);
1428              pmt_id = this->GetPMTid(kk,hh);  //             t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
1429              t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);  //             t_tof->tdcflag.AddAt(tofoutput_.tdcflagtof[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
1430              t_tof->tdcflag.AddAt(tofoutput_.tdcflagtof[hh][kk],t_tof->npmttdc); // gf: Jan 09/07  //             t_tof->npmttdc++;
1431              t_tof->npmttdc++;  //           };
1432            };  //         };
1433          };  //       };
1434        };  //       for (Int_t kk=0; kk<13;kk++){
1435        for (Int_t kk=0; kk<13;kk++){  //         t_tof->beta[kk] = tofoutput_.betatof_a[kk];
1436          t_tof->beta[kk] = tofoutput_.betatof_a[kk];  //       }
1437        }  //       //
1438        //  //       t_tof->npmtadc = 0;
1439        t_tof->npmtadc = 0;  //       for (Int_t hh=0; hh<12;hh++){
1440        for (Int_t hh=0; hh<12;hh++){  //         for (Int_t kk=0; kk<4;kk++){
1441          for (Int_t kk=0; kk<4;kk++){  //           if ( tofoutput_.adctof_c[hh][kk] < 1000 ){
1442            if ( tofoutput_.adctof_c[hh][kk] < 1000 ){  //             t_tof->dedx.AddAt(tofoutput_.adctof_c[hh][kk],t_tof->npmtadc);
1443              t_tof->dedx.AddAt(tofoutput_.adctof_c[hh][kk],t_tof->npmtadc);  //             pmt_id = this->GetPMTid(kk,hh);
1444              pmt_id = this->GetPMTid(kk,hh);  //             t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
1445              t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);  //             t_tof->adcflag.AddAt(tofoutput_.adcflagtof[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
1446              t_tof->adcflag.AddAt(tofoutput_.adcflagtof[hh][kk],t_tof->npmtadc); // gf: Jan 09/07  //             t_tof->npmtadc++;
1447              t_tof->npmtadc++;  //           };
1448            };  //         };
1449          };  //       };
1450        };  //       //
1451        //  //       memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
1452        memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));  //       memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
1453        memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));  //       memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
1454        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));
1455        memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));  //       //
1456        //  //       new(t[ntrkentry]) ToFTrkVar(*t_tof);
1457        new(t[ntrkentry]) ToFTrkVar(*t_tof);  //       ntrkentry++;
1458        ntrkentry++;  //       t_tof->Clear();
1459        t_tof->Clear();  //       //
1460        //  //       //
1461        //  //       //
1462        //  //       t_pmt->Clear();
1463        t_pmt->Clear();  //       //
1464        //  //       for (Int_t hh=0; hh<12;hh++){
1465        for (Int_t hh=0; hh<12;hh++){  //         for (Int_t kk=0; kk<4;kk++){
1466          for (Int_t kk=0; kk<4;kk++){  //          // new WM
1467           // new WM  //           if ( tofoutput_.tdc_c[hh][kk] < 4095 || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){
1468            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 ){
1469  //          if ( tdcc[kk][hh] < 4095. || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){  //             //
1470              //  //             t_pmt->pmt_id = this->GetPMTid(kk,hh);
1471              t_pmt->pmt_id = this->GetPMTid(kk,hh);  //             t_pmt->tdc_tw = tofoutput_.tdc_c[hh][kk];
1472              t_pmt->tdc_tw = tofoutput_.tdc_c[hh][kk];  //             t_pmt->adc = (Float_t)adc[kk][hh];
1473              t_pmt->adc = (Float_t)adc[kk][hh];  //             t_pmt->tdc = (Float_t)tdc[kk][hh];
1474              t_pmt->tdc = (Float_t)tdc[kk][hh];  //             //
1475              //  //             new(tpmt[npmtentry]) ToFPMT(*t_pmt);
1476              new(tpmt[npmtentry]) ToFPMT(*t_pmt);  //             npmtentry++;
1477              npmtentry++;  //             t_pmt->Clear();
1478              t_pmt->Clear();  //           };
1479            };  //         };
1480          };  //       };
1481        };  //       //
1482        //  //       // Calculate track-related variables
1483        // Calculate track-related variables  //       //
1484        //  //       if ( trk->ntrk() > 0 ){
1485        if ( trk->ntrk() > 0 ){  //         //
1486          //  //         // We have at least one track
1487          // We have at least one track  //         //
1488          //  //         //
1489          //  //         // Run over tracks
1490          // Run over tracks  //         //
1491          //  //         for(Int_t nt=0; nt < trk->ntrk(); nt++){
1492          for(Int_t nt=0; nt < trk->ntrk(); nt++){  //           //
1493            //  //           TrkTrack *ptt = trk->GetStoredTrack(nt);
1494            TrkTrack *ptt = trk->GetStoredTrack(nt);  //           //
1495            //  //           // Copy the alpha vector in the input structure
1496            // Copy the alpha vector in the input structure  //           //
1497            //  //           for (Int_t e = 0; e < 5 ; e++){
1498            for (Int_t e = 0; e < 5 ; e++){  //             tofinput_.al_pp[e] = ptt->al[e];
1499              tofinput_.al_pp[e] = ptt->al[e];  //           };
1500            };  //           //
1501            //  //           // Get tracker related variables for this track
1502            // Get tracker related variables for this track  //           //
1503            //  //           toftrk();
1504            toftrk();  //           //
1505            //  //           // Copy values in the class from the structure (we need to use a temporary class to store variables).
1506            // Copy values in the class from the structure (we need to use a temporary class to store variables).  //           //
1507            //  //           t_tof->npmttdc = 0;
1508            t_tof->npmttdc = 0;  //           for (Int_t hh=0; hh<12;hh++){
1509            for (Int_t hh=0; hh<12;hh++){  //             for (Int_t kk=0; kk<4;kk++){
1510              for (Int_t kk=0; kk<4;kk++){  //               if ( tofoutput_.tofmask[hh][kk] != 0 ){
1511                if ( tofoutput_.tofmask[hh][kk] != 0 ){  //                 pmt_id = this->GetPMTid(kk,hh);
1512                  pmt_id = this->GetPMTid(kk,hh);  //                 t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
1513                  t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);  //                 t_tof->tdcflag.AddAt(tofoutput_.tdcflag[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
1514                  t_tof->tdcflag.AddAt(tofoutput_.tdcflag[hh][kk],t_tof->npmttdc); // gf: Jan 09/07  //                 t_tof->npmttdc++;
1515                  t_tof->npmttdc++;  //               };
1516                };  //             };
1517              };  //           };
1518            };  //           for (Int_t kk=0; kk<13;kk++){
1519            for (Int_t kk=0; kk<13;kk++){  //             t_tof->beta[kk] = tofoutput_.beta_a[kk];
1520              t_tof->beta[kk] = tofoutput_.beta_a[kk];  //           };
1521            };  //           //
1522            //  //           t_tof->npmtadc = 0;
1523            t_tof->npmtadc = 0;  //           for (Int_t hh=0; hh<12;hh++){
1524            for (Int_t hh=0; hh<12;hh++){  //             for (Int_t kk=0; kk<4;kk++){
1525              for (Int_t kk=0; kk<4;kk++){  //               if ( tofoutput_.adc_c[hh][kk] < 1000 ){
1526                if ( tofoutput_.adc_c[hh][kk] < 1000 ){  //                 t_tof->dedx.AddAt(tofoutput_.adc_c[hh][kk],t_tof->npmtadc);
1527                  t_tof->dedx.AddAt(tofoutput_.adc_c[hh][kk],t_tof->npmtadc);  //                 pmt_id = this->GetPMTid(kk,hh);
1528                  pmt_id = this->GetPMTid(kk,hh);  //                 t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
1529                  t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);  //                 t_tof->adcflag.AddAt(tofoutput_.adcflag[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
1530                  t_tof->adcflag.AddAt(tofoutput_.adcflag[hh][kk],t_tof->npmtadc); // gf: Jan 09/07  //                 t_tof->npmtadc++;
1531                  t_tof->npmtadc++;  //               };
1532                };  //             };
1533              };  //           };
1534            };  //           //
1535            //  //           memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
1536            memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));  //           memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
1537            memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));  //           memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
1538            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));
1539            memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));  //           //
1540            //  //           // Store the tracker track number in order to be sure to have shyncronized data during analysis
1541            // Store the tracker track number in order to be sure to have shyncronized data during analysis  //           //
1542            //  //           t_tof->trkseqno = nt;
1543            t_tof->trkseqno = nt;  //           //
1544            //  //           // create a new object for this event with track-related variables
1545            // create a new object for this event with track-related variables  //           //
1546            //  //           new(t[ntrkentry]) ToFTrkVar(*t_tof);
1547            new(t[ntrkentry]) ToFTrkVar(*t_tof);  //           ntrkentry++;
1548            ntrkentry++;  //           t_tof->Clear();
1549            t_tof->Clear();  //           //
1550            //  //         }; // loop on all the tracks
1551          }; // loop on all the tracks  //       //
1552        //  //       this->unpackError = unpackError;
1553        this->unpackError = unpackError;  //       if ( defcal ){
1554        if ( defcal ){  //         this->default_calib = 1;
1555          this->default_calib = 1;  //       } else {
1556        } else {  //         this->default_calib = 0;
1557          this->default_calib = 0;  //       };
1558        };  //};
1559   };  //  return(0);
1560    }
1561    
1562    bool ToFLevel2::bit(int decimal, char pos){
1563    return(0);    return( (decimal>>pos)%2 );
1564    }
1565    
1566    bool ToFLevel2::checkPMT(TString givenpmt){
1567      TClonesArray* Pmt = this->PMT;
1568      //  printf(" ou %s entries %i \n",givenpmt.Data(),Pmt->GetEntries());
1569      for(int i=0; i<Pmt->GetEntries(); i++) {  
1570        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1571        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1572        //    printf(" name %s \n",pmtname.Data());
1573        if ( !strcmp(pmtname.Data(),givenpmt.Data()) )
1574          return true;
1575      }
1576      //  printf(" PMT %s missing \n",givenpmt.Data());
1577      return false;
1578    }
1579    
1580    bool ToFLevel2::checkPMTpatternPMThit(TrigLevel2 *trg, int &pmtpattern, int &pmtnosignal){
1581      UInt_t *patterntrig = trg->patterntrig;
1582      pmtpattern = 0;
1583      pmtnosignal = 0;
1584      bool good = true;
1585      //S3
1586      if ( this->bit(patterntrig[2],0) ){ pmtpattern++;  if ( !this->checkPMT("S31_1A")){ pmtnosignal++; good = false;}}
1587      if ( this->bit(patterntrig[2],1) ){ pmtpattern++;  if ( !this->checkPMT("S31_2A")){ pmtnosignal++; good = false;}}
1588      if ( this->bit(patterntrig[2],2) ){ pmtpattern++;  if ( !this->checkPMT("S31_3A")){ pmtnosignal++; good = false;}}
1589      if ( this->bit(patterntrig[2],3) ){ pmtpattern++;  if ( !this->checkPMT("S31_1B")){ pmtnosignal++; good = false;}}
1590      if ( this->bit(patterntrig[2],4) ){ pmtpattern++;  if ( !this->checkPMT("S31_2B")){ pmtnosignal++; good = false;}}
1591      if ( this->bit(patterntrig[2],5) ){ pmtpattern++;  if ( !this->checkPMT("S31_3B")){ pmtnosignal++; good = false;}}      
1592      if ( this->bit(patterntrig[2],6) ){ pmtpattern++;  if ( !this->checkPMT("S32_1A")){ pmtnosignal++; good = false;}}
1593      if ( this->bit(patterntrig[2],7) ){ pmtpattern++;  if ( !this->checkPMT("S32_2A")){ pmtnosignal++; good = false;}}
1594      if ( this->bit(patterntrig[2],8) ){ pmtpattern++;  if ( !this->checkPMT("S32_3A")){ pmtnosignal++; good = false;}}
1595      if ( this->bit(patterntrig[2],9) ){ pmtpattern++;  if ( !this->checkPMT("S32_1B")){ pmtnosignal++; good = false;}}
1596      if ( this->bit(patterntrig[2],10) ){ pmtpattern++;  if ( !this->checkPMT("S32_2B")){ pmtnosignal++; good = false;}}
1597      if ( this->bit(patterntrig[2],11) ){ pmtpattern++;  if ( !this->checkPMT("S32_3B")){ pmtnosignal++; good = false;}}      
1598      //S2
1599      if ( this->bit(patterntrig[3],0) ){ pmtpattern++;  if ( !this->checkPMT("S21_1A")){ pmtnosignal++; good = false;}}
1600      if ( this->bit(patterntrig[3],1) ){ pmtpattern++;  if ( !this->checkPMT("S21_2A")){ pmtnosignal++; good = false;}}
1601      if ( this->bit(patterntrig[3],2) ){ pmtpattern++;  if ( !this->checkPMT("S21_1B")){ pmtnosignal++; good = false;}}
1602      if ( this->bit(patterntrig[3],3) ){ pmtpattern++;  if ( !this->checkPMT("S21_2B")){ pmtnosignal++; good = false;}}      
1603      if ( this->bit(patterntrig[3],4) ){ pmtpattern++;  if ( !this->checkPMT("S22_1A")){ pmtnosignal++; good = false;}}
1604      if ( this->bit(patterntrig[3],5) ){ pmtpattern++;  if ( !this->checkPMT("S22_2A")){ pmtnosignal++; good = false;}}
1605      if ( this->bit(patterntrig[3],6) ){ pmtpattern++;  if ( !this->checkPMT("S22_1B")){ pmtnosignal++; good = false;}}
1606      if ( this->bit(patterntrig[3],7) ){ pmtpattern++;  if ( !this->checkPMT("S22_2B")){ pmtnosignal++; good = false;}}      
1607      //S12
1608      if ( this->bit(patterntrig[4],0) ){ pmtpattern++;  if ( !this->checkPMT("S12_1A")){ pmtnosignal++; good = false;}}
1609      if ( this->bit(patterntrig[4],1) ){ pmtpattern++;  if ( !this->checkPMT("S12_2A")){ pmtnosignal++; good = false;}}
1610      if ( this->bit(patterntrig[4],2) ){ pmtpattern++;  if ( !this->checkPMT("S12_3A")){ pmtnosignal++; good = false;}}
1611      if ( this->bit(patterntrig[4],3) ){ pmtpattern++;  if ( !this->checkPMT("S12_4A")){ pmtnosignal++; good = false;}}
1612      if ( this->bit(patterntrig[4],4) ){ pmtpattern++;  if ( !this->checkPMT("S12_5A")){ pmtnosignal++; good = false;}}
1613      if ( this->bit(patterntrig[4],5) ){ pmtpattern++;  if ( !this->checkPMT("S12_6A")){ pmtnosignal++; good = false;}}      
1614      if ( this->bit(patterntrig[4],6) ){ pmtpattern++;  if ( !this->checkPMT("S12_1A")){ pmtnosignal++; good = false;}}
1615      if ( this->bit(patterntrig[4],7) ){ pmtpattern++;  if ( !this->checkPMT("S12_2A")){ pmtnosignal++; good = false;}}
1616      if ( this->bit(patterntrig[4],8) ){ pmtpattern++;  if ( !this->checkPMT("S12_3A")){ pmtnosignal++; good = false;}}
1617      if ( this->bit(patterntrig[4],9) ){ pmtpattern++;  if ( !this->checkPMT("S12_4B")){ pmtnosignal++; good = false;}}
1618      if ( this->bit(patterntrig[4],10) ){ pmtpattern++; if ( !this->checkPMT("S12_5B")){ pmtnosignal++; good = false;}}
1619      if ( this->bit(patterntrig[4],11) ){ pmtpattern++; if ( !this->checkPMT("S12_6B")){ pmtnosignal++; good = false;}}      
1620      //S11
1621      if ( this->bit(patterntrig[5],0) ){ pmtpattern++;  if ( !this->checkPMT("S11_1A")){ pmtnosignal++; good = false;}}
1622      if ( this->bit(patterntrig[5],1) ){ pmtpattern++;  if ( !this->checkPMT("S11_2A")){ pmtnosignal++; good = false;}}
1623      if ( this->bit(patterntrig[5],2) ){ pmtpattern++;  if ( !this->checkPMT("S11_3A")){ pmtnosignal++; good = false;}}
1624      if ( this->bit(patterntrig[5],3) ){ pmtpattern++;  if ( !this->checkPMT("S11_4A")){ pmtnosignal++; good = false;}}
1625      if ( this->bit(patterntrig[5],4) ){ pmtpattern++;  if ( !this->checkPMT("S11_5A")){ pmtnosignal++; good = false;}}
1626      if ( this->bit(patterntrig[5],5) ){ pmtpattern++;  if ( !this->checkPMT("S11_6A")){ pmtnosignal++; good = false;}}
1627      if ( this->bit(patterntrig[5],6) ){ pmtpattern++;  if ( !this->checkPMT("S11_7A")){ pmtnosignal++; good = false;}}
1628      if ( this->bit(patterntrig[5],7) ){ pmtpattern++;  if ( !this->checkPMT("S11_8A")){ pmtnosignal++; good = false;}}      
1629      if ( this->bit(patterntrig[5],8) ){ pmtpattern++;  if ( !this->checkPMT("S11_1B")){ pmtnosignal++; good = false;}}
1630      if ( this->bit(patterntrig[5],9) ){ pmtpattern++;  if ( !this->checkPMT("S11_2B")){ pmtnosignal++; good = false;}}
1631      if ( this->bit(patterntrig[5],10) ){ pmtpattern++; if ( !this->checkPMT("S11_3B")){ pmtnosignal++; good = false;}}
1632      if ( this->bit(patterntrig[5],11) ){ pmtpattern++; if ( !this->checkPMT("S11_4B")){ pmtnosignal++; good = false;}}
1633      if ( this->bit(patterntrig[5],12) ){ pmtpattern++; if ( !this->checkPMT("S11_5B")){ pmtnosignal++; good = false;}}
1634      if ( this->bit(patterntrig[5],13) ){ pmtpattern++; if ( !this->checkPMT("S11_6B")){ pmtnosignal++; good = false;}}
1635      if ( this->bit(patterntrig[5],14) ){ pmtpattern++; if ( !this->checkPMT("S11_7B")){ pmtnosignal++; good = false;}}
1636      if ( this->bit(patterntrig[5],15) ){ pmtpattern++; if ( !this->checkPMT("S11_8B")){ pmtnosignal++; good = false;}}
1637    
1638      return good;
1639    }
1640    
1641    bool ToFLevel2::checkPMTpmttrig(TrigLevel2 *trg){
1642      //  UInt_t *patterntrig = trg->patterntrig;
1643      int rS11 = 0;
1644      int rS12 = 0;
1645      int rS21 = 0;
1646      int rS22 = 0;
1647      int rS31 = 0;
1648      int rS32 = 0;
1649    
1650      // trigger configuration for the event from saved pmts
1651      TClonesArray* Pmt = this->PMT;
1652      for(int i=0; i<Pmt->GetEntries(); i++) {  
1653        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1654        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1655        if ( pmtname.Contains("S11") ) rS11++;
1656        if ( pmtname.Contains("S12") ) rS12++;
1657        if ( pmtname.Contains("S21") ) rS21++;
1658        if ( pmtname.Contains("S22") ) rS22++;
1659        if ( pmtname.Contains("S31") ) rS31++;
1660        if ( pmtname.Contains("S32") ) rS32++;
1661      }
1662      int rTOF1 = (rS11 + rS12) * (rS21 + rS22) * (rS31 + rS32);
1663      int rTOF2 = (rS11 * rS12) * (rS21 * rS22) * (rS31 * rS32);
1664    
1665      int rTOF3 = (rS21 + rS22) * (rS31 + rS32);
1666      int rTOF4 = (rS21 * rS22) * (rS31 * rS32);
1667    
1668      int rTOF5 = rS12 * (rS21 * rS22);
1669    
1670      int rTOF6 = (rS11 + rS12) * (rS31 + rS32);
1671      int rTOF7 = (rS11 * rS12) * (rS31 * rS32);
1672    
1673    
1674      // trigger configuration of the run
1675      bool TCTOF1 = false;
1676      bool TCTOF2 = false;
1677      bool TCTOF3 = false;
1678      bool TCTOF4 = false;
1679      bool TCTOF5 = false;
1680      bool TCTOF6 = false;
1681      bool TCTOF7 = false;
1682      if ( trg->trigconf & (1<<0) ) TCTOF1 = true;
1683      if ( trg->trigconf & (1<<1) ) TCTOF2 = true;
1684      if ( trg->trigconf & (1<<2) ) TCTOF3 = true;
1685      if ( trg->trigconf & (1<<3) ) TCTOF4 = true;
1686      if ( trg->trigconf & (1<<4) ) TCTOF5 = true;
1687      if ( trg->trigconf & (1<<5) ) TCTOF6 = true;
1688      if ( trg->trigconf & (1<<6) ) TCTOF7 = true;
1689    
1690      // do patterntrig pmts match the trigger configuration?
1691      bool pmtsconf_trigconf_match = true;
1692      if ( rTOF1 == 0 && TCTOF1 ) pmtsconf_trigconf_match = false;
1693      if ( rTOF2 == 0 && TCTOF2 ) pmtsconf_trigconf_match = false;
1694      if ( rTOF3 == 0 && TCTOF3 ) pmtsconf_trigconf_match = false;
1695      if ( rTOF4 == 0 && TCTOF4 ) pmtsconf_trigconf_match = false;
1696      if ( rTOF5 == 0 && TCTOF5 ) pmtsconf_trigconf_match = false;
1697      if ( rTOF6 == 0 && TCTOF6 ) pmtsconf_trigconf_match = false;
1698      if ( rTOF7 == 0 && TCTOF7 ) pmtsconf_trigconf_match = false;
1699    
1700      return pmtsconf_trigconf_match;
1701    }
1702    
1703    void ToFLevel2::printPMT(){
1704      TClonesArray* Pmt = this->PMT;
1705      for(int i=0; i<Pmt->GetEntries(); i++) {  
1706        ToFPMT* pmthit = (ToFPMT*)Pmt->At(i);
1707        TString pmtname = this->GetPMTName(pmthit->pmt_id);
1708        printf(" PMT hit: %s \n",pmtname.Data());
1709      }
1710  }  }
1711    
1712    
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
1713  ToFdEdx::ToFdEdx()  ToFdEdx::ToFdEdx()
1714  {  {
1715    memset(conn,0,12*sizeof(Bool_t));    memset(conn,0,12*sizeof(Bool_t));
1716    memset(ts,0,12*sizeof(UInt_t));    memset(ts,0,12*sizeof(UInt_t));
1717    memset(te,0,12*sizeof(UInt_t));    memset(te,0,12*sizeof(UInt_t));
1718      eDEDXpmt = new TArrayF(48);
1719    Define_PMTsat();    Define_PMTsat();
1720    Clear();    Clear();
1721  }  }
1722    
1723    ToFdEdx::~ToFdEdx(){
1724      Clear();
1725      Delete();
1726    }
1727    
1728    void ToFdEdx::Delete(Option_t *option){
1729      if ( eDEDXpmt ){
1730        eDEDXpmt->Set(0);
1731        if ( eDEDXpmt) delete eDEDXpmt;
1732      }
1733    }
1734    
1735  //------------------------------------------------------------------------  //------------------------------------------------------------------------
1736  void ToFdEdx::CheckConnectors(UInt_t atime, GL_PARAM *glparam, TSQLServer *dbc)  void ToFdEdx::CheckConnectors(UInt_t atime, GL_PARAM *glparam, TSQLServer *dbc)
1737  {  {
# Line 1493  void ToFdEdx::Clear(Option_t *option) Line 1773  void ToFdEdx::Clear(Option_t *option)
1773  {  {
1774    //    //
1775    // Set arrays and initialize structure    // Set arrays and initialize structure
1776      //  eDEDXpmt.Set(48);    eDEDXpmt.Reset(-1);   // Set array size  and reset structure
1777    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);  
1778    //    //
1779  };  };
1780    
# Line 1515  void ToFdEdx::Print(Option_t *option) Line 1786  void ToFdEdx::Print(Option_t *option)
1786    
1787  };  };
1788    
   
1789  //------------------------------------------------------------------------  //------------------------------------------------------------------------
1790  // void ToFdEdx::InitPar(TString parname, TString parfile)  void ToFdEdx::Init(pamela::tof::TofEvent *tofl0)
1791  // {  {
1792  //   // expensive function - call it once/run    //
1793      ToFLevel2 tf;
1794      for (Int_t gg=0; gg<4;gg++){
1795        for (Int_t hh=0; hh<12;hh++){
1796  //   ReadParAtt(            Form("%s/attenuation.txt"              , pardir) );        //          tofinput_.tdc[hh][gg]=tofEvent->tdc[gg][hh];          
1797  //   ReadParPos(            Form("%s/desaturation_position.txt"    , pardir) );        int mm = tf.GetPMTid(gg,hh);        
1798  //   ReadParBBneg(          Form("%s/BetheBloch.txt"               , pardir) );        adc[mm]= (0xFFF & tofl0->adc[gg][hh]); // EM, exclude warning bits
1799  //   ReadParBBpos(          Form("%s/BetheBloch_betagt1.txt"       , pardir) );      };      
1800  //   ReadParDesatBB(        Form("%s/desaturation_beta.txt"        , pardir) );    };
1801      
1802  // };  };
   
1803    
1804  //------------------------------------------------------------------------  //------------------------------------------------------------------------
1805  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)
1806  {  {
1807      //
1808      ToFLevel2 tf;
1809      //  for (Int_t gg=0; gg<4;gg++){
1810      //    for (Int_t hh=0; hh<12;hh++){
1811      int mm = tf.GetPMTid(gg,hh);    
1812      adc[mm]=adce;
1813      
1814    };
1815    //------------------------------------------------------------------------
1816    void ToFdEdx::Process(UInt_t atime, Float_t betamean, Float_t *xtr_tof, Float_t *ytr_tof, Int_t exitat)
1817    {
1818      bool debug = false;
1819      if ( debug ) printf(" INSIDE TOFDEDX PROCESS \n");
1820    // the parameters should be already initialised by InitPar()    // the parameters should be already initialised by InitPar()
1821      //  printf(" in process \n");
   
1822    Clear();    Clear();
1823    
   
   
   //  Float_t betamean = fabs(trackTRK->GetToFTrack()->beta[12]);  
   
   if(betamean<0.05 || betamean>2){  
     for(int i=0;i<48;i++)INFOpmt[i]=1;  
   }  
   
1824   // define angle:     // define angle:  
1825    double dx   = xtr_tof[1] - xtr_tof[5];    double dx   = xtr_tof[1] - xtr_tof[5];
1826    double dy   = ytr_tof[0] - ytr_tof[4];    double dy   = ytr_tof[0] - ytr_tof[4];
1827    double dr   = sqrt(dx*dx+dy*dy);    double dr   = sqrt(dx*dx+dy*dy);
1828    double theta=atan(dr/76.81);    double theta=atan(dr/76.81);
1829      //
1830      if ( xtr_tof[1] > 99. ||  xtr_tof[5] > 99. || ytr_tof[0] > 99. ||  ytr_tof[4] > 99. ) theta = 0.;
1831      for (Int_t ii=0; ii<6; ii++){
1832    //  TArrayF adc;      if ( xtr_tof[ii] > 99. ) xtr_tof[ii] = 0.;
1833    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];  
     };        
1834    };    };
1835        //
1836        if ( debug ) printf(" theta %f \n",theta);
1837        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]);
1838        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]);
1839      //--------------------- TABLE OF PERIODS WITH HV PROBLEMS ----------------------------
1840      
1841      int Aconn=conn[0];    // PMT 0,20,22,24
1842      int Bconn=conn[1];    // PMT 6,12,26,34
1843      int Cconn=conn[2];    // PMT 4,14,28,32
1844      int Dconn=conn[3];    // PMT 2,8,10,30
1845      int Econn=conn[4];    // PMT 42,43,44,47
1846      int Fconn=conn[5];    // PMT 7,19,23,27
1847      int Gconn=conn[6];    // PMT 3,11,25,33
1848      int Hconn=conn[7];    // PMT 1,9,13,21
1849      int Iconn=conn[8];    // PMT 5,29,31,35
1850      int Lconn=conn[9];    // PMT 37,40,45,46
1851      int Mconn=conn[10];    // PMT 15,16,17,18
1852      int Nconn=conn[11];    // PMT 36,38,39,41
1853      if( false ) cout << Gconn << Iconn << Lconn <<endl; // to avoid compilation warnings
1854        
1855      //  printf(" size %i \n",eDEDXpmt.GetSize());
1856    for( int ii=0; ii<48; ii++ ) {    for( int ii=0; ii<48; ii++ ) {
1857      if( adc[ii] >= PMTsat[ii]-5 )  continue;      //
1858      if( adc[ii] <= 0. )            continue;      //    eDEDXpmt.SetAt(-1.,ii);
1859          //    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]);
1860      double adcpC   = f_adcPC( adc[ii] );    // - adc conversion in pC      if ( debug ) printf("II %i adc %f \n",ii,adc[ii]);
1861      double adccorr = adcpC*fabs(cos(theta));  
1862        if( adc[ii] >= 4095. ){
1863           if(adccorr<=0.)           continue;        //      eDEDXpmt[ii] = 0.;
1864          eDEDXpmt->AddAt(0.,ii);
1865          if ( debug ) printf(" %i adc>4095 \n",ii);
1866          continue; // EMILIANO
1867        };
1868    
1869      //--------------------- TABLE OF PERIODS WITH HV PROBLEMS ----------------------------      if( adc[ii] >= (PMTsat[ii]-5.) && adc[ii] < 4095. ){
1870          eDEDXpmt->AddAt(1000.,ii);
1871          if ( debug ) printf(" %i adc> pmtsat && adc<4095 \n",ii);
1872          continue; // EMILIANO
1873        };
1874    
1875      int Aconn=conn[0];    // PMT 0,20,22,24      if( adc[ii] <= 0. ) {
1876      int Bconn=conn[1];    // PMT 6,12,26,34        eDEDXpmt->AddAt(1500.,ii);
1877      int Cconn=conn[2];    // PMT 4,14,28,32        if ( debug ) printf(" %i adc<=0 \n",ii);
1878      int Dconn=conn[3];    // PMT 2,8,10,30        continue;
1879      int Econn=conn[4];    // PMT 42,43,44,47      };
1880      int Fconn=conn[5];    // PMT 7,19,23,27      //
1881      int Gconn=conn[6];    // PMT 3,11,25,33      double adcpC   = f_adcPC( adc[ii] );    // - adc conversion in pC
1882      int Hconn=conn[7];    // PMT 1,9,13,21      if ( exitat == 0 ){
1883      int Iconn=conn[8];    // PMT 5,29,31,35        eDEDXpmt->AddAt((Float_t)adcpC,ii);
1884      int Lconn=conn[9];    // PMT 37,40,45,46        continue;
1885      int Mconn=conn[10];    // PMT 15,16,17,18      }
1886      int Nconn=conn[11];    // PMT 36,38,39,41      //    printf(" e qua? \n");
1887    
1888        double adccorr = adcpC*fabs(cos(theta));    
1889        if ( debug ) printf(" adccorr %f \n",adccorr);
1890        if(adccorr<=0.){
1891          if ( debug ) printf(" %i adccorr<=0 \n",ii);
1892          //      eDEDXpmt->AddAt((Float_t)adcpC,ii);//?
1893          continue;
1894        }
1895        if ( exitat == 1 ){
1896          eDEDXpmt->AddAt((Float_t)adccorr,ii);
1897          continue;
1898        }
1899        //    printf(" e quo? \n");
1900    
1901      //    int standard=0;      //    int standard=0;
     if( false ) cout << Gconn << Iconn << Lconn <<endl;  
1902      int S115B_ok=0;      int S115B_ok=0;
1903      int S115B_break=0;      int S115B_break=0;
1904    
 //   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;  
 //     }  
1905      if(atime<1158720000)S115B_ok=1;      if(atime<1158720000)S115B_ok=1;
1906      else S115B_break=1;      else S115B_break=1;
1907    
1908    
1909   //------------------------------------------------------------------------      //------------------------------------------------------------------------
1910        //    printf(" e qui? \n");
1911  //---------------------------------------------------- Z reconstruction      //---------------------------------------------------- Z reconstruction
1912    
1913  double adcHe, adcnorm, adclin, dEdx, Zeta;      double adcHe, adcnorm, adclin, dEdx;//, Zeta; // EM GCC4.7
1914    
1915   adcHe=-2;      adcHe=-2;
1916   adcnorm=-2;      adcnorm=-2;
1917   adclin=-2;      adclin=-2;
1918   dEdx=-2;      dEdx=-2;
1919   Zeta=-2;      //    Zeta=-2;//EM GCC4.7
1920        Double_t correction = 1.;
   
 //  float ZetaH=-2;  
 //  float dEdxH=-2;  
   
 //  double day = (atime-1150000000)/84600;  
1921    
1922      if(Aconn==1 && (ii==0 || ii==20 || ii==22 || ii==24)){      if(Aconn==1 && (ii==0 || ii==20 || ii==22 || ii==24)){
1923         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.675;        correction = 1.675;
1924      }      }
1925      else if(Bconn==1 && (ii==6 || ii==12 || ii==26 || ii==34)){      else if(Bconn==1 && (ii==6 || ii==12 || ii==26 || ii==34)){
1926         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/2.482;        correction = 2.482;
1927      }      }
1928      else if(Cconn==1 && (ii==4 || ii==14 || ii==28 || ii==32)){      else if(Cconn==1 && (ii==4 || ii==14 || ii==28 || ii==32)){
1929        adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.464;        correction = 1.464;
1930      }      }
1931      else if(Dconn==1 && (ii==2 || ii==8 || ii==10 || ii==30)){      else if(Dconn==1 && (ii==2 || ii==8 || ii==10 || ii==30)){
1932         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.995;        correction = 1.995;
1933      }      }
1934      else if(Econn==1 && (ii==42 || ii==43 || ii==44 || ii==47)){      else if(Econn==1 && (ii==42 || ii==43 || ii==44 || ii==47)){
1935         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.273;        correction = 1.273;
1936      }      }
1937      else if(Fconn==1 && (ii==7 || ii==19 || ii==23 || ii==27)){      else if(Fconn==1 && (ii==7 || ii==19 || ii==23 || ii==27)){
1938         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.565;        correction = 1.565;
1939      }      }
1940      else if(Mconn==1 && (ii==15 || ii==16 || ii==17 || ii==18)){      else if(Mconn==1 && (ii==15 || ii==16 || ii==17 || ii==18)){
1941         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.565;        correction = 1.565;
1942      }      }
1943      else if(Nconn==1 && (ii==36 || ii==38 || ii==39 || ii==41)){      else if(Nconn==1 && (ii==36 || ii==38 || ii==39 || ii==41)){
1944         adcHe   = (Get_adc_he(ii, xtr_tof, ytr_tof))/1.018;        correction = 1.018;
1945      }      }
1946      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))){
1947        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!!!  
1948      }      }
1949      else if(S115B_break==1 && ii==9 && Hconn==1){      else if(S115B_break==1 && ii==9 && Hconn==1){
1950         adcHe   = (f_att5B( ytr_tof[0] ))/1.64;        correction = 1.64;
1951        }
1952        else correction = 1.;
1953        
1954        if( ii==9 && S115B_break==1 ){
1955          adcHe   = f_att5B( ytr_tof[0] )/correction;
1956        } else {
1957          adcHe   = Get_adc_he(ii, xtr_tof, ytr_tof)/correction;
1958        };
1959        if(adcHe<=0){
1960          if ( debug ) printf(" %i adcHe<=0 \n",ii);
1961          //      eDEDXpmt->AddAt((Float_t)adccorr,ii); //?
1962          continue;
1963        }
1964        if ( exitat == 2 ){
1965          if(ii==9 && S115B_break==1)  eDEDXpmt->AddAt(36.*(Float_t)adccorr/adcHe,ii);
1966          else  adclin  = 4.*(Float_t)adccorr/adcHe;
1967          continue;
1968      }      }
     else  adcHe   = Get_adc_he(ii, xtr_tof, ytr_tof);  
   
     if(adcHe<=0)   continue;  
1969    
1970      if(ii==9 && S115B_break==1)  adcnorm = f_pos5B(adccorr);      if(ii==9 && S115B_break==1)  adcnorm = f_pos5B(adccorr);
1971      else adcnorm = f_pos( (parPos[ii]), adccorr);      else adcnorm = f_pos( (parPos[ii]), adccorr);
1972        if(adcnorm<=0){
1973      if(adcnorm<=0) continue;        if ( debug ) printf(" %i adcnorm<=0 \n",ii);
1974          //      eDEDXpmt->AddAt((Float_t)adccorr,ii);//?
1975          continue;
1976        }
1977        if ( debug ) printf(" adcnorm %f \n",adcnorm);
1978    
1979      if(ii==9 && S115B_break==1)  adclin  = 36.*adcnorm/adcHe;      if(ii==9 && S115B_break==1)  adclin  = 36.*adcnorm/adcHe;
1980      else  adclin  = 4.*adcnorm/adcHe;      else  adclin  = 4.*adcnorm/adcHe;
1981        if ( debug ) printf(" adclin %f \n",adclin);
1982      if(adclin<=0)  continue;      if(adclin<=0){
1983          if ( debug ) printf(" %i adclin<=0 \n",ii);
1984          //      eDEDXpmt->AddAt((Float_t)adccorr,ii);//?
1985          continue;
1986        }
1987        if ( exitat == 3 ){
1988          if(ii==9 && S115B_break==1)  eDEDXpmt->AddAt((Float_t)adclin,ii);
1989          else  eDEDXpmt->AddAt((Float_t)adclin,ii);
1990          continue;
1991        }
1992        //
1993        if ( betamean > 99. ){
1994          //      eDEDXpmt.AddAt((Float_t)adclin,ii);
1995          eDEDXpmt->AddAt((Float_t)adclin,ii);
1996          //      printf(" AAPMT IS %i dedx is %f vector is %f \n",ii,adclin,eDEDXpmt[ii]);
1997          if ( debug ) printf(" %i betamean > 99 \n",ii);
1998          continue;
1999        };
2000        //
2001      double dEdxHe=-2;      double dEdxHe=-2;
2002      if(ii==9 && S115B_break==1){      if(ii==9 && S115B_break==1){
2003        if( betamean <1. ) dEdxHe = f_BB5B( betamean );        if( betamean <1. ) dEdxHe = f_BB5B( betamean );
# Line 1709  double adcHe, adcnorm, adclin, dEdx, Zet Line 2006  double adcHe, adcnorm, adclin, dEdx, Zet
2006        if( betamean <1. ) dEdxHe = f_BB( (parBBneg[ii]), betamean );        if( betamean <1. ) dEdxHe = f_BB( (parBBneg[ii]), betamean );
2007        else                       dEdxHe = parBBpos[ii];        else                       dEdxHe = parBBpos[ii];
2008      }      }
   
     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];  
     }  
2009            
2010      if(j%2==0 || j==0)eZpad[k]= (Float_t)zpdl;      if ( debug ) printf(" dEdxHe %f \n",dEdxHe);
2011            
2012      if((j%2==0 || j==0)&&eZpad[k]!=-1){      if(dEdxHe<=0){
2013        if(k>=0&&k<8)eZlayer[0]=eZpad[k];        eDEDXpmt->AddAt((Float_t)adclin,ii);
2014        if(k>=8&&k<14)eZlayer[1]=eZpad[k];        if ( debug ) printf(" %i dEdxHe<=0 \n",ii);
2015        if(k>=14&&k<16)eZlayer[2]=eZpad[k];        continue;
2016        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];  
2017    
2018      if(eZlayer[2]!=-1&&eZlayer[3]!=-1&&fabs(eZlayer[2]-eZlayer[3])<1.5)eZplane[1]=0.5*(eZlayer[2]+eZlayer[3]);      if(ii==9 && S115B_break==1)  dEdx = f_desatBB5B( adclin );
2019      else if(eZlayer[2]!=-1&&eZlayer[3]==-1)eZplane[1]=eZlayer[2];      else  dEdx = f_desatBB((parDesatBB[ii]), adclin );
     else if(eZlayer[3]!=-1&&eZlayer[2]==-1)eZplane[1]=eZlayer[3];  
2020    
2021      if(eZlayer[4]!=-1&&eZlayer[5]!=-1&&fabs(eZlayer[4]-eZlayer[5])<1.5)eZplane[2]=0.5*(eZlayer[4]+eZlayer[5]);      if(dEdx<=0){
2022      else if(eZlayer[4]!=-1&&eZlayer[5]==-1)eZplane[2]=eZlayer[4];        eDEDXpmt->AddAt((Float_t)adclin,ii);
2023      else if(eZlayer[5]!=-1&&eZlayer[4]==-1)eZplane[2]=eZlayer[5];        if ( debug ) printf(" %i dEdx<=0 \n",ii);
2024          continue;
2025        };
2026    
2027    }      if ( debug ) printf(" dEdx %f \n",dEdx);
2028        eDEDXpmt->AddAt((Float_t)dEdx,ii);
2029        //    eDEDXpmt.AddAt((Float_t)dEdx,ii);
2030    
2031    for(int jj=0;jj<48;jj++){      //    printf(" PMT IS %i dedx is %f vector is %f \n",ii,dEdx,eDEDXpmt[ii]);
     int k=100;  
     if(jj%2==0 || jj==0)k=jj/2;  
       
     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];  
   
   }  
     
2032    
2033      }  //end loop on 48 PMT
2034    
2035  };  };
2036    
2037    
2038  //------------------------------------------------------------------------  //------------------------------------------------------------------------
 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]);  
         
     }  
   }  
 }  
   
   
 //------------------------------------------------------------------------  
2039  void ToFdEdx::Define_PMTsat()  void ToFdEdx::Define_PMTsat()
2040  {  {
2041    Float_t  sat[48] = {    Float_t  sat[48] = {
# Line 1861  void ToFdEdx::Define_PMTsat() Line 2049  void ToFdEdx::Define_PMTsat()
2049  }  }
2050    
2051  //------------------------------------------------------------------------  //------------------------------------------------------------------------
 // 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);  
 // }  
   
 //------------------------------------------------------------------------  
2052  void ToFdEdx::ReadParBBpos( const char *fname )  void ToFdEdx::ReadParBBpos( const char *fname )
2053  {  {
2054    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2055    parBBpos.Set(48);    parBBpos.Set(48);
2056    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2057    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
# Line 1900  void ToFdEdx::ReadParBBpos( const char * Line 2067  void ToFdEdx::ReadParBBpos( const char *
2067  //------------------------------------------------------------------------  //------------------------------------------------------------------------
2068  void ToFdEdx::ReadParDesatBB( const char *fname )  void ToFdEdx::ReadParDesatBB( const char *fname )
2069  {  {
2070    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2071    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2072    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2073      int   tid=0;      int   tid=0;
# Line 1917  void ToFdEdx::ReadParDesatBB( const char Line 2084  void ToFdEdx::ReadParDesatBB( const char
2084  void ToFdEdx::ReadParBBneg( const char *fname )  void ToFdEdx::ReadParBBneg( const char *fname )
2085    
2086  {  {
2087    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2088    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2089    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2090      int   tid=0;      int   tid=0;
# Line 1932  void ToFdEdx::ReadParBBneg( const char * Line 2099  void ToFdEdx::ReadParBBneg( const char *
2099  //------------------------------------------------------------------------  //------------------------------------------------------------------------
2100  void ToFdEdx::ReadParPos( const char *fname )  void ToFdEdx::ReadParPos( const char *fname )
2101  {  {
2102    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2103    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2104    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2105      int   tid=0;      int   tid=0;
# Line 1947  void ToFdEdx::ReadParPos( const char *fn Line 2114  void ToFdEdx::ReadParPos( const char *fn
2114  //------------------------------------------------------------------------  //------------------------------------------------------------------------
2115  void ToFdEdx::ReadParAtt( const char *fname )  void ToFdEdx::ReadParAtt( const char *fname )
2116  {  {
2117    printf("read %s\n",fname);    //  printf("read %s\n",fname);
2118    FILE *fattin = fopen( fname , "r" );    FILE *fattin = fopen( fname , "r" );
2119    for (int i=0; i<48; i++) {    for (int i=0; i<48; i++) {
2120      int   tid=0;      int   tid=0;
# Line 2020  float ToFdEdx::Get_adc_he( int id, float Line 2187  float ToFdEdx::Get_adc_he( int id, float
2187    //             pl_x - coord x of the tof plane    //             pl_x - coord x of the tof plane
2188    //             pl_y - coord y    //             pl_y - coord y
2189    
2190     adc_he = 0;    adc_he = 0;
2191    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)] );
2192    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)] );
2193    return adc_he;    return adc_he;
# Line 2055  double ToFdEdx::f_desatBB5B( float x ) Line 2222  double ToFdEdx::f_desatBB5B( float x )
2222      0.009*x*x;      0.009*x*x;
2223  }  }
2224    
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
Legend:
Removed from v.1.26  
changed lines
  Added in v.1.44
  ViewVC Help
Powered by ViewVC 1.1.23