simplified efficiency projection
[u/mrichter/AliRoot.git] / CORRFW / AliCFFrame.cxx
CommitLineData
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// //
18// AliCFFrame Class //
19// Class to accumulate data on an N-dimensional grid, to be used //
20// as input to get corrections for Reconstruction & Trigger efficiency//
21// //
22// -- Author : S.Arcelli //
23// Still to be done: //
24// --Implement methods to merge cells //
25// --Interpolate among bins in a range //
26//--------------------------------------------------------------------//
27//
28//
29
30#include "TSystem.h"
9f6be3a2 31#include "TFile.h"
32#include "AliLog.h"
563113d0 33#include "AliCFFrame.h"
34
35//____________________________________________________________________
36ClassImp(AliCFFrame)
37
38//____________________________________________________________________
39AliCFFrame::AliCFFrame() :
40 TNamed(),
41 fNVar(0),
42 fNDim(0),
43 fNVarBinLimits(0),
44 fNVarBins(0x0),
45 fIndex(0x0),
46 fProduct(0x0),
47 fOffset(0x0),
48 fVarBinLimits(0x0)
49{
50 // default constructor
51}
52//____________________________________________________________________
53AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title) :
54 TNamed(name,title),
55 fNVar(0),
56 fNDim(0),
57 fNVarBinLimits(0),
58 fNVarBins(0x0),
59 fIndex(0x0),
60 fProduct(0x0),
61 fOffset(0x0),
62 fVarBinLimits(0x0)
63{
64 // named constructor
65}
66//____________________________________________________________________
1e9dad92 67AliCFFrame::AliCFFrame(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :
563113d0 68 TNamed(name,title),
69 fNVar(0),
70 fNDim(0),
71 fNVarBinLimits(0),
72 fNVarBins(0x0),
73 fIndex(0x0),
74 fProduct(0x0),
75 fOffset(0x0),
76 fVarBinLimits(0x0)
77{
78 //
79 // main constructor
80 //
81
82 //the number of variables on the grid
83 fNVar=nVarIn;
84
85 // the binning in each variable
86 fNVarBins= new Int_t[fNVar];
87
88 fIndex= new Int_t[fNVar];
89
90 Int_t ndimTot=1;
91 Int_t nbinTot=0;
92
93
94 //Calculate total number of elements and bins...
95
96 for(Int_t i=0;i<fNVar;i++){
97 fNVarBins[i]=nBinIn[i];
98 ndimTot*=nBinIn[i];
99 nbinTot+=(nBinIn[i]+1);
100 }
101
102
103 //total number of elements
104
105 fNDim=ndimTot;
106
107 fOffset= new Int_t[fNVar];
108 fProduct= new Int_t[fNVar];
109
110 for(Int_t ivar=0;ivar<fNVar;ivar++){
111 Int_t offset=0;
112 for(Int_t i =0;i<ivar;i++)offset+=(fNVarBins[i]+1);
113 fOffset[ivar]=offset;
114 Int_t prod=1;
115 for(Int_t i=0;i<ivar;i++)prod*=fNVarBins[i];
116 fProduct[ivar]=prod;
117 }
118
119 //The bin limits
120
121 fNVarBinLimits=nbinTot;
1e9dad92 122 fVarBinLimits=new Double_t[fNVarBinLimits];
563113d0 123 if(binLimitsIn){
124 for(Int_t i=0;i<fNVarBinLimits;i++){
125 fVarBinLimits[i] =binLimitsIn[i];
126 }
127 }
128}
129//____________________________________________________________________
130AliCFFrame::AliCFFrame(const AliCFFrame& c) :
131 TNamed(),
132 fNVar(0),
133 fNDim(0),
134 fNVarBinLimits(0),
135 fNVarBins(0x0),
136 fIndex(0x0),
137 fProduct(0x0),
138 fOffset(0x0),
139 fVarBinLimits(0x0)
140{
141 //
142 // copy constructor
143 //
144 ((AliCFFrame &)c).Copy(*this);
145}
146//____________________________________________________________________
147AliCFFrame::~AliCFFrame()
148{
149 //
150 // destructor
151 //
152 if(fNVarBins)delete [] fNVarBins;
153 if(fVarBinLimits)delete [] fVarBinLimits;
154 if(fIndex)delete [] fIndex;
155 if(fProduct)delete [] fProduct;
156 if(fOffset)delete [] fOffset;
157
158}
159//____________________________________________________________________
160AliCFFrame &AliCFFrame::operator=(const AliCFFrame &c)
161{
162 //
163 // assigment operator
164 //
165 if (this != &c)
166 ((AliCFFrame &) c).Copy(*this);
167 return *this;
168}
169//____________________________________________________________________
1e9dad92 170void AliCFFrame::SetBinLimits(Int_t ivar, Double_t *array)
563113d0 171{
172 //
173 // setting the arrays containing the bin limits
174 //
175 Int_t nbins=fNVarBins[ivar]+1;
176 for(Int_t i=0;i<nbins;i++){
177 fVarBinLimits[fOffset[ivar]+i] =array[i];
178 }
179}
180//____________________________________________________________________
1e9dad92 181void AliCFFrame::GetBinLimits(Int_t ivar, Double_t *array) const
563113d0 182{
183 //
184 // getting the arrays containing the bin limits
185 //
186 Int_t nbins=fNVarBins[ivar]+1;
187 for(Int_t i=0;i<nbins;i++){
188 array[i]=fVarBinLimits[fOffset[ivar]+i];
189 }
190}
191//____________________________________________________________________
192Int_t AliCFFrame::GetBinIndex(Int_t *ibin) const
193{
194 //
195 // getting the element number on the grid for a given set of bin indeces
d957dd37 196 //(here the numbering of bin indeces ranges from 0 to N-1)
563113d0 197 //
198 Int_t ind=ibin[fNVar-1];
199 for(Int_t i=fNVar-1;i>0;i--){
200 ind=ibin[i-1]+ind*fNVarBins[i-1];
201 }
202 return ind;
203}
204//____________________________________________________________________
205Int_t AliCFFrame::GetBinIndex(Int_t ivar, Int_t ind) const
206{
207 //
d957dd37 208 // getting the bin index on a given dim. ivar for a given element ind
209 // on the grid
210 //(here the numbering of bin indeces ranges from 0 to N-1)
563113d0 211 //
212 Int_t index=-1;
213 for(Int_t i=fNVar-1;i>=0;i--){
214 index=ind/fProduct[i];
215 fIndex[i]=index;
216 ind-=index*fProduct[i];
217 }
218
219 index=fIndex[ivar];
220 return index;
221}
222//____________________________________________________________________
223void AliCFFrame::GetBinIndex(Int_t ind, Int_t *bins ) const
224{
225 //
226 // getting the set of bin indeces for a given element ind on the grid
d957dd37 227 // (here the numbering of bin indeces ranges from 0 to N-1)
563113d0 228 //
229 Int_t index=-1;
230 for(Int_t i=fNVar-1;i>=0;i--){
231 index=ind/fProduct[i];
232 bins[i]=index;
233 ind-=index*fProduct[i];
234 }
235 return;
236}
237//____________________________________________________________________
1e9dad92 238Double_t AliCFFrame::GetBinCenter(Int_t ivar, Int_t ibin) const
563113d0 239{
240 //
1e9dad92 241 // getting the bin center of a given bin ibin along variable ivar
d957dd37 242 // (here the numbering of bin indeces in input
243 // ranges from 1 to N, TH1/2/3 and THnSparse convention)
563113d0 244 //
245
d957dd37 246 if(ibin>fNVarBins[ivar] || ibin==0){
247 AliWarning(Form("bin index out of range, number of bins in variable %i ranges from 1 to %i", ivar,fNVarBins[ivar]));
248 return -1;
249 }
250 Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin-1];
251 Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin];
1e9dad92 252 Double_t val=0.5*(binMin+binMax);
563113d0 253 return val;
254}
255//____________________________________________________________________
1e9dad92 256void AliCFFrame::GetBinCenters(Int_t *ibin, Double_t *binCenter) const
563113d0 257{
258 //
259 // gives the centers of the N-dim bin identified by a set of bin indeces
260 // invar
d957dd37 261 // (here the numbering of bin indeces in input
262 // ranges from 1 to N, TH1/2/3 and THnSparse convention)
563113d0 263 //
264 for(Int_t i=0;i<fNVar;i++){
265 binCenter[i]=GetBinCenter(i,ibin[i]);
266 }
1e9dad92 267} //____________________________________________________________________
268Double_t AliCFFrame::GetBinSize(Int_t ivar, Int_t ibin) const
269{
270 //
271 // getting the bin size on axis ivar of a given bin ibin
d957dd37 272 // (here the numbering of bin indeces in input
273 // ranges from 1 to N, TH1/2/3 and THnSparse convention)
1e9dad92 274 //
275
d957dd37 276 if(ibin>fNVarBins[ivar] || ibin==0){
277 AliWarning(Form("bin index out of range, number of bins in variable %i ranges from 1 to %i", ivar,fNVarBins[ivar]));
1e9dad92 278 return -1;
279 }
280
d957dd37 281 Double_t binMin=fVarBinLimits[fOffset[ivar]+ibin-1];
282 Double_t binMax=fVarBinLimits[fOffset[ivar]+ibin];
1e9dad92 283 Double_t val=binMax-binMin;
284 return val;
285}
286//____________________________________________________________________
287void AliCFFrame::GetBinSizes(Int_t *ibin, Double_t *binSizes) const
288{
289 //
290 // gives the sizes of the N-dim bin identified by a set of bin indeces
291 // ibin
d957dd37 292 // (here the numbering of bin indeces in input
293 // ranges from 1 to N, TH1/2/3 and THnSparse convention)
1e9dad92 294 //
295 for(Int_t i=0;i<fNVar;i++){
296 binSizes[i]=GetBinSize(i,ibin[i]);
297 }
563113d0 298}
1e9dad92 299
563113d0 300//____________________________________________________________________
301void AliCFFrame::Copy(TObject& c) const
302{
303 //
304 // copy function
305 //
306 AliCFFrame& target = (AliCFFrame &) c;
307
308 target.fNVar=fNVar;
309 target.fNDim=fNDim;
310 target.fNVarBinLimits=fNVarBinLimits;
311 if (fNVarBins)
312 target.fNVarBins = fNVarBins;
313 if (fVarBinLimits)
314 target.fVarBinLimits = fVarBinLimits;
315 if (fProduct)
316 target.fProduct = fProduct;
317 if (fOffset)
318 target.fOffset = fOffset;
319}
320//____________________________________________________________________
321void AliCFFrame::PrintBinLimits()
322{
323 //
324 // printing the array containing the bin limits
325 //
326 for(Int_t i=0;i<fNVarBinLimits;i++){
327 AliInfo(Form("bin limit index %i is: %f",i, fVarBinLimits[i]));
328 }
329}
330//____________________________________________________________________
331void AliCFFrame::PrintNBins()
332{
333 //
334 // printing the array containing the # of bins
335 //
336 for(Int_t i=0;i<fNVar;i++){
337 AliInfo(Form("bins in var %i are: %i",i, fNVarBins[i]));
338 }
339}
340//____________________________________________________________________
341void AliCFFrame::Save(const Char_t *outfile) const
342{
343 //
344 // Save the grid to a root file
345 //
346
347 const char *dirname = "./";
348 TString filename = outfile;
349 TFile *file=0x0;
350 if((gSystem->FindFile(dirname,filename))!=NULL){
351 file = new TFile( outfile,"UPDATE");
352 }
353 else{
354 file = new TFile( outfile,"RECREATE");
355 }
356 file->cd();
357 //write the object to a file
358 this->Write(GetName(),TObject::kSingleKey);
359 file->Close();
360 delete file;
361}