added low and high flux parameters to the array
[u/mrichter/AliRoot.git] / CORRFW / AliCFVGrid.cxx
CommitLineData
1e9dad92 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// //
17// AliCFVGrid Class //
18// Just an interface to handle both AliCFGrid and AliCFGridSparse //
19// implementations //
20// //
21// -- Author : S.Arcelli //
22//--------------------------------------------------------------------//
23//
24//
25#include "AliCFVGrid.h"
26#include "TMath.h"
27#include <AliLog.h>
28
29//____________________________________________________________________
30ClassImp(AliCFVGrid)
31
32//____________________________________________________________________
33AliCFVGrid::AliCFVGrid() :
34 AliCFFrame(),
318f64b1 35 fExclOffEntriesInProj(kTRUE),
1e9dad92 36 fSumW2(kFALSE)
37{
38 // default constructor
39}
40//____________________________________________________________________
41AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title) :
42 AliCFFrame(name,title),
318f64b1 43 fExclOffEntriesInProj(kTRUE),
1e9dad92 44 fSumW2(kFALSE)
45{
46 // default constructor
47}
48
49//____________________________________________________________________
50AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :
51 AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
318f64b1 52 fExclOffEntriesInProj(kTRUE),
1e9dad92 53 fSumW2(kFALSE)
54{
55 //
56 // main constructor
57 //
58
59}
60
61//____________________________________________________________________
62AliCFVGrid::AliCFVGrid(const AliCFVGrid& c) :
63 AliCFFrame(c),
318f64b1 64 fExclOffEntriesInProj(c.fExclOffEntriesInProj),
1e9dad92 65 fSumW2(c.fSumW2)
66{
67 //
68 // copy constructor
69 //
70 ((AliCFVGrid &)c).Copy(*this);
71
72}
73//____________________________________________________________________
74AliCFVGrid::~AliCFVGrid()
75{
76 //
77 // destructor
78 //
79}
80
81//____________________________________________________________________
82AliCFVGrid &AliCFVGrid::operator=(const AliCFVGrid &c)
83{
84 //
85 // assigment operator
86 //
87 if (this != &c)
88 AliCFFrame::operator=(c);
89 return *this;
90}
91
92//____________________________________________________________________
93void AliCFVGrid::Copy(TObject& c) const
94{
95 //
96 // copy function
97 //
98 AliCFVGrid& target = (AliCFVGrid &) c;
99
100 target.fSumW2=fSumW2;
101}
102
103//____________________________________________________________________
104void AliCFVGrid::Scale(Int_t index, Double_t *fact)
105{
106 //
107 //scale content of a certain cell by (positive) fact (with error)
108 //
109 if(GetElement(index)==0 || fact[0]==0)return;
110
111 Double_t in[2], out[2];
112 in[0]=GetElement(index);
113 in[1]=GetElementError(index);
114 GetScaledValues(fact,in,out);
115 SetElement(index,out[0]);
116 if(fSumW2)SetElementError(index,out[1]);
117}
118//____________________________________________________________________
119void AliCFVGrid::Scale(Int_t *bin, Double_t *fact)
120{
121 //
122 //scale content of a certain cell by (positive) fact (with error)
123 //
124 if(GetElement(bin)==0 || fact[0]==0)return;
125
126 Double_t in[2], out[2];
127 in[0]=GetElement(bin);
128 in[1]=GetElementError(bin);
129 GetScaledValues(fact,in,out);
130 SetElement(bin,out[0]);
131 if(fSumW2)SetElementError(bin,out[1]);
132
133}
134//____________________________________________________________________
135void AliCFVGrid::Scale(Double_t *var, Double_t *fact)
136{
137 //
138 //scale content of a certain cell by (positive) fact (with error)
139 //
140 if(GetElement(var)==0 || fact[0]==0)return;
141
142 Double_t in[2], out[2];
143 in[0]=GetElement(var);
144 in[1]=GetElementError(var);
145 GetScaledValues(fact,in,out);
146 SetElement(var,out[0]);
147 if(fSumW2)SetElementError(var,out[1]);
148
149}
150//____________________________________________________________________
151void AliCFVGrid::Scale( Double_t *fact)
152{
153 //
154 //scale contents of the whole grid by fact
155 //
156
157 for(Int_t iel=0;iel<fNDim;iel++){
158 Scale(iel,fact);
159 }
160}
161
162//____________________________________________________________________
163Int_t AliCFVGrid::GetEmptyBins() const {
164 //
165 // Get empty bins
166 //
167 Int_t val=0;
168 for(Int_t i=0;i<fNDim;i++){
169 if(GetElement(i)<=0)val++;
170 }
171 return val;
172}
173//_____________________________________________________________________
174Int_t AliCFVGrid::GetEmptyBins( Double_t *varMin, Double_t* varMax ) const
175{
176 //
177 // Get empty bins in a range
178 //
179
180 Int_t *indexMin=new Int_t[fNVar];
181 Int_t *indexMax=new Int_t[fNVar];
182
183 //Find out the min and max bins
184
185 for(Int_t i=0;i<fNVar;i++){
186 Double_t xmin=varMin[i]; // the min values
187 Double_t xmax=varMax[i]; // the min values
188 Int_t nbins=fNVarBins[i]+1;
189 Double_t *bins=new Double_t[nbins];
190 for(Int_t ibin =0;ibin<nbins;ibin++){
191 bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
192 }
193 indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
194 indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
195 delete [] bins;
196 }
197
198 Int_t val=0;
199 for(Int_t i=0;i<fNDim;i++){
200 for (Int_t j=0;j<fNVar;j++)fIndex[j]=GetBinIndex(j,i);
201 Bool_t isIn=kTRUE;
202 for (Int_t j=0;j<fNVar;j++){
203 if(!(fIndex[j]>=indexMin[j] && fIndex[j]<=indexMax[j]))isIn=kFALSE;
204 }
205 if(isIn && GetElement(i)<=0)val++;
206 }
207 AliInfo(Form(" the empty bins = %i ",val));
208
209 delete [] indexMin;
210 delete [] indexMax;
211 return val;
212}
213//____________________________________________________________________
214Int_t AliCFVGrid::CheckStats(Double_t thr) const
215{
216 //
217 // Count the cells below a certain threshold
218 //
219 Int_t ncellsLow=0;
220 for(Int_t i=0;i<fNDim;i++){
221 if(GetElement(i)<thr)ncellsLow++;
222 }
223 return ncellsLow;
224}
225//_____________________________________________________________________
226Double_t AliCFVGrid::GetIntegral() const
227{
228 //
229 // Get full Integral
230 //
231 Double_t val=0;
232 for(Int_t i=0;i<fNDim;i++){
233 val+=GetElement(i);
234 }
235 return val;
236}
237//_____________________________________________________________________
238Double_t AliCFVGrid::GetIntegral(Int_t *binMin, Int_t* binMax ) const
239{
240 //
241 // Get Integral in a range of bin indeces (extremes included)
242 //
243
244 Double_t val=0;
245
246 for(Int_t i=0;i<fNVar;i++){
247 if(binMin[i]<1)binMin[i]=1;
248 if(binMax[i]>fNVarBins[i])binMax[i]=fNVarBins[i];
249 if((binMin[i]>binMax[i])){
250 AliInfo(Form(" Bin indeces in variable %i in reverse order, please check!", i));
251 return val;
252 }
253 }
254 val=GetSum(0,binMin,binMax);
255
256 return val;
257
258}
259//_____________________________________________________________________
260Double_t AliCFVGrid::GetIntegral(Double_t *varMin, Double_t* varMax ) const
261{
262 //
263 // Get Integral in a range (extremes included)
264 //
265
266 Int_t *indexMin=new Int_t[fNVar];
267 Int_t *indexMax=new Int_t[fNVar];
268
269 //Find out the min and max bins
270
271 for(Int_t i=0;i<fNVar;i++){
272 Double_t xmin=varMin[i]; // the min values
273 Double_t xmax=varMax[i]; // the min values
274 Int_t nbins=fNVarBins[i]+1;
275 Double_t *bins=new Double_t[nbins];
276 for(Int_t ibin =0;ibin<nbins;ibin++){
277 bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
278 }
279 indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
280 indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
281 delete [] bins;
282 }
283
284 //move to the TH/THnSparse convention in N-dim bin numbering
285 for(Int_t i=0;i<fNVar;i++){
286 indexMin[i]+=1;
287 indexMax[i]+=1;
288 }
289
290 Double_t val=GetIntegral(indexMin,indexMax);
291
292 delete [] indexMin;
293 delete [] indexMax;
294
295 return val;
296}
297
298//_____________________________________________________________________
299Double_t AliCFVGrid::GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const
300{
301 //
302 // recursively add over nested loops....
303 //
304 static Double_t val;
305 if(ivar==0)val=0.;
306 for(Int_t ibin=binMin[ivar]-1;ibin<=binMax[ivar]-1;ibin++){
307 //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
308 fIndex[ivar]=ibin;
309 if(ivar<fNVar-1) {
310 val=GetSum(ivar+1,binMin,binMax);
311 }
312 else {
313 Int_t iel=GetBinIndex(fIndex);
314 val+=GetElement(iel);
315 }
316 }
317
318 return val;
319}
320
321//____________________________________________________________________
322Long64_t AliCFVGrid::Merge(TCollection* list)
323{
324 // Merge a list of AliCF grids with this (needed for
325 // PROOF).
326 // Returns the number of merged objects (including this).
327
328 if (!list)
329 return 0;
330
331 if (list->IsEmpty())
332 return 1;
333
334 TIterator* iter = list->MakeIterator();
335 TObject* obj;
336
337 Int_t count = 0;
338 while ((obj = iter->Next())) {
339 AliCFVGrid* entry = dynamic_cast<AliCFVGrid*> (obj);
340 if (entry == 0)
341 continue;
342 this->Add(entry);
343 count++;
344 }
345
346 return count+1;
347}
348
349//____________________________________________________________________
350void AliCFVGrid::GetScaledValues(Double_t *fact, Double_t *in, Double_t *out) const{
351 //
352 // scale input *in and it error by (positive) fact (with error)
353 // and erite it to *out
354 //
355 out[0]=in[0]*fact[0];
356 out[1]=TMath::Sqrt(in[1]*in[1]/in[0]/in[0]
357 +fact[1]*fact[1]/fact[0]/fact[0])*out[0];
358
359}