AliEMCALTriggerPatchInfo.h

Go to the documentation of this file.

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

#include "TObject.h"

#include <TLorentzVector.h>
#include <TMath.h>
#include "AliEMCALTriggerBitConfig.h"
#include "AliEMCALTriggerConstants.h"


class AliEMCALGeometry;
class TArrayI;


class AliEMCALTriggerPatchInfo: public TObject {

 public:
  enum {
    kRecalcOffset = 16,
    kOfflineOffset = 24
  };

  enum CaloDetectorType_t {
    kEMCALdet = 0,
    kDCALPHOSdet = 1
  };

  AliEMCALTriggerPatchInfo();

  AliEMCALTriggerPatchInfo(const AliEMCALTriggerPatchInfo &p);

  AliEMCALTriggerPatchInfo &operator=(const AliEMCALTriggerPatchInfo &p);

  virtual ~AliEMCALTriggerPatchInfo();

  void Reset();

  void Initialize(UChar_t col0, UChar_t row0, UChar_t size, UInt_t adc, UInt_t offlineAdc, Double_t patchE, UInt_t bitmask, const TVector3& vertex, const AliEMCALGeometry* geom);

  void Initialize(UChar_t col0, UChar_t row0, UChar_t size, UInt_t adc, UInt_t offlineAdc, UInt_t bitmask, const AliEMCALGeometry* geom);

  static AliEMCALTriggerPatchInfo* CreateAndInitialize(UChar_t col0, UChar_t row0, UChar_t size, UInt_t adc, UInt_t offlineAdc, Double_t patchE, UInt_t bitmask, const TVector3& vertex, const AliEMCALGeometry* geom);

  static AliEMCALTriggerPatchInfo* CreateAndInitialize(UChar_t col0, UChar_t row0, UChar_t size, UInt_t adc, UInt_t offlineAdc, UInt_t bitmask, const AliEMCALGeometry* geom);

  void RecalculateKinematics(Double_t patchE, const TVector3& vertex, const AliEMCALGeometry* geom);

  Double_t GetPhiGeo() const { return GetPhiTransform(fCenterGeo.Phi()); }

  Double_t GetPhiCM()  const { return GetPhiTransform(fCenterMass.Phi()); }

  Double_t GetPhiMin() const { return GetPhiTransform(fEdge1.Phi()); }

  Double_t GetPhiMax() const { return GetPhiTransform(fEdge2.Phi()); }

  Double_t GetEtaGeo() const { return fCenterGeo.Eta(); }

  Double_t GetEtaCM()  const { return fCenterMass.Eta(); }

  Double_t GetEtaMin() const { return fEdge2.Eta(); }

  Double_t GetEtaMax() const { return fEdge1.Eta(); }

  Double_t GetPatchE() const { return fCenterGeo.E(); }

  Double_t GetSmearedEnergy() const { return fEnergySmeared; }

  Int_t    GetADCAmp() const { return fADCAmp; }

  Int_t    GetADCOfflineAmp() const { return fADCOfflineAmp; }

  Double_t GetADCAmpGeVRough() const { return (Double_t)fADCAmp * EMCALTrigger::kEMCL1ADCtoGeV; }

  Int_t    GetTriggerBits() const { return fTriggerBits; }

  Int_t    GetEdgeCellX() const { return fEdgeCell[0]; }

  Int_t    GetEdgeCellY() const { return fEdgeCell[1]; }

  void     GetCellIndices( AliEMCALGeometry *geom, TArrayI *cells );
  
  Double_t GetPatchET() const { return GetET(GetPatchE()); }

  Double_t GetPatchETfromADCAmp() const { return GetET(GetADCAmpGeVRough()); }

  Int_t GetRowStart() const { return fRow0; }

  Int_t GetColStart() const { return fCol0; }

  Bool_t   IsLevel0() const { return TESTBIT(fTriggerBits, fOffSet + fTriggerBitConfig.GetLevel0Bit()); }

  Bool_t   IsJetLow() const { return TESTBIT(fTriggerBits, fOffSet + fTriggerBitConfig.GetJetLowBit()); }

  Bool_t   IsJetHigh() const { return TESTBIT(fTriggerBits, fOffSet + fTriggerBitConfig.GetJetHighBit()); }

  Bool_t   IsGammaLow() const { return TESTBIT(fTriggerBits, fOffSet + fTriggerBitConfig.GetGammaLowBit()); }

  Bool_t   IsGammaHigh() const { return TESTBIT(fTriggerBits, fOffSet + fTriggerBitConfig.GetGammaHighBit()); }

   Bool_t   IsBkg() const { return false; }

  Bool_t   IsMainTrigger() const { return false; }

  Bool_t   IsLevel0Simple() const { return TESTBIT(fTriggerBits, kOfflineOffset + fTriggerBitConfig.GetLevel0Bit()); }

  Bool_t   IsJetLowSimple() const { return TESTBIT(fTriggerBits, kOfflineOffset + fTriggerBitConfig.GetJetLowBit()); }

  Bool_t   IsJetHighSimple() const { return TESTBIT(fTriggerBits, kOfflineOffset + fTriggerBitConfig.GetJetHighBit()); }

  Bool_t   IsGammaLowSimple() const { return TESTBIT(fTriggerBits, kOfflineOffset + fTriggerBitConfig.GetGammaLowBit()); }

  Bool_t   IsGammaHighSimple() const { return TESTBIT(fTriggerBits, kOfflineOffset + fTriggerBitConfig.GetGammaHighBit()); }

  Bool_t   IsBkgSimple() const { return TESTBIT(fTriggerBits, kOfflineOffset + fTriggerBitConfig.GetBkgBit()); }

