Corrected UInt_t <-> Int_t conversion
[u/mrichter/AliRoot.git] / TPC / AliTPCTracking.C
1 ////////////////////////////////////////////////////////////////////////
2 //
3 // AliTPCTracking.C 
4 //
5 // date: 22.08.2002
6 // author: Jiri Chudoba based on code of Jourij Belikov
7 // version: 1.0
8 // description: 
9 //      reconstructs of tracks in TPC in the following steps:
10 //         TPC cluster finding
11 //         TPC track finding
12 // input parameters: 
13 //        Int_t nEvents      ... nr of events to process (<0 means all)
14 //        Int_t firstEventNr ... first event number (starts from 0)
15 //        const char* fileName ... name of galice file
16 //        Bool_t makeClusters ... run the cluster finder or not?
17 //        Bool_t makeTracks ... run the track finder or not?
18 //        const char* fileNameRaw ... if not NULL, the cluster finder uses
19 //                                    the given file as raw data input
20 //
21 // History:
22 //
23 //     21.07.2003 ... NewIO
24 //
25 //     18.03.2003 ... Char_t* replaced by const char*
26 //
27 //     03.03.2003 ... SetFieldFactor moved to AliTracker class and
28 //                    LoadTPCParam moved to AliTPC class
29 //                    TString replaced by Char_t*
30 //
31 //     20.11.2002 ... Changes due to a changed interface of AliTPCtracker. 
32 //                    Use Riostream.h instead of iostream.h
33 //
34 //     22.08.2002 ... first version
35 //
36 ////////////////////////////////////////////////////////////////////////
37
38 #if !defined(__CINT__) || defined(__MAKECINT__)
39 #include <Riostream.h>
40 #include <TFile.h>
41 #include <TTree.h>
42 #include <TBenchmark.h>
43 #include "AliRunLoader.h"
44 #include "AliTPC.h"
45 #include "AliTPCParam.h"
46 #include "AliTPCclustererMI.h"
47 #include "AliTPCtrackerMI.h"
48 #include "AliRawReaderRoot.h"
49 #endif
50
51 Bool_t AliTPCTracking(Int_t nEvents = -1, Int_t firstEvent = 0,
52                       const char* fileName = "galice.root",
53                       Bool_t makeClusters = kTRUE,
54                       Bool_t makeTracks = kTRUE,
55                       const char* fileNameRaw = NULL);
56
57 /*
58 Int_t TPCRefitInward(Int_t nEvents=1, Int_t firstEvent=0,
59                      const char* fileNameClusters="tpc.clusters.root",
60                      const char* fileNameTracks="tpc.tracks.root",
61                      const char* fileNameTRDTracks="trd.tracks.root",
62                      const char* fileNameRefittedTracks="tpc.refitted.tracks.root");
63 */
64
65 ////////////////////////////////////////////////////////////////////////
66 Bool_t AliTPCTracking(Int_t nEvents, Int_t firstEvent,
67                       const char* fileName,
68                       Bool_t makeClusters,
69                       Bool_t makeTracks,
70                       const char* fileNameRaw) 
71 {
72   // get the loaders
73   AliRunLoader* runLoader = AliRunLoader::Open(fileName);
74   if (!runLoader) {
75     cerr << "AliTPCTracking: no run loader found\n";
76     return kFALSE;
77   }
78   AliLoader* tpcLoader = runLoader->GetLoader("TPCLoader");
79   if (!tpcLoader) {
80     cerr << "AliTPCTracking: no TPC loader found\n";
81     return kFALSE;
82   }
83
84   // get the TPC parameters
85   runLoader->CdGAFile();
86   AliTPCParam* param = AliTPC::LoadTPCParam(gFile);
87   if (!param) {
88     cerr << "AliTPCTracking: no TPC parameters found\n";
89     return kFALSE;
90   }
91
92   // create the clusterer object
93   AliTPCclustererMI* clusterer = NULL;
94   if (makeClusters) {
95     clusterer = new AliTPCclustererMI(param);
96     if (!fileNameRaw) tpcLoader->LoadDigits();
97     tpcLoader->LoadRecPoints("recreate");
98   }
99
100   // create the tracker object
101   AliTPCtrackerMI* tracker = NULL;
102   if (makeTracks) {
103 //    tracker = new AliTPCtrackerMI(param);
104     if (!makeClusters) tpcLoader->LoadRecPoints();
105     tpcLoader->LoadTracks("recreate");
106   }
107
108   // get the event number range
109   Int_t maxEvent = 0;
110   if (fileNameRaw) {
111     TFile* file = TFile::Open(fileNameRaw);
112     if (file && file->IsOpen()) {
113       TTree* tree = (TTree*) file->Get("T");
114       if (tree) maxEvent = (Int_t) tree->GetEntries();
115     }
116   } else {
117     maxEvent = runLoader->GetNumberOfEvents();
118   }
119   if (nEvents < 0) nEvents = maxEvent - firstEvent;
120   Int_t lastEvent = firstEvent + nEvents;
121   if (lastEvent > maxEvent) lastEvent = maxEvent;
122
123   // loop over the events
124   for (Int_t iEvent = firstEvent; iEvent < lastEvent; iEvent++) {
125
126     runLoader->GetEvent(iEvent);
127
128     // run the cluster finder
129     if (makeClusters) {
130       if (!tpcLoader->TreeR()) tpcLoader->MakeRecPointsContainer();
131       clusterer->SetOutput(tpcLoader->TreeR());
132       if (fileNameRaw) {
133         AliRawReaderRoot rawReader(fileNameRaw, iEvent);
134         clusterer->Digits2Clusters(&rawReader);
135       } else {
136         clusterer->SetInput(tpcLoader->TreeD());
137         clusterer->Digits2Clusters();
138       }
139       tpcLoader->WriteRecPoints("OVERWRITE");
140     }
141
142     // run the track finder
143     if (makeTracks) {
144       tracker = new AliTPCtrackerMI(param);
145       tracker->Clusters2Tracks();
146       delete tracker;
147     }
148   }
149
150   if (tracker) delete tracker;
151   if (clusterer) delete clusterer;
152
153   return kTRUE;
154 }
155
156 /*
157 ////////////////////////////////////////////////////////////////////////
158 Int_t TPCRefitInward(Int_t nEvents, Int_t firstEvent,
159                      const char* fileNameClusters,
160                      const char* fileNameTracks,
161                      const char* fileNameTRDTracks,
162                      const char* fileNameRefittedTracks)
163 {
164   Int_t rc = 0;
165   const Char_t *name="TPCRefitInward";
166   if (gDEBUG>1) cout<<name<<" starts"<<endl;
167   if (gDEBUG>1) gBenchmark->Start(name);
168   TFile *fileClusters = TFile::Open(fileNameClusters);
169   TFile *fileTracks = TFile::Open(fileNameTracks);
170   TFile *fileTRDTracks = TFile::Open(fileNameTRDTracks);
171   TFile *fileRefittedTracks = TFile::Open(fileNameRefittedTracks, "recreate");
172
173   AliTPCParam* paramTPC = AliTPC::LoadTPCParam(fileClusters);
174   if (!paramTPC) return 1;
175
176   for (Int_t iEvent = firstEvent; iEvent < firstEvent+nEvents; iEvent++){
177     if (gDEBUG > 2) cout<<"TPCRefitInward: event "<<iEvent<<endl;
178     AliTPCtracker *tracker = new AliTPCtracker(paramTPC);
179     tracker->SetEventNumber(iEvent);
180     fileClusters->cd();
181     rc = tracker->RefitInward(fileTRDTracks, fileTracks, fileRefittedTracks);
182     delete tracker;
183     if (rc) return rc;
184   }
185
186   fileClusters->Close();
187   fileTracks->Close();
188   fileTRDTracks->Close();
189   fileRefittedTracks->Close();
190   delete fileClusters;
191   delete fileTracks;
192   delete fileTRDTracks;
193   delete fileRefittedTracks;
194   if (gDEBUG>1) gBenchmark->Show(name);
195   return rc;
196 }
197 */