]>
Commit | Line | Data |
---|---|---|
563113d0 | 1 | /* $Id$ */ |
1e9dad92 | 2 | /************************************************************************** |
3 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
4 | * * | |
5 | * Author: The ALICE Off-line Project. * | |
6 | * Contributors are mentioned in the code where appropriate. * | |
7 | * * | |
8 | * Permission to use, copy, modify and distribute this software and its * | |
9 | * documentation strictly for non-commercial purposes is hereby granted * | |
10 | * without fee, provided that the above copyright notice appears in all * | |
11 | * copies and that both the copyright notice and this permission notice * | |
12 | * appear in the supporting documentation. The authors make no claims * | |
13 | * about the suitability of this software for any purpose. It is * | |
14 | * provided "as is" without express or implied warranty. * | |
15 | **************************************************************************/ | |
563113d0 | 16 | //--------------------------------------------------------------------// |
17 | // // | |
9105291d | 18 | // AliCFContainer Class // |
19 | // Class to accumulate data on an N-dimensional grids, at different // | |
563113d0 | 20 | // selection stages. To be used as an input to get corrections for // |
21 | // Reconstruction & Trigger efficiency // | |
22 | // // | |
23 | // -- Author : S.Arcelli // | |
24 | //--------------------------------------------------------------------// | |
25 | // | |
26 | // | |
27 | #include <AliLog.h> | |
28 | #include "AliCFGrid.h" | |
db6722a5 | 29 | #include "AliCFGridSparse.h" |
563113d0 | 30 | #include "AliCFContainer.h" |
c8df672e | 31 | #include "TAxis.h" |
563113d0 | 32 | //____________________________________________________________________ |
33 | ClassImp(AliCFContainer) | |
34 | ||
35 | //____________________________________________________________________ | |
36 | AliCFContainer::AliCFContainer() : | |
37 | AliCFFrame(), | |
38 | fNStep(0), | |
39 | fGrid(0x0) | |
40 | { | |
41 | // | |
42 | // default constructor | |
43 | // | |
44 | } | |
45 | //____________________________________________________________________ | |
46 | AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title) : | |
47 | AliCFFrame(name,title), | |
48 | fNStep(0), | |
49 | fGrid(0x0) | |
50 | { | |
51 | // default constructor | |
52 | } | |
53 | ||
54 | //____________________________________________________________________ | |
db6722a5 | 55 | AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title,const Int_t nSelSteps, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn, const Bool_t useSparse) : |
563113d0 | 56 | AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn), |
57 | fNStep(0), | |
58 | fGrid(0x0) | |
59 | { | |
60 | // | |
61 | // main constructor | |
62 | // | |
63 | ||
64 | // The selection steps | |
65 | fNStep=nSelSteps; | |
66 | ||
67 | // The grids | |
1e9dad92 | 68 | fGrid = new AliCFVGrid*[fNStep]; //the grids at the various selection steps |
563113d0 | 69 | char gname[30]; |
70 | for(Int_t istep=0;istep<fNStep;istep++){ | |
71 | sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep); | |
db6722a5 | 72 | if(!useSparse){ |
73 | fGrid[istep] = new AliCFGrid(gname,title,nVarIn,nBinIn,binLimitsIn); | |
74 | } | |
75 | else{ | |
76 | fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn,binLimitsIn); | |
77 | } | |
1e9dad92 | 78 | fGrid[istep]->SumW2(); |
563113d0 | 79 | } |
80 | } | |
81 | //____________________________________________________________________ | |
82 | AliCFContainer::AliCFContainer(const AliCFContainer& c) : | |
83 | AliCFFrame(), | |
318f64b1 | 84 | fNStep(c.fNStep), |
318f64b1 | 85 | fGrid(c.fGrid) |
563113d0 | 86 | { |
87 | // | |
88 | // copy constructor | |
89 | // | |
90 | ((AliCFContainer &)c).Copy(*this); | |
91 | } | |
92 | //____________________________________________________________________ | |
93 | AliCFContainer::~AliCFContainer() | |
94 | { | |
95 | // | |
96 | // destructor | |
97 | // | |
98 | if(fGrid)delete [] fGrid; | |
99 | ||
100 | } | |
101 | //____________________________________________________________________ | |
102 | AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c) | |
103 | { | |
104 | // | |
105 | // assigment operator | |
106 | // | |
107 | if (this != &c) | |
108 | ((AliCFContainer &) c).Copy(*this); | |
109 | return *this; | |
110 | } | |
111 | //____________________________________________________________________ | |
1e9dad92 | 112 | void AliCFContainer::SetBinLimits(Int_t varindex, Double_t *array) |
563113d0 | 113 | { |
114 | // | |
115 | // setting the arrays containing the bin limits | |
116 | // | |
117 | Int_t nbins=fNVarBins[varindex]+1; | |
118 | for(Int_t i=0;i<nbins;i++){ | |
119 | fVarBinLimits[fOffset[varindex]+i] =array[i]; | |
120 | } | |
121 | for(Int_t istep=0;istep<fNStep;istep++){ | |
122 | fGrid[istep]->SetBinLimits(varindex,array); | |
123 | } | |
124 | } | |
125 | //____________________________________________________________________ | |
126 | void AliCFContainer::Copy(TObject& c) const | |
127 | { | |
128 | // | |
129 | // copy function | |
130 | // | |
131 | AliCFContainer& target = (AliCFContainer &) c; | |
132 | target.fNStep=fNStep; | |
133 | target.fNVar=fNVar; | |
134 | target.fNDim=fNDim; | |
135 | target.fNVarBinLimits=fNVarBinLimits; | |
136 | if (fNVarBins) | |
137 | target.fNVarBins = fNVarBins; | |
138 | if (fVarBinLimits) | |
139 | target.fVarBinLimits = fVarBinLimits; | |
140 | if (fGrid) | |
141 | target.fGrid = fGrid; | |
142 | for(Int_t istep=0;istep<fNStep;istep++){ | |
143 | for(Int_t iel=0;iel<fNDim;iel++){ | |
144 | target.fGrid[istep]->SetElement(iel,fGrid[istep]->GetElement(iel)); | |
145 | } | |
146 | } | |
147 | } | |
148 | //____________________________________________________________________ | |
1e9dad92 | 149 | void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight) |
563113d0 | 150 | { |
151 | // | |
152 | // Fills the grid at selection step istep for a set of values of the | |
153 | // input variables, with a given weight (by default w=1) | |
154 | // | |
a2255142 | 155 | if(istep >= fNStep || istep < 0){ |
156 | AliError("Non-existent selection step, grid was not filled"); | |
157 | return; | |
158 | } | |
563113d0 | 159 | fGrid[istep]->Fill(var,weight); |
160 | } | |
161 | //___________________________________________________________________ | |
1e9dad92 | 162 | TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const |
563113d0 | 163 | { |
164 | // | |
165 | // returns 1-D projection along variable ivar at selection step istep | |
166 | // | |
a2255142 | 167 | if(istep >= fNStep || istep < 0){ |
168 | AliError("Non-existent selection step, return NULL"); | |
169 | return 0x0; | |
170 | } | |
9105291d | 171 | if(ivar >= fNVar || ivar < 0){ |
172 | AliError("Non-existent selection step, return NULL"); | |
173 | return 0x0; | |
174 | } | |
175 | ||
563113d0 | 176 | return fGrid[istep]->Project(ivar); |
177 | } | |
178 | //___________________________________________________________________ | |
1e9dad92 | 179 | TH2D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) const |
563113d0 | 180 | { |
181 | // | |
182 | // returns 2-D projection along variables ivar1,ivar2 at selection step istep | |
183 | // | |
a2255142 | 184 | if(istep >= fNStep || istep < 0){ |
185 | AliError("Non-existent selection step, return NULL"); | |
186 | return 0x0; | |
187 | } | |
9105291d | 188 | if(ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0){ |
189 | AliError("Non-existent selection step, return NULL"); | |
190 | return 0x0; | |
191 | } | |
192 | ||
563113d0 | 193 | return fGrid[istep]->Project(ivar1,ivar2); |
194 | } | |
195 | //___________________________________________________________________ | |
1e9dad92 | 196 | TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const |
563113d0 | 197 | { |
198 | // | |
199 | // returns 3-D projection along variables ivar1,ivar2,ivar3 | |
200 | // at selection step istep | |
201 | // | |
a2255142 | 202 | if(istep >= fNStep || istep < 0){ |
203 | AliError("Non-existent selection step, return NULL"); | |
204 | return 0x0; | |
205 | } | |
9105291d | 206 | if(ivar1 >= fNVar || ivar1 < 0 || |
207 | ivar2 >= fNVar || ivar2 < 0 || | |
208 | ivar3 >= fNVar || ivar3 < 0 ) { | |
209 | AliError("Non-existent selection step, return NULL"); | |
210 | return 0x0; | |
211 | } | |
212 | ||
563113d0 | 213 | return fGrid[istep]->Project(ivar1,ivar2,ivar3); |
214 | } | |
215 | //___________________________________________________________________ | |
1e9dad92 | 216 | TH1D *AliCFContainer::ShowSlice(Int_t ivar, Double_t *varMin, Double_t* varMax, Int_t istep) const |
563113d0 | 217 | { |
218 | // | |
219 | // Make a slice along variable ivar at selection level istep in range [varMin,varMax] | |
220 | // | |
a2255142 | 221 | if(istep >= fNStep || istep < 0){ |
222 | AliError("Non-existent selection step, return NULL"); | |
223 | return 0x0; | |
224 | } | |
c8df672e | 225 | if (ivar >= fNVar || ivar < 0) { |
226 | AliError("Non-existent variable, return NULL"); | |
227 | return 0x0; | |
228 | } | |
1e9dad92 | 229 | return (TH1D*)fGrid[istep]->Slice(ivar,varMin,varMax); |
563113d0 | 230 | } |
c8df672e | 231 | //___________________________________________________________________ |
232 | TH2D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t* varMax, Int_t istep) const | |
233 | { | |
234 | // | |
235 | // Make a slice along variables ivar1 and ivar2 at selection level istep in range [varMin,varMax] | |
236 | // | |
237 | if(istep >= fNStep || istep < 0){ | |
238 | AliError("Non-existent selection step, return NULL"); | |
239 | return 0x0; | |
240 | } | |
241 | if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0) { | |
242 | AliError("Non-existent variable, return NULL"); | |
243 | return 0x0; | |
244 | } | |
245 | return (TH2D*)fGrid[istep]->Slice(ivar1,ivar2,varMin,varMax); | |
246 | } | |
247 | //___________________________________________________________________ | |
248 | TH3D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t* varMax, Int_t istep) const | |
249 | { | |
250 | // | |
251 | // Make a slice along variables ivar1, ivar2and ivar3 at selection level istep in range [varMin,varMax] | |
252 | // | |
253 | if(istep >= fNStep || istep < 0){ | |
254 | AliError("Non-existent selection step, return NULL"); | |
255 | return 0x0; | |
256 | } | |
257 | if (ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0 || ivar3 >= fNVar || ivar3 < 0) { | |
258 | AliError("Non-existent variable, return NULL"); | |
259 | return 0x0; | |
260 | } | |
261 | return (TH3D*)fGrid[istep]->Slice(ivar1,ivar2,ivar3,varMin,varMax); | |
262 | } | |
9105291d | 263 | //____________________________________________________________________ |
264 | AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax) const | |
265 | { | |
266 | // | |
267 | // Makes a slice along the "nVars" variables defined in "vars" in range [varMin,varMax] | |
268 | // and returns a new container | |
269 | // | |
270 | ||
271 | if (nVars < 1 || nVars > fNVar) AliError("Bad number of dimensions required for the slice"); | |
272 | ||
273 | //define new binning for new container | |
274 | Int_t* bins=new Int_t[nVars]; | |
275 | for (Int_t iVar=0; iVar<nVars; iVar++) bins[iVar] = fNVarBins[vars[iVar]]; | |
276 | AliCFContainer* out = new AliCFContainer(fName,fTitle,fNStep,nVars,bins); | |
277 | ||
278 | //set the bin limits | |
279 | for (Int_t iVar=0; iVar<nVars; iVar++) { | |
280 | Double_t *array = new Double_t[fNVarBins[vars[iVar]]+1]; | |
281 | GetBinLimits(vars[iVar],array); | |
282 | out->SetBinLimits(iVar,array); | |
283 | delete array; | |
284 | } | |
285 | ||
286 | //set grid for each step | |
287 | AliInfo(Form("Making a slice in %d dimension(s)",nVars)); | |
288 | for (Int_t iStep=0; iStep<fNStep; iStep++) out->SetGrid(iStep,fGrid[iStep]->Project(nVars,vars,varMin,varMax)); | |
289 | ||
290 | delete bins; | |
291 | return out; | |
292 | } | |
293 | ||
563113d0 | 294 | //____________________________________________________________________ |
295 | Long64_t AliCFContainer::Merge(TCollection* list) | |
296 | { | |
297 | // Merge a list of AliCorrection objects with this (needed for | |
298 | // PROOF). | |
299 | // Returns the number of merged objects (including this). | |
300 | ||
301 | if (!list) | |
302 | return 0; | |
303 | ||
304 | if (list->IsEmpty()) | |
305 | return 1; | |
306 | ||
307 | TIterator* iter = list->MakeIterator(); | |
308 | TObject* obj; | |
309 | ||
310 | Int_t count = 0; | |
311 | while ((obj = iter->Next())) { | |
312 | AliCFContainer* entry = dynamic_cast<AliCFContainer*> (obj); | |
313 | if (entry == 0) | |
314 | continue; | |
315 | this->Add(entry); | |
316 | count++; | |
317 | } | |
318 | ||
319 | return count+1; | |
320 | } | |
321 | ||
322 | //____________________________________________________________________ | |
1e9dad92 | 323 | void AliCFContainer::Add(AliCFContainer* aContainerToAdd, Double_t c) |
563113d0 | 324 | { |
325 | // | |
326 | //add the content of container aContainerToAdd to the current one | |
327 | // | |
a2255142 | 328 | if( (aContainerToAdd->GetNStep()!=fNStep) |
329 | || | |
330 | (aContainerToAdd->GetNVar()!=fNVar) | |
331 | || | |
332 | (aContainerToAdd->GetNDim()!=fNDim)){ | |
333 | AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers"); | |
334 | return; | |
335 | } | |
563113d0 | 336 | for(Int_t istep=0;istep<fNStep;istep++){ |
337 | fGrid[istep]->Add(aContainerToAdd->GetGrid(istep),c); | |
338 | } | |
339 | } | |
340 | //____________________________________________________________________ | |
341 | Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep) const { | |
342 | // | |
343 | // Get overflows in variable var at selection level istep | |
344 | // | |
a2255142 | 345 | if(istep >= fNStep || istep < 0){ |
346 | AliError("Non-existent selection step, return -1"); | |
347 | return -1.; | |
348 | } | |
563113d0 | 349 | return fGrid[istep]->GetOverFlows(ivar); |
350 | } | |
351 | //____________________________________________________________________ | |
563113d0 | 352 | Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep) const { |
353 | // | |
a2255142 | 354 | // Get underflows in variable var at selection level istep |
563113d0 | 355 | // |
a2255142 | 356 | if(istep >= fNStep || istep < 0){ |
357 | AliError("Non-existent selection step, return -1"); | |
358 | return -1.; | |
359 | } | |
563113d0 | 360 | return fGrid[istep]->GetUnderFlows(ivar); |
361 | } | |
362 | //____________________________________________________________________ | |
563113d0 | 363 | Float_t AliCFContainer::GetEntries( Int_t istep) const { |
364 | // | |
a2255142 | 365 | // Get total entries in variable var at selection level istep |
563113d0 | 366 | // |
a2255142 | 367 | if(istep >= fNStep || istep < 0){ |
368 | AliError("Non-existent selection step, return -1"); | |
369 | return -1.; | |
370 | } | |
563113d0 | 371 | return fGrid[istep]->GetEntries(); |
372 | } | |
373 | //____________________________________________________________________ | |
374 | Int_t AliCFContainer::GetEmptyBins( Int_t istep) const { | |
375 | // | |
a2255142 | 376 | // Get empty bins in variable var at selection level istep |
563113d0 | 377 | // |
a2255142 | 378 | if(istep >= fNStep || istep < 0){ |
379 | AliError("Non-existent selection step, return -1"); | |
380 | return -1; | |
381 | } | |
563113d0 | 382 | return fGrid[istep]->GetEmptyBins(); |
383 | } | |
384 | //____________________________________________________________________ | |
1e9dad92 | 385 | Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const { |
563113d0 | 386 | // |
a2255142 | 387 | // Get empty bins in a range in variable var at selection level istep |
563113d0 | 388 | // |
a2255142 | 389 | if(istep >= fNStep || istep < 0){ |
390 | AliError("Non-existent selection step, return -1"); | |
391 | return -1; | |
392 | } | |
563113d0 | 393 | return fGrid[istep]->GetEmptyBins(varMin,varMax); |
394 | } | |
395 | //_____________________________________________________________________ | |
1e9dad92 | 396 | Double_t AliCFContainer::GetIntegral( Int_t istep) const |
563113d0 | 397 | { |
398 | // | |
a2255142 | 399 | // Get Integral over the grid at selection level istep |
563113d0 | 400 | // |
a2255142 | 401 | if(istep >= fNStep || istep < 0){ |
402 | AliError("Non-existent selection step, return -1"); | |
403 | return -1.; | |
404 | } | |
563113d0 | 405 | return fGrid[istep]->GetIntegral(); |
406 | } | |
407 | //_____________________________________________________________________ | |
1e9dad92 | 408 | Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const |
563113d0 | 409 | { |
410 | // | |
a2255142 | 411 | // Get Integral over the grid in a range at selection level istep |
563113d0 | 412 | // |
a2255142 | 413 | if(istep >= fNStep || istep < 0){ |
414 | AliError("Non-existent selection step, return -1"); | |
415 | return -1.; | |
416 | } | |
563113d0 | 417 | return fGrid[istep]->GetIntegral(varMin,varMax); |
418 | } | |
c8df672e | 419 | //_____________________________________________________________________ |
420 | void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep) | |
421 | { | |
422 | // | |
423 | // set axis range at step istep | |
424 | // | |
425 | if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) { | |
426 | AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented"); | |
427 | return; | |
428 | } | |
429 | if (istep >= fNStep || istep < 0){ | |
430 | AliError("Non-existent selection step"); | |
431 | return ; | |
432 | } | |
433 | if (ivar >= fNVar || ivar < 0){ | |
434 | AliError("Non-existent selection var"); | |
435 | return ; | |
436 | } | |
9105291d | 437 | ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(ivar,varMin,varMax); |
438 | } | |
439 | ||
440 | //_____________________________________________________________________ | |
441 | void AliCFContainer::SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep) | |
442 | { | |
443 | // | |
444 | // set all axis ranges at step istep according to varMin and varMax values | |
445 | // | |
446 | if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) { | |
447 | AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented"); | |
448 | return; | |
449 | } | |
450 | if (istep >= fNStep || istep < 0){ | |
451 | AliError("Non-existent selection step"); | |
452 | return ; | |
453 | } | |
454 | ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(varMin,varMax); | |
c8df672e | 455 | } |