AliAODForwardMult.h

Go to the documentation of this file.

//
// See implementation or Doxygen comments for more information
//
#ifndef ALIAODFORWARDMULT_H
#define ALIAODFORWARDMULT_H

#include <TObject.h>
#include <TH2D.h>
class TBrowser;
class TH1I;
class AliAODForwardMult : public TObject
{
public:
  enum ETriggerBits { 
    kInel        = 0x0001, 
    kInelGt0     = 0x0002, 
    kNSD         = 0x0004, 
    kEmpty       = 0x0008, 
    kA           = 0x0010, 
    kB           = 0x0020, 
    kC           = 0x0080,  
    kE           = 0x0100,
    kPileUp      = 0x0200,    
    kMCNSD       = 0x0400,    
    kOffline     = 0x0800,
    kNClusterGt0 = 0x1000,
    kV0AND       = 0x2000, 
    kSatellite   = 0x4000,
    kSPDOutlier  = 0x8000,
    kPileupSPD   = 0x10000,
    kPileupTrack = 0x20000,
    kPileupBC    = 0x40000,
    kPileupBins  = 0x80000,
    kADOR        = 0x100000,
    kADAND       = 0x200000,
    kCentNoCalib = 0x4000000,
    kInclusive   = 0x8000000,
    kDefaultFilter = kCentNoCalib|kPileupBins|kSPDOutlier
  };
  enum ETriggerBins { 
    kBinAll=1,
    kBinInel, 
    kBinInelGt0, 
    kBinNSD, 
    kBinV0AND,
    kBinADOR,
    kBinADAND,
    kBinA, 
    kBinB, 
    kBinC, 
    kBinE,
    kBinSatellite,
    kBinMCNSD,
    kBinPileUp, 
    kBinOffline,
    kBinNClusterGt0,
    kWithTrigger, 
    kWithVertex, 
    kAccepted
  };
  enum EFlags {
    kSecondary           = (1 << 14), 
    kVertexBias          = (1 << 15),  
    kAcceptance          = (1 << 16), 
    kMergingEfficiency   = (1 << 17),
    kSum                 = (1 << 18), 
    kEmpirical           = (1 << 19)
  };
  enum ECheckStatus {
    kGoodEvent = 0, 
    kWrongCentrality, 
    kWrongTrigger, 
    kIsPileup,
    kIsFilterOut,
    kNoVertex, 
    kWrongVertex,
    kOutlierEvent
  };
    
