Added commet to explain AliAODTrack::fType, AliAODTrack::XAtDCA(), YAtDCA(), ZAtDCA...
[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisStatistics.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17 // Author: Andrei Gheata, 20/12/2010
18
19 //==============================================================================
20 // AliAnalysisStatistics - basic class for storing statistics for the processed
21 //   events. The object is mergeable and can be used for general purpose. In case
22 //   a AliAnalysisTaskStat is used, this will set the global statistics object
23 //   to the analysis manager and will update it for the accepted events.
24 //==============================================================================
25
26 #include "AliAnalysisStatistics.h"
27
28 #include "Riostream.h"
29 #include "TObjArray.h"
30 #include "TStopwatch.h"
31
32 #include "AliVEvent.h"
33
34 using std::cout;
35 using std::endl;
36 ClassImp(AliAnalysisStatistics)
37
38 //______________________________________________________________________________
39 AliAnalysisStatistics::AliAnalysisStatistics(const AliAnalysisStatistics &other)
40       :TNamed(other),
41        fNinput(other.fNinput),
42        fNprocessed(other.fNprocessed),
43        fNfailed(other.fNfailed),
44        fNaccepted(other.fNaccepted),
45        fOfflineMask(other.fOfflineMask),
46        fMaxTasks(other.fMaxTasks),
47        fNtasks(other.fNtasks),
48        fCurrentTask(other.fCurrentTask),
49        fTaskTimeReal(0),
50        fTaskTimeCPU(0),
51        fTaskNames(0),
52        fTaskTimer(0)
53 {
54 // Copy constructor.
55   if (fNtasks) {
56     fTaskTimer = new TStopwatch();
57     fTaskTimeReal = new Double_t[fMaxTasks];
58     memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
59     memcpy(fTaskTimeReal, other.fTaskTimeReal, fNtasks*sizeof(Double_t));
60     fTaskTimeCPU = new Double_t[fMaxTasks];
61     memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
62     memcpy(fTaskTimeCPU, other.fTaskTimeCPU, fNtasks*sizeof(Double_t));
63     fTaskNames = new TObjArray(fMaxTasks);
64     for (Int_t i=0; i<fNtasks; i++) fTaskNames->AddAt(new TObjString(other.GetTaskName(i)), i);
65   }
66 }
67
68 //______________________________________________________________________________
69 AliAnalysisStatistics &AliAnalysisStatistics::operator=(const AliAnalysisStatistics &other)
70 {
71 // Assignment.
72   if (&other == this) return *this;
73   fNinput       = other.fNinput;
74   fNprocessed   = other.fNprocessed;
75   fNfailed      = other.fNfailed;
76   fNaccepted    = other.fNaccepted;
77   fOfflineMask  = other.fOfflineMask;
78   fMaxTasks     = other.fMaxTasks;
79   fNtasks       = other.fNtasks;
80   fCurrentTask  = other.fCurrentTask;
81   fTaskTimeReal = 0;
82   fTaskTimeCPU  = 0;
83   fTaskNames    = 0;
84   fTaskTimer   = 0;
85   if (fNtasks) {
86     fTaskTimer = new TStopwatch();
87     fTaskTimeReal = new Double_t[fMaxTasks];
88     memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
89     memcpy(fTaskTimeReal, other.fTaskTimeReal, fNtasks*sizeof(Double_t));
90     fTaskTimeCPU = new Double_t[fMaxTasks];
91     memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
92     memcpy(fTaskTimeCPU, other.fTaskTimeCPU, fNtasks*sizeof(Double_t));
93     fTaskNames = new TObjArray(fMaxTasks);
94     for (Int_t i=0; i<fNtasks; i++) fTaskNames->AddAt(new TObjString(other.GetTaskName(i)), i);
95   }  
96   return *this;
97 }
98
99 //______________________________________________________________________________
100 void AliAnalysisStatistics::StartTimer(Int_t itask, const char *name, const char *classname)
101 {
102 // Measure the CPU time done by this task in the interval
103   if (!fTaskTimer) {
104     // Create the arrays with timings with the initial size
105     if (!fMaxTasks) fMaxTasks = 100;
106     fTaskTimer = new TStopwatch();
107     fTaskTimeReal = new Double_t[fMaxTasks];
108     memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
109     fTaskTimeCPU = new Double_t[fMaxTasks];
110     memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
111     fTaskNames = new TObjArray(fMaxTasks);
112   } else {
113   // Stop the timer if it was timing some task
114     StopTimer();
115   }  
116   
117   if (fNtasks<itask+1) {
118   // Double the array size
119     if (itask>=fMaxTasks) {
120       Int_t newsize = TMath::Max(2*fMaxTasks, itask+1);
121       Double_t *taskTimeReal = new Double_t[newsize];
122       memset(taskTimeReal, 0, newsize*sizeof(Double_t));
123       memcpy(taskTimeReal, fTaskTimeReal, fMaxTasks*sizeof(Double_t));
124       delete [] fTaskTimeReal;
125       fTaskTimeReal = taskTimeReal;
126       Double_t *taskTimeCPU = new Double_t[newsize];
127       memset(taskTimeCPU, 0, newsize*sizeof(Double_t));
128       memcpy(taskTimeCPU, fTaskTimeCPU, fMaxTasks*sizeof(Double_t));
129       delete [] fTaskTimeCPU;
130       fTaskTimeCPU = taskTimeCPU;
131       fMaxTasks = newsize;
132     }  
133     fNtasks = itask+1;
134   }
135   // Start the timer for the new task
136   fCurrentTask = itask;
137   if (!fTaskNames->At(fCurrentTask)) {
138     TString sname = name;
139     if (strlen(classname)) sname += Form("(%s)", classname);
140     fTaskNames->AddAt(new TObjString(sname), fCurrentTask);
141   }  
142   fTaskTimer->Start(kTRUE);  
143 }   
144
145 //______________________________________________________________________________
146 void AliAnalysisStatistics::StopTimer()
147 {
148 // Stop the current task timing.
149   if (fCurrentTask>=0) {
150     fTaskTimer->Stop();
151     fTaskTimeReal[fCurrentTask] += fTaskTimer->RealTime();
152     fTaskTimeCPU[fCurrentTask]  += fTaskTimer->CpuTime();
153     fCurrentTask = -1;
154   }
155 }  
156
157 //______________________________________________________________________________
158 Long64_t AliAnalysisStatistics::Merge(TCollection* list)
159 {
160 // Merge statistics objets from list on top of this.
161   TIter next(list);
162   AliAnalysisStatistics *current;
163   Long64_t count = 1;
164   while ((current = (AliAnalysisStatistics*)next())) {
165     fNinput     += current->GetNinput();
166     fNprocessed += current->GetNprocessed();
167     fNfailed    += current->GetNfailed();
168     fNaccepted  += current->GetNaccepted();
169     for (Int_t i=0; i<fNtasks; i++) {
170       fTaskTimeReal[i] += current->GetRealTime(i);
171       fTaskTimeCPU[i] += current->GetCPUTime(i);
172     }   
173   }
174   return count;
175 }
176
177 //______________________________________________________________________________
178 void AliAnalysisStatistics::Print(const Option_t *) const
179 {
180 // Print info about the processed statistics.
181   cout << "### Input events                 : " << fNinput << endl;
182   cout << "### Processed events w/o errors  : " << fNprocessed << endl;
183   cout << "### Failed events                : " << fNfailed << endl;
184   cout << "### Accepted events for mask: " << GetMaskAsString(fOfflineMask) << ": " << fNaccepted << endl;
185   if (fNtasks) {
186     cout << "Timing per task:" <<endl;
187     TString s;
188     for (Int_t i=0; i<fNtasks; i++) {
189       s = Form("%03d:  real: %9.2f   cpu: %9.2f   => %s", i,fTaskTimeReal[i], fTaskTimeCPU[i], GetTaskName(i));
190       cout << s << endl;
191     }
192   }  
193 }
194
195 //______________________________________________________________________________
196 const char *AliAnalysisStatistics::GetMaskAsString(UInt_t mask)
197 {
198 // Returns a string corresponding to the offline mask.
199    static TString smask;
200    smask = "ALL EVT.";
201    if (!mask) return smask.Data();
202    smask.Clear();
203    if (mask & AliVEvent::kMB)   smask = "MB";
204    if (mask & AliVEvent::kMUON) {
205       if (!smask.IsNull()) smask += " | ";
206       smask += "MUON";
207    }
208    if (mask & AliVEvent::kHighMult) {
209       if (!smask.IsNull()) smask += " | ";
210       smask += "HighMult";
211    }
212    if (mask & AliVEvent::kUserDefined) {
213       if (!smask.IsNull()) smask += " | ";
214       smask += "UserDefined";
215    }
216    if (mask ==  AliVEvent::kAny) smask = "ANY";
217    return smask.Data();
218 }
219
220 //______________________________________________________________________________
221 const char *AliAnalysisStatistics::GetTaskName(Int_t itask) const
222 {
223 // Returns task name
224   if (!fTaskNames || !fTaskNames->At(itask)) return 0;
225   return fTaskNames->At(itask)->GetName();
226 }
227