bug fix : slew correction in reconstruction from Digits for amplitude measured as...
[u/mrichter/AliRoot.git] / T0 / AliT0Reconstructor.cxx
index a397e56..15cc7e6 100644 (file)
  **************************************************************************/
 
 /* $Id$ */
-
-#include <Riostream.h>
-
-#include <TDirectory.h>
-
-#include "AliRunLoader.h"
-#include <AliESD.h>
+/*********************************************************************
+ *  T0 reconstruction and filling ESD
+ *  - reconstruct mean time (interation time) 
+ *  - vertex position
+ *  -  multiplicity
+ ********************************************************************/
+
+#include <AliESDEvent.h>
 #include "AliLog.h"
-#include "AliT0Loader.h"
-#include <TClonesArray.h>
 #include "AliT0RecPoint.h"
 #include "AliRawReader.h"
 #include "AliT0RawReader.h"
 #include "AliT0Reconstructor.h"
 #include "AliT0Parameters.h"
 #include "AliT0Calibrator.h"
-#include "AliCDBLocal.h"
-#include "AliCDBStorage.h"
-#include "AliCDBManager.h"
-#include "AliCDBEntry.h"
 
 #include <TArrayI.h>
 #include <TGraph.h>
+#include <TMath.h>
+#include <Riostream.h>
 
 ClassImp(AliT0Reconstructor)
 
   AliT0Reconstructor:: AliT0Reconstructor(): AliReconstructor(),
-                       fDigits(NULL),
-                       fTree(0x0),
-                       fZposition(0)
-
+                                            fdZonA(0),
+                                            fdZonC(0),
+                                            fZposition(0),
+                                            fParam(NULL),
+                                            fAmpLEDrec(),
+                                            fQTC(0),
+                                            fAmpLED(0),
+                                            fCalib()
 {
- AliDebug(1,"Start reconstructor ");
-}
-//____________________________________________________________________
+  //constructor
 
-AliT0Reconstructor::AliT0Reconstructor(const AliT0Reconstructor &r):
-  fDigits(NULL),
-  fTree(0x0),
-  fZposition(0)
-  
-{
-  //
-  // AliT0Reconstructor copy constructor
-  //
-
-  ((AliT0Reconstructor &) r).Copy(*this);
-
-}
+  fParam = AliT0Parameters::Instance();
+  fParam->Init();
+  for (Int_t i=0; i<24; i++){
+        TGraph* gr = fParam ->GetAmpLEDRec(i);
+       if (gr) fAmpLEDrec.AddAtAndExpand(gr,i) ; 
+         TGraph* gr1 = fParam ->GetAmpLED(i);
+         if (gr1) fAmpLED.AddAtAndExpand(gr1,i) ; 
+         TGraph* gr2 = fParam ->GetQTC(i);
+         if (gr2) fQTC.AddAtAndExpand(gr2,i) ;         
+  }
 
-//_____________________________________________________________________________
-AliT0Reconstructor &AliT0Reconstructor::operator=(const AliT0Reconstructor &r)
-{
-  //
-  // Assignment operator
-  //
+  
+  fdZonC = TMath::Abs(fParam->GetZPositionShift("T0/C/PMT1"));
+  fdZonA = TMath::Abs(fParam->GetZPositionShift("T0/A/PMT15"));
 
-  if (this != &r) ((AliT0Reconstructor &) r).Copy(*this);
-  return *this;
+  fCalib = new AliT0Calibrator();
 
 }
 
 //_____________________________________________________________________________
-
 void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
