AliAnaElectron (Jenn):
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Sep 2009 09:24:33 +0000 (09:24 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 24 Sep 2009 09:24:33 +0000 (09:24 +0000)
Added Mark's btag QA histos
Added three event level QA histos:  impactXY, refmult and refmult2
Added Protection for AliAODPid pointer
Added "Misidentified" electron plots and renamed "Prompt" to "All"
Corrected the definition of xsi
Turned off cut on impactZ in GetBtag()
Set Btag bit in AliAODPWG4Particle according to number returned by GetBtag()

AliAODPWG4Particle(Jenn): Correct init value of Btag bit and add bit checking methods

Readers: Change the access to the vertex, make sure it is the best primary vertex
                Access the output AOD in case the merging of events was executed in the handler

AliAnaCalorimeterQA: Set some protections in case of MC data not available.

PWG4/PartCorrBase/AliAODPWG4Particle.cxx
PWG4/PartCorrBase/AliAODPWG4Particle.h
PWG4/PartCorrBase/AliCaloTrackAODReader.cxx
PWG4/PartCorrBase/AliCaloTrackESDReader.cxx
PWG4/PartCorrDep/AliAnaCalorimeterQA.cxx
PWG4/PartCorrDep/AliAnaElectron.cxx
PWG4/PartCorrDep/AliAnaElectron.h

index 9aa6d72..e758b2a 100755 (executable)
-/**************************************************************************
- * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-
-/* $Id:   AliAODPWG4Particle.h $ */
-
-//-------------------------------------------------------------------------
-//     AOD class for photon and other particles storage and 
-//     correlation studies
-//     Author: Yves Schutz, CERN, Gustavo Conesa, INFN
-//-------------------------------------------------------------------------
-
-//-- ROOT system --
-
-//-- Analysis system
-#include "AliAODPWG4Particle.h"
-
-ClassImp(AliAODPWG4Particle)
-
-
-//______________________________________________________________________________
-AliAODPWG4Particle::AliAODPWG4Particle() :
-AliVParticle(),
-fMomentum(0),fPdg(-1), fTag(0), fBtag(0), fLabel(-1), fCaloLabel(), fTrackLabel(),
-fDetector(""), fDisp(0), fTof(0), fCharged(0), fBadDist(0), fInputFileIndex(0)
-{
-  // constructor
-  fCaloLabel [0] = -1;
-  fCaloLabel [1] = -1;
-  fTrackLabel[0] = -1;
-  fTrackLabel[1] = -1;
-}
-
-//______________________________________________________________________________
-AliAODPWG4Particle::AliAODPWG4Particle(Double_t px, Double_t py, Double_t pz, Double_t e):
-  AliVParticle(),
-  fMomentum(0),fPdg(-1), fTag(0), fBtag(0), fLabel(-1),fCaloLabel(), fTrackLabel(),
-  fDetector(""), fDisp(0),fTof(0),fCharged(0), fBadDist(0), fInputFileIndex(0)
-{
-  // constructor
-  fMomentum = new TLorentzVector(px, py, pz, e);
-  
-  fCaloLabel [0] = -1;
-  fCaloLabel [1] = -1;
-  fTrackLabel[0] = -1;
-  fTrackLabel[1] = -1; 
-}
-
-//______________________________________________________________________________
-AliAODPWG4Particle::AliAODPWG4Particle(TLorentzVector & p):
-  AliVParticle(),
-  fMomentum(0),fPdg(-1), fTag(0), fBtag(0), fLabel(-1),fCaloLabel(), fTrackLabel(),
-  fDetector(""), fDisp(0),fTof(0),fCharged(0),fBadDist(0), fInputFileIndex(0)
-{
-  // constructor
-  fMomentum = new TLorentzVector(p);
-  
-  fCaloLabel [0] = -1;
-  fCaloLabel [1] = -1;
-  fTrackLabel[0] = -1;
-  fTrackLabel[1] = -1;
-}
-
-
-//______________________________________________________________________________
-AliAODPWG4Particle::~AliAODPWG4Particle() 
-{
-  // destructor
-    delete fMomentum;
-}
-
-//______________________________________________________________________________
-AliAODPWG4Particle::AliAODPWG4Particle(const AliAODPWG4Particle& part) :
-  AliVParticle(part),
-  fMomentum(0), fPdg(part.fPdg), fTag(part.fTag), fBtag(part.fBtag), fLabel(part.fLabel), 
-  fCaloLabel(), fTrackLabel(), fDetector(part.fDetector),fDisp(part.fDisp), 
-  fTof(part.fTof), fCharged(part.fCharged),  fBadDist(part.fBadDist), 
-  fInputFileIndex(part.fInputFileIndex)
-{
-  // Copy constructor
-  fMomentum = new TLorentzVector(*part.fMomentum);
-  
-  fCaloLabel [0] = part.fCaloLabel[0];
-  fCaloLabel [1] = part.fCaloLabel[1];
-  fTrackLabel[0] = part.fTrackLabel[0];
-  fTrackLabel[1] = part.fTrackLabel[1];
-}
-
-//______________________________________________________________________________
-AliAODPWG4Particle& AliAODPWG4Particle::operator=(const AliAODPWG4Particle& part)
-{
-  // Assignment operator
-  if(this!=&part) {
-    
-    fPdg   = part.fPdg;
-    fTag   = part.fTag;
-       fBtag  = part.fBtag;
-    fLabel = part.fLabel;
-       
-    fCaloLabel [0] = part.fCaloLabel[0];
-    fCaloLabel [1] = part.fCaloLabel[1];
-    fTrackLabel[0] = part.fTrackLabel[0];
-    fTrackLabel[1] = part.fTrackLabel[1];
-       
-    fDetector = part.fDetector;
-    fDisp     = part.fDisp; 
-    fTof      = part.fTof; 
-    fCharged  = part.fCharged; 
-    fBadDist  = part.fBadDist;
-       fInputFileIndex =  part.fInputFileIndex;
-         
-    if (fMomentum ) delete fMomentum;  
-    fMomentum = new TLorentzVector(*part.fMomentum);
-  }
-  
-  return *this;
-}
-
-
-//_______________________________________________________________
-Bool_t AliAODPWG4Particle::IsPIDOK(const Int_t ipid, const Int_t pdgwanted) const{
-  // returns true if particle satisfies given PID criterium
-       switch(ipid){
-       case 0: return kTRUE ; //No PID at all
-       case 1: 
-         {
-           if (fPdg == pdgwanted) return kTRUE; 
-           else return kFALSE; //Overall PID calculated with bayesian methods.
-         }
-       case 2: return fDisp ;   //only dispersion cut
-       case 3: return fTof ;    //Only TOF cut
-       case 4: return fCharged ;    //Only Charged cut
-       case 5: return fDisp && fTof ;  //Dispersion and TOF
-       case 6: return fDisp && fCharged ;  //Dispersion and Charged
-       case 7: return fTof  && fCharged ;  //TOF and Charged
-       case 8: return fDisp && fTof && fCharged ; // all 3 cuts
-       default: return kFALSE ; //Not known combination
-       }
-}
-
-//______________________________________________________________________________
-void AliAODPWG4Particle::Print(Option_t* /*option*/) const 
-{
-  // Print information of all data members
-  printf("Particle 4-vector:\n");
-  printf("     E  = %13.3f", E() );
-  printf("     Px = %13.3f", Px());
-  printf("     Py = %13.3f", Py());
-  printf("     Pz = %13.3f\n", Pz());
-  printf("PID bits :\n");
-  printf("     TOF        : %d",fTof);
-  printf("     Charged    : %d",fCharged);
-  printf("     Dispersion : %d\n",fDisp);
-  printf("PDG       : %d\n",fPdg);
-  printf("Tag       : %d\n",fTag); 
-  printf("Btag      : %d\n",fBtag);  
-  printf("Dist. to bad channel : %d\n",fBadDist);  
-  printf("Input File Index : %d\n",fInputFileIndex);  
-  printf("Detector  : %s\n",fDetector.Data());
-  
-}
+/**************************************************************************\r
+ * Copyright(c) 1998-2007, 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 is 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
+\r
+/* $Id:   AliAODPWG4Particle.h $ */\r
+\r
+//-------------------------------------------------------------------------\r
+//     AOD class for photon and other particles storage and \r
+//     correlation studies\r
+//     Author: Yves Schutz, CERN, Gustavo Conesa, INFN\r
+//-------------------------------------------------------------------------\r
+\r
+//-- ROOT system --\r
+\r
+//-- Analysis system\r
+#include "AliAODPWG4Particle.h"\r
+\r
+ClassImp(AliAODPWG4Particle)\r
+\r
+\r
+//______________________________________________________________________________\r
+AliAODPWG4Particle::AliAODPWG4Particle() :\r
+AliVParticle(),\r
+fMomentum(0),fPdg(-1), fTag(0), fBtag(-1), fLabel(-1), fCaloLabel(), fTrackLabel(),\r
+fDetector(""), fDisp(0), fTof(0), fCharged(0), fBadDist(0), fInputFileIndex(0)\r
+{\r
+  // constructor\r
+  fCaloLabel [0] = -1;\r
+  fCaloLabel [1] = -1;\r
+  fTrackLabel[0] = -1;\r
+  fTrackLabel[1] = -1;\r
+}\r
+\r
+//______________________________________________________________________________\r
+AliAODPWG4Particle::AliAODPWG4Particle(Double_t px, Double_t py, Double_t pz, Double_t e):\r
+  AliVParticle(),\r
+  fMomentum(0),fPdg(-1), fTag(0), fBtag(-1), fLabel(-1),fCaloLabel(), fTrackLabel(),\r
+  fDetector(""), fDisp(0),fTof(0),fCharged(0), fBadDist(0), fInputFileIndex(0)\r
+{\r
+  // constructor\r
+  fMomentum = new TLorentzVector(px, py, pz, e);\r
+  \r
+  fCaloLabel [0] = -1;\r
+  fCaloLabel [1] = -1;\r
+  fTrackLabel[0] = -1;\r
+  fTrackLabel[1] = -1; \r
+}\r
+\r
+//______________________________________________________________________________\r
+AliAODPWG4Particle::AliAODPWG4Particle(TLorentzVector & p):\r
+  AliVParticle(),\r
+  fMomentum(0),fPdg(-1), fTag(0), fBtag(-1), fLabel(-1),fCaloLabel(), fTrackLabel(),\r
+  fDetector(""), fDisp(0),fTof(0),fCharged(0),fBadDist(0), fInputFileIndex(0)\r
+{\r
+  // constructor\r
+  fMomentum = new TLorentzVector(p);\r
+  \r
+  fCaloLabel [0] = -1;\r
+  fCaloLabel [1] = -1;\r
+  fTrackLabel[0] = -1;\r
+  fTrackLabel[1] = -1;\r
+}\r
+\r
+\r
+//______________________________________________________________________________\r
+AliAODPWG4Particle::~AliAODPWG4Particle() \r
+{\r
+  // destructor\r
+    delete fMomentum;\r
+}\r
+\r
+//______________________________________________________________________________\r
+AliAODPWG4Particle::AliAODPWG4Particle(const AliAODPWG4Particle& part) :\r
+  AliVParticle(part),\r
+  fMomentum(0), fPdg(part.fPdg), fTag(part.fTag), fBtag(part.fBtag), fLabel(part.fLabel), \r
+  fCaloLabel(), fTrackLabel(), fDetector(part.fDetector),fDisp(part.fDisp), \r
+  fTof(part.fTof), fCharged(part.fCharged),  fBadDist(part.fBadDist), \r
+  fInputFileIndex(part.fInputFileIndex)\r
+{\r
+  // Copy constructor\r
+  fMomentum = new TLorentzVector(*part.fMomentum);\r
+  \r
+  fCaloLabel [0] = part.fCaloLabel[0];\r
+  fCaloLabel [1] = part.fCaloLabel[1];\r
+  fTrackLabel[0] = part.fTrackLabel[0];\r
+  fTrackLabel[1] = part.fTrackLabel[1];\r
+}\r
+\r
+//______________________________________________________________________________\r
+AliAODPWG4Particle& AliAODPWG4Particle::operator=(const AliAODPWG4Particle& part)\r
+{\r
+  // Assignment operator\r
+  if(this!=&part) {\r
+    \r
+    fPdg   = part.fPdg;\r
+    fTag   = part.fTag;\r
+    fBtag  = part.fBtag;\r
+    fLabel = part.fLabel;\r
+       \r
+    fCaloLabel [0] = part.fCaloLabel[0];\r
+    fCaloLabel [1] = part.fCaloLabel[1];\r
+    fTrackLabel[0] = part.fTrackLabel[0];\r
+    fTrackLabel[1] = part.fTrackLabel[1];\r
+       \r
+    fDetector = part.fDetector;\r
+    fDisp     = part.fDisp; \r
+    fTof      = part.fTof; \r
+    fCharged  = part.fCharged; \r
+    fBadDist  = part.fBadDist;\r
+       fInputFileIndex =  part.fInputFileIndex;\r
+         \r
+    if (fMomentum ) delete fMomentum;  \r
+    fMomentum = new TLorentzVector(*part.fMomentum);\r
+  }\r
+  \r
+  return *this;\r
+}\r
+\r
+\r
+//_______________________________________________________________\r
+Bool_t AliAODPWG4Particle::IsPIDOK(const Int_t ipid, const Int_t pdgwanted) const{\r
+  // returns true if particle satisfies given PID criterium\r
+       switch(ipid){\r
+       case 0: return kTRUE ; //No PID at all\r
+       case 1: \r
+         {\r
+           if (fPdg == pdgwanted) return kTRUE; \r
+           else return kFALSE; //Overall PID calculated with bayesian methods.\r
+         }\r
+       case 2: return fDisp ;   //only dispersion cut\r
+       case 3: return fTof ;    //Only TOF cut\r
+       case 4: return fCharged ;    //Only Charged cut\r
+       case 5: return fDisp && fTof ;  //Dispersion and TOF\r
+       case 6: return fDisp && fCharged ;  //Dispersion and Charged\r
+       case 7: return fTof  && fCharged ;  //TOF and Charged\r
+       case 8: return fDisp && fTof && fCharged ; // all 3 cuts\r
+       default: return kFALSE ; //Not known combination\r
+       }\r
+}\r
+\r
+//______________________________________________________________________________\r
+void AliAODPWG4Particle::Print(Option_t* /*option*/) const \r
+{\r
+  // Print information of all data members\r
+  printf("Particle 4-vector:\n");\r
+  printf("     E  = %13.3f", E() );\r
+  printf("     Px = %13.3f", Px());\r
+  printf("     Py = %13.3f", Py());\r
+  printf("     Pz = %13.3f\n", Pz());\r
+  printf("PID bits :\n");\r
+  printf("     TOF        : %d",fTof);\r
+  printf("     Charged    : %d",fCharged);\r
+  printf("     Dispersion : %d\n",fDisp);\r
+  printf("PDG       : %d\n",fPdg);\r
+  printf("Tag       : %d\n",fTag); \r
+  printf("Btag      : %d\n",fBtag);  \r
+  printf("Dist. to bad channel : %d\n",fBadDist);  \r
+  printf("Input File Index : %d\n",fInputFileIndex);  \r
+  printf("Detector  : %s\n",fDetector.Data());\r
+  \r
+}\r
index 4f76237..32128c8 100755 (executable)
-#ifndef ALIAODPWG4PARTICLE_H
-#define ALIAODPWG4PARTICLE_H
-/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id: AliAODPWG4Particle.h  $ */
-
-//-------------------------------------------------------------------------
-//     Copy of AOD photon class, adapted for particle identification
-//     and correlations analysis
-//     Author: Yves Schutz, CERN, Gustavo Conesa, INFN
-//-------------------------------------------------------------------------
-
-//-- ROOT system --
-#include <TLorentzVector.h>
-class TString;
-
-//-- Analysis system
-#include "AliVParticle.h"
-
-class AliAODPWG4Particle : public AliVParticle {
-  
- public:
-  AliAODPWG4Particle();
-  AliAODPWG4Particle(Double_t px, Double_t py, Double_t pz, Double_t e);
-  AliAODPWG4Particle(TLorentzVector & p);  
-  virtual ~AliAODPWG4Particle();
-  AliAODPWG4Particle(const AliAODPWG4Particle& photon); 
-  AliAODPWG4Particle& operator=(const AliAODPWG4Particle& photon);
-  
-  // AliVParticle methods
-  virtual Double_t Px()         const { return fMomentum->Px();      }
-  virtual Double_t Py()         const { return fMomentum->Py();      }
-  virtual Double_t Pz()         const { return fMomentum->Pz();      }
-  virtual Double_t Pt()         const { return fMomentum->Pt();      }
-  virtual Double_t P()          const { return fMomentum->P();       }
-  virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
-  virtual Double_t OneOverPt()  const { return 1. / fMomentum->Pt(); }
-  virtual Double_t Phi()        const;
-  virtual Double_t Theta()      const { return fMomentum->Theta();   }
-  virtual Double_t E()          const { return fMomentum->E();       }
-  virtual Double_t M()          const { return fMomentum->M();       }
-  virtual Double_t Eta()        const { return fMomentum->Eta();     }
-  virtual Double_t Y()          const { return fMomentum->Rapidity();}
-  virtual Double_t Xv()         const {return -999.;} // put reasonable values here
-  virtual Double_t Yv()         const {return -999.;} //
-  virtual Double_t Zv()         const {return -999.;} //
-  virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }  
-  virtual void     Print(Option_t* /*option*/) const;
-  
-  //
-  //Dummy
-  virtual Short_t Charge()      const { return 0;}
-  virtual const Double_t* PID() const { return NULL;}
-  //
-  
-  virtual Int_t   GetPdg()               const {return fPdg ; }
-  virtual Int_t   GetTag()               const {return fTag ; }
-  virtual Int_t   GetBtag()              const {return fBtag ; }
-  virtual Int_t   GetLabel()             const {return fLabel ; }
-  virtual Int_t   GetCaloLabel (Int_t i) const {return fCaloLabel[i] ; }
-  virtual Int_t   GetTrackLabel(Int_t i) const {return fTrackLabel[i] ; }
-  virtual TString GetDetector()          const {return fDetector ; }
-  virtual Bool_t  GetDispBit(void)       const {return fDisp ; }
-  virtual Bool_t  GetTOFBit(void)        const {return fTof ; }
-  virtual Bool_t  GetChargedBit(void)    const {return fCharged ; }
-  virtual Int_t   DistToBad()            const {return fBadDist ; } 
-  virtual Int_t   GetInputFileIndex()    const {return fInputFileIndex ; }
-  virtual void SetLabel(Int_t l)         { fLabel = l ; }
-  virtual void SetCaloLabel (Int_t a, Int_t b) { fCaloLabel [0] = a; fCaloLabel [1] = b  ; }
-  virtual void SetTrackLabel(Int_t a, Int_t b) { fTrackLabel[0] = a; fTrackLabel[1] = b  ; }
-  
-  virtual void SetPdg(Int_t pdg)         { fPdg = pdg ; }
-  virtual void SetTag(Int_t tag)         { fTag = tag ; }
-  virtual void SetBtag(Int_t tag)        { fBtag = tag ; }
-  virtual void SetDetector(TString d)    { fDetector = d ; }
-  virtual void SetDispBit(Bool_t disp)   { fDisp = disp ; } 
-  virtual void SetTOFBit(Bool_t tof)     { fTof = tof ;} 
-  virtual void SetChargedBit(Bool_t ch)  { fCharged = ch ; }
-  virtual void SetDistToBad(Int_t dist)  { fBadDist=dist ;} 
-  virtual void SetInputFileIndex(Int_t i){ fInputFileIndex = i;}
-       
-  TLorentzVector * Momentum() const                { return fMomentum ; }
-  virtual void     SetMomentum(TLorentzVector *lv) { fMomentum = lv ; }
-  
-  Bool_t IsPIDOK(const Int_t ipid, const Int_t pdgwanted) const;
-  
- private:
-  TLorentzVector* fMomentum;  // Photon 4-momentum vector
-  Int_t      fPdg ;          // id of particle
-  Int_t      fTag ;          // tag of particle (decay, fragment, prompt photon), MC
-  Int_t      fBtag;          // tag particle from B.
-  Int_t      fLabel ;        // MC label
-  Int_t      fCaloLabel[2];  // CaloCluster index, 1 for photons, 2 for pi0.
-  Int_t      fTrackLabel[2]; // Track lable, 1 for pions, 2 for conversion photons 
-  TString    fDetector ;     // Detector where particle was measured.
-  Bool_t     fDisp ;         // Dispersion bit
-  Bool_t     fTof ;          // TOF bit
-  Bool_t     fCharged ;      // Charged bit
-  Int_t      fBadDist ;      // Distance to bad module in module units
-  Int_t      fInputFileIndex;// 0, standard input, 1 first input added. 
-                                // Only possible one for now, more in future?
-       
-  ClassDef(AliAODPWG4Particle,2);
-};
-
-inline Double_t AliAODPWG4Particle::Phi() const
-{
-  // Return phi
-  Double_t phi = fMomentum->Phi();
-  if (phi < 0.) phi += 2. * TMath::Pi();
-  return phi;
-}
-
-#endif //ALIAODPWG4PARTICLE_H
+#ifndef ALIAODPWG4PARTICLE_H\r
+#define ALIAODPWG4PARTICLE_H\r
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *\r
+ * See cxx source for full Copyright notice                               */\r
+\r
+/* $Id: AliAODPWG4Particle.h  $ */\r
+\r
+//-------------------------------------------------------------------------\r
+//     Copy of AOD photon class, adapted for particle identification\r
+//     and correlations analysis\r
+//     Author: Yves Schutz, CERN, Gustavo Conesa, INFN\r
+//-------------------------------------------------------------------------\r
+\r
+//-- ROOT system --\r
+#include <TLorentzVector.h>\r
+class TString;\r
+\r
+//-- Analysis system\r
+#include "AliVParticle.h"\r
+\r
+class AliAODPWG4Particle : public AliVParticle {\r
+  \r
+ public:\r
+  AliAODPWG4Particle();\r
+  AliAODPWG4Particle(Double_t px, Double_t py, Double_t pz, Double_t e);\r
+  AliAODPWG4Particle(TLorentzVector & p);  \r
+  virtual ~AliAODPWG4Particle();\r
+  AliAODPWG4Particle(const AliAODPWG4Particle& photon); \r
+  AliAODPWG4Particle& operator=(const AliAODPWG4Particle& photon);\r
+\r
+  //enumerated type for various b-tags of electrons\r
+  enum btagTypes {kDVMTag0, kDVMTag1, kDVMTag2, kTransverseIPTag, kUnknownTag};\r
+\r
+  void SetBTagBit(Int_t &tag, const UInt_t set) const {\r
+    // Set bit of type set (btagTypes) in tag                                             \r
+    tag |= (1<<set) ;\r
+  }\r
+\r
+  Bool_t CheckBTagBit(const Int_t tag, const UInt_t test) const {\r
+    // Check if in fBtag the bit test (btagTypes) is set.                                   \r
+    if (tag & (1<<test) ) return  kTRUE ;\r
+    else return kFALSE ;\r
+  }\r
+\r
+  // AliVParticle methods\r
+  virtual Double_t Px()         const { return fMomentum->Px();      }\r
+  virtual Double_t Py()         const { return fMomentum->Py();      }\r
+  virtual Double_t Pz()         const { return fMomentum->Pz();      }\r
+  virtual Double_t Pt()         const { return fMomentum->Pt();      }\r
+  virtual Double_t P()          const { return fMomentum->P();       }\r
+  virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }\r
+  virtual Double_t OneOverPt()  const { return 1. / fMomentum->Pt(); }\r
+  virtual Double_t Phi()        const;\r
+  virtual Double_t Theta()      const { return fMomentum->Theta();   }\r
+  virtual Double_t E()          const { return fMomentum->E();       }\r
+  virtual Double_t M()          const { return fMomentum->M();       }\r
+  virtual Double_t Eta()        const { return fMomentum->Eta();     }\r
+  virtual Double_t Y()          const { return fMomentum->Rapidity();}\r
+  virtual Double_t Xv()         const {return -999.;} // put reasonable values here\r
+  virtual Double_t Yv()         const {return -999.;} //\r
+  virtual Double_t Zv()         const {return -999.;} //\r
+  virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }  \r
+  virtual void     Print(Option_t* /*option*/) const;\r
+  \r
+  //\r
+  //Dummy\r
+  virtual Short_t Charge()      const { return 0;}\r
+  virtual const Double_t* PID() const { return NULL;}\r
+  //\r
+  \r
+  virtual Int_t   GetPdg()               const {return fPdg ; }\r
+  virtual Int_t   GetTag()               const {return fTag ; }\r
+  virtual Int_t   GetBtag()              const {return fBtag ; }\r
+  virtual Int_t   GetLabel()             const {return fLabel ; }\r
+  virtual Int_t   GetCaloLabel (Int_t i) const {return fCaloLabel[i] ; }\r
+  virtual Int_t   GetTrackLabel(Int_t i) const {return fTrackLabel[i] ; }\r
+  virtual TString GetDetector()          const {return fDetector ; }\r
+  virtual Bool_t  GetDispBit(void)       const {return fDisp ; }\r
+  virtual Bool_t  GetTOFBit(void)        const {return fTof ; }\r
+  virtual Bool_t  GetChargedBit(void)    const {return fCharged ; }\r
+  virtual Int_t   DistToBad()            const {return fBadDist ; } \r
+  virtual Int_t   GetInputFileIndex()    const {return fInputFileIndex ; }\r
\r
+  virtual void SetLabel(Int_t l)         { fLabel = l ; }\r
+  virtual void SetCaloLabel (Int_t a, Int_t b) { fCaloLabel [0] = a; fCaloLabel [1] = b  ; }\r
+  virtual void SetTrackLabel(Int_t a, Int_t b) { fTrackLabel[0] = a; fTrackLabel[1] = b  ; }\r
+  \r
+  virtual void SetPdg(Int_t pdg)         { fPdg = pdg ; }\r
+  virtual void SetTag(Int_t tag)         { fTag = tag ; }\r
+  virtual void SetBtag(Int_t tag)        { fBtag = tag ; }\r
+  virtual void SetDetector(TString d)    { fDetector = d ; }\r
+  virtual void SetDispBit(Bool_t disp)   { fDisp = disp ; } \r
+  virtual void SetTOFBit(Bool_t tof)     { fTof = tof ;} \r
+  virtual void SetChargedBit(Bool_t ch)  { fCharged = ch ; }\r
+  virtual void SetDistToBad(Int_t dist)  { fBadDist=dist ;} \r
+  virtual void SetInputFileIndex(Int_t i){ fInputFileIndex = i;}\r
+       \r
+  TLorentzVector * Momentum() const                { return fMomentum ; }\r
+  virtual void     SetMomentum(TLorentzVector *lv) { fMomentum = lv ; }\r
+  \r
+  Bool_t IsPIDOK(const Int_t ipid, const Int_t pdgwanted) const;\r
+  \r
+ private:\r
+  TLorentzVector* fMomentum;  // Photon 4-momentum vector\r
+  Int_t      fPdg ;          // id of particle\r
+  Int_t      fTag ;          // tag of particle (decay, fragment, prompt photon), MC\r
+  Int_t      fBtag;          // tag particle from B.\r
+  Int_t      fLabel ;        // MC label\r
+  Int_t      fCaloLabel[2];  // CaloCluster index, 1 for photons, 2 for pi0.\r
+  Int_t      fTrackLabel[2]; // Track lable, 1 for pions, 2 for conversion photons \r
+  TString    fDetector ;     // Detector where particle was measured.\r
+  Bool_t     fDisp ;         // Dispersion bit\r
+  Bool_t     fTof ;          // TOF bit\r
+  Bool_t     fCharged ;      // Charged bit\r
+  Int_t      fBadDist ;      // Distance to bad module in module units\r
+  Int_t      fInputFileIndex;// 0, standard input, 1 first input added. \r
+                                // Only possible one for now, more in future?\r
+       \r
+  ClassDef(AliAODPWG4Particle,2);\r
+};\r
+\r
+inline Double_t AliAODPWG4Particle::Phi() const\r
+{\r
+  // Return phi\r
+  Double_t phi = fMomentum->Phi();\r
+  if (phi < 0.) phi += 2. * TMath::Pi();\r
+  return phi;\r
+}\r
+\r
+#endif //ALIAODPWG4PARTICLE_H\r
index b5ca134..be59317 100755 (executable)
@@ -36,6 +36,8 @@
 #include "AliAODTrack.h"
 #include "AliESDtrack.h"
 #include "AliFidutialCut.h"
