1. Making TPC calibration task working on PROOF
authormarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 20 Jun 2008 19:32:33 +0000 (19:32 +0000)
committermarian <marian@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 20 Jun 2008 19:32:33 +0000 (19:32 +0000)
2. Adding the new calibration component for calibration using cosmic tracks
(Marian)

TPC/AliTPCAnalysisTaskcalib.cxx
TPC/AliTPCAnalysisTaskcalib.h
TPC/AliTPCcalibBase.cxx
TPC/AliTPCcalibBase.h
TPC/AliTPCcalibCosmic.cxx [new file with mode: 0644]
TPC/AliTPCcalibCosmic.h [new file with mode: 0644]
TPC/TPCcalibLinkDef.h
TPC/libTPCcalib.pkg

index b35e853c2fb89119ae5c321c9ed1b7541cc085ae..9b915863bc845a5624c0e09fe9de2c1b091c3cd5 100644 (file)
@@ -24,6 +24,7 @@
 #include "AliTPCcalibBase.h"
 #include "AliESDEvent.h"
 #include "AliESDfriend.h"
+#include "AliESDtrack.h"
 #include "AliESDfriendTrack.h"
 #include "AliTPCseed.h"
 #include "AliESDInputHandler.h"
 
 ClassImp(AliTPCAnalysisTaskcalib)
 
+
+AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib()
+  :AliAnalysisTask(),
+   fCalibJobs(0),
+   fESD(0),
+   fESDfriend(0),
+   fDebugOutputPath()
+{
+  //
+  // default constructor
+  // 
+  
+}
+
+
 AliTPCAnalysisTaskcalib::AliTPCAnalysisTaskcalib(const char *name) 
   :AliAnalysisTask(name,""),
    fCalibJobs(0),
    fESD(0),
-   fESDfriend(0)
+   fESDfriend(0),
+   fDebugOutputPath()
 {
   //
   // Constructor
   //
   DefineInput(0, TChain::Class());
   DefineOutput(0, TObjArray::Class());
-  fCalibJobs.SetOwner(kTRUE);
+  fCalibJobs = new TObjArray(0);
+  fCalibJobs->SetOwner(kFALSE);
 }
 
 AliTPCAnalysisTaskcalib::~AliTPCAnalysisTaskcalib() {
   //
   // destructor
   //
-  fCalibJobs.Delete();
+  printf("AliTPCAnalysisTaskcalib::~AliTPCAnalysisTaskcalib");
+  //fCalibJobs->Delete();
 }
 
 void AliTPCAnalysisTaskcalib::Exec(Option_t *) {
@@ -66,17 +85,20 @@ void AliTPCAnalysisTaskcalib::Exec(Option_t *) {
     return;
   }
   Int_t n=fESD->GetNumberOfTracks();
+  Process(fESD);
   for (Int_t i=0;i<n;++i) {
     AliESDfriendTrack *friendTrack=fESDfriend->GetTrack(i);
+    AliESDtrack *track=fESD->GetTrack(i);
     TObject *calibObject=0;
     AliTPCseed *seed=0;
     for (Int_t j=0;(calibObject=friendTrack->GetCalibObject(j));++j)
       if ((seed=dynamic_cast<AliTPCseed*>(calibObject)))
        break;
+    if (track) Process(track);
     if (seed)
       Process(seed);
   }
-  PostData(0,&fCalibJobs);
+  PostData(0,fCalibJobs);
 }
 
 void AliTPCAnalysisTaskcalib::ConnectInputData(Option_t *) {
@@ -109,21 +131,32 @@ void AliTPCAnalysisTaskcalib::Terminate(Option_t */*option*/) {
   // Terminate
   //
   AliTPCcalibBase *job=0;
-  Int_t njobs = fCalibJobs.GetEntriesFast();
+  Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
-    job = (AliTPCcalibBase*)fCalibJobs.UncheckedAt(i);
+    job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
     if (job) job->Terminate();
   }
 }
 
