AliFMDEventInspector.h

Go to the documentation of this file.

// 
// This class inspects the event 
//
#ifndef ALIFMDEVENTINSPECTOR_H
#define ALIFMDEVENTINSPECTOR_H

#include <TNamed.h>
#include <TAxis.h>
#include <TList.h>
#include "AliDisplacedVertexSelection.h"
class AliESDEvent;
class AliOADBPhysicsSelection;
class TH2D;
class TH1D;
class TH1I;
class TH1F;
class TH2F;
class TH2I;
class TAxis;
class TVector3;
// class TList;

class AliFMDEventInspector : public TNamed
{
public:
  enum ECodes {
    kOk = 0,
    kNoEvent = 0x1, 
    kNoTriggers = 0x2, 
    kNoSPD = 0x4, 
    kNoFMD = 0x8, 
    kNoVertex = 0x10, 
    kBadVertex = 0x20
  };
  enum ETrgBins { 
    kInel, 
    kInelGt0, 
    kNSD,
    kV0AND, 
    kEmpty, 
    kA, 
    kB, 
    kC, 
    kE,
    kPileUp,
    kMCNSD,
    kSatellite,
    kSpdOutlier,
    kOffline
  };
  enum EVtxType { 
    kNormal, 
    kpA2012, 
    kpA2013, 
    kPWGUD, 
    kDisplaced
  };
  enum EPileupType { 
    kSPD          = 0x1, 
    kTracks       = 0x2,
    kOutOfBunch   = 0x4,
    kSPDBins      = 0x8
  };
  enum ECentMethod { 
    kV0Multiplicity, 
    kV0Amplitude, 
    kV0Charge, 
    kFMDRough, 
    kNTracks, 
    kLTracks, 
    kCL0, 
    kCL1, 
    kCND, 
    kNParticles,
    kNeutrons,
    kV0vsFMD, 
    kV0vsNTracks, 
    kZEMvsZDC,
    kDefaultCent 
  };

  enum ECollisionSystem { 
    kUnknown,
    kPP, 
    kPbPb
  };
  enum EVtxStatus { 
    kVtxOK = 1, 
    kNoVtx, 
    kNoSPDVtx, 
    kFewContrib, 
    kUncertain,
    kNotVtxZ
  }; 
  enum ETrgStatus {
    kNoTrgWords=1,
    kPP2760Fast, 
    kMUON,
    kTriggered,
    kMinBias,           // CINT1
    kMinBiasNoSPD,      // CINT5
    kV0AndTrg,          // CINT7
    kMinBiasAD,         // CINT10
    kHighMult,
    kCentral, 
    kSemiCentral, 
    kDiffractive,
    kADOr,              // 
    kADAnd,             // 
    kUser,
    kOther
  };
  static const char* fgkFolderName;
  AliFMDEventInspector();
  AliFMDEventInspector(const char* name);
  virtual ~AliFMDEventInspector();

