Remove the original version of the TOF Tender.
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Oct 2010 15:17:17 +0000 (15:17 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 14 Oct 2010 15:17:17 +0000 (15:17 +0000)
ANALYSIS/TenderSupplies/AliTOFT0makerANA.cxx [deleted file]
ANALYSIS/TenderSupplies/AliTOFT0makerANA.h [deleted file]
ANALYSIS/TenderSupplies/AliTOFT0v2.cxx [deleted file]
ANALYSIS/TenderSupplies/AliTOFT0v2.h [deleted file]
ANALYSIS/TenderSupplies/AliTOFTenderSupply.cxx [deleted file]
ANALYSIS/TenderSupplies/AliTOFTenderSupply.h [deleted file]
ANALYSIS/TenderSupplies/AliTOFcalibESD.cxx [deleted file]
ANALYSIS/TenderSupplies/AliTOFcalibESD.h [deleted file]
ANALYSIS/TenderSuppliesLinkDef.h
ANALYSIS/libTENDERSupplies.pkg

diff --git a/ANALYSIS/TenderSupplies/AliTOFT0makerANA.cxx b/ANALYSIS/TenderSupplies/AliTOFT0makerANA.cxx
deleted file mode 100644 (file)
index 7436b55..0000000
+++ /dev/null
@@ -1,343 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-/* $Id: AliTOFT0makerANA.cxx,v 1.8 2010/01/19 16:32:20 noferini Exp $ */
-
-/////////////////////////////////////////////////////////////////////////////
-//                                                                         //
-//  This class contains the basic functions for the time zero              //
-//  evaluation with TOF detector informations.                             //
-// Use case in an analysis task:                                           //
-//                                                                         //
-// Create the object in the task constructor (fTOFmakerANA is a private var)  //
-// fTOFmakerANA = new AliTOFT0makerANA();                                        //
-// fTOFmakerANA->SetTimeResolution(130.0); // if you want set the TOF res     //
-// 115 ps is the TOF default resolution value                              //
-//                                                                         //
-// Use the RemakePID method in the task::Exec                              //
-// Double_t* calcolot0;                                                    //
-// calcolot0=fTOFmakerANA->RemakePID(fESD);                                   //
-// //calcolot0[0] = calculated event time                                  // 
-// //calcolot0[1] = event time time resolution                             //
-// //calcolot0[2] = average event time for the current fill                //
-// //calcolot0[3] = tracks at TOF                                          // 
-// //calcolot0[4] = calculated event time (only TOF)                       //
-// //calcolot0[5] = event time time resolution (only TOF)                  //
-// //calcolot0[6] = sigma t0 fill                                          //
-// //calcolot0[7] = tracks at TOF really used in tht algorithm             // 
-//                                                                         //
-// Let consider that:                                                      //
-// - the PIF is automatically recalculated with the event time subtrction  //
-//                                                                         //
-/////////////////////////////////////////////////////////////////////////////
-
-#include <AliPID.h>
-#include <AliESDpid.h>
-#include <AliESDEvent.h>
-#include <TFile.h>
-#include <TH1F.h>
-
-#include "AliTOFT0v2.h"
-#include "AliTOFT0makerANA.h"
-
-ClassImp(AliTOFT0makerANA)
-
-//____________________________________________________________________________ 
-AliTOFT0makerANA::AliTOFT0makerANA():
-  fPIDesd(0x0),
-  fnT0(0),
-  fiT0(0),
-  fNoTOFT0(0),
-  fTimeResolution(115),
-  fT0sigma(1000),
-  fHmapChannel(0),
-  fKmask(0)
-{
-  // ctr
-  fCalculated[0] = 0;
-  fCalculated[1] = 0;
-  fCalculated[2] = 0;
-  fCalculated[3] = 0;
-  
-  if(AliPID::ParticleMass(0) == 0) new AliPID();
-  
-  fPIDesd = new AliESDpid();
-  
-}
-//____________________________________________________________________________ 
-AliTOFT0makerANA::AliTOFT0makerANA(AliESDpid *const externalPID):
-  fPIDesd(0x0),
-  fnT0(0),
-  fiT0(0),
-  fNoTOFT0(0),
-  fTimeResolution(115),
-  fT0sigma(1000),
-  fHmapChannel(0),
-  fKmask(0)
-{
-  // ctr
-  fCalculated[0] = 0;
-  fCalculated[1] = 0;
-  fCalculated[2] = 0;
-  fCalculated[3] = 0;
-  
-  if(AliPID::ParticleMass(0) == 0) new AliPID();
-  
-  fPIDesd = externalPID;
-  if(!fPIDesd){
-    fPIDesd = new AliESDpid();
-    printf("ATTENTION!!!\n New AliESDpid is created in AliTOFT0makerANA class!!!!\n");
-  }
-  
-}
-//____________________________________________________________________________ 
-AliTOFT0makerANA::AliTOFT0makerANA(const AliTOFT0makerANA & t) :
-TObject(),
-fPIDesd(t.fPIDesd),
-fnT0(t.fnT0),
-fiT0(t.fiT0),
-fNoTOFT0(t.fNoTOFT0),
-fTimeResolution(t.fTimeResolution),
-fT0sigma(t.fT0sigma),
-fHmapChannel(t.fHmapChannel),
-fKmask(t.fKmask)
-{
-  // copy ctr
-}
-
-//____________________________________________________________________________ 
-AliTOFT0makerANA& AliTOFT0makerANA::operator=(const AliTOFT0makerANA &t)
-{
-  //
-  // assign. operator
-  //
-  
-  if (this == &t)
-    return *this;
-  fTimeResolution = t.fTimeResolution;
-  fT0sigma = t.fT0sigma;
-  
-  return *this;
-}
-//____________________________________________________________________________ 
-AliTOFT0makerANA::~AliTOFT0makerANA()
-{
-  // dtor
-}
-//____________________________________________________________________________ 
-Double_t* AliTOFT0makerANA::RemakePID(AliESDEvent *esd,Double_t t0time,Double_t t0sigma){
-  //
-  // Remake TOF PID probabilities
-  //
-  
-  Double_t *t0tof;
-  
-  if(fKmask) ApplyMask(esd);
-  
-  AliTOFT0v2 t0makerANA(esd);
-  t0makerANA.SetTimeResolution(fTimeResolution*1e-12*1.1);
-  
-  t0tof=t0makerANA.DefineT0("all");
-  
-  Float_t lT0Current=0.;
-  fT0sigma=1000;
-  
-  Double_t t0fill = GetT0Fill();
-  t0time += t0fill;
-  
-  Float_t sigmaFill = (t0fill - Int_t(t0fill))*1000;
-  if(sigmaFill < 0) sigmaFill += 1000;
-  
-  if(sigmaFill < 50) sigmaFill = 50;
-  
-  fCalculated[0]=-1000*t0tof[0]; // best t0
-  fCalculated[1]=1000*t0tof[1]; // sigma best t0
-  fCalculated[2] = t0fill;    //t0 fill
-  fCalculated[3] = t0tof[2];  // n TOF tracks
-  fCalculated[4]=-1000*t0tof[0]; // TOF t0
-  fCalculated[5]=1000*t0tof[1]; // TOF t0 sigma
-  fCalculated[6]=sigmaFill; // sigma t0 fill
-  fCalculated[7] = t0tof[3];  // n TOF tracks used for T0
-  
-  if(fCalculated[1] < sigmaFill){
-    if(fnT0 < 10){
-      fT0fill[fiT0] = fCalculated[0];
-      fT0sigmaTOF[fiT0] = fCalculated[1];
-      fiT0++;
-      fnT0++;
-    }
-    else if(TMath::Abs(fCalculated[0] - t0fill) < 500){
-      fT0fill[fiT0] = fCalculated[0];
-      fT0sigmaTOF[fiT0] = fCalculated[1];
-      fiT0++;
-      fnT0++;
-    }
-    
-    //        printf("%i - %i) %f\n",fiT0,fnT0,t0fill);
-  }
-  if(fnT0==10) fiT0=0;
-  
-  if(fiT0 > fgkNmaxT0step-1) fiT0=0;
-  
-  if(fnT0 < 100){
-    t0time -= t0fill;
-    sigmaFill=200;
-    t0fill=0;
-    fCalculated[2] = t0fill;    //t0 fill
-  }
-  
-  if(fCalculated[1] < sigmaFill && TMath::Abs(fCalculated[0] - t0fill) < 500){
-    fT0sigma=fCalculated[1];
-    lT0Current=fCalculated[0];
-  }
-  else{
-    fCalculated[4] = t0fill;
-    fCalculated[5] = sigmaFill;
-  }
-  
-  if(fCalculated[1] < 1 || fT0sigma > sigmaFill){
-    fT0sigma =1000;
-    fCalculated[4] = t0fill;
-    fCalculated[5] = sigmaFill;
-  }
-  
-  if(t0sigma < 1000){
-    if(fT0sigma < 1000){
-      Double_t w1 = 1./t0sigma/t0sigma;
-      Double_t w2 = 1./fCalculated[1]/fCalculated[1];
-      
-      Double_t wtot = w1+w2;
-      
-      lT0Current = (w1*t0time + w2*fCalculated[0]) / wtot;
-      fT0sigma = TMath::Sqrt(1./wtot);
-    }
-    else{
-      lT0Current=t0time;
-      fT0sigma=t0sigma;
-    }
-  }
-  
-  if(fT0sigma < sigmaFill && TMath::Abs(lT0Current - t0fill) < 500){
-    fCalculated[1]=fT0sigma;
-    fCalculated[0]=lT0Current;
-  }
-  
-  if(fT0sigma >= 1000 || fNoTOFT0){
-    lT0Current = t0fill;
-    fT0sigma = sigmaFill;
-    
-    fCalculated[0] = t0fill;
-    fCalculated[1] = sigmaFill;
-  }
-  
-  
-  
-  RemakeTOFpid(/*esd,*/lT0Current);
-  
-  return fCalculated;
-}
-//____________________________________________________________________________ 
-void AliTOFT0makerANA::RemakeTOFpid(/*AliESDEvent *esd,*/Float_t timezero){
-  //
-  // Recalculate TOF PID probabilities
-  //
-  
-  fPIDesd->GetTOFResponse().SetTimeResolution(TMath::Sqrt(fT0sigma*fT0sigma + fTimeResolution*fTimeResolution));
-  //  fPIDesd->MakePID(esd,kFALSE,timezero);
-  fPIDesd->GetTOFResponse().SetTimeZero(timezero);
-  // please call fESDpid->MakePID(fEvent, kFALSE,fESDpid->GetTOFResponse().GetTimeZero()); when you make new PID
-}
-//____________________________________________________________________________ 
-Double_t AliTOFT0makerANA::GetT0Fill() const {
-  //
-  // Return T0 of filling
-  //
-  
-  Double_t t0=0.200;
-  
-  Int_t n=fnT0;
-  
-  if(n >10 && n <= 20) n = 10;
-  else if(n > 20){
-    n -= 10;
-  }
-  
-  if(n > fgkNmaxT0step) n = fgkNmaxT0step;
-  
-  if(n>1){
-    Double_t lT0av=0;
-    Double_t lT0sigmaav=0;
-    Double_t lT0avErr=0;
-    for(Int_t i=0;i<n;i++){
-      lT0av+=fT0fill[i];
-      lT0sigmaav += fT0sigmaTOF[fiT0];
-      lT0avErr+=fT0fill[i]*fT0fill[i];
-    }
-    lT0avErr -= lT0av*lT0av/n;
-    lT0av /= n;
-    lT0sigmaav /= n;
-    lT0avErr = TMath::Sqrt(TMath::Max(lT0avErr/(n-1) - lT0sigmaav*lT0sigmaav,0.00001));
-    
-    
-    if(lT0avErr > 300) lT0avErr = 300;
-    
-    lT0av = Int_t(lT0av) + lT0avErr/1000.;
-    
-    return lT0av;
-  }
-  
-  
-  return t0;
-}
-//____________________________________________________________________________ 
-void  AliTOFT0makerANA::LoadChannelMap(char *filename){
-  // Load the histo with the channel off map
-  TFile *f= new TFile(filename);
-  if(!f){
-    printf("Cannot open the channel map file (%s)\n",filename);
-    return;
-  }
-  
-  fHmapChannel = (TH1F *) f->Get("hChEnabled");
-  
-  if(!fHmapChannel){
-    printf("Cannot laod the channel map histo (from %s)\n",filename);
-    return;
-  }
-  
-}
-//____________________________________________________________________________ 
-void AliTOFT0makerANA::ApplyMask(AliESDEvent * const esd){
-  // Switch off the disable channel
-  if(!fHmapChannel){
-    printf("Channel Map is not available\n");
-    return;
-  }
-  
-  Int_t ntracks = esd->GetNumberOfTracks();
-  
-  while (ntracks--) {
-    AliESDtrack *t=esd->GetTrack(ntracks);
-    
-    if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue;
-    
-    Int_t chan = t->GetTOFCalChannel();
-    
-    if(fHmapChannel->GetBinContent(chan) < 0.01){
-      t->ResetStatus(AliESDtrack::kTOFout);
-    }
-  }
-}
-
-//____________________________________________________________________________ 
diff --git a/ANALYSIS/TenderSupplies/AliTOFT0makerANA.h b/ANALYSIS/TenderSupplies/AliTOFT0makerANA.h
deleted file mode 100644 (file)
index 784858a..0000000
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef ALITOFT0MAKERANA_H
-#define ALITOFT0MAKERANA_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id: AliTOFT0makerANA.h,v 1.8 2010/01/19 16:32:20 noferini Exp $ */
-
-///////////////////////////////////////////////
-//                                          //
-//  Manager class for time zero evaluation   //
-//  with TOF informations                    //
-//                                          //
-///////////////////////////////////////////////
-
-
-#include "TObject.h"
-
-class TH1F;
-class AliESDEvent;
-
-class AliTOFT0v2;
-class AliESDpid;
-
-class AliTOFT0makerANA : public TObject {
-public:
-  
-  AliTOFT0makerANA() ;
-  AliTOFT0makerANA(AliESDpid * const externalPID);
-  virtual ~AliTOFT0makerANA() ; // dtor
-  AliTOFT0makerANA(const AliTOFT0makerANA & t);
-  AliTOFT0makerANA & operator=(const AliTOFT0makerANA & t);
-  // return (fCalculated[0]=event time -- fCalculated[1]=sigma event time in ps -- fCalculated[2]=mean event time for each fill -- fCalculated[3]=number of tracks at the TOF level) if you can subtruct the event time -- ...
-  Double_t *RemakePID(AliESDEvent *esd,Double_t t0time=0.,Double_t t0sigma=1000.); // t0time and t0sigma in ps
-
-  void      SetTimeResolution(Double_t timeresolution){fTimeResolution=timeresolution;};// TOF timeresolution in [s] e.g. for 120 ps -> 1.2e-10
-  Double_t  GetTimeResolution() const {return fTimeResolution;}
-  
-  void LoadChannelMap(char *filename="$ALICE_ROOT/TOF/enableMap.104892.root"); //load the enable channel map
-  void ApplyMask(AliESDEvent * const esd);
-  
-  void SetNoTOFT0(Bool_t status=kTRUE){fNoTOFT0=status;}; // disable the TOF T0 info
-  void SetMaskOffChannel(Bool_t status=kTRUE){fKmask=status;}; // swith for the map off channel
-  
- private:
-  AliESDpid *fPIDesd; //!ESD pid object
-  void TakeTimeRawCorrection(AliESDEvent * const esd);
-  void RemakeTOFpid(/*AliESDEvent *esd,*/Float_t timezero);
-  Double_t GetT0Fill() const;
-  
-  Int_t fnT0; //! total number of T0-TOF
-  Int_t fiT0; //! last T0-TOF used for T0 fill
-  Double_t fT0fill[1000];  //! array for dynamical t0 fill calculation
-  Double_t fT0sigmaTOF[1000]; //! array for dynamical t0 fill resolution
-
-  Bool_t fNoTOFT0;   //! switch to avoid T0-TOF is used
-  
-  Double_t fCalculated[8]; //! contains the parameters with the event time
-  Double_t fTimeResolution;  //! global time resolution used to calculate T0
-  
-  Float_t fT0sigma; //! T0 resolution
-  
-  TH1F *fHmapChannel; //! histo with the channel map
-  Bool_t fKmask; //! switch if you want apply a channel filter
-  
-  static const Int_t fgkNmaxT0step = 500; //number of steps in the t0 fill calculation
-
-  ClassDef(AliTOFT0makerANA,2);  // Calculate the time zero using TOF detector */
-  
-};
-
-#endif // ALITOFT0MAKERANA_H
diff --git a/ANALYSIS/TenderSupplies/AliTOFT0v2.cxx b/ANALYSIS/TenderSupplies/AliTOFT0v2.cxx
deleted file mode 100644 (file)
index 9d5215d..0000000
+++ /dev/null
@@ -1,692 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id: AliTOFT0v2.cxx,v 1.8 2010/01/19 16:32:20 noferini Exp $ */
-
-//_________________________________________________________________________
-// This is a TTask that made the calculation of the Time zero using TOF.
-// Description: The algorithm used to calculate the time zero of interaction
-// using TOF detector is the following.
-// We select in the ESD some "primary" particles - or tracks in the following - 
-// that strike the TOF detector (the larger part are pions, kaons or protons). 
-// We choose a set of 10 selected tracks, for each track You have the length
-// of the track when the TOF is reached, 
-// the momentum and the time of flight
-// given by the TOF detector.
-// Let consider now only one set of 10 tracks (the algorithm is the same for all sets).
-// Assuming the (mass) hypothesis that each track can be AUT a pion, AUT a kaon, AUT a proton,
-// we consider all the 3 at 10 possible cases. 
-// For each track in each (mass) configuration
-// (a configuration can be e.g. pion/pion/kaon/proton/pion/proton/kaon/kaon/pion/pion)
-// we calculate the time zero (we know in fact the velocity of the track after 
-// the assumption about its mass, the time of flight given by the TOF, and the 
-// corresponding path travelled till the TOF detector). Then for each mass configuration we have
-// 10 time zero and we can calculate the ChiSquare for the current configuration using the 
-// weighted mean over all 10 time zero.
-// We call the best assignment the mass configuration that gives the minimum value of the ChiSquare. 
-// We plot the weighted mean over all 10 time zero for the best assignment, 
-// the ChiSquare for the best assignment and the corresponding confidence level.
-// The strong assumption is the MC selection of primary particles. It will be introduced
-// in the future also some more realistic simulation about this point. 
-// Use case:
-// root [0] AliTOFT0v2 * tzero = new AliTOFT0v2("galice.root")
-// Warning in <TDatabasePDG::TDatabasePDG>: object already instantiated
-// root [1] tzero->ExecuteTask()
-// root [2] tzero->ExecuteTask("tim")
-//             // available parameters:
-//             tim - print benchmarking information
-//             all - print usefull informations about the number of misidentified tracks 
-//                   and a comparison about the true configuration (known from MC) and the best
-//                   assignment
-// Different Selections for pp and Pb-Pb: Momentum Range, Max Time, # pions 
-//-- Author: F. Pierella
-//-- Mod By Silvia Arcelli, Francesco Noferini, Barbara Guerzoni
-//////////////////////////////////////////////////////////////////////////////
-
-#include "AliESDtrack.h"
-#include "AliESDEvent.h"
-#include "AliTOFT0v2.h"
-
-ClassImp(AliTOFT0v2)
-           
-//____________________________________________________________________________ 
-AliTOFT0v2::AliTOFT0v2():
-  fLowerMomBound(0.5),
-  fUpperMomBound(1.5),  
-  fTimeResolution(0.80e-10), 
-  fTimeCorr(0.), 
-  fEvent(0x0)
-//   fCalib(0x0)
-{
-  //
-  // default constructor
-  //
-    
-  fT0SigmaT0def[0]=-999.;
-  fT0SigmaT0def[1]=999.;
-  fT0SigmaT0def[2]=-999.;
-  fT0SigmaT0def[3]=-999.;
-
-}
-
-           
-//____________________________________________________________________________ 
-AliTOFT0v2::AliTOFT0v2(AliESDEvent* event): 
-  fLowerMomBound(0.5),
-  fUpperMomBound(1.5),  
-  fTimeResolution(0.80e-10), 
-  fTimeCorr(0.), 
-  fEvent(event)
-//   fCalib(0x0)
-{
-  //
-  // real constructor
-  //
-  
-  fT0SigmaT0def[0]=-999.;
-  fT0SigmaT0def[1]= 999.;
-  fT0SigmaT0def[2]=-999.;
-  fT0SigmaT0def[3]=-999.;
-
-}
-
-//____________________________________________________________________________ 
-AliTOFT0v2::AliTOFT0v2(const AliTOFT0v2 & tzero):
-  TObject(),
-  fLowerMomBound(tzero.fLowerMomBound),
-  fUpperMomBound(tzero.fUpperMomBound),  
-  fTimeResolution(tzero.fTimeResolution), 
-  fTimeCorr(tzero.fTimeCorr), 
-  fEvent(tzero.fEvent)
-//   fCalib(tzero.fCalib)
-{
-  //
-  // copy constructor
-  //
-    
-  fT0SigmaT0def[0]=tzero.fT0SigmaT0def[0];
-  fT0SigmaT0def[1]=tzero.fT0SigmaT0def[1];
-  fT0SigmaT0def[2]=tzero.fT0SigmaT0def[2];
-  fT0SigmaT0def[3]=tzero.fT0SigmaT0def[3];
-
-}
-
-//____________________________________________________________________________ 
-AliTOFT0v2& AliTOFT0v2::operator=(const AliTOFT0v2 &tzero)
-{
- //
-  // assign. operator
-  //
-
-  if (this == &tzero)
-    return *this;
-  
-  fLowerMomBound=tzero.fLowerMomBound;
-  fUpperMomBound=tzero.fUpperMomBound;  
-  fTimeResolution=tzero.fTimeResolution; 
-  fTimeCorr=tzero.fTimeCorr; 
-  fEvent=tzero.fEvent;
-//   fCalib=tzero.fCalib;
-  fT0SigmaT0def[0]=tzero.fT0SigmaT0def[0];
-  fT0SigmaT0def[1]=tzero.fT0SigmaT0def[1];
-  fT0SigmaT0def[2]=tzero.fT0SigmaT0def[2];
-  fT0SigmaT0def[3]=tzero.fT0SigmaT0def[3];
-
-  return *this;
-}
-//____________________________________________________________________________ 
-AliTOFT0v2::~AliTOFT0v2()
-{
-  // dtor
-//   fCalib=NULL;
-  fEvent=NULL;
-
-}
-//____________________________________________________________________________ 
-void AliTOFT0v2::SetTimeResolution(Double_t timeresolution){
-  // Set the TOF time resolution
-  fTimeResolution=timeresolution;
-}
-//____________________________________________________________________________
-//____________________________________________________________________________
-Double_t * AliTOFT0v2::DefineT0(Option_t *option) 
-{ 
-  // Caluclate the Event Time using the ESD TOF time
-
- Float_t timeresolutioninns=fTimeResolution*(1.e+9); // convert in [ns]
-  
-  const Int_t nmaxtracksinset=10;
-//   if(strstr(option,"all")){
-//     cout << "Selecting primary tracks with momentum between " << fLowerMomBound << " GeV/c and " << fUpperMomBound << " GeV/c" << endl;
-//     cout << "Memorandum: 0 means PION | 1 means KAON | 2 means PROTON" << endl;
-//   }
-  
-  
-  Int_t nsets=0;
-  Int_t nUsedTracks=0;
-  Int_t ngoodsetsSel= 0;
-  Float_t t0bestSel[300];
-  Float_t eT0bestSel[300];
-  Float_t chiSquarebestSel[300];
-  Float_t confLevelbestSel[300];
-  Float_t t0bestallSel=0.;
-  Float_t eT0bestallSel=0.;
-  Float_t sumWt0bestallSel=0.;
-  Float_t eMeanTzeroPi=0.;
-  Float_t meantzeropi=0.;
-  Float_t sumAllweightspi=0.;
-  Double_t t0def=-999;
-  Double_t deltat0def=999;
-  Int_t ngoodtrktrulyused=0;
-  Int_t ntracksinsetmyCut = 0;
-
-  Int_t ntrk=fEvent->GetNumberOfTracks();
-  
-  AliESDtrack **tracks=new AliESDtrack*[ntrk];
-  Int_t ngoodtrk=0;
-  Int_t ngoodtrkt0 =0;
-  Float_t mintime =1E6;
-  
-  // First Track loop, Selection of good tracks
-
-  for (Int_t itrk=0; itrk<ntrk; itrk++) {
-    AliESDtrack *t=fEvent->GetTrack(itrk);
-    Double_t momOld=t->GetP();
-    Double_t mom=momOld-0.0036*momOld;
-    if ((t->GetStatus()&AliESDtrack::kTIME)==0) continue;
-    if ((t->GetStatus()&AliESDtrack::kTOFout)==0) continue;
-    Double_t time=t->GetTOFsignal();
-    
-    time*=1.E-3; // tof given in nanoseconds      
-    if (!(mom<=fUpperMomBound && mom>=fLowerMomBound))continue;
-   
-    if (!AcceptTrack(t)) continue;
-
-    if(t->GetP() < fLowerMomBound || t->GetIntegratedLength() < 350 || t->GetTOFsignalToT() < 0.000000001)continue; //skip decays
-    if(time <= mintime) mintime=time;
-    tracks[ngoodtrk]=t;
-    ngoodtrk++;
-  }
-  
-  
-//    cout << " N. of ESD tracks                    : " << ntrk << endl;
-//    cout << " N. of preselected tracks            : " << ngoodtrk << endl;
-//    cout << " Minimum tof time in set (in ns)                 : " << mintime << endl;
-  
-  AliESDtrack **gtracks=new AliESDtrack*[ngoodtrk];
-  
-  for (Int_t jtrk=0; jtrk< ngoodtrk; jtrk++) {
-    AliESDtrack *t=tracks[jtrk];
-    Double_t time=t->GetTOFsignal();
-
-    if((time-mintime*1.E3)<50.E3){ // For pp and per 
-      gtracks[ngoodtrkt0]=t;
-      ngoodtrkt0++;
-    }
-  }
-  
-
-  Int_t nseteq = (ngoodtrkt0-1)/nmaxtracksinset + 1;
-  Int_t nmaxtracksinsetCurrent=ngoodtrkt0/nseteq;
-  if(nmaxtracksinsetCurrent*nseteq < ngoodtrkt0) nmaxtracksinsetCurrent++;
-
-  if(ngoodtrkt0<2){
-//     cout << "less than 2 tracks, skip event " << endl;
-    t0def=-999;
-    deltat0def=0.600;
-    fT0SigmaT0def[0]=t0def;
-    fT0SigmaT0def[1]=deltat0def;
-    fT0SigmaT0def[2]=ngoodtrkt0;
-    fT0SigmaT0def[3]=ngoodtrkt0;
-    //goto finish;
-  }
-  if(ngoodtrkt0>=2){
-  // Decide how many tracks in set 
-    Int_t ntracksinset = std::min(ngoodtrkt0,nmaxtracksinsetCurrent);
-    Int_t nset=1;
-
-    if(ngoodtrkt0>nmaxtracksinsetCurrent) {nset= (Int_t)(ngoodtrkt0/ntracksinset)+1;} 
-        
-    // Loop over selected sets
-    
-    if(nset>=1){
-      for (Int_t i=0; i< nset; i++) {   
-       
-       Float_t t0best=999.;
-       Float_t eT0best=999.;
-       Float_t chisquarebest=99999.;
-       Int_t npionbest=0;
-       
-       Int_t ntracksinsetmy=0;      
-       AliESDtrack **tracksT0=new AliESDtrack*[ntracksinset];
-       for (Int_t itrk=0; itrk<ntracksinset; itrk++) {
-         Int_t index = itrk+i*ntracksinset;
-         if(index < ngoodtrkt0){
-           AliESDtrack *t=gtracks[index];
-           tracksT0[itrk]=t;
-           ntracksinsetmy++;
-         }
-       }
-       
-       // Analyse it
-       
-       Int_t   assparticle[nmaxtracksinset];
-       Float_t exptof[nmaxtracksinset][3];
-       Float_t timeofflight[nmaxtracksinset];
-       Float_t momentum[nmaxtracksinset];
-       Float_t timezero[nmaxtracksinset];
-       Float_t weightedtimezero[nmaxtracksinset];
-       Float_t beta[nmaxtracksinset];
-       Float_t texp[nmaxtracksinset];
-       Float_t dtexp[nmaxtracksinset];
-       Float_t sqMomError[nmaxtracksinset];
-       Float_t sqTrackError[nmaxtracksinset];
-       Float_t massarray[3]={0.13957,0.493677,0.9382723};
-       Float_t tracktoflen[nmaxtracksinset];
-       Float_t besttimezero[nmaxtracksinset];
-       Float_t besttexp[nmaxtracksinset];
-       Float_t besttimeofflight[nmaxtracksinset];
-       Float_t bestmomentum[nmaxtracksinset];
-       Float_t bestchisquare[nmaxtracksinset];
-       Float_t bestweightedtimezero[nmaxtracksinset];
-       Float_t bestsqTrackError[nmaxtracksinset];
-       Int_t imass[nmaxtracksinset];
-       
-       for (Int_t j=0; j<ntracksinset; j++) {
-         assparticle[j] = 3;
-         timeofflight[j] = 0;
-         momentum[j] = 0;
-         timezero[j] = 0;
-         weightedtimezero[j] = 0;
-         beta[j] = 0;
-         texp[j] = 0;
-         dtexp[j] = 0;
-         sqMomError[j] = 0;
-         sqTrackError[j] = 0;
-         tracktoflen[j] = 0;
-         besttimezero[j] = 0;
-         besttexp[j] = 0;
-         besttimeofflight[j] = 0;
-         bestmomentum[j] = 0;
-         bestchisquare[j] = 0;
-         bestweightedtimezero[j] = 0;
-         bestsqTrackError[j] = 0;
-         imass[j] = 1;
-       }
-       
-       for (Int_t j=0; j<ntracksinsetmy; j++) {
-         AliESDtrack *t=tracksT0[j];
-         Double_t momOld=t->GetP();
-         Double_t mom=momOld-0.0036*momOld;
-         Double_t time=t->GetTOFsignal();
-         
-         time*=1.E-3; // tof given in nanoseconds         
-         Double_t exptime[10]; t->GetIntegratedTimes(exptime);
-         Double_t toflen=t->GetIntegratedLength();
-         toflen=toflen/100.; // toflen given in m 
-         
-         timeofflight[j]=time;
-         tracktoflen[j]=toflen;
-         exptof[j][0]=exptime[2]*1.E-3+fTimeCorr;// in ns
-         exptof[j][1]=exptime[3]*1.E-3+fTimeCorr;
-         exptof[j][2]=exptime[4]*1.E-3+fTimeCorr;
-         momentum[j]=mom;
-         assparticle[j]=3;
-         
-       } //end  for (Int_t j=0; j<ntracksinsetmy; j++) {
-       
-       for (Int_t itz=0; itz<ntracksinsetmy;itz++) {
-         beta[itz]=momentum[itz]/sqrt(massarray[0]*massarray[0]
-                                      +momentum[itz]*momentum[itz]);
-         sqMomError[itz]= ((1.-beta[itz]*beta[itz])*0.01)*((1.-beta[itz]*beta[itz])*0.01)*(tracktoflen[itz]/(0.299792*beta[itz]))*(tracktoflen[itz]/(0.299792*beta[itz])); 
-         sqTrackError[itz]=(timeresolutioninns*timeresolutioninns+sqMomError[itz]); //in ns
-         timezero[itz]=exptof[itz][0]-timeofflight[itz];// in ns
-         weightedtimezero[itz]=timezero[itz]/sqTrackError[itz];
-         sumAllweightspi+=1./sqTrackError[itz];
-         meantzeropi+=weightedtimezero[itz];   
-       } // end loop for (Int_t itz=0; itz< ntracksinset;itz++)
-       
-       
-       // Then, Combinatorial Algorithm
-       
-       if(ntracksinsetmy<2 )break;
-       
-       for (Int_t j=0; j<ntracksinsetmy; j++) {
-         imass[j] = 3;
-       }
-       
-       Int_t ncombinatorial = Int_t(TMath::Power(3,ntracksinsetmy));
-       
-       // Loop on mass hypotheses
-       for (Int_t k=0; k < ncombinatorial;k++) {
-         for (Int_t j=0; j<ntracksinsetmy; j++) {
-           imass[j] = (k % Int_t(TMath::Power(3,ntracksinsetmy-j)))/Int_t(TMath::Power(3,ntracksinsetmy-j-1));
-           texp[j]=exptof[j][imass[j]];
-           dtexp[j]=GetMomError(imass[j], momentum[j], texp[j]);
-         }
-         Float_t sumAllweights=0.;
-         Float_t meantzero=0.;
-         Float_t eMeanTzero=0.;
-         
-         for (Int_t itz=0; itz<ntracksinsetmy;itz++) {
-           sqTrackError[itz]=
-             (timeresolutioninns*
-              timeresolutioninns
-              +dtexp[itz]*dtexp[itz]*1E-6); //in ns2
-           
-           timezero[itz]=texp[itz]-timeofflight[itz];// in ns                    
-           
-           weightedtimezero[itz]=timezero[itz]/sqTrackError[itz];
-           sumAllweights+=1./sqTrackError[itz];
-           meantzero+=weightedtimezero[itz];
-           
-         } // end loop for (Int_t itz=0; itz<15;itz++)
-         
-         meantzero=meantzero/sumAllweights; // it is given in [ns]
-         eMeanTzero=sqrt(1./sumAllweights); // it is given in [ns]
-         
-         // calculate chisquare
-         
-         Float_t chisquare=0.;         
-         for (Int_t icsq=0; icsq<ntracksinsetmy;icsq++) {
-           chisquare+=(timezero[icsq]-meantzero)*(timezero[icsq]-meantzero)/sqTrackError[icsq];
-           
-         } // end loop for (Int_t icsq=0; icsq<15;icsq++) 
-         
-         if(chisquare<=chisquarebest){
-           for(Int_t iqsq = 0; iqsq<ntracksinsetmy; iqsq++) {
-             
-             bestsqTrackError[iqsq]=sqTrackError[iqsq]; 
-             besttimezero[iqsq]=timezero[iqsq]; 
-             bestmomentum[iqsq]=momentum[iqsq]; 
-             besttimeofflight[iqsq]=timeofflight[iqsq]; 
-             besttexp[iqsq]=texp[iqsq]; 
-             bestweightedtimezero[iqsq]=weightedtimezero[iqsq]; 
-             bestchisquare[iqsq]=(timezero[iqsq]-meantzero)*(timezero[iqsq]-meantzero)/sqTrackError[iqsq]; 
-           }
-           
-           Int_t npion=0;
-           for (Int_t j=0; j<ntracksinsetmy; j++) {
-             assparticle[j]=imass[j];
-             if(imass[j] == 0) npion++;
-           }
-           npionbest=npion;
-           chisquarebest=chisquare;          
-           t0best=meantzero;
-           eT0best=eMeanTzero;
-         } // close if(dummychisquare<=chisquare)
-         
-       }
-       
-       Double_t chi2cut[nmaxtracksinset];
-       chi2cut[0] = 0;
-       chi2cut[1] = 6.6; // corresponding to a C.L. of 0.01
-       for (Int_t j=2; j<ntracksinset; j++) {
-         chi2cut[j] = chi2cut[1] * TMath::Sqrt(j*1.);
-       }
-       
-       Double_t chi2singlecut = chi2cut[ntracksinsetmy-1]/ntracksinsetmy + TMath::Abs(chisquarebest-chi2cut[ntracksinsetmy-1])/ntracksinsetmy;
-       
-//     printf("tracks removed with a chi2 > %f (chi2total = %f w.r.t. the limit of %f)\n",chi2singlecut,chisquarebest,chi2cut[ntracksinsetmy-1]);
-       
-       Bool_t kRedoT0 = kFALSE;
-        ntracksinsetmyCut = ntracksinsetmy;
-       Bool_t usetrack[nmaxtracksinset];
-       for (Int_t icsq=0; icsq<ntracksinsetmy;icsq++) {
-         usetrack[icsq] = kTRUE;
-         if((bestchisquare[icsq] > chisquarebest*0.5 && ntracksinsetmy > 2) || (bestchisquare[icsq] > chi2singlecut)){
-           kRedoT0 = kTRUE;
-           ntracksinsetmyCut--;
-           usetrack[icsq] = kFALSE;
-         }
-       } // end loop for (Int_t icsq=0; icsq<15;icsq++) 
-       
-       //      printf("ntrackinsetmy = %i - %i\n",ntracksinsetmy,ntracksinsetmyCut);
-       
-       // Loop on mass hypotheses Redo
-       if(kRedoT0 && ntracksinsetmyCut > 1){
-         //      printf("Redo T0\n");
-         for (Int_t k=0; k < ncombinatorial;k++) {
-           for (Int_t j=0; j<ntracksinsetmy; j++) {
-             imass[j] = (k % Int_t(TMath::Power(3,ntracksinsetmy-j))) / Int_t(TMath::Power(3,ntracksinsetmy-j-1));
-             texp[j]=exptof[j][imass[j]];
-             dtexp[j]=GetMomError(imass[j], momentum[j], texp[j]);
-           }
-           
-           Float_t sumAllweights=0.;
-           Float_t meantzero=0.;
-           Float_t eMeanTzero=0.;
-           
-           for (Int_t itz=0; itz<ntracksinsetmy;itz++) {
-             if(! usetrack[itz]) continue;
-             sqTrackError[itz]=
-               (timeresolutioninns*
-                timeresolutioninns
-                +dtexp[itz]*dtexp[itz]*1E-6); //in ns2
-             
-             timezero[itz]=texp[itz]-timeofflight[itz];// in ns                          
-             
-             weightedtimezero[itz]=timezero[itz]/sqTrackError[itz];
-             sumAllweights+=1./sqTrackError[itz];
-             meantzero+=weightedtimezero[itz];
-             
-           } // end loop for (Int_t itz=0; itz<15;itz++)
-           
-           meantzero=meantzero/sumAllweights; // it is given in [ns]
-           eMeanTzero=sqrt(1./sumAllweights); // it is given in [ns]
-           
-           // calculate chisquare
-           
-           Float_t chisquare=0.;               
-           for (Int_t icsq=0; icsq<ntracksinsetmy;icsq++) {
-             if(! usetrack[icsq]) continue;
-             chisquare+=(timezero[icsq]-meantzero)*(timezero[icsq]-meantzero)/sqTrackError[icsq];
-             
-           } // end loop for (Int_t icsq=0; icsq<15;icsq++) 
-           
-           Int_t npion=0;
-           for (Int_t j=0; j<ntracksinsetmy; j++) {
-             assparticle[j]=imass[j];
-             if(imass[j] == 0) npion++;
-           }
-           
-           if(chisquare<=chisquarebest){
-             for(Int_t iqsq = 0; iqsq<ntracksinsetmy; iqsq++) {
-               if(! usetrack[iqsq]) continue;
-               bestsqTrackError[iqsq]=sqTrackError[iqsq]; 
-               besttimezero[iqsq]=timezero[iqsq]; 
-               bestmomentum[iqsq]=momentum[iqsq]; 
-               besttimeofflight[iqsq]=timeofflight[iqsq]; 
-               besttexp[iqsq]=texp[iqsq]; 
-               bestweightedtimezero[iqsq]=weightedtimezero[iqsq]; 
-               bestchisquare[iqsq]=(timezero[iqsq]-meantzero)*(timezero[iqsq]-meantzero)/sqTrackError[iqsq]; 
-             }
-             
-             npionbest=npion;
-             chisquarebest=chisquare;        
-             t0best=meantzero;
-             eT0best=eMeanTzero;
-           } // close if(dummychisquare<=chisquare)
-           
-         }
-       }
-               
-       // filling histos
-       Float_t confLevel=999;
-       
-       // Sets with decent chisquares
-       
-       if(chisquarebest<999.){
-         Double_t dblechisquare=(Double_t)chisquarebest;
-         confLevel=(Float_t)TMath::Prob(dblechisquare,ntracksinsetmyCut-1); 
-//       cout << " Set Number " << nsets << endl;      
-//       cout << "Best Assignment, selection " << assparticle[0] << 
-//         assparticle[1] << assparticle[2] << 
-//         assparticle[3] << assparticle[4] << 
-//         assparticle[5] << endl;
-//       cout << " Chisquare of the set "<< chisquarebest <<endl;
-//       cout << " C.L. of the set "<< confLevel <<endl;
-//       cout << " T0 for this set (in ns)  " << t0best << endl;
-
-         for(Int_t icsq=0; icsq<ntracksinsetmy;icsq++){
-
-           if(! usetrack[icsq]) continue;
-           
-//         cout << "Track # " << icsq  << " T0 offsets = " 
-//              << besttimezero[icsq]-t0best << 
-//           " track error = "  << bestsqTrackError[icsq]
-//              << " Chisquare = " << bestchisquare[icsq] 
-//              << " Momentum  = " << bestmomentum[icsq] 
-//              << " TOF   = "     << besttimeofflight[icsq] 
-//              << " TOF tracking  = " << besttexp[icsq]
-//              << " is used = " << usetrack[icsq] << endl;
-         }
-         
-         // Pick up only those with C.L. >1%
-         //      if(confLevel>0.01 && ngoodsetsSel<200){
-         if(confLevel>0.01 && ngoodsetsSel<200){
-           chiSquarebestSel[ngoodsetsSel]=chisquarebest;
-           confLevelbestSel[ngoodsetsSel]=confLevel;
-           t0bestSel[ngoodsetsSel]=t0best/eT0best/eT0best;
-           eT0bestSel[ngoodsetsSel]=1./eT0best/eT0best;
-           t0bestallSel += t0best/eT0best/eT0best;
-           sumWt0bestallSel += 1./eT0best/eT0best;
-           ngoodsetsSel++;
-           ngoodtrktrulyused+=ntracksinsetmyCut;           
-         }
-         else{
-           //      printf("conflevel = %f -- ngoodsetsSel = %i -- ntrackset = %i\n",confLevel,ngoodsetsSel,ntracksinsetmy);
-         }
-       }       
-       delete[] tracksT0;
-       nsets++;
-       
-      } // end for the current set
-      
-      nUsedTracks =  ngoodtrkt0;  
-      if(strstr(option,"all")){
-       if(sumAllweightspi>0.){
-         meantzeropi=meantzeropi/sumAllweightspi; // it is given in [ns]
-         eMeanTzeroPi=sqrt(1./sumAllweightspi); // it is given in [ns]
-       }      
-       
-       if(sumWt0bestallSel>0){
-         t0bestallSel  = t0bestallSel/sumWt0bestallSel;
-         eT0bestallSel = sqrt(1./sumWt0bestallSel);
-         
-       }// end of if(sumWt0bestallSel>0){
-       
-//     cout << "T0 all " << t0bestallSel << " +/- " << eT0bestallSel << "Number of tracks used: "<<ngoodtrktrulyused<<endl;
-      }
-      
-      t0def=t0bestallSel;
-      deltat0def=eT0bestallSel;
-      if ((TMath::Abs(t0bestallSel) < 0.001)&&(TMath::Abs(eT0bestallSel)<0.001)){
-       t0def=-999; deltat0def=0.600;
-      }
-      
-      fT0SigmaT0def[0]=t0def;
-      fT0SigmaT0def[1]=TMath::Sqrt(deltat0def*deltat0def);//*ngoodtrktrulyused/(ngoodtrktrulyused-1));
-      fT0SigmaT0def[2]=ngoodtrkt0;
-      fT0SigmaT0def[3]=ngoodtrktrulyused;
-    }
-  }
-  
-  //   if(strstr(option,"tim") || strstr(option,"all")){
-  //     cout << "AliTOFT0v2:" << endl ;
-  //}
-  
-  return fT0SigmaT0def;
-  }
-//__________________________________________________________________
-Float_t AliTOFT0v2::GetMomError(Int_t index, Float_t mom, Float_t texp) const
-{
-  // Take the error extimate for the TOF time in the track reconstruction
-
-  static const Double_t kMasses[]={
-    0.000511, 0.105658, 0.139570, 0.493677, 0.938272, 1.875613
-  };
-
-  Double_t mass=kMasses[index+2];
-  Double_t dpp=0.01;      //mean relative pt resolution;
-  if(mom > 1) dpp = 0.01*mom;
-  Double_t sigma=dpp*texp*1E3/(1.+ mom*mom/(mass*mass));
-
-  sigma =TMath::Sqrt(sigma*sigma);
-
-  return sigma;
-}
-
-//__________________________________________________________________
-Bool_t AliTOFT0v2::AcceptTrack(AliESDtrack *track)
-{
-
-  /* TPC refit */
-  if (!(track->GetStatus() & AliESDtrack::kTPCrefit)) return kFALSE;
-  /* do not accept kink daughters */
-  if (track->GetKinkIndex(0)>0) return kFALSE;
-  /* N clusters TPC */
-  if (track->GetTPCclusters(0) < 50) return kFALSE;
-  /* chi2 TPC */
-  if (track->GetTPCchi2()/Float_t(track->GetTPCclusters(0)) > 3.5) return kFALSE;
-  /* sigma to vertex */
-  if (GetSigmaToVertex(track) > 4.) return kFALSE;
-  
-  /* accept track */
-  return kTRUE;
-
-}
-
-//____________________________________________________________________
-Float_t AliTOFT0v2::GetSigmaToVertex(AliESDtrack* esdTrack) const
-{
-  // Calculates the number of sigma to the vertex.
-
-  Float_t b[2];
-  Float_t bRes[2];
-  Float_t bCov[3];
-  esdTrack->GetImpactParameters(b,bCov);
-  
-  if (bCov[0]<=0 || bCov[2]<=0) {
-    bCov[0]=0; bCov[2]=0;
-  }
-  bRes[0] = TMath::Sqrt(bCov[0]);
-  bRes[1] = TMath::Sqrt(bCov[2]);
-
-  // -----------------------------------
-  // How to get to a n-sigma cut?
-  //
-  // The accumulated statistics from 0 to d is
-  //
-  // ->  Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
-  // ->  1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
-  //
-  // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-d**2)/2)
-  // Can this be expressed in a different way?
-
-  if (bRes[0] == 0 || bRes[1] ==0)
-    return -1;
-
-  Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
-
-  // work around precision problem
-  // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
-  // 1e-15 corresponds to nsigma ~ 7.7
-  if (TMath::Exp(-d * d / 2) < 1e-15)
-    return 1000;
-
-  Float_t nSigma = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
-  return nSigma;
-}
diff --git a/ANALYSIS/TenderSupplies/AliTOFT0v2.h b/ANALYSIS/TenderSupplies/AliTOFT0v2.h
deleted file mode 100644 (file)
index 15bc073..0000000
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef ALITOFT0V2_H
-#define ALITOFT0V2_H
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-//----------------------------------------------------------------------------//
-//                                                                            //
-//   Description: class to performe an event time measurment with TOF.        //
-//                                                                            //
-//----------------------------------------------------------------------------//
-
-#include "TObject.h"
-
-class AliESDtrack;
-/* class AliTOFcalibHisto; */
-class AliESDEvent;
-
-class AliTOFT0v2: public TObject {
-public:
-  
-  AliTOFT0v2() ;
-  AliTOFT0v2(const AliTOFT0v2 & tzero);
-  AliTOFT0v2 & operator=(const AliTOFT0v2 & tzero) ;
-  AliTOFT0v2(AliESDEvent *event);
-  virtual ~AliTOFT0v2() ; // dtor
-  //  void SetCalib(AliTOFcalibHisto * const calib){fCalib = calib;};
-
-  Double_t* DefineT0(Option_t *option); 
-  
-  void      SetTimeResolution(Double_t timeresolution);// timeresolution in [s] e.g. for 120 ps -> 1.2e-10
-  
-  Double_t GetTimeResolution() const {return fTimeResolution;}
-  
-  void          SetMomBounds(Float_t pLow, Float_t pUp) { fLowerMomBound=pLow; fUpperMomBound=pUp;} // momenta are expressed in [GeV/c]
-  void          SetTimeCorr(Float_t timecorr) {fTimeCorr=timecorr;} //in ns!!!
-  Float_t       GetMomError(Int_t index, Float_t mom, Float_t texp) const;
-/*   void  Print(Option_t* option) const ; */
-
- private:
-
-  Bool_t AcceptTrack(AliESDtrack *track); /* accept track */
-  Float_t GetSigmaToVertex(AliESDtrack *track) const; /* get sigma to vertex */
-
-
-  Float_t fLowerMomBound;   // momentum lower bound for selected primary tracks   
-  Float_t fUpperMomBound;   // momentum upper bound for selected primary tracks 
-  Double_t fTimeResolution;  // global time resolution used to calculate T0
-  Float_t fTimeCorr;  // global time resolution used to calculate T0
-  AliESDEvent* fEvent;      //evento per il quale si vuole calcolare il T0
-/*   AliTOFcalibHisto *fCalib; // pointer to the class with the TOF time corrections */
-
-  Double_t fT0SigmaT0def[4]; // array with the event information ([0]=event time -- [1] = sigma -- [2] = tracks on the TOF -- [3] = tracks used for the event time)
-  
-  ClassDef(AliTOFT0v2,2);  // Calculate the time zero using TOF detector */
-  
-};
-
-#endif 
diff --git a/ANALYSIS/TenderSupplies/AliTOFTenderSupply.cxx b/ANALYSIS/TenderSupplies/AliTOFTenderSupply.cxx
deleted file mode 100644 (file)
index 5310ece..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-// TOF tender: reapply TOF pid on the fly                                    //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
-
-#include <AliLog.h>
-#include <AliESDEvent.h>
-#include <AliESDInputHandler.h>
-#include <AliAnalysisManager.h>
-#include <AliESDpid.h>
-#include <AliTender.h>
-
-#include "AliTOFcalibESD.h"
-#include "AliTOFT0makerANA.h"
-
-#include "AliTOFTenderSupply.h"
-
-
-AliTOFTenderSupply::AliTOFTenderSupply() :
-  AliTenderSupply(),
-  fESDpid(0x0),
-  fTOFesdCalib(0x0),
-  fTOFT0maker(0x0),
-  fTOFres(130.)
-{
-  //
-  // default ctor
-  //
-}
-
-//_____________________________________________________
-AliTOFTenderSupply::AliTOFTenderSupply(const char *name, const AliTender *tender) :
-  AliTenderSupply(name,tender),
-  fESDpid(0x0),
-  fTOFesdCalib(0x0),
-  fTOFT0maker(0x0),
-  fTOFres(130.)
-{
-  //
-  // named ctor
-  //
-}
-
-//_____________________________________________________
-void AliTOFTenderSupply::Init()
-{
-  //
-  // Initialise TOF tender
-  //
-
-
-  //
-  // Setup PID object
-  //
-
-  // Check if another detector already created the esd pid object
-  // if not we create it and set it to the ESD input handler
-  fESDpid=fTender->GetESDhandler()->GetESDpid();
-  if (!fESDpid) {
-    fESDpid=new AliESDpid;
-    fTender->GetESDhandler()->SetESDpid(fESDpid);
-  }
-
-  //Set proper resolution in case of MC
-  AliAnalysisManager *mgr=AliAnalysisManager::GetAnalysisManager();
-  if (mgr->GetMCtruthEventHandler())   fESDpid->GetTOFResponse().SetTimeResolution(80.);
-  
-  
-  //
-  // Create TOF calibration classes
-  //
-  if (!fTOFesdCalib) fTOFesdCalib=new AliTOFcalibESD;
-  if (!fTOFT0maker) {
-    fTOFT0maker = new AliTOFT0makerANA(fESDpid);
-    fTOFT0maker->SetTimeResolution(fTOFres); // set TOF resolution for the PID 
-  }
-}
-
-//_____________________________________________________
-void AliTOFTenderSupply::ProcessEvent()
-{
-  //
-  // Reapply pid information
-  //
-
-  //no corrections for MC
-  AliAnalysisManager *mgr=AliAnalysisManager::GetAnalysisManager();
-  if (mgr->GetMCtruthEventHandler()) return;
-
-  AliESDEvent *event=fTender->GetEvent();
-  if (!event) return;
-
-  //recalculate TOF signal
-  if (fTender->RunChanged()){
-    fTOFesdCalib->Init(fTender->GetRun());
-  }
-  fTOFesdCalib->CalibrateESD(event);
-  
-  //Calculate event time zero
-  Double_t* calcolot0;
-  calcolot0=fTOFT0maker->RemakePID(event); // calculate T0-TOF(T0-FILL) and
-  Double_t t0best=calcolot0[0];  // T0-Event = (T0-TOF .OR. T0-FILL) <- This is what you asked me
-  event->SetT0(t0best);
-  
-  //
-  // recalculate PID probabilities
-  //
-  
-  Int_t ntracks=event->GetNumberOfTracks();
-  for(Int_t itrack = 0; itrack < ntracks; itrack++){
-    fESDpid->MakeTOFPID(event->GetTrack(itrack),0);
-  }
-  
-}
diff --git a/ANALYSIS/TenderSupplies/AliTOFTenderSupply.h b/ANALYSIS/TenderSupplies/AliTOFTenderSupply.h
deleted file mode 100644 (file)
index d81ddca..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef ALITOFTENDERSUPPLY_H
-#define ALITOFTENDERSUPPLY_H
-
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-////////////////////////////////////////////////////////////////////////
-//                                                                    //
-//  TPC tender, reapply pid on the fly                                //
-//                                                                    //
-////////////////////////////////////////////////////////////////////////
-
-
-
-#include <AliTenderSupply.h>
-
-class AliESDpid;
-class AliTOFcalibESD;
-class AliTOFT0makerANA;
-
-class AliTOFTenderSupply: public AliTenderSupply {
-  
-public:
-  AliTOFTenderSupply();
-  AliTOFTenderSupply(const char *name, const AliTender *tender=NULL);
-  
-  virtual ~AliTOFTenderSupply(){;}
-  
-  virtual void              Init();
-  virtual void              ProcessEvent();
-
-  // TOF method
-  void SetTOFres(Float_t res){fTOFres=res;}
-  
-private:
-  AliESDpid          *fESDpid;         //! ESD pid object
-  
-  // variables for TOF calibrations
-  AliTOFcalibESD     *fTOFesdCalib;    //! recalibrate TOF signal with OCDB
-  AliTOFT0makerANA   *fTOFT0maker;     //! TOF maker objects (apply all the correction for T0)
-
-  Float_t fTOFres;                   // TOF resolution
-  
-  AliTOFTenderSupply(const AliTOFTenderSupply&c);
-  AliTOFTenderSupply& operator= (const AliTOFTenderSupply&c);
-  
-  ClassDef(AliTOFTenderSupply, 1);  // TPC tender task
-};
-
-
-#endif
-
diff --git a/ANALYSIS/TenderSupplies/AliTOFcalibESD.cxx b/ANALYSIS/TenderSupplies/AliTOFcalibESD.cxx
deleted file mode 100644 (file)
index fddb474..0000000
+++ /dev/null
@@ -1,167 +0,0 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-////////////////////////////////////////////////////////////////////
-//                                                                //
-// recalculate the TOF signal from the TOF raw signal             //
-// using the updates in the OCDB                                  //
-//                                                                //
-////////////////////////////////////////////////////////////////////
-
-#include "AliTOFChannelOnlineStatusArray.h"
-#include "TObjArray.h"
-#include "AliTOFDeltaBCOffset.h"
-#include "AliTOFCTPLatency.h"
-#include "AliTOFRunParams.h"
-#include "AliESDEvent.h"
-#include "AliESDtrack.h"
-#include "AliCDBManager.h"
-#include "AliCDBEntry.h"
-#include "AliTOFChannelOffline.h"
-#include "AliTOFGeometry.h"
-
-#include "AliTOFcalibESD.h"
-
-ClassImp(AliTOFcalibESD)
-
-//______________________________________________________________-
-
-AliTOFcalibESD::AliTOFcalibESD() :
-  TObject(),
-  fInitFlag(kFALSE),
-  fChannelStatusArray(NULL),
-  fParOfflineArray(NULL),
-  fDeltaBCOffsetObj(NULL),
-  fCTPLatencyObj(NULL),
-  fRunParamsObj(NULL),
-  fTimeZero(0),
-  fTOFResolution(130)
-{
-  /*
-   * default constructor
-   */
-}
-
-//______________________________________________________________-
-
-AliTOFcalibESD::~AliTOFcalibESD()
-{
-  /*
-   * default destructor
-   */
-}
-
-//______________________________________________________________-
-
-Bool_t
-AliTOFcalibESD::Init(Int_t run)
-{
-  /*
-   * init
-   */
-
-  /* get cdb instance */
-  AliCDBManager *cdb = AliCDBManager::Instance();
-  AliCDBEntry *entry = NULL;
-
-  /* get channel status array */
-  entry = cdb->Get("TOF/Calib/Status", run);
-  if (!entry || !entry->GetObject()) return kFALSE;
-  fChannelStatusArray = (AliTOFChannelOnlineStatusArray *)entry->GetObject();
-  /* get par offline array */
-  entry = cdb->Get("TOF/Calib/ParOffline", run);
-  if (!entry || !entry->GetObject()) return kFALSE;
-  fParOfflineArray = (TObjArray *)entry->GetObject();
-  /* get deltaBC offset obj */
-  entry = cdb->Get("TOF/Calib/DeltaBCOffset", run);
-  if (!entry || !entry->GetObject()) return kFALSE;
-  fDeltaBCOffsetObj = (AliTOFDeltaBCOffset *)entry->GetObject();
-  /* get CTP latency obj */
-  entry = cdb->Get("TOF/Calib/CTPLatency", run);
-  if (!entry || !entry->GetObject()) return kFALSE;
-  fCTPLatencyObj = (AliTOFCTPLatency *)entry->GetObject();
-  /* get run params obj */
-  entry = cdb->Get("TOF/Calib/RunParams", run);
-  if (!entry || !entry->GetObject()) return kFALSE;
-  fRunParamsObj = (AliTOFRunParams *)entry->GetObject();
-
-  /* all done */
-  fInitFlag = kTRUE;
-  return kTRUE;
-}
-
-//______________________________________________________________-
-
-void
-AliTOFcalibESD::CalibrateESD(AliESDEvent *event)
-{
-  /*
-   * calibrate ESD
-   */
-  
-  /* get global calibration params */
-  AliTOFChannelOffline *parOffline = NULL;
-//   Int_t deltaBCOffset = fDeltaBCOffsetObj->GetDeltaBCOffset();  //see below
-  Float_t ctpLatency = fCTPLatencyObj->GetCTPLatency();
-  Float_t tdcLatencyWindow;
-  Float_t timezero = fRunParamsObj->EvalT0(event->GetTimeStamp());
-  fTimeZero=timezero;
-  fTOFResolution=fRunParamsObj->EvalTOFResolution(event->GetTimeStamp());
-  
-  /* loop over tracks */
-  AliESDtrack *track = NULL;
-  Int_t index, l0l1, deltaBC;
-  Double_t time, tot;
-  for (Int_t itrk = 0; itrk < event->GetNumberOfTracks(); itrk++) {
-
-    /* get track */
-    track = event->GetTrack(itrk);
-    if (!track || !(track->GetStatus() & AliESDtrack::kTOFout)) continue;
-    
-    /* get info */
-    index = track->GetTOFCalChannel();
-    time = track->GetTOFsignalRaw();
-    tot = track->GetTOFsignalToT();
-    l0l1 = track->GetTOFL0L1();
-    deltaBC = track->GetTOFDeltaBC();
-    
-    /* get channel dependent calibration params */
-    parOffline = (AliTOFChannelOffline *)fParOfflineArray->At(index);
-    tdcLatencyWindow = fChannelStatusArray->GetLatencyWindow(index) * 1.e3;
-    
-    /* deltaBC correction (inhibited for the time being) */
-    //  time -= (deltaBC - deltaBCOffset) * AliTOFGeometry::BunchCrossingBinWidth();
-    /* L0-L1 latency correction */
-    time += l0l1 * AliTOFGeometry::BunchCrossingBinWidth();
-    /* CTP latency correction */
-    time += ctpLatency;
-    /* TDC latency window correction */
-    time -= tdcLatencyWindow;
-    /* time-zero correction */
-    time -= timezero;
-    /* time calibration correction */
-    if (tot < AliTOFGeometry::SlewTOTMin()) 
-      tot = AliTOFGeometry::SlewTOTMin();
-    if (tot > AliTOFGeometry::SlewTOTMax()) 
-      tot = AliTOFGeometry::SlewTOTMax();
-    for (Int_t islew = 0; islew < 6; islew++)
-      time -= parOffline->GetSlewPar(islew) * TMath::Power(tot, islew) * 1.e3;
-    
-    /* set new TOF signal */
-    track->SetTOFsignal(time);
-
-  }
-
-}
diff --git a/ANALYSIS/TenderSupplies/AliTOFcalibESD.h b/ANALYSIS/TenderSupplies/AliTOFcalibESD.h
deleted file mode 100644 (file)
index 65f47a4..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef ALITOFCALIBESD_H
-#define ALITOFCALIBESD_H
-
-
-////////////////////////////////////////////////////////////////////
-//                                                                //
-// recalculate the TOF signal from the TOF raw signal             //
-// using the updates in the OCDB                                  //
-//                                                                //
-////////////////////////////////////////////////////////////////////
-
-#include "TObject.h"
-
-class AliTOFChannelOnlineStatusArray;
-class TObjArray;
-class AliTOFDeltaBCOffset;
-class AliTOFCTPLatency;
-class AliTOFRunParams;
-class AliESDEvent;
-
-class AliTOFcalibESD :
-public TObject
-{
-
- public:
-
-  AliTOFcalibESD(); // default constructor
-  virtual ~AliTOFcalibESD(); // default destructor
-
-  Bool_t Init(Int_t run = -1); // init
-  void CalibrateESD(AliESDEvent *event); // calibrate ESD
-
-  Float_t GetTimeZero() const {return fTimeZero;}
-  Float_t GetTOFResolution() const {return fTOFResolution;}
- private:
-
-  AliTOFcalibESD(const AliTOFcalibESD &); // copy constructor
-  AliTOFcalibESD &operator=(const AliTOFcalibESD &); // operator=
-
-  Bool_t fInitFlag; //! init flag
-  AliTOFChannelOnlineStatusArray *fChannelStatusArray; //! channel status array
-  TObjArray *fParOfflineArray;            //! par offline array
-  AliTOFDeltaBCOffset *fDeltaBCOffsetObj; //! deltaBC offset object
-  AliTOFCTPLatency *fCTPLatencyObj;       //! CTP latency object
-  AliTOFRunParams *fRunParamsObj;         //! run params object
-  Float_t fTimeZero;                      //! TOF Time0
-  Float_t fTOFResolution;                 //! TOF Time0
-  
-  ClassDef(AliTOFcalibESD, 1);
-};
-
-#endif /* ALITOFCALIBESD_H */
index 387133e..079b2b9 100644 (file)
@@ -6,9 +6,6 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class AliTOFcalibESD+;
-#pragma link C++ class AliTOFT0makerANA+;
-#pragma link C++ class AliTOFT0v2+;
 #pragma link C++ class AliPIDTenderSupply+;
 #pragma link C++ class AliTOFTenderSupply+;
 #pragma link C++ class AliTPCTenderSupply+;
index 411e646..444f6ef 100644 (file)
@@ -1,10 +1,7 @@
 #-*- Mode: Makefile -*-
 
-SRCS= TenderSupplies/AliTOFcalibESD.cxx \
-      TenderSupplies/AliTOFT0makerANA.cxx \
-      TenderSupplies/AliTOFT0v2.cxx \
+SRCS= TenderSupplies/AliTOFTenderSupply.cxx \
       TenderSupplies/AliPIDTenderSupply.cxx \
-      TenderSupplies/AliTOFTenderSupply.cxx \
       TenderSupplies/AliTPCTenderSupply.cxx \
       TenderSupplies/AliTRDTenderSupply.cxx \
       TenderSupplies/AliVtxTenderSupply.cxx \