  Bool_t   IsLevel0Recalc() const { return TESTBIT(fTriggerBits, kRecalcOffset + fTriggerBitConfig.GetLevel0Bit()); }

  Bool_t   IsJetLowRecalc() const { return TESTBIT(fTriggerBits, kRecalcOffset + fTriggerBitConfig.GetJetLowBit()); }

  Bool_t   IsJetHighRecalc() const { return TESTBIT(fTriggerBits, kRecalcOffset + fTriggerBitConfig.GetJetHighBit()); }

  Bool_t   IsGammaLowRecalc() const { return TESTBIT(fTriggerBits, kRecalcOffset + fTriggerBitConfig.GetGammaLowBit()); }

  Bool_t   IsGammaHighRecalc() const { return TESTBIT(fTriggerBits, kRecalcOffset + fTriggerBitConfig.GetGammaHighBit()); }

  Bool_t   IsBkgRecalc() const { return TESTBIT(fTriggerBits, kRecalcOffset + fTriggerBitConfig.GetBkgBit()); }

  Bool_t   IsMainTriggerSimple() const { return kFALSE; }

  Bool_t   IsOfflineSimple() const { return IsJetLowSimple() || IsJetHighSimple() || IsGammaLowSimple() || IsGammaHighSimple(); }

  Bool_t   IsRecalc() const { return IsJetLowRecalc() || IsJetHighRecalc() || IsGammaLowRecalc() || IsGammaHighRecalc(); }

  Bool_t   IsOnline() const { return IsJetLow() || IsJetHigh() || IsGammaLow() || IsGammaHigh(); }

  const TLorentzVector &GetLorentzVectorCM() const { return fCenterMass; }

  const TLorentzVector &GetLorentzVectorCenterGeo() const { return fCenterGeo; }

  const TLorentzVector &GetLorentzVectorEdge1() const { return fEdge1; }

  const TLorentzVector &GetLorentzVectorEdge2() const { return fEdge2; }

  // Recalculated max patches
  Bool_t   IsRecalcJet() const { return IsJetLowRecalc() || IsJetHighRecalc(); }

  Bool_t   IsRecalcGamma() const { return IsGammaLowRecalc() || IsGammaHighRecalc(); }

  Bool_t         IsEMCal()         const { return (fDetectorType == kEMCALdet)   ; }

  Bool_t         IsDCalPHOS()      const { return (fDetectorType == kDCALPHOSdet); }

  CaloDetectorType_t GetDetectorType() const { return fDetectorType                  ; }

  Bool_t   TestTriggerBit(UInt_t bitnumber) const { return TESTBIT(fTriggerBits, bitnumber); }

  UChar_t  GetPatchSize() const { return fPatchSize; }

  void SetRowStart(int row0) { fRow0 = row0; }

  void SetCol0(int col0) { fCol0 = col0; }

  void SetCenterGeo( const TVector3 &v, Double_t e ) { SetLorentzVector( fCenterGeo, v, e ); }

  void SetCenterGeo( const TLorentzVector &v ) { fCenterGeo = v; }

  void SetCenterMass( const TLorentzVector &v ) { fCenterMass = v; }

  void SetCenterMass( const TVector3 &v, Double_t e ) { SetLorentzVector( fCenterMass, v, e ); }

  void SetEdge1( const TLorentzVector &v ) { fEdge1 = v; }

  void SetEdge1( const TVector3 &v, Double_t e ) { SetLorentzVector( fEdge1, v, e ); }

  void SetEdge2( const TLorentzVector &v ) { fEdge2 = v; }

  void SetEdge2( const TVector3 &v, Double_t e ) { SetLorentzVector( fEdge2, v, e ); }

  void SetADCAmp( Int_t a ) { fADCAmp = a; }

  void SetADCOfflineAmp( Int_t a ) { fADCOfflineAmp = a; }

  void SetSmearedEnergy(Double_t e) { fEnergySmeared = e; }

  void SetEdgeCell( Int_t x, Int_t y ) { fEdgeCell[0] = x; fEdgeCell[1] = y; }

  void SetOfflineSimple() { }

  void SetLorentzVector( TLorentzVector &lv, const TVector3 &v, Double_t e );

  void SetTriggerBits( Int_t i ) { fTriggerBits = i; }

  void SetDetectorType(CaloDetectorType_t t)  { fDetectorType = t; }

  void SetOffSet(Int_t i)        { fOffSet      = i; }

  void SetTriggerBitConfig(const AliEMCALTriggerBitConfig * ref) { fTriggerBitConfig.Initialise(*ref); }

  const AliEMCALTriggerBitConfig *GetTriggerBitConfig() const { return &fTriggerBitConfig; }


 protected:
  Double_t GetPhiTransform(Double_t phiin) const;
  Double_t GetET(Double_t energy) const;

  TLorentzVector    fCenterGeo;                     
  TLorentzVector    fCenterMass;                    
  TLorentzVector    fEdge1;                         
  TLorentzVector    fEdge2;                         
  Int_t             fADCAmp;                        
  Int_t             fADCOfflineAmp;                 
  Double_t          fEnergySmeared;                 
  Int_t             fTriggerBits;                   
  Int_t             fEdgeCell[2];                   
  Int_t             fOffSet;                        
  Int_t             fCol0;                          
  Int_t             fRow0;                          
  UChar_t           fPatchSize;                     
  CaloDetectorType_t    fDetectorType;                  
  AliEMCALTriggerBitConfig fTriggerBitConfig;     

  ClassDef(AliEMCALTriggerPatchInfo, 6) // Emcal particle class
};
#endif