ROOT logo
#ifndef AliAODJet_H
#define AliAODJet_H
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

//-------------------------------------------------------------------------
//     AOD jet class
//     Author: Andreas Morsch, CERN
//-------------------------------------------------------------------------

#include <TLorentzVector.h>
#include "AliVParticle.h"
#include <TArrayI.h>
#include "AliAODVertex.h"


class AliAODJet : public AliVParticle {

 public:
    AliAODJet();
    AliAODJet(Double_t px, Double_t py, Double_t pz, Double_t e);
    AliAODJet(TLorentzVector & p);  
    virtual ~AliAODJet();
    AliAODJet(const AliAODJet& jet); 
    AliAODJet& operator=(const AliAODJet& jet);
// 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 Double_t OneOverPt()  const { return 1. / fMomentum->Pt(); }
    virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
    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 Bool_t   IsTriggeredEMCAL(){return (fTrigger&kEMCALTriggered)==kEMCALTriggered;}
    virtual Bool_t   IsTriggeredTRD(){return (fTrigger&kTRDTriggered)==kTRDTriggered;}
    virtual UInt_t  Trigger(){return fTrigger;}
    
    virtual void     AddTrack(TObject *tr);
    
    TObject* GetTrack(Int_t i) {return fRefTracks->At(i);}
    virtual void     SetPtSubtracted(Double_t ptCh, Double_t ptN){
      fPtSubtracted[0] = ptCh;
      fPtSubtracted[1] = ptN;
    }
    virtual Double_t GetPtSubtracted(Int_t i){return (i<2?fPtSubtracted[i]:0);}
    virtual void     SetBgEnergy(Double_t bgEnCh, Double_t bgEnNe)
	{fBackgEnergy[0] = bgEnCh; fBackgEnergy[1] = bgEnNe;}
    virtual void     SetEffArea(Double_t effACh, Double_t effANe, Double_t effAErrCh = 0, Double_t effAErrNe = 0)
	{
	  fEffectiveArea[0] = effACh; fEffectiveArea[1] = effANe;
	  fEffectiveAreaError[0] = effAErrCh;
	  fEffectiveAreaError[1] = effAErrNe;
	}
    virtual void     SetPxPyPzE(Double_t px, Double_t py, Double_t pz, Double_t e);
    virtual void     SetPtEtaPhiM(Double_t pt, Double_t eta, Double_t phi, Double_t m);
    virtual void     SetTrigger(UInt_t f){fTrigger |= f;}
    virtual void     ResetTrigger(UInt_t f){fTrigger &= ~f;}
    virtual void     SetNEF(Double_t nef) {fNeutralFraction=nef;}
    virtual Double_t GetNEF() const {return fNeutralFraction;}

    virtual TRefArray* GetRefTracks()           const { return  fRefTracks;}
    virtual Double_t   ChargedBgEnergy()        const { return  fBackgEnergy[0];}
    virtual Double_t   NeutralBgEnergy()        const { return  fBackgEnergy[1];}
    virtual Double_t   TotalBgEnergy()          const { return (fBackgEnergy[0] + fBackgEnergy[1]);}

    virtual Double_t   EffectiveAreaCharged()   const { return  fEffectiveArea[0];}
    virtual Double_t   EffectiveAreaNeutral()   const { return  fEffectiveArea[1];}
    virtual void SetVectorAreaCharged(TLorentzVector *effVACh){
      if(!fVectorAreaCharged)fVectorAreaCharged= new TLorentzVector(*effVACh);
      else *fVectorAreaCharged = *effVACh;
    }
    virtual TLorentzVector*  VectorAreaCharged()   const {return fVectorAreaCharged;}



    virtual Double_t   ErrorEffectiveAreaCharged()   const { return  fEffectiveAreaError[0];}
    virtual Double_t   ErrorEffectiveAreaNeutral()   const { return  fEffectiveAreaError[1];}
    virtual Double_t   DeltaR(const AliVParticle* part) const;
    
    TLorentzVector*    MomentumVector()         const {return fMomentum;}

    virtual void     SetPtLeading(Double_t pt) {fPtLeadingConstituent=pt;}
    virtual Double_t GetPtLeading()        const { return fPtLeadingConstituent;}

    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   GetLabel()    const { return -1;}
    // Dummy
    virtual Int_t    PdgCode()    const {return 0;}

    //

    // first only one bit for EMCAL and TRD, leave space for more
    // trigger types and/or other detectors
    // use some of the bits to flag jets with high pT track
    // and good high pT cut
    enum {kEMCALTriggered = 1<<0,
	  kTRDTriggered =   1<<2,
	  kHighTrackPtTriggered = 1<<7,
	  kHighTrackPtBest = 1<<8
    };


