Place the config and root file at the right place
[u/mrichter/AliRoot.git] / PWGHF / hfe / AliHFECorrectSpectrumBase.cxx
1
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 // Class for spectrum correction
18 // Subtraction of hadronic background, Unfolding of the data and
19 // Renormalization done here
20 // The following containers have to be set:
21 //  - Correction framework container for real data
22 //  - Correction framework container for MC (Efficiency Map)
23 //  - Correction framework container for background coming from data
24 //  - Correction framework container for background coming from MC
25 //
26 //  Author: 
27 //            Raphaelle Bailhache <R.Bailhache@gsi.de>
28 //            Markus Fasel <M.Fasel@gsi.de>
29 //
30
31 #include <TArrayD.h>
32 #include <TH1.h>
33 #include <TList.h>
34 #include <TObjArray.h>
35 #include <TROOT.h>
36 #include <TCanvas.h>
37 #include <TLegend.h>
38 #include <TStyle.h>
39 #include <TMath.h>
40 #include <TAxis.h>
41 #include <TGraphErrors.h>
42 #include <TFile.h>
43 #include <TPad.h>
44 #include <TH2D.h>
45 #include <TF1.h>
46
47 #include "AliPID.h"
48 #include "AliCFContainer.h"
49 #include "AliCFDataGrid.h"
50 #include "AliCFEffGrid.h"
51 #include "AliCFGridSparse.h"
52 #include "AliCFUnfolding.h"
53 #include "AliLog.h"
54
55 #include "AliHFECorrectSpectrumBase.h"
56 #include "AliHFEcuts.h"
57 #include "AliHFEcontainer.h"
58 #include "AliHFEtools.h"
59
60 ClassImp(AliHFECorrectSpectrumBase)
61
62 //____________________________________________________________
63 AliHFECorrectSpectrumBase::AliHFECorrectSpectrumBase(const char *name):
64   TNamed(name, ""),
65   fCFContainers(new TObjArray(kNbCFContainers)),
66   fCorrelation(NULL),
67   fEfficiencyFunction(NULL),
68   fEtaSelected(kFALSE),
69   fSetSmoothing(kFALSE),
70   fNbDimensions(1),
71   fNEvents(0),
72   fStepMC(-1),
73   fStepTrue(-1),
74   fStepData(-1),
75   fStepBeforeCutsV0(-1),
76   fStepAfterCutsV0(-1),
77   fStepGuessedUnfolding(-1),
78   fNumberOfIterations(10),
79   fChargeChoosen(kAllCharge),
80   fTestCentralityLow(-1),
81   fTestCentralityHigh(-1)
82 {
83   //
84   // Default constructor
85   //
86
87   memset(fEtaRange, 0, sizeof(Double_t) * 2);
88   memset(fEtaRangeNorm, 0, sizeof(Double_t) * 2);
89  
90 }
91 //____________________________________________________________
92 AliHFECorrectSpectrumBase::AliHFECorrectSpectrumBase(const AliHFECorrectSpectrumBase &ref):
93   TNamed(ref),
94   fCFContainers(NULL),
95   fCorrelation(NULL),
96   fEfficiencyFunction(NULL),
97   fEtaSelected(ref.fEtaSelected),
98   fSetSmoothing(ref.fSetSmoothing),
99   fNbDimensions(ref.fNbDimensions),
100   fNEvents(ref.fNEvents),
101   fStepMC(ref.fStepMC),
102   fStepTrue(ref.fStepTrue),
103   fStepData(ref.fStepData),
104   fStepBeforeCutsV0(ref.fStepBeforeCutsV0),
105   fStepAfterCutsV0(ref.fStepAfterCutsV0),
106   fStepGuessedUnfolding(ref.fStepGuessedUnfolding),
107   fNumberOfIterations(ref.fNumberOfIterations),
108   fChargeChoosen(ref.fChargeChoosen),
109   fTestCentralityLow(ref.fTestCentralityLow),
110   fTestCentralityHigh(ref.fTestCentralityHigh)
111 {
112   //
113   // Copy constructor
114   //
115   ref.Copy(*this);
116
117 }
118 //____________________________________________________________
119 AliHFECorrectSpectrumBase &AliHFECorrectSpectrumBase::operator=(const AliHFECorrectSpectrumBase &ref){
120   //
121   // Assignment operator
122   //
123   if(this == &ref) 
124     ref.Copy(*this);
125   return *this;
126 }
127 //____________________________________________________________
128 void AliHFECorrectSpectrumBase::Copy(TObject &o) const {
129   // 
130   // Copy into object o
131   //
132   AliHFECorrectSpectrumBase &target = dynamic_cast<AliHFECorrectSpectrumBase &>(o);
133   target.fCFContainers = fCFContainers;
134   target.fCorrelation = fCorrelation;
135   target.fEfficiencyFunction = fEfficiencyFunction;
136   target.fEtaSelected = fEtaSelected;
137   target.fSetSmoothing = fSetSmoothing;
138   target.fNbDimensions = fNbDimensions;
139   target.fNEvents = fNEvents;
140   target.fStepMC = fStepMC;
141   target.fStepTrue = fStepTrue;
142   target.fStepData = fStepData;
143   target.fStepBeforeCutsV0 = fStepBeforeCutsV0;
144   target.fStepAfterCutsV0 = fStepAfterCutsV0;
145   target.fStepGuessedUnfolding = fStepGuessedUnfolding;
146   target.fNumberOfIterations = fNumberOfIterations;
147   target.fChargeChoosen = fChargeChoosen;
148   target.fTestCentralityLow = fTestCentralityLow;
149   target.fTestCentralityHigh = fTestCentralityHigh;
150   target.fEtaRange[0] = fEtaRange[0];
151   target.fEtaRange[1] = fEtaRange[1];
152   target.fEtaRangeNorm[0] = fEtaRangeNorm[0];
153   target.fEtaRangeNorm[1] = fEtaRangeNorm[1];
154
155 }
156
157 //____________________________________________________________
158 AliHFECorrectSpectrumBase::~AliHFECorrectSpectrumBase(){
159   //
160   // Destructor
161   //
162   if(fCFContainers) delete fCFContainers;
163  
164 }
165 //__________________________________________________________________________________
166 TGraphErrors *AliHFECorrectSpectrumBase::Normalize(THnSparse * const spectrum) const {
167   //
168   // Normalize the spectrum to 1/(2*Pi*p_{T})*dN/dp_{T} (GeV/c)^{-2}
169   // Give the final pt spectrum to be compared
170   //
171
172   if(fNEvents > 0) {
173
174     TH1D* projection = spectrum->Projection(0);
175     CorrectFromTheWidth(projection);
176     TGraphErrors *graphError = NormalizeTH1(projection);
177     return graphError;
178   
179   }
180     
181   return 0x0;
182   
183
184 }
185 //__________________________________________________________________________________
186 TGraphErrors *AliHFECorrectSpectrumBase::Normalize(AliCFDataGrid * const spectrum) const {
187   //
188   // Normalize the spectrum to 1/(2*Pi*p_{T})*dN/dp_{T} (GeV/c)^{-2}
189   // Give the final pt spectrum to be compared
190   //
191   if(fNEvents > 0) {
192
193     TH1D* projection = (TH1D *) spectrum->Project(0);
194     CorrectFromTheWidth(projection);
195     TGraphErrors *graphError = NormalizeTH1(projection);
196
197     return graphError;
198     
199   }
200
201   return 0x0;
202   
203
204 }
205 //__________________________________________________________________________________
206 TGraphErrors *AliHFECorrectSpectrumBase::NormalizeTH1(TH1 *input) const {
207   //
208   // Normalize the spectrum to 1/(2*Pi*p_{T})*dN/dp_{T} (GeV/c)^{-2}
209   // Give the final pt spectrum to be compared
210   //
211   Double_t chargecoefficient = 0.5;
212   if(fChargeChoosen != 0) chargecoefficient = 1.0;
213
214   Double_t etarange = fEtaSelected ? fEtaRangeNorm[1] - fEtaRangeNorm[0] : 1.6;
215   printf("Normalizing Eta Range %f\n", etarange);
216   printf("Number of events in Normalisation: %d\n", fNEvents);
217   AliDebug(3, Form("charge coefficient: %f\n", chargecoefficient));
218   if(fNEvents > 0) {
219
220     TGraphErrors *spectrumNormalized = new TGraphErrors(input->GetNbinsX());
221     Double_t p = 0, dp = 0; Int_t point = 1;
222     Double_t n = 0, dN = 0;
223     Double_t nCorr = 0, dNcorr = 0;
224     //Double_t errdN = 0, errdp = 0;
225     Double_t errdN = 0;
226     for(Int_t ibin = input->GetXaxis()->GetFirst(); ibin <= input->GetXaxis()->GetLast(); ibin++){
227       point = ibin - input->GetXaxis()->GetFirst();
228       p = input->GetXaxis()->GetBinCenter(ibin);
229       //dp = input->GetXaxis()->GetBinWidth(ibin)/2.;
230       n = input->GetBinContent(ibin);
231       AliDebug(6, Form("p: %f, n: %e\n", p, n));
232       dN = input->GetBinError(ibin);
233       // New point
234       nCorr = chargecoefficient * 1./etarange * 1./(Double_t)(fNEvents) * 1./(2. * TMath::Pi() * p) * n;
235       errdN = 1./(2. * TMath::Pi() * p);
236       //errdp = 1./(2. * TMath::Pi() * p*p) * n;
237       //dNcorr = chargecoefficient * 1./etarange * 1./(Double_t)(fNEvents) * TMath::Sqrt(errdN * errdN * dN *dN + errdp *errdp * dp *dp);
238       dNcorr = chargecoefficient * 1./etarange * 1./(Double_t)(fNEvents) * TMath::Sqrt(errdN * errdN * dN *dN);
239       
240       spectrumNormalized->SetPoint(point, p, nCorr);
241       spectrumNormalized->SetPointError(point, dp, dNcorr);
242     }
243     spectrumNormalized->GetXaxis()->SetTitle("p_{T} [GeV/c]");
244     spectrumNormalized->GetYaxis()->SetTitle("#frac{1}{2 #pi p_{T}} #frac{dN}{dp_{T}} / [GeV/c]^{-2}");
245     spectrumNormalized->SetMarkerStyle(22);
246     spectrumNormalized->SetMarkerColor(kBlue);
247     spectrumNormalized->SetLineColor(kBlue);
248
249     return spectrumNormalized;
250     
251   }
252
253   return 0x0;
254   
255
256 }
257 //____________________________________________________________
258 void AliHFECorrectSpectrumBase::SetContainer(AliCFContainer *cont, AliHFECorrectSpectrumBase::CFContainer_t type){
259   //
260   // Set the container for a given step to the 
261   //
262   if(!fCFContainers) fCFContainers = new TObjArray(kNbCFContainers);
263   fCFContainers->AddAt(cont, type);
264 }
265
266 //____________________________________________________________
267 AliCFContainer *AliHFECorrectSpectrumBase::GetContainer(AliHFECorrectSpectrumBase::CFContainer_t type){
268   //
269   // Get Correction Framework Container for given type
270   //
271   if(!fCFContainers) return NULL;
272   return dynamic_cast<AliCFContainer *>(fCFContainers->At(type));
273 }
274 //____________________________________________________________
275 AliCFContainer *AliHFECorrectSpectrumBase::GetSlicedContainer(AliCFContainer *container, Int_t nDim, Int_t *dimensions,Int_t source,Chargetype_t charge, Int_t centralitylow, Int_t centralityhigh, Bool_t doCentralityProjection) {
276   //
277   // Slice bin for a given source of electron
278   // nDim is the number of dimension the corrections are done
279   // dimensions are the definition of the dimensions
280   // source is if we want to keep only one MC source (-1 means we don't cut on the MC source)
281   // positivenegative if we want to keep positive (1) or negative (0) or both (-1)
282   // centrality (-1 means we do not cut on centrality)
283   //
284   const double kVerySmall = 1e-5;
285   
286   Double_t *varMin = new Double_t[container->GetNVar()],
287            *varMax = new Double_t[container->GetNVar()];
288
289   Double_t *binLimits;
290   for(Int_t ivar = 0; ivar < container->GetNVar(); ivar++){
291     
292     binLimits = new Double_t[container->GetNBins(ivar)+1];
293     container->GetBinLimits(ivar,binLimits);
294     varMin[ivar] = binLimits[0];
295     varMax[ivar] = binLimits[container->GetNBins(ivar)];
296     // source
297     if(ivar == 4){
298       if((source>= 0) && (source<container->GetNBins(ivar))) {
299               varMin[ivar] = binLimits[source];
300               varMax[ivar] = binLimits[source];
301       }     
302     }
303     // charge
304     if(ivar == 3) {
305       if(charge != kAllCharge) varMin[ivar] = varMax[ivar] = charge;
306     }
307     // eta
308     if(ivar == 1){
309       for(Int_t ic = 1; ic <= container->GetAxis(1,0)->GetLast(); ic++) 
310         AliDebug(1, Form("eta bin %d, min %f, max %f\n", ic, container->GetAxis(1,0)->GetBinLowEdge(ic), container->GetAxis(1,0)->GetBinUpEdge(ic))); 
311       if(fEtaSelected){
312         varMin[ivar] = fEtaRange[0];
313         varMax[ivar] = fEtaRange[1];
314       }
315     }
316     if(fEtaSelected){
317       fEtaRangeNorm[0] = container->GetAxis(1,0)->GetBinLowEdge(container->GetAxis(1,0)->FindBin(fEtaRange[0]));
318       fEtaRangeNorm[1] = container->GetAxis(1,0)->GetBinUpEdge(container->GetAxis(1,0)->FindBin(fEtaRange[1]));
319       AliInfo(Form("Normalization done in eta range [%f,%f]\n", fEtaRangeNorm[0], fEtaRangeNorm[1]));
320     }
321     // centrality
322     if(ivar == 5){
323             if((centralitylow>= 0) && (centralitylow<container->GetNBins(ivar)) && (centralityhigh>= 0) && (centralityhigh<container->GetNBins(ivar)) && doCentralityProjection) {
324               varMin[ivar] = binLimits[centralitylow]+ kVerySmall;
325               varMax[ivar] = binLimits[centralityhigh]+ kVerySmall;
326
327               TAxis *axistest = container->GetAxis(5,0);
328               AliDebug(1, Form("Number of bin in centrality direction %d\n",axistest->GetNbins()));
329               AliDebug(1, Form("Project from %f to %f\n",binLimits[centralitylow],binLimits[centralityhigh]));
330               Double_t lowcentrality = axistest->GetBinLowEdge(axistest->FindBin(binLimits[centralitylow]));
331               Double_t highcentrality = axistest->GetBinUpEdge(axistest->FindBin(binLimits[centralityhigh]));
332               AliDebug(1, Form("Low centrality %f and high centrality %f\n",lowcentrality,highcentrality));
333             }
334     }
335     
336     // Protect varmax against overflow 
337     if(TMath::Abs(varMax[ivar] - binLimits[container->GetNBins(ivar)]) < kVerySmall){
338       AliInfo("Protection against overflow bin");
339       varMax[ivar] -= kVerySmall;
340     }
341     if(varMax[ivar] > binLimits[container->GetNBins(ivar)]){
342       AliError("Upper limit exceeds allowed range");
343       varMax[ivar] = binLimits[container->GetNBins(ivar)] - kVerySmall;
344     }
345
346     // Protect varmin against overflow 
347     if(TMath::Abs(varMin[ivar] - binLimits[container->GetNBins(ivar)]) < kVerySmall){
348       AliInfo("Protection against overflow bin");
349       varMin[ivar] -= kVerySmall;
350     }
351     if(varMin[ivar] > binLimits[container->GetNBins(ivar)]){
352       AliError("Upper limit exceeds allowed range");
353       varMin[ivar] = binLimits[container->GetNBins(ivar)] - kVerySmall;
354     }
355     AliDebug(1, Form("variable %d: Settting limits to %f and %f\n", ivar, varMin[ivar], varMax[ivar]));
356     delete[] binLimits;
357    
358   }
359
360   AliCFContainer *k = container->MakeSlice(nDim, dimensions, varMin, varMax);
361   delete[] varMin; delete[] varMax;
362
363   return k;
364
365 }
366
367 //_________________________________________________________________________
368 THnSparseF *AliHFECorrectSpectrumBase::GetSlicedCorrelation(THnSparseF *correlationmatrix, Int_t nDim, Int_t *dimensions,Chargetype_t charge,Int_t centralitylow, Int_t centralityhigh, Bool_t doCentralityProjection) const {
369   //
370   // Slice correlation
371   //
372
373   Int_t ndimensions = correlationmatrix->GetNdimensions();
374   //printf("Number of dimension %d correlation map\n",ndimensions);
375   if(ndimensions < (2*nDim)) {
376     AliError("Problem in the dimensions");
377     return NULL;
378   }
379   
380   // Cut in centrality is centrality > -1
381   if((5+((Int_t)(ndimensions/2.))) < ndimensions) {
382     if((centralitylow >=0) && (centralityhigh >=0)) {
383       
384       TAxis *axiscentrality0 = correlationmatrix->GetAxis(5);
385       TAxis *axiscentrality1 = correlationmatrix->GetAxis(5+((Int_t)(ndimensions/2.)));
386       
387       Int_t bins0 = axiscentrality0->GetNbins();
388       Int_t bins1 = axiscentrality1->GetNbins();
389       
390       AliDebug(1, Form("Number of centrality bins: %d and %d\n",bins0,bins1));
391       if(bins0 != bins1) {
392               AliError("Problem in the dimensions");
393               return NULL;
394       }
395       
396       if((centralitylow>= 0) && (centralitylow<bins0) && (centralityhigh>= 0) && (centralityhigh<bins0) && doCentralityProjection) {
397               axiscentrality0->SetRangeUser(centralitylow,centralityhigh);
398               axiscentrality1->SetRangeUser(centralitylow,centralityhigh);
399         
400               Double_t lowcentrality0 = axiscentrality0->GetBinLowEdge(axiscentrality0->FindBin(centralitylow));
401               Double_t highcentrality0 = axiscentrality0->GetBinUpEdge(axiscentrality0->FindBin(centralityhigh));
402               Double_t lowcentrality1 = axiscentrality1->GetBinLowEdge(axiscentrality1->FindBin(centralitylow));
403               Double_t highcentrality1 = axiscentrality1->GetBinUpEdge(axiscentrality1->FindBin(centralityhigh));
404               AliDebug(1,Form("0 Low centrality %f and high centrality %f\n",lowcentrality0,highcentrality0));
405               AliDebug(1,Form("1 Low centrality %f and high centrality %f\n",lowcentrality1,highcentrality1));
406         
407       }    
408     }
409   }
410
411   // Cut in eta > -1
412   if(fEtaSelected){
413     if((1+((Int_t)(ndimensions/2.))) < ndimensions) {
414       
415       TAxis *axiseta0 = correlationmatrix->GetAxis(1);
416       TAxis *axiseta1 = correlationmatrix->GetAxis(1+((Int_t)(ndimensions/2.)));
417       
418       Int_t bins0 = axiseta0->GetNbins();
419       Int_t bins1 = axiseta1->GetNbins();
420       
421       AliDebug(1, Form("Number of eta bins: %d and %d\n",bins0,bins1));
422       if(bins0 != bins1) {
423         AliError("Problem in the dimensions");
424         return NULL;
425       }
426       
427       axiseta0->SetRangeUser(fEtaRange[0],fEtaRange[1]);
428       axiseta1->SetRangeUser(fEtaRange[0],fEtaRange[1]);
429         
430         Double_t loweta0 = axiseta0->GetBinLowEdge(axiseta0->FindBin(fEtaRange[0]));
431         Double_t higheta0 = axiseta0->GetBinUpEdge(axiseta0->FindBin(fEtaRange[1]));
432         Double_t loweta1 = axiseta1->GetBinLowEdge(axiseta1->FindBin(fEtaRange[0]));
433         Double_t higheta1 = axiseta1->GetBinUpEdge(axiseta1->FindBin(fEtaRange[1]));
434         AliInfo(Form("0 Low eta %f and high eta %f\n",loweta0,higheta0));
435         AliInfo(Form("1 Low eta %f and high eta %f\n",loweta1,higheta1));
436         
437     }    
438   }
439
440   // Cut in charge
441   if(charge != kAllCharge) {
442     if((3+((Int_t)(ndimensions/2.))) < ndimensions) {
443       
444       TAxis *axischarge0 = correlationmatrix->GetAxis(3);
445       TAxis *axischarge1 = correlationmatrix->GetAxis(3+((Int_t)(ndimensions/2.)));
446       
447       Int_t bins0 = axischarge0->GetNbins();
448       Int_t bins1 = axischarge1->GetNbins();
449       
450       AliDebug(1, Form("Number of charge bins: %d and %d\n",bins0,bins1));
451       if(bins0 != bins1) {
452         AliError("Problem in the dimensions");
453         return NULL;
454       }
455       
456       axischarge0->SetRangeUser(charge,charge);
457       axischarge1->SetRangeUser(charge,charge);
458       
459       Double_t lowcharge0 = axischarge0->GetBinLowEdge(axischarge0->FindBin(charge));
460       Double_t highcharge0 = axischarge0->GetBinUpEdge(axischarge0->FindBin(charge));
461       Double_t lowcharge1 = axischarge1->GetBinLowEdge(axischarge1->FindBin(charge));
462       Double_t highcharge1 = axischarge1->GetBinUpEdge(axischarge1->FindBin(charge));
463       AliInfo(Form("0 Low charge %f and high charge %f\n",lowcharge0,highcharge0));
464       AliInfo(Form("1 Low charge %f and high charge %f\n",lowcharge1,highcharge1));
465       
466     }
467   }
468   
469
470   Int_t ndimensionsContainer = (Int_t) ndimensions/2;
471   
472   Int_t *dim = new Int_t[nDim*2];
473   for(Int_t iter=0; iter < nDim; iter++){
474     dim[iter] = dimensions[iter];
475     dim[iter+nDim] = ndimensionsContainer + dimensions[iter];
476   }
477     
478   THnSparseF *k = (THnSparseF *) correlationmatrix->Projection(nDim*2,dim);
479
480   delete[] dim; 
481   return k;
482   
483 }
484 //___________________________________________________________________________
485 void AliHFECorrectSpectrumBase::CorrectFromTheWidth(TH1D *h1) const {
486   //
487   // Correct from the width of the bins --> dN/dp_{T} (GeV/c)^{-1}
488   //
489
490   TAxis *axis = h1->GetXaxis();
491   Int_t nbinX = h1->GetNbinsX();
492
493   for(Int_t i = 1; i <= nbinX; i++) {
494
495     Double_t width = axis->GetBinWidth(i);
496     Double_t content = h1->GetBinContent(i);
497     Double_t error = h1->GetBinError(i); 
498     h1->SetBinContent(i,content/width); 
499     h1->SetBinError(i,error/width);
500   }
501
502 }
503
504 //___________________________________________________________________________
505 void AliHFECorrectSpectrumBase::CorrectStatErr(AliCFDataGrid *backgroundGrid) const { 
506   //
507   // Correct statistical error
508   //
509
510   TH1D *h1 = (TH1D*)backgroundGrid->Project(0);
511   Int_t nbinX = h1->GetNbinsX();
512   Int_t bins[1];
513   for(Long_t i = 1; i <= nbinX; i++) {
514     bins[0] = i;
515     Float_t content = h1->GetBinContent(i);
516     if(content>0){
517       Float_t error = TMath::Sqrt(content);
518       backgroundGrid->SetElementError(bins, error);
519     }
520   }
521 }
522 //_________________________________________________________________________
523 TObject* AliHFECorrectSpectrumBase::GetSpectrum(const AliCFContainer * const c, Int_t step) {
524   AliCFDataGrid* data = new AliCFDataGrid("data","",*c, step);
525   return data;
526 }
527 //_________________________________________________________________________
528 TObject* AliHFECorrectSpectrumBase::GetEfficiency(const AliCFContainer * const c, Int_t step, Int_t step0){
529   // 
530   // Create efficiency grid and calculate efficiency
531   // of step to step0
532   //
533   TString name("eff");
534   name += step;
535   name+= step0;
536   AliCFEffGrid* eff = new AliCFEffGrid((const char*)name,"",*c);
537   eff->CalculateEfficiency(step,step0);
538   return eff;
539 }