all time measurements perfomed as difference with case vertex=0
authoralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 May 2007 13:48:13 +0000 (13:48 +0000)
committeralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 3 May 2007 13:48:13 +0000 (13:48 +0000)
T0/AliT0CalibData.cxx
T0/AliT0CalibData.h
T0/AliT0Digitizer.cxx
T0/AliT0Parameters.cxx
T0/AliT0Parameters.h
T0/AliT0RawData.cxx
T0/AliT0RawReader.cxx
T0/AliT0Reconstructor.cxx
T0/Calib/TimeDelay/Run0_10_v0_s0.root

index 815f417..5e03f2b 100644 (file)
@@ -48,7 +48,14 @@ ClassImp(AliT0CalibData)
 }
 
 //________________________________________________________________
-AliT0CalibData::AliT0CalibData(const char* name):TNamed(),fTimeDelayTVD(0),fWalk(),fSlewingLED(),fSlewingRec()
+AliT0CalibData::AliT0CalibData(const char* name):TNamed(),
+                                     fTimeDelayTVD(0),
+                                     fMeanT0(0),
+                                     fWalk(0),
+                                     fSlewingLED(0),
+                                     fSlewingRec(0),
+                                     fLookup(0),
+                                     fNumberOfTRMs(0)
 {
   TString namst = "Calib_";
   namst += name;
@@ -59,7 +66,15 @@ AliT0CalibData::AliT0CalibData(const char* name):TNamed(),fTimeDelayTVD(0),fWalk
 
 //________________________________________________________________
 AliT0CalibData::AliT0CalibData(const AliT0CalibData& calibda) :
-  TNamed(calibda),fTimeDelayTVD(0),fWalk(),fSlewingLED(),fSlewingRec()
+  TNamed(calibda),             
+  fTimeDelayTVD(0),
+  fMeanT0(0),
+  fWalk(0),
+  fSlewingLED(0),
+  fSlewingRec(0),
+  fLookup(0),
+  fNumberOfTRMs(0)
+
 {
 // copy constructor
   SetName(calibda.GetName());
@@ -87,7 +102,7 @@ AliT0CalibData::~AliT0CalibData()
 void AliT0CalibData::Reset()
 {
     memset(fTimeDelayCFD,1,24*sizeof(Float_t));
-    memset(fTimeDelayLED,1,24*sizeof(Float_t));
+    memset(fTimeDelayDA,1,24*sizeof(Float_t));
 }
 
 
@@ -96,8 +111,8 @@ void  AliT0CalibData::Print(Option_t*) const
 {
 
   printf("\n   ----    PM Arrays       ----\n\n");
-  printf(" Time delay CFD & LED\n");
-  for (Int_t i=0; i<24; i++) printf(" CFD  %f LED %f ",fTimeDelayCFD[i], fTimeDelayLED[i]);
+  printf(" Time delay CFD & DA\n");
+  for (Int_t i=0; i<24; i++) printf(" CFD  %f DA %f ",fTimeDelayCFD[i], fTimeDelayDA[i]);
 } 
 
 //________________________________________________________________
@@ -117,7 +132,7 @@ void  AliT0CalibData::PrintLookup(Option_t*, Int_t iTRM, Int_t iTDC, Int_t iChan
   printf(" AliT0CalibData::PrintLookup ::start GetValue %i %i %i \n",iTRM, iTDC, iChannel);
   lookkey = (AliT0LookUpKey*) fLookup.GetValue((TObject*)lookvalue);
   
-  cout<<"  AliT0CalibData::PrintLookup :: lookkey "<< lookkey<<endl;
+
   if (lookkey)
     {
       cout<<" lookup KEY!!! "<<lookkey->GetKey()<<" VALUE "<<lookvalue->GetTRM()<<" "
@@ -135,9 +150,9 @@ void AliT0CalibData::SetTimeDelayCFD(Float_t* TimeDelay)
   if(TimeDelay) for(int t=0; t<24; t++) fTimeDelayCFD[t] = TimeDelay[t];
 }  
   //________________________________________________________________
-  void AliT0CalibData::SetTimeDelayLED(Float_t* TimeDelay)
+  void AliT0CalibData::SetTimeDelayDA(Float_t* TimeDelay)
 {
-  if(TimeDelay) for(int t=0; t<24; t++) fTimeDelayLED[t] = TimeDelay[t];
+  if(TimeDelay) for(int t=0; t<24; t++) fTimeDelayDA[t] = TimeDelay[t];
 }
 
 
@@ -175,7 +190,6 @@ void AliT0CalibData::SetWalk(Int_t ipmt)
        {
          sum +=x[ind];
          iin++;
-         //      cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" "<<sum<<endl;
        }
       else
        {
@@ -185,7 +199,6 @@ void AliT0CalibData::SetWalk(Int_t ipmt)
            time[isum] =Float_t (x[ind]);
          amplitude[isum] = Float_t (amp);
          amp=y[ind];
-         //      cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
          iin=0;
          isum++;
          sum=0;
index fc9ce80..964dd30 100644 (file)
@@ -31,8 +31,8 @@ class AliT0CalibData: public TNamed {
   virtual void  Print(Option_t* option= "") const; 
   Float_t  GetTimeDelayCFD(Int_t channel) const {return fTimeDelayCFD[channel];}
   Float_t* GetTimeDelayCFD()  const  {return(float*) fTimeDelayCFD;}
-  Float_t  GetTimeDelayLED(Int_t channel) const {return fTimeDelayLED[channel];}
-  Float_t* GetTimeDelayLED()  const  {return(float*) fTimeDelayLED;}
+  Float_t  GetTimeDelayDA(Int_t channel) const {return fTimeDelayDA[channel];}
+  Float_t* GetTimeDelayDA()  const  {return(float*) fTimeDelayDA;}
 
   
   TGraph *GetWalk(Int_t ipmt )  const {return ((TGraph*)fWalk.At(ipmt));}
@@ -51,8 +51,8 @@ class AliT0CalibData: public TNamed {
 
   void     SetTimeDelayCFD(Float_t val, Int_t channel) {fTimeDelayCFD[channel]=val;}
   void     SetTimeDelayCFD(Float_t* TimeDelay);
-  void     SetTimeDelayLED(Float_t val, Int_t channel) {fTimeDelayLED[channel]=val;}
-  void     SetTimeDelayLED(Float_t* TimeDelay);
+  void     SetTimeDelayDA(Float_t val, Int_t channel) {fTimeDelayDA[channel]=val;}
+  void     SetTimeDelayDA(Float_t* TimeDelay);
 
   void SetTimeDelayTVD(Int_t r=150)   { fTimeDelayTVD = r; };
   Float_t GetTimeDelayTVD()   { return fTimeDelayTVD; }
@@ -63,12 +63,15 @@ class AliT0CalibData: public TNamed {
   TMap *GetMapLookup(void) {return &fLookup;}
   Int_t GetNumberOfTRMs() const {return fNumberOfTRMs;}
   void SetNumberOfTRMs(Int_t ntrms=2) {fNumberOfTRMs = ntrms;}
+  void SetMeanT0(Int_t mean=500) { fMeanT0 = mean; };
+  Int_t GetMeanT0 () {return fMeanT0;};
 
  protected:
 
   Float_t  fTimeDelayCFD[24]; // Coeff. for time delay (24 different cables & CFD )
-  Float_t  fTimeDelayLED[24]; // Coeff. for time delay (24 different cables & CFD )
+  Float_t  fTimeDelayDA[24]; // number of channel with mean time+delay if vertex=0 )
   Float_t fTimeDelayTVD; //time delay for TVD (vertex trigger channel)
+  Int_t fMeanT0; //mean of T0distribution with vertex=0;
   TObjArray fWalk;  //time - amp. walk
   TObjArray fSlewingLED;  //time - amp.LED slew
   TObjArray fSlewingRec;  //time - amp. LED slew for reconstruction
index d65e899..52b91ac 100644 (file)
@@ -155,7 +155,6 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
   Float_t delayVertex = param->GetTimeDelayTVD();
   for (Int_t i=0; i<24; i++){
     timeDelayCFD[i] = param->GetTimeDelayCFD(i);
-    timeDelayLED[i] = param->GetTimeDelayLED(i);
     TGraph* gr = param ->GetSlew(i);
     slewingLED.AddAtAndExpand(gr,i);
 
@@ -295,9 +294,9 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
          qt= 50.*al/ph2Mip;  // 50mv/Mip amp in mV 
          //  fill TDC
          trCFD = Int_t (timeGaus[i]/channelWidth + (timeDelayCFD[i]-timeDelayCFD[0])); 
-         trLED= Int_t (timeGaus[i] + timeDelayLED[i]); 
+         //      trLED= Int_t (timeGaus[i] + timeDelayLED[i]); 
          sl = ((TGraph*)slewingLED.At(i))->Eval(qt);
-         trLED = Int_t(( trLED + 1000*sl )/channelWidth);
+         trLED = Int_t(( timeGaus[i] + 1000*sl )/channelWidth);
          qtCh=Int_t (1000.*TMath::Log(qt)) / channelWidth;
          fADC0->AddAt(0,i);
          fADC->AddAt(qtCh,i);
index 78353dd..082267f 100644 (file)
@@ -68,8 +68,10 @@ AliT0Parameters::AliT0Parameters()
    fQTmin(0),fQTmax(0),
    fSlewingLED(),fSlewingRec(),
    fPMTeff(),
-   fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),
-   fCalibentry(), fLookUpentry(),fSlewCorr()
+   fTimeDelayDA(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fMeanT0(0),
+   fCalibentry(), fLookUpentry(),fSlewCorr(),
+   fLookUp(0), fNumberOfTRMs(0)
+
 {
   // Default constructor 
 
@@ -99,8 +101,8 @@ AliT0Parameters::Init()
 {
   // Initialize the parameters manager.  We need to get stuff from the
   // CDB here. 
-  //   if (fIsInit) return;
-  
+   if (fIsInit) return;
 
   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
   //time equalizing
@@ -130,15 +132,15 @@ AliT0Parameters::Init()
 
 //__________________________________________________________________
 Float_t
-AliT0Parameters::GetTimeDelayLED(Int_t ipmt) 
+AliT0Parameters::GetTimeDelayDA(Int_t ipmt) 
 {
   // return time delay for LED channel
   // 
   if (!fCalibentry) {
-    fTimeDelayLED = 0;
-    return  fTimeDelayLED;
+    fTimeDelayDA = 0;
+    return  fTimeDelayDA;
   } 
-  return fgCalibData ->GetTimeDelayLED(ipmt);
+  return fgCalibData ->GetTimeDelayDA(ipmt);
 }
 //__________________________________________________________________
 Float_t
@@ -156,6 +158,19 @@ AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 }
 
 //__________________________________________________________________
+Int_t
+AliT0Parameters::GetMeanT0() 
+{
+  // return mean of T0 distrubution with vertex=0
+   // 
+  if (!fCalibentry) 
+    {
+      return fMeanT0;
+    }
+   
+  return fgCalibData->GetMeanT0();
+}
+//__________________________________________________________________
 
 void 
 AliT0Parameters::SetSlewingLED(Int_t ipmt)
index 6c94bc8..2d5bba7 100644 (file)
@@ -76,7 +76,10 @@ public:
    void SetWalk(Int_t ipmt) ;
    
   Float_t GetTimeDelayCFD(Int_t ipmt);
-  Float_t GetTimeDelayLED(Int_t ipmt);
+  Float_t GetTimeDelayDA(Int_t ipmt);
+
+  void SetMeanT0(Int_t mean=500) { fMeanT0 = mean; };
+  Int_t GetMeanT0 (); //{return fMeanT0;};
 
   //  TMap *LookupTable;
 
@@ -103,10 +106,11 @@ protected:
   TObjArray fPMTeff; //array PMT registration efficiency
   TObjArray fWalk; //array time-amplitude walk
   
-  Float_t fTimeDelayLED;  //  sum time delay for LED channel
+  Float_t fTimeDelayDA;  //  sum time delay for LED channel
   Float_t fTimeDelayCFD;  // sum time delay for CFD channel
   Float_t  fTimeDelayTVD;  //time delay for TVD (vertex trigger channel)
-  
+ Int_t fMeanT0; //mean of T0distribution with vertex=0;
+   
   TMap fLookUp;           //lookup table
   Int_t fNumberOfTRMs;    // number of TRMs in setup
 
index fb1604b..b33021d 100644 (file)
@@ -540,7 +540,7 @@ Int_t AliT0RawData::RawDataT0(AliT0digit *fDigits)
 
   fIndex=-1;
  
-  AliRawDataHeaderSim header;
+
    WriteDataHeader(kTRUE, kFALSE);
   GetDigits(fDigits);
   //write packing digits
index 98c8050..266018b 100644 (file)
@@ -84,6 +84,8 @@ Bool_t  AliT0RawReader::Next()
   Int_t  TRM_CHAIN_0_TRAILER =  0x10000000;
   Int_t  TRM_CHAIN_1_TRAILER =  0x30000000;
   Int_t  TRM_GLOBAL_TRAILER =  0x5000000f;
+ Int_t  FILLER =  0x70000000;
 
   AliT0Parameters* param = AliT0Parameters::Instance();   
 
@@ -189,8 +191,10 @@ Bool_t  AliT0RawReader::Next()
          AliError(Form(" !!!! wrong TRM GLOBAL trailer  %x!!!!", word));
          break;
        }
-     } //TRM loop
+     } //TRM loop end
+
       word = GetNextWord(); //
+      if (word == FILLER )  {cout<< "FIILER "<<endl; word = GetNextWord(); }
       uu = word& fDRM_GLOBAL_TRAILER;
       if(uu != fDRM_GLOBAL_TRAILER )
        {
index 8fbdea8..1f33172 100644 (file)
@@ -81,17 +81,16 @@ AliT0Reconstructor &AliT0Reconstructor::operator=(const AliT0Reconstructor &r)
 //_____________________________________________________________________________
 
 void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
-
+  
 {
-// T0 digits reconstruction
-// T0RecPoint writing 
-
+  // T0 digits reconstruction
+  // T0RecPoint writing 
   
-  Float_t  timeDelayLED[24];
-  Float_t zdetA,zdetC;
+  
+  Float_t time0vertex[24];
   TObjArray slewingLEDrec;
   TObjArray walk;
-    
+  
   TArrayI * timeCFD = new TArrayI(24); 
   TArrayI * timeLED = new TArrayI(24); 
   TArrayI * chargeQT0 = new TArrayI(24); 
@@ -101,20 +100,20 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   param->Init();
   AliT0Calibrator *calib=new AliT0Calibrator(); 
 
-  Int_t mV2Mip = param->GetmV2Mip();     
+  //  Int_t mV2Mip = param->GetmV2Mip();     
   //mV2Mip = param->GetmV2Mip();     
   Int_t channelWidth = param->GetChannelWidth() ;  
+  Int_t meanT0 = param->GetMeanT0();
   
   for (Int_t i=0; i<24; i++){
     TGraph* gr = param ->GetSlewRec(i);
     slewingLEDrec.AddAtAndExpand(gr,i) ;  
+    time0vertex[i]= param->GetTimeDelayDA(i);
   }
-  zdetC = param->GetZPosition("C");
-  zdetA  = param->GetZPosition("A");
 
-    
+  
   AliDebug(1,Form("Start DIGITS reconstruction "));
-
+  
   TBranch *brDigits=digitsTree->GetBranch("T0");
   AliT0digit *fDigits = new AliT0digit() ;
   if (brDigits) {
@@ -140,21 +139,22 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   
 
 
-   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) ) ) ;
+      //     time[ipmt] = channelWidth * (calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ) ;
+      time[ipmt] = calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ;
       
       //LED
-      Double_t sl = (timeLED->At(ipmt) - timeCFD->At(ipmt)- (1000.*timeDelayLED[ipmt]/channelWidth))*channelWidth;
+      Double_t sl = (timeLED->At(ipmt) - timeCFD->At(ipmt))*channelWidth;
       Double_t qt=((TGraph*)slewingLEDrec.At(ipmt))->Eval(sl/1000.);
-      frecpoints->SetTime(ipmt,time[ipmt]);
+      //      frecpoints->SetTime(ipmt,time[ipmt]);
       frecpoints->SetAmp(ipmt,adc[ipmt]);
       frecpoints->SetAmpLED(ipmt,qt);
     }
@@ -163,7 +163,7 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
       adc[ipmt] = 0;
     }
   }
-
+  
   for (Int_t ipmt=0; ipmt<12; ipmt++){
     if(time[ipmt] > 1 ) {
       if(time[ipmt]<besttimeC){
@@ -185,14 +185,21 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   Float_t c = 0.0299792; // cm/ps
   Float_t vertex = 0;
   if(besttimeA !=999999 && besttimeC != 999999 ){
-    timeDiff = besttimeC - besttimeA;
-    meanTime = (besttimeA + besttimeC)/2.;
+    timeDiff =(besttimeC - besttimeA)*channelWidth;
+    meanTime = (meanT0 - (besttimeA + besttimeC)/2) * channelWidth;
     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));
     
   }
+  //time in each channel as time[ipmt]-MeanTimeinThisChannel(with vertex=0)
+  for (Int_t ipmt=0; ipmt<24; ipmt++) {
+    if(time[ipmt]>1) {
+      time[ipmt] = (time[ipmt] - time0vertex[ipmt])*channelWidth;
+      frecpoints->SetTime(ipmt,time[ipmt]);
+    }
+  }
   clustersTree->Fill();
 
   delete timeCFD;
@@ -206,16 +213,15 @@ 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;
+  // T0 raw ->
+  // T0RecPoint writing 
+  
+  //Q->T-> coefficients !!!! should be measured!!!
+  Float_t time0vertex[24];
   Int_t allData[110][5];
-   TObjArray slewingLEDrec;
+  TObjArray slewingLEDrec;
   TObjArray walk;
-    
+  
   TArrayI * timeCFD = new TArrayI(24); 
   TArrayI * timeLED = new TArrayI(24); 
   TArrayI * chargeQT0 = new TArrayI(24); 
@@ -239,14 +245,14 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
   Int_t mV2Mip = param->GetmV2Mip();     
   //mV2Mip = param->GetmV2Mip();     
   Int_t channelWidth = param->GetChannelWidth() ;  
+  Int_t meanT0 = param->GetMeanT0();
     
   for (Int_t i=0; i<24; i++){
     TGraph* gr = param ->GetSlewRec(i);
     slewingLEDrec.AddAtAndExpand(gr,i) ;  
+    time0vertex[i]= param->GetTimeDelayDA(i);
   }
   
-  zdetC = param->GetZPosition("T0/C/PMT1");
-  zdetA  = param->GetZPosition("T0/A/PMT15");
 
   for (Int_t in=0; in<24; in++)
      {
@@ -275,8 +281,9 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
       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;
+      //      time[ipmt] = channelWidth * (calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ) ;
+      time[ipmt] = calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ;
+      Double_t sl = (timeLED->At(ipmt) - timeCFD->At(ipmt))*channelWidth;
       Double_t qt=((TGraph*)slewingLEDrec.At(ipmt))->Eval(sl/1000.);
       frecpoints->SetTime(ipmt,time[ipmt]);
       frecpoints->SetAmp(ipmt,adc[ipmt]);
@@ -309,16 +316,24 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
   Float_t c = 0.0299792; // cm/ps
   Float_t vertex = 0;
   if(besttimeA !=999999 && besttimeC != 999999 ){
-    timeDiff = besttimeC - besttimeA;
-    meanTime = (besttimeA + besttimeC)/2.;
+    timeDiff = (besttimeC - besttimeA)*channelWidth;
+    //    meanTime = (besttimeA + besttimeC)/2.;
+    meanTime = (meanT0 - (besttimeA + besttimeC)/2) * channelWidth;
     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));
     
   }
+  //time in each channel as time[ipmt]-MeanTimeinThisChannel(with vertex=0)
+  for (Int_t ipmt=0; ipmt<24; ipmt++) {
+    if(time[ipmt]>1) {
+      time[ipmt] = (time[ipmt] - time0vertex[ipmt])*channelWidth;
+      frecpoints->SetTime(ipmt,time[ipmt]);
+    }
+  }
   recTree->Fill();
-
 
   delete timeCFD;
   delete timeLED;
@@ -367,12 +382,11 @@ void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESD *pESD) const
     
     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;
+    timeStart = frecpoints -> GetMeanTime() ;
     for ( i=0; i<24; i++) {
-       time[i] = Float_t (frecpoints -> GetTime(i)) / 1000.; // ps to ns
+      time[i] = Float_t (frecpoints -> GetTime(i)); // ps to ns
       amp[i] = frecpoints -> GetAmp(i);
     }
     pESD->SetT0zVertex(Zposition); //vertex Z position 
index a57b3fa..7fe8e46 100644 (file)
Binary files a/T0/Calib/TimeDelay/Run0_10_v0_s0.root and b/T0/Calib/TimeDelay/Run0_10_v0_s0.root differ