 private:
    Double32_t      fBackgEnergy[2];         // Subtracted background energy
    Double32_t      fEffectiveArea[2];       // Effective jet area used for background subtraction
    Double32_t      fEffectiveAreaError[2];  //[0,1,10] relative error of jet areas, 10 bit precision
    Double32_t      fNeutralFraction;        //[0,1,12] Neutral fraction between 0 and 1 12 bit precision;
    Double32_t      fPtSubtracted[2];        //[0,0,12] pT after subtraction can be negative four momentum close to 0 in this case, 12 bit precision
    Double32_t      fPtLeadingConstituent;   //[0,0,12] pT of leading constituent
    UInt_t          fTrigger;                // Bit mask to flag jets triggered by a certain detector  
    TLorentzVector* fMomentum;               // Jet 4-momentum vector
    TLorentzVector* fVectorAreaCharged;      // jet area four momentum 
    TRefArray*      fRefTracks;              // array of references to the tracks belonging to the jet


    ClassDef(AliAODJet,14);

};

inline Double_t AliAODJet::Phi() const
{
    // Return phi
    Double_t phi = fMomentum->Phi();
    if (phi < 0.) phi += 2. * TMath::Pi();
    return phi;
}

#endif
 AliAODJet.h:1
 AliAODJet.h:2
 AliAODJet.h:3
 AliAODJet.h:4
 AliAODJet.h:5
 AliAODJet.h:6
 AliAODJet.h:7
 AliAODJet.h:8
 AliAODJet.h:9
 AliAODJet.h:10
 AliAODJet.h:11
 AliAODJet.h:12
 AliAODJet.h:13
 AliAODJet.h:14
 AliAODJet.h:15
 AliAODJet.h:16
 AliAODJet.h:17
 AliAODJet.h:18
 AliAODJet.h:19
 AliAODJet.h:20
 AliAODJet.h:21
 AliAODJet.h:22
 AliAODJet.h:23
 AliAODJet.h:24
 AliAODJet.h:25
 AliAODJet.h:26
 AliAODJet.h:27
 AliAODJet.h:28
 AliAODJet.h:29
 AliAODJet.h:30
 AliAODJet.h:31
 AliAODJet.h:32
 AliAODJet.h:33
 AliAODJet.h:34
 AliAODJet.h:35
 AliAODJet.h:36
 AliAODJet.h:37
 AliAODJet.h:38
 AliAODJet.h:39
 AliAODJet.h:40
 AliAODJet.h:41
 AliAODJet.h:42
 AliAODJet.h:43
 AliAODJet.h:44
 AliAODJet.h:45
 AliAODJet.h:46
 AliAODJet.h:47
 AliAODJet.h:48
 AliAODJet.h:49
 AliAODJet.h:50
 AliAODJet.h:51
 AliAODJet.h:52
 AliAODJet.h:53
 AliAODJet.h:54
 AliAODJet.h:55
 AliAODJet.h:56
 AliAODJet.h:57
 AliAODJet.h:58
 AliAODJet.h:59
 AliAODJet.h:60
 AliAODJet.h:61
 AliAODJet.h:62
 AliAODJet.h:63
 AliAODJet.h:64
 AliAODJet.h:65
 AliAODJet.h:66
 AliAODJet.h:67
 AliAODJet.h:68
 AliAODJet.h:69
 AliAODJet.h:70
 AliAODJet.h:71
 AliAODJet.h:72
 AliAODJet.h:73
 AliAODJet.h:74
 AliAODJet.h:75
 AliAODJet.h:76
 AliAODJet.h:77
 AliAODJet.h:78
 AliAODJet.h:79
 AliAODJet.h:80
 AliAODJet.h:81
 AliAODJet.h:82
 AliAODJet.h:83
 AliAODJet.h:84
 AliAODJet.h:85
 AliAODJet.h:86
 AliAODJet.h:87
 AliAODJet.h:88
 AliAODJet.h:89
 AliAODJet.h:90
 AliAODJet.h:91
 AliAODJet.h:92
 AliAODJet.h:93
 AliAODJet.h:94
 AliAODJet.h:95
 AliAODJet.h:96
 AliAODJet.h:97
 AliAODJet.h:98
 AliAODJet.h:99
 AliAODJet.h:100
 AliAODJet.h:101
 AliAODJet.h:102
 AliAODJet.h:103
 AliAODJet.h:104
 AliAODJet.h:105
 AliAODJet.h:106
 AliAODJet.h:107
 AliAODJet.h:108
 AliAODJet.h:109
 AliAODJet.h:110
 AliAODJet.h:111
 AliAODJet.h:112
 AliAODJet.h:113
 AliAODJet.h:114
 AliAODJet.h:115
 AliAODJet.h:116
 AliAODJet.h:117
 AliAODJet.h:118
 AliAODJet.h:119
 AliAODJet.h:120
 AliAODJet.h:121
 AliAODJet.h:122
 AliAODJet.h:123
 AliAODJet.h:124
 AliAODJet.h:125
 AliAODJet.h:126
 AliAODJet.h:127
 AliAODJet.h:128
 AliAODJet.h:129
 AliAODJet.h:130
 AliAODJet.h:131
 AliAODJet.h:132
 AliAODJet.h:133
 AliAODJet.h:134
 AliAODJet.h:135
 AliAODJet.h:136
 AliAODJet.h:137
 AliAODJet.h:138
 AliAODJet.h:139
 AliAODJet.h:140
 AliAODJet.h:141
 AliAODJet.h:142
 AliAODJet.h:143
 AliAODJet.h:144