  virtual void SetupForData(const TAxis& vtxAxis);
  UInt_t Process(const AliESDEvent* event, 
     UInt_t&            triggers,
     Bool_t&            lowFlux,
     UShort_t&          ivz, 
     TVector3&          ip,
     Double_t&          cent,
     UShort_t&          nClusters);
  void CreateOutputObjects(TList* dir);
  void SetLowFluxCut(Int_t c) { fLowFluxCut = c; }
  void SetMaxVzErr(Double_t c=0.1) { fMaxVzErr = c; }
  void SetVertexMethod(EVtxType t) { fVtxMethod = t; }
  void SetUseFirstPhysicsVtx(Bool_t use) {
    SetVertexMethod(use ? kPWGUD : kNormal); }
  void SetpA2012Vtx(Bool_t use) {
    SetVertexMethod(use ? kpA2012 : kNormal); }
  void SetUseV0AndForNSD(Bool_t use=true) {fUseV0AND = use; }
  void SetMinPileupContributors(UShort_t nContrib=3) 
  { 
    fMinPileupContrib = nContrib;
  }
  void SetMinPileupDistance(Double_t cm=0.8)
  {
    fMinPileupDistance = cm;
  }
  void SetUseDisplacedVertices(Bool_t use=true) { 
    SetVertexMethod(use ? kDisplaced : kNormal); }  
  Bool_t IsUseDisplacedVertices() const { return AllowDisplaced(); }
  void SetMinCentrality(Double_t mincent=-1.0);
  void SetMaxCentrality(Double_t maxcent=-1.0);
  void SetCentralityMethod(const TString& m) { fCentMethod = m; }
  void SetCentralityMethod(ECentMethod m);
  void SetPileupFlags(UShort_t flags=0x5) { fPileupFlags = flags; }
  void SetDebug(Int_t dbg=1) { fDebug = dbg; }
  void SetMC(Bool_t isMC=true) { fMC = isMC; }
  Bool_t IsMC() const { return fMC; }
  Bool_t FetchHistograms(const TList* d, 
       TH1I*& hEventsTr, 
       TH1I*& hEventsTrVtx, 
       TH1I*& hEventsAcc,
       TH1I*& hTriggers) const;
  Bool_t ReadRunDetails(const AliESDEvent* esd);
  UShort_t GetCollisionSystem() const { return fCollisionSystem; }
  UShort_t GetEnergy() const { return fEnergy; }
  Short_t  GetField() const { return fField; }
  ULong_t GetRunNumber() const { return fRunNumber; }
  Short_t GetProductionYear() const { return fProdYear; }
  Char_t  GetProductionPeriod() const { return fProdLetter; } 
  Short_t GetProductionRevision() const { return fProdSVN; } 
  Bool_t  IsProductionMC() const { return fProdMC; }
  
  void Print(Option_t* option="") const;
  // getter for fmincentrality
  // Double_t GetMinCentrality() const { return fMinCent;}
  // gettter for fmaxcentrality 
  // Double_t GetMaxCentrality() const { return fMaxCent;}
  virtual void StoreInformation();
  virtual void StoreProduction();
  static const char* CodeString(UInt_t mask);
protected:
  AliFMDEventInspector(const AliFMDEventInspector& o)
    : TNamed(o),
      fHEventsTr(0), 
      fHEventsTrVtx(0),
      fHEventsAccepted(0),
      fHEventsAcceptedXY(0),
      fHTriggers(0),
      fHType(0),
      fHWords(0),
      fHCent(0),
      fHCentVsQual(0),
      fHStatus(0),
      fHVtxStatus(0),
      fHTrgStatus(0), 
      fHPileup(0),
      fLowFluxCut(1000),
      fMaxVzErr(0.2),
      fList(0),
      fEnergy(0),
      fField(999), 
      fCollisionSystem(kUnknown),
      fDebug(0),
      fCentAxis(0),
      fVtxAxis(10,-10,10),
      fVtxMethod(kNormal),
      // fUseFirstPhysicsVertex(false),
      fUseV0AND(false),
      fPileupFlags(kSPD|kTracks|kOutOfBunch|kSPDBins),
      fMinPileupContrib(3), 
      fMinPileupDistance(0.8),
      // fUseDisplacedVertices(false),
      fDisplacedVertex(),
      fCollWords(),
      fBgWords(),
      fCentMethod("default"),
      fMinCent(-1.0),
      fMaxCent(-1.0),
      // fUsepA2012Vertex(false),
      fRunNumber(0),
      fMC(false),
      fProdYear(-1),
      fProdLetter('?'),
      fProdPass(-1),
      fProdSVN(-1),
      fProdMC(false)
  {}
  AliFMDEventInspector& operator=(const AliFMDEventInspector&){return *this;}
  Bool_t AllowDisplaced() const { return fVtxMethod == kDisplaced; }
  void CacheConfiguredTriggerClasses(TList& cache, 
             const TList* classes,
             AliOADBPhysicsSelection* o);
  Bool_t ReadTriggers(const AliESDEvent& esd, UInt_t& triggers, 
          UShort_t& nClusters);
  Bool_t CheckpAExtraV0(const AliESDEvent& esd) const;
  virtual Bool_t CheckFastPartition(bool fastonly) const;
  virtual Bool_t CheckINELGT0(const AliESDEvent& esd, UShort_t& nClusters, 
            UInt_t& triggers) const;
  virtual Bool_t CheckPileup(const AliESDEvent& esd, UInt_t& triggers) const;
  virtual Bool_t CheckMultiVertex(const AliESDEvent& esd, 
          Bool_t checkOtherBC=false) const;
  virtual Bool_t CheckCosmics(const TString& trigStri) const;
  virtual Bool_t CheckEmpty(const TString& trigStr, UInt_t& triggers) const;
  virtual Bool_t CheckWords(const AliESDEvent& esd, UInt_t& triggers) const;
  Bool_t ReadVertex(const AliESDEvent& esd, TVector3& ip);
  virtual EVtxStatus CheckPWGUDVertex(const AliESDEvent& esd, 
              TVector3& ip) const;
  virtual EVtxStatus CheckpA2012Vertex(const AliESDEvent& esd, 
               TVector3& ip) const;
  virtual EVtxStatus CheckpA2013Vertex(const AliESDEvent& esd, 
               TVector3& ip) const;
  virtual EVtxStatus CheckVertex(const AliESDEvent& esd, TVector3& ip) const;
  virtual Bool_t ReadCentrality(const AliESDEvent& esd, Double_t& cent,
        UShort_t& qual) const;

