StRefMultCorr.h

#ifndef __StRefMultCorr_h__
#define __StRefMultCorr_h__

// C++ headers
#include <vector>
#include <map>

// ROOT headers
#include "Rtypes.h"
#include "TString.h"
#include "BadRun.h"

//_________________
// Class to correct z-vertex dependence, luminosity dependence of multiplicity
class StRefMultCorr {
 public:
  StRefMultCorr(const TString name="refmult", const TString subname="Def", const TString libname="Def");
  virtual ~StRefMultCorr(); 
  
  Bool_t isBadRun(const Int_t RunId) ;

  // Event-by-event initialization. Call this function event-by-event
  // * Default ZDC coincidence rate = 0 to make the function backward compatible 
  // --> i.e. no correction will be applied unless users set the values for 200 GeV
  void initEvent(const UShort_t RefMult, const Double_t z, const Double_t zdcCoincidenceRate=0.0) ; // Set multiplicity, vz and zdc coincidence rate

  Bool_t isPileUpEvent(Double_t refmult, Double_t ntofmatch, Double_t vz=0.) const {
    return !passnTofMatchRefmultCut(refmult, ntofmatch, vz);
  }
  Bool_t passnTofMatchRefmultCut(Double_t refmult, Double_t ntofmatch, Double_t vz=0.) const;

  Double_t getRefMultCorr() const;
  // Corrected multiplity, flag=0:  Luminosity only, flag=1:  z-vertex only, flag=2:  full correction (default)
  Double_t getRefMultCorr(const UShort_t RefMult, const Double_t z,
                          const Double_t zdcCoincidenceRate, const UInt_t flag = 2) const;

  Double_t luminosityCorrection(Double_t zdcCoincidenceRate) const;
  Double_t vzCorrection(Double_t z) const;
  Double_t sampleRefMult(Int_t refMult) const;
  Double_t getShapeWeight_SubVz2Center() const;
  Double_t triggerWeight() const;

  Double_t getWeight() const;

  Int_t getCentralityBin16() const;
  Int_t getCentralityBin9() const;

  void init(const Int_t RunId);

  // Read scale factor from text file
  void setVzForWeight(const Int_t nbin, const Double_t min, const Double_t max) ;
  void readScaleForWeight(const Char_t* input) ;

  Int_t getBeginRun(const Double_t energy, const Int_t year);
  Int_t getEndRun(  const Double_t energy, const Int_t year);

  void print(const Option_t* option="") const ;

  void setVerbose(const Bool_t& verbose) { mVerbose = verbose; }

 private:
  const TString mName;
  const TString mSubName;
  const TString mLibName;

  // Functions

  void clear();
  Bool_t isIndexOk() const; 
  Bool_t isZvertexOk() const;
  Bool_t isRefMultOk() const;
  Bool_t isCentralityOk(const Int_t icent) const;
  Int_t setParameterIndex(const Int_t RunId);
  Bool_t mIsZr;
  Bool_t mIsRu;

  // Special scale factor for Run14 to take into account the weight
  // between different triggers
  //  - return 1 for all the other runs
  Double_t getScaleForWeight() const ;

  // Data members
  enum
  {
    mNCentrality = 16,
    mNPar_z_vertex = 8,
    mNPar_weight = 8,
    mNPar_luminosity = 2
  };

  // Use these variables to avoid varying the corrected multiplicity
  // in the same event by random numbers
  UShort_t mRefMult ;     
  Double_t mVz ;          
  Double_t mZdcCoincidenceRate ; 
  Double_t mRefMult_corr; 

  std::vector<Int_t> mYear              ; 
  std::vector<Int_t> mStart_runId       ; 
  std::vector<Int_t> mStop_runId        ; 
  std::vector<Double_t> mStart_zvertex  ; 
  std::vector<Double_t> mStop_zvertex   ; 
  std::vector<Double_t> mNormalize_stop ; 
  std::vector<Int_t>    mCentrality_bins[mNCentrality+1] ;  
  std::vector<Double_t> mPar_z_vertex[mNPar_z_vertex] ;     
  std::vector<Double_t> mPar_weight[mNPar_weight] ;         
  std::vector<Double_t> mPar_luminosity[mNPar_luminosity] ; 
  Int_t mParameterIndex; 

  std::multimap<std::pair<Double_t, Int_t>, Int_t> mBeginRun ; 
  std::multimap<std::pair<Double_t, Int_t>, Int_t> mEndRun   ; 
  std::vector<Int_t> mBadRun ; 

  // [6][680];
  Int_t mnVzBinForWeight ; 
  std::vector<Double_t> mVzEdgeForWeight ; 
  std::vector<Double_t> mgRefMultTriggerCorrDiffVzScaleRatio ; 

  Short_t mRefX;
  Bool_t mVerbose;

  const Int_t getRefX() const;  

  const Int_t getNumberOfDatasets() const; 
  void readHeaderFile();   
  void readBadRunsFromHeaderFile();  
  Int_t getVzWindowForVzDepCentDef() const;
  Int_t getCentralityBin9VzDep() const;
  Int_t getCentralityBin16VzDep() const;
  std::vector<std::string> StringSplit( const std::string str, const char sep ) const;

  // Read scale factor from header file
  void readScaleForWeight(const Int_t nRefmultBin, const Double_t *weight);

  Double_t calcPileUpRefMult(Double_t ntofmatch, Double_t x0, Double_t x1, 
                             Double_t x2, Double_t x3, Double_t x4) const;
  Bool_t isInPileUpRefMultLimits(Double_t refMult, Double_t low, Double_t hi) const 
  { return ( low < refMult && refMult < hi); }

  ClassDef(StRefMultCorr, 0)
};
#endif