]>
Commit | Line | Data |
---|---|---|
1 | /* $Id$ */ | |
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 | **************************************************************************/ | |
16 | //--------------------------------------------------------------------// | |
17 | // // | |
18 | // AliCFContainer Class // | |
19 | // Class to accumulate data on an N-dimensional grids, at different // | |
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" | |
29 | #include "AliCFGridSparse.h" | |
30 | #include "AliCFContainer.h" | |
31 | #include "TAxis.h" | |
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 | //____________________________________________________________________ | |
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) : | |
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 | |
68 | fGrid = new AliCFVGrid*[fNStep]; //the grids at the various selection steps | |
69 | char gname[30]; | |
70 | for(Int_t istep=0;istep<fNStep;istep++){ | |
71 | sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep); | |
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 | } | |
78 | fGrid[istep]->SumW2(); | |
79 | } | |
80 | } | |
81 | //____________________________________________________________________ | |
82 | AliCFContainer::AliCFContainer(const AliCFContainer& c) : | |
83 | AliCFFrame(), | |
84 | fNStep(c.fNStep), | |
85 | fGrid(c.fGrid) | |
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 | //____________________________________________________________________ | |
112 | void AliCFContainer::SetBinLimits(Int_t varindex, Double_t *array) | |
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 | //____________________________________________________________________ | |
149 | void AliCFContainer::Fill(Double_t *var, Int_t istep, Double_t weight) | |
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 | // | |
155 | if(istep >= fNStep || istep < 0){ | |
156 | AliError("Non-existent selection step, grid was not filled"); | |
157 | return; | |
158 | } | |
159 | fGrid[istep]->Fill(var,weight); | |
160 | } | |
161 | //___________________________________________________________________ | |
162 | TH1D *AliCFContainer::ShowProjection(Int_t ivar, Int_t istep) const | |
163 | { | |
164 | // | |
165 | // returns 1-D projection along variable ivar at selection step istep | |
166 | // | |
167 | if(istep >= fNStep || istep < 0){ | |
168 | AliError("Non-existent selection step, return NULL"); | |
169 | return 0x0; | |
170 | } | |
171 | if(ivar >= fNVar || ivar < 0){ | |
172 | AliError("Non-existent selection step, return NULL"); | |
173 | return 0x0; | |
174 | } | |
175 | ||
176 | return fGrid[istep]->Project(ivar); | |
177 | } | |
178 | //___________________________________________________________________ | |
179 | TH2D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t istep) const | |
180 | { | |
181 | // | |
182 | // returns 2-D projection along variables ivar1,ivar2 at selection step istep | |
183 | // | |
184 | if(istep >= fNStep || istep < 0){ | |
185 | AliError("Non-existent selection step, return NULL"); | |
186 | return 0x0; | |
187 | } | |
188 | if(ivar1 >= fNVar || ivar1 < 0 || ivar2 >= fNVar || ivar2 < 0){ | |
189 | AliError("Non-existent selection step, return NULL"); | |
190 | return 0x0; | |
191 | } | |
192 | ||
193 | return fGrid[istep]->Project(ivar1,ivar2); | |
194 | } | |
195 | //___________________________________________________________________ | |
196 | TH3D *AliCFContainer::ShowProjection(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const | |
197 | { | |
198 | // | |
199 | // returns 3-D projection along variables ivar1,ivar2,ivar3 | |
200 | // at selection step istep | |
201 | // | |
202 | if(istep >= fNStep || istep < 0){ | |
203 | AliError("Non-existent selection step, return NULL"); | |
204 | return 0x0; | |
205 | } | |
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 | ||
213 | return fGrid[istep]->Project(ivar1,ivar2,ivar3); | |
214 | } | |
215 | //___________________________________________________________________ | |
216 | TH1D *AliCFContainer::ShowSlice(Int_t ivar, Double_t *varMin, Double_t* varMax, Int_t istep) const | |
217 | { | |
218 | // | |
219 | // Make a slice along variable ivar at selection level istep in range [varMin,varMax] | |
220 | // | |
221 | if(istep >= fNStep || istep < 0){ | |
222 | AliError("Non-existent selection step, return NULL"); | |
223 | return 0x0; | |
224 | } | |
225 | if (ivar >= fNVar || ivar < 0) { | |
226 | AliError("Non-existent variable, return NULL"); | |
227 | return 0x0; | |
228 | } | |
229 | return (TH1D*)fGrid[istep]->Slice(ivar,varMin,varMax); | |
230 | } | |
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 | } | |
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 the array "vars[nVars]" for all the container steps. | |
268 | // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar] | |
269 | // The function returns a new container of nVars variables. | |
270 | // | |
271 | Int_t* steps = new Int_t[fNStep]; | |
272 | for (Int_t iStep=0;iStep<fNStep;iStep++) steps[iStep]=iStep; | |
273 | return MakeSlice(nVars,vars,varMin,varMax,fNStep,steps); | |
274 | } | |
275 | ||
276 | //____________________________________________________________________ | |
277 | AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, Int_t* vars, Double_t* varMin, Double_t* varMax, Int_t nSteps, Int_t* steps) const | |
278 | { | |
279 | // | |
280 | // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for the given "nSteps" defined in "steps[nSteps]". | |
281 | // The ranges of ALL the container variables must be defined in the array varMin[fNVar] and varMax[fNVar] | |
282 | // The function returns a new container of nVars variables. | |
283 | // | |
284 | ||
285 | if (nVars < 1 || nVars > fNVar) AliError("Bad number of dimensions required for the slice"); | |
286 | if (nSteps< 1 || nSteps> fNStep) AliError("Bad number of steps required for the slice"); | |
287 | ||
288 | //define new binning for new container | |
289 | Int_t* bins=new Int_t[nVars]; | |
290 | for (Int_t iVar=0; iVar<nVars; iVar++) bins[iVar] = fNVarBins[vars[iVar]]; | |
291 | AliCFContainer* out = new AliCFContainer(fName,fTitle,nSteps,nVars,bins); | |
292 | ||
293 | //set the bin limits | |
294 | for (Int_t iVar=0; iVar<nVars; iVar++) { | |
295 | Double_t *array = new Double_t[fNVarBins[vars[iVar]]+1]; | |
296 | GetBinLimits(vars[iVar],array); | |
297 | out->SetBinLimits(iVar,array); | |
298 | delete array; | |
299 | } | |
300 | ||
301 | //set grid for the given steps | |
302 | AliInfo(Form("Making a slice in %d dimension(s)",nVars)); | |
303 | for (Int_t iStep=0; iStep<nSteps; iStep++) out->SetGrid(iStep,fGrid[steps[iStep]]->Project(nVars,vars,varMin,varMax)); | |
304 | ||
305 | delete bins; | |
306 | return out; | |
307 | } | |
308 | ||
309 | //____________________________________________________________________ | |
310 | Long64_t AliCFContainer::Merge(TCollection* list) | |
311 | { | |
312 | // Merge a list of AliCorrection objects with this (needed for | |
313 | // PROOF). | |
314 | // Returns the number of merged objects (including this). | |
315 | ||
316 | if (!list) | |
317 | return 0; | |
318 | ||
319 | if (list->IsEmpty()) | |
320 | return 1; | |
321 | ||
322 | TIterator* iter = list->MakeIterator(); | |
323 | TObject* obj; | |
324 | ||
325 | Int_t count = 0; | |
326 | while ((obj = iter->Next())) { | |
327 | AliCFContainer* entry = dynamic_cast<AliCFContainer*> (obj); | |
328 | if (entry == 0) | |
329 | continue; | |
330 | this->Add(entry); | |
331 | count++; | |
332 | } | |
333 | ||
334 | return count+1; | |
335 | } | |
336 | ||
337 | //____________________________________________________________________ | |
338 | void AliCFContainer::Add(AliCFContainer* aContainerToAdd, Double_t c) | |
339 | { | |
340 | // | |
341 | //add the content of container aContainerToAdd to the current one | |
342 | // | |
343 | if( (aContainerToAdd->GetNStep()!=fNStep) | |
344 | || | |
345 | (aContainerToAdd->GetNVar()!=fNVar) | |
346 | || | |
347 | (aContainerToAdd->GetNDim()!=fNDim)){ | |
348 | AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers"); | |
349 | return; | |
350 | } | |
351 | for(Int_t istep=0;istep<fNStep;istep++){ | |
352 | fGrid[istep]->Add(aContainerToAdd->GetGrid(istep),c); | |
353 | } | |
354 | } | |
355 | //____________________________________________________________________ | |
356 | Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep) const { | |
357 | // | |
358 | // Get overflows in variable var at selection level istep | |
359 | // | |
360 | if(istep >= fNStep || istep < 0){ | |
361 | AliError("Non-existent selection step, return -1"); | |
362 | return -1.; | |
363 | } | |
364 | return fGrid[istep]->GetOverFlows(ivar); | |
365 | } | |
366 | //____________________________________________________________________ | |
367 | Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep) const { | |
368 | // | |
369 | // Get underflows in variable var at selection level istep | |
370 | // | |
371 | if(istep >= fNStep || istep < 0){ | |
372 | AliError("Non-existent selection step, return -1"); | |
373 | return -1.; | |
374 | } | |
375 | return fGrid[istep]->GetUnderFlows(ivar); | |
376 | } | |
377 | //____________________________________________________________________ | |
378 | Float_t AliCFContainer::GetEntries( Int_t istep) const { | |
379 | // | |
380 | // Get total entries in variable var at selection level istep | |
381 | // | |
382 | if(istep >= fNStep || istep < 0){ | |
383 | AliError("Non-existent selection step, return -1"); | |
384 | return -1.; | |
385 | } | |
386 | return fGrid[istep]->GetEntries(); | |
387 | } | |
388 | //____________________________________________________________________ | |
389 | Int_t AliCFContainer::GetEmptyBins( Int_t istep) const { | |
390 | // | |
391 | // Get empty bins in variable var at selection level istep | |
392 | // | |
393 | if(istep >= fNStep || istep < 0){ | |
394 | AliError("Non-existent selection step, return -1"); | |
395 | return -1; | |
396 | } | |
397 | return fGrid[istep]->GetEmptyBins(); | |
398 | } | |
399 | //____________________________________________________________________ | |
400 | Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const { | |
401 | // | |
402 | // Get empty bins in a range in variable var at selection level istep | |
403 | // | |
404 | if(istep >= fNStep || istep < 0){ | |
405 | AliError("Non-existent selection step, return -1"); | |
406 | return -1; | |
407 | } | |
408 | return fGrid[istep]->GetEmptyBins(varMin,varMax); | |
409 | } | |
410 | //_____________________________________________________________________ | |
411 | Double_t AliCFContainer::GetIntegral( Int_t istep) const | |
412 | { | |
413 | // | |
414 | // Get Integral over the grid at selection level istep | |
415 | // | |
416 | if(istep >= fNStep || istep < 0){ | |
417 | AliError("Non-existent selection step, return -1"); | |
418 | return -1.; | |
419 | } | |
420 | return fGrid[istep]->GetIntegral(); | |
421 | } | |
422 | //_____________________________________________________________________ | |
423 | Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const | |
424 | { | |
425 | // | |
426 | // Get Integral over the grid in a range at selection level istep | |
427 | // | |
428 | if(istep >= fNStep || istep < 0){ | |
429 | AliError("Non-existent selection step, return -1"); | |
430 | return -1.; | |
431 | } | |
432 | return fGrid[istep]->GetIntegral(varMin,varMax); | |
433 | } | |
434 | //_____________________________________________________________________ | |
435 | void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep) | |
436 | { | |
437 | // | |
438 | // set axis range at step istep | |
439 | // | |
440 | if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) { | |
441 | AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented"); | |
442 | return; | |
443 | } | |
444 | if (istep >= fNStep || istep < 0){ | |
445 | AliError("Non-existent selection step"); | |
446 | return ; | |
447 | } | |
448 | if (ivar >= fNVar || ivar < 0){ | |
449 | AliError("Non-existent selection var"); | |
450 | return ; | |
451 | } | |
452 | ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(ivar,varMin,varMax); | |
453 | } | |
454 | ||
455 | //_____________________________________________________________________ | |
456 | void AliCFContainer::SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep) | |
457 | { | |
458 | // | |
459 | // set all axis ranges at step istep according to varMin and varMax values | |
460 | // | |
461 | if ( strcmp(fGrid[istep]->ClassName(),"AliCFGrid") ==0 ) { | |
462 | AliWarning("Could not AliCFGrid::SetRangeUser(), function not implemented"); | |
463 | return; | |
464 | } | |
465 | if (istep >= fNStep || istep < 0){ | |
466 | AliError("Non-existent selection step"); | |
467 | return ; | |
468 | } | |
469 | ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(varMin,varMax); | |
470 | } |