#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 *) {
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 *) {
// 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);
}
}
// 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())))
// 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());
+ }
+}
#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)
// marian.ivanov@cern.ch
//
#include "AliTPCcalibBase.h"
+#include "TSystem.h"
+#include "TFile.h"
#include "TTreeStream.h"
+#include "AliLog.h"
+
ClassImp(AliTPCcalibBase)
//
// destructor
//
+ if (fDebugLevel>0) printf("AliTPCcalibBase::~AliTPCcalibBase\n");
if (fDebugStreamer) delete fDebugStreamer;
fDebugStreamer=0;
}
//
//
//
+ if (fDebugLevel>0) printf("AliTPCcalibBase::Terminate\n");
if (fDebugStreamer) delete fDebugStreamer;
fDebugStreamer = 0;
return;
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());
+}
#include "TNamed.h"
class AliTPCseed;
class AliESDEvent;
+class AliESDtrack;
class TCollection;
class TTreeSRedirector;
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();
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
--- /dev/null
+/**************************************************************************
+ * 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;
+
+}
+
--- /dev/null
+#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
+
#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
#-*- 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)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff