Adding TOF calib task for calibration of problematic channels
authorzampolli <chiara.zampolli@cern.ch>
Thu, 16 Oct 2014 13:33:52 +0000 (15:33 +0200)
committerzampolli <chiara.zampolli@cern.ch>
Thu, 16 Oct 2014 13:34:07 +0000 (15:34 +0200)
TOF/AddTOFAnalysisTaskCalibTree.C [new file with mode: 0644]
TOF/AliTOFAnalysisTaskCalibTree.cxx [new file with mode: 0644]
TOF/AliTOFAnalysisTaskCalibTree.h [new file with mode: 0644]
TOF/CMakelibTOFcalib.pkg
TOF/TOFcalibLinkDef.h

diff --git a/TOF/AddTOFAnalysisTaskCalibTree.C b/TOF/AddTOFAnalysisTaskCalibTree.C
new file mode 100644 (file)
index 0000000..7416193
--- /dev/null
@@ -0,0 +1,88 @@
+AliTOFAnalysisTaskCalibTree *AddTOFAnalysisTaskCalibTree()
+{
+
+  // check analysis manager 
+  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+  if (!mgr) {
+    Error("AddTOFAnalysisTaskCalibTree", "cannot get analysis manager");
+    return NULL;
+  }
+
+  //check input event handler
+  if (!mgr->GetInputEventHandler()) {
+    Error("AddTOFAnalysisTaskCalibTree", "cannot get input event handler");
+    return NULL;
+  }
+  
+  // check input data type 
+  TString str = mgr->GetInputEventHandler()->GetDataType();
+  if (str.CompareTo("ESD")) {
+    Error("AddTOFAnalysisTaskCalibTree", "input data type is not \"ESD\"");
+    return NULL;
+  }
+
+  // get common input data container
+  AliAnalysisDataContainer *inputc = mgr->GetCommonInputContainer();
+  if (!inputc) {
+    Error("AddTOFAnalysisTaskCalibTree", "cannot get common input container");
+    return NULL;
+  }
+  
+  // setup output event handler
+  AliAODHandler *outputh = (AliAODHandler *)mgr->GetOutputEventHandler();
+  outputh->SetCreateNonStandardAOD();
+  outputh->SetOutputFileName("TOFcalibTree.root");
+
+  //  create task and connect input/output 
+  AliTOFAnalysisTaskCalibTree *task = new AliTOFAnalysisTaskCalibTree();
+  mgr->ConnectInput(task, 0, inputc);
+
+  // setup task 
+  task->SetEventSelectionFlag(kFALSE);
+  task->SetVertexSelectionFlag(kTRUE);
+  task->SetVertexCut(50.0);
+  task->SetDiscardPileupEventFlag(kFALSE);
+  task->SetPrimaryDCASelectionFlag(kFALSE);
+  task->SetCalibrateTOFsignal(kTRUE);
+  task->SetComputeT0TOF(kTRUE);
+  task->SetUseT0TOF(kFALSE);
+  task->SetUseLHCClockPhase(kFALSE);
+  //  task->SetSpecificStorageParOffline("alien://?folder=/alice/cern.ch/user/r/rpreghen/OCDB");
+  //  task->SetSpecificStorageRunParams("alien://?folder=/alice/cern.ch/user/r/rpreghen/OCDB");
+
+  // setup event cuts 
+  task->GetEventCuts()->SetAnalyzeMC(kFALSE);
+
+  // setup TOF calib 
+  task->GetTOFcalib()->SetRemoveMeanT0(kFALSE);
+  task->GetTOFcalib()->SetCalibrateTOFsignal(kTRUE);
+  task->GetTOFcalib()->SetCorrectTExp(kFALSE);
+
+  //setup resolution 
+  Double_t timeReso = 100.;
+
+  // setup TOF response 
+  //task->GetESDpid()->GetTOFResponse().SetTimeResolution(timeReso);
+
+  // setup TOF-T0 maker 
+  task->GetTOFT0maker()->SetTimeResolution(timeReso);
+
+  // setup track cuts 
+  AliESDtrackCuts *trackCuts = task->GetTrackCuts();
+  trackCuts->SetPtRange(0.15, 10.);
+  trackCuts->SetEtaRange(-1.0, 1.0);
+  trackCuts->SetRequireITSRefit(kTRUE);
+  trackCuts->SetMinNClustersITS(1);
+  //  trackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
+  trackCuts->SetRequireTPCRefit(kTRUE);
+  trackCuts->SetMinNClustersTPC(70);
+  trackCuts->SetMaxChi2PerClusterTPC(4.);
+  trackCuts->SetAcceptKinkDaughters(kFALSE);
+  trackCuts->SetMaxDCAToVertexZ(3.2);
+  trackCuts->SetMaxDCAToVertexXY(2.4);
+  trackCuts->SetDCAToVertex2D(kTRUE);
+
+  // return task 
+  return task;
+
+}
diff --git a/TOF/AliTOFAnalysisTaskCalibTree.cxx b/TOF/AliTOFAnalysisTaskCalibTree.cxx
new file mode 100644 (file)
index 0000000..e8c7224
--- /dev/null
@@ -0,0 +1,340 @@
+#include "AliTOFAnalysisTaskCalibTree.h"
+#include "AliAnalysisManager.h"
+#include "AliAODHandler.h"
+#include "TTree.h"
+#include "AliCDBManager.h"
+#include "AliGRPManager.h"
+#include "AliGRPObject.h"
+#include "AliPhysicsSelection.h"
+#include "AliESDtrack.h"
+#include "AliESDEvent.h"
+#include "AliESDpid.h"
+#include "AliESDtrackCuts.h"
+#include "AliTOFT0v1.h"
+#include "AliTOFT0maker.h"
+#include "AliTOFcalib.h"
+
+ClassImp(AliTOFAnalysisTaskCalibTree)
+  
+//_______________________________________________________
+  
+AliTOFAnalysisTaskCalibTree::AliTOFAnalysisTaskCalibTree(const Char_t* name) :
+AliAnalysisTaskSE(name),
+  fInitFlag(kFALSE),                   
+  fEventSelectionFlag(kFALSE),        
+  fVertexSelectionFlag(kFALSE),       
+  fVertexCut(1000.),              
+  fDiscardPileupEventFlag(kFALSE),   
+  fCalibrateTOFsignal(kFALSE),       
+  fComputeT0TOF(kFALSE),             
+  fUseT0TOF(kFALSE),                 
+  fUseLHCClockPhase(kFALSE),         
+  fPrimaryDCASelectionFlag(kFALSE),  
+  fRunNumber(0),                   
+  fESDEvent(0),             
+  fEventCuts(new AliPhysicsSelection()),    
+  fTrackCuts(new AliESDtrackCuts()),  
+  fESDpid(new AliESDpid()),
+  fStartTime(0),
+  fEndTime(0),
+  fElapsedTime(0),
+  fIsCollisionCandidate(kFALSE),
+  fHasVertex(kFALSE),
+  fVertex(NULL),
+  fGRPManager(new AliGRPManager()),         
+  fGRPObject(NULL),     
+  fSpecificStorageParOffline(), 
+  fSpecificStorageRunParams(),  
+  fTimeResolution(80.),
+  fTOFcalib(new AliTOFcalib()),             
+  fTOFT0maker(new AliTOFT0maker(fESDpid, fTOFcalib)),         
+  fTOFT0v1(new AliTOFT0v1(fESDpid))             
+
+{
+  /* 
+   * default constructor 
+   */
+
+}
+
+//_______________________________________________________
+
+AliTOFAnalysisTaskCalibTree::~AliTOFAnalysisTaskCalibTree()
+{
+  /*
+   * default destructor
+   */
+  delete fEventCuts;
+  delete fTrackCuts;
+  delete fESDpid;
+  delete fTOFcalib;
+  delete fTOFT0maker;
+  delete fTOFT0v1;
+
+}
+
+//_______________________________________________________
+
+void
+AliTOFAnalysisTaskCalibTree::UserCreateOutputObjects()
+{
+  /*
+   * user create output objects
+   */
+
+  /* setup output tree */
+  OutputTree()->Branch("run", &fRunNumber, "run/I");
+  OutputTree()->Branch("timestamp", &ftimestamp, "timestamp/i");
+  OutputTree()->Branch("timezero", &ftimezero, "timezero/F");
+  OutputTree()->Branch("vertex", &fVertexZ, "vertex/F");
+  OutputTree()->Branch("nhits", &fnhits, "nhits/I");
+  OutputTree()->Branch("momentum", &fmomentum, "momentum[nhits]/F");
+  OutputTree()->Branch("length", &flength, "length[nhits]/F");
+  OutputTree()->Branch("index", &findex, "index[nhits]/I");
+  OutputTree()->Branch("time", &ftime, "time[nhits]/F");
+  OutputTree()->Branch("tot", &ftot, "tot[nhits]/F");
+  OutputTree()->Branch("texp", &ftexp, "texp[nhits]/F");
+
+}
+
+//_______________________________________________________
+
+void AliTOFAnalysisTaskCalibTree::UserExec(Option_t *option) {
+  //
+  // user exec
+  //
+
+  // unset fill AOD
+  ((AliAODHandler*)(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()))->SetFillAOD(kFALSE);
+
+  //init run
+  if (!InitRun()) return;
+
+  //init event 
+  if (!InitEvent()) return;
+
+  /*** ACCEPTED EVENT ***/
+  
+  // set vertex
+  fVertexZ = fVertex->GetZ();
+
+  // compute T0-TOF using all availeble tracks 
+  fTOFT0v1->DefineT0("all", 0.0, 0.5);
+  Float_t timeZeroTOF = -1000. * fTOFT0v1->GetResult(0);
+  Float_t timeZeroTOF_sigma = 1000. * fTOFT0v1->GetResult(1);
+  Int_t timeZeroTOF_tracks = fTOFT0v1->GetResult(3);
+
+  // check T0-TOF sigma 
+  if (timeZeroTOF_sigma >= 250.) ftimezero = 999999.; 
+  else ftimezero = timeZeroTOF;
+
+  // reset
+  fnhits = 0;
+  
+  // loop over ESD tracks
+  Int_t nTracks = fESDEvent->GetNumberOfTracks();
+  AliESDtrack *track;
+  Int_t index;
+  Double_t momentum, length, time, tot, timei[AliPID::kSPECIES];
+  for (Int_t itrk = 0; itrk < nTracks; itrk++) {
+    // get track
+    track = fESDEvent->GetTrack(itrk);
+    if (!track) continue;
+    // check accept track
+    if (!fTrackCuts->AcceptTrack(track)) continue;
+    // check primary DCA
+    if (fPrimaryDCASelectionFlag && !HasPrimaryDCA(track)) continue;
+    // check TOF measurement
+    if (!HasTOFMeasurement(track)) continue;
+
+    /*** ACCEPTED TRACK WITH TOF MEASUREMENT ***/
+
+    // get track info 
+    momentum = track->P();
+    length = track->GetIntegratedLength();
+    index = track->GetTOFCalChannel();
+    time = track->GetTOFsignal();
+    tot = track->GetTOFsignalToT();
+    track->GetIntegratedTimes(timei);
+
+    // add hit to array (if there is room)
+    if (fnhits > MAXHITS) continue;
+    fmomentum[fnhits] = momentum;
+    flength[fnhits] = length;
+    findex[fnhits] = index;
+    ftime[fnhits] = time;
+    ftot[fnhits] = tot;
+    ftexp[fnhits] = timei[AliPID::kPion];
+    fnhits++;
+
+  } /* end of loop over ESD tracks */
+
+  // check number of hits and set fill output tree
+  if (fnhits > 0)
+    ((AliAODHandler*)(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()))->SetFillAOD(kTRUE);
+
+}
+
+//_______________________________________________________
+
+Bool_t AliTOFAnalysisTaskCalibTree::InitRun() {
+
+  //
+  // init run
+  //
+  
+  // get ESD event 
+  fESDEvent = dynamic_cast<AliESDEvent *>(InputEvent());
+  if (!fESDEvent) {
+    AliError("cannot get ESD event");
+    return kFALSE;
+  }
+
+  // get run number 
+  Int_t runNb = fESDEvent->GetRunNumber();
+
+  // check run already initialized 
+  if (fInitFlag && fRunNumber == runNb) return kTRUE;
+  fInitFlag = kFALSE;
+
+  // init cdb 
+  AliCDBManager *cdb = AliCDBManager::Instance();
+  cdb->SetDefaultStorage("raw://");
+  if (!fSpecificStorageParOffline.IsNull())
+    cdb->SetSpecificStorage("TOF/Calib/ParOffline", fSpecificStorageParOffline.Data());
+  if (!fSpecificStorageRunParams.IsNull())
+    cdb->SetSpecificStorage("TOF/Calib/RunParams", fSpecificStorageRunParams.Data());
+  cdb->SetRun(runNb);
+  
+  // init TOF calib
+  if (!fTOFcalib->Init()) {
+    AliError("cannot init TOF calib");
+    return kFALSE;
+  }
+
+  // get GRP data
+  if (!fGRPManager->ReadGRPEntry()) {
+    AliError("error while reading \"GRPEntry\" from OCDB");
+    return kFALSE;
+  }
+  fGRPObject = fGRPManager->GetGRPData();
+  if (!fGRPObject) {
+    AliError("cannot get \"GRPData\" from GRP manager");
+    return kFALSE;
+  }
+  fStartTime = fGRPObject->GetTimeStart();
+  fEndTime = fGRPObject->GetTimeEnd();
+  AliInfo(Form("got \"GRPData\": startTime=%d, endTime=%d", fStartTime, fEndTime));
+  
+  AliInfo(Form("initialized for run %d", runNb));
+  fInitFlag = kTRUE;
+  fRunNumber = runNb;
+  return kTRUE;
+}
+
+//_______________________________________________________
+
+Bool_t AliTOFAnalysisTaskCalibTree::InitEvent() {
+
+  //
+  // init event
+  //
+
+  // get ESD event 
+  fESDEvent = dynamic_cast<AliESDEvent *>(InputEvent());
+  if (!fESDEvent) return kFALSE;
+
+  // set event time and elapsed time
+  ftimestamp = fESDEvent->GetTimeStamp();
+  fElapsedTime = fESDEvent->GetTimeStamp() - fStartTime;
+
+  // event selection
+  fIsCollisionCandidate = fEventCuts->IsCollisionCandidate(fESDEvent);
+  if (fEventSelectionFlag && !fIsCollisionCandidate) return kFALSE;
+
+  // vertex selection
+  fVertex = fESDEvent->GetPrimaryVertexTracks();
+  if (fVertex->GetNContributors() < 1) {
+    fVertex = fESDEvent->GetPrimaryVertexSPD();
+    if (fVertex->GetNContributors() < 1) fHasVertex = kFALSE;
+    else fHasVertex = kTRUE;
+  }
+  else fHasVertex = kTRUE;
+  if (fVertexSelectionFlag && (!fHasVertex || TMath::Abs(fVertex->GetZ()) > fVertexCut)) return kFALSE;
+
+  // discard pile-up event is requested
+  if (fDiscardPileupEventFlag) {
+    if (fESDEvent->IsPileupFromSPD()) {
+      printf("PILE-UP event, will be discarded\n");
+      return kFALSE;
+    }
+  }
+
+  // init TOF response 
+  fESDpid->GetTOFResponse().SetTimeResolution(fTimeResolution);
+
+  // init TOF-T0 maker 
+  fTOFT0maker->SetTimeResolution(fTimeResolution);
+  
+  // calibrate ESD if requested
+  if (fCalibrateTOFsignal)
+    fTOFcalib->CalibrateESD(fESDEvent);
+
+  // compute T0-TOF and apply it if requested
+  if (fComputeT0TOF) 
+    fTOFT0maker->ComputeT0TOF(fESDEvent);
+  if (fUseT0TOF) {
+    fTOFT0maker->ApplyT0TOF(fESDEvent);
+    //fESDpid->MakePID(fESDEvent, kFALSE, 0.);
+  }
+
+  // init T0-TOF
+  fTOFT0v1->Init(fESDEvent);
+
+  return kTRUE;
+
+}
+
+//_______________________________________________________
+
+Bool_t AliTOFAnalysisTaskCalibTree::HasTOFMeasurement(AliESDtrack *track) {
+
+  //
+  // has TOF measurement
+  //
+
+  //check TOF status flags 
+  if (!(track->GetStatus() & AliESDtrack::kTOFout) ||
+      !(track->GetStatus() & AliESDtrack::kTIME)) return kFALSE;
+
+  // check integrated length
+  if (track->GetIntegratedLength() < 350.) return kFALSE;
+
+  // TOF measurement ok
+  return kTRUE;
+}
+
+//_______________________________________________________
+
+Bool_t AliTOFAnalysisTaskCalibTree::HasPrimaryDCA(AliESDtrack *track) {
+
+  //
+  // has primary DCA
+  //
+
+  // cut on transverse impact parameter
+  Float_t d0z0[2],covd0z0[3];
+  track->GetImpactParameters(d0z0, covd0z0);
+  Float_t sigma= 0.0050 + 0.0060 / TMath::Power(track->Pt(), 0.9);
+  Float_t d0max = 7. * sigma;
+  //
+  Float_t sigmaZ = 0.0146 + 0.0070 / TMath::Power(track->Pt(), 1.114758);
+  if (track->Pt() > 1.) sigmaZ = 0.0216;
+  Float_t d0maxZ = 5. * sigmaZ;
+  //
+  if(TMath::Abs(d0z0[0]) > d0max || TMath::Abs(d0z0[1]) > d0maxZ) 
+    return kFALSE;
+  
+  /* primary DCA ok */
+  return kTRUE;
+}
diff --git a/TOF/AliTOFAnalysisTaskCalibTree.h b/TOF/AliTOFAnalysisTaskCalibTree.h
new file mode 100644 (file)
index 0000000..0dd93c1
--- /dev/null
@@ -0,0 +1,130 @@
+#ifndef ALITOFANALYSISTASKCALIBTREE_H
+#define ALITOFANALYSISTASKCALIBTREE_H
+
+#include "AliAnalysisTaskSE.h"
+#include "TString.h"
+#include "TMath.h"
+
+class AliESDEvent;
+class AliESDtrackCuts;
+class AliESDtrackCuts;
+class AliESDtrack;
+class AliESDVertex;
+class AliESDpid;
+
+class AliPhysicsSelection;
+
+class AliTOFcalibHisto;
+class AliTOFcalib;
+class AliTOFT0maker;
+class AliTOFT0v1;
+
+class AliGRPManager;
+class AliGRPObject;
+
+class TH2F;
+
+#define MAXHITS 100000
+
+class AliTOFAnalysisTaskCalibTree :
+public AliAnalysisTaskSE
+{
+
+ public:
+
+  AliTOFAnalysisTaskCalibTree(const Char_t* name = "TOFcalibTree"); // default constructor
+  virtual ~AliTOFAnalysisTaskCalibTree(); // default destructor
+
+  virtual void UserCreateOutputObjects(); // user create output objects
+  virtual void UserExec(Option_t *option); // user exec
+
+  // getters
+  AliPhysicsSelection *GetEventCuts() const {return fEventCuts;}; // getter
+  AliESDtrackCuts *GetTrackCuts() const {return fTrackCuts;}; // getter
+  AliTOFcalib *GetTOFcalib() const {return fTOFcalib;}; // getter
+  AliTOFT0maker *GetTOFT0maker() const {return fTOFT0maker;}; // getter
+  AliTOFT0v1 *GetTOFT0v1() const {return fTOFT0v1;}; // getter
+  Float_t GetTimeResolution() const {return fTimeResolution;}; // time resolution
+  AliESDpid *GetESDpid() const {return fESDpid;}; // get ESD PID
+
+  // setters
+  void SetEventSelectionFlag(Bool_t value = kTRUE) {fEventSelectionFlag = value;}; // setter
+  void SetVertexSelectionFlag(Bool_t value = kTRUE) {fVertexSelectionFlag = value;}; // setter
+  void SetVertexCut(Double_t value) {fVertexCut = value;}; // setter
+  void SetDiscardPileupEventFlag(Bool_t value = kTRUE) {fDiscardPileupEventFlag = value;}; // setter
+  void SetPrimaryDCASelectionFlag(Bool_t value = kTRUE) {fPrimaryDCASelectionFlag = value;}; // setter
+  void SetTimeResolution(Float_t value) {fTimeResolution = value;}; // set time resolution
+  void SetCalibrateTOFsignal(Bool_t value = kTRUE) {fCalibrateTOFsignal = value;}; // setter
+  void SetComputeT0TOF(Bool_t value = kTRUE) {fComputeT0TOF = value;}; // setter
+  void SetUseT0TOF(Bool_t value = kTRUE) {fUseT0TOF = value;}; // setter
+  void SetUseLHCClockPhase(Bool_t value = kTRUE) {fUseLHCClockPhase = value;}; // setter
+  void SetSpecificStorageParOffline(Char_t *value) {fSpecificStorageParOffline = value;}; // set specific storage ParOffline
+  void SetSpecificStorageRunParams(Char_t *value) {fSpecificStorageRunParams = value;}; // set specific storage RunParams
+
+ protected:
+
+  AliTOFAnalysisTaskCalibTree(const AliTOFAnalysisTaskCalibTree &); // copy constructor
+  AliTOFAnalysisTaskCalibTree &operator=(const AliTOFAnalysisTaskCalibTree &); // operator=
+
+  // methods:
+
+  Bool_t InitRun(); // init run
+  Bool_t InitEvent(); // init event
+  Bool_t HasTOFMeasurement(AliESDtrack *track); // has TOF
+  Bool_t HasPrimaryDCA(AliESDtrack *track); // has primary DCA
+
+  // members:
+
+  // flags and cuts
+  Bool_t fInitFlag;                   // init flag
+  Bool_t fEventSelectionFlag;         // event selection flag
+  Bool_t fVertexSelectionFlag;        // vertex selection flag
+  Double_t fVertexCut;                // vertex cut
+  Bool_t fDiscardPileupEventFlag;     // discard pile-up event flag
+  Bool_t fCalibrateTOFsignal;         // calibrate TOF signal
+  Bool_t fComputeT0TOF;               // compute T0-TOF
+  Bool_t fUseT0TOF;                   // use T0-TOF
+  Bool_t fUseLHCClockPhase;           // use LHC-clock phase
+  Bool_t fPrimaryDCASelectionFlag;    // selection of primaries with DCA cut
+
+  // ESD related stuff
+  Int_t fRunNumber;                   // run number
+  AliESDEvent *fESDEvent;             // ESD event
+  AliPhysicsSelection *fEventCuts;    // event cuts
+  AliESDtrackCuts *fTrackCuts;        // track cuts
+  AliESDpid *fESDpid;                 // ESD PID
+  UInt_t fStartTime;                  // start time
+  UInt_t fEndTime;                    // end time
+  UInt_t fElapsedTime;                // event time since start
+  Bool_t fIsCollisionCandidate;       // is collision candidate
+  Bool_t fHasVertex;                  // has vertex
+  const AliESDVertex *fVertex;        // vertex
+
+  // GRP related stuff
+  AliGRPManager *fGRPManager;         // GRP manager
+  const AliGRPObject *fGRPObject;     // GRP object
+
+  // TOF related stuff
+  TString fSpecificStorageParOffline; // specific storage ParOffline
+  TString fSpecificStorageRunParams;  // specific storage RunParams
+  Float_t fTimeResolution;            // time resolution
+  AliTOFcalib *fTOFcalib;             // TOF calib
+  AliTOFT0maker *fTOFT0maker;         // TOF-T0 maker
+  AliTOFT0v1 *fTOFT0v1;               // TOF-T0 v1
+
+  // task related stuff
+  UInt_t ftimestamp;
+  Float_t fVertexZ;
+  Float_t ftimezero;
+  Int_t fnhits;
+  Float_t fmomentum[MAXHITS];
+  Float_t flength[MAXHITS];
+  Int_t findex[MAXHITS];
+  Float_t ftime[MAXHITS];
+  Float_t ftot[MAXHITS];
+  Float_t ftexp[MAXHITS];
+
+  ClassDef(AliTOFAnalysisTaskCalibTree, 1);
+};
+
+#endif /* ALIANALYSISTASKTOFCOMPACTCALIB_H */
index 0dee57c..8c758c2 100644 (file)
 # SHLIBS - Shared Libraries and objects for linking (Executables only)           #
 #--------------------------------------------------------------------------------#
 
-set ( SRCS  AliTOFAnalysisTaskCalibPass0.cxx)
+set ( SRCS  AliTOFAnalysisTaskCalibPass0.cxx
+    AliTOFAnalysisTaskCalibTree.cxx)
 
 string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
 
 set ( DHDR TOFcalibLinkDef.h)
 
-set ( EINCLUDE  RAW STEER/STEERBase ANALYSIS)
+set ( EINCLUDE  RAW STEER/STEERBase ANALYSIS STEER/AOD)
index cd350ac..116ae44 100644 (file)
@@ -9,5 +9,6 @@
 #pragma link off all functions;
  
 #pragma link C++ class AliTOFAnalysisTaskCalibPass0+;
+#pragma link C++ class AliTOFAnalysisTaskCalibTree+;
 
 #endif