AliEmcalContainer.h

Go to the documentation of this file.

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

class TLorentzVector;
class AliTLorentzVector;
class AliVEvent;
class AliNamedArrayI;
class AliVParticle;

#include <TNamed.h>
#include <TClonesArray.h>
#include "AliEmcalIterableContainer.h"

class AliEmcalContainer : public TObject {
 public:
  enum RejectionReason {
    // General
    kNullObject = 1<<0,                  
    kPtCut = 1<<1,                       
    kAcceptanceCut = 1<<2,               
    kMCLabelCut = 1<<3,                  
    kBitMapCut = 1<<4,                   
    kHFCut = 1<<5,                       
    // leave bit 6 free for future implementations
    
    // AliParticleContainer
    kNotHybridTrack = 1<<7,              
    kMCFlag = 1<<8,                      
    kMCGeneratorCut = 1<<9,              
    kChargeCut = 1<<10,                  
    kMinDistanceTPCSectorEdgeCut = 1<<11,
    // leave bit 12 free for future implementations

    // AliClusterContainer
    kIsEMCalCut = 1<<13,                 
    kTimeCut = 1<<14,                    
    kEnergyCut = 1<<15,                  
    kExoticCut = 1<<16,                  
    // leave bit 17 free for future implementations

    // AliJetContainer
    kAreaCut = 1<<18,                    
    kAreaEmcCut = 1<<19,                 
    kZLeadingChCut = 1<<20,              
    kZLeadingEmcCut = 1<<21,             
    kNEFCut = 1<<22,                     
    kMinLeadPtCut = 1<<23,               
    kMaxTrackPtCut = 1<<24,              
    kMaxClusterPtCut = 1<<25,            
    kFlavourCut = 1<<26,                 
    kTagStatus = 1<<27,                  
    kMinNConstituents = 1<<28            
  };

  AliEmcalContainer();
  AliEmcalContainer(const char *name); 
  virtual ~AliEmcalContainer(){;}

  TObject *operator[](int index) const;

  virtual Bool_t              ApplyKinematicCuts(const AliTLorentzVector& mom, UInt_t &rejectionReason) const;
  TClonesArray               *GetArray() const                      { return fClArray                   ; }
  const TString&              GetArrayName()                  const { return fClArrayName               ; }
  const TString&              GetClassName()                  const { return fClassName                 ; }
  Double_t                    GetMinE()                       const { return fMinE  ; }
  Double_t                    GetMaxE()                       const { return fMaxE  ; }
  Double_t                    GetMinPt()                      const { return fMinPt  ; }
  Double_t                    GetMaxPt()                      const { return fMaxPt  ; }
  Double_t                    GetMinEta()                     const { return fMinEta ; }
  Double_t                    GetMaxEta()                     const { return fMaxEta ; }
  Double_t                    GetMinPhi()                     const { return fMinPhi ; }
  Double_t                    GetMaxPhi()                     const { return fMaxPhi ; }
  Int_t                       GetCurrentID()                  const { return fCurrentID                 ; }
  Bool_t                      GetIsParticleLevel()            const { return fIsParticleLevel           ; }
  Int_t                       GetIndexFromLabel(Int_t lab)    const;
  Int_t                       GetNEntries()                   const { return fClArray->GetEntriesFast() ; }
  virtual Bool_t              GetMomentum(TLorentzVector &mom, Int_t i) const = 0;
  virtual Bool_t              GetAcceptMomentum(TLorentzVector &mom, Int_t i) const = 0;
  virtual Bool_t              GetNextMomentum(TLorentzVector &mom) = 0;
  virtual Bool_t              GetNextAcceptMomentum(TLorentzVector &mom) = 0;
  virtual Bool_t              AcceptObject(Int_t i, UInt_t &rejectionReason) const = 0;
  virtual Bool_t              AcceptObject(const TObject* obj, UInt_t &rejectionReason) const = 0;
  Int_t                       GetNAcceptEntries() const;
  void                        ResetCurrentID(Int_t i=-1)            { fCurrentID = i                    ; }
  virtual void                SetArray(AliVEvent *event);
  void                        SetArrayName(const char *n)           { fClArrayName = n                  ; }
  void                        SetBitMap(UInt_t m)                   { fBitMap = m                       ; }
  void                        SetIsParticleLevel(Bool_t b)          { fIsParticleLevel = b              ; }
  void                        SortArray()                           { fClArray->Sort()                  ; }
  UShort_t                    GetRejectionReasonBitPosition(UInt_t rejectionReason) const;
  TClass*                     GetLoadedClass()                      { return fLoadedClass               ; }
  virtual void                NextEvent() {;}
  void                        SetMinMCLabel(Int_t s)                            { fMinMCLabel      = s   ; }
  void                        SetMaxMCLabel(Int_t s)                            { fMaxMCLabel      = s   ; }
  void                        SetMCLabelRange(Int_t min, Int_t max)             { SetMinMCLabel(min)     ; SetMaxMCLabel(max)    ; }
  void                        SetELimits(Double_t min, Double_t max)    { fMinE   = min ; fMaxE   = max ; }
  void                        SetMinE(Double_t min)                     { fMinE   = min ; }
  void                        SetMaxE(Double_t max)                     { fMaxE   = max ; }
  void                        SetPtLimits(Double_t min, Double_t max)   { fMinPt  = min ; fMaxPt  = max ; }
  void                        SetMinPt(Double_t min)                    { fMinPt  = min ; }
  void                        SetMaxPt(Double_t max)                    { fMaxPt  = max ; }
  void                        SetEtaLimits(Double_t min, Double_t max)  { fMaxEta = max ; fMinEta = min ; }
  void                        SetPhiLimits(Double_t min, Double_t max)  { fMaxPhi = max ; fMinPhi = min ; }
  void                        SetMassHypothesis(Double_t m)             { fMassHypothesis         = m   ; }
  void                        SetClassName(const char *clname);

  const char*                 GetName()                       const { return fName.Data()               ; }
  void                        SetName(const char* n)                { fName = n                         ; }

  static Bool_t               SamePart(const AliVParticle* part1, const AliVParticle* part2, Double_t dist = 1.e-4);

  const AliEmcalIterableContainer   all() const;
  const AliEmcalIterableContainer   accepted() const;

 protected:
  TString                     fName;                    
  TString                     fClArrayName;             
  TString                     fBaseClassName;           
  Bool_t                      fIsParticleLevel;         
  UInt_t                      fBitMap;                  
  Double_t                    fMinPt;                   
  Double_t                    fMaxPt;                   
  Double_t                    fMaxE;                    
  Double_t                    fMinE;                    
  Double_t                    fMinEta;                  
  Double_t                    fMaxEta;                  
  Double_t                    fMinPhi;                  
  Double_t                    fMaxPhi;                  
  Int_t                       fMinMCLabel;              
  Int_t                       fMaxMCLabel;              
  Double_t                    fMassHypothesis;          
  TClonesArray               *fClArray;                 
  Int_t                       fCurrentID;               
  AliNamedArrayI             *fLabelMap;                
  Double_t                    fVertex[3];               
  TClass                     *fLoadedClass;             

 private:
  TString                     fClassName;               

  AliEmcalContainer(const AliEmcalContainer& obj); // copy constructor
  AliEmcalContainer& operator=(const AliEmcalContainer& other); // assignment

  ClassDef(AliEmcalContainer,8);
};
#endif