+ /**************************************************************************\r
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
+ * *\r
+ * Author: The ALICE Off-line Project. *\r
+ * Contributors are mentioned in the code where appropriate. *\r
+ * *\r
+ * Permission to use, copy, modify and distribute this software and its *\r
+ * documentation strictly for non-commercial purposes hereby granted *\r
+ * without fee, provided that the above copyright notice appears in all *\r
+ * copies and that both the copyright notice and this permission notice *\r
+ * appear in the supporting documentation. The authors make no claims *\r
+ * about the suitability of this software for any purpose. It is *\r
+ * provided "as is" without express or implied warranty. *\r
+ **************************************************************************/\r
+/* $Id: $ */\r
+\r
+//_________________________________________________________________________\r
+//\r
+// Class for the electron identification.\r
+// Clusters from EMCAL matched to tracks\r
+// and kept in the AOD. Few histograms produced.\r
+//\r
+// -- Author: J.L. Klay (Cal Poly)\r
+//////////////////////////////////////////////////////////////////////////////\r
+ \r
+ \r
+// --- ROOT system --- \r
+#include <TH2F.h>\r
+#include <TClonesArray.h>\r
+#include <TObjString.h>\r
+#include <Riostream.h>\r
+\r
+// --- Analysis system --- \r
+#include "AliAnaElectron.h" \r
+#include "AliCaloTrackReader.h"\r
+#include "AliMCAnalysisUtils.h"\r
+#include "AliFidutialCut.h"\r
+#include "AliESDCaloCluster.h"\r
+//#include "AliESDCaloCells.h"\r
+#include "AliESDtrack.h"\r
+#include "AliESDEvent.h"\r
+#include "AliCaloPID.h"\r
+#include "AliVEvent.h"\r
+\r
+ClassImp(AliAnaElectron)\r
+ \r
+//____________________________________________________________________________\r
+AliAnaElectron::AliAnaElectron() \r
+ : AliAnaPartCorrBaseClass(), fCalorimeter(""),\r
+ fpOverEmin(0.),fpOverEmax(0.),fResidualCut(0.),\r
+ //matching checks\r
+ fh1pOverE(0),fh1dR(0),fh2EledEdx(0),fh2MatchdEdx(0),fh2dEtadPhi(0),\r
+ fh2dEtadPhiMatched(0),fh2dEtadPhiUnmatched(0),\r
+ fh2OuterPtVsExtrapPt(0),fh2OuterPhiVsExtrapPhi(0),fh2OuterEtaVsExtrapEta(0),\r
+ fh2TrackPVsClusterE(0),fh2TrackPtVsClusterE(0),fh2TrackPhiVsClusterPhi(0),fh2TrackEtaVsClusterEta(0),\r
+ //reco\r
+ fhPtElectron(0),fhPhiElectron(0),fhEtaElectron(0),\r
+ //MC\r
+ fhPtConversion(0),fhPhiConversion(0),fhEtaConversion(0),\r
+ fhPtBottom(0),fhPhiBottom(0),fhEtaBottom(0),\r
+ fhPtCharm(0),fhPhiCharm(0),fhEtaCharm(0),\r
+ fhPtCFromB(0),fhPhiCFromB(0),fhEtaCFromB(0),\r
+ fhPtDalitz(0),fhPhiDalitz(0),fhEtaDalitz(0),\r
+ fhPtWDecay(0),fhPhiWDecay(0),fhEtaWDecay(0),\r
+ fhPtZDecay(0),fhPhiZDecay(0),fhEtaZDecay(0),\r
+ fhPtPrompt(0),fhPhiPrompt(0),fhEtaPrompt(0),\r
+ fhPtUnknown(0),fhPhiUnknown(0),fhEtaUnknown(0)\r
+// fhMCElePt(0),fhMCElePhi(0),fhMCEleEta(0)\r
+{\r
+ //default ctor\r
+ \r
+ //Initialize parameters\r
+ InitParameters();\r
+\r
+}\r
+\r
+//____________________________________________________________________________\r
+AliAnaElectron::AliAnaElectron(const AliAnaElectron & g) \r
+ : AliAnaPartCorrBaseClass(g), fCalorimeter(g.fCalorimeter),\r
+ fpOverEmin(g.fpOverEmin),fpOverEmax(g.fpOverEmax),fResidualCut(g.fResidualCut),\r
+ //matching checks\r
+ fh1pOverE(g.fh1pOverE),fh1dR(g.fh1dR),\r
+ fh2EledEdx(g.fh2EledEdx),fh2MatchdEdx(g.fh2MatchdEdx),fh2dEtadPhi(g.fh2dEtadPhi),\r
+ fh2dEtadPhiMatched(g.fh2dEtadPhiMatched),fh2dEtadPhiUnmatched(g.fh2dEtadPhiUnmatched),\r
+ fh2OuterPtVsExtrapPt(g.fh2OuterPtVsExtrapPt),fh2OuterPhiVsExtrapPhi(g.fh2OuterPhiVsExtrapPhi),\r
+ fh2OuterEtaVsExtrapEta(g.fh2OuterEtaVsExtrapEta),\r
+ fh2TrackPVsClusterE(g.fh2TrackPVsClusterE),fh2TrackPtVsClusterE(g.fh2TrackPtVsClusterE),\r
+ fh2TrackPhiVsClusterPhi(g.fh2TrackPhiVsClusterPhi),fh2TrackEtaVsClusterEta(g.fh2TrackEtaVsClusterEta), \r
+ //reco\r
+ fhPtElectron(g.fhPtElectron),fhPhiElectron(g.fhPhiElectron),fhEtaElectron(g.fhEtaElectron),\r
+ //MC\r
+ fhPtConversion(g.fhPtConversion),fhPhiConversion(g.fhPhiConversion),fhEtaConversion(g.fhEtaConversion),\r
+ fhPtBottom(g.fhPtBottom),fhPhiBottom(g.fhPhiBottom),fhEtaBottom(g.fhEtaBottom),\r
+ fhPtCharm(g.fhPtCharm),fhPhiCharm(g.fhPhiCharm),fhEtaCharm(g.fhEtaCharm),\r
+ fhPtCFromB(g.fhPtCFromB),fhPhiCFromB(g.fhPhiCFromB),fhEtaCFromB(g.fhEtaCFromB),\r
+ fhPtDalitz(g.fhPtDalitz),fhPhiDalitz(g.fhPhiDalitz),fhEtaDalitz(g.fhEtaDalitz),\r
+ fhPtWDecay(g.fhPtWDecay),fhPhiWDecay(g.fhPhiWDecay),fhEtaWDecay(g.fhEtaWDecay),\r
+ fhPtZDecay(g.fhPtZDecay),fhPhiZDecay(g.fhPhiZDecay),fhEtaZDecay(g.fhEtaZDecay),\r
+ fhPtPrompt(g.fhPtPrompt),fhPhiPrompt(g.fhPhiPrompt),fhEtaPrompt(g.fhEtaPrompt),\r
+ fhPtUnknown(g.fhPtUnknown),fhPhiUnknown(g.fhPhiUnknown),fhEtaUnknown(g.fhEtaUnknown)\r
+ // fhMCElePt(g.fhMCElePt),fhMCElePhi(g.fhMCElePhi),fhMCEleEta(g.fhMCEleEta)\r
+{\r
+ // cpy ctor\r
+ \r
+}\r
+\r
+//_________________________________________________________________________\r
+AliAnaElectron & AliAnaElectron::operator = (const AliAnaElectron & g)\r
+{\r
+ // assignment operator\r
+ \r
+ if(&g == this) return *this;\r
+ fCalorimeter = g.fCalorimeter;\r
+ fpOverEmin = g.fpOverEmin;\r
+ fpOverEmax = g.fpOverEmax;\r
+ fResidualCut = g.fResidualCut;\r
+ //fhEnergy = g.fhEnergy;\r
+ //fhClusMult = g.fhClusMult;\r
+ //fhClusters = g.fhClusters;\r
+ //fhDigitsEvent = g.fhDigitsEvent;\r
+ fh1pOverE = g.fh1pOverE;\r
+ fh1dR = g.fh1dR;\r
+ fh2EledEdx = g.fh2EledEdx;\r
+ fh2MatchdEdx = g.fh2MatchdEdx;\r
+ fh2dEtadPhi = g.fh2dEtadPhi;\r
+ fh2dEtadPhiMatched = g.fh2dEtadPhiMatched;\r
+ fh2dEtadPhiUnmatched = g.fh2dEtadPhiUnmatched;\r
+ fh2OuterPtVsExtrapPt = g.fh2OuterPtVsExtrapPt;\r
+ fh2OuterPhiVsExtrapPhi = g.fh2OuterPhiVsExtrapPhi;\r
+ fh2OuterEtaVsExtrapEta = g.fh2OuterEtaVsExtrapEta;\r
+ fh2TrackPVsClusterE = g.fh2TrackPVsClusterE;\r
+ fh2TrackPtVsClusterE = g.fh2TrackPtVsClusterE;\r
+ fh2TrackPhiVsClusterPhi = g.fh2TrackPhiVsClusterPhi;\r
+ fh2TrackEtaVsClusterEta = g.fh2TrackEtaVsClusterEta; \r
+ fhPtElectron = g.fhPtElectron;\r
+ fhPhiElectron = g.fhPhiElectron;\r
+ fhEtaElectron = g.fhEtaElectron;\r
+ fhPtConversion = g.fhPtConversion;\r
+ fhPhiConversion = g.fhPhiConversion;\r
+ fhEtaConversion = g.fhEtaConversion;\r
+ fhPtBottom = g.fhPtBottom;\r
+ fhPhiBottom = g.fhPhiBottom;\r
+ fhEtaBottom = g.fhEtaBottom;\r
+ fhPtCharm = g.fhPtCharm;\r
+ fhPhiCharm = g.fhPhiCharm;\r
+ fhEtaCharm = g.fhEtaCharm;\r
+ fhPtCFromB = g.fhPtCFromB;\r
+ fhPhiCFromB = g.fhPhiCFromB;\r
+ fhEtaCFromB = g.fhEtaCFromB;\r
+ fhPtDalitz = g.fhPtDalitz;\r
+ fhPhiDalitz = g.fhPhiDalitz;\r
+ fhEtaDalitz = g.fhEtaDalitz;\r
+ fhPtWDecay = g.fhPtWDecay;\r
+ fhPhiWDecay = g.fhPhiWDecay;\r
+ fhEtaWDecay = g.fhEtaWDecay;\r
+ fhPtZDecay = g.fhPtZDecay;\r
+ fhPhiZDecay = g.fhPhiZDecay;\r
+ fhEtaZDecay = g.fhEtaZDecay;\r
+ fhPtPrompt = g.fhPtPrompt;\r
+ fhPhiPrompt = g.fhPhiPrompt;\r
+ fhEtaPrompt = g.fhEtaPrompt;\r
+ fhPtUnknown = g.fhPtUnknown;\r
+ fhPhiUnknown = g.fhPhiUnknown;\r
+ fhEtaUnknown = g.fhEtaUnknown;\r
+\r
+ /*\r
+ fhMCElePt = g.fhMCElePt;\r
+ fhMCElePhi = g.fhMCElePhi;\r
+ fhMCEleEta = g.fhMCEleEta;\r
+ */\r
+\r
+ return *this;\r
+ \r
+}\r
+\r
+//____________________________________________________________________________\r
+AliAnaElectron::~AliAnaElectron() \r
+{\r
+ //dtor\r
+\r
+}\r
+\r
+\r
+//________________________________________________________________________\r
+TList * AliAnaElectron::GetCreateOutputObjects()\r
+{ \r
+ // Create histograms to be saved in output file and \r
+ // store them in outputContainer\r
+ TList * outputContainer = new TList() ; \r
+ outputContainer->SetName("ElectronHistos") ; \r
+ \r
+ Int_t nptbins = GetHistoNPtBins();\r
+ Int_t nphibins = GetHistoNPhiBins();\r
+ Int_t netabins = GetHistoNEtaBins();\r
+ Float_t ptmax = GetHistoPtMax();\r
+ Float_t phimax = GetHistoPhiMax();\r
+ Float_t etamax = GetHistoEtaMax();\r
+ Float_t ptmin = GetHistoPtMin();\r
+ Float_t phimin = GetHistoPhiMin();\r
+ Float_t etamin = GetHistoEtaMin(); \r
+\r
+ fh1pOverE = new TH1F("h1pOverE","EMCAL-TRACK matches p/E",100,0.,10.);\r
+ fh1dR = new TH1F("h1dR","EMCAL-TRACK matches dR",300, 0.,TMath::Pi());\r
+ fh2EledEdx = new TH2F("h2EledEdx","dE/dx vs. p for electrons",200,0.,50.,200,0.,400.);\r
+ fh2MatchdEdx = new TH2F("h2MatchdEdx","dE/dx vs. p for all matches",200,0.,50.,200,0.,400.);\r
+ fh2dEtadPhi = new TH2F("h2dEtadPhi","#Delta#eta vs. #Delta#phi for all track-cluster pairs",200,0.,1.4,300,0.,TMath::Pi());\r
+ fh2dEtadPhiMatched = new TH2F("h2dEtadPhiMatched","#Delta#eta vs. #Delta#phi for matched track-cluster pairs",200,0.,1.4,300,0.,TMath::Pi());\r
+ fh2dEtadPhiUnmatched = new TH2F("h2dEtadPhiUnmatched","#Delta#eta vs. #Delta#phi for unmatched track-cluster pairs",200,0.,1.4,300,0.,TMath::Pi());\r
+ fh2OuterPtVsExtrapPt = new TH2F("h2OuterPtVsExtrapPt","h2OuterPtVsExtrapPt",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);\r
+ fh2OuterPhiVsExtrapPhi = new TH2F("h2OuterPhiVsExtrapPhi","h2OuterPhiVsExtrapPhi",nphibins,phimin,phimax,nphibins,phimin,phimax);\r
+ fh2OuterEtaVsExtrapEta = new TH2F("h2OuterEtaVsExtrapEta","h2OuterEtaVsExtrapEta",netabins,etamin,etamax,netabins,etamin,etamax);\r
+\r
+ fh2TrackPVsClusterE = new TH2F("h2TrackPVsClusterE","h2TrackPVsClusterE",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);\r
+ fh2TrackPtVsClusterE = new TH2F("h2TrackPtVsClusterE","h2TrackPtVsClusterE",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);\r
+ fh2TrackPhiVsClusterPhi = new TH2F("h2TrackPhiVsClusterPhi","h2TrackPhiVsClusterPhi",nphibins,phimin,phimax,nphibins,phimin,phimax);\r
+ fh2TrackEtaVsClusterEta = new TH2F("h2TrackEtaVsClusterEta","h2TrackEtaVsClusterEta",netabins,etamin,etamax,netabins,etamin,etamax);\r
+\r
+ outputContainer->Add(fh1pOverE) ; \r
+ outputContainer->Add(fh1dR) ; \r
+ outputContainer->Add(fh2EledEdx) ;\r
+ outputContainer->Add(fh2MatchdEdx) ;\r
+ outputContainer->Add(fh2dEtadPhi) ;\r
+ outputContainer->Add(fh2dEtadPhiMatched) ;\r
+ outputContainer->Add(fh2dEtadPhiUnmatched) ;\r
+ outputContainer->Add(fh2OuterPtVsExtrapPt) ;\r
+ outputContainer->Add(fh2OuterPhiVsExtrapPhi) ;\r
+ outputContainer->Add(fh2OuterEtaVsExtrapEta) ;\r
+ outputContainer->Add(fh2TrackPVsClusterE) ;\r
+ outputContainer->Add(fh2TrackPtVsClusterE) ;\r
+ outputContainer->Add(fh2TrackPhiVsClusterPhi) ;\r
+ outputContainer->Add(fh2TrackEtaVsClusterEta) ;\r
+ \r
+ fhPtElectron = new TH1F("hPtElectron","Electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiElectron = new TH2F("hPhiElectron","Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaElectron = new TH2F("hEtaElectron","Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+\r
+ outputContainer->Add(fhPtElectron) ; \r
+ outputContainer->Add(fhPhiElectron) ; \r
+ outputContainer->Add(fhEtaElectron) ;\r
+ \r
+ if(IsDataMC()){\r
+ \r
+ fhPtConversion = new TH1F("hPtConversion","Conversion electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiConversion = new TH2F("hPhiConversion","Conversion Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaConversion = new TH2F("hEtaConversion","Conversion Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtBottom = new TH1F("hPtBottom","Bottom electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiBottom = new TH2F("hPhiBottom","Bottom Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaBottom = new TH2F("hEtaBottom","Bottom Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtCharm = new TH1F("hPtCharm","Charm electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiCharm = new TH2F("hPhiCharm","Charm Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaCharm = new TH2F("hEtaCharm","Charm Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtCFromB = new TH1F("hPtCFromB","Charm from Bottom electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiCFromB = new TH2F("hPhiCFromB","Charm from Bottom Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaCFromB = new TH2F("hEtaCFromB","Charm from Bottom Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtDalitz = new TH1F("hPtDalitz","Dalitz electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiDalitz = new TH2F("hPhiDalitz","Dalitz Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaDalitz = new TH2F("hEtaDalitz","Dalitz Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtWDecay = new TH1F("hPtWDecay","W-boson Electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiWDecay = new TH2F("hPhiWDecay","W-boson electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaWDecay = new TH2F("hEtaWDecay","W-boson Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtZDecay = new TH1F("hPtZDecay","Z-boson electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiZDecay = new TH2F("hPhiZDecay","Z-boson Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaZDecay = new TH2F("hEtaZDecay","Z-boson Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtPrompt = new TH1F("hPtPrompt","Prompt electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiPrompt = new TH2F("hPhiPrompt","Prompt Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaPrompt = new TH2F("hEtaPrompt","Prompt Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ fhPtUnknown = new TH1F("hPtUnknown","Unknown electron pT",nptbins,ptmin,ptmax);\r
+ fhPhiUnknown = new TH2F("hPhiUnknown","Unknown Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhEtaUnknown = new TH2F("hEtaUnknown","Unknown Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+\r
+ outputContainer->Add(fhPtConversion);\r
+ outputContainer->Add(fhPhiConversion);\r
+ outputContainer->Add(fhEtaConversion);\r
+ outputContainer->Add(fhPtBottom);\r
+ outputContainer->Add(fhPhiBottom);\r
+ outputContainer->Add(fhEtaBottom);\r
+ outputContainer->Add(fhPtCharm);\r
+ outputContainer->Add(fhPhiCharm);\r
+ outputContainer->Add(fhEtaCharm);\r
+ outputContainer->Add(fhPtCFromB);\r
+ outputContainer->Add(fhPhiCFromB);\r
+ outputContainer->Add(fhEtaCFromB);\r
+ outputContainer->Add(fhPtDalitz);\r
+ outputContainer->Add(fhPhiDalitz);\r
+ outputContainer->Add(fhEtaDalitz);\r
+ outputContainer->Add(fhPtWDecay);\r
+ outputContainer->Add(fhPhiWDecay);\r
+ outputContainer->Add(fhEtaWDecay);\r
+ outputContainer->Add(fhPtZDecay);\r
+ outputContainer->Add(fhPhiZDecay);\r
+ outputContainer->Add(fhEtaZDecay);\r
+ outputContainer->Add(fhPtPrompt);\r
+ outputContainer->Add(fhPhiPrompt);\r
+ outputContainer->Add(fhEtaPrompt);\r
+ outputContainer->Add(fhPtUnknown);\r
+ outputContainer->Add(fhPhiUnknown);\r
+ outputContainer->Add(fhEtaUnknown);\r
+\r
+ /*\r
+ fhMCElePt = new TH1F("hMCElePt","MC Electron pT",nptbins,ptmin,ptmax);\r
+ fhMCElePhi = new TH2F("hMCElePhi","MC Electron phi",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+ fhMCEleEta = new TH2F("hMCEleEta","MC Electron eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+ \r
+ outputContainer->Add(fhMCElePt) ; \r
+ outputContainer->Add(fhMCElePhi) ; \r
+ outputContainer->Add(fhMCEleEta) ;\r
+ */\r
+\r
+ }//Histos with MC\r
+ \r
+ //Save parameters used for analysis\r
+ TString parList ; //this will be list of parameters used for this analysis.\r
+ char onePar[255] ;\r
+ \r
+ sprintf(onePar,"--- AliAnaElectron ---\n") ;\r
+ parList+=onePar ; \r
+ sprintf(onePar,"fCalorimeter: %s\n",fCalorimeter.Data()) ;\r
+ parList+=onePar ; \r
+ sprintf(onePar,"fpOverEmin: %f\n",fpOverEmin) ;\r
+ parList+=onePar ; \r
+ sprintf(onePar,"fpOverEmax: %f\n",fpOverEmax) ;\r
+ parList+=onePar ; \r
+ sprintf(onePar,"fResidualCut: %f\n",fResidualCut) ;\r
+ parList+=onePar ; \r
+ \r
+ //Get parameters set in base class.\r
+ parList += GetBaseParametersList() ;\r
+ \r
+ //Get parameters set in FidutialCut class (not available yet)\r
+ //parlist += GetFidCut()->GetFidCutParametersList() \r
+ \r
+ TObjString *oString= new TObjString(parList) ;\r
+ outputContainer->Add(oString);\r
+ \r
+ return outputContainer ;\r
+ \r
+}\r
+\r
+//____________________________________________________________________________\r
+void AliAnaElectron::Init()\r
+{\r
+ \r
+ //Init\r
+ //Do some checks\r
+// if(fCalorimeter == "PHOS" && !GetReader()->IsPHOSSwitchedOn()){\r
+// printf("AliAnaElectron::Init() - !!ABORT: You want to use PHOS in analysis but it is not read!! \n!!Check the configuration file!!\n");\r
+// abort();\r
+// }\r
+// else if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn()){\r
+// printf("AliAnaElectron::Init() - !!ABORT: You want to use EMCAL in analysis but it is not read!! \n!!Check the configuration file!!\n");\r
+// abort();\r
+// }\r
+ \r
+}\r
+\r
+\r
+//____________________________________________________________________________\r
+void AliAnaElectron::InitParameters()\r
+{\r
+ \r
+ //Initialize the parameters of the analysis.\r
+ SetOutputAODClassName("AliAODPWG4Particle");\r
+ SetOutputAODName("PWG4Particle");\r
+\r
+ AddToHistogramsName("AnaElectron_");\r
+\r
+ fCalorimeter = "EMCAL" ;\r
+ fpOverEmin = 0.5;\r
+ fpOverEmax = 1.5;\r
+ fResidualCut = 0.02;\r
+\r
+}\r
+\r
+//__________________________________________________________________\r
+void AliAnaElectron::MakeAnalysisFillAOD() \r
+{\r
+ //\r
+ // Do analysis and fill aods with electron candidates\r
+ // These AODs will be used to do subsequent histogram filling\r
+ //\r
+ // Also fill some QA histograms\r
+ //\r
+\r
+ //Search for electrons in fCalorimeter \r
+ //TRefArray * caloData = new TRefArray(); \r
+ //TRefArray * ctsData = new TRefArray();\r
+ cout<<"Event type "<<GetReader()->GetInputEvent()->GetName()<<endl;\r
+ if((strcmp(GetReader()->GetInputEvent()->GetName(),"AliESDEvent"))) {\r
+ printf("AliAnaElectron::MakeAnalysisFillAOD() - !!ABORT: Analysis working only with ESDs!!\n");\r
+ abort();\r
+ }\r
+\r
+ //Get vertex for cluster momentum calculation\r
+ Double_t vertex[]={0,0,0} ; //vertex ;\r
+ if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) GetReader()->GetVertex(vertex);\r
+ //Get bfield for track extrapolation to Calorimeter\r
+ Double_t bfield = GetReader()->GetInputEvent()->GetMagneticField(); //from V0 finder\r
+ Double_t radius = 0.;\r
+\r
+ //Get the CTS tracks\r
+ //ctsData = GetAODCTS();\r
+ //Select the Calorimeter of the electron\r
+ if(fCalorimeter == "PHOS") {\r
+ //caloData = GetAODPHOS();\r
+ radius = 425.0; //FIXME\r
+ } else if (fCalorimeter == "EMCAL") {\r
+ //caloData = GetAODEMCAL();\r
+ radius = 441.0; //[cm] EMCAL radius +13cm FIXME\r
+ }\r
+\r
+ //if(!(ctsData && caloData) || (ctsData->GetEntriesFast() == 0 || caloData->GetEntriesFast() == 0)) return;\r
+ //if(!caloData || caloData->GetEntriesFast() == 0) return;\r
+\r
+ ////////////////////////////////////////////////\r
+ //Start from tracks and get associated clusters \r
+ //\r
+ //Note: an alternative method would be to start from clusters and get associated tracks -\r
+ //which is better? For electrons, probably tracks-->clusters\r
+ ////////////////////////////////////////////////\r
+// for(Int_t itrk = 0; itrk < ctsData->GetEntriesFast(); itrk++){\r
+// AliAODTrack *track = (AliAODTrack*)ctsData->At(itrk);\r
+\r
+ AliESDEvent *esd = (AliESDEvent*) GetReader()->GetInputEvent();\r
+ Int_t nTracks = esd->GetNumberOfTracks() ;\r
+ for (Int_t itrk = 0; itrk < nTracks; itrk++) {////////////// track loop\r
+ AliESDtrack * track = (AliESDtrack*) esd->GetTrack(itrk) ;\r
+ //extrapolate track to Calorimeter\r
+ Double_t emcmom[3] = {0.,0.,0.};\r
+ Double_t emcpos[3] = {0.,0.,0.};\r
+ AliExternalTrackParam *outerparam = (AliExternalTrackParam*)track->GetOuterParam();\r
+ if(!outerparam) continue;\r
+ \r
+ Bool_t okpos = outerparam->GetXYZAt(radius,bfield,emcpos);\r
+ Bool_t okmom = outerparam->GetPxPyPzAt(radius,bfield,emcmom);\r
+ if(!(okpos && okmom)) continue;\r
+ \r
+ TVector3 pos(emcpos[0],emcpos[1],emcpos[2]);\r
+ TVector3 mom(emcmom[0],emcmom[1],emcmom[2]);\r
+ Double_t tphi = pos.Phi();\r
+ Double_t teta = pos.Eta();\r
+ Double_t tmom = mom.Mag();\r
+ \r
+ TLorentzVector mom2(mom,0.);\r
+ Bool_t in = GetFidutialCut()->IsInFidutialCut(mom2,fCalorimeter) ;\r
+ if(GetDebug() > 1) printf("AliAnaElectron::MakeAnalysisFillAOD() - Track pt %2.2f, phi %2.2f, eta %2.2f in fidutial cut %d\n",track->Pt(), track->Phi(), track->Eta(), in);\r
+ if(mom.Pt() > GetMinPt() && in) {\r
+\r
+ printf("\tExtrapolated pt %2.2f, phi %2.2f, eta %2.2f \n",mom.Pt(),mom.Phi(),mom.Eta());\r
+ fh2OuterPtVsExtrapPt->Fill(mom.Pt(),track->Pt());\r
+ fh2OuterPhiVsExtrapPhi->Fill(mom.Phi(),track->Phi());\r
+ fh2OuterEtaVsExtrapEta->Fill(mom.Eta(),track->Eta());\r
+\r
+ Int_t ntot = esd->GetNumberOfCaloClusters();//caloData->GetEntriesFast();\r
+ Double_t res = 999.;\r
+ Double_t pOverE = -999.;\r
+ \r
+ //For tracks in EMCAL acceptance, pair them with all clusters\r
+ //and fill the dEta vs dPhi for these pairs:\r
+ for(Int_t iclus = 0; iclus < esd->GetNumberOfCaloClusters(); iclus++) {\r
+ AliESDCaloCluster * clus = (AliESDCaloCluster*) esd->GetCaloCluster(iclus);\r
+ if(!clus) continue;\r
+ if(fCalorimeter == "PHOS" && !clus->IsPHOS()) continue;\r
+ if(fCalorimeter == "EMCAL" && !clus->IsEMCAL()) continue;\r
+ \r
+ Float_t x[3];\r
+ clus->GetPosition(x);\r
+ TVector3 cluspos(x[0],x[1],x[2]);\r
+ Double_t deta = teta - cluspos.Eta();\r
+ Double_t dphi = tphi - cluspos.Phi();\r
+ if(dphi > TMath::Pi()) dphi -= 2*TMath::Pi();\r
+ if(dphi < -TMath::Pi()) dphi += 2*TMath::Pi();\r
+ if(track->GetEMCALcluster() < -9000) fh2dEtadPhiUnmatched->Fill(deta,dphi);\r
+ fh2dEtadPhi->Fill(deta,dphi);\r
+ fh2TrackPVsClusterE->Fill(clus->E(),track->P());\r
+ fh2TrackPtVsClusterE->Fill(clus->E(),track->Pt());\r
+ fh2TrackPhiVsClusterPhi->Fill(cluspos.Phi(),mom.Phi());\r
+ fh2TrackEtaVsClusterEta->Fill(cluspos.Eta(),mom.Eta());\r
+ }\r
+ \r
+ /////////////////////////////////\r
+ //Perform electron cut analysis//\r
+ /////////////////////////////////\r
+ Bool_t isElectron = kFALSE;\r
+ \r
+ Int_t iCluster = track->GetEMCALcluster();\r
+ if(iCluster < -9000) {printf("NOT MATCHED"); continue; }//no match\r
+ if(iCluster > ntot) continue; //index out of range; shouldn't happen\r
+ if(iCluster < 0 && iCluster > -9000) { //this should only happen in MC events\r
+ printf("AliAnaElectron::MakeAnalysisFillAOD() - Track has a fake match: %d\n",iCluster);\r
+ continue;\r
+ }\r
+ AliESDCaloCluster * clus = (AliESDCaloCluster*) esd->GetCaloCluster(iCluster);\r
+ if(!clus) continue;\r
+ if(fCalorimeter == "PHOS" && !clus->IsPHOS()) continue;\r
+ if(fCalorimeter == "EMCAL" && !clus->IsEMCAL()) continue;\r
+ \r
+ Float_t x[3];\r
+ clus->GetPosition(x);\r
+ TVector3 cluspos(x[0],x[1],x[2]);\r
+ Double_t deta = teta - cluspos.Eta();\r
+ Double_t dphi = tphi - cluspos.Phi();\r
+ if(dphi > TMath::Pi()) dphi -= 2*TMath::Pi();\r
+ if(dphi < -TMath::Pi()) dphi += 2*TMath::Pi();\r
+ res = sqrt(dphi*dphi + deta*deta);\r
+ fh1dR->Fill(res);\r
+ fh2dEtadPhiMatched->Fill(deta,dphi);\r
+ \r
+ if(res < fResidualCut) {\r
+ //Good match\r
+ fh2MatchdEdx->Fill(track->P(),track->GetTPCsignal());\r
+ \r
+ Double_t energy = clus->E(); \r
+ if(energy > 0) pOverE = tmom/energy;\r
+ fh1pOverE->Fill(pOverE);\r
+ \r
+ Int_t mult = clus->GetNumberOfDigits();\r
+ // Int_t mcClus = clus->GetLabel();\r
+ AliESDCaloCluster * esdcalo = (AliESDCaloCluster*) esd->GetCaloCluster(clus->GetID());\r
+ Int_t matchIndex = esdcalo->GetTrackMatched();\r
+ \r
+ if(matchIndex != itrk) printf("Track and cluster don't agree! track %d, cluster %d",itrk,matchIndex);\r
+ if(mult < 2) printf("Single digit cluster.");\r
+ \r
+ //////////////////////////////\r
+ //Electron cuts happen here!//\r
+ //////////////////////////////\r
+ if(pOverE > fpOverEmin && pOverE < fpOverEmax) isElectron = kTRUE;\r
+ \r
+ } //good matching residual\r
+ \r
+ ///////////////////////////\r
+ //Fill AOD with electrons//\r
+ ///////////////////////////\r
+ if(isElectron) {\r
+ \r
+ fh2EledEdx->Fill(track->P(),track->GetTPCsignal());\r
+\r
+ Double_t eMass = 0.511/1000; //mass in GeV\r
+ Double_t eleE = sqrt(track->P()*track->P() + eMass*eMass);\r
+ AliAODPWG4Particle tr = AliAODPWG4Particle(track->Px(),track->Py(),track->Pz(),eleE);\r
+ tr.SetLabel(tr.GetLabel());\r
+ tr.SetCaloLabel(clus->GetID(),-1); //sets the indices of the original caloclusters\r
+ tr.SetDetector(fCalorimeter);\r
+ tr.SetPdg(11);\r
+ \r
+ //Play with the MC stack if available\r
+ //Check origin of the candidates\r
+ if(IsDataMC()){\r
+ \r
+ //FIXME: Need to re-think this for track-oriented analysis\r
+ tr.SetTag(GetMCAnalysisUtils()->CheckOrigin(clus->GetLabel(),GetMCStack()));\r
+ \r
+ if(GetDebug() > 0) printf("AliAnaElectron::MakeAnalysisFillAOD() - Origin of candidate %d\n",tr.GetTag());\r
+ }//Work with stack also \r
+\r
+ AddAODParticle(tr);\r
+\r
+ if(GetDebug() > 1) printf("AliAnaElectron::MakeAnalysisFillAOD() - Electron selection cuts passed: pT %3.2f, pdg %d\n",tr.Pt(),tr.GetPdg()); \r
+ }//electron\r
+ }//pt, fiducial selection \r
+ }//track loop \r
+ \r
+ //FIXME: Should we also check from the calocluster side, just in\r
+ //case?\r
+\r
+ if(GetDebug() > 1) printf("AliAnaElectron::MakeAnalysisFillAOD() End fill AODs \n"); \r
+\r
+}\r
+\r
+//__________________________________________________________________\r
+void AliAnaElectron::MakeAnalysisFillHistograms() \r
+{\r
+ //Do analysis and fill histograms\r
+ \r
+ //Loop on stored AOD electrons\r
+ Int_t naod = GetOutputAODBranch()->GetEntriesFast();\r
+ if(GetDebug() > 0) printf("AliAnaElectron::MakeAnalysisFillHistograms() - aod branch entries %d\n", naod);\r
+ \r
+ for(Int_t iaod = 0; iaod < naod ; iaod++){\r
+ AliAODPWG4Particle* ele = (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));\r
+ Int_t pdg = ele->GetPdg();\r
+ \r
+ if(GetDebug() > 3) \r
+ printf("AliAnaElectron::MakeAnalysisFillHistograms() - PDG %d, MC TAG %d, Calorimeter %s\n", ele->GetPdg(),ele->GetTag(), (ele->GetDetector()).Data()) ;\r
+ \r
+ if(pdg != AliCaloPID::kElectron) continue; \r
+ if(ele->GetDetector() != fCalorimeter) continue;\r
+ \r
+ if(GetDebug() > 1) \r
+ printf("AliAnaElectron::MakeAnalysisFillHistograms() - ID Electron: pt %f, phi %f, eta %f\n", ele->Pt(),ele->Phi(),ele->Eta()) ;\r
+ \r
+ //Fill electron histograms \r
+ Float_t ptele = ele->Pt();\r
+ Float_t phiele = ele->Phi();\r
+ Float_t etaele = ele->Eta();\r
+ \r
+ fhPtElectron ->Fill(ptele);\r
+ fhPhiElectron ->Fill(ptele,phiele);\r
+ fhEtaElectron ->Fill(ptele,etaele);\r
+ \r
+ if(IsDataMC()){\r
+ Int_t tag = ele->GetTag();\r
+ if(tag == AliMCAnalysisUtils::kMCConversion){\r
+ fhPtConversion ->Fill(ptele);\r
+ fhPhiConversion ->Fill(ptele,phiele);\r
+ fhEtaConversion ->Fill(ptele,etaele);\r
+ }\r
+ else if(tag==AliMCAnalysisUtils::kMCEFromB)\r
+ {\r
+ fhPtBottom ->Fill(ptele);\r
+ fhPhiBottom ->Fill(ptele,phiele);\r
+ fhEtaBottom ->Fill(ptele,etaele);\r
+ }\r
+ else if(tag==AliMCAnalysisUtils::kMCEFromC)\r
+ {\r
+ fhPtCharm ->Fill(ptele);\r
+ fhPhiCharm ->Fill(ptele,phiele);\r
+ fhEtaCharm ->Fill(ptele,etaele);\r
+ }\r
+ else if(tag==AliMCAnalysisUtils::kMCEFromCFromB)\r
+ {\r
+ fhPtCFromB ->Fill(ptele);\r
+ fhPhiCFromB ->Fill(ptele,phiele);\r
+ fhEtaCFromB ->Fill(ptele,etaele);\r
+ }\r
+ else if(tag==AliMCAnalysisUtils::kMCPi0Decay || tag==AliMCAnalysisUtils::kMCEtaDecay || tag==AliMCAnalysisUtils::kMCOtherDecay)\r
+ {\r
+ fhPtDalitz ->Fill(ptele);\r
+ fhPhiDalitz ->Fill(ptele,phiele);\r
+ fhEtaDalitz ->Fill(ptele,etaele);\r
+ }\r
+ else if(tag==AliMCAnalysisUtils::kMCWDecay)\r
+ {\r
+ fhPtWDecay ->Fill(ptele);\r
+ fhPhiWDecay ->Fill(ptele,phiele);\r
+ fhEtaWDecay ->Fill(ptele,etaele);\r
+ }\r
+ else if(tag==AliMCAnalysisUtils::kMCZDecay)\r
+ {\r
+ fhPtZDecay ->Fill(ptele);\r
+ fhPhiZDecay ->Fill(ptele,phiele);\r
+ fhEtaZDecay ->Fill(ptele,etaele);\r
+ }\r
+ else if(tag==AliMCAnalysisUtils::kMCElectron)\r
+ {\r
+ fhPtPrompt ->Fill(ptele);\r
+ fhPhiPrompt ->Fill(ptele,phiele);\r
+ fhEtaPrompt ->Fill(ptele,etaele); \r
+ }\r
+ else{\r
+ fhPtUnknown ->Fill(ptele);\r
+ fhPhiUnknown ->Fill(ptele,phiele);\r
+ fhEtaUnknown ->Fill(ptele,etaele);\r
+ }\r
+ }//Histograms with MC\r
+ \r
+ }// aod loop\r
+\r
+ ////////////////////////////////////////////////////////\r
+ //Fill histograms of pure MC kinematics from the stack//\r
+ ////////////////////////////////////////////////////////\r
+ if(IsDataMC()) {\r
+ AliStack * stack = GetMCStack() ;\r
+\r
+ if(!stack)\r
+ printf("AliAnaElectron::MakeAnalysisFillHistograms() *** no stack ***: \n");\r
+\r
+ //FIXME: Fill pure kine histograms here\r
+\r
+ }\r
+\r
+}\r
+\r
+\r
+//__________________________________________________________________\r
+void AliAnaElectron::Print(const Option_t * opt) const\r
+{\r
+ //Print some relevant parameters set for the analysis\r
+ \r
+ if(! opt)\r
+ return;\r
+ \r
+ printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;\r
+ AliAnaPartCorrBaseClass::Print(" ");\r
+\r
+ printf("Calorimeter = %s\n", fCalorimeter.Data()) ;\r
+ printf("pOverE range = %f - %f\n",fpOverEmin,fpOverEmax);\r
+ printf("residual cut = %f\n",fResidualCut);\r
+ printf(" \n") ;\r
+ \r
+} \r
+\r
+//________________________________________________________________________ \r
+void AliAnaElectron::ReadHistograms(TList* outputList)\r
+{\r
+ // Needed when Terminate is executed in distributed environment \r
+ // Refill analysis histograms of this class with corresponding\r
+ // histograms in output list. \r
+\r
+ // Histograms of this analsys are kept in the same list as other\r
+ // analysis, recover the position of\r
+ // the first one and then add the next \r
+ Int_t index = outputList->IndexOf(outputList->FindObject(GetAddedHistogramsStringToName()+"fh1pOverE"));\r
+\r
+ //Read histograms, must be in the same order as in\r
+ //GetCreateOutputObject. \r
+ fh1pOverE = (TH1F *) outputList->At(index);\r
+ fh1dR = (TH1F *) outputList->At(index++);\r
+ fh2EledEdx = (TH2F *) outputList->At(index++);\r
+ fh2MatchdEdx = (TH2F *) outputList->At(index++);\r
+ \r
+}\r
+\r
+//__________________________________________________________________ \r
+void AliAnaElectron::Terminate(TList* outputList)\r
+{\r
+\r
+ //Do some plots to end\r
+ //Recover histograms from output histograms list, needed for\r
+ //distributed analysis. \r
+ // ReadHistograms(outputList);\r
+\r
+ printf(" AliAnaElectron::Terminate() *** %s Report:", GetName()) ;\r
+\r
+}\r
+\r