AliEmcalContainer.h

Go to the documentation of this file.

/************************************************************************************
 * Copyright (C) 2016, Copyright Holders of the ALICE Collaboration                 *
 * All rights reserved.                                                             *
 *                                                                                  *
 * Redistribution and use in source and binary forms, with or without               *
 * modification, are permitted provided that the following conditions are met:      *
 *     * Redistributions of source code must retain the above copyright             *
 *       notice, this list of conditions and the following disclaimer.              *
 *     * Redistributions in binary form must reproduce the above copyright          *
 *       notice, this list of conditions and the following disclaimer in the        *
 *       documentation and/or other materials provided with the distribution.       *
 *     * Neither the name of the <organization> nor the                             *
 *       names of its contributors may be used to endorse or promote products       *
 *       derived from this software without specific prior written permission.      *
 *                                                                                  *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND  *
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED    *
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
 * DISCLAIMED. IN NO EVENT SHALL ALICE COLLABORATION BE LIABLE FOR ANY              *
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES       *
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;     *
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND      *
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT       *
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS    *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                     *
 ************************************************************************************/
#include "AliEmcalIterableContainer.h"

#ifndef ALIEMCALCONTAINER_H
#define ALIEMCALCONTAINER_H

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

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

#if !(defined(__CINT__) || defined(__MAKECINT__))
typedef EMCALIterableContainer::AliEmcalIterableContainerT<TObject, EMCALIterableContainer::operator_star_object<TObject> > AliEmcalIterableContainer;
typedef EMCALIterableContainer::AliEmcalIterableContainerT<TObject, EMCALIterableContainer::operator_star_pair<TObject> > AliEmcalIterableMomentumContainer;
#endif

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,            
    kOverlapTpcHole = 1<<29             
  };

  AliEmcalContainer();

  AliEmcalContainer(const char *name); 

  virtual ~AliEmcalContainer(){;}

  virtual TObject *operator[](int index) const = 0;

  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                 ; }
  TClass                     *GetClass()                      const { return fClArray == 0 ? 0 : fClArray->GetClass(); }
  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 ; }
  Double_t                    GetEtaSwing()                   const { return fMaxEta - fMinEta; }
  Double_t                    GetPhiSwing()                   const { return fMaxPhi - fMinPhi; }
  Double_t                    GetAcceptance()                 const { return GetEtaSwing() * GetPhiSwing(); }
  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 ? fClArray->GetEntriesFast() : 0 ; }
  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(const AliVEvent *event);
  void                        SetArrayName(const char *n)           { fClArrayName = n                  ; }
  void                        SetVertex(Double_t *vtx)              { memcpy(fVertex, vtx, sizeof(Double_t) * 3); }
  void                        SetBitMap(UInt_t m)                   { fBitMap = m                       ; }
  void                        SetIsParticleLevel(Bool_t b)          { fIsParticleLevel = b              ; }
  void                        SortArray()                           { fClArray->Sort()                  ; }

  TClass*                     GetLoadedClass()                      { return fLoadedClass               ; }

  virtual void                NextEvent(const AliVEvent *event);
  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);

  void                        SetIsEmbedding(Bool_t b)                  { fIsEmbedding = b ; }

  Bool_t                      GetIsEmbedding() const                    { return fIsEmbedding; }

  const char*                 GetName()                       const { return fName.Data()               ; }

  void                        SetName(const char* n)                { fName = n                         ; }

  static Double_t             RelativePhi(Double_t ang1, Double_t ang2);

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

#if !(defined(__CINT__) || defined(__MAKECINT__))

  const AliEmcalIterableContainer   all() const;

  const AliEmcalIterableContainer   accepted() const;

  const AliEmcalIterableMomentumContainer   all_momentum() const;

  const AliEmcalIterableMomentumContainer   accepted_momentum() const;
#endif

 protected:
  virtual TString             GetDefaultArrayName(const AliVEvent * const ev) const { return ""; }

  void                        GetVertexFromEvent(const AliVEvent * event);

  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;          
  Bool_t                      fIsEmbedding;             
  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,9);
};
#endif