Changes for report #62764: port to STEER new AliESDTZERO
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 26 Feb 2010 15:19:12 +0000 (15:19 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 26 Feb 2010 15:19:12 +0000 (15:19 +0000)
STEER/AliESD.cxx
STEER/AliESD.h
STEER/AliESDEvent.h
STEER/AliESDTZERO.cxx
STEER/AliESDTZERO.h
T0/AliT0RecPoint.cxx
T0/AliT0RecPoint.h
T0/AliT0Reconstructor.cxx

index 5b82cb2..f95452e 100644 (file)
@@ -50,8 +50,9 @@ AliESD::AliESD():
   fSPDVertex(),
   fPrimaryVertex(),
   fSPDMult(),
-  fT0timeStart(0),
   fT0clock(0),
+  fT0timeStart(0),
+  fT0trig(0),
   fTracks("AliESDtrack",15000),
   fHLTConfMapTracks("AliESDHLTtrack",25000),
   fHLTHoughTracks("AliESDHLTtrack",15000),
@@ -79,7 +80,8 @@ AliESD::AliESD():
   // Standar constructor
   //
 
-  for (Int_t i=0; i<24; i++) {
+   for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
+ for (Int_t i=0; i<24; i++) {
     fT0time[i] = 0;
     fT0amplitude[i] = 0;
   }
@@ -113,6 +115,7 @@ AliESD::AliESD(const AliESD& esd):
   fSPDMult(esd.fSPDMult),
   fT0timeStart(esd.fT0timeStart),
   fT0clock(esd.fT0clock),
+  fT0trig(esd.fT0trig),
   fTracks(*((TClonesArray*)esd.fTracks.Clone())),
   fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
   fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
@@ -139,6 +142,7 @@ AliESD::AliESD(const AliESD& esd):
   // 
   // copy constructor
   //
+  for (Int_t i=0; i<3; i++)fT0TOF[i] = esd.fT0TOF[i];
   for (Int_t i=0; i<24; i++) {
     fT0time[i] = esd.fT0time[i];
     fT0amplitude[i] = esd.fT0amplitude[i];
@@ -210,6 +214,7 @@ void AliESD::Reset()
   }
   fT0timeStart = 0;
   fT0clock = 0;
+  for (Int_t i=0; i<3; i++) fT0TOF[i] = 0;
 //
   fSPDMult.~AliMultiplicity();
   new (&fSPDMult) AliMultiplicity();
index 255e68d..df5481a 100644 (file)
@@ -195,18 +195,23 @@ public:
   TArrayF *GetPHOSTriggerAmplitudes() const {return  fPHOSTriggerAmplitudes;}
 
 
-  Float_t GetT0zVertex() const {return fT0zVertex;}
-  void SetT0zVertex(Float_t z) {fT0zVertex=z;}
-  Float_t GetT0() const {return fT0timeStart;}
-  void SetT0(Float_t timeStart) {fT0timeStart = timeStart;}
+  Double32_t GetT0zVertex() const {return fT0zVertex;}
+  void SetT0zVertex(Double32_t z) {fT0zVertex=z;}
+  Double32_t GetT0() const {return fT0timeStart;}
+  void SetT0(Double32_t timeStart) {fT0timeStart = timeStart;}
   Float_t GetT0clock() const {return fT0clock;}
   void SetT0clock(Float_t timeStart) {fT0clock = timeStart;}
-  const Float_t * GetT0time() const {return fT0time;}
-  void SetT0time(Float_t time[24]) {
-    for (Int_t i=0; i<24; i++) fT0time[i] = time[i];
+  Double32_t GetT0TOF(Int_t i) const {return fT0TOF[i];}
+  const Double32_t * GetT0TOF() const {return fT0TOF;}
+  void SetT0TOF(Int_t icase, Float_t time) { fT0TOF[icase] = time;}
+  Int_t GetT0Trig() const {return fT0trig;}
+  void SetT0Trig(Int_t tvdc) {fT0trig = tvdc;}
+  const Double32_t * GetT0time() const {return fT0time;}
+  void SetT0time(Double32_t time[24]) {
+  for (Int_t i=0; i<24; i++) fT0time[i] = time[i];
   }
-  const Float_t * GetT0amplitude() const {return fT0amplitude;}
-  void SetT0amplitude(Float_t amp[24]) {
+  const Double32_t * GetT0amplitude() const {return fT0amplitude;}
+  void SetT0amplitude(Double32_t amp[24]) {
     for (Int_t i=0; i<24; i++) fT0amplitude[i] = amp[i];
   }
     
@@ -266,17 +271,21 @@ protected:
   Float_t      fZDCEMEnergy;     // reconstructed energy in the electromagnetic ZDC
   Int_t        fZDCParticipants; // number of participants estimated by the ZDC
 
-  Float_t      fT0zVertex;       // vertex z position estimated by the T0
+
+  Double32_t   fT0zVertex;       // vertex z position estimated by the T0
   AliESDVertex fSPDVertex;       // Primary vertex estimated by the SPD
   AliESDVertex fPrimaryVertex;   // Primary vertex estimated using ESD tracks
   Float_t      fDiamondXY[2];    // Interaction diamond (x,y) in RUN
   Float_t      fDiamondCovXY[3]; // Interaction diamond covariance (x,y) in RUN
   AliMultiplicity fSPDMult;      // SPD tracklet multiplicity
 
-  Float_t      fT0timeStart;     // interaction time estimated by the T0
-  Float_t      fT0clock;     // interaction time with reference point(spectrum)
-  Float_t      fT0time[24];      // best TOF on each T0 PMT
-  Float_t      fT0amplitude[24]; // number of particles(MIPs) on each T0 PMT
+  Float_t      fT0clock;     // backward compatibility
+  Double32_t   fT0TOF[3];     // interaction time in ns ( A&C, A, C)
+  Double32_t   fT0timeStart;     // interaction time estimated by the T0
+  Int_t        fT0trig;            // T0 trigger signals
+  Double32_t   fT0time[24];      // best TOF on each T0 PMT
+  Double32_t   fT0amplitude[24]; // number of particles(MIPs) on each T0 PMT
+
 
   TClonesArray fTracks;          // ESD tracks
   TClonesArray fHLTConfMapTracks;// HLT ESD tracks from Conformal Mapper method
index f868697..e0b59c5 100644 (file)
@@ -189,16 +189,21 @@ public:
   const AliESDTZERO*    GetESDTZERO() const {return fESDTZERO;}
   // delegetated methods for fESDTZERO
 
-  Double_t GetT0zVertex() const {return fESDTZERO?fESDTZERO->GetT0zVertex():0;}
-  void SetT0zVertex(Float_t z) {if(fESDTZERO) fESDTZERO->SetT0zVertex(z);}
-  Double_t GetT0() const {return fESDTZERO?fESDTZERO->GetT0():0;}
-  void SetT0(Float_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0(timeStart);}
-  Float_t GetT0clock() const {return fESDTZERO?fESDTZERO->GetT0clock():0;}
-  void SetT0clock(Float_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0clock(timeStart);}
-  const Double_t * GetT0time() const {return fESDTZERO?fESDTZERO->GetT0time():0x0;}
-  void SetT0time(Float_t time[24]) {if(fESDTZERO) fESDTZERO->SetT0time(time);}
-  const Double_t * GetT0amplitude() const {return fESDTZERO?fESDTZERO->GetT0amplitude():0x0;}
-  void SetT0amplitude(Float_t amp[24]){if(fESDTZERO) fESDTZERO->SetT0amplitude(amp);}
+  Double32_t GetT0zVertex() const {return fESDTZERO?fESDTZERO->GetT0zVertex():0;}
+  void SetT0zVertex(Double32_t z) {if(fESDTZERO) fESDTZERO->SetT0zVertex(z);}
+  Double32_t GetT0() const {return fESDTZERO?fESDTZERO->GetT0():0;}
+  void SetT0(Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0(timeStart);}
+  Double32_t GetT0clock() const {return fESDTZERO?fESDTZERO->GetT0clock():0;}
+  void SetT0clock(Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0clock(timeStart);}
+  Double32_t GetT0TOF(Int_t icase) const {return fESDTZERO?fESDTZERO->GetT0TOF(icase):0;}
+  const Double32_t * GetT0TOF() const {return fESDTZERO?fESDTZERO->GetT0TOF():0x0;}
+  void SetT0TOF(Int_t icase,Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0TOF(icase,timeStart);}
+  const Double32_t * GetT0time() const {return fESDTZERO?fESDTZERO->GetT0time():0x0;}
+  void SetT0time(Double32_t time[24]) {if(fESDTZERO) fESDTZERO->SetT0time(time);}
+  const Double32_t * GetT0amplitude() const {return fESDTZERO?fESDTZERO->GetT0amplitude():0x0;}
+  void SetT0amplitude(Double32_t amp[24]){if(fESDTZERO) fESDTZERO->SetT0amplitude(amp);}
+  Int_t GetT0Trig() const { return fESDTZERO?fESDTZERO->GetT0Trig():0;}
+  void SetT0Trig(Int_t tvdc) {if(fESDTZERO) fESDTZERO->SetT0Trig(tvdc);}
 
   // VZERO 
   AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
index 66d6796..d9f02f5 100644 (file)
@@ -31,18 +31,23 @@ AliESDTZERO::AliESDTZERO() :
   TObject(),
   fT0clock(0),
   fT0zVertex(0),
-  fT0timeStart(0)   
+  fT0timeStart(0),   
+  fT0trig(0)
 {
   for(int i = 0;i<24;i++)fT0time[i] = fT0amplitude[i] = 0;
+  for(int i = 0;i<3;i++) fT0TOF[i]=0;
 }
 
 AliESDTZERO::AliESDTZERO(const AliESDTZERO &tzero ) :
   TObject(tzero),
-  fT0clock(tzero.fT0clock),
+  fT0clock(tzero.fT0clock),  
+  fT0trig(tzero.fT0trig),
   fT0zVertex(tzero.fT0zVertex),
   fT0timeStart(tzero.fT0timeStart)   
 {
   // copy constuctor
+  for(int i = 0;i<3;i++) fT0TOF[i] = tzero.fT0TOF[i];
+
   for(int i = 0;i<24;i++){
     fT0time[i] = tzero.fT0time[i]; 
     fT0amplitude[i] = tzero.fT0amplitude[i];
@@ -53,8 +58,10 @@ AliESDTZERO& AliESDTZERO::operator=(const AliESDTZERO& tzero){
   // assigmnent operator
   if(this!=&tzero) {
     TObject::operator=(tzero);
+    fT0clock = tzero.fT0clock;
     fT0zVertex = tzero.fT0zVertex;
     fT0timeStart = tzero.fT0timeStart;   
+    for(int i = 0;i<3;i++) fT0TOF[i] = tzero.fT0TOF[i];
     for(int i = 0;i<24;i++){
       fT0time[i] = tzero.fT0time[i]; 
       fT0amplitude[i] = tzero.fT0amplitude[i];
@@ -81,13 +88,26 @@ void AliESDTZERO::Copy(TObject &obj) const {
 void AliESDTZERO::Reset()
 {
   // reset contents
+  fT0clock=0;
   fT0zVertex = 0;  
   fT0timeStart = 0;
   for(int i = 0;i<24;i++)fT0time[i] = fT0amplitude[i] = 0;
+  for(int i = 0;i<3;i++) fT0TOF[i] = 0;
 }
 
 //______________________________________________________________________________
 void AliESDTZERO::Print(const Option_t *) const
 {
   // does noting fornow
+  printf(" Vertex %f (T0A+T0C)/2 %f #channels T0signal %f ns OrA %f ns OrC %f \n",fT0zVertex,  fT0timeStart, fT0TOF[0],fT0TOF[1],fT0TOF[2]);
+
+   Bool_t tr[5];
+  for (Int_t i=0; i<5; i++) tr[i]=false; 
+
+  for (Int_t i=0; i<5; i++) {
+    tr[i] = fT0trig & (1<<i);
+    printf(" AliT0ESD ::: T0 trigers %i ",tr[i]);
+  }
+    printf(" \n ");
+
 }
index 154a1cd..ab1554b 100644 (file)
@@ -23,18 +23,23 @@ public:
   AliESDTZERO& operator=(const AliESDTZERO& tzero);
   virtual void Copy(TObject &obj) const;
 
-  Double_t GetT0zVertex() const {return fT0zVertex;}
-  void SetT0zVertex(Double_t z) {fT0zVertex=z;}
-  Double_t GetT0() const {return fT0timeStart;}
+  Double32_t GetT0zVertex() const {return fT0zVertex;}
+  void SetT0zVertex(Double32_t z) {fT0zVertex=z;}
+  Double32_t GetT0() const {return fT0timeStart;}
   void SetT0(Double_t timeStart) {fT0timeStart = timeStart;}
- Float_t GetT0clock() const {return fT0clock;}
+  Float_t GetT0clock() const {return fT0clock;}
   void SetT0clock(Float_t timeStart) {fT0clock = timeStart;}
-   const Double_t * GetT0time() const {return fT0time;}
-  void SetT0time(Float_t time[24]) {
-    for (Int_t i=0; i<24; i++) fT0time[i] = time[i];
+  Double32_t GetT0TOF(Int_t i) const {return fT0TOF[i];}
+  const Double32_t * GetT0TOF() const {return fT0TOF;}
+  void SetT0TOF(Int_t icase, Float_t time) { fT0TOF[icase] = time;}
+  Int_t GetT0Trig() const {return fT0trig;}
+  void SetT0Trig(Int_t tvdc) {fT0trig = tvdc;}
+  const Double32_t * GetT0time() const {return fT0time;}
+  void SetT0time(Double32_t time[24]) {
+  for (Int_t i=0; i<24; i++) fT0time[i] = time[i];
   }
-  const Double_t * GetT0amplitude() const {return fT0amplitude;}
-  void SetT0amplitude(Float_t amp[24]) {
+  const Double32_t * GetT0amplitude() const {return fT0amplitude;}
+  void SetT0amplitude(Double32_t amp[24]) {
     for (Int_t i=0; i<24; i++) fT0amplitude[i] = amp[i];
   }
 
@@ -43,13 +48,15 @@ public:
 
 private:
 
-  Float_t      fT0clock;     // interaction time with reference point(spectrum)
-  Double32_t      fT0zVertex;       // vertex z position estimated by the T0
-  Double32_t      fT0timeStart;     // interaction time estimated by the T0
-  Double32_t      fT0time[24];      // best TOF on each T0 PMT
-  Double32_t      fT0amplitude[24]; // number of particles(MIPs) on each T0 PMT
+  Float_t      fT0clock;     // backward compatibility
+  Double32_t   fT0TOF[3];     // interaction time in ns ( A&C, A, C)
+  Double32_t   fT0zVertex;       // vertex z position estimated by the T0
+  Double32_t   fT0timeStart;     // interaction time estimated by the T0
+  Int_t        fT0trig;            // T0 trigger signals
+  Double32_t   fT0time[24];      // best TOF on each T0 PMT
+  Double32_t   fT0amplitude[24]; // number of particles(MIPs) on each T0 PMT
 
-  ClassDef(AliESDTZERO,3)
+  ClassDef(AliESDTZERO,4)
 };
 
 
index f1b941c..42bb2ef 100644 (file)
@@ -40,7 +40,9 @@ ClassImp(AliT0RecPoint)
                                   fVertexPosition(999999),
                                   fTimeBestA(0),fTimeBestC(0),
                                    fMultC(0),fMultA(0),
-                                   fT0clock(9999999)
+                                   fT0clock(9999999),
+                                  fT0trig(0)
+
 {
   //ctor
   // fTimeAverage=99999;
@@ -59,7 +61,8 @@ AliT0RecPoint::AliT0RecPoint(const AliT0RecPoint &r):TObject(),
                                                     fVertexPosition(999999),
                                                     fTimeBestA(0),fTimeBestC(0),
                                                     fMultC(0),fMultA(0),
-                                                     fT0clock(9999999)
+                                                     fT0clock(9999999),
+                                                    fT0trig(0)
 {
   //
   // AliT0RecPoint copy constructor
@@ -68,3 +71,25 @@ AliT0RecPoint::AliT0RecPoint(const AliT0RecPoint &r):TObject(),
   ((AliT0RecPoint &) r).Copy(*this);
 
 }
+//_____________________________________________________________________________
+
+void AliT0RecPoint::SetT0Trig(Bool_t *tr)
+{
+  fT0trig=0;
+  for (Int_t i=0; i<5; i++) fT0trig=fT0trig<<1|tr[i];
+}
+//_____________________________________________________________________________
+
+void AliT0RecPoint::PrintTriggerSignals(Int_t trig)
+{
+  Bool_t tr[5];
+  for (Int_t i=0; i<5; i++) tr[i]=false; 
+
+  for (Int_t i=0; i<5; i++) {
+    tr[i] = trig&(1<<i);
+    printf(" T0 trigers %i ",tr[i]);
+  }
+    printf(" \n ");
+  
+
+}
index b6bb93a..a8f3e33 100644 (file)
@@ -16,50 +16,54 @@ class AliT0RecPoint: public TObject  {
     AliT0RecPoint& operator= (const AliT0RecPoint &)  { return *this;}
     virtual ~AliT0RecPoint() {}
 
-     Int_t  GetMeanTime()   const {return fTimeAverage;}
-     Int_t  GetOnlineMean() const {return fTimeOnlineMean;}
-     Int_t  GetBestTimeA()  const {return fTimeBestA ;}
-     Int_t  GetBestTimeC()  const {return fTimeBestC ;}
-     Int_t GetMultC()       const {return fMultC;}
-     Int_t GetMultA()       const {return fMultA;}
-     Float_t  GetVertex()   const {return fVertexPosition;}
+    Double32_t  GetMeanTime()   const {return fTimeAverage;}
+    Int_t  GetOnlineMean() const {return fTimeOnlineMean;}
+    Double32_t  GetBestTimeA()  const {return fTimeBestA ;}
+    Double32_t  GetBestTimeC()  const {return fTimeBestC ;}
+    Float_t GetMultC()       const {return fMultC;}
+    Float_t GetMultA()       const {return fMultA;}
+    Double32_t  GetVertex()   const {return fVertexPosition;}
 
 
-    void SetMeanTime(Int_t time) {fTimeAverage=time;}
+    void SetMeanTime(Double32_t time) {fTimeAverage=time;}
     void SetOnlineMean(Int_t time) {fTimeOnlineMean=time;}
-    void SetTimeBestA( Int_t time) {fTimeBestA = time;}
-    void SetTimeBestC( Int_t time) {fTimeBestC = time;}
-    void SetVertex( Float_t vertex) {fVertexPosition= vertex;}
-    void SetMultC(Int_t mult) {fMultC = mult;}
-    void SetMultA(Int_t mult) {fMultA = mult;}
-
-    void SetTime (Int_t ipmt, Float_t time) { fTime[ipmt] = time;}
-    Float_t GetTime (Int_t ipmt)const { return fTime[ipmt];}
-    void SetAmp (Int_t ipmt, Float_t adc) { fADC[ipmt] = adc;}
-    Float_t GetAmp (Int_t ipmt) const{ return fADC[ipmt];}
-    void SetAmpLED (Int_t ipmt, Float_t adc) { fADCLED[ipmt] = adc;}
-    Float_t AmpLED (Int_t ipmt) const{ return fADCLED[ipmt];}
+    void SetTimeBestA( Double32_t time) {fTimeBestA = time;}
+    void SetTimeBestC( Double32_t time) {fTimeBestC = time;}
+    void SetVertex( Double32_t vertex) {fVertexPosition= vertex;}
+    void SetMultC(Float_t mult) {fMultC = mult;}
+    void SetMultA(Float_t mult) {fMultA = mult;}
+
+    void    SetTime (Int_t ipmt, Double32_t time) { fTime[ipmt] = time;}
+    Double32_t GetTime (Int_t ipmt)const { return fTime[ipmt];}
+    void    SetAmp (Int_t ipmt, Double32_t adc) { fADC[ipmt] = adc;}
+    Double32_t GetAmp (Int_t ipmt) const{ return fADC[ipmt];}
+    void    SetAmpLED (Int_t ipmt, Double32_t adc) { fADCLED[ipmt] = adc;}
+    Double32_t AmpLED (Int_t ipmt) const{ return fADCLED[ipmt];}
     
-    void SetT0clock (Int_t time) { fT0clock = time;}
-    Float_t GetT0clock () const{ return fT0clock;}
-
+    void    SetT0clock (Double32_t time) { fT0clock = time;}
+    Double32_t GetT0clock () const{ return fT0clock;}
 
+    Bool_t GetT0Trig(Int_t i) {return fT0trig&(1<<i);}
+    Int_t GetT0Trig() {return fT0trig;}
+    void   SetT0Trig(Bool_t *tr );
+    void PrintTriggerSignals(Int_t trig);
   private: 
-    Int_t fTimeAverage;     // Average time
-    Int_t fTimeOnlineMean; // online mean signal
-    Float_t fVertexPosition;     // Diffrence time between C and A
-    Int_t fTimeBestA;   //TOF first particle on the A
-    Int_t fTimeBestC;    //TOF first particle on the C
-    Int_t fMultC; // multiplicity on the 
-    Int_t fMultA; // multiplicity on the 
-    Int_t fT0clock; // T0 with reference point
+    Double32_t fTimeAverage;     // Average time
+    Int_t   fTimeOnlineMean; // online mean signal
+    Double32_t fVertexPosition;     // Diffrence time between C and A
+    Double32_t fTimeBestA;   //TOF first particle on the A
+    Double32_t fTimeBestC;    //TOF first particle on the C
+    Float_t fMultC; // multiplicity on the 
+    Float_t fMultA; // multiplicity on the 
+    Double32_t fT0clock; // T0 with reference point in ns
+    Int_t   fT0trig;    // T0 trigger signals
  
-    Float_t fTime[24];    // array's TDC
-    Float_t fADC[24];    // array's amplitude
-    Float_t fADCLED[24];    // array's LED amplitude
+    Double32_t fTime[24];    // array's TDC
+    Double32_t fADC[24];    // array's amplitude
+    Double32_t fADCLED[24];    // array's LED amplitude
 
 
-    ClassDef(AliT0RecPoint,5)  //Digit (Header) object for set:T0
+    ClassDef(AliT0RecPoint,6)  //Digit (Header) object for set:T0
 };
 
 typedef AliT0RecPoint AliSTARTRecPoint; // for backward compatibility
index 15cc7e6..42d67d0 100644 (file)
@@ -63,8 +63,9 @@ ClassImp(AliT0Reconstructor)
   }
 
   
-  fdZonC = TMath::Abs(fParam->GetZPositionShift("T0/C/PMT1"));
-  fdZonA = TMath::Abs(fParam->GetZPositionShift("T0/A/PMT15"));
+  // fdZonC = TMath::Abs(fParam->GetZPositionShift("T0/C/PMT1"));
+  //fdZonA = TMath::Abs(fParam->GetZPositionShift("T0/A/PMT15"));
+
 
   fCalib = new AliT0Calibrator();
 
@@ -86,8 +87,8 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   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;
+  Double32_t vertex = 9999999;
+  Double32_t timeDiff=999999, meanTime=999999, timeclock=999999;
 
   
   AliDebug(1,Form("Start DIGITS reconstruction "));
@@ -110,11 +111,12 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   fDigits->GetQT0(*chargeQT0);
   fDigits->GetQT1(*chargeQT1);
   Int_t onlineMean =  fDigits->MeanTime();
-  Int_t ref =  fDigits->RefPoint();
 
+  Bool_t tr[5];
+  for (Int_t i=0; i<5; i++) tr[i]=false; 
   
-  Float_t besttimeA=999999;
-  Float_t besttimeC=999999;
+  Double32_t besttimeA=999999;
+  Double32_t besttimeC=999999;
   Int_t pmtBestA=99999;
   Int_t pmtBestC=99999;
   
@@ -166,24 +168,40 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
         pmtBestA=ipmt;}
     }
   }
-  if(besttimeA !=999999)  frecpoints->SetTimeBestA(Int_t(besttimeA));
-  if( besttimeC != 999999 ) frecpoints->SetTimeBestC(Int_t(besttimeC));
+  if(besttimeA < 999999) {
+    frecpoints->SetTimeBestA(Int_t(besttimeA *channelWidth));
+    tr[1]=true;
+  }
+  if( besttimeC < 999999 ) {
+    frecpoints->SetTimeBestC(Int_t(besttimeC *channelWidth));
+    tr[2]=true;
+  }
   AliDebug(10,Form(" besttimeA %f ch,  besttimeC %f ch",besttimeA, besttimeC));
-    if(besttimeA !=999999 && besttimeC != 999999 ){
+  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(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));
-    
-    //  }
+    meanTime = (besttimeA + besttimeC)/2;// * channelWidth); 
+    timeclock = meanTime *channelWidth ;
+    vertex = meanVertex - c*(timeDiff)/2.;// + (fdZonA - fdZonC)/2;
+    tr[0]=true; 
+  }
+  frecpoints->SetVertex(vertex);
+  frecpoints->SetMeanTime(meanTime);
+  frecpoints->SetT0clock(timeclock);
+  frecpoints->SetT0Trig(tr);
+
+  for (Int_t i=0; i<5; i++) {
+    printf(" T0 trigers %i ",tr[i]);
+  }
+    printf(" \n ");
+
+  //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();
 
@@ -204,21 +222,25 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
 
   Int_t refAmp = GetRecoParam()->GetRefAmp();
   Int_t refPoint = GetRecoParam()->GetRefPoint();
+  Float_t latencyL1 = GetRecoParam()->GetLatencyL1();
+  Float_t latencyHPTDC = GetRecoParam()->GetLatencyHPTDC();
+  Float_t vertexshift = GetRecoParam()->GetVertexShift();
 
   Int_t allData[110][5];
   
   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;
+  Double32_t timeDiff=999999, meanTime=999999, timeclock=999999;
+  Float_t c = 29.9792458; // cm/ns
+  Double32_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;
+  Double32_t besttimeA=9999999;
+  Double32_t besttimeC=9999999;
   Int_t pmtBestA=99999;
   Int_t pmtBestC=99999;
   Float_t meanVertex = fParam->GetMeanVertex();
@@ -245,7 +267,7 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
       }
       Int_t ref=0;
       if (refPoint>0) 
-      ref = allData[refPoint][0]-5000.;
+      ref = allData[refPoint][0]-5000;
 
       Float_t channelWidth = fParam->GetChannelWidth() ;  
       
@@ -281,7 +303,7 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
                           in, timeLED[in],timeCFD[in],chargeQT0[in],chargeQT1[in]));
         onlineMean = allData[49][0];       
        
-       Float_t time[24], adc[24];
+       Double32_t time[24], adc[24];
        for (Int_t ipmt=0; ipmt<24; ipmt++) {
         if(timeCFD[ipmt]>0 && timeLED[ipmt]>0){
           //for simulated data
@@ -302,9 +324,10 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
           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));
+          //      frecpoints->SetTime(ipmt, Float_t(time[ipmt]) );
+          frecpoints->SetTime(ipmt,Double32_t(timeCFD[ipmt]));
+          frecpoints->SetAmpLED(ipmt, Double32_t( qtMip)); //for cosmic &pp beam 
+          frecpoints->SetAmp(ipmt, Double32_t(ampMip));
             
         }
         else {
@@ -328,41 +351,76 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
             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",
+       if(besttimeA < 999999) 
+        frecpoints->SetTimeBestA( 0.001 * besttimeA * channelWidth - latencyHPTDC + latencyL1);
+       if( besttimeC < 999999 ) 
+        frecpoints->SetTimeBestC(0.001 * besttimeC * channelWidth - latencyHPTDC + latencyL1);
+       AliDebug(10,Form(" pmtA %i besttimeA %f ps, pmtC %i besttimeC %f ps",
                       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(besttimeA <999999 && besttimeC < 999999 ){
+        timeDiff = ( besttimeA - besttimeC) *0.001 * channelWidth;
+        timeclock =  0.001 * channelWidth * Float_t(besttimeA+besttimeC)/2. - latencyHPTDC + latencyL1;  
+        meanTime = (besttimeA+besttimeC-2.*Float_t(ref))/2.;
+        vertex =  meanVertex -  c*(timeDiff)/2. + vertexshift; //+ (fdZonA - fdZonC)/2; 
+       }
       }  //if phys event       
+      AliDebug(5,Form("  timeDiff %f #channel,  meanTime %f #channel, TOFmean%f  vertex %f cm meanVertex %f online mean %i \n",timeDiff, meanTime,timeclock, vertex,meanVertex, onlineMean));
       frecpoints->SetT0clock(timeclock);
       frecpoints->SetVertex(vertex);
-      frecpoints->SetMeanTime(Int_t(meanTime));
+      frecpoints->SetMeanTime(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(TTree */*digitsTree*/, TTree *clustersTree, AliESDEvent *pESD) const
-{
+       // Set triggers
+      
+      Bool_t tr[5];
+      Int_t trchan[5]= {50,51,52,55,56};
+      for (Int_t i=0; i<5; i++) tr[i]=false; 
+      for (Int_t itr=0; itr<5; itr++) {
+       if(allData[trchan[itr]][0]>0) tr[itr]=true;
+       frecpoints->SetT0Trig(tr);
+      }
+      for (Int_t i=0; i<5; i++) 
+       printf(" T0 trigers %i ",tr[i]);
+      printf(" \n ");
+      
+      
+      } // if (else )raw data
+      recTree->Fill();
+      if(frecpoints) delete frecpoints;
+    }
+  
+  
+  //____________________________________________________________
+  
+  void AliT0Reconstructor::FillESD(TTree */*digitsTree*/, TTree *clustersTree, AliESDEvent *pESD) const
+  {
 
   /***************************************************
   Resonstruct digits to vertex position
   ****************************************************/
   
   AliDebug(1,Form("Start FillESD T0"));
-
+  Float_t channelWidth = 0.0244;
+  Float_t c = 29.9792458; // cm/ns
+  Float_t currentVertex=0, shift=0;
+  Int_t ncont=0;
+  const AliESDVertex* vertex = pESD->GetPrimaryVertex();
+  if (!vertex)        vertex = pESD->GetPrimaryVertexSPD();
+  if (!vertex)        vertex = pESD->GetPrimaryVertexTPC();
+  if (!vertex)        vertex = pESD->GetVertex();
+
+  if (vertex) {
+    AliDebug(2, Form("Got %s (%s) from ESD: %f", 
+                   vertex->GetName(), vertex->GetTitle(), vertex->GetZ()));
+    currentVertex = vertex->GetZ();
+    
+    ncont = vertex->GetNContributors();
+    // cout<<" spdver "<<spdver<<" ncont "<<ncont<<endl;
+    if(ncont>3 ) {
+      //     hVertexSPD->Fill(spdver);
+      shift = currentVertex/c;
+      //         cout<<" vertex shif "<<shift<<" vertex "<<spdver<<" IsFromVertexer3D  "<<fverSPD->IsFromVertexer3D()<<endl;
+    }
+  }
   TTree *treeR = clustersTree;
   
    AliT0RecPoint* frecpoints= new AliT0RecPoint ();
@@ -381,22 +439,31 @@ void AliT0Reconstructor::FillESD(TTree */*digitsTree*/, TTree *clustersTree, Ali
   } 
     
     brRec->GetEntry(0);
-    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
+    Double32_t amp[24], time[24];  
+    Double32_t timeClock[3];
+    Double32_t zPosition = frecpoints -> GetVertex();
+    Double32_t timeStart = frecpoints -> GetMeanTime();
+    timeClock[0] = frecpoints -> GetT0clock() ;
+    timeClock[1] = frecpoints -> GetBestTimeA() + shift;
+    timeClock[2] = frecpoints -> GetBestTimeC() - shift;
+    for ( Int_t i=0; i<24; i++) {
+      time[i] =  frecpoints -> GetTime(i); // ps to ns
       amp[i] = frecpoints -> GetAmp(i);
     }
+    Int_t trig= frecpoints ->GetT0Trig();
+    pESD->SetT0Trig(trig);
+    
     pESD->SetT0zVertex(zPosition); //vertex Z position 
     pESD->SetT0(timeStart);        // interaction time 
-    pESD->SetT0clock(timeClock);   // interaction time with ref.point(spectrum) 
+    for(Int_t i=0; i<3; i++) 
+      pESD->SetT0TOF(i,timeClock[i]);   // interaction time (ns) 
     pESD->SetT0time(time);         // best TOF on each PMT 
     pESD->SetT0amplitude(amp);     // number of particles(MIPs) on each PMT
-    AliDebug(1,Form(" Z position %f cm,  T0  %f ps",zPosition , timeStart));
-
+    pESD->Print(); 
+    
+    AliDebug(1,Form("T0: Vertex %f (T0A+T0C)/2 %f #channels T0signal %f ns OrA %f ns OrC %f T0trig %i\n",zPosition, timeStart, timeClock[0], timeClock[1], timeClock[2], trig));
+    
+    
 } // vertex in 3 sigma