  AliAODForwardMult();
  AliAODForwardMult(Bool_t isMC);
  virtual ~AliAODForwardMult() {} // Destructor 
  void Init(const TAxis& etaAxis);
  const TH2D& GetHistogram() const { return fHist; } // Get histogram 
  TH2D& GetHistogram() { return fHist; } // Get histogram
  Int_t GetEtaCoverageBin() const { return 0; }
  Int_t GetPhiAcceptanceBin() const { return fHist.GetNbinsY()+1; }
  TH1* GetEtaCoverage() const;
  TH1* GetPhiAcceptance() const;
  void FillEtaCoverage(TH1& h) const;
  void FillPhiAcceptance(TH1& h) const;
  /* @} */
  void SetIpZ(Float_t ipZ) { fIpZ = ipZ; } // Set Ip's Z coordinate
  Float_t GetIpZ() const { return fIpZ; } // Get Ip's Z coordinate 
  Bool_t HasIpZ() const;
  Bool_t InRange(Float_t low, Float_t high) const;
  /* @} */
  void SetSNN(UShort_t sNN); 
  void SetSystem(UShort_t sys);
  UShort_t GetSNN() const;
  UShort_t GetSystem() const;
  void SetCentrality(Float_t c) { fCentrality = c; }
  Float_t GetCentrality() const { return fCentrality; }
  Bool_t  HasCentrality() const { return !(fCentrality  < 0); }
  /* @} */
  UShort_t GetNClusters() const { return fNClusters; }
  void SetNClusters(UShort_t n) { fNClusters = n; }
  /* @} */
  UInt_t GetTriggerBits() const { return fTriggers; } // Get triggers
  void SetTriggerMask(UInt_t trg) { fTriggers = trg; } // Set triggers 
  void SetTriggerBits(UInt_t bits) { fTriggers |= bits; } // Set trigger bits
  static Bool_t IsTriggerBits(UInt_t bits, UInt_t trg);
  Bool_t IsTriggerBits(UInt_t bits) const;
  Bool_t IsTriggerOrBits(UInt_t bits) const;
  Bool_t HasTrigger() const { return fTriggers != 0; } // Check for triggers
  static const Char_t* GetTriggerString(UInt_t mask, const char* sep="&");
  static UInt_t MakeTriggerMask(const char* what, const char* sep="&");
  /* @} */
  Bool_t IsInel() const { return (fTriggers & kInel); } 
  Bool_t IsInelGt0() const { return (fTriggers & kInelGt0); } 
  Bool_t IsNSD() const { return (fTriggers & kNSD); } 
  Bool_t IsEmpty() const { return (fTriggers & kEmpty); } 
  Bool_t IsBeamEmpty() const { return (fTriggers & kA); } 
  Bool_t IsBeamBeam() const { return (fTriggers & kB); } 
  Bool_t IsEmptyBeam() const { return (fTriggers & kC); }  
  Bool_t IsEmptyEmpty() const { return (fTriggers & kE); }
  Bool_t IsPileUp() const { return (fTriggers & kPileUp); }    
  Bool_t IsMCNSD() const { return (fTriggers & kMCNSD); }    
  Bool_t IsOffline() const { return (fTriggers & kOffline); }
  Bool_t IsNClusterGt0() const { return (fTriggers & kNClusterGt0); }
  Bool_t IsV0AND() const { return (fTriggers & kV0AND); } 
  Bool_t IsSatellite() const { return (fTriggers & kSatellite); }
  Bool_t IsSPDOutlier() const { return (fTriggers & kSPDOutlier); }
  Bool_t IsPileupSPD() const { return (fTriggers & kPileupSPD); }
  Bool_t IsPileupTrack() const { return (fTriggers & kPileupTrack); }
  Bool_t IsPileupBC() const { return (fTriggers & kPileupBC); }
  Bool_t IsPileupBins() const { return (fTriggers & kPileupBins); }
  /* @} */
  Bool_t IsSecondaryCorrected() const { return TestBit(kSecondary); }
  Bool_t IsVertexBiasCorrected() const { return TestBit(kVertexBias); }
  Bool_t IsAcceptanceCorrected() const { return TestBit(kAcceptance); }
  Bool_t IsMergingEfficiencyCorrected() const { 
    return TestBit(kMergingEfficiency); }
  Bool_t IsEmpiricalCorrected() const { return TestBit(kEmpirical); }
  Bool_t IsSumSignal() const { return TestBit(kSum); }
  /* @} */
  const Char_t* GetName() const { return (fIsMC ? "ForwardMC" : "Forward"); }
  void Clear(Option_t* option="");
  void Browse(TBrowser* b);
  Bool_t IsFolder() const { return kTRUE; } // Always true 
  
  void Print(Option_t* option="") const;
  /* @} */
  /* @} */
  Bool_t CheckEvent(UInt_t   triggerMask=kInel,
        Double_t vzMin=-10, Double_t vzMax=10,
        Double_t cMin=0,    Double_t cMax=100, 
        TH1*     hist=0,
        TH1*     status=0,
        UInt_t   filterMask=kDefaultFilter) const;
  static void FillTriggerHistogram(UInt_t triggerMask, UInt_t trg, TH1* hist);
  Bool_t FilterEvent(Double_t vzMin, Double_t vzMax,
         TH1* hist, TH1* status,
         UInt_t filterMask) const;
  static TH1I* MakeTriggerHistogram(const char* name="triggers",
            UInt_t mask=0);
  static TH1I* MakeStatusHistogram(const char* name="status");
  /* @} */
protected: 
  Bool_t   fIsMC;       // Whether this is from MC 
  TH2D     fHist;       // Histogram of N_{ch}(eta,phi)
  UInt_t   fTriggers;   // Trigger bit mask 
  Float_t  fIpZ;        // Z coordinate of the interaction point
  Float_t  fCentrality; // Event centrality 
  UShort_t fNClusters;  // Number of SPD clusters in |eta|<1
  static const Float_t fgkInvalidIpZ; // Invalid IpZ value 
  ClassDef(AliAODForwardMult,7); // AOD forward multiplicity 
};

//____________________________________________________________________
inline Bool_t
AliAODForwardMult::InRange(Float_t low, Float_t high) const 
{
  return HasIpZ() && fIpZ >= low && fIpZ < high;
}

//____________________________________________________________________
inline Bool_t 
AliAODForwardMult::IsTriggerBits(UInt_t bits) const 
{
  return IsTriggerBits(bits, fTriggers);
}
//____________________________________________________________________
inline Bool_t 
AliAODForwardMult::IsTriggerBits(UInt_t bits, UInt_t trig)
{
  const UInt_t mask = ~kInclusive;
  if (bits & kInclusive)
    return trig > 0 && ((trig & mask & bits) != 0);
  return trig > 0 && ((trig & mask & bits) == bits); 
}

//____________________________________________________________________
inline Bool_t 
AliAODForwardMult::IsTriggerOrBits(UInt_t bits) const 
{ 
  return HasTrigger() && ((fTriggers & bits) != 0);
}

#endif
// Local Variables:
//  mode: C++
// End: