Eff C++ warning removal
[u/mrichter/AliRoot.git] / TPC / AliTPCSelectorESD.cxx
1 // The class definition in esdClus.h has been generated automatically
2 // by the ROOT utility TTree::MakeSelector(). This class is derived
3 // from the ROOT class TSelector. For more information on the TSelector
4 // framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.
5
6 // The following methods are defined in this file:
7 //    Begin():        called everytime a loop on the tree starts,
8 //                    a convenient place to create your histograms.
9 //    SlaveBegin():   called after Begin(), when on PROOF called only on the
10 //                    slave servers.
11 //    Process():      called for each event, in this function you decide what
12 //                    to read and fill your histograms.
13 //    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
14 //                    called only on the slave servers.
15 //    Terminate():    called at the end of the loop on the tree,
16 //                    a convenient place to draw/fit your histograms.
17 //
18 // To use this file, try the following session on your Tree T:
19 //
20 // Root > T->Process("esdClus.C")
21 // Root > T->Process("esdClus.C","some options")
22 // Root > T->Process("esdClus.C+")
23 //
24 // Modification log:
25 // 05/11/2006 HH  Correct for large pads (outer sectors) in amplitude plots
26
27 #include "TSystem.h"
28 #include <TPDGCode.h>
29 #include <TStyle.h>
30 #include "TCint.h"
31 #include "TH1I.h"
32 #include "TTimeStamp.h"
33 #include "TProof.h"
34 #include "TTree.h"
35 //
36 #include "AliTracker.h"
37 #include "AliMagF.h"
38 // 
39 #include "AliESDEvent.h"   // new container
40 #include "AliESD.h"
41 #include "AliESDtrack.h"
42 #include "AliESDfriend.h"
43 #include "AliESDfriendTrack.h"
44 #include "AliTPCseed.h"
45 #include "AliTPCclusterMI.h"
46 //
47 #include "AliSysInfo.h"
48 #include "AliTPCSelectorESD.h" 
49
50
51  
52
53
54 AliTPCSelectorESD::AliTPCSelectorESD(TTree *tree) : 
55    TSelector(),
56    fChain(0),
57    fESDevent(0),
58    fESD(0),
59    fESDfriend(0),
60    fNtracks(0),       //! number of Tracks
61    fNtracksFriend(0), //! number of firend Tracks  
62    fNClusters(0),      //! number of clusters on track
63    fRegPath(0),       // path to store persistent data 
64    fFileNo(0),
65    fSysWatch(0),      // system info        
66    fFileWatch(0),      // file watch - write the status of the analyzed files
67    fDebugLevel(0)
68  {
69    G__SetCatchException(0);     
70    //
71    //
72    //if (somthing){  
73    fSysWatch  = new fstream("syswatch2.log", ios_base::out|ios_base::trunc);
74    fFileWatch = new fstream("filewatch.log", ios_base::out|ios_base::trunc);
75    if (gProof) fDebugLevel = gProof->GetLogLevel();
76    if (tree) fChain=tree;
77  }   
78
79
80 void AliTPCSelectorESD::Begin(TTree * /*tree*/)
81 {
82   // The Begin() function is called at the start of the query.
83   // When running with PROOF Begin() is only called on the client.
84   // The tree argument is deprecated (on PROOF 0 is passed).
85   
86   TString option = GetOption();
87
88 }
89
90
91 void    AliTPCSelectorESD::SetInputList(TList *input) { 
92   //
93   //
94   //
95   fInput = input; 
96   TNamed *regData = (TNamed*)input->FindObject("debugStreamPrefix");
97   if (regData) fRegPath = new TString(regData->GetTitle());
98
99 }
100
101
102 void AliTPCSelectorESD::SlaveBegin(TTree * tree)
103 {
104    // The SlaveBegin() function is called after the Begin() function.
105    // When running with PROOF SlaveBegin() is called on each slave server.
106    // The tree argument is deprecated (on PROOF 0 is passed).
107   if (tree) fChain = tree;
108   Init(tree);
109   //
110   fNtracks       = new TH1I("ntracks","Number of tracks",100,0,400);
111   fNtracksFriend = new TH1I("ntracksF","Number of friend tracks",100,0,400);
112   fNClusters     = new TH1I("ncluster","Number of clusters",100,0,200);
113   fOutput->AddLast(fNtracks);
114   fOutput->AddLast(fNtracksFriend);
115   fOutput->AddLast(fNClusters);
116   
117
118 }
119
120 void   AliTPCSelectorESD::CleanESD(){
121   //
122   Bool_t isNew =  fESDevent!=0;
123   if (isNew) return;
124   
125
126   if (fESD!=0){
127     delete fESD;
128     fESD = 0;
129   }
130   if (fESDevent!=0){
131     delete fESDevent;
132     fESDevent=0;
133   }
134   if (fESDfriend){
135     delete fESDfriend;
136     fESDfriend =0;
137   }
138 }
139
140 Bool_t AliTPCSelectorESD::Process(Long64_t entry)
141 {
142    // The Process() function is called for each entry in the tree (or possibly
143    // keyed object in the case of PROOF) to be processed. The entry argument
144    // specifies which entry in the currently loaded tree is to be processed.
145    // It can be passed to either AliTPCSelectorESD::GetEntry() or TBranch::GetEntry()
146    // to read either all or the required parts of the data. When processing
147    // keyed objects with PROOF, the object is already loaded and is available
148    // via the fObject pointer.
149    //
150    // This function should contain the "body" of the analysis. It can contain
151    // simple or elaborate selection criteria, run algorithms on the data
152    // of the event and typically fill histograms.
153    //
154    // The processing can be stopped by calling Abort().
155    //
156    // Use fStatus to set the return value of TTree::Process().
157    //
158    // The return value is currently not used.
159
160   Int_t status = ProcessIn(entry);
161   if (fFileWatch) {
162     (*fFileWatch) << "__" << status ;
163   }
164   return (status==0);
165 }
166
167
168
169
170 Int_t   AliTPCSelectorESD::ReadEvent(Long64_t entry){
171   //
172   //
173   //
174
175
176   if (!fChain) return -1;  
177   if (!fChain->GetTree()) return -1; 
178   try {
179     fChain->GetTree()->GetEntry(entry);
180   } catch (std::bad_alloc) {
181     printf("Pica vyjebana pojebany skurveny kokot piciak\n");
182     //    fESD =0;
183     //fESDfriend = 0;
184     //fESDevent=0;
185     return -1;
186   }
187   //
188   // Info("Procces","0");
189   if (!fESD && !fESDevent) { 
190     //fESD = 0;
191     //fESDfriend = 0;
192     //CleanESD();
193     return -2;
194   }
195   Int_t ntracks = (fESD) ? fESD->GetNumberOfTracks() : fESDevent->GetNumberOfTracks();   
196
197   if (fESDevent){
198     fESDevent->SetESDfriend(fESDfriend);   
199   }
200
201
202   fNtracks->Fill(ntracks);
203   Info("Procces", Form("entry\t%d: Ntracks = %d",entry, ntracks));
204   
205   if (!fESDfriend || fESDfriend->GetNumberOfTracks() != ntracks) {
206     try {
207       delete fESD;
208     }
209     catch (std::bad_alloc) {
210       printf("Pica vyjebana pojebany skurveny kokot piciak\n");
211       fESD =0;
212       return -1;
213     }
214     //fESD = 0;
215     //fESDfriend = 0;
216     //fESD = 0;
217     //    CleanESD(); 
218     if (fESDfriend) fNtracksFriend->Fill(fESDfriend->GetNumberOfTracks());
219     Info("Procces","2: PROBLEM");
220     return -3;
221   }
222   if (fESD) fESD->SetESDfriend(fESDfriend);
223   return 0;
224 }
225
226
227 Int_t AliTPCSelectorESD::ProcessIn(Long64_t entry)
228 {
229   //
230   // User part of proccess method
231   //
232  
233   //
234   // USER code to go here
235   //
236   Int_t status = ReadEvent(entry);
237   if (status<0) return status; 
238   Int_t ntracks = (fESD) ? fESD->GetNumberOfTracks() : fESDevent->GetNumberOfTracks();   
239   //
240   AliTPCseed *seed;
241   AliTPCclusterMI cl;
242   Info("Procces", Form("entry\t%d: NtracksF = %d",entry,fESDfriend->GetNumberOfTracks() ));
243
244   for (Int_t tr = 0; tr < ntracks; tr++){ 
245     AliESDtrack *esdTrack = fESD ? (AliESDtrack*) fESD->GetTrack(tr): (AliESDtrack*) fESDevent->GetTrack(tr);
246     AliESDfriendTrack *friendtrack = (AliESDfriendTrack*) esdTrack->GetFriendTrack();
247     seed = 0;
248     TObject *cobject=0;
249     for (Int_t i=0;;i++){
250       cobject = friendtrack->GetCalibObject(i);
251       if (!cobject) break;
252       seed = dynamic_cast<AliTPCseed*>(cobject);
253       if (seed) break;
254     }
255     //
256     //Info("Process",Form("Proccessing track%d\n",tr));
257     if (seed) { 
258       fNClusters->Fill(seed->GetNumberOfClusters());
259       //
260       //
261     }
262   }
263   CleanESD();
264   return 0;
265   
266 }
267
268
269 void AliTPCSelectorESD::SlaveTerminate()
270 {
271    // The SlaveTerminate() function is called after all entries or objects
272    // have been processed. When running with PROOF SlaveTerminate() is called
273    // on each slave server.
274     printf ("SlaveTerminate.. \n");    
275     RegisterData();
276 }
277
278 void AliTPCSelectorESD::Terminate()
279 {
280    // The Terminate() function is the last function to be called during
281    // a query. It always runs on the client, it can be used to present
282    // the results graphically or save the results to file.
283    
284   printf ("Terminate... \n");
285   if (!fOutput) return;
286   TFile file("Output.root","recreate");
287   printf("fOutput contains the following: \n");
288   fOutput->Print();
289   printf("Trying to write the file 'Output.root'... \n");
290   fOutput->Write();
291   file.Close();
292   
293   
294 }
295
296
297
298 void AliTPCSelectorESD::Init(TTree *tree) 
299 {
300    // The Init() function is called when the selector needs to initialize
301    // a new tree or chain. Typically here the branch addresses and branch
302    // pointers of the tree will be set.
303    // It is normaly not necessary to make changes to the generated
304    // code, but the routine can be extended by the user if needed.
305    // Init() will be called many times when running on PROOF
306    // (once per file to be processed).
307
308    // Set branch addresses and branch pointers
309   static Int_t counter=0;
310   printf(Form("\nAliTPCSelectorESD::Init Accesing%d time\n",counter));
311   counter++;
312   if (!tree) return;
313   fChain = tree;
314   //if (counter>1) return;
315   tree->SetBranchStatus("*",1);
316   //
317   // New AliESDevent format
318   //
319   if (!fChain->GetBranch("ESD")){
320     //
321     //
322     //
323     if (fESDevent) delete fESDevent;
324      fESDevent = new AliESDEvent();
325      fESDevent->ReadFromTree(tree); // Attach the branch with ESD friends
326      fESDfriend = (AliESDfriend*)fESDevent->FindListObject("AliESDfriend");
327      tree->SetBranchAddress("ESDfriend.",&fESDfriend); 
328      return;
329   }
330   //
331   // if old format
332   //
333   
334
335
336    //   fChain->SetMakeClass(1);
337    fChain->SetBranchAddress("ESD",&fESD);
338    Info("Init","Enter");
339    Bool_t isOK=kFALSE;
340    if (fChain->GetBranch("ESDfriend")) {
341      fChain->SetBranchAddress("ESDfriend",&fESDfriend);
342      Info("Init","V0-ESDfriend.");
343      isOK=kTRUE;
344    }
345    if (fChain->GetBranch("ESDfriend.")){
346      Info("Init","V1-ESDfriend.");
347      fChain->SetBranchAddress("ESDfriend.",&fESDfriend);
348      isOK=kTRUE;
349    }
350    if (isOK) return;
351
352    //
353    // Try to solve problem
354    //
355
356    Info("Init","Problem");
357    if (tree->GetBranch("ESD")){
358      Info("InitTree",tree->GetBranch("ESD")->GetFile()->GetName());
359      char  fname[1000];
360      sprintf(fname,"%s/AliESDfriends.root",gSystem->DirName(tree->GetBranch("ESD")->GetFile()->GetName()));
361      Info("InitFile",fname);
362      if (tree->AddFriend("esdFriendTree",fname)){
363        Info("InitFileOK",fname);
364        if (fChain->GetBranch("ESDfriend")) {
365          fChain->SetBranchAddress("ESDfriend",&fESDfriend);
366          Info("Init","V0-ESDfriend.");
367          isOK=kTRUE;
368        }
369        if (fChain->GetBranch("ESDfriend.")){
370          Info("Init","V1-ESDfriend.");
371          fChain->SetBranchAddress("ESDfriend.",&fESDfriend);
372          isOK=kTRUE;
373        }       
374      }   
375    }
376 }
377
378
379
380 Bool_t AliTPCSelectorESD::Notify()
381 {
382    // The Notify() function is called when a new file is opened. This
383    // can be either for a new TTree in a TChain or when when a new TTree
384    // is started when using PROOF. It is normaly not necessary to make changes
385    // to the generated code, but the routine can be extended by the
386    // user if needed. The return value is currently not used.
387
388   ++fFileNo;
389   const char * fname = "UNKNOWN";
390   const char * hname = gSystem->HostName();
391   if (!fChain) return kFALSE;
392   if (fChain->GetCurrentFile()){
393     fname = fChain->GetCurrentFile()->GetName();
394   }
395   Info("Notify",Form("Host %s processing file no %d %s\n",hname,fFileNo,fname));
396
397   //
398   // Print statistic to log file
399   //
400 //   if (fname) {
401 //     (*fFileWatch) << endl;
402 //     (*fFileWatch) << hname   <<"\t"
403 //                << fname   <<"\t";
404 //   }
405   DumpSysInfo(-1);
406   
407   return kTRUE;
408 }
409
410 void    AliTPCSelectorESD::RegisterData(){
411   //
412   // Register persistent data
413   //
414   if (fRegPath){
415     gSystem->Exec(Form("mkdir %s/%s",fRegPath->Data(), gSystem->HostName()));
416     printf("Register data to\t%s\n",fRegPath->Data());
417     char command[1000];
418     sprintf(command,"cp *.log %s/%s/",fRegPath->Data(), gSystem->HostName());
419     gSystem->Exec(command);
420     sprintf(command,"cp *.root %s/%s/",fRegPath->Data(), gSystem->HostName());
421     gSystem->Exec(command);
422   }
423 }
424
425
426 void   AliTPCSelectorESD::DumpSysInfo(Int_t entry){
427   //
428   // dump system info to log file
429   // entry  - entry number in the chain
430   //
431   const char * fname = "UNKNOWN";
432   const char * hname = gSystem->HostName();
433   if (fChain->GetCurrentFile()){
434     fname = fChain->GetCurrentFile()->GetName();
435   }
436   //   //
437   if (fSysWatch){
438     TTimeStamp stamp;
439     CpuInfo_t  cpuInfo;
440     MemInfo_t  memInfo;
441     ProcInfo_t procInfo;
442     
443     gSystem->GetCpuInfo(&cpuInfo, 1000);
444     gSystem->GetMemInfo(&memInfo);
445     gSystem->GetProcInfo(&procInfo);
446     
447     (*fSysWatch) << hname   <<"\t"               // hname - hostname
448                  << fname   <<"\t"               // fname - filename
449                  << entry   <<"\t"               // entry - entry number
450                  << stamp.GetSec()<<"\t"         // time  - time stamp in seconds
451                  << memInfo.fMemUsed<<"\t"       //  
452                  << memInfo.fSwapUsed<<"\t"      //
453                  << procInfo.fMemResident<<"\t"  //
454                  << procInfo.fMemVirtual<<"\t"   //    
455                  << cpuInfo.fUser <<"\t"         //
456                  << cpuInfo.fSys  <<"\t"         //
457                  << procInfo.fCpuUser<<"\t"      //
458                  << procInfo.fCpuSys<<"\t"       //
459                  << endl;
460   }
461   AliSysInfo::AddStamp(fname);
462 }