Switch to AliCaloPhotons
authorprsnko <Dmitri.Peressounko@cern.ch>
Fri, 30 May 2014 09:20:35 +0000 (13:20 +0400)
committerprsnko <Dmitri.Peressounko@cern.ch>
Fri, 30 May 2014 09:21:16 +0000 (13:21 +0400)
PWGGA/PHOSTasks/PHOS_Tagging/AliAnalysisTaskTaggedPhotons.cxx
PWGGA/PHOSTasks/PHOS_Tagging/AliAnalysisTaskTaggedPhotons.h
PWGGA/PHOSTasks/PHOS_pp_pi0/AliCaloPhoton.cxx
PWGGA/PHOSTasks/PHOS_pp_pi0/AliCaloPhoton.h

index 772f7a7..efbc08f 100644 (file)
@@ -41,7 +41,7 @@
 #include "AliAODEvent.h" 
 #include "AliAODEvent.h" 
 #include "AliVCluster.h" 
-#include "AliAODPWG4Particle.h"
+#include "AliCaloPhoton.h"
 #include "AliAODMCParticle.h"
 #include "AliAnalysisManager.h"
 #include "AliLog.h"
@@ -554,7 +554,7 @@ void AliAnalysisTaskTaggedPhotons::UserExec(Option_t *)
   if(fTrackEvent)
     fTrackEvent->Clear() ;
   else