+void AliTPCAnalysisTaskcalib::FinishTaskOutput()
+{
+  //
+  // According description in AliAnalisysTask this method is call 
+  // on the slaves before sending data
+  //
+  Terminate("slave");
+  RegisterDebugOutput();
+}
+
+
 void AliTPCAnalysisTaskcalib::Process(AliESDEvent *event) {
   //
   // Process ESD event
   //
   AliTPCcalibBase *job=0;
-  Int_t njobs = fCalibJobs.GetEntriesFast();
+  Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
-    job = (AliTPCcalibBase*)fCalibJobs.UncheckedAt(i);
+    job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
     if (job) job->Process(event);
   }
 }
@@ -133,15 +166,27 @@ void AliTPCAnalysisTaskcalib::Process(AliTPCseed *track) {
   // Process TPC track
   //
   AliTPCcalibBase *job=0;
-  Int_t njobs = fCalibJobs.GetEntriesFast();
+  Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
-    job = (AliTPCcalibBase*)fCalibJobs.UncheckedAt(i);
+    job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
+    if (job) job->Process(track);
+  }
+}
+
+void AliTPCAnalysisTaskcalib::Process(AliESDtrack *track) {
+  //
+  // Process ESD track
+  //
+  AliTPCcalibBase *job=0;
+  Int_t njobs = fCalibJobs->GetEntriesFast();
+  for (Int_t i=0;i<njobs;i++){
+    job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
     if (job) job->Process(track);
   }
 }
 
 Long64_t AliTPCAnalysisTaskcalib::Merge(TCollection *li) {
-  TIterator *i=fCalibJobs.MakeIterator();
+  TIterator *i=fCalibJobs->MakeIterator();
   AliTPCcalibBase *job;
   Long64_t n=0;
   while ((job=dynamic_cast<AliTPCcalibBase*>(i->Next())))
@@ -154,9 +199,22 @@ void AliTPCAnalysisTaskcalib::Analyze() {
   // Analyze the content of the task
   //
   AliTPCcalibBase *job=0;
-  Int_t njobs = fCalibJobs.GetEntriesFast();
+  Int_t njobs = fCalibJobs->GetEntriesFast();
   for (Int_t i=0;i<njobs;i++){
-    job = (AliTPCcalibBase*)fCalibJobs.UncheckedAt(i);
+    job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
     if (job) job->Analyze();
   }
 }
+
+
+void AliTPCAnalysisTaskcalib::RegisterDebugOutput(){
+  //
+  //
+  //
+  AliTPCcalibBase *job=0;
+  Int_t njobs = fCalibJobs->GetEntriesFast();
+  for (Int_t i=0;i<njobs;i++){
+    job = (AliTPCcalibBase*)fCalibJobs->UncheckedAt(i);
+    if (job) job->RegisterDebugOutput(fDebugOutputPath.Data());
+  }
+}
index c81cc3621762db40506936e08c903b45c5ec18ef..4c603f52b39cd8341b2435e5ad830fd6d97f6c7a 100644 (file)
 #include "TObjArray.h"
 #include "AliTPCcalibBase.h"
 class AliESDEvent;
+class AliESDtrack;
 class AliESDfriend;
 class AliTPCseed;
 
 class AliTPCAnalysisTaskcalib:public AliAnalysisTask {
 public:
+  AliTPCAnalysisTaskcalib();
   AliTPCAnalysisTaskcalib(const char *name);
   virtual ~AliTPCAnalysisTaskcalib();
-  void AddJob(AliTPCcalibBase *job) {fCalibJobs.Add(job);}
-  TObjArray* GetJobs() {return &fCalibJobs;}
+  void AddJob(AliTPCcalibBase *job) {fCalibJobs->Add(job);}
+  TObjArray* GetJobs() {return fCalibJobs;}
 
   virtual void ConnectInputData(Option_t *option);
   virtual void CreateOutputObjects();
   virtual void Exec(Option_t *option);
   virtual void Terminate(Option_t *option);
+  virtual void FinishTaskOutput();
+  void         SetDebugOuputhPath(const char * name){fDebugOutputPath=name;}
 protected:
   virtual void     Process(AliESDEvent *event);
   virtual void     Process(AliTPCseed *track);
+  virtual void     Process(AliESDtrack *track);
   virtual Long64_t Merge(TCollection *li);
   virtual void     Analyze();
+  void             RegisterDebugOutput();
 private:
-  TObjArray fCalibJobs;
-  AliESDEvent *fESD;
-  AliESDfriend *fESDfriend;
+  TObjArray *fCalibJobs;      // array of calibration objects - WE ARE NOT OWNER?
+  AliESDEvent *fESD;         //! current esd
+  AliESDfriend *fESDfriend;  //! current esd friend
+  TString      fDebugOutputPath; // debug output path   
   AliTPCAnalysisTaskcalib(const AliTPCAnalysisTaskcalib&);
   AliTPCAnalysisTaskcalib& operator=(const AliTPCAnalysisTaskcalib&);
   ClassDef(AliTPCAnalysisTaskcalib,1)
index a97244be4cea901ea1843a00e1e3d7f926715153..13aa0b7a2a73552ed45f23d0e4f1cd15e1062ce8 100644 (file)
 //  marian.ivanov@cern.ch
 // 
 #include "AliTPCcalibBase.h"
+#include "TSystem.h"
+#include "TFile.h"
 #include "TTreeStream.h"
+#include "AliLog.h"
+
 
 ClassImp(AliTPCcalibBase)
 
@@ -81,6 +85,7 @@ AliTPCcalibBase::~AliTPCcalibBase() {
   //
   // destructor
   //
+  if (fDebugLevel>0) printf("AliTPCcalibBase::~AliTPCcalibBase\n");
   if (fDebugStreamer) delete fDebugStreamer;
   fDebugStreamer=0;
 }
@@ -89,6 +94,7 @@ void  AliTPCcalibBase::Terminate(){
   //
   //
   //
+  if (fDebugLevel>0) printf("AliTPCcalibBase::Terminate\n");
   if (fDebugStreamer) delete fDebugStreamer;
   fDebugStreamer = 0;
   return;
@@ -108,3 +114,25 @@ TTreeSRedirector *AliTPCcalibBase::GetDebugStreamer(){
   fDebugStreamer = new TTreeSRedirector(dsName.Data());
   return fDebugStreamer;
 }
+
+
+void AliTPCcalibBase::RegisterDebugOutput(const char *path){
+  //
+  // store  - copy debug output to the destination position
+  // currently ONLY for local copy
+  if (fDebugLevel>0) printf("AliTPCcalibBase::RegisterDebugOutput(%s)\n",path);
+  if (fStreamLevel==0) return;
+  TString dsName;
+  dsName=GetName();
+  dsName+="Debug.root";
+  dsName.ReplaceAll(" ",""); 
+  TString dsName2=path;
+  gSystem->MakeDirectory(dsName2.Data());
+  dsName2+=gSystem->HostName();
+  gSystem->MakeDirectory(dsName2.Data());
+  dsName2+="/";
+  dsName2+=dsName;
+  AliInfo(Form("copy %s\t%s\n",dsName.Data(),dsName2.Data()));
+  printf("copy %s\t%s\n",dsName.Data(),dsName2.Data());
+  TFile::Cp(dsName.Data(),dsName2.Data());
+}
index cf15022cfc4f3975db0f4664e216281abdf945f0..d55f02cf3bad287fc77a16886b9bb55feca7a690 100644 (file)
@@ -11,6 +11,7 @@
 #include "TNamed.h"
 class AliTPCseed;
 class AliESDEvent;
+class AliESDtrack;
 class TCollection;
 class TTreeSRedirector;
 
@@ -22,6 +23,7 @@ public:
   virtual ~AliTPCcalibBase();
   virtual void     Process(AliESDEvent */*event*/){return;}
   virtual void     Process(AliTPCseed */*track*/){return;}
+  virtual void     Process(AliESDtrack */*track*/){return;}
   virtual Long64_t Merge(TCollection */*li*/){return 0;}
   virtual void     Analyze(){return;}
   virtual void     Terminate();
@@ -32,6 +34,7 @@ public:
   void       SetDebugLevel(Int_t level) {fDebugLevel = level;}
   Int_t      GetStreamLevel() const {return fStreamLevel;}
   Int_t      GetDebugLevel() const {return fDebugLevel;}
+  virtual void RegisterDebugOutput(const char *path);
 protected: 
   TTreeSRedirector *fDebugStreamer;     //! debug streamer
   Int_t  fStreamLevel;                  //  debug stream level
diff --git a/TPC/AliTPCcalibCosmic.cxx b/TPC/AliTPCcalibCosmic.cxx
new file mode 100644 (file)
index 0000000..772f2a1
--- /dev/null
@@ -0,0 +1,247 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+#include "Riostream.h"
+#include "TChain.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TList.h"
+#include "TMath.h"
+#include "TCanvas.h"
+#include "TFile.h"
+
+#include "AliTPCseed.h"
+#include "AliESDVertex.h"
+#include "AliESDEvent.h"
+#include "AliESDfriend.h"
+#include "AliESDInputHandler.h"
+
+#include "AliTracker.h"
+#include "AliMagFMaps.h"
+
+#include "AliLog.h"
+
+#include "AliTPCcalibCosmic.h"
+
+#include "TTreeStream.h"
+#include "AliTPCTracklet.h"
+
+ClassImp(AliTPCcalibCosmic)
+
+
+AliTPCcalibCosmic::AliTPCcalibCosmic() 
+  :AliTPCcalibBase(),
+  fHistNTracks(0),
+  fClusters(0),
+  fModules(0),
+  fHistPt(0),
+  fPtResolution(0),
+  fDeDx(0)
+{  
+  AliInfo("Defualt Constructor");  
+}
+
+
+AliTPCcalibCosmic::AliTPCcalibCosmic(const Text_t *name, const Text_t *title) 
+  :AliTPCcalibBase(),
+  fHistNTracks(0),
+  fClusters(0),
+  fModules(0),
+  fHistPt(0),
+  fPtResolution(0),
+  fDeDx(0)
+{  
+  SetName(name);
+  SetTitle(title);
+  AliMagFMaps * field = new AliMagFMaps("dummy1", "dummy2",0,5,0);
+  AliTracker::SetFieldMap(field, kTRUE);  
+  fHistNTracks = new TH1F("ntracks","Number of Tracks per Event",501,-0.5,500.5);
+  fClusters = new TH1F("signal","Number of Clusters per track",160,0,160);
+  fModules = new TH2F("sector","Acorde hits; z (cm); x(cm)",1200,-1200,1200,600,-1000,1000);
+  fHistPt = new TH1F("Pt","Pt distribution",2000,0,50);  
+  fPtResolution = new TH1F("PtResolution","Pt resolution",100,-50,50);
+  fDeDx = new TH2F("DeDx","dEdx",500,0.01,20.,500,0.,500);
+  BinLogX(fDeDx);
+  AliInfo("Non Defualt Constructor");  
+}
+
+AliTPCcalibCosmic::~AliTPCcalibCosmic(){
+  //
+  //
+  //
+}
+
+
+void AliTPCcalibCosmic::Process(AliESDEvent *event) {
+    
+  if (!event) {
+    Printf("ERROR: ESD not available");
+    return;
+  }
+  
+  AliESDfriend *ESDfriend=static_cast<AliESDfriend*>(event->FindListObject("AliESDfriend"));
+  if (!ESDfriend) {
+   Printf("ERROR: ESDfriend not available");
+   return;
+  }
+
+  printf("Hallo world: Im here\n");
+  
+  Int_t n=event->GetNumberOfTracks(); 
+  fHistNTracks->Fill(n);
+  
+  //track loop
+  for (Int_t i=0;i<n;++i) { 
+   AliESDtrack *track = event->GetTrack(i); 
+   fClusters->Fill(track->GetTPCNcls());
+   
+   AliExternalTrackParam * trackIn = new AliExternalTrackParam(*track->GetInnerParam());
+   
+   AliESDfriendTrack *friendTrack = ESDfriend->GetTrack(i);
+   TObject *calibObject;
+   AliTPCseed *seed = 0;
+   for (Int_t l=0;calibObject=friendTrack->GetCalibObject(l);++l) {
+    if (seed=dynamic_cast<AliTPCseed*>(calibObject)) break;
+   }
+   if (seed && track->GetTPCNcls() > 80) fDeDx->Fill(trackIn->GetP(), seed->CookdEdxNorm(0.05,0.45,0));
+
+    
+  }
+  
+  // dE/dx,pt and ACORDE study --> studies which need the pair selection  
+  if (n > 2) return;
+  
+  for (Int_t i=0;i<n;++i) {
+    AliESDtrack *track1 = event->GetTrack(i);
+     
+    Double_t d1[3];
+    track1->GetDirection(d1);
+    
+    for (Int_t j=i+1;j<n;++j) {
+     AliESDtrack *track2 = event->GetTrack(j);   
+     Double_t d2[3];
+     track2->GetDirection(d2);
+       
+     if (d1[0]*d2[0] + d1[1]*d2[1] + d1[2]*d2[2] < -0.999) {
+     
+      /*___________________________________ Pt resolution ________________________________________*/
+      if (track1->Pt() != 0 && track1->GetTPCNcls() > 80 && track2->GetTPCNcls() > 80) {
+       Double_t res = (track1->Pt() - track2->Pt());
+       res = res/(2*(track1->Pt() + track2->Pt()));
+       fPtResolution->Fill(100*res);
+      }
+      
+      /*_______________________________ Propagation to ACORDE ___________________________________*/
+      const Double_t AcordePlane = 850.; //distance of the central Acorde detectors to the beam line at y =0
+      const Double_t roof = 210.5; // distance from x =0 to end of magnet roof
+     
+      if (d1[1] > 0 && d2[1] < 0 && track1->GetTPCNcls() > 50) {        
+       Double_t r[3];
+       track1->GetXYZ(r);
+       Double_t x,z;
+       z = r[2] + (d1[2]/d1[1])*(AcordePlane - r[1]);
+       x = r[0] + (d1[0]/d1[1])*(AcordePlane - r[1]);
+       
+       if (x > roof) {
+        x = x - (x-roof)/(1 + TMath::Abs(TMath::Tan(track1->Phi())));
+        z = z - TMath::Abs(TMath::Tan(track1->Phi()))/TMath::Abs(TMath::Tan(track1->Theta()))*(x-roof)/(1 + TMath::Abs(TMath::Tan(track1->Phi())));
+       }
+       if (x < -roof) {
+        x = x - (x+roof)/(1 + TMath::Abs(TMath::Tan(track1->Phi())));
+        z = z -  TMath::Abs(TMath::Tan(track1->Phi()))/TMath::Abs(TMath::Tan(track1->Theta()))*(x+roof)/(1 + TMath::Abs(TMath::Tan(track1->Phi())));
+       }
+       
+       fModules->Fill(z, x);
+      }
+      
+      if (d2[1] > 0 && d1[1] < 0 && track2->GetTPCNcls() > 50) {
+       Double_t r[3];
+       track2->GetXYZ(r);
+       Double_t x,z;
+       z = r[2] + (d2[2]/d2[1])*(AcordePlane - r[1]);
+       x = r[0] + (d2[0]/d2[1])*(AcordePlane - r[1]);
+       
+       if (x > roof) {
+        x = x - (x-roof)/(1 + TMath::Abs(TMath::Tan(track2->Phi())));
+        z = z - TMath::Abs(TMath::Tan(track2->Phi()))/TMath::Abs(TMath::Tan(track2->Theta()))*(x-roof)/(1 + TMath::Abs(TMath::Tan(track2->Phi())));  
+       }
+       if (x < -roof) {
+        x = x - (x+roof)/(1 + TMath::Abs(TMath::Tan(track2->Phi())));
+       z = z -  TMath::Abs(TMath::Tan(track2->Phi()))/TMath::Abs(TMath::Tan(track2->Theta()))*(x+roof)/(1 + TMath::Abs(TMath::Tan(track2->Phi())));
+       }       
+       
+       fModules->Fill(z, x);
+      }
+      
+      printf("My stream level=%d\n",fStreamLevel);
+
+      if (fStreamLevel>0){
+       TTreeSRedirector * cstream =  GetDebugStreamer();
+       printf("My stream=%p\n",cstream);
+       if (cstream) {
+         (*cstream) << "Track" <<
+           "Track1.=" << track1 <<      // original track 1
+           "Track2.=" << track2 <<      // original track2
+           "\n";
+       }
+      }
+  //     AliExternalTrackParam * trackOut = new AliExternalTrackParam(*track2->GetOuterParam());
+//       AliTracker::PropagateTrackTo(trackOut,850.,105.658,30);
+//       delete trackOut;
+      
+
+
+      
+
+      break;            
+     }     
+    }
+  }
+  
+  
+  
+  
+}    
+
+
+Long64_t AliTPCcalibCosmic::Merge(TCollection *li) {
+
+}
+
+
+void AliTPCcalibCosmic::BinLogX(TH1 *h) {
+
+  // Method for the correct logarithmic binning of histograms
+
+  TAxis *axis = h->GetXaxis();
+  int bins = axis->GetNbins();
+
+  Double_t from = axis->GetXmin();
+  Double_t to = axis->GetXmax();
+  Double_t *new_bins = new Double_t[bins + 1];
+   
+  new_bins[0] = from;
+  Double_t factor = pow(to/from, 1./bins);
+  
+  for (int i = 1; i <= bins; i++) {
+   new_bins[i] = factor * new_bins[i-1];
+  }
+  axis->Set(bins, new_bins);
+  delete new_bins;
+  
+}
+
diff --git a/TPC/AliTPCcalibCosmic.h b/TPC/AliTPCcalibCosmic.h
new file mode 100644 (file)
index 0000000..5b7729f
--- /dev/null
@@ -0,0 +1,43 @@
+#ifndef ALITPCCALIBCOSMIC_H
+#define ALITPCCALIBCOSMIC_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+#include "AliTPCcalibBase.h"
+class TH1F;
+class TH2F;
+class TList;
+class AliESDEvent;
+
+#include "TTreeStream.h"
+
+
+class AliTPCcalibCosmic:public AliTPCcalibBase {
+public:
+  AliTPCcalibCosmic(); 
+  AliTPCcalibCosmic(const Text_t *name, const Text_t *title);
+  virtual ~AliTPCcalibCosmic();
+  
+  virtual void     Process(AliESDEvent *event);
+  virtual Long64_t Merge(TCollection *li);
+  
+  
+public:
+  static void BinLogX(TH1 * h);   // method for correct histogram binning
+
+  TH1F  *fHistNTracks;
+  TH1F  *fClusters;
+  TH2F  *fModules;
+  TH1F  *fHistPt;
+  TH1F  *fPtResolution;
+  TH2F  *fDeDx;
+
+  AliTPCcalibCosmic(const AliTPCcalibCosmic&); 
+  AliTPCcalibCosmic& operator=(const AliTPCcalibCosmic&); 
+
+  ClassDef(AliTPCcalibCosmic, 1); 
+};
+
+#endif
+
index df821786b05d255cc2b4f92536121385d591ab5c..af6c84fb8a8d505b80d503ce22dafe1b7dee0547 100644 (file)
@@ -27,6 +27,8 @@
 #pragma link C++ class  AliTPCAnalysisTaskcalib+;
 #pragma link C++ class AliTPCCalibKr+;
 #pragma link C++ class AliTPCCalibKrTask+;
+#pragma link C++ class AliTPCcalibLaser+;
+#pragma link C++ class AliTPCcalibCosmic+;
 
 #endif
 
index 0485f177a141dbf4ea51dd3b1ec14a0d7d56fc49..3f2c736100aa121c12f31987d99bd4649370dc80 100644 (file)
@@ -1,7 +1,7 @@
 #-*- Mode: Makefile -*-
 
 SRCS = AliTPCcalibTracksCuts.cxx   AliTPCcalibTracks.cxx   AliTPCcalibTracksGain.cxx  \
-        AliTPCSelectorESD.cxx   AliTPCSelectorTracks.cxx   AliTPCCalPadRegion.cxx AliTPCFitPad.cxx AliAnaTPCTrackBase.cxx AliAnaTPCTrackCalib.cxx AliTPCcalibAlign.cxx AliTPCcalibAlignment.cxx  AliTPCcalibV0.cxx AliTPCCalibKr.cxx AliTPCcalibBase.cxx AliTPCAnalysisTaskcalib.cxx  AliTPCCalibKrTask.cxx 
+        AliTPCSelectorESD.cxx   AliTPCSelectorTracks.cxx   AliTPCCalPadRegion.cxx AliTPCFitPad.cxx AliAnaTPCTrackBase.cxx AliAnaTPCTrackCalib.cxx AliTPCcalibAlign.cxx AliTPCcalibAlignment.cxx  AliTPCcalibV0.cxx AliTPCCalibKr.cxx AliTPCcalibBase.cxx AliTPCAnalysisTaskcalib.cxx  AliTPCCalibKrTask.cxx AliTPCcalibLaser.cxx AliTPCcalibCosmic.cxx
 
 HDRS:= $(SRCS:.cxx=.h)