-
+  
 {
-// T0 digits reconstruction
-// T0RecPoint writing 
-
+  // T0 digits reconstruction
+  Int_t refAmp = GetRecoParam()->GetRefAmp();
   
-  Float_t  timeDelayLED[24];
-  Float_t zdetA,zdetC;
-  TObjArray slewingLEDrec;
-  TObjArray walk;
-    
   TArrayI * timeCFD = new TArrayI(24); 
   TArrayI * timeLED = new TArrayI(24); 
   TArrayI * chargeQT0 = new TArrayI(24); 
   TArrayI * chargeQT1 = new TArrayI(24); 
-  
-  AliT0Parameters* param = AliT0Parameters::Instance();
-  param->Init();
-  AliT0Calibrator *calib=new AliT0Calibrator(); 
 
-  Int_t mV2Mip = param->GetmV2Mip();     
-  //mV2Mip = param->GetmV2Mip();     
-  Int_t channelWidth = param->GetChannelWidth() ;  
+  Float_t channelWidth = fParam->GetChannelWidth() ;  
+  Float_t meanVertex = fParam->GetMeanVertex();
+  Float_t c = 0.0299792; // cm/ps
+  Float_t vertex = 9999999;
+  Int_t timeDiff=999999, meanTime=999999, timeclock=999999;
+
   
-  for (Int_t i=0; i<24; i++){
-    TGraph* gr = param ->GetSlewRec(i);
-    slewingLEDrec.AddAtAndExpand(gr,i) ;  
-  }
-  zdetC = param->GetZposition(0);
-  zdetA  = param->GetZposition(1);
-    
   AliDebug(1,Form("Start DIGITS reconstruction "));
+  
 
   TBranch *brDigits=digitsTree->GetBranch("T0");
   AliT0digit *fDigits = new AliT0digit() ;
   if (brDigits) {
     brDigits->SetAddress(&fDigits);
   }else{
-    cerr<<"EXEC Branch T0 digits not found"<<endl;
-    return;
+    AliError(Form("EXEC Branch T0 digits not found"));
+     return;
   }
   
   digitsTree->GetEvent(0);
@@ -129,39 +109,48 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   fDigits->GetTimeLED(*timeLED);
   fDigits->GetQT0(*chargeQT0);
   fDigits->GetQT1(*chargeQT1);
+  Int_t onlineMean =  fDigits->MeanTime();
+  Int_t ref =  fDigits->RefPoint();
+
   
   Float_t besttimeA=999999;
   Float_t besttimeC=999999;
   Int_t pmtBestA=99999;
   Int_t pmtBestC=99999;
-  Float_t timeDiff=999999, meanTime=0;
   
-
-
-   AliT0RecPoint* frecpoints= new AliT0RecPoint ();
-   clustersTree->Branch( "T0", "AliT0RecPoint" ,&frecpoints, 405,1);
-
+  AliT0RecPoint* frecpoints= new AliT0RecPoint ();
+  clustersTree->Branch( "T0", "AliT0RecPoint" ,&frecpoints, 405,1);
+  
   Float_t time[24], adc[24];
   for (Int_t ipmt=0; ipmt<24; ipmt++) {
     if(timeCFD->At(ipmt)>0 ){
-      Int_t qt0= chargeQT0->At(ipmt);
-      Int_t qt1= chargeQT1->At(ipmt);
-      if((qt1-qt0)>0)  adc[ipmt] = TMath::Exp( Double_t (channelWidth*(qt1-qt0)/1000));
-      time[ipmt] = channelWidth * (calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ) ;
+     if(( chargeQT1->At(ipmt) - chargeQT0->At(ipmt))>0)  
+       adc[ipmt] = chargeQT1->At(ipmt) - chargeQT0->At(ipmt);
+      else
+       adc[ipmt] = 0;
+      
+     // time[ipmt] = fCalib-> WalkCorrection(refAmp, ipmt, adc[ipmt],  timeCFD->At(ipmt)) ;
+            
+      Double_t sl = Double_t(timeLED->At(ipmt) - timeCFD->At(ipmt));
+      time[ipmt] = fCalib-> WalkCorrection( refAmp,ipmt, Int_t(sl),  timeCFD->At(ipmt) ) ;
+      AliDebug(10,Form(" ipmt %i QTC %i , time in chann %i (led-cfd) %i ",
+                      ipmt, Int_t(adc[ipmt]) ,Int_t(time[ipmt]),Int_t( sl)));
+
+      Double_t ampMip =((TGraph*)fAmpLED.At(ipmt))->Eval(sl);
+      Double_t qtMip = ((TGraph*)fQTC.At(ipmt))->Eval(adc[ipmt]);
+      AliDebug(10,Form("  Amlitude in MIPS LED %f ,  QTC %f in channels %i\n ",ampMip,qtMip, adc[ipmt]));
+      
+      frecpoints->SetTime(ipmt, Float_t(time[ipmt]) );
+      frecpoints->SetAmp(ipmt, Float_t( ampMip)); //for cosmic &pp beam 
+      frecpoints->SetAmpLED(ipmt, Float_t(qtMip));
       
-      //LED
-      Double_t sl = (timeLED->At(ipmt) - timeCFD->At(ipmt)- (1000.*timeDelayLED[ipmt]/channelWidth))*channelWidth;
-      Double_t qt=((TGraph*)slewingLEDrec.At(ipmt))->Eval(sl/1000.);
-      frecpoints->SetTime(ipmt,time[ipmt]);
-      frecpoints->SetAmp(ipmt,adc[ipmt]);
-      frecpoints->SetAmpLED(ipmt,qt);
     }
     else {
       time[ipmt] = 0;
       adc[ipmt] = 0;
     }
   }
-
+  
   for (Int_t ipmt=0; ipmt<12; ipmt++){
     if(time[ipmt] > 1 ) {
       if(time[ipmt]<besttimeC){
@@ -179,19 +168,29 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   }
   if(besttimeA !=999999)  frecpoints->SetTimeBestA(Int_t(besttimeA));
   if( besttimeC != 999999 ) frecpoints->SetTimeBestC(Int_t(besttimeC));
-  AliDebug(1,Form(" besttimeA %f ps,  besttimeC %f ps",besttimeA, besttimeC));
-  Float_t c = 0.0299792; // cm/ps
-  Float_t vertex = 0;
-  if(besttimeA !=999999 && besttimeC != 999999 ){
-    timeDiff = besttimeC - besttimeA;
-    meanTime = (besttimeA + besttimeC)/2.;
-    vertex = c*(timeDiff)/2.; //-(lenr-lenl))/2;
-    AliDebug(1,Form("  timeDiff %f ps,  meanTime %f ps, vertex %f cm",timeDiff, meanTime,vertex ));
+  AliDebug(10,Form(" besttimeA %f ch,  besttimeC %f ch",besttimeA, besttimeC));
+    if(besttimeA !=999999 && besttimeC != 999999 ){
+    //    timeDiff = (besttimeC - besttimeA)*channelWidth;
+    timeDiff = (besttimeA - besttimeC)*channelWidth;
+    meanTime = Float_t((besttimeA + besttimeC)/2);// * channelWidth); 
+    timeclock = Float_t(meanTime - ref);
+    vertex = meanVertex - c*(timeDiff)/2.;// + (fdZonA - fdZonC)/2; 
+   }
     frecpoints->SetVertex(vertex);
-    frecpoints->SetMeanTime(Int_t(meanTime));
+    frecpoints->SetMeanTime(meanTime);
+    frecpoints->SetT0clock(timeclock);
+    //online mean
+    frecpoints->SetOnlineMean(Int_t(onlineMean));
+    AliDebug(10,Form("  timeDiff %i #channel,  meanTime %i #channel, vertex %f cm online mean %i timeclock %i ps",timeDiff, meanTime,vertex, Int_t(onlineMean), timeclock));
     
-  }
+    //  }
+  
   clustersTree->Fill();
+
+  delete timeCFD;
+  delete timeLED;
+  delete chargeQT0; 
+  delete chargeQT1; 
 }
 
 
@@ -199,137 +198,172 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
 
 void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) const
 {
-// T0 raw ->
-// T0RecPoint writing 
-
-    //Q->T-> coefficients !!!! should be asked!!!
-  Float_t  timeDelayLED[24];
-  Float_t zdetA,zdetC;
-  TObjArray slewingLEDrec;
-  TObjArray walk;
-    
-  TArrayI * timeCFD = new TArrayI(24); 
-  TArrayI * timeLED = new TArrayI(24); 
-  TArrayI * chargeQT0 = new TArrayI(24); 
-  TArrayI * chargeQT1 = new TArrayI(24); 
-
-   AliT0RawReader myrawreader(rawReader);
-   if (!myrawreader.Next())
-     AliDebug(1,Form(" no raw data found!! %i", myrawreader.Next()));
-   Int_t allData[110][5];
-   for (Int_t i=0; i<110; i++) {
-     allData[i][0]=myrawreader.GetData(i,0);
-   }
+  // T0 raw ->
+  //
+  // reference amplitude and time ref. point from reco param
 
-  AliT0Parameters* param = AliT0Parameters::Instance();
-  param->Init();
-  AliT0Calibrator *calib=new AliT0Calibrator(); 
+  Int_t refAmp = GetRecoParam()->GetRefAmp();
+  Int_t refPoint = GetRecoParam()->GetRefPoint();
 
-  Int_t mV2Mip = param->GetmV2Mip();     
-  //mV2Mip = param->GetmV2Mip();     
-  Int_t channelWidth = param->GetChannelWidth() ;  
-    
-  for (Int_t i=0; i<24; i++){
-    TGraph* gr = param ->GetSlewRec(i);
-    slewingLEDrec.AddAtAndExpand(gr,i) ;  
-  }
+  Int_t allData[110][5];
   
-  zdetC = param->GetZposition(0);
-  zdetA  = param->GetZposition(1);
-    
-   for (Int_t in=0; in<24; in++)
-     {
-       timeLED->AddAt(allData[in+1][0],in);
-       timeCFD->AddAt(allData[in+25][0],in);
-       chargeQT1->AddAt(allData[in+55][0],in);
-       chargeQT0->AddAt(allData[in+79][0],in);
-       AliDebug(10, Form(" readed Raw %i %i %i %i %i", in, timeLED->At(in),timeCFD->At(in),chargeQT0->At(in),chargeQT1->At(in)));
-     }
-
-  Float_t besttimeA=999999;
-  Float_t besttimeC=999999;
+  Int_t timeCFD[24], timeLED[24], chargeQT0[24], chargeQT1[24];
+  Int_t timeDiff=999999, meanTime=999999, timeclock=999999;
+  Float_t c = 0.0299792458; // cm/ps
+  Float_t vertex = 9999999;
+  Int_t onlineMean=0;
+  for (Int_t i0=0; i0<105; i0++)
+    {
+      for (Int_t j0=0; j0<5; j0++) allData[i0][j0]=0;  
+    }
+   
+  Float_t besttimeA=9999999;
+  Float_t besttimeC=9999999;
   Int_t pmtBestA=99999;
   Int_t pmtBestC=99999;
-  Float_t timeDiff=999999, meanTime=0;
-
-  
+  Float_t meanVertex = fParam->GetMeanVertex();
+   
   AliT0RecPoint* frecpoints= new AliT0RecPoint ();
-  recTree->Branch( "T0", "AliT0RecPoint" ,&frecpoints, 405,1);
   
-
-  Float_t time[24], adc[24];
-  for (Int_t ipmt=0; ipmt<24; ipmt++) {
-    if(timeCFD->At(ipmt)>0 ){
-      Int_t qt0= chargeQT0->At(ipmt);
-      Int_t qt1= chargeQT1->At(ipmt);
-      if((qt1-qt0)>0)  adc[ipmt] = TMath::Exp( Double_t (channelWidth*(qt1-qt0)/1000));
-      time[ipmt] = channelWidth * (calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ) ;
-      Double_t sl = (timeLED->At(ipmt) - timeCFD->At(ipmt)- (1000.*timeDelayLED[ipmt]/channelWidth))*channelWidth;
-      Double_t qt=((TGraph*)slewingLEDrec.At(ipmt))->Eval(sl/1000.);
-      frecpoints->SetTime(ipmt,time[ipmt]);
-      frecpoints->SetAmp(ipmt,adc[ipmt]);
-      frecpoints->SetAmpLED(ipmt,qt);
-    }
-    else {
-      time[ipmt] = 0;
-      adc[ipmt] = 0;
-    }
-  }
-
-  for (Int_t ipmt=0; ipmt<12; ipmt++){
-    if(time[ipmt] > 1 ) {
-      if(time[ipmt]<besttimeC){
-       besttimeC=time[ipmt]; //timeC
-       pmtBestC=ipmt;
+  recTree->Branch( "T0", "AliT0RecPoint" ,&frecpoints, 405,1);
+   
+  AliDebug(10," before read data ");
+  AliT0RawReader myrawreader(rawReader);
+
+  UInt_t type =rawReader->GetType();
+
+  if (!myrawreader.Next())
+    AliDebug(1,Form(" no raw data found!!"));
+  else
+    {  
+      if(type == 7) {  //only physics 
+      for (Int_t i=0; i<105; i++) {
+       for (Int_t iHit=0; iHit<5; iHit++) 
+         {
+           allData[i][iHit] = myrawreader.GetData(i,iHit);
+         }
       }
-    }
-  }
-  for ( Int_t ipmt=12; ipmt<24; ipmt++){
-    if(time[ipmt] > 1) {
-      if(time[ipmt]<besttimeA) {
-       besttimeA=time[ipmt]; //timeA
-        pmtBestA=ipmt;}
-    }
-  }
-  if(besttimeA !=999999)  frecpoints->SetTimeBestA(Int_t(besttimeA));
-  if( besttimeC != 999999 ) frecpoints->SetTimeBestC(Int_t(besttimeC));
-  AliDebug(1,Form(" besttimeA %f ps,  besttimeC %f ps",besttimeA, besttimeC));
-  Float_t c = 0.0299792; // cm/ps
-  Float_t vertex = 0;
-  if(besttimeA !=999999 && besttimeC != 999999 ){
-    timeDiff = besttimeC - besttimeA;
-    meanTime = (besttimeA + besttimeC)/2.;
-    vertex = c*(timeDiff)/2.; //-(lenr-lenl))/2;
-    AliDebug(1,Form("  timeDiff %f ps,  meanTime %f ps, vertex %f cm",timeDiff, meanTime,vertex ));
-    frecpoints->SetVertex(vertex);
-    frecpoints->SetMeanTime(Int_t(meanTime));
-    
-  }
-  recTree->Fill();
+      Int_t ref=0;
+      if (refPoint>0) 
+      ref = allData[refPoint][0]-5000.;
+
+      Float_t channelWidth = fParam->GetChannelWidth() ;  
+      
+      //       Int_t meanT0 = fParam->GetMeanT0();
+       
+         
+         for (Int_t in=0; in<12; in++)  
+           {
+             timeCFD[in] = allData[in+1][0] ;
+             timeCFD[in+12] = allData[in+56+1][0] ;
+             timeLED[in] = allData[in+12+1][0] ;
+             timeLED[in+12] = allData[in+68+1][0] ;
+             AliDebug(10, Form(" readed i %i cfdC %i cfdA %i ledC %i ledA%i ",
+                               in, timeCFD[in],timeCFD[in+12],timeLED[in], 
+                               timeLED[in+12]));   
+           }
+         
+         for (Int_t in=0; in<12;  in++)
+           {
+             chargeQT0[in]=allData[2*in+25][0];
+             chargeQT1[in]=allData[2*in+26][0];
+           }
+         
+          for (Int_t in=12; in<24;  in++)
+            {
+              chargeQT0[in]=allData[2*in+57][0];
+              chargeQT1[in]=allData[2*in+58][0];
+            }
+          
+          //    } //cosmic with physics event
+       for (Int_t in=0; in<24; in++)  
+        AliDebug(10, Form(" readed Raw %i %i %i %i %i",
+                          in, timeLED[in],timeCFD[in],chargeQT0[in],chargeQT1[in]));
+        onlineMean = allData[49][0];       
+       
+       Float_t time[24], adc[24];
+       for (Int_t ipmt=0; ipmt<24; ipmt++) {
+        if(timeCFD[ipmt]>0 && timeLED[ipmt]>0){
+          //for simulated data
+            //for physics  data
+          if(( chargeQT1[ipmt] - chargeQT0[ipmt])>0)  
+            adc[ipmt] = chargeQT0[ipmt] - chargeQT1[ipmt];
+          else
+            adc[ipmt] = 0;
+          
+
+          //      time[ipmt] = fCalib-> WalkCorrection(refAmp, ipmt, adc[ipmt], timeCFD[ipmt] ) ;
+          
+          Double_t sl = timeLED[ipmt] - timeCFD[ipmt];
+          time[ipmt] = fCalib-> WalkCorrection( refAmp,ipmt, Int_t(sl), timeCFD[ipmt] ) ;
+          AliDebug(10,Form(" ipmt %i QTC %i , time in chann %i (led-cfd) %i ",
+                           ipmt, Int_t(adc[ipmt]) ,Int_t(time[ipmt]),Int_t( sl)));
+          Double_t ampMip =( (TGraph*)fAmpLED.At(ipmt))->Eval(sl);
+          Double_t qtMip = ((TGraph*)fQTC.At(ipmt))->Eval(adc[ipmt]);
+          AliDebug(10,Form("  Amlitude in MIPS LED %f ; QTC %f;  in channels %i\n ",ampMip,qtMip, adc[ipmt]));
+            
+          frecpoints->SetTime(ipmt, Float_t(time[ipmt]) );
+          frecpoints->SetAmpLED(ipmt, Float_t( qtMip)); //for cosmic &pp beam 
+          frecpoints->SetAmp(ipmt, Float_t(ampMip));
+            
+        }
+        else {
+          time[ipmt] = 0;
+          adc[ipmt] = 0;
+        }
+       }
+       
+       for (Int_t ipmt=0; ipmt<12; ipmt++){
+        if(time[ipmt] > 1 ) {
+          if(time[ipmt]<besttimeC){
+            besttimeC=time[ipmt]; //timeC
+            pmtBestC=ipmt;
+          }
+        }
+       }
+       for ( Int_t ipmt=12; ipmt<24; ipmt++){
+        if(time[ipmt] > 1) {
+          if(time[ipmt]<besttimeA) {
+            besttimeA=time[ipmt]; //timeA
+            pmtBestA=ipmt;}
+        }
+       }
+       if(besttimeA !=9999999)  frecpoints->SetTimeBestA(Int_t(besttimeA));
+       if( besttimeC != 9999999 ) frecpoints->SetTimeBestC(Int_t(besttimeC));
+       AliDebug(5,Form(" pmtA %i besttimeA %f ps, pmtC %i besttimeC %f #channel",
+                      pmtBestA,besttimeA, pmtBestC,  besttimeC));
+        if(besttimeA <9999999 && besttimeC < 9999999 ){
+        timeDiff = ( besttimeA - besttimeC) *channelWidth;
+        meanTime =  Float_t(((besttimeA-ref) + (besttimeC-ref))/2.);  
+        timeclock = Float_t(meanTime);
+        vertex =  meanVertex - c*(timeDiff)/2.; //+ (fdZonA - fdZonC)/2; 
+       }
+      }  //if phys event       
+      frecpoints->SetT0clock(timeclock);
+      frecpoints->SetVertex(vertex);
+      frecpoints->SetMeanTime(Int_t(meanTime));
+      frecpoints->SetOnlineMean(Int_t(onlineMean));
+      AliDebug(5,Form("  timeDiff %f #channel,  meanTime %f #channel, vertex %f cm meanVertex %f online mean %i ",timeDiff, meanTime,vertex,meanVertex, onlineMean));
+        
+       
+    } // if (else )raw data
+        recTree->Fill();
+        if(frecpoints) delete frecpoints;
 }
+       
+       
 //____________________________________________________________
 
-void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESD *pESD) const
+void AliT0Reconstructor::FillESD(TTree */*digitsTree*/, TTree *clustersTree, AliESDEvent *pESD) const
 {
 
   /***************************************************
   Resonstruct digits to vertex position
   ****************************************************/
   
-  
-  if (!runLoader) {
-    AliError("Reconstruct >> No run loader");
-    return;
-  }
-  
   AliDebug(1,Form("Start FillESD T0"));
 
-  AliT0Loader* pStartLoader = (AliT0Loader*) runLoader->GetLoader("T0Loader");
-  pStartLoader->LoadRecPoints("READ");
-
-  TTree *treeR = pStartLoader->TreeR();
+  TTree *treeR = clustersTree;
   
    AliT0RecPoint* frecpoints= new AliT0RecPoint ();
     if (!frecpoints) {
@@ -342,29 +376,27 @@ void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESD *pESD) const
   if (brRec) {
     brRec->SetAddress(&frecpoints);
   }else{
-    cerr<<"EXEC Branch T0 rec not found"<<endl;
-    // exit(111);
+    AliError(Form("EXEC Branch T0 rec not found"));
     return;
   } 
     
     brRec->GetEntry(0);
-    Float_t timeStart, Zposition, amp[24], time[24];
-    Int_t mean0 = 12450;
-    Int_t i;
-    Zposition = frecpoints -> GetVertex();
-    timeStart = frecpoints -> GetMeanTime() - mean0;
-    for ( i=0; i<24; i++) {
-       time[i] = Float_t (frecpoints -> GetTime(i)) / 1000.; // ps to ns
+    Float_t amp[24], time[24];
+    Float_t  zPosition = frecpoints -> GetVertex();
+    Float_t timeStart = frecpoints -> GetMeanTime() ;
+    Float_t timeClock = frecpoints -> GetT0clock() ;
+     for ( Int_t i=0; i<24; i++) {
+      time[i] = Float_t (frecpoints -> GetTime(i)); // ps to ns
       amp[i] = frecpoints -> GetAmp(i);
     }
-    pESD->SetT0zVertex(Zposition); //vertex Z position 
+    pESD->SetT0zVertex(zPosition); //vertex Z position 
     pESD->SetT0(timeStart);        // interaction time 
+    pESD->SetT0clock(timeClock);   // interaction time with ref.point(spectrum) 
     pESD->SetT0time(time);         // best TOF on each PMT 
     pESD->SetT0amplitude(amp);     // number of particles(MIPs) on each PMT
-    cout<<" ESD >> "<<Zposition<<" "<<timeStart<<endl;
+    AliDebug(1,Form(" Z position %f cm,  T0  %f ps",zPosition , timeStart));
 
-    pStartLoader->UnloadRecPoints();
-   
 } // vertex in 3 sigma