  TH1I*    fHEventsTr;            
  TH1I*    fHEventsTrVtx;         
  TH1I*    fHEventsAccepted;      
  TH2D*    fHEventsAcceptedXY;    
  TH1I*    fHTriggers;            
  TH1I*    fHType;                
  TH1I*    fHWords;               
  TH1F*    fHCent;                
  TH2F*    fHCentVsQual;          
  TH1I*    fHStatus;              
  TH1I*    fHVtxStatus;           
  TH1I*    fHTrgStatus;           
  TH1I*    fHPileup;              
  Int_t    fLowFluxCut;           //  Low flux cut
  Double_t fMaxVzErr;             //  Maximum error on v_z
  TList*   fList;                 
  UShort_t fEnergy;               // CMS energy (per nucleon pair) [GeV]
  Short_t  fField;                // L3 magnetic field [kG]
  UShort_t fCollisionSystem;      //  Collision system
  Int_t    fDebug;                //  Debug level 
  TAxis*   fCentAxis;             // Centrality axis used in histograms
  TAxis    fVtxAxis;              // IP_z Axis 
  EVtxType fVtxMethod;            // Vertex method to use 
  // Bool_t   fUseFirstPhysicsVertex;//Use the vtx code from p+p first physics
  Bool_t   fUseV0AND;             // Use the vtx code from p+p first physics
  UShort_t fPileupFlags;          // Which pileups to use 
  UShort_t fMinPileupContrib;     // Min contributors to 2nd pile-up IP
  Double_t fMinPileupDistance;    // Min distance of 2nd pile-up IP
  // Bool_t   fUseDisplacedVertices; // Analyze displaced vertices?
  AliDisplacedVertexSelection fDisplacedVertex; //Displaced vertex selector
  TList    fCollWords;            
  TList    fBgWords;              
  TString  fCentMethod;           // Centrality method
  Double_t fMinCent;              // min centrality
  Double_t fMaxCent;              // max centrailty
  // Bool_t   fUsepA2012Vertex;      // flag to use pA2012 Veretx selection
  ULong_t  fRunNumber;            // Current run number 
  Bool_t   fMC;                   // Is this MC input
  Short_t  fProdYear;             // Production year 
  Char_t   fProdLetter;           // Production letter 
  Short_t  fProdPass;             // Pass number 
  Int_t    fProdSVN;              // AliROOT revision used in production
  Bool_t   fProdMC;               // True if anchor production

  ClassDef(AliFMDEventInspector,16); // Inspect the event 
};

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