]>
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> | |
db6722a5 | 28 | #include "AliCFGridSparse.h" |
563113d0 | 29 | #include "AliCFContainer.h" |
c8df672e | 30 | #include "TAxis.h" |
563113d0 | 31 | //____________________________________________________________________ |
32 | ClassImp(AliCFContainer) | |
33 | ||
34 | //____________________________________________________________________ | |
35 | AliCFContainer::AliCFContainer() : | |
36 | AliCFFrame(), | |
37 | fNStep(0), | |
38 | fGrid(0x0) | |
39 | { | |
40 | // | |
41 | // default constructor | |
42 | // | |
43 | } | |
44 | //____________________________________________________________________ | |
45 | AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title) : | |
46 | AliCFFrame(name,title), | |
47 | fNStep(0), | |
48 | fGrid(0x0) | |
49 | { | |
50 | // default constructor | |
51 | } | |
52 | ||
53 | //____________________________________________________________________ | |
fb494025 | 54 | AliCFContainer::AliCFContainer(const Char_t* name, const Char_t* title, const Int_t nSelSteps, const Int_t nVarIn, const Int_t* nBinIn) : |
55 | AliCFFrame(name,title), | |
56 | fNStep(nSelSteps), | |
563113d0 | 57 | fGrid(0x0) |
58 | { | |
59 | // | |
60 | // main constructor | |
61 | // | |
62 | ||
563113d0 | 63 | // The grids |
fb494025 | 64 | fGrid = new AliCFGridSparse*[fNStep]; //the grids at the various selection steps |
563113d0 | 65 | char gname[30]; |
fb494025 | 66 | for (Int_t istep=0; istep<fNStep; istep++) { |
563113d0 | 67 | sprintf(gname,"%s%s%i",GetName(),"_SelStep", istep); |
fb494025 | 68 | fGrid[istep] = new AliCFGridSparse(gname,title,nVarIn,nBinIn); |
69 | fGrid[istep]->SumW2(); | |
563113d0 | 70 | } |
fb494025 | 71 | AliInfo(Form("Grids created for %d steps required \n => Don't forget to set the bin limits !!",fNStep)); |
563113d0 | 72 | } |
73 | //____________________________________________________________________ | |
fb494025 | 74 | AliCFContainer::AliCFContainer(const AliCFContainer& c) : |
75 | AliCFFrame(c.fName,c.fTitle), | |
76 | fNStep(0), | |
77 | fGrid(0x0) | |
563113d0 | 78 | { |
79 | // | |
80 | // copy constructor | |
81 | // | |
fb494025 | 82 | c.Copy(*this); |
563113d0 | 83 | } |
84 | //____________________________________________________________________ | |
85 | AliCFContainer::~AliCFContainer() | |
86 | { | |
87 | // | |
88 | // destructor | |
89 | // | |
fb494025 | 90 | if (fGrid) delete [] fGrid; |
563113d0 | 91 | } |
92 | //____________________________________________________________________ | |
93 | AliCFContainer &AliCFContainer::operator=(const AliCFContainer &c) | |
94 | { | |
95 | // | |
96 | // assigment operator | |
97 | // | |
fb494025 | 98 | if (this != &c) c.Copy(*this); |
563113d0 | 99 | return *this; |
100 | } | |
fb494025 | 101 | |
563113d0 | 102 | //____________________________________________________________________ |
103 | void AliCFContainer::Copy(TObject& c) const | |
104 | { | |
105 | // | |
106 | // copy function | |
107 | // | |
fb494025 | 108 | AliCFFrame::Copy(c); |
563113d0 | 109 | AliCFContainer& target = (AliCFContainer &) c; |
fb494025 | 110 | target.fNStep = fNStep; |
111 | target.fGrid = new AliCFGridSparse*[fNStep]; | |
112 | for (Int_t iStep=0; iStep<fNStep; iStep++) { | |
113 | if (fGrid[iStep]) target.fGrid[iStep] = new AliCFGridSparse(*(fGrid[iStep])); | |
114 | } | |
563113d0 | 115 | } |
fb494025 | 116 | |
563113d0 | 117 | //____________________________________________________________________ |
fb494025 | 118 | void AliCFContainer::Fill(const Double_t *var, Int_t istep, Double_t weight) |
563113d0 | 119 | { |
120 | // | |
121 | // Fills the grid at selection step istep for a set of values of the | |
122 | // input variables, with a given weight (by default w=1) | |
123 | // | |
a2255142 | 124 | if(istep >= fNStep || istep < 0){ |
125 | AliError("Non-existent selection step, grid was not filled"); | |
126 | return; | |
127 | } | |
563113d0 | 128 | fGrid[istep]->Fill(var,weight); |
129 | } | |
130 | //___________________________________________________________________ | |
fb494025 | 131 | TH1D *AliCFContainer::Project(Int_t ivar, Int_t istep) const |
563113d0 | 132 | { |
133 | // | |
134 | // returns 1-D projection along variable ivar at selection step istep | |
135 | // | |
a2255142 | 136 | if(istep >= fNStep || istep < 0){ |
137 | AliError("Non-existent selection step, return NULL"); | |
138 | return 0x0; | |
139 | } | |
fb494025 | 140 | if(ivar >= GetNVar() || ivar < 0){ |
141 | AliError("Non-existent variable, return NULL"); | |
9105291d | 142 | return 0x0; |
143 | } | |
144 | ||
563113d0 | 145 | return fGrid[istep]->Project(ivar); |
146 | } | |
147 | //___________________________________________________________________ | |
fb494025 | 148 | TH2D *AliCFContainer::Project(Int_t ivar1, Int_t ivar2, Int_t istep) const |
563113d0 | 149 | { |
150 | // | |
151 | // returns 2-D projection along variables ivar1,ivar2 at selection step istep | |
152 | // | |
a2255142 | 153 | if(istep >= fNStep || istep < 0){ |
154 | AliError("Non-existent selection step, return NULL"); | |
155 | return 0x0; | |
156 | } | |
fb494025 | 157 | if(ivar1 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0){ |
158 | AliError("Non-existent variable, return NULL"); | |
9105291d | 159 | return 0x0; |
160 | } | |
161 | ||
563113d0 | 162 | return fGrid[istep]->Project(ivar1,ivar2); |
163 | } | |
164 | //___________________________________________________________________ | |
fb494025 | 165 | TH3D *AliCFContainer::Project(Int_t ivar1, Int_t ivar2, Int_t ivar3, Int_t istep) const |
563113d0 | 166 | { |
167 | // | |
168 | // returns 3-D projection along variables ivar1,ivar2,ivar3 | |
169 | // at selection step istep | |
170 | // | |
a2255142 | 171 | if(istep >= fNStep || istep < 0){ |
172 | AliError("Non-existent selection step, return NULL"); | |
173 | return 0x0; | |
174 | } | |
fb494025 | 175 | if(ivar1 >= GetNVar() || ivar1 < 0 || |
176 | ivar2 >= GetNVar() || ivar2 < 0 || | |
177 | ivar3 >= GetNVar() || ivar3 < 0 ) { | |
178 | AliError("Non-existent variable, return NULL"); | |
9105291d | 179 | return 0x0; |
180 | } | |
181 | ||
563113d0 | 182 | return fGrid[istep]->Project(ivar1,ivar2,ivar3); |
183 | } | |
184 | //___________________________________________________________________ | |
1e9dad92 | 185 | TH1D *AliCFContainer::ShowSlice(Int_t ivar, Double_t *varMin, Double_t* varMax, Int_t istep) const |
563113d0 | 186 | { |
187 | // | |
188 | // Make a slice along variable ivar at selection level istep in range [varMin,varMax] | |
189 | // | |
a2255142 | 190 | if(istep >= fNStep || istep < 0){ |
191 | AliError("Non-existent selection step, return NULL"); | |
192 | return 0x0; | |
193 | } | |
fb494025 | 194 | if (ivar >= GetNVar() || ivar < 0) { |
c8df672e | 195 | AliError("Non-existent variable, return NULL"); |
196 | return 0x0; | |
197 | } | |
1e9dad92 | 198 | return (TH1D*)fGrid[istep]->Slice(ivar,varMin,varMax); |
563113d0 | 199 | } |
c8df672e | 200 | //___________________________________________________________________ |
201 | TH2D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Double_t *varMin, Double_t* varMax, Int_t istep) const | |
202 | { | |
203 | // | |
204 | // Make a slice along variables ivar1 and ivar2 at selection level istep in range [varMin,varMax] | |
205 | // | |
206 | if(istep >= fNStep || istep < 0){ | |
207 | AliError("Non-existent selection step, return NULL"); | |
208 | return 0x0; | |
209 | } | |
fb494025 | 210 | if (ivar1 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0) { |
c8df672e | 211 | AliError("Non-existent variable, return NULL"); |
212 | return 0x0; | |
213 | } | |
214 | return (TH2D*)fGrid[istep]->Slice(ivar1,ivar2,varMin,varMax); | |
215 | } | |
216 | //___________________________________________________________________ | |
217 | TH3D *AliCFContainer::ShowSlice(Int_t ivar1, Int_t ivar2, Int_t ivar3, Double_t *varMin, Double_t* varMax, Int_t istep) const | |
218 | { | |
219 | // | |
220 | // Make a slice along variables ivar1, ivar2and ivar3 at selection level istep in range [varMin,varMax] | |
221 | // | |
222 | if(istep >= fNStep || istep < 0){ | |
223 | AliError("Non-existent selection step, return NULL"); | |
224 | return 0x0; | |
225 | } | |
fb494025 | 226 | if (ivar1 >= GetNVar() || ivar1 < 0 || ivar2 >= GetNVar() || ivar2 < 0 || ivar3 >= GetNVar() || ivar3 < 0) { |
c8df672e | 227 | AliError("Non-existent variable, return NULL"); |
228 | return 0x0; | |
229 | } | |
230 | return (TH3D*)fGrid[istep]->Slice(ivar1,ivar2,ivar3,varMin,varMax); | |
231 | } | |
9105291d | 232 | //____________________________________________________________________ |
fb494025 | 233 | AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax) const |
9105291d | 234 | { |
235 | // | |
38b1447f | 236 | // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for all the container steps. |
fb494025 | 237 | // The ranges of ALL the container variables must be defined in the array varMin[GetNVar()] and varMax[GetNVar()] |
38b1447f | 238 | // The function returns a new container of nVars variables. |
239 | // | |
240 | Int_t* steps = new Int_t[fNStep]; | |
241 | for (Int_t iStep=0;iStep<fNStep;iStep++) steps[iStep]=iStep; | |
9be0fa4e | 242 | AliCFContainer* out = MakeSlice(nVars,vars,varMin,varMax,fNStep,steps); |
243 | delete [] steps ; | |
244 | return out; | |
38b1447f | 245 | } |
246 | ||
247 | //____________________________________________________________________ | |
fb494025 | 248 | AliCFContainer* AliCFContainer::MakeSlice(Int_t nVars, const Int_t* vars, const Double_t* varMin, const Double_t* varMax, Int_t nSteps, const Int_t* steps) const |
38b1447f | 249 | { |
250 | // | |
251 | // Makes a slice along the "nVars" variables defined in the array "vars[nVars]" for the given "nSteps" defined in "steps[nSteps]". | |
fb494025 | 252 | // The ranges of ALL the container variables must be defined in the array varMin[GetNVar()] and varMax[GetNVar()] |
a8b83c87 | 253 | // The function returns a new container of nVars variables. |
9105291d | 254 | // |
255 | ||
fb494025 | 256 | if (nVars < 1 || nVars > GetNVar()) AliError("Bad number of dimensions required for the slice"); |
38b1447f | 257 | if (nSteps< 1 || nSteps> fNStep) AliError("Bad number of steps required for the slice"); |
9105291d | 258 | |
9be0fa4e | 259 | AliInfo(Form("Making a slice in %d dimension(s)",nVars)); |
260 | ||
261 | // create the output grids | |
fb494025 | 262 | AliCFGridSparse** grids = new AliCFGridSparse*[nSteps] ; |
9be0fa4e | 263 | for (Int_t iStep=0; iStep<nSteps; iStep++) grids[iStep] = fGrid[steps[iStep]]->Project(nVars,vars,varMin,varMax); |
264 | ||
265 | TAxis ** axis = new TAxis*[nVars]; | |
266 | for (Int_t iVar=0; iVar<nVars; iVar++) axis[iVar] = ((AliCFGridSparse*)grids[0])->GetGrid()->GetAxis(iVar); //same axis for every grid | |
267 | ||
9105291d | 268 | //define new binning for new container |
269 | Int_t* bins=new Int_t[nVars]; | |
9be0fa4e | 270 | for (Int_t iVar=0; iVar<nVars; iVar++) bins[iVar] = axis[iVar]->GetNbins(); |
271 | ||
38b1447f | 272 | AliCFContainer* out = new AliCFContainer(fName,fTitle,nSteps,nVars,bins); |
9105291d | 273 | |
274 | //set the bin limits | |
275 | for (Int_t iVar=0; iVar<nVars; iVar++) { | |
9be0fa4e | 276 | Int_t nBins = bins[iVar]; |
277 | Double_t *array = new Double_t[nBins+1]; | |
278 | for (Int_t iBin=1; iBin<=nBins; iBin++) { | |
279 | array[iBin-1] = axis[iVar]->GetBinLowEdge(iBin); | |
280 | } | |
281 | array[nBins] = axis[iVar]->GetBinUpEdge(nBins); | |
9105291d | 282 | out->SetBinLimits(iVar,array); |
9be0fa4e | 283 | delete [] array; |
9105291d | 284 | } |
285 | ||
38b1447f | 286 | //set grid for the given steps |
9be0fa4e | 287 | for (Int_t iStep=0; iStep<nSteps; iStep++) out->SetGrid(iStep,grids[iStep]); |
9105291d | 288 | |
289 | delete bins; | |
9be0fa4e | 290 | delete [] axis ; |
9105291d | 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 | //____________________________________________________________________ | |
fb494025 | 323 | void AliCFContainer::Add(const AliCFContainer* aContainerToAdd, Double_t c) |
563113d0 | 324 | { |
325 | // | |
326 | //add the content of container aContainerToAdd to the current one | |
327 | // | |
fb494025 | 328 | if ((aContainerToAdd->GetNStep() != fNStep) || |
329 | (aContainerToAdd->GetNVar() != GetNVar()) || | |
330 | (aContainerToAdd->GetNBinsTotal() != GetNBinsTotal())) | |
331 | { | |
332 | AliError("Different number of steps/sensitive variables/grid elements: cannot add the containers"); | |
333 | return; | |
334 | } | |
335 | for (Int_t istep=0; istep<fNStep; istep++) { | |
563113d0 | 336 | fGrid[istep]->Add(aContainerToAdd->GetGrid(istep),c); |
337 | } | |
338 | } | |
339 | //____________________________________________________________________ | |
fb494025 | 340 | Float_t AliCFContainer::GetOverFlows( Int_t ivar, Int_t istep, Bool_t exclusive) const { |
563113d0 | 341 | // |
342 | // Get overflows in variable var at selection level istep | |
fb494025 | 343 | // Set 'exclusive' to true for an exclusive check on variable ivar |
563113d0 | 344 | // |
a2255142 | 345 | if(istep >= fNStep || istep < 0){ |
346 | AliError("Non-existent selection step, return -1"); | |
347 | return -1.; | |
348 | } | |
fb494025 | 349 | return fGrid[istep]->GetOverFlows(ivar,exclusive); |
563113d0 | 350 | } |
351 | //____________________________________________________________________ | |
fb494025 | 352 | Float_t AliCFContainer::GetUnderFlows( Int_t ivar, Int_t istep, Bool_t exclusive) const { |
563113d0 | 353 | // |
a2255142 | 354 | // Get underflows in variable var at selection level istep |
fb494025 | 355 | // Set 'exclusive' to true for an exclusive check on variable ivar |
563113d0 | 356 | // |
a2255142 | 357 | if(istep >= fNStep || istep < 0){ |
358 | AliError("Non-existent selection step, return -1"); | |
359 | return -1.; | |
360 | } | |
fb494025 | 361 | return fGrid[istep]->GetUnderFlows(ivar,exclusive); |
563113d0 | 362 | } |
363 | //____________________________________________________________________ | |
fb494025 | 364 | Float_t AliCFContainer::GetEntries(Int_t istep) const { |
563113d0 | 365 | // |
a2255142 | 366 | // Get total entries in variable var at selection level istep |
563113d0 | 367 | // |
a2255142 | 368 | if(istep >= fNStep || istep < 0){ |
369 | AliError("Non-existent selection step, return -1"); | |
370 | return -1.; | |
371 | } | |
563113d0 | 372 | return fGrid[istep]->GetEntries(); |
373 | } | |
fb494025 | 374 | // //____________________________________________________________________ |
375 | // Int_t AliCFContainer::GetEmptyBins(Int_t istep) const { | |
376 | // // | |
377 | // // Get empty bins in variable var at selection level istep | |
378 | // // | |
379 | // if(istep >= fNStep || istep < 0){ | |
380 | // AliError("Non-existent selection step, return -1"); | |
381 | // return -1; | |
382 | // } | |
383 | // return fGrid[istep]->GetEmptyBins(); | |
384 | // } | |
385 | // //____________________________________________________________________ | |
386 | // Int_t AliCFContainer::GetEmptyBins( Int_t istep, Double_t *varMin, Double_t* varMax) const { | |
387 | // // | |
388 | // // Get empty bins in a range in variable var at selection level istep | |
389 | // // | |
390 | // if(istep >= fNStep || istep < 0){ | |
391 | // AliError("Non-existent selection step, return -1"); | |
392 | // return -1; | |
393 | // } | |
394 | // return fGrid[istep]->GetEmptyBins(varMin,varMax); | |
395 | // } | |
563113d0 | 396 | //_____________________________________________________________________ |
1e9dad92 | 397 | Double_t AliCFContainer::GetIntegral( Int_t istep) const |
563113d0 | 398 | { |
399 | // | |
a2255142 | 400 | // Get Integral over the grid at selection level istep |
563113d0 | 401 | // |
a2255142 | 402 | if(istep >= fNStep || istep < 0){ |
403 | AliError("Non-existent selection step, return -1"); | |
404 | return -1.; | |
405 | } | |
563113d0 | 406 | return fGrid[istep]->GetIntegral(); |
407 | } | |
408 | //_____________________________________________________________________ | |
fb494025 | 409 | // Double_t AliCFContainer::GetIntegral( Int_t istep, Double_t *varMin, Double_t* varMax ) const |
410 | // { | |
411 | // // | |
412 | // // Get Integral over the grid in a range at selection level istep | |
413 | // // | |
414 | // if(istep >= fNStep || istep < 0){ | |
415 | // AliError("Non-existent selection step, return -1"); | |
416 | // return -1.; | |
417 | // } | |
418 | // return fGrid[istep]->GetIntegral(varMin,varMax); | |
419 | // } | |
c8df672e | 420 | //_____________________________________________________________________ |
421 | void AliCFContainer::SetRangeUser(Int_t ivar, Double_t varMin, Double_t varMax, Int_t istep) | |
422 | { | |
423 | // | |
424 | // set axis range at step istep | |
425 | // | |
c8df672e | 426 | if (istep >= fNStep || istep < 0){ |
427 | AliError("Non-existent selection step"); | |
428 | return ; | |
429 | } | |
fb494025 | 430 | if (ivar >= GetNVar() || ivar < 0){ |
c8df672e | 431 | AliError("Non-existent selection var"); |
432 | return ; | |
433 | } | |
fb494025 | 434 | fGrid[istep]->SetRangeUser(ivar,varMin,varMax); |
9105291d | 435 | } |
436 | ||
437 | //_____________________________________________________________________ | |
438 | void AliCFContainer::SetRangeUser(Double_t* varMin, Double_t* varMax, Int_t istep) | |
439 | { | |
440 | // | |
441 | // set all axis ranges at step istep according to varMin and varMax values | |
442 | // | |
9105291d | 443 | if (istep >= fNStep || istep < 0){ |
444 | AliError("Non-existent selection step"); | |
445 | return ; | |
446 | } | |
447 | ((AliCFGridSparse*)fGrid[istep])->SetRangeUser(varMin,varMax); | |
c8df672e | 448 | } |