+#include "AliAODInputHandler.h"
+#include "AliAnalysisManager.h"
 
 ClassImp(AliCaloTrackAODReader)
 
@@ -290,18 +292,16 @@ void AliCaloTrackAODReader::FillInputPHOSCells() {
 void AliCaloTrackAODReader::GetVertex(Double_t  v[3]) const {
   //Return vertex position
 
-  v[0] = ((AliAODEvent*)fInputEvent)->GetVertex(0)->GetX() ;//CHECK!!!
-  v[1] = ((AliAODEvent*)fInputEvent)->GetVertex(0)->GetY() ;//CHECK!!!
-  v[2] = ((AliAODEvent*)fInputEvent)->GetVertex(0)->GetZ() ;//CHECK!!!
+ ((AliAODEvent*)fInputEvent)->GetPrimaryVertex()->GetXYZ(v);
+       
 }
 
 //____________________________________________________________________________
 void AliCaloTrackAODReader::GetSecondInputAODVertex(Double_t  v[3]) const {
        //Return vertex position of second AOD input
        
-       v[0] = ((AliAODEvent*)fSecondInputAODEvent)->GetVertex(0)->GetX() ;//CHECK!!!
-       v[1] = ((AliAODEvent*)fSecondInputAODEvent)->GetVertex(0)->GetY() ;//CHECK!!!
-       v[2] = ((AliAODEvent*)fSecondInputAODEvent)->GetVertex(0)->GetZ() ;//CHECK!!!
+       fSecondInputAODEvent->GetPrimaryVertex()->GetXYZ(v);
+
 }
 
 //____________________________________________________________________________
@@ -318,13 +318,24 @@ Double_t AliCaloTrackAODReader::GetBField() const {
 void AliCaloTrackAODReader::SetInputOutputMCEvent(AliVEvent* input, AliAODEvent* aod, AliMCEvent* mc) {
   // Connect the data pointers
   // If input is AOD, do analysis with input, if not, do analysis with the output aod.
+
   if(!strcmp(input->GetName(),"AliESDEvent"))   {
     SetInputEvent(aod);
     SetOutputEvent(aod);
   }
   else if(!strcmp(input->GetName(),"AliAODEvent")){
-    SetInputEvent(input);
-    SetOutputEvent(aod);
+         
+         AliAODInputHandler* aodIH = static_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
+         //printf("AODInputHandler %p, MergeEvents %d \n",aodIH, aodIH->GetMergeEvents());
+         if (aodIH && aodIH->GetMergeEvents()) {
+                 //Merged events, use output AOD.
+                 SetInputEvent(aod);
+                 SetOutputEvent(aod);
+         }
+         else{
+                 SetInputEvent(input);
+                 SetOutputEvent(aod);
+         }
   }
   else{ 
     printf("AliCaloTrackAODReader::SetInputOutputMCEvent() - STOP : Wrong data format: %s\n",input->GetName());
index f69f92b..134494d 100755 (executable)
@@ -367,8 +367,9 @@ void AliCaloTrackESDReader::FillInputPHOSCells() {
 void AliCaloTrackESDReader::GetVertex(Double_t  v[3]) const {
   //Return vertex position
   
-  ((AliESDEvent*)fInputEvent)->GetVertex()->GetXYZ(v) ;
-  
+  //((AliESDEvent*)fInputEvent)->GetVertex()->GetXYZ(v) ;//SPD
+  ((AliESDEvent*)fInputEvent)->GetPrimaryVertex()->GetXYZ(v);
+       
 }
 
 
index b6a5eaf..818ecbf 100755 (executable)
@@ -902,7 +902,7 @@ void  AliAnaCalorimeterQA::MakeAnalysisFillHistograms()
                Float_t eta = mom.Eta();
                Float_t phi = mom.Phi();
                if(phi < 0) phi +=TMath::TwoPi();
-               
+               if(GetDebug() > 0) printf("AliAnaCalorimeterQA::MakeAnalysisFillHistograms() - cluster %d: E %2.3f, pT %2.3f, eta %2.3f, phi %2.3f \n",iclus,e,pt,eta,phi*TMath::RadToDeg());
                fhE     ->Fill(e);              
                fhPt    ->Fill(pt);
                fhPhi   ->Fill(phi);
@@ -1242,13 +1242,10 @@ void  AliAnaCalorimeterQA::MakeAnalysisFillHistograms()
        fhNCells->Fill(ncells) ;
        
        for (Int_t iCell = 0; iCell < ncells; iCell++) {      
-               if(GetDebug() > 10)  printf("AliAnaCalorimeterQA::MakeAnalysisFillHistograms() - Cell : amp %f, absId %d \n", cell->GetAmplitude(iCell), cell->GetCellNumber(iCell));
+               if(GetDebug() > 0)  printf("AliAnaCalorimeterQA::MakeAnalysisFillHistograms() - Cell : amp %f, absId %d \n", cell->GetAmplitude(iCell), cell->GetCellNumber(iCell));
                fhAmplitude->Fill(cell->GetAmplitude(iCell));
        }
        
-       if(GetDebug() > 0) 
-               printf("AliAnaCalorimeterQA::MakeAnalysisFillHistograms() - end \n");  
-       
        //Monte Carlo
        if(IsDataMC()){
                //Play with the MC stack if available
@@ -1505,6 +1502,40 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        char name[128];
        char cname[128];
                
+       //CaloCells
+       //printf("c9\n");
+       sprintf(cname,"QA_%s_nclustercellsamp",fCalorimeter.Data());
+       TCanvas  * c9 = new TCanvas(cname, " CaloClusters and CaloCells", 400, 400) ;
+       c9->Divide(2, 2);
+       
+       c9->cd(1) ; 
+       if(fhNClusters->GetEntries() > 0) gPad->SetLogy();
+       gPad->SetLogx();
+       fhNClusters->SetLineColor(4);
+       fhNClusters->Draw();
+       
+       c9->cd(2) ; 
+       if(fhNCells->GetEntries() > 0) gPad->SetLogy();
+       gPad->SetLogx();
+       fhNCells->SetLineColor(4);
+       fhNCells->Draw();
+       
+       c9->cd(3) ; 
+       if(fhNCellsPerCluster->GetEntries() > 0) gPad->SetLogy();
+       gPad->SetLogx();
+       fhNCellsPerCluster->SetLineColor(4);
+       fhNCellsPerCluster->Draw();
+       
+       c9->cd(4) ; 
+       if(fhAmplitude->GetEntries() > 0) gPad->SetLogy();
+       //gPad->SetLogx();
+       fhAmplitude->SetLineColor(4);
+       fhAmplitude->Draw();
+       
+       sprintf(name,"QA_%s_CaloClustersAndCaloCells.eps",fCalorimeter.Data());
+       c9->Print(name); printf("Plot: %s\n",name);
+       
+       
        //Reconstructed distributions
        //printf("c1\n");
        sprintf(cname,"QA_%s_rec",fCalorimeter.Data());
@@ -1512,12 +1543,12 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        c->Divide(2, 2);
        
        c->cd(1) ; 
-       gPad->SetLogy();
+       if(fhE->GetEntries() > 0) gPad->SetLogy();
        fhE->SetLineColor(4);
        fhE->Draw();
        
        c->cd(2) ; 
-       gPad->SetLogy();
+       if(fhPt->GetEntries() > 0) gPad->SetLogy();
        fhPt->SetLineColor(4);
        fhPt->Draw();
        
@@ -1530,7 +1561,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fhEta->Draw();
        
        sprintf(name,"QA_%s_ReconstructedDistributions.eps",fCalorimeter.Data());
-       c->Print(name);
+       c->Print(name); printf("Plot: %s\n",name);
        
        //Reconstructed distributions, matched with tracks
        //printf("c2\n");
@@ -1539,12 +1570,12 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        c2->Divide(2, 2);
        
        c2->cd(1) ; 
-       gPad->SetLogy();
+       if(fhECharged->GetEntries() > 0) gPad->SetLogy();
        fhECharged->SetLineColor(4);
        fhECharged->Draw();
        
        c2->cd(2) ; 
-       gPad->SetLogy();
+       if(fhPtCharged->GetEntries() > 0) gPad->SetLogy();
        fhPtCharged->SetLineColor(4);
        fhPtCharged->Draw();
        
@@ -1557,7 +1588,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fhEtaCharged->Draw();
        
        sprintf(name,"QA_%s_ReconstructedDistributions_TrackMatched.eps",fCalorimeter.Data());
-       c2->Print(name);
+       c2->Print(name); printf("Plot: %s\n",name);
        
        TH1F *  hEChargedClone   = (TH1F*)   fhECharged->Clone("EChargedClone");
        TH1F *  hPtChargedClone  = (TH1F*)   fhPtCharged->Clone("PtChargedClone");
@@ -1576,7 +1607,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        c3->Divide(2, 2);
        
        c3->cd(1) ;
-       gPad->SetLogy();
+       if(hEChargedClone->GetEntries() > 0) gPad->SetLogy();
        hEChargedClone->SetTitleOffset(1.6,"Y");
     hEChargedClone->SetYTitle("track matched / all   ");
        hEChargedClone->SetXTitle("E (GeV)");
@@ -1584,7 +1615,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hEChargedClone->Draw();
        
        c3->cd(2) ; 
-       gPad->SetLogy();
+       if(hPtChargedClone->GetEntries() > 0) gPad->SetLogy();
        hPtChargedClone->SetTitleOffset(1.6,"Y");
        hPtChargedClone->SetYTitle("track matched / all   ");
     hPtChargedClone->SetXTitle("p_{T} (GeV/c)");
@@ -1592,7 +1623,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hPtChargedClone->Draw();
        
        c3->cd(3) ;
-       gPad->SetLogy();
+       if(hPhiChargedClone->GetEntries() > 0) gPad->SetLogy();
        hPhiChargedClone->SetTitleOffset(1.6,"Y");
        hPhiChargedClone->SetYTitle("track matched / all   ");
        hPhiChargedClone->SetXTitle("#phi (rad)");
@@ -1600,7 +1631,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hPhiChargedClone->Draw();
        
        c3->cd(4) ; 
-       gPad->SetLogy();
+       if(hEtaChargedClone->GetEntries() > 0) gPad->SetLogy();
        hEtaChargedClone->SetTitleOffset(1.6,"Y");
        hEtaChargedClone->SetYTitle("track matched / all   ");
        hEtaChargedClone->SetXTitle("#eta");
@@ -1608,7 +1639,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hEtaChargedClone->Draw();
        
        sprintf(name,"QA_%s_RatioReconstructedMatchedDistributions.eps",fCalorimeter.Data());
-       c3->Print(name);
+       c3->Print(name); printf("Plot: %s\n",name);
        
        //Ratio: reconstructed track matched (minus no track param) / all
        //printf("c3\n");
@@ -1645,7 +1676,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hEtaChargedClone2->Draw();
        
        sprintf(name,"QA_%s_RatioReconstructedMatchedDistributionsOuter.eps",fCalorimeter.Data());
-       c333->Print(name);
+       c333->Print(name); printf("Plot: %s\n",name);
        
        //Reconstructed distributions, matched with tracks but no outer param
        //printf("c2\n");
@@ -1654,12 +1685,12 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        c22->Divide(2, 2);
        
        c22->cd(1) ; 
-       gPad->SetLogy();
+       if(fhEChargedNoOut->GetEntries() > 0) gPad->SetLogy();
        fhEChargedNoOut->SetLineColor(4);
        fhEChargedNoOut->Draw();
        
        c22->cd(2) ; 
-       gPad->SetLogy();
+       if(fhEChargedNoOut->GetEntries() > 0) gPad->SetLogy();
        fhPtChargedNoOut->SetLineColor(4);
        fhPtChargedNoOut->Draw();
        
@@ -1672,7 +1703,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fhEtaChargedNoOut->Draw();
        
        sprintf(name,"QA_%s_ReconstructedDistributions_TrackMatched_NoOutParam.eps",fCalorimeter.Data());
-       c22->Print(name);
+       c22->Print(name); printf("Plot: %s\n",name);
        
        //Ratio: reconstructed track matched/ all reconstructed
        //printf("c3\n");
@@ -1711,7 +1742,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
 //     hEtaChargedNoOutClone->Draw();
 //     
 //     sprintf(name,"QA_%s_RatioMatchedDistributionsAllToNoOut.eps",fCalorimeter.Data());
-//     c33->Print(name);
+//     c33->Print(name); printf("Plot: %s\n",name);
        
        
        //eta vs phi
@@ -1733,7 +1764,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        //      fhEtaPhiChargedNoOut->Draw("cont");
        
        sprintf(name,"QA_%s_ReconstructedEtaVsPhi.eps",fCalorimeter.Data());
-       c4->Print(name);
+       c4->Print(name); printf("Plot: %s\n",name);
        
        //Invariant mass
        Int_t binmin = -1;
@@ -1780,7 +1811,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                pyim10->Draw();
                
                sprintf(name,"QA_%s_InvariantMass.eps",fCalorimeter.Data());
-               c5->Print(name);
+               c5->Print(name); printf("Plot: %s\n",name);
        }
        
        //Asymmetry
@@ -1826,10 +1857,10 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                pyAsym10->Draw();
                
                sprintf(name,"QA_%s_Asymmetry.eps",fCalorimeter.Data());
-               c5b->Print(name);
+               c5b->Print(name); printf("Plot: %s\n",name);
        }
        
-       
+       if(IsDataMC()){
        //Reconstructed vs MC distributions
        //printf("c6\n");
        sprintf(cname,"QA_%s_recvsmc",fCalorimeter.Data());
@@ -1857,7 +1888,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fh2Eta->Draw();
        
        sprintf(name,"QA_%s_ReconstructedVSMCDistributions.eps",fCalorimeter.Data());
-       c6->Print(name);        
+       c6->Print(name); printf("Plot: %s\n",name);     
        
        //Reconstructed vs MC distributions
        //printf("c6\n");
@@ -1878,7 +1909,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fhGamEta->Draw();
        
        sprintf(name,"QA_%s_GammaReconstructedVSMCDistributions.eps",fCalorimeter.Data());
-       c6->Print(name);        
+       c6->Print(name); printf("Plot: %s\n",name);     
        
        //Generated - reconstructed  
        //printf("c7\n");
@@ -1887,7 +1918,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        c7->Divide(2, 2);
        
        c7->cd(1) ; 
-       gPad->SetLogy();
+       if(fhDeltaE->GetEntries() > 0) gPad->SetLogy();
        fhGamDeltaE->SetLineColor(4);
        fhDeltaE->Draw();
        fhGamDeltaE->Draw("same");
@@ -1901,7 +1932,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        pLegendd.Draw();
        
        c7->cd(2) ; 
-       gPad->SetLogy();
+       if(fhDeltaPt->GetEntries() > 0) gPad->SetLogy();
        fhGamDeltaPt->SetLineColor(4);
        fhDeltaPt->Draw();
        fhGamDeltaPt->Draw("same");
@@ -1917,7 +1948,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fhGamDeltaEta->Draw("same");
        
        sprintf(name,"QA_%s_DiffGeneratedReconstructed.eps",fCalorimeter.Data());
-       c7->Print(name);
+       c7->Print(name); printf("Plot: %s\n",name);
        
        // Reconstructed / Generated 
        //printf("c8\n");
@@ -1926,7 +1957,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        c8->Divide(2, 2);
        
        c8->cd(1) ; 
-       gPad->SetLogy();
+       if(fhRatioE->GetEntries() > 0) gPad->SetLogy();
        fhGamRatioE->SetLineColor(4);
        fhRatioE->Draw();
        fhGamRatioE->Draw("same");
@@ -1940,7 +1971,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        pLegendr.Draw();
        
        c8->cd(2) ; 
-       gPad->SetLogy();
+       if(fhRatioPt->GetEntries() > 0) gPad->SetLogy();
        fhGamRatioPt->SetLineColor(4);
        fhRatioPt->Draw();
        fhGamRatioPt->Draw("same");
@@ -1956,42 +1987,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fhGamRatioEta->Draw("same");
        
        sprintf(name,"QA_%s_ReconstructedDivGenerated.eps",fCalorimeter.Data());
-       c8->Print(name);
-       
-       
-       // CaloClusters CaloCells
-       //printf("c9\n");
-       sprintf(cname,"QA_%s_nclustercellsamp",fCalorimeter.Data());
-       TCanvas  * c9 = new TCanvas(cname, " CaloClusters and CaloCells", 400, 400) ;
-       c9->Divide(2, 2);
-       
-       c9->cd(1) ; 
-       gPad->SetLogy();
-       gPad->SetLogx();
-       fhNClusters->SetLineColor(4);
-       fhNClusters->Draw();
-       
-       c9->cd(2) ; 
-       gPad->SetLogy();
-       gPad->SetLogx();
-       fhNCells->SetLineColor(4);
-       fhNCells->Draw();
-       
-       c9->cd(3) ; 
-       gPad->SetLogy();
-       gPad->SetLogx();
-       fhNCellsPerCluster->SetLineColor(4);
-       fhNCellsPerCluster->Draw();
-       
-       c9->cd(4) ; 
-       gPad->SetLogy();
-       //gPad->SetLogx();
-       fhAmplitude->SetLineColor(4);
-       fhAmplitude->Draw();
-       
-       sprintf(name,"QA_%s_CaloClustersAndCaloCells.eps",fCalorimeter.Data());
-       c9->Print(name);
-       
+       c8->Print(name); printf("Plot: %s\n",name);
        
        //MC
        
@@ -2114,7 +2110,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        fhGenElePhi->Draw("same");
        
        sprintf(name,"QA_%s_GeneratedDistributions.eps",fCalorimeter.Data());
-       c10->Print(name);
+       c10->Print(name); printf("Plot: %s\n",name);
        
        
        //Reconstructed clusters depending on its original particle.
@@ -2299,7 +2295,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hElePhi->Draw("same");
        
        sprintf(name,"QA_%s_RecDistributionsGenID.eps",fCalorimeter.Data());
-       c11->Print(name);
+       c11->Print(name); printf("Plot: %s\n",name);
        
        
        //Ratio reconstructed clusters / generated particles in acceptance, for different particle ID
@@ -2381,7 +2377,8 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hGamPhiClone->Draw("same");
        
        sprintf(name,"QA_%s_EfficiencyGenID.eps",fCalorimeter.Data());
-       c12->Print(name);
+       c12->Print(name); printf("Plot: %s\n",name);
+       
        
        
        //Reconstructed distributions
@@ -2414,12 +2411,11 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        
        
        sprintf(name,"QA_%s_ParticleVertex.eps",fCalorimeter.Data());
-       c13->Print(name);
+       c13->Print(name); printf("Plot: %s\n",name);
        
        
        //Track-matching distributions
-       
-       
+
        //Reconstructed distributions, matched with tracks, generated particle dependence
        //printf("c2\n");
        sprintf(cname,"QA_%s_rectrackmatchGenID",fCalorimeter.Data());
@@ -2527,7 +2523,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        
        
        sprintf(name,"QA_%s_ReconstructedDistributions_TrackMatchedGenID.eps",fCalorimeter.Data());
-       c22ch->Print(name);
+       c22ch->Print(name); printf("Plot: %s\n",name);
        
        TH1F *  hGamEChargedClone   = (TH1F*)   hGamECharged->Clone("GamEChargedClone");
        TH1F *  hGamPtChargedClone  = (TH1F*)   hGamPtCharged->Clone("GamPtChargedClone");
@@ -2641,9 +2637,9 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
        hChHadPhiChargedClone->Draw("same");
        
        sprintf(name,"QA_%s_RatioReconstructedMatchedDistributionsGenID.eps",fCalorimeter.Data());
-       c3ch->Print(name);
-       
+       c3ch->Print(name); printf("Plot: %s\n",name);
        
+       }       
        //Track-matching distributions
        if(!strcmp(GetReader()->GetInputEvent()->GetName(),"AliESDEvent")){
                
@@ -2661,7 +2657,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                //pLegendpE0.Draw();
                
                cme->cd(1);
-               gPad->SetLogy();
+               if(fh1pOverE->GetEntries() > 0) gPad->SetLogy();
                fh1pOverE->SetTitle("Track matches p/E");
                fh1pOverE->Draw();
                fh1pOverER02->SetLineColor(4);
@@ -2669,7 +2665,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                pLegendpE0.Draw();
                
                cme->cd(2);
-               gPad->SetLogy();
+               if(fh1dR->GetEntries() > 0) gPad->SetLogy();
                fh1dR->Draw();
                
                cme->cd(3);
@@ -2679,9 +2675,9 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                fh2EledEdx->Draw();
                
                sprintf(name,"QA_%s_TrackMatchingEleDist.eps",fCalorimeter.Data());
-               cme->Print(name);       
-               
+               cme->Print(name); printf("Plot: %s\n",name);       
                
+               if(IsDataMC()){
                sprintf(cname,"QA_%s_trkmatchMCEle",fCalorimeter.Data());
                TCanvas *cmemc = new TCanvas(cname,"Track-matching distributions from MC electrons", 600, 200);
                cmemc->Divide(3,1);
@@ -2702,7 +2698,8 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                fhMCEle2MatchdEdx->Draw();
                
                sprintf(name,"QA_%s_TrackMatchingDistMCEle.eps",fCalorimeter.Data());
-               cmemc->Print(name);  
+               cmemc->Print(name); printf("Plot: %s\n",name);  
+       
                
                sprintf(cname,"QA_%s_trkmatchMCChHad",fCalorimeter.Data());
                TCanvas *cmemchad = new TCanvas(cname,"Track-matching distributions from MC charged hadrons", 600, 200);
@@ -2724,7 +2721,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                fhMCChHad2MatchdEdx->Draw();
                
                sprintf(name,"QA_%s_TrackMatchingDistMCChHad.eps",fCalorimeter.Data());
-               cmemchad->Print(name);       
+               cmemchad->Print(name); printf("Plot: %s\n",name);       
                
                sprintf(cname,"QA_%s_trkmatchMCNeutral",fCalorimeter.Data());
                TCanvas *cmemcn = new TCanvas(cname,"Track-matching distributions from MC neutrals", 600, 200);
@@ -2746,7 +2743,7 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                fhMCNeutral2MatchdEdx->Draw();
                
                sprintf(name,"QA_%s_TrackMatchingDistMCNeutral.eps",fCalorimeter.Data());
-               cmemcn->Print(name);       
+               cmemcn->Print(name); printf("Plot: %s\n",name);       
                
                sprintf(cname,"QA_%s_trkmatchpE",fCalorimeter.Data());
                TCanvas *cmpoe = new TCanvas(cname,"Track-matching distributions, p/E", 400, 200);
@@ -2795,8 +2792,8 @@ void  AliAnaCalorimeterQA::Terminate(TList* outputList)
                //              pLegendpE2.Draw();
                
                sprintf(name,"QA_%s_TrackMatchingPOverE.eps",fCalorimeter.Data());
-               cmpoe->Print(name);                             
-               
+               cmpoe->Print(name); printf("Plot: %s\n",name);                          
+               }
                
        }
        
index b6ae24e..f054ee3 100755 (executable)
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes hereby granted      *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
-/* $Id: $ */
-
-//_________________________________________________________________________
-//
-// Class for the electron identification.
-// Clusters from EMCAL matched to tracks
-// and kept in the AOD. Few histograms produced.
-//
-// -- Author: J.L. Klay (Cal Poly), M. Heinz (Yale)
-//////////////////////////////////////////////////////////////////////////////
-  
-// --- ROOT system --- 
-#include <TH2F.h>
-#include <TParticle.h>
-#include <TNtuple.h>
-#include <TClonesArray.h>
-#include <TObjString.h>
-//#include <Riostream.h>
-
-// --- Analysis system --- 
-#include "AliAnaElectron.h" 
-#include "AliCaloTrackReader.h"
-#include "AliMCAnalysisUtils.h"
-#include "AliAODCaloCluster.h"
-#include "AliFidutialCut.h"
-#include "AliAODTrack.h"
-#include "AliAODPid.h"
-#include "AliCaloPID.h"
-#include "AliAODMCParticle.h"
-#include "AliStack.h"
-#include "AliExternalTrackParam.h"
-#include "AliESDv0.h"
-
-ClassImp(AliAnaElectron)
-  
-//____________________________________________________________________________
-AliAnaElectron::AliAnaElectron() 
-: AliAnaPartCorrBaseClass(),fCalorimeter(""),
-  fpOverEmin(0.),fpOverEmax(0.),fResidualCut(0.),
-  fDrCut(0.),fPairDcaCut(0.),fDecayLenCut(0.),fImpactCut(0.),
-  fAssocPtCut(0.),fMassCut(0.),fSdcaCut(0.),fITSCut(0),
-  fWriteNtuple(kFALSE),
-  //matching checks
-  fEleNtuple(0),
-  fh1pOverE(0),fh1dR(0),fh2EledEdx(0),fh2MatchdEdx(0),fh2dEtadPhi(0),
-  fh2dEtadPhiMatched(0),fh2dEtadPhiUnmatched(0),
-  fh2TrackPVsClusterE(0),fh2TrackPtVsClusterE(0),fh2TrackPhiVsClusterPhi(0),fh2TrackEtaVsClusterEta(0),
-  //Photonic electron checks
-  fh1OpeningAngle(0),fh1MinvPhoton(0),
-  //reco
-  fhPtElectron(0),fhPhiElectron(0),fhEtaElectron(0),
-  fhPtNPE(0),fhPhiNPE(0),fhEtaNPE(0),
-  fhPtPE(0),fhPhiPE(0),fhEtaPE(0),
-  fhPtConversion(0),fhPhiConversion(0),fhEtaConversion(0),
-  fhPtBottom(0),fhPhiBottom(0),fhEtaBottom(0),
-  fhPtCharm(0),fhPhiCharm(0),fhEtaCharm(0),
-  fhPtCFromB(0),fhPhiCFromB(0),fhEtaCFromB(0),
-  fhPtDalitz(0),fhPhiDalitz(0),fhEtaDalitz(0),
-  fhPtWDecay(0),fhPhiWDecay(0),fhEtaWDecay(0),
-  fhPtZDecay(0),fhPhiZDecay(0),fhEtaZDecay(0),
-  fhPtPrompt(0),fhPhiPrompt(0),fhEtaPrompt(0),
-  fhPtUnknown(0),fhPhiUnknown(0),fhEtaUnknown(0),
-  fhPtHadron(0),fhPtEleTrkDet(0),
-  //B-tagging
-  fhBtagCut1(0),fhBtagCut2(0),fhBtagCut3(0),fhBtagQA1(0),fhBtagQA2(0),
-  //MC
-  fMCEleNtuple(0),fhPtMCHadron(0)
-{
-  //default ctor
-  
-  //Initialize parameters
-  InitParameters();
-
-}
-
-//____________________________________________________________________________
-AliAnaElectron::AliAnaElectron(const AliAnaElectron & g) 
-  : AliAnaPartCorrBaseClass(g),fCalorimeter(g.fCalorimeter),
-   fpOverEmin(g.fpOverEmin),fpOverEmax(g.fpOverEmax),fResidualCut(g.fResidualCut),
-   fDrCut(g.fDrCut),fPairDcaCut(g.fPairDcaCut),fDecayLenCut(g.fDecayLenCut),fImpactCut(g.fImpactCut),
-  fAssocPtCut(g.fAssocPtCut),fMassCut(g.fMassCut),fSdcaCut(g.fSdcaCut),fITSCut(g.fITSCut),
-   fWriteNtuple(g.fWriteNtuple),
-   //matching checks
-   fEleNtuple(g.fEleNtuple),
-   fh1pOverE(g.fh1pOverE),fh1dR(g.fh1dR),
-   fh2EledEdx(g.fh2EledEdx),fh2MatchdEdx(g.fh2MatchdEdx),fh2dEtadPhi(g.fh2dEtadPhi),
-   fh2dEtadPhiMatched(g.fh2dEtadPhiMatched),fh2dEtadPhiUnmatched(g.fh2dEtadPhiUnmatched),
-   fh2TrackPVsClusterE(g.fh2TrackPVsClusterE),fh2TrackPtVsClusterE(g.fh2TrackPtVsClusterE),
-   fh2TrackPhiVsClusterPhi(g.fh2TrackPhiVsClusterPhi),fh2TrackEtaVsClusterEta(g.fh2TrackEtaVsClusterEta),   
-   //Photonic electron checks
-   fh1OpeningAngle(g.fh1OpeningAngle),fh1MinvPhoton(g.fh1MinvPhoton),
-   //reco
-   fhPtElectron(g.fhPtElectron),fhPhiElectron(g.fhPhiElectron),fhEtaElectron(g.fhEtaElectron),
-   fhPtNPE(g.fhPtNPE),fhPhiNPE(g.fhPhiNPE),fhEtaNPE(g.fhEtaNPE),
-   fhPtPE(g.fhPtPE),fhPhiPE(g.fhPhiPE),fhEtaPE(g.fhEtaPE),
-   fhPtConversion(g.fhPtConversion),fhPhiConversion(g.fhPhiConversion),fhEtaConversion(g.fhEtaConversion),
-   fhPtBottom(g.fhPtBottom),fhPhiBottom(g.fhPhiBottom),fhEtaBottom(g.fhEtaBottom),
-   fhPtCharm(g.fhPtCharm),fhPhiCharm(g.fhPhiCharm),fhEtaCharm(g.fhEtaCharm),
-   fhPtCFromB(g.fhPtCFromB),fhPhiCFromB(g.fhPhiCFromB),fhEtaCFromB(g.fhEtaCFromB),
-   fhPtDalitz(g.fhPtDalitz),fhPhiDalitz(g.fhPhiDalitz),fhEtaDalitz(g.fhEtaDalitz),
-   fhPtWDecay(g.fhPtWDecay),fhPhiWDecay(g.fhPhiWDecay),fhEtaWDecay(g.fhEtaWDecay),
-   fhPtZDecay(g.fhPtZDecay),fhPhiZDecay(g.fhPhiZDecay),fhEtaZDecay(g.fhEtaZDecay),
-   fhPtPrompt(g.fhPtPrompt),fhPhiPrompt(g.fhPhiPrompt),fhEtaPrompt(g.fhEtaPrompt),
-   fhPtUnknown(g.fhPtUnknown),fhPhiUnknown(g.fhPhiUnknown),fhEtaUnknown(g.fhEtaUnknown),
-   fhPtHadron(g.fhPtHadron),fhPtEleTrkDet(g.fhPtEleTrkDet),
-   //B-tagging
-   fhBtagCut1(g.fhBtagCut1),fhBtagCut2(g.fhBtagCut2),fhBtagCut3(g.fhBtagCut3),
-   fhBtagQA1(g.fhBtagQA1),fhBtagQA2(g.fhBtagQA2),
-   //MC
-    fMCEleNtuple(g.fMCEleNtuple),fhPtMCHadron(g.fhPtMCHadron)
-{
-  // cpy ctor
-  
-}
-
-//_________________________________________________________________________
-AliAnaElectron & AliAnaElectron::operator = (const AliAnaElectron & g)
-{
-  // assignment operator
-  
-  if(&g == this) return *this;
-  fCalorimeter = g.fCalorimeter;
-  fpOverEmin = g.fpOverEmin;
-  fpOverEmax = g.fpOverEmax;
-  fResidualCut = g.fResidualCut;
-  fDrCut = g.fDrCut;
-  fPairDcaCut = g.fPairDcaCut;
-  fDecayLenCut = g.fDecayLenCut;
-  fImpactCut = g.fImpactCut;
-  fAssocPtCut = g.fAssocPtCut;
-  fMassCut = g.fMassCut;
-  fSdcaCut = g.fSdcaCut;
-  fITSCut = g.fITSCut;
-  fWriteNtuple = g.fWriteNtuple;
-  fEleNtuple = g.fEleNtuple;
-  fh1pOverE = g.fh1pOverE;
-  fh1dR = g.fh1dR;
-  fh2EledEdx = g.fh2EledEdx;
-  fh2MatchdEdx = g.fh2MatchdEdx;
-  fh2dEtadPhi = g.fh2dEtadPhi;
-  fh2dEtadPhiMatched = g.fh2dEtadPhiMatched;
-  fh2dEtadPhiUnmatched = g.fh2dEtadPhiUnmatched;
-  fh2TrackPVsClusterE = g.fh2TrackPVsClusterE;
-  fh2TrackPtVsClusterE = g.fh2TrackPtVsClusterE;
-  fh2TrackPhiVsClusterPhi = g.fh2TrackPhiVsClusterPhi;
-  fh2TrackEtaVsClusterEta = g.fh2TrackEtaVsClusterEta;   
-  fh1OpeningAngle = g.fh1OpeningAngle;
-  fh1MinvPhoton = g.fh1MinvPhoton;
-  fhPtElectron = g.fhPtElectron;
-  fhPhiElectron = g.fhPhiElectron;
-  fhEtaElectron = g.fhEtaElectron;
-  fhPtNPE = g.fhPtNPE;
-  fhPhiNPE = g.fhPhiNPE;
-  fhEtaNPE = g.fhEtaNPE;
-  fhPtPE = g.fhPtPE;
-  fhPhiPE = g.fhPhiPE;
-  fhEtaPE = g.fhEtaPE;
-  fhPtConversion = g.fhPtConversion;
-  fhPhiConversion = g.fhPhiConversion;
-  fhEtaConversion = g.fhEtaConversion;
-  fhPtBottom = g.fhPtBottom;
-  fhPhiBottom = g.fhPhiBottom;
-  fhEtaBottom = g.fhEtaBottom;
-  fhPtCharm = g.fhPtCharm;
-  fhPhiCharm = g.fhPhiCharm;
-  fhEtaCharm = g.fhEtaCharm;
-  fhPtCFromB = g.fhPtCFromB;
-  fhPhiCFromB = g.fhPhiCFromB;
-  fhEtaCFromB = g.fhEtaCFromB;
-  fhPtDalitz = g.fhPtDalitz;
-  fhPhiDalitz = g.fhPhiDalitz;
-  fhEtaDalitz = g.fhEtaDalitz;
-  fhPtWDecay = g.fhPtWDecay;
-  fhPhiWDecay = g.fhPhiWDecay;
-  fhEtaWDecay = g.fhEtaWDecay;
-  fhPtZDecay = g.fhPtZDecay;
-  fhPhiZDecay = g.fhPhiZDecay;
-  fhEtaZDecay = g.fhEtaZDecay;
-  fhPtPrompt = g.fhPtPrompt;
-  fhPhiPrompt = g.fhPhiPrompt;
-  fhEtaPrompt = g.fhEtaPrompt;
-  fhPtUnknown = g.fhPtUnknown;
-  fhPhiUnknown = g.fhPhiUnknown;
-  fhEtaUnknown = g.fhEtaUnknown;
-
-  fhPtHadron = g.fhPtHadron;
-  fhPtEleTrkDet = g.fhPtEleTrkDet;
-
-  //B-tagging
-  fhBtagCut1 = g.fhBtagCut1;
-  fhBtagCut2 = g.fhBtagCut2;
-  fhBtagCut3 = g.fhBtagCut3;
-  fhBtagQA1 = g.fhBtagQA1;
-  fhBtagQA2 = g.fhBtagQA2;
-
-  fMCEleNtuple = g.fMCEleNtuple;
-  fhPtMCHadron = g.fhPtMCHadron;
-
-  return *this;
-  
-}
-
-//____________________________________________________________________________
-AliAnaElectron::~AliAnaElectron() 
-{
-  //dtor
-
-}
-
-
-//________________________________________________________________________
-TList *  AliAnaElectron::GetCreateOutputObjects()
-{  
-  // Create histograms to be saved in output file and 
-  // store them in outputContainer
-  TList * outputContainer = new TList() ; 
-  outputContainer->SetName("ElectronHistos") ; 
-  
-  //created ele ntuple for further analysis
-  if(fWriteNtuple) {
-      fEleNtuple = new TNtuple("EleNtuple","Electron Ntuple","tmctag:cmctag:pt:phi:eta:p:E:deta:dphi:nCells:dEdx:pidProb:impXY:impZ");
-    outputContainer->Add(fEleNtuple) ;
-  }
-
-  Int_t nptbins  = GetHistoNPtBins();
-  Int_t nphibins = GetHistoNPhiBins();
-  Int_t netabins = GetHistoNEtaBins();
-  Float_t ptmax  = GetHistoPtMax();
-  Float_t phimax = GetHistoPhiMax();
-  Float_t etamax = GetHistoEtaMax();
-  Float_t ptmin  = GetHistoPtMin();
-  Float_t phimin = GetHistoPhiMin();
-  Float_t etamin = GetHistoEtaMin();   
-
-  fh1pOverE = new TH1F("h1pOverE","EMCAL-TRACK matches p/E",100,0.,10.);
-  fh1dR = new TH1F("h1dR","EMCAL-TRACK matches dR",300, 0.,TMath::Pi());
-  fh2EledEdx = new TH2F("h2EledEdx","dE/dx vs. p for electrons",200,0.,50.,200,0.,400.);
-  fh2MatchdEdx = new TH2F("h2MatchdEdx","dE/dx vs. p for all matches",200,0.,50.,200,0.,400.);
-  fh2dEtadPhi = new TH2F("h2dEtadPhi","#Delta#eta vs. #Delta#phi for all track-cluster pairs",200,0.,1.4,300,0.,TMath::Pi());
-  fh2dEtadPhiMatched = new TH2F("h2dEtadPhiMatched","#Delta#eta vs. #Delta#phi for matched track-cluster pairs",200,0.,1.4,300,0.,TMath::Pi());
-  fh2dEtadPhiUnmatched = new TH2F("h2dEtadPhiUnmatched","#Delta#eta vs. #Delta#phi for unmatched track-cluster pairs",200,0.,1.4,300,0.,TMath::Pi());
-
-  fh2TrackPVsClusterE = new TH2F("h2TrackPVsClusterE","h2TrackPVsClusterE",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
-  fh2TrackPtVsClusterE = new TH2F("h2TrackPtVsClusterE","h2TrackPtVsClusterE",nptbins,ptmin,ptmax,nptbins,ptmin,ptmax);
-  fh2TrackPhiVsClusterPhi = new TH2F("h2TrackPhiVsClusterPhi","h2TrackPhiVsClusterPhi",nphibins,phimin,phimax,nphibins,phimin,phimax);
-  fh2TrackEtaVsClusterEta = new TH2F("h2TrackEtaVsClusterEta","h2TrackEtaVsClusterEta",netabins,etamin,etamax,netabins,etamin,etamax);
-
-  outputContainer->Add(fh1pOverE) ; 
-  outputContainer->Add(fh1dR) ; 
-  outputContainer->Add(fh2EledEdx) ;
-  outputContainer->Add(fh2MatchdEdx) ;
-  outputContainer->Add(fh2dEtadPhi) ;
-  outputContainer->Add(fh2dEtadPhiMatched) ;
-  outputContainer->Add(fh2dEtadPhiUnmatched) ;
-  outputContainer->Add(fh2TrackPVsClusterE) ;
-  outputContainer->Add(fh2TrackPtVsClusterE) ;
-  outputContainer->Add(fh2TrackPhiVsClusterPhi) ;
-  outputContainer->Add(fh2TrackEtaVsClusterEta) ;
-  
-  //photonic electron checks
-  fh1OpeningAngle = new TH1F("hOpeningAngle","Opening angle between e+e- pairs",100,0.,TMath::Pi());
-  fh1MinvPhoton = new TH1F("hMinvPhoton","Invariant mass of e+e- pairs",200,0.,2.);
-
-  outputContainer->Add(fh1OpeningAngle);
-  outputContainer->Add(fh1MinvPhoton);
-
-  fhPtElectron = new TH1F("hPtElectron","Electron pT",nptbins,ptmin,ptmax);
-  fhPhiElectron = new TH2F("hPhiElectron","Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-  fhEtaElectron = new TH2F("hEtaElectron","Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-  fhPtNPE = new TH1F("hPtNPE","Non-photonic Electron pT",nptbins,ptmin,ptmax);
-  fhPhiNPE = new TH2F("hPhiNPE","Non-photonic Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-  fhEtaNPE = new TH2F("hEtaNPE","Non-photonic Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-  fhPtPE = new TH1F("hPtPE","Photonic Electron pT",nptbins,ptmin,ptmax);
-  fhPhiPE = new TH2F("hPhiPE","Photonic Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-  fhEtaPE = new TH2F("hEtaPE","Photonic Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-
-  outputContainer->Add(fhPtElectron) ; 
-  outputContainer->Add(fhPhiElectron) ; 
-  outputContainer->Add(fhEtaElectron) ;
-  outputContainer->Add(fhPtNPE) ; 
-  outputContainer->Add(fhPhiNPE) ; 
-  outputContainer->Add(fhEtaNPE) ;
-  outputContainer->Add(fhPtPE) ; 
-  outputContainer->Add(fhPhiPE) ; 
-  outputContainer->Add(fhEtaPE) ;
-
-  fhPtHadron = new TH1F("hPtHadron","Charged hadrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);
-  fhPtEleTrkDet = new TH1F("hPtEleTrkDet","Electrons identified by tracking detectors w/in EMCAL acceptance",nptbins,ptmin,ptmax);
-
-  outputContainer->Add(fhPtHadron);
-  outputContainer->Add(fhPtEleTrkDet);
-
-  //B-tagging
-  fhBtagCut1 = new TH2F("hbtag_cut1","B-tag result cut1", 10,0,10 ,nptbins,ptmin,ptmax);
-  fhBtagCut2 = new TH2F("hbtag_cut2","B-tag result cut2", 10,0,10 ,nptbins,ptmin,ptmax);
-  fhBtagCut3 = new TH2F("hbtag_cut3","B-tag result cut3", 10,0,10 ,nptbins,ptmin,ptmax);
-  fhBtagQA1  = new TH2F("hbtag_qa1" ,"B-tag QA: pairDCA vs length", 100,0,0.2 ,100,0,1.0);
-  fhBtagQA2  = new TH2F("hbtag_qa2" ,"B-tag QA: signDCA vs mass"  , 200,-0.5,0.5 ,100,0,10);
-
-  outputContainer->Add(fhBtagCut1) ;
-  outputContainer->Add(fhBtagCut2) ;
-  outputContainer->Add(fhBtagCut3) ;
-  outputContainer->Add(fhBtagQA1) ;
-  outputContainer->Add(fhBtagQA2) ;
-
-  if(IsDataMC()){
-    
-    fhPtConversion = new TH1F("hPtConversion","Conversion electron pT",nptbins,ptmin,ptmax);
-    fhPhiConversion = new TH2F("hPhiConversion","Conversion Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaConversion = new TH2F("hEtaConversion","Conversion Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtBottom = new TH1F("hPtBottom","Bottom electron pT",nptbins,ptmin,ptmax);
-    fhPhiBottom = new TH2F("hPhiBottom","Bottom Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaBottom = new TH2F("hEtaBottom","Bottom Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtCharm = new TH1F("hPtCharm","Charm electron pT",nptbins,ptmin,ptmax);
-    fhPhiCharm = new TH2F("hPhiCharm","Charm Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaCharm = new TH2F("hEtaCharm","Charm Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtCFromB = new TH1F("hPtCFromB","Charm from Bottom electron pT",nptbins,ptmin,ptmax);
-    fhPhiCFromB = new TH2F("hPhiCFromB","Charm from Bottom Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaCFromB = new TH2F("hEtaCFromB","Charm from Bottom Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtDalitz = new TH1F("hPtDalitz","Dalitz electron pT",nptbins,ptmin,ptmax);
-    fhPhiDalitz = new TH2F("hPhiDalitz","Dalitz Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaDalitz = new TH2F("hEtaDalitz","Dalitz Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtWDecay = new TH1F("hPtWDecay","W-boson Electron pT",nptbins,ptmin,ptmax);
-    fhPhiWDecay = new TH2F("hPhiWDecay","W-boson electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaWDecay = new TH2F("hEtaWDecay","W-boson Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtZDecay = new TH1F("hPtZDecay","Z-boson electron pT",nptbins,ptmin,ptmax);
-    fhPhiZDecay = new TH2F("hPhiZDecay","Z-boson Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaZDecay = new TH2F("hEtaZDecay","Z-boson Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtPrompt = new TH1F("hPtPrompt","Prompt electron pT",nptbins,ptmin,ptmax);
-    fhPhiPrompt = new TH2F("hPhiPrompt","Prompt Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaPrompt = new TH2F("hEtaPrompt","Prompt Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-    fhPtUnknown = new TH1F("hPtUnknown","Unknown electron pT",nptbins,ptmin,ptmax);
-    fhPhiUnknown = new TH2F("hPhiUnknown","Unknown Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);
-    fhEtaUnknown = new TH2F("hEtaUnknown","Unknown Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);
-
-    outputContainer->Add(fhPtConversion);
-    outputContainer->Add(fhPhiConversion);
-    outputContainer->Add(fhEtaConversion);
-    outputContainer->Add(fhPtBottom);
-    outputContainer->Add(fhPhiBottom);
-    outputContainer->Add(fhEtaBottom);
-    outputContainer->Add(fhPtCharm);
-    outputContainer->Add(fhPhiCharm);
-    outputContainer->Add(fhEtaCharm);
-    outputContainer->Add(fhPtCFromB);
-    outputContainer->Add(fhPhiCFromB);
-    outputContainer->Add(fhEtaCFromB);
-    outputContainer->Add(fhPtDalitz);
-    outputContainer->Add(fhPhiDalitz);
-    outputContainer->Add(fhEtaDalitz);
-    outputContainer->Add(fhPtWDecay);
-    outputContainer->Add(fhPhiWDecay);
-    outputContainer->Add(fhEtaWDecay);
-    outputContainer->Add(fhPtZDecay);
-    outputContainer->Add(fhPhiZDecay);
-    outputContainer->Add(fhEtaZDecay);
-    outputContainer->Add(fhPtPrompt);
-    outputContainer->Add(fhPhiPrompt);
-    outputContainer->Add(fhEtaPrompt);
-    outputContainer->Add(fhPtUnknown);
-    outputContainer->Add(fhPhiUnknown);
-    outputContainer->Add(fhEtaUnknown);
-    
-    //created ele ntuple for further analysis
-    if(fWriteNtuple) {
-      fMCEleNtuple = new TNtuple("MCEleNtuple","MC Electron Ntuple","mctag:pt:phi:eta:x:y:z");
-      outputContainer->Add(fMCEleNtuple) ;
-    }
-
-    fhPtMCHadron = new TH1F("hPtMCHadron","MC Charged hadrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);
-
-    outputContainer->Add(fhPtMCHadron);
-
-  }//Histos with MC
-  
-  //Save parameters used for analysis
-  TString parList ; //this will be list of parameters used for this analysis.
-  char onePar[255] ;
-  
-  sprintf(onePar,"--- AliAnaElectron ---\n") ;
-  parList+=onePar ;    
-  sprintf(onePar,"fCalorimeter: %s\n",fCalorimeter.Data()) ;
-  parList+=onePar ;  
-  sprintf(onePar,"fpOverEmin: %f\n",fpOverEmin) ;
-  parList+=onePar ;  
-  sprintf(onePar,"fpOverEmax: %f\n",fpOverEmax) ;
-  parList+=onePar ;  
-  sprintf(onePar,"fResidualCut: %f\n",fResidualCut) ;
-  parList+=onePar ;  
-  sprintf(onePar,"---Btagging\n");
-  parList+=onePar ;
-  sprintf(onePar,"max IP-cut (e,h): %f\n",fImpactCut);
-  parList+=onePar ;
-  sprintf(onePar,"min ITS-hits: %d\n",fITSCut);
-  parList+=onePar ;
-  sprintf(onePar,"max dR (e,h): %f\n",fDrCut);
-  parList+=onePar ;
-  sprintf(onePar,"max pairDCA: %f\n",fPairDcaCut);
-  parList+=onePar ;
-  sprintf(onePar,"max decaylength: %f\n",fDecayLenCut);
-  parList+=onePar ;
-  sprintf(onePar,"min Associated Pt: %f\n",fAssocPtCut);
-  parList+=onePar ;
-
-  //Get parameters set in base class.
-  parList += GetBaseParametersList() ;
-  
-  //Get parameters set in FidutialCut class (not available yet)
-  //parlist += GetFidCut()->GetFidCutParametersList() 
-  
-  TObjString *oString= new TObjString(parList) ;
-  outputContainer->Add(oString);
-  
-  return outputContainer ;
-  
-}
-
-//____________________________________________________________________________
-void AliAnaElectron::Init()
-{
-
-  //do some initialization
-  if(fCalorimeter == "PHOS") {
-    printf("AliAnaElectron::Init() - !!STOP: You want to use PHOS in analysis but this is not (yet) supported!!\n!!Check the configuration file!!\n");
-    fCalorimeter = "EMCAL";
-  }
-  if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn()){
-    printf("AliAnaElectron::Init() - !!STOP: You want to use EMCAL in analysis but it is not read!!\n!!Check the configuration file!!\n");
-    abort();
-  }
-
-}
-
-
-//____________________________________________________________________________
-void AliAnaElectron::InitParameters()
-{
-  
-  //Initialize the parameters of the analysis.
-  SetOutputAODClassName("AliAODPWG4Particle");
-  SetOutputAODName("PWG4Particle");
-
-  AddToHistogramsName("AnaElectron_");
-
-  fCalorimeter = "EMCAL" ;
-  fpOverEmin = 0.5;
-  fpOverEmax = 1.5;
-  fResidualCut = 0.02;
-  //B-tagging
-  fDrCut       = 1.0; 
-  fPairDcaCut  = 0.02;
-  fDecayLenCut = 1.0;
-  fImpactCut   = 0.5;
-  fAssocPtCut  = 1.0;
-  fMassCut     = 1.5;
-  fSdcaCut     = 0.1;
-  fITSCut      = 4;
-
-}
-
-//__________________________________________________________________
-void  AliAnaElectron::MakeAnalysisFillAOD() 
-{
-  //
-  // Do analysis and fill aods with electron candidates
-  // These AODs will be used to do subsequent histogram filling
-  //
-  // Also fill some QA histograms
-  //
-
-  TObjArray *cl = new TObjArray();
-
-  Double_t bfield = 0.;
-  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) bfield = GetReader()->GetBField();
-
-  //Select the calorimeter of the electron
-  if(fCalorimeter != "EMCAL") {
-    printf("This class not yet implemented for PHOS\n");
-    abort();
-  }
-  cl = GetAODEMCAL();
-  
-  ////////////////////////////////////////////////
-  //Start from tracks and get associated clusters 
-  ////////////////////////////////////////////////
-  if(!GetAODCTS() || GetAODCTS()->GetEntriesFast() == 0) return ;
-  Int_t ntracks = GetAODCTS()->GetEntriesFast();
-  if(GetDebug() > 0)
-    printf("AliAnaElectron::MakeAnalysisFillAOD() - In CTS aod entries %d\n", ntracks);
-
-  //Unfortunately, AliAODTracks don't have associated EMCAL clusters.
-  //we have to redo track-matching, I guess
-  Int_t iCluster = -999;
-  Int_t bt = 0; //counter for event b-tags
-
-  for (Int_t itrk =  0; itrk <  ntracks; itrk++) {////////////// track loop
-    iCluster = -999; //start with no match
-    AliAODTrack * track = (AliAODTrack*) (GetAODCTS()->At(itrk)) ;
-    AliAODPid* pid = (AliAODPid*) track->GetDetPid();
-
-    Double_t emcpos[3];
-    pid->GetEMCALPosition(emcpos);
-    Double_t emcmom[3];
-    pid->GetEMCALMomentum(emcmom);
-    
-    TVector3 pos(emcpos[0],emcpos[1],emcpos[2]);
-    TVector3 mom(emcmom[0],emcmom[1],emcmom[2]);
-    Double_t tphi = pos.Phi();
-    Double_t teta = pos.Eta();
-    Double_t tmom = mom.Mag();
-
-    TLorentzVector mom2(mom,0.);
-    Bool_t in =  GetFidutialCut()->IsInFidutialCut(mom2,fCalorimeter) ;
-    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);
-    if(mom.Pt() > GetMinPt() && in) {
-
-      Double_t dEdx = pid->GetTPCsignal();
-
-      //NOTE:  As of 02-Sep-2009, the XYZAtDCA methods of AOD do not
-      //work, but it is possible to get the position of a track at
-      //closest approach to the vertex from the GetPosition method
-      Double_t xyz[3];
-      //track->XYZAtDCA(xyz);
-      Bool_t isNotDCA = track->GetPosition(xyz);
-      if(isNotDCA) printf("##Problem getting impact parameter!\n");
-      //printf("\tTRACK POSITION AT DCA: %2.2f,%2.2f,%2.2f\n",xyz[0],xyz[1],xyz[2]);
-      Double_t xy = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
-      Double_t z = xyz[2];
-            
-      Int_t ntot = cl->GetEntriesFast();
-      Double_t res = 999.;
-      Double_t pOverE = -999.;
-
-      Int_t pidProb = track->GetMostProbablePID();
-      if(pidProb == AliAODTrack::kPion || pidProb == AliAODTrack::kKaon || pidProb == AliAODTrack::kProton) fhPtHadron->Fill(track->Pt());
-      if(pidProb == AliAODTrack::kElectron) fhPtEleTrkDet->Fill(track->Pt());
-
-      Bool_t isElectron = kFALSE;      
-      //For tracks in EMCAL acceptance, pair them with all clusters
-      //and fill the dEta vs dPhi for these pairs:
-      for(Int_t iclus = 0; iclus < ntot; iclus++) {
-       AliAODCaloCluster * clus = (AliAODCaloCluster*) (cl->At(iclus));
-       if(!clus) continue;
-       
-       Double_t x[3];
-       clus->GetPosition(x);
-       TVector3 cluspos(x[0],x[1],x[2]);
-       Double_t deta = teta - cluspos.Eta();
-       Double_t dphi = tphi - cluspos.Phi();
-       if(dphi > TMath::Pi()) dphi -= 2*TMath::Pi();
-       if(dphi < -TMath::Pi()) dphi += 2*TMath::Pi();
-       fh2dEtadPhi->Fill(deta,dphi);
-       fh2TrackPVsClusterE->Fill(clus->E(),track->P());
-       fh2TrackPtVsClusterE->Fill(clus->E(),track->Pt());
-       fh2TrackPhiVsClusterPhi->Fill(cluspos.Phi(),mom.Phi());
-       fh2TrackEtaVsClusterEta->Fill(cluspos.Eta(),mom.Eta());
-
-       res = sqrt(dphi*dphi + deta*deta);
-       fh1dR->Fill(res);
-
-       /////////////////////////////////
-       //Perform electron cut analysis//
-       /////////////////////////////////
-       //Good match
-       if(res < fResidualCut) {
-         fh2dEtadPhiMatched->Fill(deta,dphi);
-         iCluster = iclus;
-
-         Int_t tmctag = -1;
-         Int_t cmctag = -1;
-
-         if(IsDataMC()) {
-           //Input from second AOD?
-           Int_t input = 0;
-           if(GetReader()->GetAODCTSNormalInputEntries() <= itrk) input = 1;
-           tmctag = GetMCAnalysisUtils()->CheckOrigin(track->GetLabel(),GetReader(),input);
-
-           //Do you want the cluster or the track label?
-           input = 0;
-           if(GetReader()->GetAODEMCALNormalInputEntries() <= iclus) input = 1;
-           cmctag = GetMCAnalysisUtils()->CheckOrigin(clus->GetLabel(0),GetReader(),input);
-         }
-
-         if(fWriteNtuple) {
-           fEleNtuple->Fill(tmctag,cmctag,track->Pt(),track->Phi(),track->Eta(),track->P(),clus->E(),deta,dphi,clus->GetNCells(),dEdx,pidProb,xy,z);
-         }
-         
-         fh2MatchdEdx->Fill(track->P(),dEdx);
-         
-         Double_t energy = clus->E(); 
-         if(energy > 0) pOverE = tmom/energy;
-         fh1pOverE->Fill(pOverE);
-         
-         Int_t mult = clus->GetNCells();
-         if(mult < 2 &&  GetDebug() > 0) printf("Single digit cluster.\n");
-         
-         //////////////////////////////
-         //Electron cuts happen here!//
-         //////////////////////////////
-         if(pOverE > fpOverEmin && pOverE < fpOverEmax) isElectron = kTRUE;
-       } else {
-         fh2dEtadPhiUnmatched->Fill(deta,dphi);
-       }
-         
-      } //calocluster loop
-
-      ///////////////////////////
-      //Fill AOD with electrons//
-      ///////////////////////////
-      if(isElectron) {
-
-       //B-tagging
-       if(GetDebug() > 1) printf("Found Electron - do b-tagging\n");
-       Int_t btag = GetBtag(track); bt += btag;
-       
-       fh2EledEdx->Fill(track->P(),dEdx);
-       
-       Double_t eMass = 0.511/1000; //mass in GeV
-       Double_t eleE = sqrt(track->P()*track->P() + eMass*eMass);
-       AliAODPWG4Particle tr = AliAODPWG4Particle(track->Px(),track->Py(),track->Pz(),eleE);
-       tr.SetLabel(track->GetLabel());
-       tr.SetCaloLabel(iCluster,-1); //sets the indices of the original caloclusters
-       tr.SetTrackLabel(itrk,-1); //sets the indices of the original tracks
-       tr.SetDetector(fCalorimeter);
-       if(GetReader()->GetAODCTSNormalInputEntries() <= itrk) tr.SetInputFileIndex(1);
-       //Make this preserve sign of particle
-       if(track->Charge() < 0) tr.SetPdg(11); //electron is 11
-       else  tr.SetPdg(-11); //positron is -11
-       tr.SetBtag(btag);
-
-       //Play with the MC stack if available
-       //Check origin of the candidates
-       if(IsDataMC()){
-         
-         //FIXME:  Need to re-think this for track-oriented analysis
-         //JLK DO WE WANT TRACK TAG OR CLUSTER TAG?
-         tr.SetTag(GetMCAnalysisUtils()->CheckOrigin(tr.GetLabel(),GetReader(),tr.GetInputFileIndex()));
-         
-         if(GetDebug() > 0) printf("AliAnaElectron::MakeAnalysisFillAOD() - Origin of candidate %d\n",tr.GetTag());
-       }//Work with stack also   
-       
-       AddAODParticle(tr);
-       
-       if(GetDebug() > 1) printf("AliAnaElectron::MakeAnalysisFillAOD() - Electron selection cuts passed: pT %3.2f, pdg %d\n",tr.Pt(),tr.GetPdg());    
-      }//electron
-    }//pt, fiducial selection                                                                                  
-  }//track loop                         
-  
-  //FIXME:  Should we also check from the calocluster side, just in
-  //case?
-
-  if(GetDebug() > 1 && bt > 0) printf("AliAnaElectron::MakeAnalysisFillAOD() *** Event Btagged *** \n");
-  if(GetDebug() > 1) printf("AliAnaElectron::MakeAnalysisFillAOD()  End fill AODs \n");  
-  
-}
-
-//__________________________________________________________________
-void  AliAnaElectron::MakeAnalysisFillHistograms() 
-{
-  //Do analysis and fill histograms
-
-  AliStack * stack = 0x0;
-  TParticle * primary = 0x0;
-  TClonesArray * mcparticles0 = 0x0;
-  TClonesArray * mcparticles1 = 0x0;
-  AliAODMCParticle * aodprimary = 0x0;
-
-  if(IsDataMC()) {
-    if(GetReader()->ReadStack()){
-      stack =  GetMCStack() ;
-      
-      if(!stack)
-       printf("AliAnaElectron::MakeAnalysisFillHistograms() *** no stack ***: \n");
-      
-    }
-    else if(GetReader()->ReadAODMCParticles()){
-      //Get the list of MC particles
-      mcparticles0 = GetReader()->GetAODMCParticles(0);
-      if(!mcparticles0 && GetDebug() > 0)     {
-       printf("AliAnaElectron::MakeAnalysisFillHistograms() -  Standard MCParticles not available!\n");
-      }
-      if(GetReader()->GetSecondInputAODTree()){
-       mcparticles1 = GetReader()->GetAODMCParticles(1);
-       if(!mcparticles1 && GetDebug() > 0)     {
-         printf("AliAnaElectron::MakeAnalysisFillHistograms() -  Second input MCParticles not available!\n");
-       }
-      }
-      
-    }
-  }// is data and MC
-  
-  //Loop on stored AOD electrons
-  Int_t naod = GetOutputAODBranch()->GetEntriesFast();
-  if(GetDebug() > 0) printf("AliAnaElectron::MakeAnalysisFillHistograms() - aod branch entries %d\n", naod);
-  
-  for(Int_t iaod = 0; iaod < naod ; iaod++){
-    AliAODPWG4Particle* ele =  (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));
-    Int_t pdg = ele->GetPdg();
-    
-    if(GetDebug() > 3) 
-      printf("AliAnaElectron::MakeAnalysisFillHistograms() - PDG %d, MC TAG %d, Calorimeter %s\n", ele->GetPdg(),ele->GetTag(), (ele->GetDetector()).Data()) ;
-    
-    if(TMath::Abs(pdg) != AliCaloPID::kElectron) continue; 
-    if(ele->GetDetector() != fCalorimeter) continue;
-    
-    if(GetDebug() > 1) 
-      printf("AliAnaElectron::MakeAnalysisFillHistograms() - ID Electron: pt %f, phi %f, eta %f\n", ele->Pt(),ele->Phi(),ele->Eta()) ;
-    
-
-    //Filter for photonic electrons based on opening angle and Minv
-    //cuts, also fill histograms
-    Bool_t photonic = kFALSE;
-    photonic = IsItPhotonic(ele);
-
-    //Fill electron histograms 
-    Float_t ptele = ele->Pt();
-    Float_t phiele = ele->Phi();
-    Float_t etaele = ele->Eta();
-    
-    fhPtElectron  ->Fill(ptele);
-    fhPhiElectron ->Fill(ptele,phiele);
-    fhEtaElectron ->Fill(ptele,etaele);
-
-    if(photonic) {
-      fhPtPE->Fill(ptele);
-      fhPhiPE->Fill(ptele,phiele);
-      fhEtaPE->Fill(ptele,etaele);
-    } else {
-      fhPtNPE->Fill(ptele);
-      fhPhiNPE->Fill(ptele,phiele);
-      fhEtaNPE->Fill(ptele,etaele);
-    }
-
-    if(IsDataMC()){
-      Int_t tag = ele->GetTag();
-      if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)){
-       fhPtConversion  ->Fill(ptele);
-       fhPhiConversion ->Fill(ptele,phiele);
-       fhEtaConversion ->Fill(ptele,etaele);
-      }
-      else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEFromB))
-       {
-         fhPtBottom  ->Fill(ptele);
-         fhPhiBottom ->Fill(ptele,phiele);
-         fhEtaBottom ->Fill(ptele,etaele);
-       }
-      else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEFromC))
-       {
-         fhPtCharm  ->Fill(ptele);
-         fhPhiCharm ->Fill(ptele,phiele);
-         fhEtaCharm ->Fill(ptele,etaele);
-       }
-      else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEFromCFromB))
-       {
-         fhPtCFromB  ->Fill(ptele);
-         fhPhiCFromB ->Fill(ptele,phiele);
-         fhEtaCFromB ->Fill(ptele,etaele);
-       }
-      else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay) || GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) || GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay))
-       {
-         fhPtDalitz  ->Fill(ptele);
-         fhPhiDalitz ->Fill(ptele,phiele);
-         fhEtaDalitz ->Fill(ptele,etaele);
-       }
-      else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCWDecay))
-       {
-         fhPtWDecay  ->Fill(ptele);
-         fhPhiWDecay ->Fill(ptele,phiele);
-         fhEtaWDecay ->Fill(ptele,etaele);
-       }
-      else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCZDecay))
-       {
-         fhPtZDecay  ->Fill(ptele);
-         fhPhiZDecay ->Fill(ptele,phiele);
-         fhEtaZDecay ->Fill(ptele,etaele);
-       }
-      else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron))
-       {
-         fhPtPrompt  ->Fill(ptele);
-         fhPhiPrompt ->Fill(ptele,phiele);
-         fhEtaPrompt ->Fill(ptele,etaele);       
-       }
-      else{
-       fhPtUnknown  ->Fill(ptele);
-       fhPhiUnknown ->Fill(ptele,phiele);
-       fhEtaUnknown ->Fill(ptele,etaele);
-      }
-    }//Histograms with MC
-    
-  }// aod loop
-
-  ////////////////////////////////////////////////////////
-  //Fill histograms of pure MC kinematics from the stack//
-  ////////////////////////////////////////////////////////
-  if(IsDataMC()) {
-    if(GetReader()->ReadStack()) {
-      for(Int_t ipart = 0; ipart < stack->GetNtrack(); ipart++) {
-       primary = stack->Particle(ipart);
-       TLorentzVector mom;
-       primary->Momentum(mom);
-       Bool_t in = GetFidutialCut()->IsInFidutialCut(mom,fCalorimeter);
-       if(primary->Pt() < GetMinPt()) continue;
-       if(!in) continue;
-
-       Int_t pdgcode = primary->GetPdgCode();
-       if(TMath::Abs(pdgcode) == 211 || TMath::Abs(pdgcode) == 321 || TMath::Abs(pdgcode) == 2212)
-         fhPtMCHadron->Fill(primary->Pt());
-
-       //we only care about electrons
-       if(TMath::Abs(pdgcode) != 11) continue;
-       //we only want TRACKABLE electrons (TPC 85-250cm)
-       if(primary->R() > 200.) continue;
-       //Ignore low pt electrons
-       if(primary->Pt() < 0.2) continue;
-       
-       //find out what the ancestry of this electron is
-       Int_t mctag = -1;
-       Int_t input = 0;
-       mctag = GetMCAnalysisUtils()->CheckOrigin(ipart,GetReader(),input);
-
-       //fill ntuple
-       if(fWriteNtuple) {
-         fMCEleNtuple->Fill(mctag,primary->Pt(),primary->Phi(),primary->Eta(),primary->Vx(),primary->Vy(),primary->Vz());
-       }
-       
-      }
-      
-    } else if(GetReader()->ReadAODMCParticles()) {
-      Int_t npart0 = mcparticles0->GetEntriesFast();
-      Int_t npart1 = 0;
-      if(mcparticles1) npart1 = mcparticles1->GetEntriesFast();
-      Int_t npart = npart0+npart1;
-      for(Int_t ipart = 0; ipart < npart; ipart++) {
-       if(ipart < npart0) aodprimary = (AliAODMCParticle*)mcparticles0->At(ipart);
-       else aodprimary = (AliAODMCParticle*)mcparticles1->At(ipart-npart0);
-       if(!aodprimary) {
-         printf("AliAnaElectron::MakeAnalysisFillHistograms() *** no primary ***:  label %d \n", ipart);
-         continue;
-       }
-
-       Double_t mom[3] = {0.,0.,0.};
-       aodprimary->PxPyPz(mom);
-       TLorentzVector mom2(mom,0.);    
-       Bool_t in = GetFidutialCut()->IsInFidutialCut(mom2,fCalorimeter);
-       if(aodprimary->Pt() < GetMinPt()) continue;
-       if(!in) continue;
-
-       Int_t pdgcode = aodprimary->GetPdgCode();
-       if(TMath::Abs(pdgcode) == 211 || TMath::Abs(pdgcode) == 321 || TMath::Abs(pdgcode) == 2212)
-         fhPtMCHadron->Fill(aodprimary->Pt());
-
-       //we only care about electrons
-       if(TMath::Abs(pdgcode) != 11) continue;
-       //we only want TRACKABLE electrons (TPC 85-250cm)
-       Double_t radius = TMath::Sqrt(aodprimary->Xv()*aodprimary->Xv() + aodprimary->Yv()*aodprimary->Yv());
-       if(radius > 200.) continue;
-       
-       if(aodprimary->Pt() < 0.2) continue;
-
-       /*
-       if(aodprimary->GetDaughter(0) > 0) {
-         Int_t dindex = aodprimary->GetDaughter(0);
-         //printf("####AODMCparticle daughter index %d and flag value %d\n",dindex,aodprimary->GetFlag());
-         Double_t dxv = 0.;
-         Double_t dyv = 0.;
-         if(ipart < npart0) {
-           dxv =  ((AliAODMCParticle*)mcparticles0->At(dindex))->Xv();
-           dyv =  ((AliAODMCParticle*)mcparticles0->At(dindex))->Yv();
-         } else {
-           dxv =  ((AliAODMCParticle*)mcparticles1->At(dindex))->Xv();
-           dyv =  ((AliAODMCParticle*)mcparticles1->At(dindex))->Yv();
-         }
-         Double_t dradius = TMath::Sqrt(dxv*dxv+dyv*dyv);
-         //printf("\tDaughter production radius = %2.2f\n",dradius); 
-         //if you convert/decay within the trackable zone, discard
-         //from ntuple ?
-         //      if(dradius < 200.) continue;
-       }
-       */
-
-       //find out what the ancestry of this electron is
-       Int_t mctag = -1;
-       Int_t input = 0;
-       Int_t ival = ipart;
-       if(ipart > npart0) { ival -= npart0; input = 1;}
-       mctag = GetMCAnalysisUtils()->CheckOrigin(ival,GetReader(),input);
-       
-       //fill ntuple
-       if(fWriteNtuple) {
-         fMCEleNtuple->Fill(mctag,aodprimary->Pt(),aodprimary->Phi(),aodprimary->Eta(),aodprimary->Xv(),aodprimary->Yv(),aodprimary->Zv());
-       }
-       
-      }
-    }
-  } //pure MC kine histos
-    
-}
-
-//__________________________________________________________________
-Int_t AliAnaElectron::GetBtag(AliAODTrack * tr )
-{
-  //This method uses the Displaced Vertex between electron-hadron
-  //pairs and the primary vertex to determine whether an electron is
-  //likely from a B hadron.
-
-  Int_t ncls1 = 0;
-  for(Int_t l = 0; l < 6; l++) if(TESTBIT(tr->GetITSClusterMap(),l)) ncls1++;
-  if (ncls1 < fITSCut) return 0;
-
-  Double_t x[3];
-  //Note: 02-Sep-2009, Must use GetPosition, not XYZAtDCA
-  //Bool_t gotit = tr->XYZAtDCA(x);
-  Bool_t isNotDCA = tr->GetPosition(x);
-  if(isNotDCA) { printf("##Problem getting impact parameter!\n"); return 0; }
-
-  Double_t d1 = TMath::Sqrt(x[0]*x[0] + x[1]*x[1]);
-  if (TMath::Abs(d1)   > fImpactCut ) return 0;
-  if (TMath::Abs(x[2]) > fImpactCut ) return 0;
-  //printf("----- impact parameter: x=%f, y=%f, z=%f -------\n",x[0],x[1], x[2]);
-
-  Int_t nvtx1 = 0;
-  Int_t nvtx2 = 0;
-  Int_t nvtx3 = 0;
-
-  for (Int_t k2 =0; k2 < GetAODCTS()->GetEntriesFast() ; k2++) {
-    //loop over assoc
-    AliAODTrack* track2 = (AliAODTrack*) (GetAODCTS()->At(k2));
-    Int_t id1 = tr->GetID();
-    Int_t id2 = track2->GetID();
-    if(id1 == id2) continue;
-
-    Int_t ncls2 = 0;
-    for(Int_t l = 0; l < 6; l++) if(TESTBIT(track2->GetITSClusterMap(),l)) ncls2++;
-    if (ncls2 < fITSCut) continue;
-
-    if(track2->Pt() < fAssocPtCut) continue;
-
-    Double_t dphi = tr->Phi() - track2->Phi();
-    if(dphi > TMath::Pi()) dphi -= 2*TMath::Pi();
-    if(dphi < -TMath::Pi()) dphi += 2*TMath::Pi();
-    Double_t deta = tr->Eta() - track2->Eta();
-    Double_t dr = sqrt(deta*deta + dphi*dphi);
-
-    if(dr > fDrCut) continue;
-    
-    Double_t sDca1 = ComputeSignDca(tr, track2, 1.0);
-    if (sDca1 > fSdcaCut) nvtx1++;
-    Double_t sDca2 = ComputeSignDca(tr, track2, 1.5);
-    if (sDca2 > fSdcaCut) nvtx2++;
-    Double_t sDca3 = ComputeSignDca(tr, track2, 1.8);
-    if (sDca3 > fSdcaCut) nvtx3++;
-
-  } //loop over hadrons
-
-  if(GetDebug() > 0) {
-    if (nvtx1>0) printf("result1 of btagging: %d \n",nvtx1);
-    if (nvtx2>0) printf("result2 of btagging: %d \n",nvtx2);
-    if (nvtx3>0) printf("result3 of btagging: %d \n",nvtx3);
-  }
-
-  //fill QA histograms
-  fhBtagCut1->Fill(nvtx1,tr->Pt());
-  fhBtagCut2->Fill(nvtx2,tr->Pt());
-  fhBtagCut3->Fill(nvtx3,tr->Pt());
-
-  return nvtx2;
-}
-
-//__________________________________________________________________
-Double_t AliAnaElectron::ComputeSignDca(AliAODTrack *tr, AliAODTrack *tr2 , float masscut)
-{
-  //Compute the signed dca between two tracks
-  //and return the result
-
-  Double_t signDca=-999.;
-  if(GetDebug() > 2 ) printf(">>ComputeSdca:: track1 %d, track2 %d, masscut %f \n", tr->GetLabel(), tr2->GetLabel(), masscut);
-
-  //=====Now calculate DCA between both tracks=======  
-  Double_t massE = 0.000511;
-  Double_t massK = 0.493677;
-
-  Double_t bfield = 5.; //kG
-  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) bfield = GetReader()->GetBField();
-
-  Double_t vertex[3] = {-999.,-999.,-999}; //vertex
-  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) {
-    GetReader()->GetVertex(vertex); //If only one file, get the vertex from there
-    //FIXME:  Add a check for whether file 2 is PYTHIA or HIJING
-    //If PYTHIA, then set the vertex from file 2, if not, use the
-    //vertex from file 1
-    if(GetReader()->GetSecondInputAODTree()) GetReader()->GetSecondInputAODVertex(vertex);
-  }
-  
-  TVector3 primV(vertex[0],vertex[1],vertex[2]) ;
-
-  if(GetDebug() > 5) printf(">>ComputeSdca:: primary vertex = %2.2f,%2.2f,%2.2f \n",vertex[0],vertex[1],vertex[2]) ;
-
-  AliExternalTrackParam *param1 = new AliExternalTrackParam(tr);
-  AliExternalTrackParam *param2 = new AliExternalTrackParam(tr2);
-
-  Double_t xplane1 = 0.; Double_t xplane2 = 0.;
-  Double_t pairdca = param1->GetDCA(param2,bfield,xplane1,xplane2);
-
-  Int_t id1 = 0, id2 = 0;
-  AliESDv0 bvertex(*param1,id1,*param2,id2);
-  Double_t vx,vy,vz;
-  bvertex.GetXYZ(vx,vy,vz);
-
-  Double_t emom[3];
-  Double_t hmom[3];
-  param1->PxPyPz(emom);
-  param2->PxPyPz(hmom);
-  TVector3 emomAtB(emom[0],emom[1],emom[2]);
-  TVector3 hmomAtB(hmom[0],hmom[1],hmom[2]);
-  TVector3 secvtxpt(vx,vy,vz);
-  TVector3 decayvector(0,0,0);
-  decayvector = secvtxpt - primV; //decay vector from PrimVtx
-  Double_t decaylength = decayvector.Mag();
-
-  if(GetDebug() > 0) {
-    printf(">>ComputeSdca:: mom1=%f, mom2=%f \n", emomAtB.Perp(), hmomAtB.Perp() );
-    printf(">>ComputeSdca:: pairDCA=%f, length=%f \n", pairdca,decaylength );
-  }
-
-  if (masscut<1.1) fhBtagQA1->Fill(pairdca,decaylength);
-
-  if (emomAtB.Mag()>0 && pairdca < fPairDcaCut && decaylength < fDecayLenCut ) {
-    TVector3 sumMom = emomAtB+hmomAtB;
-    Double_t ener1 = sqrt(pow(emomAtB.Mag(),2) + massE*massE);
-    Double_t ener2 = sqrt(pow(hmomAtB.Mag(),2) + massK*massK);
-    Double_t ener3 = sqrt(pow(hmomAtB.Mag(),2) + massE*massE);
-    Double_t mass = sqrt(pow((ener1+ener2),2) - pow(sumMom.Mag(),2));
-    Double_t massPhot = sqrt(pow((ener1+ener3),2) - pow(sumMom.Mag(),2));
-    Double_t sDca = decayvector.Dot(emomAtB)/emomAtB.Mag();
-
-    if (masscut<1.1) fhBtagQA2->Fill(sDca, mass);
-
-    if (mass > masscut && massPhot > 0.1) signDca = sDca;
-    
-    if(GetDebug() > 0) printf("\t>>ComputeSdca:: mass=%f \n", mass);
-    if(GetDebug() > 0) printf("\t>>ComputeSdca:: sec vtx-signdca :%f\n",signDca);
-  }
-
-  //clean up
-  delete param1;
-  delete param2;
-
-  return signDca;
-}
-
-//__________________________________________________________________
-Bool_t AliAnaElectron::IsItPhotonic(const AliAODPWG4Particle* part) 
-{
-  //This method checks the opening angle and invariant mass of
-  //electron pairs to see if they are likely to be photonic electrons
-
-  Bool_t itIS = kFALSE;
-
-  Double_t massE = 0.000511;
-  Double_t bfield = 5.; //kG
-  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) bfield = GetReader()->GetBField();
-
-  Int_t pdg1 = part->GetPdg();
-  Int_t trackId = part->GetTrackLabel(0);
-  AliAODTrack* track = (AliAODTrack*)GetAODCTS()->At(trackId);
-  if(!track) {
-    if(GetDebug() > 0) printf("AliAnaElectron::IsItPhotonic - can't get the AOD Track from the particle!  Skipping the photonic check");
-    return kFALSE; //Don't proceed because we can't get the track
-  }
-
-  AliExternalTrackParam *param1 = new AliExternalTrackParam(track);
-
-  //Loop on stored AOD electrons and compute the angle differences and Minv
-  for (Int_t k2 =0; k2 < GetOutputAODBranch()->GetEntriesFast() ; k2++) {
-    AliAODPWG4Particle* part2 = (AliAODPWG4Particle*) GetOutputAODBranch()->At(k2);
-    Int_t track2Id = part2->GetTrackLabel(0);
-    if(trackId == track2Id) continue;
-    Int_t pdg2 = part2->GetPdg();
-    if(TMath::Abs(pdg2) != AliCaloPID::kElectron) continue;
-    if(part2->GetDetector() != fCalorimeter) continue;
-
-    //JLK: Check opp. sign pairs only
-    if(pdg1*pdg2 > 0) continue; //skip same-sign pairs
-
-    //propagate to common vertex and check opening angle
-    AliAODTrack* track2 = (AliAODTrack*)GetAODCTS()->At(track2Id);
-    if(!track2) {
-      if(GetDebug() >0) printf("AliAnaElectron::IsItPhotonic - problem getting the partner track.  Continuing on to the next one");
-      continue;
-    }
-    AliExternalTrackParam *param2 = new AliExternalTrackParam(track2);
-    Int_t id1 = 0, id2 = 0;
-    AliESDv0 photonVtx(*param1,id1,*param2,id2);
-    Double_t vx,vy,vz;
-    photonVtx.GetXYZ(vx,vy,vz);
-
-    Double_t p1mom[3];
-    Double_t p2mom[3];
-    param1->PxPyPz(p1mom);
-    param2->PxPyPz(p2mom);
-
-    TVector3 p1momAtB(p1mom[0],p1mom[1],p1mom[2]);
-    TVector3 p2momAtB(p2mom[0],p2mom[1],p2mom[2]);
-    TVector3 sumMom = p1momAtB+p2momAtB;
-
-    Double_t ener1 = sqrt(pow(p1momAtB.Mag(),2) + massE*massE);
-    Double_t ener2 = sqrt(pow(p2momAtB.Mag(),2) + massE*massE);
-    Double_t mass = sqrt(pow((ener1+ener2),2) - pow(sumMom.Mag(),2));
-
-    Double_t dphi = p1momAtB.DeltaPhi(p2momAtB);
-    fh1OpeningAngle->Fill(dphi);
-    fh1MinvPhoton->Fill(mass);
-
-    if(mass < 0.1) {
-      if(GetDebug() > 0) printf("######PROBABLY A PHOTON\n");
-      itIS = kTRUE;
-    }
-
-    //clean up
-    delete param2;
-
-  }
-
-  delete param1;
-  return itIS;
-
-}
-
-//__________________________________________________________________
-void AliAnaElectron::Print(const Option_t * opt) const
-{
-  //Print some relevant parameters set for the analysis
-  
-  if(! opt)
-    return;
-  
-  printf("**** Print %s %s ****\n", GetName(), GetTitle() ) ;
-  AliAnaPartCorrBaseClass::Print(" ");
-
-  printf("Calorimeter            =     %s\n", fCalorimeter.Data()) ;
-  printf("pOverE range           =     %f - %f\n",fpOverEmin,fpOverEmax);
-  printf("residual cut           =     %f\n",fResidualCut);
-  printf("---Btagging\n");
-  printf("max IP-cut (e,h)       =     %f\n",fImpactCut);
-  printf("min ITS-hits           =     %d\n",fITSCut);
-  printf("max dR (e,h)           =     %f\n",fDrCut);
-  printf("max pairDCA            =     %f\n",fPairDcaCut);
-  printf("max decaylength        =     %f\n",fDecayLenCut);
-  printf("min Associated Pt      =     %f\n",fAssocPtCut);
-  printf("    \n") ;
-       
-} 
-
-//________________________________________________________________________
-void AliAnaElectron::ReadHistograms(TList* outputList)
-{
-  // Needed when Terminate is executed in distributed environment                             
-  // Refill analysis histograms of this class with corresponding
-  // histograms in output list.   
-
-  // Histograms of this analsys are kept in the same list as other
-  // analysis, recover the position of
-  // the first one and then add the next                                                      
-  Int_t index = outputList->IndexOf(outputList->FindObject(GetAddedHistogramsStringToName()+"fh1pOverE"));
-
-  //Read histograms, must be in the same order as in
-  //GetCreateOutputObject.                   
-  fh1pOverE     = (TH1F *) outputList->At(index);
-  fh1dR         = (TH1F *) outputList->At(index++);
-  fh2EledEdx    = (TH2F *) outputList->At(index++);
-  fh2MatchdEdx  = (TH2F *) outputList->At(index++);
-  
-}
-
-//__________________________________________________________________
-void  AliAnaElectron::Terminate(TList* outputList)
-{
-
-  //Do some plots to end
-  //Recover histograms from output histograms list, needed for
-  //distributed analysis.                
-  //ReadHistograms(outputList);
-
-  printf(" AliAnaElectron::Terminate()  *** %s Report: %d outputs\n", GetName(), outputList->GetEntries()) ;
-
-}
-
+/**************************************************************************\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), M. Heinz (Yale)\r
+//////////////////////////////////////////////////////////////////////////////\r
+  \r
+// --- ROOT system --- \r
+#include <TH2F.h>\r
+#include <TParticle.h>\r
+#include <TNtuple.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 "AliAODCaloCluster.h"\r
+#include "AliFidutialCut.h"\r
+#include "AliAODTrack.h"\r
+#include "AliAODPid.h"\r
+#include "AliCaloPID.h"\r
+#include "AliAODMCParticle.h"\r
+#include "AliStack.h"\r
+#include "AliExternalTrackParam.h"\r
+#include "AliESDv0.h"\r
+#include "AliAODJet.h"\r
+#include "AliAODEvent.h"\r
+\r
+ClassImp(AliAnaElectron)\r
+  \r
+//____________________________________________________________________________\r
+AliAnaElectron::AliAnaElectron() \r
+: AliAnaPartCorrBaseClass(),fCalorimeter(""),\r
+  fpOverEmin(0.),fpOverEmax(0.),fResidualCut(0.),\r
+  fDrCut(0.),fPairDcaCut(0.),fDecayLenCut(0.),fImpactCut(0.),\r
+  fAssocPtCut(0.),fMassCut(0.),fSdcaCut(0.),fITSCut(0),\r
+  fWriteNtuple(kFALSE),\r
+  //matching checks\r
+  fEleNtuple(0),\r
+  fh1pOverE(0),fh1dR(0),fh2EledEdx(0),fh2MatchdEdx(0),fh2dEtadPhi(0),\r
+  fh2dEtadPhiMatched(0),fh2dEtadPhiUnmatched(0),\r
+  fh2TrackPVsClusterE(0),fh2TrackPtVsClusterE(0),fh2TrackPhiVsClusterPhi(0),fh2TrackEtaVsClusterEta(0),\r
+  //Photonic electron checks\r
+  fh1OpeningAngle(0),fh1MinvPhoton(0),\r
+  //reco\r
+  fhPtElectron(0),fhPhiElectron(0),fhEtaElectron(0),\r
+  fhPtNPE(0),fhPhiNPE(0),fhEtaNPE(0),\r
+  fhPtPE(0),fhPhiPE(0),fhEtaPE(0),\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
+  fhPtAll(0),fhPhiAll(0),fhEtaAll(0),\r
+  fhPtUnknown(0),fhPhiUnknown(0),fhEtaUnknown(0),\r
+  fhPtMisidentified(0),fhPhiMisidentified(0),fhEtaMisidentified(0),\r
+  fhPtHadron(0),fhPtEleTrkDet(0),\r
+  //event QA\r
+  fhImpactXY(0),fhRefMult(0),fhRefMult2(0),\r
+  //B-tagging\r
+  fhBtagCut1(0),fhBtagCut2(0),fhBtagCut3(0),fhBtagQA1(0),fhBtagQA2(0),fhBtagQA3(0),fhBtagQA4(0),fhBtagQA5(0),\r
+  //B-jets\r
+  fhBJetXsiFF(0),fhBJetPtFF(0),fhBJetEtaPhi(0),fhNonBJetXsiFF(0),fhNonBJetPtFF(0),fhNonBJetEtaPhi(0),\r
+  //MC\r
+  fMCEleNtuple(0),fhPtMCHadron(0),fhPtMCBottom(0),fhPtMCCharm(0),fhPtMCCFromB(0),fhPtMCConversion(0),\r
+  fhPtMCDalitz(0),fhPtMCWDecay(0),fhPtMCZDecay(0),fhPtMCUnknown(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
+   fDrCut(g.fDrCut),fPairDcaCut(g.fPairDcaCut),fDecayLenCut(g.fDecayLenCut),fImpactCut(g.fImpactCut),\r
+  fAssocPtCut(g.fAssocPtCut),fMassCut(g.fMassCut),fSdcaCut(g.fSdcaCut),fITSCut(g.fITSCut),\r
+   fWriteNtuple(g.fWriteNtuple),\r
+   //matching checks\r
+   fEleNtuple(g.fEleNtuple),\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
+   fh2TrackPVsClusterE(g.fh2TrackPVsClusterE),fh2TrackPtVsClusterE(g.fh2TrackPtVsClusterE),\r
+   fh2TrackPhiVsClusterPhi(g.fh2TrackPhiVsClusterPhi),fh2TrackEtaVsClusterEta(g.fh2TrackEtaVsClusterEta),   \r
+   //Photonic electron checks\r
+   fh1OpeningAngle(g.fh1OpeningAngle),fh1MinvPhoton(g.fh1MinvPhoton),\r
+   //reco\r
+   fhPtElectron(g.fhPtElectron),fhPhiElectron(g.fhPhiElectron),fhEtaElectron(g.fhEtaElectron),\r
+   fhPtNPE(g.fhPtNPE),fhPhiNPE(g.fhPhiNPE),fhEtaNPE(g.fhEtaNPE),\r
+   fhPtPE(g.fhPtPE),fhPhiPE(g.fhPhiPE),fhEtaPE(g.fhEtaPE),\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
+   fhPtAll(g.fhPtAll),fhPhiAll(g.fhPhiAll),fhEtaAll(g.fhEtaAll),\r
+   fhPtUnknown(g.fhPtUnknown),fhPhiUnknown(g.fhPhiUnknown),fhEtaUnknown(g.fhEtaUnknown),\r
+   fhPtMisidentified(g.fhPtMisidentified),fhPhiMisidentified(g.fhPhiMisidentified),fhEtaMisidentified(g.fhEtaMisidentified),\r
+   fhPtHadron(g.fhPtHadron),fhPtEleTrkDet(g.fhPtEleTrkDet),\r
+   //event QA\r
+   fhImpactXY(g.fhImpactXY),fhRefMult(g.fhRefMult),fhRefMult2(g.fhRefMult2),\r
+   //B-tagging\r
+   fhBtagCut1(g.fhBtagCut1),fhBtagCut2(g.fhBtagCut2),fhBtagCut3(g.fhBtagCut3),\r
+   fhBtagQA1(g.fhBtagQA1),fhBtagQA2(g.fhBtagQA2),fhBtagQA3(g.fhBtagQA3),fhBtagQA4(g.fhBtagQA4),\r
+   fhBtagQA5(g.fhBtagQA5),\r
+   //B-jets\r
+    fhBJetXsiFF(g.fhBJetXsiFF),fhBJetPtFF(g.fhBJetPtFF),fhBJetEtaPhi(g.fhBJetEtaPhi),\r
+    fhNonBJetXsiFF(g.fhNonBJetXsiFF),fhNonBJetPtFF(g.fhNonBJetPtFF),fhNonBJetEtaPhi(g.fhNonBJetEtaPhi),\r
+   //MC\r
+    fMCEleNtuple(g.fMCEleNtuple),fhPtMCHadron(g.fhPtMCHadron),fhPtMCBottom(g.fhPtMCBottom),\r
+    fhPtMCCharm(g.fhPtMCCharm),fhPtMCCFromB(g.fhPtMCCFromB),fhPtMCConversion(g.fhPtMCConversion),\r
+    fhPtMCDalitz(g.fhPtMCDalitz),fhPtMCWDecay(g.fhPtMCWDecay),\r
+    fhPtMCZDecay(g.fhPtMCZDecay),fhPtMCUnknown(g.fhPtMCUnknown)\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
+  fDrCut = g.fDrCut;\r
+  fPairDcaCut = g.fPairDcaCut;\r
+  fDecayLenCut = g.fDecayLenCut;\r
+  fImpactCut = g.fImpactCut;\r
+  fAssocPtCut = g.fAssocPtCut;\r
+  fMassCut = g.fMassCut;\r
+  fSdcaCut = g.fSdcaCut;\r
+  fITSCut = g.fITSCut;\r
+  fWriteNtuple = g.fWriteNtuple;\r
+  fEleNtuple = g.fEleNtuple;\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
+  fh2TrackPVsClusterE = g.fh2TrackPVsClusterE;\r
+  fh2TrackPtVsClusterE = g.fh2TrackPtVsClusterE;\r
+  fh2TrackPhiVsClusterPhi = g.fh2TrackPhiVsClusterPhi;\r
+  fh2TrackEtaVsClusterEta = g.fh2TrackEtaVsClusterEta;   \r
+  fh1OpeningAngle = g.fh1OpeningAngle;\r
+  fh1MinvPhoton = g.fh1MinvPhoton;\r
+  fhPtElectron = g.fhPtElectron;\r
+  fhPhiElectron = g.fhPhiElectron;\r
+  fhEtaElectron = g.fhEtaElectron;\r
+  fhPtNPE = g.fhPtNPE;\r
+  fhPhiNPE = g.fhPhiNPE;\r
+  fhEtaNPE = g.fhEtaNPE;\r
+  fhPtPE = g.fhPtPE;\r
+  fhPhiPE = g.fhPhiPE;\r
+  fhEtaPE = g.fhEtaPE;\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
+  fhPtAll = g.fhPtAll;\r
+  fhPhiAll = g.fhPhiAll;\r
+  fhEtaAll = g.fhEtaAll;\r
+  fhPtUnknown = g.fhPtUnknown;\r
+  fhPhiUnknown = g.fhPhiUnknown;\r
+  fhEtaUnknown = g.fhEtaUnknown;\r
+  fhPtMisidentified = g.fhPtMisidentified;\r
+  fhPhiMisidentified = g.fhPhiMisidentified;\r
+  fhEtaMisidentified = g.fhEtaMisidentified;\r
+\r
+  fhPtHadron = g.fhPtHadron;\r
+  fhPtEleTrkDet = g.fhPtEleTrkDet;\r
+\r
+  //event QA\r
+  fhImpactXY = g.fhImpactXY;\r
+  fhRefMult = g.fhRefMult;\r
+  fhRefMult2 = g.fhRefMult2;\r
+\r
+  //B-tagging\r
+  fhBtagCut1 = g.fhBtagCut1;\r
+  fhBtagCut2 = g.fhBtagCut2;\r
+  fhBtagCut3 = g.fhBtagCut3;\r
+  fhBtagQA1 = g.fhBtagQA1;\r
+  fhBtagQA2 = g.fhBtagQA2;\r
+  fhBtagQA3 = g.fhBtagQA3;\r
+  fhBtagQA4 = g.fhBtagQA4;\r
+  fhBtagQA5 = g.fhBtagQA5;\r
+\r
+  fhBJetXsiFF = g.fhBJetXsiFF;\r
+  fhBJetPtFF = g.fhBJetPtFF;\r
+  fhBJetEtaPhi = g.fhBJetEtaPhi;\r
+  fhNonBJetXsiFF = g.fhNonBJetXsiFF;\r
+  fhNonBJetPtFF = g.fhNonBJetPtFF;\r
+  fhNonBJetEtaPhi = g.fhNonBJetEtaPhi;\r
+\r
+  fMCEleNtuple = g.fMCEleNtuple;\r
+  fhPtMCHadron = g.fhPtMCHadron;\r
+  fhPtMCBottom = g.fhPtMCBottom;\r
+  fhPtMCCharm = g.fhPtMCCharm;\r
+  fhPtMCCFromB = g.fhPtMCCFromB;\r
+  fhPtMCConversion = g.fhPtMCConversion;\r
+  fhPtMCDalitz = g.fhPtMCDalitz;\r
+  fhPtMCWDecay = g.fhPtMCWDecay;\r
+  fhPtMCZDecay = g.fhPtMCZDecay;\r
+  fhPtMCUnknown = g.fhPtMCUnknown;\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
+  //created ele ntuple for further analysis\r
+  if(fWriteNtuple) {\r
+      fEleNtuple = new TNtuple("EleNtuple","Electron Ntuple","tmctag:cmctag:pt:phi:eta:p:E:deta:dphi:nCells:dEdx:pidProb:impXY:impZ");\r
+    outputContainer->Add(fEleNtuple) ;\r
+  }\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
+\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(fh2TrackPVsClusterE) ;\r
+  outputContainer->Add(fh2TrackPtVsClusterE) ;\r
+  outputContainer->Add(fh2TrackPhiVsClusterPhi) ;\r
+  outputContainer->Add(fh2TrackEtaVsClusterEta) ;\r
+  \r
+  //photonic electron checks\r
+  fh1OpeningAngle = new TH1F("hOpeningAngle","Opening angle between e+e- pairs",100,0.,TMath::Pi());\r
+  fh1MinvPhoton = new TH1F("hMinvPhoton","Invariant mass of e+e- pairs",200,0.,2.);\r
+\r
+  outputContainer->Add(fh1OpeningAngle);\r
+  outputContainer->Add(fh1MinvPhoton);\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
+  fhPtNPE = new TH1F("hPtNPE","Non-photonic Electron pT",nptbins,ptmin,ptmax);\r
+  fhPhiNPE = new TH2F("hPhiNPE","Non-photonic Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+  fhEtaNPE = new TH2F("hEtaNPE","Non-photonic Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+  fhPtPE = new TH1F("hPtPE","Photonic Electron pT",nptbins,ptmin,ptmax);\r
+  fhPhiPE = new TH2F("hPhiPE","Photonic Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+  fhEtaPE = new TH2F("hEtaPE","Photonic Electron eta vs. eta",nptbins,ptmin,ptmax,netabins,etamin,etamax);\r
+\r
+  outputContainer->Add(fhPtElectron) ; \r
+  outputContainer->Add(fhPhiElectron) ; \r
+  outputContainer->Add(fhEtaElectron) ;\r
+  outputContainer->Add(fhPtNPE) ; \r
+  outputContainer->Add(fhPhiNPE) ; \r
+  outputContainer->Add(fhEtaNPE) ;\r
+  outputContainer->Add(fhPtPE) ; \r
+  outputContainer->Add(fhPhiPE) ; \r
+  outputContainer->Add(fhEtaPE) ;\r
+\r
+  fhPtHadron = new TH1F("hPtHadron","Charged hadrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+  fhPtEleTrkDet = new TH1F("hPtEleTrkDet","Electrons identified by tracking detectors w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+\r
+  outputContainer->Add(fhPtHadron);\r
+  outputContainer->Add(fhPtEleTrkDet);\r
+\r
+  //event QA\r
+  fhImpactXY = new TH1F("hImpactXY","Impact parameter for all tracks",500,0.,100.);\r
+  fhRefMult = new TH1F("hRefMult" ,"refmult QA: " ,100,0,200);\r
+  fhRefMult2  = new TH1F("hRefMult2" ,"refmult2 QA: " ,100,0,200);\r
+\r
+  outputContainer->Add(fhImpactXY);\r
+  outputContainer->Add(fhRefMult);\r
+  outputContainer->Add(fhRefMult2);\r
+\r
+  //B-tagging\r
+  fhBtagCut1 = new TH2F("hbtag_cut1","B-tag result cut1", 10,0,10 ,nptbins,ptmin,ptmax);\r
+  fhBtagCut2 = new TH2F("hbtag_cut2","B-tag result cut2", 10,0,10 ,nptbins,ptmin,ptmax);\r
+  fhBtagCut3 = new TH2F("hbtag_cut3","B-tag result cut3", 10,0,10 ,nptbins,ptmin,ptmax);\r
+  fhBtagQA1  = new TH2F("hbtag_qa1" ,"B-tag QA: pairDCA vs length", 100,0,0.2 ,100,0,1.0);\r
+  fhBtagQA2  = new TH2F("hbtag_qa2" ,"B-tag QA: signDCA vs mass"  , 200,-0.5,0.5 ,100,0,10);\r
+  fhBtagQA3  = new TH1F("hbtag_qa3" ,"B-tag QA: ITS-Hits electron" ,7,0,7);\r
+  fhBtagQA4  = new TH1F("hbtag_qa4" ,"B-tag QA: IP d electron" ,100,0,3);\r
+  fhBtagQA5  = new TH1F("hbtag_qa5" ,"B-tag QA: IP z electron" ,100,0,3);\r
+\r
+  outputContainer->Add(fhBtagCut1) ;\r
+  outputContainer->Add(fhBtagCut2) ;\r
+  outputContainer->Add(fhBtagCut3) ;\r
+  outputContainer->Add(fhBtagQA1) ;\r
+  outputContainer->Add(fhBtagQA2) ;\r
+  outputContainer->Add(fhBtagQA3) ;\r
+  outputContainer->Add(fhBtagQA4) ;\r
+  outputContainer->Add(fhBtagQA5) ;\r
+\r
+  fhBJetXsiFF = new TH2F("hBJetXsiFF","B-jet #Xsi Frag. Fn.",100,0.,10.,100,0.,100.);\r
+  fhBJetPtFF = new TH2F("hBJetPtFF","B-jet p_{T} Frag. Fn.",nptbins,ptmin,ptmax,100,0.,100.);\r
+  fhBJetEtaPhi = new TH2F("hBJetEtaPhi","B-jet eta-phi distribution",netabins,etamin,etamax,nphibins,phimin,phimax);\r
+  fhNonBJetXsiFF = new TH2F("hNonBJetXsiFF","Non B-jet #Xsi Frag. Fn.",100,0.,10.,100,0.,100.);\r
+  fhNonBJetPtFF = new TH2F("hNonBJetPtFF","Non B-jet p_{T} Frag. Fn.",nptbins,ptmin,ptmax,100,0.,100.);\r
+  fhNonBJetEtaPhi = new TH2F("hNonBJetEtaPhi","Non B-jet eta-phi distribution",netabins,etamin,etamax,nphibins,phimin,phimax);\r
+\r
+  outputContainer->Add(fhBJetXsiFF);\r
+  outputContainer->Add(fhBJetPtFF);\r
+  outputContainer->Add(fhBJetEtaPhi);\r
+  outputContainer->Add(fhNonBJetXsiFF);\r
+  outputContainer->Add(fhNonBJetPtFF);\r
+  outputContainer->Add(fhNonBJetEtaPhi);\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
+    fhPtAll = new TH1F("hPtAll","All electron pT",nptbins,ptmin,ptmax);\r
+    fhPhiAll = new TH2F("hPhiAll","All Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+    fhEtaAll = new TH2F("hEtaAll","All 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
+    fhPtMisidentified = new TH1F("hPtMisidentified","Misidentified electron pT",nptbins,ptmin,ptmax);\r
+    fhPhiMisidentified = new TH2F("hPhiMisidentified","Misidentified Electron phi vs pT",nptbins,ptmin,ptmax,nphibins,phimin,phimax);\r
+    fhEtaMisidentified = new TH2F("hEtaMisidentified","Misidentified 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(fhPtAll);\r
+    outputContainer->Add(fhPhiAll);\r
+    outputContainer->Add(fhEtaAll);\r
+    outputContainer->Add(fhPtUnknown);\r
+    outputContainer->Add(fhPhiUnknown);\r
+    outputContainer->Add(fhEtaUnknown);\r
+    outputContainer->Add(fhPtMisidentified);\r
+    outputContainer->Add(fhPhiMisidentified);\r
+    outputContainer->Add(fhEtaMisidentified);\r
+    \r
+    //created ele ntuple for further analysis\r
+    if(fWriteNtuple) {\r
+      fMCEleNtuple = new TNtuple("MCEleNtuple","MC Electron Ntuple","mctag:pt:phi:eta:x:y:z");\r
+      outputContainer->Add(fMCEleNtuple) ;\r
+    }\r
+\r
+    fhPtMCHadron = new TH1F("hPtMCHadron","MC Charged hadrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCBottom = new TH1F("hPtMCBottom","MC Bottom electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCCharm = new TH1F("hPtMCCharm","MC Charm electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCCFromB = new TH1F("hPtMCCFromB","MC Charm from Bottom electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCConversion = new TH1F("hPtMCConversion","MC Conversion electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCDalitz  = new TH1F("hPtMCDalitz","MC Dalitz electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCWDecay = new TH1F("hPtMCWDecay","MC W Decay electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCZDecay = new TH1F("hPtMCZDecay","MC Z Decay electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+    fhPtMCUnknown = new TH1F("hPtMCUnknown","MC Unknown electrons w/in EMCAL acceptance",nptbins,ptmin,ptmax);\r
+\r
+    outputContainer->Add(fhPtMCHadron);\r
+    outputContainer->Add(fhPtMCBottom);\r
+    outputContainer->Add(fhPtMCCharm);\r
+    outputContainer->Add(fhPtMCCFromB);\r
+    outputContainer->Add(fhPtMCConversion);\r
+    outputContainer->Add(fhPtMCDalitz);\r
+    outputContainer->Add(fhPtMCWDecay);\r
+    outputContainer->Add(fhPtMCZDecay);\r
+    outputContainer->Add(fhPtMCUnknown);\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
+  sprintf(onePar,"---Btagging\n");\r
+  parList+=onePar ;\r
+  sprintf(onePar,"max IP-cut (e,h): %f\n",fImpactCut);\r
+  parList+=onePar ;\r
+  sprintf(onePar,"min ITS-hits: %d\n",fITSCut);\r
+  parList+=onePar ;\r
+  sprintf(onePar,"max dR (e,h): %f\n",fDrCut);\r
+  parList+=onePar ;\r
+  sprintf(onePar,"max pairDCA: %f\n",fPairDcaCut);\r
+  parList+=onePar ;\r
+  sprintf(onePar,"max decaylength: %f\n",fDecayLenCut);\r
+  parList+=onePar ;\r
+  sprintf(onePar,"min Associated Pt: %f\n",fAssocPtCut);\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
+  //do some initialization\r
+  if(fCalorimeter == "PHOS") {\r
+    printf("AliAnaElectron::Init() - !!STOP: You want to use PHOS in analysis but this is not (yet) supported!!\n!!Check the configuration file!!\n");\r
+    fCalorimeter = "EMCAL";\r
+  }\r
+  if(fCalorimeter == "EMCAL" && !GetReader()->IsEMCALSwitchedOn()){\r
+    printf("AliAnaElectron::Init() - !!STOP: 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
+  //B-tagging\r
+  fDrCut       = 1.0; \r
+  fPairDcaCut  = 0.02;\r
+  fDecayLenCut = 1.0;\r
+  fImpactCut   = 0.5;\r
+  fAssocPtCut  = 1.0;\r
+  fMassCut     = 1.5;\r
+  fSdcaCut     = 0.1;\r
+  fITSCut      = 4;\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
+  TObjArray *cl = new TObjArray();\r
+\r
+  Double_t bfield = 0.;\r
+  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) bfield = GetReader()->GetBField();\r
+\r
+  //Select the calorimeter of the electron\r
+  if(fCalorimeter != "EMCAL") {\r
+    printf("This class not yet implemented for PHOS\n");\r
+    abort();\r
+  }\r
+  cl = GetAODEMCAL();\r
+  \r
+  ////////////////////////////////////////////////\r
+  //Start from tracks and get associated clusters \r
+  ////////////////////////////////////////////////\r
+  if(!GetAODCTS() || GetAODCTS()->GetEntriesFast() == 0) return ;\r
+  Int_t ntracks = GetAODCTS()->GetEntriesFast();\r
+  Int_t refmult = 0; Int_t refmult2 = 0;\r
+  if(GetDebug() > 0)\r
+    printf("AliAnaElectron::MakeAnalysisFillAOD() - In CTS aod entries %d\n", ntracks);\r
+\r
+  //Unfortunately, AliAODTracks don't have associated EMCAL clusters.\r
+  //we have to redo track-matching, I guess\r
+  Int_t iCluster = -999;\r
+  Int_t bt = 0; //counter for event b-tags\r
+\r
+  for (Int_t itrk =  0; itrk <  ntracks; itrk++) {////////////// track loop\r
+    iCluster = -999; //start with no match\r
+    AliAODTrack * track = (AliAODTrack*) (GetAODCTS()->At(itrk)) ;\r
+    if (TMath::Abs(track->Eta())< 0.5) refmult++;\r
+    Double_t x[3];\r
+    Bool_t isNotDCA = track->GetPosition(x);\r
+    Double_t d1 = TMath::Sqrt(x[0]*x[0] + x[1]*x[1]);\r
+    if (TMath::Abs(track->Eta())< 0.5 && TMath::Abs(d1)<1.0 && TMath::Abs(x[2])<1.0) refmult2++;\r
+\r
+    AliAODPid* pid = (AliAODPid*) track->GetDetPid();\r
+    if(pid == 0) {\r
+      if(GetDebug() > 0) printf("AliAnaElectron::MakeAnalysisFillAOD() - No PID object - skipping track %d",itrk);\r
+      continue;\r
+    } else {\r
+      Double_t emcpos[3];\r
+      pid->GetEMCALPosition(emcpos);\r
+      Double_t emcmom[3];\r
+      pid->GetEMCALMomentum(emcmom);\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
+       Double_t dEdx = pid->GetTPCsignal();\r
+       \r
+       //NOTE:  As of 02-Sep-2009, the XYZAtDCA methods of AOD do not\r
+       //work, but it is possible to get the position of a track at\r
+       //closest approach to the vertex from the GetPosition method\r
+       Double_t xyz[3];\r
+       //track->XYZAtDCA(xyz);\r
+       isNotDCA = track->GetPosition(xyz);\r
+       if(isNotDCA) printf("##Problem getting impact parameter!\n");\r
+       //printf("\tTRACK POSITION AT DCA: %2.2f,%2.2f,%2.2f\n",xyz[0],xyz[1],xyz[2]);\r
+       Double_t xy = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);\r
+       Double_t z = xyz[2];\r
+       \r
+       Int_t ntot = cl->GetEntriesFast();\r
+       Double_t res = 999.;\r
+       Double_t pOverE = -999.;\r
+       \r
+       Int_t pidProb = track->GetMostProbablePID();\r
+       if(pidProb == AliAODTrack::kPion || pidProb == AliAODTrack::kKaon || pidProb == AliAODTrack::kProton) fhPtHadron->Fill(track->Pt());\r
+       if(pidProb == AliAODTrack::kElectron) fhPtEleTrkDet->Fill(track->Pt());\r
+       \r
+       Bool_t isElectron = kFALSE;      \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 < ntot; iclus++) {\r
+         AliAODCaloCluster * clus = (AliAODCaloCluster*) (cl->At(iclus));\r
+         if(!clus) continue;\r
+         \r
+         //Double_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
+         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
+         res = sqrt(dphi*dphi + deta*deta);\r
+         fh1dR->Fill(res);\r
+         \r
+         /////////////////////////////////\r
+         //Perform electron cut analysis//\r
+         /////////////////////////////////\r
+         //Good match\r
+         if(res < fResidualCut) {\r
+           fh2dEtadPhiMatched->Fill(deta,dphi);\r
+           iCluster = iclus;\r
+           \r
+           Int_t tmctag = -1;\r
+           Int_t cmctag = -1;\r
+           \r
+           if(IsDataMC()) {\r
+             //Input from second AOD?\r
+             Int_t input = 0;\r
+             if(GetReader()->GetAODCTSNormalInputEntries() <= itrk) input = 1;\r
+             tmctag = GetMCAnalysisUtils()->CheckOrigin(track->GetLabel(),GetReader(),input);\r
+             \r
+             //Do you want the cluster or the track label?\r
+             input = 0;\r
+             if(GetReader()->GetAODEMCALNormalInputEntries() <= iclus) input = 1;\r
+             cmctag = GetMCAnalysisUtils()->CheckOrigin(clus->GetLabel(0),GetReader(),input);\r
+           }\r
+           \r
+           if(fWriteNtuple) {\r
+             fEleNtuple->Fill(tmctag,cmctag,track->Pt(),track->Phi(),track->Eta(),track->P(),clus->E(),deta,dphi,clus->GetNCells(),dEdx,pidProb,xy,z);\r
+           }\r
+           \r
+           fh2MatchdEdx->Fill(track->P(),dEdx);\r
+           \r
+           Double_t energy = clus->E(); \r
+           if(energy > 0) pOverE = tmom/energy;\r
+           fh1pOverE->Fill(pOverE);\r
+           \r
+           Int_t mult = clus->GetNCells();\r
+           if(mult < 2 &&  GetDebug() > 0) printf("Single digit cluster.\n");\r
+           \r
+           //////////////////////////////\r
+           //Electron cuts happen here!//\r
+           //////////////////////////////\r
+           if(pOverE > fpOverEmin && pOverE < fpOverEmax) isElectron = kTRUE;\r
+         } else {\r
+           fh2dEtadPhiUnmatched->Fill(deta,dphi);\r
+         }\r
+         \r
+       } //calocluster loop\r
+       \r
+       ///////////////////////////\r
+       //Fill AOD with electrons//\r
+       ///////////////////////////\r
+       if(isElectron) {\r
+         \r
+         //B-tagging\r
+         if(GetDebug() > 1) printf("Found Electron - do b-tagging\n");\r
+         Int_t dvmbtag = GetBtag(track); bt += dvmbtag;\r
+         \r
+         fh2EledEdx->Fill(track->P(),dEdx);\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(track->GetLabel());\r
+         tr.SetCaloLabel(iCluster,-1); //sets the indices of the original caloclusters\r
+         tr.SetTrackLabel(itrk,-1); //sets the indices of the original tracks\r
+         tr.SetDetector(fCalorimeter);\r
+         if(GetReader()->GetAODCTSNormalInputEntries() <= itrk) tr.SetInputFileIndex(1);\r
+         //Make this preserve sign of particle\r
+         if(track->Charge() < 0) tr.SetPdg(11); //electron is 11\r
+         else  tr.SetPdg(-11); //positron is -11\r
+         Int_t btag = -1;\r
+         if(dvmbtag > 0) tr.SetBTagBit(btag,tr.kDVMTag0);\r
+         if(dvmbtag > 1) tr.SetBTagBit(btag,tr.kDVMTag1);\r
+         if(dvmbtag > 2) tr.SetBTagBit(btag,tr.kDVMTag2);\r
+         tr.SetBtag(btag);\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
+           //JLK DO WE WANT TRACK TAG OR CLUSTER TAG?\r
+           tr.SetTag(GetMCAnalysisUtils()->CheckOrigin(tr.GetLabel(),GetReader(),tr.GetInputFileIndex()));\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
+    }//pid check\r
+  }//track loop                         \r
+  \r
+  //FIXME:  Should we also check from the calocluster side, just in\r
+  //case?\r
+  fhRefMult->Fill(refmult);\r
+  fhRefMult2->Fill(refmult2);\r
+\r
+  if(GetDebug() > 1 && bt > 0) printf("AliAnaElectron::MakeAnalysisFillAOD() *** Event Btagged *** \n");\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
+  AliStack * stack = 0x0;\r
+  TParticle * primary = 0x0;\r
+  TClonesArray * mcparticles0 = 0x0;\r
+  TClonesArray * mcparticles1 = 0x0;\r
+  AliAODMCParticle * aodprimary = 0x0;\r
+\r
+  if(IsDataMC()) {\r
+    if(GetReader()->ReadStack()){\r
+      stack =  GetMCStack() ;\r
+      \r
+      if(!stack)\r
+       printf("AliAnaElectron::MakeAnalysisFillHistograms() *** no stack ***: \n");\r
+      \r
+    }\r
+    else if(GetReader()->ReadAODMCParticles()){\r
+      //Get the list of MC particles\r
+      mcparticles0 = GetReader()->GetAODMCParticles(0);\r
+      if(!mcparticles0 && GetDebug() > 0)     {\r
+       printf("AliAnaElectron::MakeAnalysisFillHistograms() -  Standard MCParticles not available!\n");\r
+      }\r
+      if(GetReader()->GetSecondInputAODTree()){\r
+       mcparticles1 = GetReader()->GetAODMCParticles(1);\r
+       if(!mcparticles1 && GetDebug() > 0)     {\r
+         printf("AliAnaElectron::MakeAnalysisFillHistograms() -  Second input MCParticles not available!\n");\r
+       }\r
+      }\r
+      \r
+    }\r
+  }// is data and MC\r
+\r
+  ////////////////////////////////////\r
+  //Loop over jets and check for b-tag\r
+  ////////////////////////////////////\r
+  Int_t njets = (GetReader()->GetOutputEvent())->GetNJets();\r
+  if(njets > 0) {\r
+    if(GetDebug() > 0) printf("AliAnaElectron::MakeAnalysisFillHistograms() - Jet AOD branch has %d jets.  Performing b-jet tag analysis",njets);\r
+    \r
+    for(Int_t ijet = 0; ijet < njets ; ijet++) {\r
+      AliAODJet * jet = (AliAODJet*)(GetReader()->GetOutputEvent())->GetJet(ijet) ;\r
+      if(GetDebug() > 3) {\r
+       printf("AliAODJet ijet = %d\n",ijet);\r
+       jet->Print("");\r
+      }\r
+      //Assuming that they fixed the problem of track references in\r
+      //AliAODJet not being filled, we will loop over the tracks and\r
+      //see which ones were tagged as electrons\r
+      Bool_t bjet = kFALSE;  //We'll check the jet's tracks to see if this is a bjet candidate\r
+      TRefArray* rt = jet->GetRefTracks();\r
+      Int_t ntrk = rt->GetEntries();\r
+      for(Int_t itrk = 0; itrk < ntrk; itrk++) {\r
+       AliAODTrack* jetTrack = (AliAODTrack*)jet->GetTrack(itrk);\r
+       Bool_t isNPE = CheckTrack(jetTrack);\r
+       if(isNPE) bjet = kTRUE;\r
+      }\r
+      for(Int_t itrk = 0; itrk < ntrk; itrk++) {\r
+       AliAODTrack* jetTrack = (AliAODTrack*)jet->GetTrack(itrk);\r
+       Double_t xsi = TMath::Log(jet->Pt()/jetTrack->Pt());\r
+       if(bjet) {\r
+         printf("We have a winner!\n");\r
+         //Fill bjet histograms here\r
+         fhBJetXsiFF->Fill(xsi,jet->Pt());\r
+         fhBJetPtFF->Fill(jetTrack->Pt(),jet->Pt());\r
+         fhBJetEtaPhi->Fill(jet->Eta(),jet->Phi());\r
+       } else {\r
+         //Fill non-bjet histograms here\r
+         fhNonBJetXsiFF->Fill(xsi,jet->Pt());\r
+         fhNonBJetPtFF->Fill(jetTrack->Pt(),jet->Pt());\r
+         fhNonBJetEtaPhi->Fill(jet->Eta(),jet->Phi());\r
+       }\r
+      }\r
+    } //jet loop\r
+  } //jets exist\r
+  \r
+  //////////////////////////////\r
+  //Loop on stored AOD electrons\r
+  //////////////////////////////\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(TMath::Abs(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
+    //Filter for photonic electrons based on opening angle and Minv\r
+    //cuts, also fill histograms\r
+    Bool_t photonic = kFALSE;\r
+    photonic = IsItPhotonic(ele);\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(photonic) {\r
+      fhPtPE->Fill(ptele);\r
+      fhPhiPE->Fill(ptele,phiele);\r
+      fhEtaPE->Fill(ptele,etaele);\r
+    } else {\r
+      fhPtNPE->Fill(ptele);\r
+      fhPhiNPE->Fill(ptele,phiele);\r
+      fhEtaNPE->Fill(ptele,etaele);\r
+    }\r
+\r
+    if(IsDataMC()){\r
+      Int_t tag = ele->GetTag();\r
+      if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCElectron)) {\r
+       fhPtAll  ->Fill(ptele);\r
+       fhPhiAll ->Fill(ptele,phiele);\r
+       fhEtaAll ->Fill(ptele,etaele);    \r
+\r
+       if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCConversion)){\r
+         fhPtConversion  ->Fill(ptele);\r
+         fhPhiConversion ->Fill(ptele,phiele);\r
+         fhEtaConversion ->Fill(ptele,etaele);\r
+       }\r
+       else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEFromB)){\r
+         fhPtBottom  ->Fill(ptele);\r
+         fhPhiBottom ->Fill(ptele,phiele);\r
+         fhEtaBottom ->Fill(ptele,etaele);\r
+       }\r
+       else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEFromC)){\r
+         fhPtCharm  ->Fill(ptele);\r
+         fhPhiCharm ->Fill(ptele,phiele);\r
+         fhEtaCharm ->Fill(ptele,etaele);\r
+       }\r
+       else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEFromCFromB)){\r
+         fhPtCFromB  ->Fill(ptele);\r
+         fhPhiCFromB ->Fill(ptele,phiele);\r
+         fhEtaCFromB ->Fill(ptele,etaele);\r
+       }\r
+       else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCPi0Decay) || GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCEtaDecay) || GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCOtherDecay)) {\r
+         fhPtDalitz  ->Fill(ptele);\r
+         fhPhiDalitz ->Fill(ptele,phiele);\r
+         fhEtaDalitz ->Fill(ptele,etaele);\r
+       }\r
+       else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCWDecay)) {\r
+         fhPtWDecay  ->Fill(ptele);\r
+         fhPhiWDecay ->Fill(ptele,phiele);\r
+         fhEtaWDecay ->Fill(ptele,etaele);\r
+       }\r
+       else if(GetMCAnalysisUtils()->CheckTagBit(tag,AliMCAnalysisUtils::kMCZDecay)) {\r
+         fhPtZDecay  ->Fill(ptele);\r
+         fhPhiZDecay ->Fill(ptele,phiele);\r
+         fhEtaZDecay ->Fill(ptele,etaele);\r
+       } \r
+       else {\r
+         fhPtUnknown  ->Fill(ptele);\r
+         fhPhiUnknown ->Fill(ptele,phiele);\r
+         fhEtaUnknown ->Fill(ptele,etaele);\r
+       }\r
+       //not electron:\r
+      } else {\r
+       fhPtMisidentified  ->Fill(ptele);\r
+        fhPhiMisidentified ->Fill(ptele,phiele);\r
+        fhEtaMisidentified ->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
+    if(GetReader()->ReadStack()) {\r
+      for(Int_t ipart = 0; ipart < stack->GetNtrack(); ipart++) {\r
+       primary = stack->Particle(ipart);\r
+       TLorentzVector mom;\r
+       primary->Momentum(mom);\r
+       Bool_t in = GetFidutialCut()->IsInFidutialCut(mom,fCalorimeter);\r
+       if(primary->Pt() < GetMinPt()) continue;\r
+       if(!in) continue;\r
+\r
+       Int_t pdgcode = primary->GetPdgCode();\r
+       if(TMath::Abs(pdgcode) == 211 || TMath::Abs(pdgcode) == 321 || TMath::Abs(pdgcode) == 2212)\r
+         fhPtMCHadron->Fill(primary->Pt());\r
+\r
+       //we only care about electrons\r
+       if(TMath::Abs(pdgcode) != 11) continue;\r
+       //we only want TRACKABLE electrons (TPC 85-250cm)\r
+       if(primary->R() > 200.) continue;\r
+       //Ignore low pt electrons\r
+       if(primary->Pt() < 0.2) continue;\r
+       \r
+       //find out what the ancestry of this electron is\r
+       Int_t mctag = -1;\r
+       Int_t input = 0;\r
+       mctag = GetMCAnalysisUtils()->CheckOrigin(ipart,GetReader(),input);\r
+\r
+       //fill ntuple\r
+       if(fWriteNtuple) {\r
+         fMCEleNtuple->Fill(mctag,primary->Pt(),primary->Phi(),primary->Eta(),primary->Vx(),primary->Vy(),primary->Vz());\r
+       }\r
+       if(!GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCConversion)) {\r
+         if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEFromB))\r
+           fhPtMCBottom->Fill(primary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEFromC))\r
+           fhPtMCCharm->Fill(primary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEFromCFromB))\r
+           fhPtMCCFromB->Fill(primary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCWDecay))\r
+           fhPtMCWDecay->Fill(primary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCZDecay))\r
+           fhPtMCZDecay->Fill(primary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCPi0Decay) \r
+                 || GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEtaDecay)\r
+                 || GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCOtherDecay))\r
+           fhPtMCDalitz->Fill(primary->Pt());\r
+         else \r
+           fhPtMCUnknown->Fill(primary->Pt());\r
+       } else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCConversion)) {\r
+         fhPtMCConversion->Fill(primary->Pt());\r
+       }\r
+      }      \r
+    } else if(GetReader()->ReadAODMCParticles()) {\r
+      Int_t npart0 = mcparticles0->GetEntriesFast();\r
+      Int_t npart1 = 0;\r
+      if(mcparticles1) npart1 = mcparticles1->GetEntriesFast();\r
+      Int_t npart = npart0+npart1;\r
+      for(Int_t ipart = 0; ipart < npart; ipart++) {\r
+       if(ipart < npart0) aodprimary = (AliAODMCParticle*)mcparticles0->At(ipart);\r
+       else aodprimary = (AliAODMCParticle*)mcparticles1->At(ipart-npart0);\r
+       if(!aodprimary) {\r
+         printf("AliAnaElectron::MakeAnalysisFillHistograms() *** no primary ***:  label %d \n", ipart);\r
+         continue;\r
+       }\r
+\r
+       Double_t mom[3] = {0.,0.,0.};\r
+       aodprimary->PxPyPz(mom);\r
+       TLorentzVector mom2(mom,0.);    \r
+       Bool_t in = GetFidutialCut()->IsInFidutialCut(mom2,fCalorimeter);\r
+       if(aodprimary->Pt() < GetMinPt()) continue;\r
+       if(!in) continue;\r
+\r
+       Int_t pdgcode = aodprimary->GetPdgCode();\r
+       if(TMath::Abs(pdgcode) == 211 || TMath::Abs(pdgcode) == 321 || TMath::Abs(pdgcode) == 2212)\r
+         fhPtMCHadron->Fill(aodprimary->Pt());\r
+\r
+       //we only care about electrons\r
+       if(TMath::Abs(pdgcode) != 11) continue;\r
+       //we only want TRACKABLE electrons (TPC 85-250cm)\r
+       Double_t radius = TMath::Sqrt(aodprimary->Xv()*aodprimary->Xv() + aodprimary->Yv()*aodprimary->Yv());\r
+       if(radius > 200.) continue;\r
+\r
+       //find out what the ancestry of this electron is\r
+       Int_t mctag = -1;\r
+       Int_t input = 0;\r
+       Int_t ival = ipart;\r
+       if(ipart > npart0) { ival -= npart0; input = 1;}\r
+       mctag = GetMCAnalysisUtils()->CheckOrigin(ival,GetReader(),input);\r
+       \r
+       //fill ntuple\r
+       if(fWriteNtuple) {\r
+         fMCEleNtuple->Fill(mctag,aodprimary->Pt(),aodprimary->Phi(),aodprimary->Eta(),aodprimary->Xv(),aodprimary->Yv(),aodprimary->Zv());\r
+       }\r
+       if(!GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCConversion)) {\r
+         if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEFromB))\r
+           fhPtMCBottom->Fill(aodprimary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEFromC))\r
+           fhPtMCCharm->Fill(aodprimary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEFromCFromB))\r
+           fhPtMCCFromB->Fill(aodprimary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCWDecay))\r
+           fhPtMCWDecay->Fill(aodprimary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCZDecay))\r
+           fhPtMCZDecay->Fill(aodprimary->Pt());\r
+         else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCPi0Decay) \r
+                 || GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCEtaDecay)\r
+                 || GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCOtherDecay))\r
+           fhPtMCDalitz->Fill(aodprimary->Pt());\r
+         else \r
+           fhPtMCUnknown->Fill(aodprimary->Pt());\r
+       } else if(GetMCAnalysisUtils()->CheckTagBit(mctag,AliMCAnalysisUtils::kMCConversion)) {\r
+         fhPtMCConversion->Fill(aodprimary->Pt());\r
+       }       \r
+      }\r
+    }\r
+  } //pure MC kine histos\r
+    \r
+}\r
+\r
+//__________________________________________________________________\r
+Int_t AliAnaElectron::GetBtag(AliAODTrack * tr )\r
+{\r
+  //This method uses the Displaced Vertex between electron-hadron\r
+  //pairs and the primary vertex to determine whether an electron is\r
+  //likely from a B hadron.\r
+\r
+  Int_t ncls1 = 0;\r
+  for(Int_t l = 0; l < 6; l++) if(TESTBIT(tr->GetITSClusterMap(),l)) ncls1++;\r
+\r
+  fhBtagQA3->Fill(ncls1);\r
+  if (ncls1 < fITSCut) return 0;\r
+\r
+  Double_t x[3];\r
+  //Note: 02-Sep-2009, Must use GetPosition, not XYZAtDCA\r
+  //Bool_t gotit = tr->XYZAtDCA(x);\r
+  Bool_t isNotDCA = tr->GetPosition(x);\r
+  if(isNotDCA) { printf("##Problem getting impact parameter!\n"); return 0; }\r
+\r
+  Double_t d1 = TMath::Sqrt(x[0]*x[0] + x[1]*x[1]);\r
+  fhBtagQA4->Fill(TMath::Abs(d1));\r
+  if (TMath::Abs(d1)   > fImpactCut ) return 0;\r
+  fhBtagQA5->Fill(TMath::Abs(x[2]));\r
+  //  if (TMath::Abs(x[2]) > fImpactCut ) return 0;\r
+  //printf("----- impact parameter: x=%f, y=%f, z=%f -------\n",x[0],x[1], x[2]);\r
+\r
+  Int_t nvtx1 = 0;\r
+  Int_t nvtx2 = 0;\r
+  Int_t nvtx3 = 0;\r
+\r
+  for (Int_t k2 =0; k2 < GetAODCTS()->GetEntriesFast() ; k2++) {\r
+    //loop over assoc\r
+    AliAODTrack* track2 = (AliAODTrack*) (GetAODCTS()->At(k2));\r
+    Int_t id1 = tr->GetID();\r
+    Int_t id2 = track2->GetID();\r
+    if(id1 == id2) continue;\r
+\r
+    Int_t ncls2 = 0;\r
+    for(Int_t l = 0; l < 6; l++) if(TESTBIT(track2->GetITSClusterMap(),l)) ncls2++;\r
+    if (ncls2 < fITSCut) continue;\r
+\r
+    if(track2->Pt() < fAssocPtCut) continue;\r
+\r
+    Double_t dphi = tr->Phi() - track2->Phi();\r
+    if(dphi > TMath::Pi()) dphi -= 2*TMath::Pi();\r
+    if(dphi < -TMath::Pi()) dphi += 2*TMath::Pi();\r
+    Double_t deta = tr->Eta() - track2->Eta();\r
+    Double_t dr = sqrt(deta*deta + dphi*dphi);\r
+\r
+    if(dr > fDrCut) continue;\r
+    \r
+    Double_t sDca1 = ComputeSignDca(tr, track2, 1.0);\r
+    if (sDca1 > fSdcaCut) nvtx1++;\r
+    Double_t sDca2 = ComputeSignDca(tr, track2, 1.5);\r
+    if (sDca2 > fSdcaCut) nvtx2++;\r
+    Double_t sDca3 = ComputeSignDca(tr, track2, 1.8);\r
+    if (sDca3 > fSdcaCut) nvtx3++;\r
+\r
+  } //loop over hadrons\r
+\r
+  if(GetDebug() > 0) {\r
+    if (nvtx1>0) printf("result1 of btagging: %d \n",nvtx1);\r
+    if (nvtx2>0) printf("result2 of btagging: %d \n",nvtx2);\r
+    if (nvtx3>0) printf("result3 of btagging: %d \n",nvtx3);\r
+  }\r
+\r
+  //fill QA histograms\r
+  fhBtagCut1->Fill(nvtx1,tr->Pt());\r
+  fhBtagCut2->Fill(nvtx2,tr->Pt());\r
+  fhBtagCut3->Fill(nvtx3,tr->Pt());\r
+\r
+  return nvtx2;\r
+\r
+}\r
+\r
+//__________________________________________________________________\r
+Double_t AliAnaElectron::ComputeSignDca(AliAODTrack *tr, AliAODTrack *tr2 , float masscut)\r
+{\r
+  //Compute the signed dca between two tracks\r
+  //and return the result\r
+\r
+  Double_t signDca=-999.;\r
+  if(GetDebug() > 2 ) printf(">>ComputeSdca:: track1 %d, track2 %d, masscut %f \n", tr->GetLabel(), tr2->GetLabel(), masscut);\r
+\r
+  //=====Now calculate DCA between both tracks=======  \r
+  Double_t massE = 0.000511;\r
+  Double_t massK = 0.493677;\r
+\r
+  Double_t bfield = 5.; //kG\r
+  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) bfield = GetReader()->GetBField();\r
+\r
+  Double_t vertex[3] = {-999.,-999.,-999}; //vertex\r
+  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) {\r
+    GetReader()->GetVertex(vertex); //If only one file, get the vertex from there\r
+    //FIXME:  Add a check for whether file 2 is PYTHIA or HIJING\r
+    //If PYTHIA, then set the vertex from file 2, if not, use the\r
+    //vertex from file 1\r
+    if(GetReader()->GetSecondInputAODTree()) GetReader()->GetSecondInputAODVertex(vertex);\r
+  }\r
+  \r
+  TVector3 primV(vertex[0],vertex[1],vertex[2]) ;\r
+\r
+  if(GetDebug() > 5) printf(">>ComputeSdca:: primary vertex = %2.2f,%2.2f,%2.2f \n",vertex[0],vertex[1],vertex[2]) ;\r
+\r
+  AliExternalTrackParam *param1 = new AliExternalTrackParam(tr);\r
+  AliExternalTrackParam *param2 = new AliExternalTrackParam(tr2);\r
+\r
+  Double_t xplane1 = 0.; Double_t xplane2 = 0.;\r
+  Double_t pairdca = param1->GetDCA(param2,bfield,xplane1,xplane2);\r
+\r
+  Int_t id1 = 0, id2 = 0;\r
+  AliESDv0 bvertex(*param1,id1,*param2,id2);\r
+  Double_t vx,vy,vz;\r
+  bvertex.GetXYZ(vx,vy,vz);\r
+\r
+  Double_t emom[3];\r
+  Double_t hmom[3];\r
+  param1->PxPyPz(emom);\r
+  param2->PxPyPz(hmom);\r
+  TVector3 emomAtB(emom[0],emom[1],emom[2]);\r
+  TVector3 hmomAtB(hmom[0],hmom[1],hmom[2]);\r
+  TVector3 secvtxpt(vx,vy,vz);\r
+  TVector3 decayvector(0,0,0);\r
+  decayvector = secvtxpt - primV; //decay vector from PrimVtx\r
+  Double_t decaylength = decayvector.Mag();\r
+\r
+  if(GetDebug() > 0) {\r
+    printf(">>ComputeSdca:: mom1=%f, mom2=%f \n", emomAtB.Perp(), hmomAtB.Perp() );\r
+    printf(">>ComputeSdca:: pairDCA=%f, length=%f \n", pairdca,decaylength );\r
+  }\r
+\r
+  if (masscut<1.1) fhBtagQA1->Fill(pairdca,decaylength);\r
+\r
+  if (emomAtB.Mag()>0 && pairdca < fPairDcaCut && decaylength < fDecayLenCut ) {\r
+    TVector3 sumMom = emomAtB+hmomAtB;\r
+    Double_t ener1 = sqrt(pow(emomAtB.Mag(),2) + massE*massE);\r
+    Double_t ener2 = sqrt(pow(hmomAtB.Mag(),2) + massK*massK);\r
+    Double_t ener3 = sqrt(pow(hmomAtB.Mag(),2) + massE*massE);\r
+    Double_t mass = sqrt(pow((ener1+ener2),2) - pow(sumMom.Mag(),2));\r
+    Double_t massPhot = sqrt(pow((ener1+ener3),2) - pow(sumMom.Mag(),2));\r
+    Double_t sDca = decayvector.Dot(emomAtB)/emomAtB.Mag();\r
+\r
+    if (masscut<1.1) fhBtagQA2->Fill(sDca, mass);\r
+\r
+    if (mass > masscut && massPhot > 0.1) signDca = sDca;\r
+    \r
+    if(GetDebug() > 0) printf("\t>>ComputeSdca:: mass=%f \n", mass);\r
+    if(GetDebug() > 0) printf("\t>>ComputeSdca:: sec vtx-signdca :%f\n",signDca);\r
+  }\r
+\r
+  //clean up\r
+  delete param1;\r
+  delete param2;\r
+\r
+  return signDca;\r
+}\r
+\r
+//__________________________________________________________________\r
+Bool_t AliAnaElectron::IsItPhotonic(const AliAODPWG4Particle* part) \r
+{\r
+  //This method checks the opening angle and invariant mass of\r
+  //electron pairs to see if they are likely to be photonic electrons\r
+\r
+  Bool_t itIS = kFALSE;\r
+\r
+  Double_t massE = 0.000511;\r
+  Double_t bfield = 5.; //kG\r
+  if(GetReader()->GetDataType() != AliCaloTrackReader::kMC) bfield = GetReader()->GetBField();\r
+\r
+  Int_t pdg1 = part->GetPdg();\r
+  Int_t trackId = part->GetTrackLabel(0);\r
+  AliAODTrack* track = (AliAODTrack*)GetAODCTS()->At(trackId);\r
+  if(!track) {\r
+    if(GetDebug() > 0) printf("AliAnaElectron::IsItPhotonic - can't get the AOD Track from the particle!  Skipping the photonic check");\r
+    return kFALSE; //Don't proceed because we can't get the track\r
+  }\r
+\r
+  AliExternalTrackParam *param1 = new AliExternalTrackParam(track);\r
+\r
+  //Loop on stored AOD electrons and compute the angle differences and Minv\r
+  for (Int_t k2 =0; k2 < GetOutputAODBranch()->GetEntriesFast() ; k2++) {\r
+    AliAODPWG4Particle* part2 = (AliAODPWG4Particle*) GetOutputAODBranch()->At(k2);\r
+    Int_t track2Id = part2->GetTrackLabel(0);\r
+    if(trackId == track2Id) continue;\r
+    Int_t pdg2 = part2->GetPdg();\r
+    if(TMath::Abs(pdg2) != AliCaloPID::kElectron) continue;\r
+    if(part2->GetDetector() != fCalorimeter) continue;\r
+\r
+    //JLK: Check opp. sign pairs only\r
+    if(pdg1*pdg2 > 0) continue; //skip same-sign pairs\r
+\r
+    //propagate to common vertex and check opening angle\r
+    AliAODTrack* track2 = (AliAODTrack*)GetAODCTS()->At(track2Id);\r
+    if(!track2) {\r
+      if(GetDebug() >0) printf("AliAnaElectron::IsItPhotonic - problem getting the partner track.  Continuing on to the next one");\r
+      continue;\r
+    }\r
+    AliExternalTrackParam *param2 = new AliExternalTrackParam(track2);\r
+    Int_t id1 = 0, id2 = 0;\r
+    AliESDv0 photonVtx(*param1,id1,*param2,id2);\r
+    Double_t vx,vy,vz;\r
+    photonVtx.GetXYZ(vx,vy,vz);\r
+\r
+    Double_t p1mom[3];\r
+    Double_t p2mom[3];\r
+    param1->PxPyPz(p1mom);\r
+    param2->PxPyPz(p2mom);\r
+\r
+    TVector3 p1momAtB(p1mom[0],p1mom[1],p1mom[2]);\r
+    TVector3 p2momAtB(p2mom[0],p2mom[1],p2mom[2]);\r
+    TVector3 sumMom = p1momAtB+p2momAtB;\r
+\r
+    Double_t ener1 = sqrt(pow(p1momAtB.Mag(),2) + massE*massE);\r
+    Double_t ener2 = sqrt(pow(p2momAtB.Mag(),2) + massE*massE);\r
+    Double_t mass = sqrt(pow((ener1+ener2),2) - pow(sumMom.Mag(),2));\r
+\r
+    Double_t dphi = p1momAtB.DeltaPhi(p2momAtB);\r
+    fh1OpeningAngle->Fill(dphi);\r
+    fh1MinvPhoton->Fill(mass);\r
+\r
+    if(mass < 0.1) {\r
+      if(GetDebug() > 0) printf("######PROBABLY A PHOTON\n");\r
+      itIS = kTRUE;\r
+    }\r
+\r
+    //clean up\r
+    delete param2;\r
+\r
+  }\r
+\r
+  delete param1;\r
+  return itIS;\r
+\r
+}\r
+\r
+//__________________________________________________________________\r
+Bool_t AliAnaElectron::CheckTrack(const AliAODTrack* track) \r
+{\r
+  //Check this track to see if it is also tagged as an electron in the\r
+  //AliAODPWG4Particle list and if it is non-photonic\r
+\r
+  Bool_t isNPE = kFALSE;\r
+\r
+  Int_t trackId = track->GetID(); //get the index in the reader\r
+\r
+  Int_t naod = GetOutputAODBranch()->GetEntriesFast();\r
+  if(GetDebug() > 3) printf("AliAnaElectron::CheckTrack() - aod branch entries %d\n", naod);\r
+  for(Int_t iaod = 0; iaod < naod ; iaod++){\r
+    AliAODPWG4Particle* ele =  (AliAODPWG4Particle*) (GetOutputAODBranch()->At(iaod));\r
+    Int_t label = ele->GetTrackLabel(0);\r
+    if(label != trackId) continue;  //skip to the next one if they don't match\r
+\r
+    isNPE = kTRUE;\r
+  }\r
+\r
+  return isNPE;\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("---Btagging\n");\r
+  printf("max IP-cut (e,h)       =     %f\n",fImpactCut);\r
+  printf("min ITS-hits           =     %d\n",fITSCut);\r
+  printf("max dR (e,h)           =     %f\n",fDrCut);\r
+  printf("max pairDCA            =     %f\n",fPairDcaCut);\r
+  printf("max decaylength        =     %f\n",fDecayLenCut);\r
+  printf("min Associated Pt      =     %f\n",fAssocPtCut);\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: %d outputs\n", GetName(), outputList->GetEntries()) ;\r
+\r
+}\r
+\r
index 513418d..13727d1 100755 (executable)
-#ifndef ALIANAELECTRON_H
-#define ALIANAELECTRON_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice     */
-/* $Id:  $ */
-
-//_________________________________________________________________________
-//
-// Class for the electron identification.
-// Clusters from EMCAL matched to tracks are selected 
-// and kept in the AOD. Few histograms produced.
-//
-
-//-- Author: J.L. Klay (Cal Poly)
-
-// --- ROOT system ---
-class TH2F ;
-class TString ;
-class TNtuple ;
-class TH3F;
-
-// --- ANALYSIS system ---
-#include "AliAnaPartCorrBaseClass.h"
-
-class AliCaloTrackReader;
-class AliAODTrack;
-class TList ;
-
-class AliAnaElectron : public AliAnaPartCorrBaseClass {
-
-public: 
-
-  AliAnaElectron() ; // default ctor
-  AliAnaElectron(const AliAnaElectron & g) ; // cpy ctor
-  AliAnaElectron & operator = (const AliAnaElectron & g) ;//cpy assignment
-  virtual ~AliAnaElectron() ; //virtual dtor
-  
-  TList *  GetCreateOutputObjects();
-
-  void Init();
-
-  void MakeAnalysisFillAOD()  ;
-  
-  void MakeAnalysisFillHistograms() ; 
-  
-  //B-tagging
-  Double_t ComputeSignDca(AliAODTrack *track, AliAODTrack *track2 , float cut1);
-  Int_t GetBtag(AliAODTrack * tr);
-
-  Bool_t IsItPhotonic(const AliAODPWG4Particle* part);
-
-  void Print(const Option_t * opt)const;
-  
-  TString GetCalorimeter()   const {return fCalorimeter ; }
-  Double_t GetpOverEmin()   const {return fpOverEmin ; }
-  Double_t GetpOverEmax()   const {return fpOverEmax ; }
-  Bool_t GetWriteNtuple()   const {return fWriteNtuple ; }
-
-  Double_t GetDrCut() const { return fDrCut; }
-  Double_t GetPairDcaCut() const { return fPairDcaCut; }
-  Double_t GetDecayLenCut() const { return fDecayLenCut; }
-  Double_t GetImpactCut() const { return fImpactCut; }
-  Double_t GetAssocPtCut() const { return fAssocPtCut; }
-  Double_t GetMassCut() const { return fMassCut; }
-  Double_t GetSdcaCut() const { return fSdcaCut; }
-  Int_t   GetITSCut() const { return fITSCut; }
-
-  void SetCalorimeter(TString det)    {fCalorimeter = det ; }
-  void SetpOverEmin(Double_t min)     {fpOverEmin = min ; }
-  void SetpOverEmax(Double_t max)     {fpOverEmax = max ; }
-  void SetResidualCut(Double_t cut)     {fResidualCut = cut ; }
-  void SetWriteNtuple(Bool_t val)     {fWriteNtuple = val ; }
-
-  void SetDrCut(Double_t dr)  { fDrCut = dr; }
-  void SetPairDcaCut(Double_t pdca) { fPairDcaCut = pdca; }
-  void SetDecayLenCut(Double_t dlen) { fDecayLenCut = dlen; }
-  void SetImpactCut(Double_t imp) { fImpactCut = imp; }
-  void SetAssocPtCut(Double_t pt) { fAssocPtCut = pt; }
-  void SetMassCut(Double_t mass) { fMassCut = mass; }
-  void SetSdcaCut(Double_t sdca) { fSdcaCut = sdca; }
-  void SetITSCut(Int_t its) { fITSCut = its; }
-
-  void InitParameters();
-
-  void Terminate(TList * outputList);
-  void ReadHistograms(TList * outputList); //Fill histograms with
-                                          //histograms in ouput list,
-                                          //needed in Terminate.            
-
-  private:
-  TString  fCalorimeter;  //! Which detector? EMCAL or PHOS
-  Double_t fpOverEmin;    //! Minimum p/E value for Electrons
-  Double_t fpOverEmax;    //! Maximum p/E value for Electrons
-  Double_t fResidualCut;  //! Track-cluster matching distance
-
-  //B-tagging
-  Double_t fDrCut;       //max dR
-  Double_t fPairDcaCut;  //max pair-DCA
-  Double_t fDecayLenCut; //max 3d-decaylength
-  Double_t fImpactCut;   //max track impact param
-  Double_t fAssocPtCut;  //min associated pt
-  Double_t fMassCut;     //min Minv cut
-  Double_t fSdcaCut;     //min signDca
-  Int_t   fITSCut;       //min ITS hits (both)
-
-  Bool_t  fWriteNtuple; //flag for filling ntuple or not
-
-  TNtuple* fEleNtuple; //! testing ntuple
-
-  //matching checks   
-  TH1F *fh1pOverE;     //! p/E for track-cluster matches
-  TH1F *fh1dR;         //! distance between projected track and cluster
-  TH2F *fh2EledEdx;    //! dE/dx vs. momentum for electron candidates
-  TH2F *fh2MatchdEdx;  //! dE/dx vs. momentum for all matches
-  TH2F *fh2dEtadPhi;   //! DeltaEta vs. DeltaPhi of all track/cluster
-                      //! pairs
-  TH2F *fh2dEtadPhiMatched;   //! DeltaEta vs. DeltaPhi of matched
-                               //! track/cluster pairs
-  TH2F *fh2dEtadPhiUnmatched;   //! DeltaEta vs. DeltaPhi of unmatched track/cluster pairs
-
-  TH2F* fh2TrackPVsClusterE;     //!track momentum vs. cluster energy
-  TH2F* fh2TrackPtVsClusterE;    //!track pt vs. cluster energy
-  TH2F* fh2TrackPhiVsClusterPhi; //!track phi vs. cluster phi
-  TH2F* fh2TrackEtaVsClusterEta; //!track eta vs. cluster eta
-
-  //Photonic Electron checks
-  TH1F* fh1OpeningAngle; //!opening angle between pairs of photon candidates
-  TH1F* fh1MinvPhoton;   //!invariant mass distribution of electron pairs
-
-  //Reconstructed
-  TH1F * fhPtElectron;  //! Number of identified electron vs transverse momentum 
-  TH2F * fhPhiElectron; //! Azimuthal angle of identified  electron vs transverse momentum 
-  TH2F * fhEtaElectron; //! Pseudorapidity of identified  electron vs tranvserse momentum 
-
-  TH1F * fhPtNPE;  //! Number of non-photonic electron vs transverse momentum 
-  TH2F * fhPhiNPE; //! Azimuthal angle of non-photonic electron vs transverse momentum 
-  TH2F * fhEtaNPE; //! Pseudorapidity of non-photonic electron vs tranvserse momentum 
-
-  TH1F * fhPtPE;  //! Number of photonic electron vs transverse momentum 
-  TH2F * fhPhiPE; //! Azimuthal angle of photonic electron vs transverse momentum 
-  TH2F * fhEtaPE; //! Pseudorapidity of photonic electron vs tranvserse momentum 
-
-  TH1F * fhPtConversion;  //! Number of conversion electron vs transverse momentum 
-  TH2F * fhPhiConversion; //! Azimuthal angle of conversion  electron vs transverse momentum 
-  TH2F * fhEtaConversion; //! Pseudorapidity of conversion electron vs tranvserse momentum 
-
-  TH1F * fhPtBottom;  //! Number of bottom electron vs transverse momentum 
-  TH2F * fhPhiBottom; //! Azimuthal angle of bottom  electron vs transverse momentum 
-  TH2F * fhEtaBottom; //! Pseudorapidity of bottom electron vs tranvserse momentum 
-
-  TH1F * fhPtCharm;  //! Number of charm electron vs transverse momentum 
-  TH2F * fhPhiCharm; //! Azimuthal angle of charm  electron vs transverse momentum 
-  TH2F * fhEtaCharm; //! Pseudorapidity of charm electron vs tranvserse momentum 
-
-  TH1F * fhPtCFromB;  //! Number of charm from bottom electron vs transverse momentum 
-  TH2F * fhPhiCFromB; //! Azimuthal angle of charm from bottom electron vs transverse momentum 
-  TH2F * fhEtaCFromB; //! Pseudorapidity of charm from bottom electron vs tranvserse momentum 
-
-  TH1F * fhPtDalitz;  //! Number of dalitz electron vs transverse momentum 
-  TH2F * fhPhiDalitz; //! Azimuthal angle of dalitz  electron vs transverse momentum 
-  TH2F * fhEtaDalitz; //! Pseudorapidity of dalitz electron vs tranvserse momentum 
-
-  TH1F * fhPtWDecay;  //! Number of W-boson electron vs transverse momentum 
-  TH2F * fhPhiWDecay; //! Azimuthal angle of W-boson  electron vs transverse momentum 
-  TH2F * fhEtaWDecay; //! Pseudorapidity of W-boson electron vs tranvserse momentum 
-               
-  TH1F * fhPtZDecay;  //! Number of Z-boson electron vs transverse momentum 
-  TH2F * fhPhiZDecay; //! Azimuthal angle of Z-boson  electron vs transverse momentum 
-  TH2F * fhEtaZDecay; //! Pseudorapidity of Z-boson electron vs tranvserse momentum 
-
-  TH1F * fhPtPrompt;  //! Number of prompt electron vs transverse momentum 
-  TH2F * fhPhiPrompt; //! Azimuthal angle of prompt  electron vs transverse momentum 
-  TH2F * fhEtaPrompt; //! Pseudorapidity of prompt electron vs tranvserse momentum 
-
-  TH1F * fhPtUnknown;  //! Number of unknown electron vs transverse momentum 
-  TH2F * fhPhiUnknown; //! Azimuthal angle of unknown  electron vs transverse momentum 
-  TH2F * fhEtaUnknown; //! Pseudorapidity of unknown electron vs tranvserse momentum 
-
-  TH1F* fhPtHadron;     //!Pt distribution of reco charged hadrons
-                       //!(pi,k,p) in EMCAL acceptance
-  TH1F* fhPtEleTrkDet;  //!Pt distribution of reco electrons using
-                       //!pid info from tracking detectors only in
-                       //!EMCAL acceptance
-
-  //B-tagging
-  TH2F * fhBtagCut1; //! B-tagging result for cut1 (minv>1.0)
-  TH2F * fhBtagCut2; //! B-tagging result for cut2 (minv>1.5)
-  TH2F * fhBtagCut3; //! B-tagging result for cut3 (minv>1.8)
-  TH2F * fhBtagQA1;  //! B-tagging : QA of pairDca vs decaylength
-  TH2F * fhBtagQA2;  //! B-tagging : QA of signDca vs mass
-
-  //MC
-  TNtuple *fMCEleNtuple; //! Ntuple of MC electrons
-  TH1F* fhPtMCHadron;    //! Pt distribution of MC charged hadrons
-                        //! (pi,k,p) in EMCAL acceptance
-
-  ClassDef(AliAnaElectron,4)
-
-} ;
-
-#endif//ALIANAELECTRON_H
-
-
-
+#ifndef ALIANAELECTRON_H\r
+#define ALIANAELECTRON_H\r
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
+ * See cxx source for full Copyright notice     */\r
+/* $Id:  $ */\r
+\r
+//_________________________________________________________________________\r
+//\r
+// Class for the electron identification.\r
+// Clusters from EMCAL matched to tracks are selected \r
+// and kept in the AOD. Few histograms produced.\r
+//\r
+\r
+//-- Author: J.L. Klay (Cal Poly)\r
+\r
+// --- ROOT system ---\r
+class TH2F ;\r
+class TString ;\r
+class TNtuple ;\r
+class TH3F;\r
+\r
+// --- ANALYSIS system ---\r
+#include "AliAnaPartCorrBaseClass.h"\r
+\r
+class AliCaloTrackReader;\r
+class AliAODTrack;\r
+class TList ;\r
+\r
+class AliAnaElectron : public AliAnaPartCorrBaseClass {\r
+\r
+public: \r
+\r
+  AliAnaElectron() ; // default ctor\r
+  AliAnaElectron(const AliAnaElectron & g) ; // cpy ctor\r
+  AliAnaElectron & operator = (const AliAnaElectron & g) ;//cpy assignment\r
+  virtual ~AliAnaElectron() ; //virtual dtor\r
+  \r
+  TList *  GetCreateOutputObjects();\r
+\r
+  void Init();\r
+\r
+  void MakeAnalysisFillAOD()  ;\r
+  \r
+  void MakeAnalysisFillHistograms() ; \r
+  \r
+  //B-tagging\r
+  Double_t ComputeSignDca(AliAODTrack *track, AliAODTrack *track2 , float cut1);\r
+  Int_t GetBtag(AliAODTrack * tr);\r
+\r
+  Bool_t IsItPhotonic(const AliAODPWG4Particle* part);\r
+  Bool_t CheckTrack(const AliAODTrack* track);\r
+\r
+  void Print(const Option_t * opt)const;\r
+  \r
+  TString GetCalorimeter()   const {return fCalorimeter ; }\r
+  Double_t GetpOverEmin()   const {return fpOverEmin ; }\r
+  Double_t GetpOverEmax()   const {return fpOverEmax ; }\r
+  Bool_t GetWriteNtuple()   const {return fWriteNtuple ; }\r
+\r
+  Double_t GetDrCut() const { return fDrCut; }\r
+  Double_t GetPairDcaCut() const { return fPairDcaCut; }\r
+  Double_t GetDecayLenCut() const { return fDecayLenCut; }\r
+  Double_t GetImpactCut() const { return fImpactCut; }\r
+  Double_t GetAssocPtCut() const { return fAssocPtCut; }\r
+  Double_t GetMassCut() const { return fMassCut; }\r
+  Double_t GetSdcaCut() const { return fSdcaCut; }\r
+  Int_t   GetITSCut() const { return fITSCut; }\r
+\r
+  void SetCalorimeter(TString det)    {fCalorimeter = det ; }\r
+  void SetpOverEmin(Double_t min)     {fpOverEmin = min ; }\r
+  void SetpOverEmax(Double_t max)     {fpOverEmax = max ; }\r
+  void SetResidualCut(Double_t cut)     {fResidualCut = cut ; }\r
+  void SetWriteNtuple(Bool_t val)     {fWriteNtuple = val ; }\r
+\r
+  void SetDrCut(Double_t dr)  { fDrCut = dr; }\r
+  void SetPairDcaCut(Double_t pdca) { fPairDcaCut = pdca; }\r
+  void SetDecayLenCut(Double_t dlen) { fDecayLenCut = dlen; }\r
+  void SetImpactCut(Double_t imp) { fImpactCut = imp; }\r
+  void SetAssocPtCut(Double_t pt) { fAssocPtCut = pt; }\r
+  void SetMassCut(Double_t mass) { fMassCut = mass; }\r
+  void SetSdcaCut(Double_t sdca) { fSdcaCut = sdca; }\r
+  void SetITSCut(Int_t its) { fITSCut = its; }\r
+\r
+  void InitParameters();\r
+\r
+  void Terminate(TList * outputList);\r
+  void ReadHistograms(TList * outputList); //Fill histograms with\r
+                                          //histograms in ouput list,\r
+                                          //needed in Terminate.            \r
+\r
+  private:\r
+  TString  fCalorimeter;  //! Which detector? EMCAL or PHOS\r
+  Double_t fpOverEmin;    //! Minimum p/E value for Electrons\r
+  Double_t fpOverEmax;    //! Maximum p/E value for Electrons\r
+  Double_t fResidualCut;  //! Track-cluster matching distance\r
+\r
+  //B-tagging\r
+  Double_t fDrCut;       //max dR\r
+  Double_t fPairDcaCut;  //max pair-DCA\r
+  Double_t fDecayLenCut; //max 3d-decaylength\r
+  Double_t fImpactCut;   //max track impact param\r
+  Double_t fAssocPtCut;  //min associated pt\r
+  Double_t fMassCut;     //min Minv cut\r
+  Double_t fSdcaCut;     //min signDca\r
+  Int_t   fITSCut;       //min ITS hits (both)\r
+\r
+  Bool_t  fWriteNtuple; //flag for filling ntuple or not\r
+\r
+  TNtuple* fEleNtuple; //! testing ntuple\r
+\r
+  //matching checks   \r
+  TH1F *fh1pOverE;     //! p/E for track-cluster matches\r
+  TH1F *fh1dR;         //! distance between projected track and cluster\r
+  TH2F *fh2EledEdx;    //! dE/dx vs. momentum for electron candidates\r
+  TH2F *fh2MatchdEdx;  //! dE/dx vs. momentum for all matches\r
+  TH2F *fh2dEtadPhi;   //! DeltaEta vs. DeltaPhi of all track/cluster\r
+                      //! pairs\r
+  TH2F *fh2dEtadPhiMatched;   //! DeltaEta vs. DeltaPhi of matched\r
+                               //! track/cluster pairs\r
+  TH2F *fh2dEtadPhiUnmatched;   //! DeltaEta vs. DeltaPhi of unmatched track/cluster pairs\r
+\r
+  TH2F* fh2TrackPVsClusterE;     //!track momentum vs. cluster energy\r
+  TH2F* fh2TrackPtVsClusterE;    //!track pt vs. cluster energy\r
+  TH2F* fh2TrackPhiVsClusterPhi; //!track phi vs. cluster phi\r
+  TH2F* fh2TrackEtaVsClusterEta; //!track eta vs. cluster eta\r
+\r
+  //Photonic Electron checks\r
+  TH1F* fh1OpeningAngle; //!opening angle between pairs of photon candidates\r
+  TH1F* fh1MinvPhoton;   //!invariant mass distribution of electron pairs\r
+\r
+  //Reconstructed\r
+  TH1F * fhPtElectron;  //! Number of identified electron vs transverse momentum \r
+  TH2F * fhPhiElectron; //! Azimuthal angle of identified  electron vs transverse momentum \r
+  TH2F * fhEtaElectron; //! Pseudorapidity of identified  electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtNPE;  //! Number of non-photonic electron vs transverse momentum \r
+  TH2F * fhPhiNPE; //! Azimuthal angle of non-photonic electron vs transverse momentum \r
+  TH2F * fhEtaNPE; //! Pseudorapidity of non-photonic electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtPE;  //! Number of photonic electron vs transverse momentum \r
+  TH2F * fhPhiPE; //! Azimuthal angle of photonic electron vs transverse momentum \r
+  TH2F * fhEtaPE; //! Pseudorapidity of photonic electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtConversion;  //! Number of conversion electron vs transverse momentum \r
+  TH2F * fhPhiConversion; //! Azimuthal angle of conversion  electron vs transverse momentum \r
+  TH2F * fhEtaConversion; //! Pseudorapidity of conversion electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtBottom;  //! Number of bottom electron vs transverse momentum \r
+  TH2F * fhPhiBottom; //! Azimuthal angle of bottom  electron vs transverse momentum \r
+  TH2F * fhEtaBottom; //! Pseudorapidity of bottom electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtCharm;  //! Number of charm electron vs transverse momentum \r
+  TH2F * fhPhiCharm; //! Azimuthal angle of charm  electron vs transverse momentum \r
+  TH2F * fhEtaCharm; //! Pseudorapidity of charm electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtCFromB;  //! Number of charm from bottom electron vs transverse momentum \r
+  TH2F * fhPhiCFromB; //! Azimuthal angle of charm from bottom electron vs transverse momentum \r
+  TH2F * fhEtaCFromB; //! Pseudorapidity of charm from bottom electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtDalitz;  //! Number of dalitz electron vs transverse momentum \r
+  TH2F * fhPhiDalitz; //! Azimuthal angle of dalitz  electron vs transverse momentum \r
+  TH2F * fhEtaDalitz; //! Pseudorapidity of dalitz electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtWDecay;  //! Number of W-boson electron vs transverse momentum \r
+  TH2F * fhPhiWDecay; //! Azimuthal angle of W-boson  electron vs transverse momentum \r
+  TH2F * fhEtaWDecay; //! Pseudorapidity of W-boson electron vs tranvserse momentum \r
+               \r
+  TH1F * fhPtZDecay;  //! Number of Z-boson electron vs transverse momentum \r
+  TH2F * fhPhiZDecay; //! Azimuthal angle of Z-boson  electron vs transverse momentum \r
+  TH2F * fhEtaZDecay; //! Pseudorapidity of Z-boson electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtAll;  //! Number of all electron vs transverse momentum \r
+  TH2F * fhPhiAll; //! Azimuthal angle of all  electron vs transverse momentum \r
+  TH2F * fhEtaAll; //! Pseudorapidity of all electron vs tranvserse momentum \r
+\r
+  TH1F * fhPtUnknown;  //! Number of unknown electron vs transverse momentum\r
+  TH2F * fhPhiUnknown; //! Azimuthal angle of unknown  electron vs transverse momentum\r
+  TH2F * fhEtaUnknown; //! Pseudorapidity of unknown electron vs tranvserse momentum\r
+\r
+  TH1F * fhPtMisidentified;  //! Number of misidentified electron vs transverse momentum\r
+  TH2F * fhPhiMisidentified; //! Azimuthal angle of misidentified electron vs transverse momentum\r
+  TH2F * fhEtaMisidentified; //! Pseudorapidity of misidentified electron vs tranvserse momentum \r
+\r
+  TH1F* fhPtHadron;     //!Pt distribution of reco charged hadrons\r
+                       //!(pi,k,p) in EMCAL acceptance\r
+  TH1F* fhPtEleTrkDet;  //!Pt distribution of reco electrons using\r
+                       //!pid info from tracking detectors only in\r
+                       //!EMCAL acceptance\r
+  //event QA\r
+  TH1F * fhImpactXY;    //! impact parameter of all tracks to primary vertex\r
+  TH1F * fhRefMult;     //! refmult (sep 14)\r
+  TH1F * fhRefMult2;    //! refmult2 (sep 14)\r
+\r
+  //B-tagging\r
+  TH2F * fhBtagCut1; //! B-tagging result for cut1 (minv>1.0)\r
+  TH2F * fhBtagCut2; //! B-tagging result for cut2 (minv>1.5)\r
+  TH2F * fhBtagCut3; //! B-tagging result for cut3 (minv>1.8)\r
+  TH2F * fhBtagQA1;  //! B-tagging : QA of pairDca vs decaylength\r
+  TH2F * fhBtagQA2;  //! B-tagging : QA of signDca vs mass\r
+  TH1F * fhBtagQA3;  //! B-tagging : QA (sep 14)\r
+  TH1F * fhBtagQA4;  //! B-tagging : QA (sep 14)\r
+  TH1F * fhBtagQA5;  //! B-tagging : QA (sep 14)\r
+\r
+  //B-Jet histograms\r
+  TH2F* fhBJetXsiFF;     //! B-tagged jet FF with xsi = log(pt_Jet/pt_Track)\r
+  TH2F* fhBJetPtFF;      //! B-tagged jet FF with pt_Track\r
+  TH2F* fhBJetEtaPhi;    //! B-tagged jet eta-phi distribution\r
+  TH2F* fhNonBJetXsiFF;  //! Non b-tagged jet FF with xsi = log(pt_Jet/pt_Track)\r
+  TH2F* fhNonBJetPtFF;   //! Non b-tagged jet FF with pt_Track\r
+  TH2F* fhNonBJetEtaPhi; //! Non b-tagged jet eta-phi distribution\r
+\r
+  //MC\r
+  TNtuple *fMCEleNtuple; //! Ntuple of MC electrons\r
+  TH1F* fhPtMCHadron;    //! Pt distribution of MC charged hadrons (pi,k,p) in EMCAL acceptance\r
+  TH1F* fhPtMCBottom;    //! Pt distribution of MC bottom electrons in EMCAL\r
+  TH1F* fhPtMCCharm;     //! Pt distribution of MC charm electrons in EMCAL \r
+  TH1F* fhPtMCCFromB;    //! Pt distribution of MC charm from bottom ele in EMCAL\r
+  TH1F* fhPtMCConversion;//! Pt distribution of MC conversion electrons in EMCAL \r
+  TH1F* fhPtMCDalitz;    //! Pt distribution of MC Dalitz electrons in EMCAL\r
+  TH1F* fhPtMCWDecay;    //! Pt distribution of MC W decay electrons in EMCAL\r
+  TH1F* fhPtMCZDecay;    //! Pt distribution of MC Z decay electrons in EMCAL\r
+  TH1F* fhPtMCUnknown;   //! Pt distribution of MC unknown electrons in EMCAL\r
+\r
+  ClassDef(AliAnaElectron,5)\r
+\r
+} ;\r
\r
+\r
+#endif//ALIANAELECTRON_H\r
+\r
+\r
+\r