PWGLF/totEt/AliAnalysisEtReconstructed.cxx

   1 //_________________________________________________________________________
   2 //  Utility Class for transverse energy studies
   3 //  Base class for ESD analysis
   4 //  - reconstruction output
   5 //  implementation file
   6 //
   7 //*-- Authors: Oystein Djuvsland (Bergen), David Silvermyr (ORNL)
   8 //_________________________________________________________________________
   9
  10 #include "AliAnalysisEtReconstructed.h"
  11 #include "AliAnalysisEtCuts.h"
  12 #include "AliESDtrack.h"
  13 #include "AliEMCALTrack.h"
  14 #include "AliESDCaloCluster.h"
  15 #include "TVector3.h"
  16 #include "TGeoGlobalMagField.h"
  17 #include "AliMagF.h"
  18 #include "AliVEvent.h"
  19 #include "AliESDEvent.h"
  20 #include "AliESDtrackCuts.h"
  21 #include "AliVParticle.h"
  22 #include "TDatabasePDG.h"
  23 #include "TList.h"
  24 #include "AliESDpid.h"
  25 #include <iostream>
  26 #include "TH3F.h"
  27 #include "TH2F.h"
  28 #include "TH2I.h"
  29 #include "TH1I.h"
  30 #include "TFile.h"
  31 #include "AliAnalysisHadEtCorrections.h"
  32 #include "AliAnalysisEtSelector.h"
  33 #include "AliLog.h"
  34 #include "AliCentrality.h"
  35 #include "AliPHOSGeoUtils.h"
  36 #include "AliPHOSGeometry.h"
  37 #include "AliAnalysisEtRecEffCorrection.h"
  38
  39
  40 using namespace std;
  41
  42 ClassImp(AliAnalysisEtReconstructed);
  43
  44
  45 AliAnalysisEtReconstructed::AliAnalysisEtReconstructed() :
  46         AliAnalysisEt()
  47         ,fCorrections(0)
  48         ,fPidCut(0)
  49         ,fHistChargedPionEnergyDeposit(0)
  50         ,fHistProtonEnergyDeposit(0)
  51         ,fHistAntiProtonEnergyDeposit(0)
  52         ,fHistChargedKaonEnergyDeposit(0)
  53         ,fHistMuonEnergyDeposit(0)
  54         ,fHistRemovedEnergy(0)
  55         ,fGeomCorrection(1.0)
  56         ,fEMinCorrection(1.0/0.687)
  57         ,fRecEffCorrection(1.0)
  58         ,fClusterPosition(0)
  59         ,fClusterEnergy(0)
  60         ,fClusterEt(0)
  61         ,fHistChargedEnergyRemoved(0)
  62         ,fHistNeutralEnergyRemoved(0)
  63         ,fHistGammaEnergyAdded(0)
  64         ,fHistMatchedTracksEvspTvsMult(0)
  65         ,fHistMatchedTracksEvspTvsMultEffCorr(0)
  66         ,fHistNominalRawEt(0)
  67         ,fHistNominalNonLinHighEt(0)
  68         ,fHistNominalNonLinLowEt(0)
  69         ,fHistNominalEffHighEt(0)
  70         ,fHistNominalEffLowEt(0)
  71 {
  72
  73 }
  74
  75 AliAnalysisEtReconstructed::~AliAnalysisEtReconstructed()
  76 {//destructor
  77     delete fCorrections;
  78     delete fHistChargedPionEnergyDeposit; /** Energy deposited in calorimeter by charged pions */
  79     delete fHistProtonEnergyDeposit; /** Energy deposited in calorimeter by protons */
  80     delete fHistAntiProtonEnergyDeposit; /** Energy deposited in calorimeter by anti-protons */
  81     delete fHistChargedKaonEnergyDeposit; /** Energy deposited in calorimeter by charged kaons */
  82     delete fHistMuonEnergyDeposit; /** Energy deposited in calorimeter by muons */
  83
  84     delete fHistRemovedEnergy; // removed energy
  85     delete fClusterPosition;
  86     delete fClusterEnergy;
  87     delete fClusterEt;
  88     delete fHistChargedEnergyRemoved;
  89     delete fHistNeutralEnergyRemoved;
  90     delete fHistGammaEnergyAdded;
  91     delete fHistMatchedTracksEvspTvsMult;
  92     delete fHistMatchedTracksEvspTvsMultEffCorr;
  93     delete fHistNominalRawEt;
  94     delete fHistNominalNonLinHighEt;
  95     delete fHistNominalNonLinLowEt;
  96     delete fHistNominalEffHighEt;
  97     delete fHistNominalEffLowEt;
  98 }
  99
 100 Int_t AliAnalysisEtReconstructed::AnalyseEvent(AliVEvent* ev)
 101 {
 102
 103     //AliAnalysisEt::AnalyseEvent(ev);
 104     // analyse ESD event
 105     ResetEventValues();
 106     if (!ev) {
 107         AliFatal("ERROR: Event does not exist");
 108         return 0;
 109     }
 110
 111     AliESDEvent *event = dynamic_cast<AliESDEvent*>(ev);
 112     if (!event) {
 113         AliFatal("ERROR: ESD Event does not exist");
 114         return 0;
 115     }
 116     if(!fSelector){
 117         AliFatal("ERROR: fSelector does not exist");
 118         return 0;
 119     }
 120     fSelector->SetEvent(event);
 121
 122     Int_t cent = -1;
 123     fCentrality = event->GetCentrality();
 124     if (fCentrality && cent)
 125     {
 126         cent = fCentrality->GetCentralityClass5("V0M");
 127         fCentClass = fCentrality->GetCentralityClass5("V0M");
 128     }
 129
 130     TRefArray *caloClusters = fSelector->GetClusters();
 131     Float_t fClusterMult = caloClusters->GetEntries();
 132
 133     Float_t nominalRawEt = 0;
 134     Float_t nonlinHighRawEt = 0;
 135     Float_t nonlinLowRawEt = 0;
 136     Float_t effHighRawEt = 0;
 137     Float_t effLowRawEt = 0;
 138
 139
 140     for (Int_t iCluster = 0; iCluster < event->GetNumberOfCaloClusters(); iCluster++)
 141     {
 142         AliESDCaloCluster* cluster = event->GetCaloCluster(iCluster);
 143         if (!cluster)
 144         {
 145             AliError(Form("ERROR: Could not get cluster %d", iCluster));
 146             continue;
 147         }
 148         int x = 0;
 149         fCutFlow->Fill(x++);
 150         if(!fSelector->IsDetectorCluster(*cluster)) continue;
 151         fCutFlow->Fill(x++);
 152         if(!fSelector->PassMinEnergyCut(*cluster)) continue;
 153         fCutFlow->Fill(x++);
 154         if (!fSelector->PassDistanceToBadChannelCut(*cluster)) continue;
 155         fCutFlow->Fill(x++);
 156
 157         Float_t pos[3];
 158
 159         cluster->GetPosition(pos);
 160         TVector3 cp(pos);
 161
 162         Bool_t matched = kTRUE;//default to no track matched
 163         Int_t trackMatchedIndex = cluster->GetTrackMatchedIndex();//find the index of the matched track
 164         matched = fSelector->PassTrackMatchingCut(*cluster);
 165         if(!matched){
 166           if(trackMatchedIndex < 0) matched=kTRUE;
 167           AliESDtrack *track = event->GetTrack(trackMatchedIndex);
 168           //if this is a good track, accept track will return true.  The track matched is good, so not track matched is false
 169           matched = !(fEsdtrackCutsTPC->AcceptTrack(track));
 170         }
 171
 172
 173         if (matched)
 174         {
 175
 176             if (cluster->GetNTracksMatched() > 0 && trackMatchedIndex>=0)
 177             {
 178                 AliVTrack *track = event->GetTrack(trackMatchedIndex);
 179                 if (!track) {
 180                     AliError("Error: track does not exist");
 181                 }
 182                 else {
 183                   fHistMatchedTracksEvspTvsMult->Fill(track->P(),cluster->E(),fClusterMult);
 184                   fHistMatchedTracksEvspTvsMultEffCorr->Fill(track->P(),CorrectForReconstructionEfficiency(*cluster),fClusterMult);
 185                     const Double_t *pidWeights = track->PID();
 186
 187                     Double_t maxpidweight = 0;
 188                     Int_t maxpid = 0;
 189
 190                     if (pidWeights)
 191                     {
 192                         for (Int_t p =0; p < AliPID::kSPECIES; p++)
 193                         {
 194                             if (pidWeights[p] > maxpidweight)
 195                             {
 196                                 maxpidweight = pidWeights[p];
 197                                 maxpid = p;
 198                             }
 199                         }
 200                         if (fCuts->GetHistMakeTreeDeposit() && fDepositTree)
 201                         {
 202                             fEnergyDeposited = cluster->E();
 203                             fMomentumTPC = track->P();
 204                             fCharge = track->Charge();
 205                             fParticlePid = maxpid;
 206                             fPidProb = maxpidweight;
 207                             AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(track);
 208                             if (!esdTrack) {
 209                                 AliError("Error: track does not exist");
 210                             }
 211                             else {
 212                                 if (esdTrack) fTrackPassedCut = fEsdtrackCutsTPC->AcceptTrack(esdTrack);
 213                                 fDepositTree->Fill();
 214                             }
 215                         }
 216
 217                         if (maxpidweight > fPidCut)
 218                         {
 219                             //Float_t dist = TMath::Sqrt(pos[0]*pos[0] + pos[1]*pos[1]);
 220
 221                             //Float_t theta = TMath::ATan(pos[2]/dist)+TMath::Pi()/2;
 222
 223                             //Float_t et = cluster->E() * TMath::Sin(theta);
 224                             if (maxpid == AliPID::kProton)
 225                             {
 226
 227                                 if (track->Charge() == 1)
 228                                 {
 229                                     fHistProtonEnergyDeposit->Fill(cluster->E(), track->E());
 230                                 }
 231                                 else if (track->Charge() == -1)
 232                                 {
 233                                     fHistAntiProtonEnergyDeposit->Fill(cluster->E(), track->E());
 234                                 }
 235                             }
 236                             else if (maxpid == AliPID::kPion)
 237                             {
 238                                 fHistChargedPionEnergyDeposit->Fill(cluster->E(), track->E());
 239                             }
 240                             else if (maxpid == AliPID::kKaon)
 241                             {
 242                                 fHistChargedKaonEnergyDeposit->Fill(cluster->E(), track->E());
 243                             }
 244                             else if (maxpid == AliPID::kMuon)
 245                             {
 246                                 fHistMuonEnergyDeposit->Fill(cluster->E(), track->E());
 247                             }
 248                         }
 249                     }
 250                 }
 251             }
 252             //continue;
 253         } // distance
 254         else
 255           {//these are clusters which were not track matched
 256           fCutFlow->Fill(x++);
 257           //std::cout << x++ << std::endl;
 258
 259             //if (cluster->E() >  fSingleCellEnergyCut && cluster->GetNCells() == fCuts->GetCommonSingleCell()) continue;
 260             //if (cluster->E() < fClusterEnergyCut) continue;
 261             cluster->GetPosition(pos);
 262
 263             TVector3 p2(pos);
 264
 265             fClusterPosition->Fill(p2.Phi(), p2.PseudoRapidity());
 266             fClusterEnergy->Fill(cluster->E());
 267             fClusterEt->Fill(TMath::Sin(p2.Theta())*cluster->E());
 268
 269             Double_t effCorrEt = CorrectForReconstructionEfficiency(*cluster);
 270             fTotNeutralEt += effCorrEt;
 271             nominalRawEt += effCorrEt;
 272             nonlinHighRawEt += effCorrEt*GetCorrectionModification(*cluster,1,0);
 273             nonlinLowRawEt += effCorrEt*GetCorrectionModification(*cluster,-1,0);
 274             effHighRawEt += effCorrEt*GetCorrectionModification(*cluster,0,1);
 275             effLowRawEt += effCorrEt*GetCorrectionModification(*cluster,0,-1);
 276             fNeutralMultiplicity++;
 277         }
 278         fMultiplicity++;
 279     }
 280
 281     fChargedEnergyRemoved = GetChargedContribution(fNeutralMultiplicity);
 282     fNeutralEnergyRemoved = GetNeutralContribution(fNeutralMultiplicity);
 283     fHistChargedEnergyRemoved->Fill(fChargedEnergyRemoved, fNeutralMultiplicity);
 284     fHistNeutralEnergyRemoved->Fill(fNeutralEnergyRemoved, fNeutralMultiplicity);
 285
 286     fGammaEnergyAdded = GetGammaContribution(fNeutralMultiplicity);
 287     fHistGammaEnergyAdded->Fill(fGammaEnergyAdded, fNeutralMultiplicity);
 288
 289     Double_t removedEnergy = GetChargedContribution(fNeutralMultiplicity) + GetNeutralContribution(fNeutralMultiplicity) + GetGammaContribution(fNeutralMultiplicity) + GetSecondaryContribution(fNeutralMultiplicity);
 290     fHistRemovedEnergy->Fill(removedEnergy);
 291
 292     fTotNeutralEt = fGeomCorrection * fEMinCorrection * (fTotNeutralEt - removedEnergy);
 293     fTotEt = fTotChargedEt + fTotNeutralEt;
 294 // Fill the histograms...0
 295     FillHistograms();
 296     //std::cout << "fTotNeutralEt: " << fTotNeutralEt << ", Contribution from non-removed charged: " << GetChargedContribution(fNeutralMultiplicity) << ", neutral: " << GetNeutralContribution(fNeutralMultiplicity) << ", gammas: " << GetGammaContribution(fNeutralMultiplicity) << ", multiplicity: " << fNeutralMultiplicity<< std::endl;
 297     //cout<<"cent "<<cent<<" cluster mult "<<fClusterMult<<" fTotNeutralEt "<<fTotNeutralEt<<" nominalRawEt "<<nominalRawEt<<endl;
 298     fHistNominalRawEt->Fill(nominalRawEt,cent);
 299     fHistNominalNonLinHighEt->Fill(nonlinHighRawEt,cent);
 300     fHistNominalNonLinLowEt->Fill(nonlinLowRawEt,cent);
 301     fHistNominalEffHighEt->Fill(effHighRawEt,cent);
 302     fHistNominalEffLowEt->Fill(effLowRawEt,cent);
 303
 304     return 0;
 305 }
 306
 307 bool AliAnalysisEtReconstructed::CheckGoodVertex(AliVParticle* track)
 308 { // check vertex
 309
 310     Float_t bxy = 999.;
 311     Float_t bz = 999.;
 312     if (!track) {
 313         AliError("ERROR: no track");
 314         return kFALSE;
 315     }
 316     AliESDtrack *esdTrack = dynamic_cast<AliESDtrack*>(track);
 317     if (!esdTrack) {
 318         AliError("ERROR: no track");
 319         return kFALSE;
 320     }
 321     esdTrack->GetImpactParametersTPC(bxy,bz);
 322
 323
 324     bool status = (TMath::Abs(track->Xv()) < fCuts->GetReconstructedVertexXCut()) &&
 325                   (TMath::Abs(track->Yv()) < fCuts->GetReconstructedVertexYCut()) &&
 326                   (TMath::Abs(track->Zv()) < fCuts->GetReconstructedVertexZCut()) &&
 327                   (TMath::Abs(bxy) < fCuts->GetReconstructedIPxyCut()) &&
 328                   (TMath::Abs(bz) < fCuts->GetReconstructedIPzCut());
 329
 330     return status;
 331 }
 332
 333 void AliAnalysisEtReconstructed::Init()
 334 { // Init
 335     AliAnalysisEt::Init();
 336     fPidCut = fCuts->GetReconstructedPidCut();
 337     TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", 1., 1., AliMagF::k5kG));
 338     if (!fCorrections) {
 339         cout<<"Warning!  You have not set corrections.  Your code will crash.  You have to set the corrections."<<endl;
 340     }
 341 }
 342
 343 bool AliAnalysisEtReconstructed::TrackHitsCalorimeter(AliVParticle* track, Double_t magField)
 344 { // propagate track to detector radius
 345
 346     if (!track) {
 347         cout<<"Warning: track empty"<<endl;
 348         return kFALSE;
 349     }
 350     AliESDtrack *esdTrack= dynamic_cast<AliESDtrack*>(track);
 351     if (!esdTrack) {
 352         AliError("ERROR: no ESD track");
 353         return kFALSE;
 354     }
 355     // Printf("Propagating track: eta: %f, phi: %f, pt: %f", esdTrack->Eta(), esdTrack->Phi(), esdTrack->Pt());
 356
 357     Bool_t prop = esdTrack->PropagateTo(fDetectorRadius, magField);
 358
 359     // if (prop) Printf("Track propagated, eta: %f, phi: %f, pt: %f", esdTrack->Eta(), esdTrack->Phi(), esdTrack->Pt());
 360     return prop && fSelector->CutGeometricalAcceptance(*esdTrack);
 361 }
 362
 363 void AliAnalysisEtReconstructed::FillOutputList(TList* list)
 364 { // add some extra histograms to the ones from base class
 365     AliAnalysisEt::FillOutputList(list);
 366
 367     list->Add(fHistChargedPionEnergyDeposit);
 368     list->Add(fHistProtonEnergyDeposit);
 369     list->Add(fHistAntiProtonEnergyDeposit);
 370     list->Add(fHistChargedKaonEnergyDeposit);
 371     list->Add(fHistMuonEnergyDeposit);
 372
 373     list->Add(fHistRemovedEnergy);
 374     list->Add(fClusterPosition);
 375     list->Add(fClusterEnergy);
 376     list->Add(fClusterEt);
 377
 378     list->Add(fHistChargedEnergyRemoved);
 379     list->Add(fHistNeutralEnergyRemoved);
 380     list->Add(fHistGammaEnergyAdded);
 381     list->Add(fHistMatchedTracksEvspTvsMult);
 382     list->Add(fHistMatchedTracksEvspTvsMultEffCorr);
 383     list->Add(fHistNominalRawEt);
 384     list->Add(fHistNominalNonLinHighEt);
 385     list->Add(fHistNominalNonLinLowEt);
 386     list->Add(fHistNominalEffHighEt);
 387     list->Add(fHistNominalEffLowEt);
 388 }
 389
 390 void AliAnalysisEtReconstructed::CreateHistograms()
 391 { // add some extra histograms to the ones from base class
 392     AliAnalysisEt::CreateHistograms();
 393
 394     Int_t nbinsEt = 1000;
 395     Double_t minEt = 0;
 396     Double_t maxEt = 10;
 397
 398     // possibly change histogram limits
 399 //     if (fCuts) {
 400 //         nbinsEt = fCuts->GetHistNbinsParticleEt();
 401 //         minEt = fCuts->GetHistMinParticleEt();
 402 //         maxEt = fCuts->GetHistMaxParticleEt();
 403 //     }
 404
 405     TString histname;
 406     histname = "fHistChargedPionEnergyDeposit" + fHistogramNameSuffix;
 407     fHistChargedPionEnergyDeposit = new TH2F(histname.Data(), "Energy deposited by #pi^{+/-}", nbinsEt, minEt, maxEt, nbinsEt, minEt, maxEt);
 408     fHistChargedPionEnergyDeposit->SetXTitle("Energy deposited in calorimeter");
 409     fHistChargedPionEnergyDeposit->SetYTitle("Energy of track");
 410
 411     histname = "fHistProtonEnergyDeposit" + fHistogramNameSuffix;
 412     fHistProtonEnergyDeposit = new TH2F(histname.Data(), "Energy deposited by protons", nbinsEt, minEt, maxEt, nbinsEt, minEt, maxEt);
 413     fHistProtonEnergyDeposit->SetXTitle("Energy deposited in calorimeter");
 414     fHistProtonEnergyDeposit->SetYTitle("Energy of track");
 415
 416     histname = "fHistAntiProtonEnergyDeposit" + fHistogramNameSuffix;
 417     fHistAntiProtonEnergyDeposit = new TH2F(histname.Data(), "Energy deposited by anti-protons", nbinsEt, minEt, maxEt, nbinsEt, minEt, maxEt);
 418     fHistAntiProtonEnergyDeposit->SetXTitle("Energy deposited in calorimeter");
 419     fHistAntiProtonEnergyDeposit->SetYTitle("Energy of track");
 420
 421     histname = "fHistChargedKaonEnergyDeposit" + fHistogramNameSuffix;
 422     fHistChargedKaonEnergyDeposit = new TH2F(histname.Data(), "Energy deposited by K^{+/-}", nbinsEt, minEt, maxEt, nbinsEt, minEt, maxEt);
 423     fHistChargedKaonEnergyDeposit->SetXTitle("Energy deposited in calorimeter");
 424     fHistChargedKaonEnergyDeposit->SetYTitle("Energy of track");
 425
 426     histname = "fHistMuonEnergyDeposit" + fHistogramNameSuffix;
 427     fHistMuonEnergyDeposit = new TH2F(histname.Data(), "Energy deposited by #mu^{+/-}", nbinsEt, minEt, maxEt, nbinsEt, minEt, maxEt);
 428     fHistMuonEnergyDeposit->SetXTitle("Energy deposited in calorimeter");
 429     fHistMuonEnergyDeposit->SetYTitle("Energy of track");
 430
 431     histname = "fHistRemovedEnergy" + fHistogramNameSuffix;
 432     fHistRemovedEnergy = new TH1F(histname.Data(), histname.Data(), 1000, 0, 20);
 433     //fHistMuonEnergyDeposit->SetXTitle("Energy deposited in calorimeter");
 434     //fHistMuonEnergyDeposit->SetYTitle("Energy of track");
 435
 436     histname = "fClusterPosition" + fHistogramNameSuffix;
 437     fClusterPosition = new TH2D(histname.Data(), "Position of accepted neutral clusters",1000, -2.0, -.5, 1000, -.13 , 0.13);
 438     fClusterPosition->SetXTitle("Energy deposited in calorimeter");
 439     fClusterPosition->SetYTitle("Energy of track");
 440
 441     histname = "fClusterEnergy" + fHistogramNameSuffix;
 442     fClusterEnergy = new TH1F(histname.Data(), histname.Data(), 100, 0, 5);
 443     fClusterEnergy->SetXTitle("Number of clusters");
 444     fClusterEnergy->SetYTitle("Energy of cluster");
 445
 446     histname = "fClusterEt" + fHistogramNameSuffix;
 447     fClusterEt = new TH1F(histname.Data(), histname.Data(), 100, 0, 5);
 448     fClusterEt->SetXTitle("Number of clusters");
 449     fClusterEt->SetYTitle("E_{T} of cluster");
 450
 451     histname = "fHistChargedEnergyRemoved" + fHistogramNameSuffix;
 452     fHistChargedEnergyRemoved = new TH2D(histname.Data(), histname.Data(), 1000, .0, 30, 100, -0.5 , 99.5);
 453
 454     histname = "fHistNeutralEnergyRemoved" + fHistogramNameSuffix;
 455     fHistNeutralEnergyRemoved = new TH2D(histname.Data(), histname.Data(), 1000, .0, 30, 100, -0.5 , 99.5);
 456
 457     histname = "fHistGammaEnergyAdded" + fHistogramNameSuffix;
 458     fHistGammaEnergyAdded = new TH2D(histname.Data(), histname.Data(), 1000, .0, 30, 100, -0.5 , 99.5);
 459
 460     fHistMatchedTracksEvspTvsMult = new TH3F("fHistMatchedTracksEvspTvsMult", "fHistMatchedTracksEvspTvsMult",100, 0, 3,100,0,3,10,0,100);
 461     fHistMatchedTracksEvspTvsMultEffCorr = new TH3F("fHistMatchedTracksEvspTvsMultEffCorr", "fHistMatchedTracksEvspTvsMultEffCorr",100, 0, 3,100,0,3,10,0,100);
 462
 463     maxEt = 100;
 464     histname = "fHistNominalRawEt" + fHistogramNameSuffix;
 465     fHistNominalRawEt = new TH2D(histname.Data(), histname.Data(),nbinsEt,minEt,maxEt,20,-0.5,19.5);
 466     histname = "fHistNominalNonLinHighEt" + fHistogramNameSuffix;
 467     fHistNominalNonLinHighEt = new TH2D(histname.Data(), histname.Data(),nbinsEt,minEt,maxEt,20,-0.5,19.5);
 468     histname = "fHistNominalNonLinLowEt" + fHistogramNameSuffix;
 469     fHistNominalNonLinLowEt = new TH2D(histname.Data(), histname.Data(),nbinsEt,minEt,maxEt,20,-0.5,19.5);
 470     histname = "fHistNominalEffHighEt" + fHistogramNameSuffix;
 471     fHistNominalEffHighEt = new TH2D(histname.Data(), histname.Data(),nbinsEt,minEt,maxEt,20,-0.5,19.5);
 472     histname = "fHistNominalEffLowEt" + fHistogramNameSuffix;
 473     fHistNominalEffLowEt = new TH2D(histname.Data(), histname.Data(),nbinsEt,minEt,maxEt,20,-0.5,19.5);
 474
 475 }
 476 Double_t AliAnalysisEtReconstructed::ApplyModifiedCorrections(const AliESDCaloCluster& cluster,Int_t nonLinCorr, Int_t effCorr)
 477 {
 478   Float_t pos[3];
 479   cluster.GetPosition(pos);
 480   TVector3 cp(pos);
 481   Double_t corrEnergy = fReCorrections->CorrectedEnergy(cluster.E());
 482
 483   Double_t factorNonLin = GetCorrectionModification(cluster, nonLinCorr,effCorr);
 484
 485   //std::cout << "Original energy: " << cluster.E() << ", corrected energy: " << corrEnergy << std::endl;
 486   return TMath::Sin(cp.Theta())*corrEnergy*factorNonLin;
 487 }
 488
 489 Double_t AliAnalysisEtReconstructed::GetCorrectionModification(const AliESDCaloCluster& cluster,Int_t nonLinCorr, Int_t effCorr){//nonLinCorr 0 = nominal 1 = high -1 = low, effCorr  0 = nominal 1 = high -1 = low
 490   if(nonLinCorr==0){
 491     cout<<"Warning:  This function should not get called!"<<endl;//this statement is basically here to avoid a compilation warning
 492   }
 493   if(effCorr==0){
 494     cout<<"Warning:  This function should not get called!"<<endl;//this statement is basically here to avoid a compilation warning
 495   }
 496   return cluster.E();
 497 }