-    fTrackEvent = new TClonesArray("AliAODPWG4Particle",event->GetNumberOfTracks()) ;
+    fTrackEvent = new TClonesArray("AliCaloPhoton",event->GetNumberOfTracks()) ;
 
   for (Int_t i=0;i<event->GetNumberOfTracks();++i) {
     AliAODTrack *track = (AliAODTrack*)event->GetTrack(i) ;
@@ -563,7 +563,7 @@ void AliAnalysisTaskTaggedPhotons::UserExec(Option_t *)
     if(TMath::Abs(track->Eta())< 0.9){
       if(trackMult>=fTrackEvent->GetSize())
        fTrackEvent->Expand(2*trackMult) ;
-      new ((*fTrackEvent)[trackMult]) AliAODPWG4Particle(track->Px(),track->Py(),track->Pz(),track->P());
+      new ((*fTrackEvent)[trackMult]) AliCaloPhoton(track->Px(),track->Py(),track->Pz(),track->P());
       trackMult++;
      FillHistogram("hTrackEtaPhi",track->Eta(),track->Phi()) ;
      FillHistogram("hTrackEtaPt",track->Eta(),track->Pt()) ;
@@ -580,7 +580,7 @@ void AliAnalysisTaskTaggedPhotons::UserExec(Option_t *)
   //---------Select photons-------------------
   Int_t multClust = event->GetNumberOfCaloClusters();
   if(!fPHOSEvent)
-    fPHOSEvent   = new TClonesArray("AliAODPWG4Particle",multClust);
+    fPHOSEvent   = new TClonesArray("AliCaloPhoton",multClust);
   else
     fPHOSEvent->Clear() ;
   Int_t inList = 0; //counter of caloClusters
@@ -636,24 +636,23 @@ void AliAnalysisTaskTaggedPhotons::UserExec(Option_t *)
     
     TLorentzVector momentum ;
     clu->GetMomentum(momentum, vtx5);
-    AliAODPWG4Particle *p = new ((*fPHOSEvent)[inList]) AliAODPWG4Particle(momentum.Px(),momentum.Py(),momentum.Pz(),clu->E() );
+    AliCaloPhoton *p = new ((*fPHOSEvent)[inList]) AliCaloPhoton(momentum.Px(),momentum.Py(),momentum.Pz(),clu->E() );
     inList++;
 
     Int_t isolation = EvalIsolation(&momentum) ;
-    p->SetBtag(isolation) ;
+    p->SetIsolationTag(isolation) ;
     
-    p->SetCaloLabel(i,-1); //This and partner cluster
     p->SetDistToBad((Int_t)(1.+clu->GetDistanceToBadChannel()/2.2));
     
-    p->SetTag(0); //Strict PID pi0 partner not found
+    p->SetTagInfo(0); //Strict PID pi0 partner not found
     p->SetTagged(kFALSE);   //Reconstructed pairs found
     
-    Bool_t sure = 0;
     p->SetFiducialArea(fidArea) ;
 
     if(fStack){    
        //This is primary entered PHOS
-       Int_t primLabel=FindPrimary(clu,sure) ;
+       FillHistogram(Form("LabelsNPrim_cent%d",fCentBin),clu->E(),float(clu->GetNLabels())) ;
+       Int_t primLabel=clu->GetLabelAt(0) ; //FindPrimary(clu,sure) ;
        //Look what particle left vertex
        if(primLabel>-1){
          AliAODMCParticle * prim = (AliAODMCParticle*)fStack->At(primLabel) ;
@@ -663,22 +662,25 @@ void AliAnalysisTaskTaggedPhotons::UserExec(Option_t *)
          while((r2 > rcut*rcut) && (iparent>-1)){
            iparent=parent->GetMother();
            parent=(AliAODMCParticle*)fStack->At(iparent);
+           r2=parent->Xv()*parent->Xv()+parent->Yv()*parent->Yv() ;
          }
-         p->SetCaloLabel(primLabel,iparent); //This and partner cluster
+         p->SetPrimary(primLabel) ;
+         p->SetPrimaryAtVertex(iparent) ;
+        p->SetWeight(PrimaryParticleWeight(parent)) ;
        }
        else{
-         p->SetCaloLabel(-1,-1); //This and partner cluster
+         p->SetPrimary(-1); //Primary index    
+         p->SetPrimaryAtVertex(-1) ;
        }
     }
     else{  
-      //This is primary at vertex(R<1cm)
-      p->SetCaloLabel(-1,-1); //This and partner cluster
+      p->SetPrimary(-1); //Primary index    
+      p->SetPrimaryAtVertex(-1) ;
     }
-    p->SetLabel(i); //Cluster index    
     //PID criteria
     p->SetDispBit(clu->Chi2()<2.5) ;
     p->SetTOFBit(TestTOF(clu->GetTOF(),clu->E())) ;
-    p->SetChargedBit(clu->GetEmcCpvDistance()>2.5) ;      
+    p->SetCPVBit(clu->GetEmcCpvDistance()>2.5) ;      
   }
   FillHistogram("hPHOSCentrality",fCentrality,inList+0.5) ;
   
@@ -776,17 +778,17 @@ void AliAnalysisTaskTaggedPhotons::FillMCHistos(){
   
   const Int_t n=fPHOSEvent->GetEntriesFast() ;
   for(Int_t i=0;i<n;i++){
-    AliAODPWG4Particle *p = static_cast<AliAODPWG4Particle*>(fPHOSEvent->At(i));
-    Int_t label=p->GetLabel() ;
+    AliCaloPhoton *p = static_cast<AliCaloPhoton*>(fPHOSEvent->At(i));
+    Int_t label=p->GetPrimary() ;
     if(label<0){ //No label!
       FillHistogram("hMCRecNoLabel",p->Pt());
       continue ;
     }     
 
     
-    AliAODMCParticle * prim = (AliAODMCParticle*)fStack->At(p->GetLabel()) ;
+    AliAODMCParticle * prim = (AliAODMCParticle*)fStack->At(p->GetPrimary()) ;
     //Look what particle left virtex
-    Int_t iparent=p->GetLabel();
+    Int_t iparent=p->GetPrimary();
     AliAODMCParticle * parent = prim;
     while(parent->Xv()*parent->Xv()+parent->Yv()*parent->Yv() > rcut*rcut){
        iparent=parent->GetMother();
@@ -877,12 +879,12 @@ void AliAnalysisTaskTaggedPhotons::FillMCHistos(){
            AliAODMCParticle * partner = (AliAODMCParticle *)fStack->At(ipartner);
            //Check if partner is registered and made correct mass
            //If not - trace the reason
-           AliAODPWG4Particle *pp = 0x0 ;
+           AliCaloPhoton *pp = 0x0 ;
          
            for(Int_t ii=0;ii<n;ii++){
              if(i==ii) continue; 
-             AliAODPWG4Particle * tmp = static_cast<AliAODPWG4Particle*>(fPHOSEvent->At(ii));
-             Int_t ipartnPrim = tmp->GetLabel() ;
+             AliCaloPhoton * tmp = static_cast<AliCaloPhoton*>(fPHOSEvent->At(ii));
+             Int_t ipartnPrim = tmp->GetPrimary() ;
              while(ipartnPrim>-1){
                 if(ipartnPrim==ipartner)
                  break ;
@@ -896,19 +898,8 @@ void AliAnalysisTaskTaggedPhotons::FillMCHistos(){
 
            if(pp){
              //Partner reconstructed, but did not pass cuts
-             Bool_t cutEmin = (pp->GetInputFileIndex() &1) ;   
-             Bool_t cutNcell = (pp->GetInputFileIndex() &2) ;   
-             Bool_t cutEcross = (pp->GetInputFileIndex() &4) ;   
-             Bool_t cutM02 = (pp->GetInputFileIndex() &8) ;   
-              if(!cutEmin)FillPIDHistograms("hMCDecWMisPartnCutEmin",p) ;
-              if(!cutNcell)FillPIDHistograms("hMCDecWMisPartnCutNcell",p) ;
-              if(!cutEcross)FillPIDHistograms("hMCDecWMisPartnCutEcross",p) ;
-              if(!cutM02)FillPIDHistograms("hMCDecWMisPartnCutM02",p) ;
-             
-             if(cutEmin && cutNcell && cutEcross && cutM02){
                 FillPIDHistograms("hMCDecWRecPartn",p) ;       
-               Double_t invMass=p->GetPairMass(pp) ;
+               Double_t invMass=(*p+ *pp).M() ;
                FillHistogram("hMCmass",invMass,p->Pt()) ;
                if(IsInPi0Band(invMass,p->Pt())){
                  FillPIDHistograms("hMCDecWithFoundPartn",p) ;
@@ -916,10 +907,6 @@ void AliAnalysisTaskTaggedPhotons::FillMCHistos(){
                else{
                  FillPIDHistograms("hMCDecWithWrongMass",p) ;
                }
-             }
-             else{
-                FillPIDHistograms("hMCDecWMisPartnDefCuts",p) ;                        
-             }
            }
            else{//Partner not reconstructed
              if(partner->GetPdgCode()==22){
@@ -997,11 +984,11 @@ void AliAnalysisTaskTaggedPhotons::FillTaggingHistos(){
   //Invariant Mass analysis
   const Int_t n=fPHOSEvent->GetEntriesFast() ;
   for(Int_t i=0;i<n-1;i++){
-    AliAODPWG4Particle *p1 = static_cast<AliAODPWG4Particle*>(fPHOSEvent->At(i));
+    AliCaloPhoton *p1 = static_cast<AliCaloPhoton*>(fPHOSEvent->At(i));
     for(Int_t j = i+1 ; j < n ; j++) {
-      AliAODPWG4Particle * p2 = static_cast<AliAODPWG4Particle*>(fPHOSEvent->At(j));
+      AliCaloPhoton * p2 = static_cast<AliCaloPhoton*>(fPHOSEvent->At(j));
       
-      Double_t invMass = p1->GetPairMass(p2);   
+      Double_t invMass = (*p1 + *p2).M();   
 
       if((p1->E()>0.1) && (p2->E()>0.1)){
         FillPIDHistograms("hInvM_Re_Emin1",p1,p2,invMass) ;
@@ -1083,7 +1070,7 @@ void AliAnalysisTaskTaggedPhotons::FillTaggingHistos(){
          }
        }
       }
-      p1->SetTag(tag1) ;
+      p1->SetTagInfo(tag1) ;
       Int_t tag2=0 ;
       for(Int_t eminType=0; eminType<3; eminType++){
         if(p1->E()>0.1*(eminType+1)){
@@ -1098,7 +1085,7 @@ void AliAnalysisTaskTaggedPhotons::FillTaggingHistos(){
          }
        }
       }
-      p2->SetTag(tag2) ;
+      p2->SetTagInfo(tag2) ;
       
       if(tag1 & (1<<7)){ //2 sigma, Emin=0.3: default tagging
         if(p1->IsTagged()){//Multiple tagging
@@ -1119,9 +1106,9 @@ void AliAnalysisTaskTaggedPhotons::FillTaggingHistos(){
   
   //Single particle histgams
   for(Int_t i=0;i<n;i++){
-    AliAODPWG4Particle *p = static_cast<AliAODPWG4Particle*>(fPHOSEvent->At(i));
+    AliCaloPhoton *p = static_cast<AliCaloPhoton*>(fPHOSEvent->At(i));
 
-    Int_t isolation = p->GetBtag();
+    Int_t isolation = p->GetIsolationTag();
 
     //Inclusive spectra
     FillPIDHistograms("hPhot",p) ;
@@ -1153,7 +1140,7 @@ void AliAnalysisTaskTaggedPhotons::FillTaggingHistos(){
       //3 Emin cuts
       //Default Emin, 1,2,3 sigmas
       //strict and loose PID cut on partner
-      Int_t tag=p->GetTag() ;
+      Int_t tag=p->GetTagInfo() ;
       for(Int_t ibit=0; ibit<18; ibit++){
         if((tag & (1<<ibit))==0){ 
           FillPIDHistograms(Form("hPhot_nTagged%d_Area1",ibit),p) ;
@@ -1187,12 +1174,12 @@ void AliAnalysisTaskTaggedPhotons::FillTaggingHistos(){
    //Fill Mixed InvMass distributions:
   TIter nextEv(fCurrentMixedList) ;
   for(Int_t i=0;i<n;i++){
-    AliAODPWG4Particle *p1 = static_cast<AliAODPWG4Particle*>(fPHOSEvent->At(i));
+    AliCaloPhoton *p1 = static_cast<AliCaloPhoton*>(fPHOSEvent->At(i));
     while(TClonesArray * event2 = static_cast<TClonesArray*>(nextEv())){
       Int_t nPhotons2 = event2->GetEntriesFast() ;
       for(Int_t j=0; j < nPhotons2 ; j++){
-        AliAODPWG4Particle * p2 = static_cast<AliAODPWG4Particle*>(event2->At(j)) ;
-        Double_t invMass = p1->GetPairMass(p2);
+        AliCaloPhoton * p2 = static_cast<AliCaloPhoton*>(event2->At(j)) ;
+        Double_t invMass = (*p1 + *p2).M();
 
         if((p1->E()>0.1) && (p2->E()>0.1)){
           FillPIDHistograms("hInvM_Mi_Emin1",p1,p2,invMass) ;
@@ -1276,15 +1263,15 @@ Bool_t AliAnalysisTaskTaggedPhotons::IsInPi0Band(Double_t m, Double_t pt)const
   return (m>mpi0mean-2*mpi0sigma && m<mpi0mean+2*mpi0sigma) ;
 }
 //______________________________________________________________________________
-Bool_t AliAnalysisTaskTaggedPhotons::IsSamePi0(const AliAODPWG4Particle *p1, const AliAODPWG4Particle *p2)const{
+Bool_t AliAnalysisTaskTaggedPhotons::IsSamePi0(const AliCaloPhoton *p1, const AliCaloPhoton *p2)const{
   //Looks through parents and finds if there was commont pi0 among ancestors
 
   if(!fStack)
     return kFALSE ; //can not say anything
 
-  Int_t prim1 = p1->GetCaloLabel(0);
+  Int_t prim1 = p1->GetPrimary();
   while(prim1!=-1){ 
-    Int_t prim2 = p2->GetCaloLabel(0);
+    Int_t prim2 = p2->GetPrimary();
     while(prim2!=-1){ 
       if(prim1==prim2){
         if(((AliAODMCParticle*)fStack->At(prim1))->GetPdgCode()==111)
@@ -1425,39 +1412,39 @@ void AliAnalysisTaskTaggedPhotons::FillHistogram(const char * key,Double_t x,Dou
   }
 }
 //_____________________________________________________________________________
-void AliAnalysisTaskTaggedPhotons::FillPIDHistograms(const char * name, const AliAODPWG4Particle * p) const{
+void AliAnalysisTaskTaggedPhotons::FillPIDHistograms(const char * name, const AliCaloPhoton * p) const{
 
   FillHistogram(Form("%s_All_cent%d",name,fCentBin),p->Pt()) ;
-  if(p->GetDispBit())
+  if(p->IsDispOK())
     FillHistogram(Form("%s_Disp_cent%d",name,fCentBin),p->Pt()) ;
-  if(p->GetChargedBit())
+  if(p->IsCPVOK())
     FillHistogram(Form("%s_CPV_cent%d",name,fCentBin),p->Pt()) ;
-  if(p->GetDispBit() && p->GetChargedBit()) 
+  if(p->IsDispOK() && p->IsCPVOK()) 
     FillHistogram(Form("%s_Both_cent%d",name,fCentBin),p->Pt()) ;
   
 }
 //_____________________________________________________________________________
-void AliAnalysisTaskTaggedPhotons::FillPIDHistograms(const char * name, const AliAODPWG4Particle * p,Double_t x) const{
+void AliAnalysisTaskTaggedPhotons::FillPIDHistograms(const char * name, const AliCaloPhoton * p,Double_t x) const{
 
   FillHistogram(Form("%s_All_cent%d",name,fCentBin),x,p->Pt()) ;
-  if(p->GetDispBit())
+  if(p->IsDispOK())
     FillHistogram(Form("%s_Disp_cent%d",name,fCentBin),x,p->Pt()) ;
-  if(p->GetChargedBit())
+  if(p->IsCPVOK())
     FillHistogram(Form("%s_CPV_cent%d",name,fCentBin),x,p->Pt()) ;
-  if(p->GetDispBit() && p->GetChargedBit()) 
+  if(p->IsDispOK() && p->IsCPVOK()) 
     FillHistogram(Form("%s_Both_cent%d",name,fCentBin),x,p->Pt()) ;
   
 }
 //_____________________________________________________________________________
-void AliAnalysisTaskTaggedPhotons::FillPIDHistograms(const char * name, const AliAODPWG4Particle * p1,const AliAODPWG4Particle * p2,Double_t x) const{
+void AliAnalysisTaskTaggedPhotons::FillPIDHistograms(const char * name, const AliCaloPhoton * p1,const AliCaloPhoton * p2,Double_t x) const{
 
-  Double_t ptPi = (*(p1->Momentum()) + *(p2->Momentum())).Pt() ;
+  Double_t ptPi = (*p1 + *p2).Pt() ;
   FillHistogram(Form("%s_All_cent%d",name,fCentBin),x,ptPi) ;
-  if(p1->GetDispBit() && p2->GetDispBit())
+  if(p1->IsDispOK() && p2->IsDispOK())
     FillHistogram(Form("%s_Disp_cent%d",name,fCentBin),x,ptPi) ;
-  if(p1->GetChargedBit() && p2->GetChargedBit())
+  if(p1->IsCPVOK() && p2->IsCPVOK())
     FillHistogram(Form("%s_CPV_cent%d",name,fCentBin),x,ptPi) ;
-  if(p1->GetDispBit() && p1->GetChargedBit() && p2->GetDispBit() && p2->GetChargedBit()) 
+  if(p1->IsDispOK() && p1->IsCPVOK() && p2->IsDispOK() && p2->IsCPVOK()) 
     FillHistogram(Form("%s_Both_cent%d",name,fCentBin),x,ptPi) ;
   
 }
@@ -1501,7 +1488,7 @@ Int_t AliAnalysisTaskTaggedPhotons::EvalIsolation(TLorentzVector * ph){
 
    Int_t n=fTrackEvent->GetEntriesFast() ;
    for(Int_t itr=0; itr<n; itr++){
-     AliAODPWG4Particle * track = (AliAODPWG4Particle*)fTrackEvent->At(itr) ;
+     AliCaloPhoton * track = (AliCaloPhoton*)fTrackEvent->At(itr) ;
          
      Double_t deleta = etaTrig - track->Eta() ;
      Double_t delphi = phiTrig - track->Phi() ;      
@@ -1543,14 +1530,14 @@ Int_t AliAnalysisTaskTaggedPhotons::EvalIsolation(TLorentzVector * ph){
     return isolation ;             
 }
 //_________________________________________________________________________________
-Bool_t AliAnalysisTaskTaggedPhotons::TestPID(Int_t iPID, AliAODPWG4Particle* part){
+Bool_t AliAnalysisTaskTaggedPhotons::TestPID(Int_t iPID, AliCaloPhoton* part){
 //   //Checks PID of particle
   
   if(!part) return kFALSE ;
   if(iPID==0) return kTRUE ;
-  if(iPID==1) return part->GetDispBit() ;
-  if(iPID==2) return part->GetChargedBit() ;
-  if(iPID==3) return part->GetDispBit() && part->GetChargedBit() ;
+  if(iPID==1) return part->IsDispOK() ;
+  if(iPID==2) return part->IsCPVOK() ;
+  if(iPID==3) return part->IsDispOK() && part->IsCPVOK() ;
   return kFALSE ;
     
 }
index 9efcf51..16d3f95 100644 (file)
@@ -18,7 +18,7 @@ class AliAODEvent ;
 class THashList ; 
 class TH2I ;
 class AliPHOSGeometry;
-class AliAODPWG4Particle;
+class AliCaloPhoton;
 class AliAODMCParticle ;
 class AliVCluster ;
 class AliTriggerAnalysis ;
@@ -45,7 +45,7 @@ protected:
   void    FillMCHistos() ;
   void    FillTaggingHistos() ;
   Int_t   GetFiducialArea(const Float_t * pos)const ; //what kind of fiducial area hit the photon
-  Bool_t  IsSamePi0(const AliAODPWG4Particle *p1, const AliAODPWG4Particle *p2) const; //Check MC genealogy
+  Bool_t  IsSamePi0(const AliCaloPhoton *p1, const AliCaloPhoton *p2) const; //Check MC genealogy
   Bool_t  IsGoodChannel(Int_t mod, Int_t ix, Int_t iz) ;
   Bool_t  IsInPi0Band(Double_t m, Double_t pt)const; //Check if invariant mass is within pi0 peak
   Bool_t  TestDisp(Double_t l0, Double_t l1, Double_t e)const  ;
@@ -54,15 +54,15 @@ protected:
   void    InitGeometry() ;  //read reotation matrixes from AOD/AOD
   Int_t   EvalIsolation(TLorentzVector * ph) ;
   Bool_t  TestLambda(Double_t pt,Double_t l1,Double_t l2) ;
-  Bool_t  TestPID(Int_t iPID, AliAODPWG4Particle* part) ;
+  Bool_t  TestPID(Int_t iPID, AliCaloPhoton* part) ;
   Double_t PrimaryParticleWeight(AliAODMCParticle * particle) ;
   Int_t   FindPrimary(AliVCluster*, Bool_t&);
   void FillHistogram(const char * key,Double_t x) const ; //Fill 1D histogram witn name key
   void FillHistogram(const char * key,Double_t x, Double_t y) const ; //Fill 2D histogram witn name key
   void FillHistogram(const char * key,Double_t x, Double_t y, Double_t z) const ; //Fill 3D histogram witn name key
-  void FillPIDHistograms(const char * name, const AliAODPWG4Particle * p) const ;
-  void FillPIDHistograms(const char * name, const AliAODPWG4Particle * p ,Double_t y) const ;
-  void FillPIDHistograms(const char * name, const AliAODPWG4Particle * p , const AliAODPWG4Particle * p2,Double_t y) const ;
+  void FillPIDHistograms(const char * name, const AliCaloPhoton * p) const ;
+  void FillPIDHistograms(const char * name, const AliCaloPhoton * p ,Double_t y) const ;
+  void FillPIDHistograms(const char * name, const AliCaloPhoton * p , const AliCaloPhoton * p2,Double_t y) const ;
 
 private:
 
index d43b0e4..bebba4c 100644 (file)
@@ -36,23 +36,27 @@ AliCaloPhoton::AliCaloPhoton() :
   fIsIsolated(0),
   fIsPhoton(0),
   fUnfolded(0),
-  fX(0.),
-  fY(0.),
-  fZ(0.),
-  fLambda0(0.),
-  fLambda1(0.),
-  fTime(0.),
   fModule(0),
   fBC(0),
   fBadDist(0),
   fNCells(0),
+  fFiducialArea(0),
   fPi0Decayflag(0),
   fPi0Id(0),
   fConverted(0),
   fConvertedPartner(0),
+  fIsolationTag(0),
+  fTagInfo(0),
+  fPrimary(-1),
+  fPrimaryAtVertex(-1),
+  fX(0.),
+  fY(0.),
+  fZ(0.),
+  fLambda0(0.),
+  fLambda1(0.),
+  fTime(0.),
   fPartnerPt(0),
   fWeight(1.),
-  fPrimary(0),
   fCluster(0x0)
 {
 
@@ -73,23 +77,27 @@ AliCaloPhoton::AliCaloPhoton(Double_t px,Double_t py,Double_t pz,Double_t energy
   fIsIsolated(0),
   fIsPhoton(0),
   fUnfolded(0),
-  fX(0.),
-  fY(0.),
-  fZ(0.),
-  fLambda0(0.),
-  fLambda1(0.),
-  fTime(0.),
   fModule(0),
   fBC(0),
   fBadDist(0),
   fNCells(0),
+  fFiducialArea(0),
   fPi0Decayflag(0),
   fPi0Id(0),
   fConverted(0),
   fConvertedPartner(0),
+  fIsolationTag(0),
+  fTagInfo(0),
+  fPrimary(-1),
+  fPrimaryAtVertex(-1),
+  fX(0.),
+  fY(0.),
+  fZ(0.),
+  fLambda0(0.),
+  fLambda1(0.),
+  fTime(0.),
   fPartnerPt(0),
   fWeight(1.),
-  fPrimary(0),
   fCluster(0x0)
 {
   
index d49baee..abcc75b 100644 (file)
@@ -26,80 +26,87 @@ class AliCaloPhoton :public TLorentzVector{
   ~AliCaloPhoton(){} 
 
    const TLorentzVector * GetMomV2()const{return &fMomV2;}
-   Double_t EMCx(void)const {return fX;}
-   Double_t EMCy(void)const {return fY;}
-   Double_t EMCz(void)const {return fZ;}
-   Int_t    Module(void)const{return fModule;}
-   Int_t    GetBC()const{return fBC;}
-   Int_t    DistToBad()const  {return fBadDist ;}
-   Int_t    GetNCells()const { return fNCells ;} 
-   Double_t GetTime(void) const {return fTime ;}
-   void SetTime(Double_t t) {fTime=t ;}
+   Int_t    DistToBad() const {return fBadDist ;}
+   Double_t EMCx(void)  const {return fX;}
+   Double_t EMCy(void)  const {return fY;}
+   Double_t EMCz(void)  const {return fZ;}
+   Int_t    Module(void)const {return fModule;}
+   Int_t    GetBC(void) const {return fBC;}
+   Int_t    GetFiducialArea(void) const {return fFiducialArea ;}
+   Int_t    GetIsolationTag(void) const {return fIsolationTag ;}
+   Double_t GetLambda1(void) const {return fLambda0;}
+   Double_t GetLambda2(void) const {return fLambda1;}
+   Int_t    GetNCells() const { return fNCells ;} 
+   Int_t    GetPrimary()const {return fPrimary;}
+   Int_t    GetPrimaryAtVertex()  const {return fPrimaryAtVertex;}
+   Double_t GetPartnerPt(void)    const {return fPartnerPt;}  
+   Int_t    GetTagInfo(void) const {return fTagInfo;}
+   Double_t GetTime(void)    const {return fTime ;}
+   Double_t GetWeight(void)  const {return fWeight;}
 
-   Bool_t   IsDispOK(void)const {return fDisp;}
-   Bool_t   IsDisp2OK(void)const {return fDisp2;} //stricter cut
-   Bool_t   IsTOFOK(void)const {return fTof;}
-   Bool_t   IsCPVOK(void)const {return fCpv;}
-   Bool_t   IsCPV2OK(void)const {return fCpv2;}
-   Bool_t   IsIsolated(void)const{return fIsIsolated ;}
-   Bool_t   IsTagged(void) const{return fIsTagged ;} //check if this photon is tagged
-   Bool_t   IsTagged(Int_t i,Int_t k) const{return fIsTagged_reg[i][k] ;} //check if this photon is tagged
+   Int_t    IsConvertedPartner() const { if(fConvertedPartner == 1) return 1; else return 0; }
+   Bool_t   IsCPVOK(void)   const {return fCpv;}
+   Bool_t   IsCPV2OK(void)  const {return fCpv2;}
+   Bool_t   IsDispOK(void)  const {return fDisp;}
+   Bool_t   IsDisp2OK(void) const {return fDisp2;} //stricter cut
+   Bool_t   IsIsolated(void)const {return fIsIsolated ;}
+   Bool_t   IsPhoton() const {return fIsPhoton ;} //check if this particle is indeed photon (this bit is set with MC stack info
    Bool_t   IsPIDOK(const Int_t ipid) const ;
-   Bool_t   IsPhoton()const {return fIsPhoton ;} //check if this particle is indeed photon (this bit is set with MC stack info
-   Bool_t   IsntUnfolded()const{return fUnfolded;}
-   Int_t    IsConvertedPartner(){ if(fConvertedPartner == 1) return 1; else return 0; }
-   Bool_t   IsTrig(void)const{ return fTrig ; }
-   Double_t GetWeight(void){return fWeight;}
+   Bool_t   IsTagged(void)  const {return fIsTagged ;} //check if this photon is tagged
+   Bool_t   IsTagged(Int_t i,Int_t k) const {return fIsTagged_reg[i][k] ;} //check if this photon is tagged
+   Bool_t   IsTOFOK(void)   const {return fTof;}
+   Bool_t   IsTrig(void)    const{ return fTrig ; }
+   Bool_t   IsntUnfolded(void)const{return fUnfolded;}
 
    //ConvertedPair bit is set for events when photon's FirstMother is not e+/e- but pi0, but after pi0 decayed
 //there is conversion of one or both of the photons and results of their conversion are registered by PHOS.
 //This process is marked as tagged photons but actually the energy of photons is changed and pi0 can't be
 //correctly found.
-   Int_t IsConverted(){ if(fConverted == 1) return 1; else return 0; }
+   Int_t IsConverted(void) const { if(fConverted == 1) return 1; else return 0; }
 //Converted bit is set if this photon originate from e+/e- conversion on medium
-   Int_t IsPi0Decay(){ if(fPi0Decayflag == 1) return 1; else return 0; }
+   Int_t IsPi0Decay(void) const { if(fPi0Decayflag == 1) return 1; else return 0; }
 //Pi0Decayflag is set if this photon originate from pi0 decay
    void Pi0Decay(Int_t flag){ fPi0Decayflag=flag; }
    void Pi0Id(Int_t id){ fPi0Id=id; }
 //Id of pi0 from which this photon is decayed (to check if 2 photons originate from the same pi0 or not)
 
+   Int_t ComparePi0Ids( AliCaloPhoton *phot) { if(AliCaloPhoton::fPi0Id!=0 && (*phot).fPi0Id !=0 && AliCaloPhoton::fPi0Id == (*phot).fPi0Id) return 1; else return 0; }
 
-   void SetMomV2(TLorentzVector * p){fMomV2=(*p);}
-   void SetNCells(Int_t n){fNCells=n;}
+   void SetBC(Int_t bc){fBC = bc;}
+   void SetCluster(AliVCluster* cluster) { fCluster = cluster; }
    void SetConverted(Int_t flag){ fConverted=flag; }
-   Int_t ComparePi0Ids( AliCaloPhoton *phot) { if(AliCaloPhoton::fPi0Id!=0 && (*phot).fPi0Id !=0 && AliCaloPhoton::fPi0Id == (*phot).fPi0Id) return 1; else return 0; }
    void SetConvertedPartner(Int_t flag){ fConvertedPartner=flag; }
-   void SetPhoton(Int_t flag){ fIsPhoton=flag; }
-   void SetDispBit(Bool_t chi2){fDisp = chi2 ;} 
-   void SetDisp2Bit(Bool_t chi2){fDisp2 = chi2 ;} 
-   void SetTOFBit(Bool_t tof){fTof = tof ;} 
    void SetCPVBit(Bool_t cpv){fCpv = cpv; }
    void SetCPV2Bit(Bool_t cpv){fCpv2 = cpv; }
-   void SetPCAPID(Bool_t pca){fPCA = pca;}
-   void SetTrig(Bool_t trig){fTrig=trig;}
+   void SetDispBit(Bool_t chi2){fDisp = chi2 ;} 
+   void SetDisp2Bit(Bool_t chi2){fDisp2 = chi2 ;} 
+   void SetDistToBad(Int_t dist){fBadDist=dist;} 
    void SetEMCx(Double_t x){fX = x ;} 
    void SetEMCy(Double_t y){fY = y ;} 
    void SetEMCz(Double_t z){fZ = z ;} 
-   void SetModule(Int_t mod){fModule = mod ;} 
-   void SetBC(Int_t bc){fBC = bc;}
-   void SetDistToBad(Int_t dist){fBadDist=dist;} 
-   void SetTagged(Bool_t bit){fIsTagged=bit;}
-   void SetTagged(Bool_t bit,Int_t i,Int_t k){fIsTagged_reg[i][k]=bit;}
+   void SetFiducialArea(Int_t a){fFiducialArea=a ;}
+   void SetIsolationTag(Int_t tag){fIsolationTag=tag ;}
    void SetIsolated(Bool_t bit){fIsIsolated=bit;}
+   void SetLambdas(Double_t l1,Double_t l2){fLambda0=l1; fLambda1=l2;}
+   void SetModule(Int_t mod){fModule = mod ;} 
+   void SetMomV2(TLorentzVector * p){fMomV2=(*p);}
+   void SetNCells(Int_t n){fNCells=n;}
    void SetPartnerPt(Double_t pt){fPartnerPt=pt;}
+   void SetPCAPID(Bool_t pca){fPCA = pca;}
+   void SetPhoton(Int_t flag){ fIsPhoton=flag; }
    void SetPrimary(Int_t label){fPrimary=label;}
+   void SetPrimaryAtVertex(Int_t label){fPrimaryAtVertex=label;}
+   void SetTagged(Bool_t bit){fIsTagged=bit;}
+   void SetTagged(Bool_t bit,Int_t i,Int_t k){fIsTagged_reg[i][k]=bit;}
+   void SetTagInfo(Int_t bits){fTagInfo=bits;}
+   void SetTime(Double_t t) {fTime=t ;}
+   void SetTOFBit(Bool_t tof){fTof = tof ;} 
+   void SetTrig(Bool_t trig){fTrig=trig;}
    void SetUnfolded(Bool_t wasNotUnfolded){fUnfolded=wasNotUnfolded;} 
    void SetWeight(Double_t w){fWeight=w;}
 
-   void SetCluster(AliVCluster* cluster) { fCluster = cluster; }
    AliVCluster* GetCluster() { return fCluster; }
 
-   void SetLambdas(Double_t l1,Double_t l2){fLambda0=l1; fLambda1=l2;}
-   Double_t GetLambda1(void){return fLambda0;}
-   Double_t GetLambda2(void){return fLambda1;}
-
-   Int_t GetPrimary(){return fPrimary;}
-   Double_t GetPartnerPt(){return fPartnerPt;}  
 private:
   AliCaloPhoton(const AliCaloPhoton&); // not implemented
   AliCaloPhoton& operator=(const AliCaloPhoton&);
@@ -117,26 +124,30 @@ private:
   Bool_t    fIsIsolated ; //it is isolated
   Bool_t    fIsPhoton; //If it is really photon or not
   Bool_t    fUnfolded;  //True if was not unfolded
-  Double_t  fX ;        //Cluster coordinates in ALICE ref system 
-  Double_t  fY ;        //Cluster coordinates in ALICE ref system
-  Double_t  fZ ;        //Cluster coordinates in ALICE ref system
-  Double_t  fLambda0 ;  //Short and 
-  Double_t  fLambda1 ;  //Long dispersion axis
-  Double_t  fTime ;     //time of the cluster
   Int_t     fModule ;   //Module number
   Int_t     fBC ;       //Bunch crossing number (BC=0 is main-main collision)
   Int_t     fBadDist ;  //Distance to bad module in module units
   Int_t     fNCells ;   //Number of cells in cluster
+  Int_t     fFiducialArea ; //class of fiducial areas
   Int_t     fPi0Decayflag; //if this photon is from pi0 decay (from simulation)
   Int_t     fPi0Id;
   Int_t     fConverted; //If this photon originated from convertion on material (i.e. its primary is electron)
   Int_t            fConvertedPartner;
+  Int_t     fIsolationTag ;
+  Int_t     fTagInfo ;
+  Int_t     fPrimary;   //Primary entered PHOS
+  Int_t     fPrimaryAtVertex;   //Primary at vertex
+  Double_t  fX ;        //Cluster coordinates in ALICE ref system 
+  Double_t  fY ;        //Cluster coordinates in ALICE ref system
+  Double_t  fZ ;        //Cluster coordinates in ALICE ref system
+  Double_t  fLambda0 ;  //Short and 
+  Double_t  fLambda1 ;  //Long dispersion axis
+  Double_t  fTime ;     //time of the cluster
   Double_t  fPartnerPt;
   Double_t  fWeight ;   //Weight of parent particle
-  Int_t     fPrimary;   //Primary label
   AliVCluster* fCluster; //! Originating Cluster the Photon Candidate is based on
 
-  ClassDef(AliCaloPhoton,6);
+  ClassDef(AliCaloPhoton,7);
 
 };