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