//////////////////////////////////////////////////////////////////////
//
// $Id: StFlowEvent.h,v 1.56 2009/11/24 19:23:03 posk Exp $
//
// Author: Raimond Snellings and Art Poskanzer
//          FTPC added by Markus Oldenburg, MPI, Dec 2000
//          Cumulants added by Aihong Tang, KSU, Nov 2001
//
//////////////////////////////////////////////////////////////////////
//
// Description: A subset of StEvent with flow functions
//
//////////////////////////////////////////////////////////////////////

#ifndef StFlowEvent_h
#define StFlowEvent_h
#include "StObject.h"
#include "StFlowTrackCollection.h"
#include "StTrackTopologyMap.h"
#include "StThreeVectorF.hh"
#include "StEnumerations.h"
#include "Rtypes.h"
#include "TVector2.h"
#include "TComplex.h"
class StFlowSelection;

class StFlowEvent  : public StObject {

public:

  StFlowEvent();
  virtual        ~StFlowEvent();

  Double_t       PhiWeight(Int_t selN, Int_t harN, StFlowTrack* pFlowTrack) const;
  Double_t       PhiWeightRaw(Int_t selN, Int_t harN, StFlowTrack* pFlowTrack) const;
  Double_t       Weight(Int_t selN, Int_t harN, StFlowTrack* pFlowTrack) const;
  Double_t       ZDCSMD_PsiWgtEast();
  Double_t       ZDCSMD_PsiWgtWest();
  Double_t       ZDCSMD_PsiWgtFull();
  Int_t          EventID() const;
  Int_t          RunID() const;
  Double_t       CenterOfMassEnergy() const;
  Double_t       MagneticField() const;
  Short_t        BeamMassNumberEast() const;
  Short_t        BeamMassNumberWest() const;
  UInt_t         OrigMult() const;
  UInt_t         L0TriggerWord() const;
  UInt_t         UncorrNegMult() const;
  UInt_t         UncorrPosMult() const;
  UInt_t         MultEta() const;
  UInt_t         FlowEventMult() const;
  UInt_t         Centrality() const;
  StThreeVectorF VertexPos() const;
  UInt_t         Mult(StFlowSelection*);
  UInt_t         MultPart(StFlowSelection*);
  TVector2       Q(StFlowSelection*);
  TVector2       NormQ(StFlowSelection* pFlowSelect);
  TVector2       QPart(StFlowSelection*);
  TVector2       ReCentEPPar(StFlowSelection*, const char*); // for ana
  TVector2       ReCentPar(StFlowSelection*, const char*); // for LYZ
  TVector2       ReCent(Int_t selN, Int_t harN, StFlowTrack* pFlowTrack) const;
  TVector2       ReCentEP(Int_t selN, Int_t harN, StFlowTrack* pFlowTrack) const;
  Float_t        q(StFlowSelection*);
  Float_t        MeanPt(StFlowSelection*);
  Float_t        Qtheta(StFlowSelection*, Float_t theta);
  TComplex       Grtheta(StFlowSelection*, Float_t r, Float_t theta);
  TComplex       GV1r0theta(StFlowSelection*, Float_t r, Float_t theta1, Float_t theta);
  TComplex       Gder_r0theta(StFlowSelection*, Float_t r, Float_t theta);
  Float_t        Psi(StFlowSelection*);
  Float_t 	 ZDCSMD_PsiCorr();
  Float_t 	 ZDCSMD_PsiEst();
  Float_t        ZDCSMD_PsiWst();
  Float_t 	 ZDCSMD_GetPosition(int eastwest,int verthori,int strip);
  Double_t       G_New(StFlowSelection* pFlowSelect, Double_t Zx, Double_t Zy);
  Double_t       G_Mix(StFlowSelection* pFlowSelect, Double_t Z1x, Double_t Z1y, Double_t Z2x, Double_t Z2y);
  Double_t       SumWeightSquare(StFlowSelection* pFlowSelect);
  Double_t       PtAbsWgtValue(Double_t pt) const;
  Double_t       EtaAbsWgtValue(Double_t eta) const;
  Float_t        CTB() const;
  Float_t        ZDCe() const;
  Float_t        ZDCw() const;
  Float_t	 ZDCSMD(int eastwest,int verthori,int strip) const;
  Float_t        PtWgtSaturation() const;
  Bool_t         PtWgt() const;
  Bool_t         EtaWgt() const;
  Bool_t         FirstLastPhiWgt() const;
  Bool_t         FirstLastPoints() const;
  Bool_t	 UseZDCSMD() const;
  Char_t*        Pid();
  Bool_t         EtaSubs() const;
  Bool_t         RanSubs() const;

  Float_t V1TPCDetctWgtG_Mix(Int_t selN) const;
  Float_t V1FtpcEastDetctWgtG_Mix(Int_t selN) const;
  Float_t V1FtpcWestDetctWgtG_Mix(Int_t selN) const;

  Float_t V2TPCDetctWgtG_Mix(Int_t selN) const;
  Float_t V2FtpcEastDetctWgtG_Mix(Int_t selN) const;
  Float_t V2FtpcWestDetctWgtG_Mix(Int_t selN) const;


  StFlowTrackCollection* TrackCollection() const;

  void SetSelections();
  void SetPid(const Char_t*);
  void SetPidsDeviant();
  void SetPidsProb();
  void PrintSelectionList();
  void MakeSubEvents();
  void MakeEtaSubEvents();
  void SetEventID(const Int_t&);
  void SetRunID(const Int_t&);
  void SetCenterOfMassEnergy(const Double_t&);
  void SetMagneticField(const Double_t&);
  void SetBeamMassNumberEast(const Short_t&);
  void SetBeamMassNumberWest(const Short_t&);
  void SetOrigMult(const UInt_t&);
  void SetL0TriggerWord(const UInt_t&);
  void SetUncorrPosMult(const UInt_t&);
  void SetUncorrNegMult(const UInt_t&);
  void SetMultEta(const UInt_t&);
  void SetCentrality();
  void SetVertexPos(const StThreeVectorF&);
  void SetCTB(const Float_t ctb);
  void SetZDCe(const Float_t zdce);
  void SetZDCw(const Float_t zdcw);
  void SetZDCSMD(int eastwest,int verthori,int strip,const Float_t zdcsmd);
#ifndef __CINT__		
  void SetPhiWeightFarEast(const Flow::PhiWgt_t &pPhiWgt);
  void SetPhiWeightEast(const Flow::PhiWgt_t &pPhiWgt);
  void SetPhiWeightWest(const Flow::PhiWgt_t &pPhiWgt);
  void SetPhiWeightFarWest(const Flow::PhiWgt_t &pPhiWgt);
  void SetPhiWeightFtpcFarEast(const Flow::PhiWgtFtpc_t &pPhiWgt);
  void SetPhiWeightFtpcEast(const Flow::PhiWgtFtpc_t &pPhiWgt);
  void SetPhiWeightFtpcWest(const Flow::PhiWgtFtpc_t &pPhiWgt);
  void SetPhiWeightFtpcFarWest(const Flow::PhiWgtFtpc_t &pPhiWgt);
  void SetZDCSMD_PsiWeightWest(const Flow::ZDCSMD_PsiWgt_t&  ZDCSMD_PsiWgtWest);
  void SetZDCSMD_PsiWeightEast(const Flow::ZDCSMD_PsiWgt_t&  ZDCSMD_PsiWgtEast); 
  void SetZDCSMD_PsiWeightFull(const Flow::ZDCSMD_PsiWgt_t&  ZDCSMD_PsiWgtFull);
  void SetZDCSMD_BeamCenter(Double_t ex,Double_t ey,Double_t wx,Double_t wy);
  void SetReCentX(const Flow::ReCent_t &pReCentX);
  void SetReCentY(const Flow::ReCent_t &pReCentY);
#endif
  static void SetEtaTpcCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN);
  
  //#Added by jcampbell
  static Float_t EtaTpcCut(Int_t lowOrHigh, Int_t harN, Int_t selN);
  static Float_t Etaq2Cut(Int_t lowOrHigh);
  static void SetEtaq2Cut(Float_t lo, Float_t hi);
  static void SetEtaGap(Float_t gap);
  
  static void SetPtTpcCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN);
  static void SetEtaFtpcCut(Float_t lo_neg, Float_t hi_neg, 
			    Float_t lo_pos, Float_t hi_pos, 
			    Int_t harN, Int_t selN);
  static void SetPtFtpcCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN);
  static void SetPiPlusCut(Float_t lo, Float_t hi);
  static void SetPiMinusCut(Float_t lo, Float_t hi);
  static void SetProtonCut(Float_t lo, Float_t hi);
  static void SetAntiProtonCut(Float_t lo, Float_t hi);
  static void SetKPlusCut(Float_t lo, Float_t hi);
  static void SetKMinusCut(Float_t lo, Float_t hi);
  static void SetElectronCut(Float_t lo, Float_t hi);
  static void SetPositronCut(Float_t lo, Float_t hi);
  static void SetDeuteronCut(Float_t lo, Float_t hi);
  static void SetAntiDeuteronCut(Float_t lo, Float_t hi);
  static void SetDcaGlobalTpcCut(Float_t lo, Float_t hi);
  static void SetDcaGlobalFtpcCut(Float_t lo, Float_t hi);
  static void SetProbPid();
  static void SetEtaSubs();
  static void SetRanSubs();
  static void SetPtWgtSaturation(Float_t);
  static void SetPtWgt(Bool_t);
  static void SetEtaWgt(Bool_t);
  static void SetFirstLastPhiWgt();
  static void SetFirstLastPoints();
  static void SetUseZDCSMD(Bool_t);

  static void SetV1TPCDetctWgtG_Mix(Float_t val,  Int_t selN);
  static void SetV1FtpcEastDetctWgtG_Mix(Float_t val, Int_t selN);
  static void SetV1FtpcWestDetctWgtG_Mix(Float_t val,  Int_t selN);


  static void SetV2TPCDetctWgtG_Mix(Float_t val,  Int_t selN);
  static void SetV2FtpcEastDetctWgtG_Mix(Float_t val, Int_t selN);
  static void SetV2FtpcWestDetctWgtG_Mix(Float_t val,  Int_t selN);
  static Bool_t ProbPid();


private:

  Int_t               mEventID;                                  // ID of the event
  Int_t               mRunID;                                    // ID of the run
  Double_t            mMagneticField;                            // 
  Double_t            mCenterOfMassEnergy;                       // 
  Short_t             mBeamMassNumberEast;                       //
  Short_t             mBeamMassNumberWest;                       //
  UInt_t              mOrigMult;                                 // number of tracks
  UInt_t              mL0TriggerWord;                            // L0 trigger word
  UInt_t              mUncorrNegMult;                            // number of h-
  UInt_t              mUncorrPosMult;                            // number of h+
  UInt_t              mMultEta;                                  // number of tracks
                                                // with pos. flag in 1.5 unit of eta
  UInt_t              mCentrality;                               // centrality bin
  StThreeVectorF      mVertexPos;                                // primary vertex position
  Float_t             mCTB;                                      // CTB value sum
  Float_t             mZDCe;                                     // ZDC east
  Float_t             mZDCw;                                     // ZDC west
  Float_t	      mZDCSMD[2][2][8];				 // ZDCSMD
  static Double_t     mZDCSMDCenterex,mZDCSMDCenterey;           // ZDCSMD Beam Center
  static Double_t     mZDCSMDCenterwx,mZDCSMDCenterwy;           // ZDCSMD Beam Center
  static Float_t      mEtaTpcCuts[2][2][Flow::nSels];            // range absolute values
  static Float_t      mEtaGap;                                   // size of eta gap // # added by jmcampbell
  static Float_t      mEtaq2Cuts[2];                             //  eta range for q2 cuts // # added by jmcampbell
  static Float_t      mEtaFtpcCuts[4][2][Flow::nSels];           // range values
  static Float_t      mPtTpcCuts[2][2][Flow::nSels];             // range
  static Float_t      mPtFtpcCuts[2][2][Flow::nSels];            // range

  static Float_t      mV1TPCDetctWgtG_Mix[Flow::nSels]; // detector wgt for G_Mix in v1{3} calc.
  static Float_t      mV1FtpcEastDetctWgtG_Mix[Flow::nSels]; 
  static Float_t      mV1FtpcWestDetctWgtG_Mix[Flow::nSels]; 
  static Float_t      mV2TPCDetctWgtG_Mix[Flow::nSels]; 
  static Float_t      mV2FtpcEastDetctWgtG_Mix[Flow::nSels]; 
  static Float_t      mV2FtpcWestDetctWgtG_Mix[Flow::nSels]; 

  Flow::PhiWgt_t      mPhiWgtFarEast;                            //!flattening weights FarEast
  Flow::PhiWgt_t      mPhiWgtEast;                               //!flattening weights East
  Flow::PhiWgt_t      mPhiWgtWest;                               //!flattening weights West
  Flow::PhiWgt_t      mPhiWgtFarWest;                            //!flattening weights FarWest
  Flow::PhiWgtFtpc_t  mPhiWgtFtpcFarEast;                        //!flattening weights Ftpc FarEast
  Flow::PhiWgtFtpc_t  mPhiWgtFtpcEast;                           //!flattening weights Ftpc East
  Flow::PhiWgtFtpc_t  mPhiWgtFtpcWest;                           //!flattening weights Ftpc West
  Flow::PhiWgtFtpc_t  mPhiWgtFtpcFarWest;                        //!flattening weights Ftpc FarWest
  Flow::ZDCSMD_PsiWgt_t  mZDCSMD_PsiWgtWest;		         //! ZDCSMD west Psi
  Flow::ZDCSMD_PsiWgt_t  mZDCSMD_PsiWgtEast;        		 //! ZDCSMD east Psi
  Flow::ZDCSMD_PsiWgt_t  mZDCSMD_PsiWgtFull;                     //! ZDCSMD full Psi
  Flow::ReCent_t      mReCentX;                                  //! recentering parameters
  Flow::ReCent_t      mReCentY;                                  //! recentering parameters

  static Float_t      mPiPlusCuts[2];                            // PID cuts
  static Float_t      mPtWgtSaturation;                          // saturation value for pt weighting
  static Bool_t       mPtWgt;                                    // flag for pt weighting
  static Bool_t       mEtaWgt;                                   // flag for y weighting for odd harmonics
  static Char_t       mPid[10];                                  // h+, h-, pi-, pi+, pi, k+, k-, k, pr+, pr-, pr, e+, e-, e
  static Bool_t       mProbPid;                                  // flag for probability pid
  static Bool_t       mEtaSubs;                                  // flag for eta subevents
  static Bool_t       mRanSubs;                                  // flag for random subevents
  static Bool_t       mFirstLastPhiWgt;                          // flag for using z of first and last points for reading phi weights
  static Bool_t       mFirstLastPoints;                          // flag for using z of first and last points for generating phi weights
  static Bool_t	      mUseZDCSMD;				 // flag for using ZDC SMD for RP
  static Float_t      mPiMinusCuts[2];
  static Float_t      mProtonCuts[2];
  static Float_t      mKMinusCuts[2];
  static Float_t      mKPlusCuts[2];
  static Float_t      mAntiProtonCuts[2];
  static Float_t      mDeuteronCuts[2];
  static Float_t      mAntiDeuteronCuts[2];
  static Float_t      mElectronCuts[2];
  static Float_t      mPositronCuts[2];
  static Float_t      mDcaGlobalTpcCuts[2];
  static Float_t      mDcaGlobalFtpcCuts[2];

  StFlowTrackCollection* pTrackCollection;   //!

  ClassDef(StFlowEvent,1)                    // macro for rootcint

};

inline StFlowTrackCollection* StFlowEvent::TrackCollection() const {
  return pTrackCollection; }

inline Int_t StFlowEvent::EventID() const { return mEventID; }

inline Int_t StFlowEvent::RunID() const { return mRunID; }

inline Double_t StFlowEvent::CenterOfMassEnergy() const { return mCenterOfMassEnergy; }

inline Double_t StFlowEvent::MagneticField() const { return mMagneticField; }

inline Short_t StFlowEvent::BeamMassNumberEast() const { return mBeamMassNumberEast; }

inline Short_t StFlowEvent::BeamMassNumberWest() const { return mBeamMassNumberWest; }

inline UInt_t StFlowEvent::OrigMult() const { return mOrigMult; }

inline UInt_t StFlowEvent::L0TriggerWord() const { return mL0TriggerWord; }

inline UInt_t StFlowEvent::UncorrNegMult() const { return mUncorrNegMult; }

inline UInt_t StFlowEvent::UncorrPosMult() const { return mUncorrPosMult; }

inline UInt_t StFlowEvent::MultEta() const { return mMultEta; }

inline UInt_t StFlowEvent::FlowEventMult() const { return pTrackCollection->size(); }

inline UInt_t StFlowEvent::Centrality() const { return mCentrality; }

inline StThreeVectorF StFlowEvent::VertexPos() const { return mVertexPos; }

inline Float_t  StFlowEvent::CTB() const { return mCTB; }

inline Float_t  StFlowEvent::ZDCe() const { return mZDCe; }

inline Float_t  StFlowEvent::ZDCw() const { return mZDCw; }  

inline Float_t  StFlowEvent::ZDCSMD(int eastwest,int verthori,int strip) const {return mZDCSMD[eastwest][verthori][strip-1];}

inline Float_t  StFlowEvent::PtWgtSaturation() const { return mPtWgtSaturation; }

inline Bool_t   StFlowEvent::PtWgt() const { return mPtWgt; }

inline Bool_t   StFlowEvent::EtaWgt() const { return mEtaWgt; }

inline Bool_t   StFlowEvent::FirstLastPhiWgt() const { return mFirstLastPhiWgt; }

inline Bool_t   StFlowEvent::FirstLastPoints() const { return mFirstLastPoints; }

inline Char_t*  StFlowEvent::Pid() { return mPid; }

inline Bool_t   StFlowEvent::ProbPid() { return mProbPid; }

inline Bool_t   StFlowEvent::EtaSubs() const { return mEtaSubs; }

inline Bool_t   StFlowEvent::RanSubs() const { return mRanSubs; }

inline Bool_t   StFlowEvent::UseZDCSMD() const { return mUseZDCSMD;}

inline   Float_t StFlowEvent::V1TPCDetctWgtG_Mix(Int_t selN) const {
  return mV1TPCDetctWgtG_Mix[selN]; }
inline   Float_t StFlowEvent::V1FtpcEastDetctWgtG_Mix(Int_t selN) const {
  return mV1FtpcEastDetctWgtG_Mix[selN]; }
inline   Float_t StFlowEvent::V1FtpcWestDetctWgtG_Mix(Int_t selN) const {
  return mV1FtpcWestDetctWgtG_Mix[selN]; }

inline   Float_t StFlowEvent::V2TPCDetctWgtG_Mix(Int_t selN) const {
  return mV2TPCDetctWgtG_Mix[selN]; }
inline   Float_t StFlowEvent::V2FtpcEastDetctWgtG_Mix(Int_t selN) const {
  return mV2FtpcEastDetctWgtG_Mix[selN]; }
inline   Float_t StFlowEvent::V2FtpcWestDetctWgtG_Mix(Int_t selN) const {
  return mV2FtpcWestDetctWgtG_Mix[selN]; }

#ifndef __CINT__
inline void StFlowEvent::SetPhiWeightFarEast(const Flow::PhiWgt_t& pPhiWgtFarEast) {
  memcpy (mPhiWgtFarEast, pPhiWgtFarEast, sizeof(Flow::PhiWgt_t)); }

inline void StFlowEvent::SetPhiWeightEast(const Flow::PhiWgt_t& pPhiWgtEast) {
  memcpy (mPhiWgtEast, pPhiWgtEast, sizeof(Flow::PhiWgt_t)); }

inline void StFlowEvent::SetPhiWeightWest(const Flow::PhiWgt_t& pPhiWgtWest) {
  memcpy (mPhiWgtWest, pPhiWgtWest, sizeof(Flow::PhiWgt_t)); }

inline void StFlowEvent::SetPhiWeightFarWest(const Flow::PhiWgt_t& pPhiWgtFarWest) {
  memcpy (mPhiWgtFarWest, pPhiWgtFarWest, sizeof(Flow::PhiWgt_t)); }

inline void StFlowEvent::SetPhiWeightFtpcFarEast(const Flow::PhiWgtFtpc_t& pPhiWgtFtpcFarEast) {
  memcpy (mPhiWgtFtpcFarEast, pPhiWgtFtpcFarEast, sizeof(Flow::PhiWgtFtpc_t)); }

inline void StFlowEvent::SetPhiWeightFtpcEast(const Flow::PhiWgtFtpc_t& pPhiWgtFtpcEast) {
  memcpy (mPhiWgtFtpcEast, pPhiWgtFtpcEast, sizeof(Flow::PhiWgtFtpc_t)); }

inline void StFlowEvent::SetPhiWeightFtpcWest(const Flow::PhiWgtFtpc_t& pPhiWgtFtpcWest) {
  memcpy (mPhiWgtFtpcWest, pPhiWgtFtpcWest, sizeof(Flow::PhiWgtFtpc_t)); }

inline void StFlowEvent::SetPhiWeightFtpcFarWest(const Flow::PhiWgtFtpc_t& pPhiWgtFtpcFarWest) {
  memcpy (mPhiWgtFtpcFarWest, pPhiWgtFtpcFarWest, sizeof(Flow::PhiWgtFtpc_t)); }

inline void StFlowEvent::SetZDCSMD_PsiWeightEast(const Flow::ZDCSMD_PsiWgt_t&  ZDCSMD_PsiWgtEast) {
  memcpy (mZDCSMD_PsiWgtEast, ZDCSMD_PsiWgtEast, sizeof(Flow::ZDCSMD_PsiWgt_t)); }

inline void StFlowEvent::SetZDCSMD_PsiWeightWest(const Flow::ZDCSMD_PsiWgt_t&  ZDCSMD_PsiWgtWest) {
  memcpy (mZDCSMD_PsiWgtWest, ZDCSMD_PsiWgtWest, sizeof(Flow::ZDCSMD_PsiWgt_t)); }

inline void StFlowEvent::SetZDCSMD_PsiWeightFull(const Flow::ZDCSMD_PsiWgt_t&  ZDCSMD_PsiWgtFull) {
  memcpy (mZDCSMD_PsiWgtFull, ZDCSMD_PsiWgtFull, sizeof(Flow::ZDCSMD_PsiWgt_t)); }
 
inline void StFlowEvent::SetZDCSMD_BeamCenter(Double_t ex,Double_t ey,Double_t wx,Double_t wy) {
  mZDCSMDCenterex = ex; mZDCSMDCenterey = ey; mZDCSMDCenterwx = wx; mZDCSMDCenterwy = wy;}

inline void StFlowEvent::SetReCentX(const Flow::ReCent_t& pReCentX) {
  memcpy (mReCentX, pReCentX, sizeof(Flow::ReCent_t)); }

inline void StFlowEvent::SetReCentY(const Flow::ReCent_t& pReCentY) {
  memcpy (mReCentY, pReCentY, sizeof(Flow::ReCent_t)); }
#endif

inline void StFlowEvent::SetEtaTpcCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)
{ mEtaTpcCuts[0][harN][selN] = lo; mEtaTpcCuts[1][harN][selN] = hi; }

//# Added by jcampbell
inline Float_t StFlowEvent::EtaTpcCut(Int_t lowOrHigh, Int_t harN, Int_t selN) {
  return lowOrHigh ? mEtaTpcCuts[1][harN][selN] : mEtaTpcCuts[0][harN][selN]; }

//# Added by jcampbell
inline Float_t StFlowEvent::Etaq2Cut(Int_t lowOrHigh) {
  return lowOrHigh ? mEtaq2Cuts[1] : mEtaq2Cuts[0]; }

//# Added by jcampbell
inline void StFlowEvent::SetEtaq2Cut(Float_t lo, Float_t hi) {
    mEtaq2Cuts[0] = lo; mEtaq2Cuts[1] = hi; }

//# Added by jcampbell
inline void StFlowEvent::SetEtaGap(Float_t gap) {
    mEtaGap = gap; }

inline void StFlowEvent::SetPtTpcCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)
{ mPtTpcCuts[0][harN][selN] = lo; mPtTpcCuts[1][harN][selN] = hi; }

inline void StFlowEvent::SetEtaFtpcCut(Float_t lo_neg, Float_t hi_neg, 
				       Float_t lo_pos, Float_t hi_pos, 
				       Int_t harN, Int_t selN)
{ mEtaFtpcCuts[0][harN][selN] = lo_neg; mEtaFtpcCuts[1][harN][selN] = hi_neg; 
 mEtaFtpcCuts[2][harN][selN] = lo_pos; mEtaFtpcCuts[3][harN][selN] = hi_pos; }

inline void StFlowEvent::SetPtFtpcCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)
{ mPtFtpcCuts[0][harN][selN] = lo; mPtFtpcCuts[1][harN][selN] = hi; }

inline void StFlowEvent::SetEventID(const Int_t& id) { mEventID = id; }

inline void StFlowEvent::SetRunID(const Int_t& id) { mRunID = id; }

inline void StFlowEvent::SetMagneticField(const Double_t& mf) { mMagneticField = mf; }

inline void StFlowEvent::SetCenterOfMassEnergy(const Double_t& cms) { mCenterOfMassEnergy = cms; }

inline void StFlowEvent::SetBeamMassNumberEast(const Short_t& bme) { mBeamMassNumberEast = bme; }

inline void StFlowEvent::SetBeamMassNumberWest(const Short_t& bmw) { mBeamMassNumberWest = bmw; }

inline void StFlowEvent::SetOrigMult(const UInt_t& tracks) {
  mOrigMult = tracks; }

inline void StFlowEvent::SetL0TriggerWord(const UInt_t& trigger) {
  mL0TriggerWord = trigger; }

inline void StFlowEvent::SetUncorrNegMult(const UInt_t& negtracks) {
  mUncorrNegMult = negtracks; }

inline void StFlowEvent::SetUncorrPosMult(const UInt_t& postracks) {
  mUncorrPosMult = postracks; }

inline void StFlowEvent::SetMultEta(const UInt_t& goodtracks) {
  mMultEta = goodtracks; }

inline void StFlowEvent::SetVertexPos(const StThreeVectorF& vertexPos) {
  mVertexPos = vertexPos; }

inline void StFlowEvent::SetPiPlusCut(Float_t lo, Float_t hi) { 
  mPiPlusCuts[0] = lo; mPiPlusCuts[1] = hi; }

inline void StFlowEvent::SetPiMinusCut(Float_t lo, Float_t hi) { 
  mPiMinusCuts[0] = lo; mPiMinusCuts[1] = hi; }

inline void StFlowEvent::SetProtonCut(Float_t lo, Float_t hi) { 
  mProtonCuts[0] = lo; mProtonCuts[1] = hi; }

inline void StFlowEvent::SetKMinusCut(Float_t lo, Float_t hi) { 
  mKMinusCuts[0] = lo; mKMinusCuts[1] = hi; }

inline void StFlowEvent::SetKPlusCut(Float_t lo, Float_t hi) { 
  mKPlusCuts[0] = lo; mKPlusCuts[1] = hi; }

inline void StFlowEvent::SetAntiProtonCut(Float_t lo, Float_t hi) { 
  mAntiProtonCuts[0] = lo; mAntiProtonCuts[1] = hi; }

inline void StFlowEvent::SetDeuteronCut(Float_t lo, Float_t hi) { 
  mDeuteronCuts[0] = lo; mDeuteronCuts[1] = hi; }

inline void StFlowEvent::SetAntiDeuteronCut(Float_t lo, Float_t hi) { 
  mAntiDeuteronCuts[0] = lo; mAntiDeuteronCuts[1] = hi; }

inline void StFlowEvent::SetElectronCut(Float_t lo, Float_t hi) { 
  mElectronCuts[0] = lo; mElectronCuts[1] = hi; }

inline void StFlowEvent::SetPositronCut(Float_t lo, Float_t hi) { 
  mPositronCuts[0] = lo; mPositronCuts[1] = hi; }

inline void StFlowEvent::SetDcaGlobalTpcCut(Float_t lo, Float_t hi) { 
  mDcaGlobalTpcCuts[0] = lo; mDcaGlobalTpcCuts[1] = hi; }

inline void StFlowEvent::SetDcaGlobalFtpcCut(Float_t lo, Float_t hi) { 
  mDcaGlobalFtpcCuts[0] = lo; mDcaGlobalFtpcCuts[1] = hi; }

inline void StFlowEvent::SetCTB(const Float_t ctb) { mCTB = ctb; }

inline void StFlowEvent::SetZDCe(const Float_t zdce) { mZDCe = zdce; }

inline void StFlowEvent::SetZDCw(const Float_t zdcw) { mZDCw = zdcw; }

inline void StFlowEvent::SetZDCSMD(int eastwest,int verthori,int strip,const Float_t zdcsmd) {
  mZDCSMD[eastwest][verthori][strip-1] = (zdcsmd >0.)? zdcsmd:0.;}

inline void StFlowEvent::SetPid(const Char_t* pid)  { 
  strncpy(mPid, pid, 9); mPid[9] = '\0'; }

inline void StFlowEvent::SetProbPid() { mProbPid = kTRUE; }

inline void StFlowEvent::SetEtaSubs() { mEtaSubs = kTRUE; }

inline void StFlowEvent::SetRanSubs() { mRanSubs = kTRUE; }

inline void StFlowEvent::SetFirstLastPhiWgt() { mFirstLastPhiWgt = kTRUE; }

inline void StFlowEvent::SetFirstLastPoints() { mFirstLastPoints = kTRUE; }

inline void StFlowEvent::SetUseZDCSMD(Bool_t UseZDCSMD) { mUseZDCSMD = UseZDCSMD; }

inline void StFlowEvent::SetPtWgtSaturation(Float_t PtWgtSaturation) { mPtWgtSaturation = PtWgtSaturation; }

inline void StFlowEvent::SetPtWgt(Bool_t PtWgt) { mPtWgt = PtWgt; }

inline void StFlowEvent::SetEtaWgt(Bool_t EtaWgt) { mEtaWgt = EtaWgt; }

inline void StFlowEvent::SetV1TPCDetctWgtG_Mix(Float_t val,  Int_t selN){
  mV1TPCDetctWgtG_Mix[selN]=val;}
inline void StFlowEvent::SetV1FtpcEastDetctWgtG_Mix(Float_t val,  Int_t selN){
  mV1FtpcEastDetctWgtG_Mix[selN]=val;}
inline void StFlowEvent::SetV1FtpcWestDetctWgtG_Mix(Float_t val,  Int_t selN){
  mV1FtpcWestDetctWgtG_Mix[selN]=val;}

inline void StFlowEvent::SetV2TPCDetctWgtG_Mix(Float_t val,  Int_t selN){
  mV2TPCDetctWgtG_Mix[selN]=val;}
inline void StFlowEvent::SetV2FtpcEastDetctWgtG_Mix(Float_t val,  Int_t selN){
  mV2FtpcEastDetctWgtG_Mix[selN]=val;}
inline void StFlowEvent::SetV2FtpcWestDetctWgtG_Mix(Float_t val,  Int_t selN){
  mV2FtpcWestDetctWgtG_Mix[selN]=val;}

#endif

//////////////////////////////////////////////////////////////////////
//
// $Log: StFlowEvent.h,v $
// Revision 1.56  2009/11/24 19:23:03  posk
// Added reCenter option to remove acceptance correlations instead of phiWgt.
//
// Revision 1.55  2007/02/06 18:57:54  posk
// In Lee Yang Zeros method, introduced recentering of Q vector.
// Reactivated eta symmetry cut.
//
// Revision 1.54  2006/07/06 16:56:01  posk
// Calculation of v1 for selection=2 is done with mixed harmonics.
//
// Revision 1.53  2006/02/22 19:29:16  posk
// Additions needed for the StFlowLeeYangZerosMaker
//
// Revision 1.52  2005/02/10 21:04:57  aihong
// test mProbPid of StFlowEvent before launch calculation pid on fly
//
// Revision 1.51  2004/12/17 22:33:08  aihong
// add in full Psi weight for ZDC SMD and fix a few bugs, done by Gang
//
// Revision 1.50  2004/12/17 15:50:08  aihong
// check in v1{3} code
//
// Revision 1.49  2004/12/07 17:04:46  posk
// Eliminated the very old mOnePhiWgt, which used one phiWgt histogram for flttening
// instead of four.
//
// Revision 1.48  2004/11/16 21:22:22  aihong
// removed old cumulant method
//
// Revision 1.47  2004/05/05 21:13:45  aihong
// Gang's code for ZDC-SMD added
//
// Revision 1.46  2004/03/11 17:58:42  posk
// Added Random Subs analysis method.
//
// Revision 1.45  2003/07/30 22:00:40  oldi
// Eta cuts for event plane selection separated for FTPC east and west.
// PtWgtSaturation parameter introduced (default set to 2. -> no change of default behavior).
//
// Revision 1.44  2003/06/18 17:00:59  posk
// Event plane cuts now only odd and even, instead of different for each harmonic.
//
// Revision 1.43  2003/04/01 00:27:07  posk
// Little q is now unweighted by pt or eta. Big Q is unaffected.
//
// Revision 1.42  2003/01/10 16:42:15  oldi
// Several changes to comply with FTPC tracks:
// - Switch to include/exclude FTPC tracks introduced.
//   The same switch changes the range of the eta histograms.
// - Eta symmetry plots for FTPC tracks added and separated from TPC plots.
// - PhiWgts and related histograms for FTPC tracks split in FarEast, East,
//   West, FarWest (depending on vertex.z()).
// - Psi_Diff plots for 2 different selections and the first 2 harmonics added.
// - Cut to exclude mu-events with no primary vertex introduced.
//   (This is possible for UPC events and FTPC tracks.)
// - Global DCA cut for FTPC tracks added.
// - Global DCA cuts for event plane selection separated for TPC and FTPC tracks.
// - Charge cut for FTPC tracks added.
//
// Revision 1.41  2003/01/08 19:26:48  posk
// PhiWgt hists sorted on sign of z of first and last points.
// Version 6 of pico file.
//
// Revision 1.40  2002/05/23 18:54:11  posk
// Moved centrality cuts into StFlowConstants
//
// Revision 1.39  2002/03/15 16:43:22  snelling
// Added a method to recalculate the centrality in StFlowPicoEvent
//
// Revision 1.38  2002/03/14 18:51:50  snelling
// Added new centralities
//
// Revision 1.37  2002/02/13 22:29:28  posk
// Pt Weight now also weights Phi Weights. Added Eta Weight, default=FALSE.
//
// Revision 1.36  2002/02/01 23:06:26  snelling
// Added entries for header information in flowPico (not everthing is available yet)
//
// Revision 1.35  2002/01/31 01:04:47  posk
// *** empty log message ***
//
// Revision 1.34  2001/12/18 19:22:09  posk
// "proton" and "antiproton" changed to "pr+" and "pr-".
// Compiles on Solaris.
//
// Revision 1.33  2001/12/11 21:33:50  posk
// Went from one to four sets of histograms for making the event plane isotropic.
// StFlowEvent::PhiWeight() has changed arguments and return value.
// The ptWgt saturates above 2 GeV/c.
//
// Revision 1.32  2001/11/09 21:10:42  posk
// Switched from CERNLIB to TMath. Little q is now normalized.
//
// Revision 1.31  2001/11/02 04:49:52  aihong
// add func. for cumulant maker
//
// Revision 1.30  2001/08/01 19:39:35  snelling
// Added the trigger word
//
// Revision 1.29  2001/07/27 01:26:14  snelling
// Added and changed variables for picoEvent. Changed trackCut class to StTrack
//
// Revision 1.28  2001/07/24 22:29:12  snelling
// First attempt to get a standard root pico file again, added variables
//
// Revision 1.27  2001/06/07 20:06:20  posk
// Global Dca cut for event plane particles.
// Removed SetPtWgt().
//
// Revision 1.26  2001/06/06 13:02:58  rcwells
// Added SetPtWgt(Bool_t) function to StFlowEvent
//
// Revision 1.25  2001/06/04 18:57:05  rcwells
// Adding filling from HbtEvents
//
// Revision 1.24  2001/05/23 18:11:09  posk
// Removed SetPids().
//
// Revision 1.23  2001/05/22 20:17:30  posk
// Now can do pseudorapidity subevents.
//
// Revision 1.22  2001/04/03 17:47:23  oldi
// Bug fix that excluded FTPC tracks from the determination of the reaction plane.
//
// Revision 1.21  2000/12/12 20:22:05  posk
// Put log comments at end of files.
// Deleted persistent StFlowEvent (old micro DST).
//
// Revision 1.20  2000/12/10 02:01:13  oldi
// A new member (StTrackTopologyMap mTopology) was added to StFlowPicoTrack.
// The evaluation of either a track originates from the FTPC or not is
// unambiguous now. The evaluation itself is easily extendible for other
// detectors (e.g. SVT+TPC). Old flowpicoevent.root files are treated as if
// they contain TPC tracks only (backward compatibility).
//
// Revision 1.19  2000/12/08 17:03:38  oldi
// Phi weights for both FTPCs included.
//
// Revision 1.18  2000/10/12 22:46:36  snelling
// Added support for the new pDST's and the probability pid method
//
// Revision 1.16  2000/09/15 22:51:30  posk
// Added pt weighting for event plane calcualtion.
//
// Revision 1.15  2000/09/05 16:11:32  snelling
// Added global DCA, electron and positron
//
// Revision 1.14  2000/08/31 18:58:22  posk
// For picoDST, added version number, runID, and multEta for centrality.
// Added centrality cut when reading picoDST.
// Added pt and eta selections for particles corr. wrt event plane.
//
// Revision 1.13  2000/08/09 21:38:23  snelling
// PID added
//
// Revision 1.12  2000/08/05 22:07:18  fisyak
// less restrictive selection for ROOTCINT
//
// Revision 1.11  2000/08/05 21:21:33  fisyak
// hide from CINT inline functions
//
// Revision 1.10  2000/08/04 21:03:45  perev
// Leaks + Clear() cleanup
//
// Revision 1.9  2000/06/30 14:48:32  posk
// Using MessageMgr, changed Eta Symmetry cut.
//
// Revision 1.8  2000/06/20 16:34:25  snelling
// fixed cout/streamer problem for mPhiWgt under Solaris
//
// Revision 1.7  2000/05/26 21:29:27  posk
// Protected Track data members from overflow.
//
// Revision 1.5  2000/05/16 20:59:30  posk
// Voloshin's flownanoevent.root added.
//
// Revision 1.4  2000/05/12 22:42:04  snelling
// Additions for persistency and minor fix
//
// Revision 1.2  2000/03/15 23:28:51  posk
// Added StFlowSelection.
//
// Revision 1.1  2000/03/02 23:02:50  posk
// Changed extensions from .hh and .cc to .h and .cxx .
//
// Revision 1.10  2000/02/29 22:00:54  posk
// Made SetPhiWeight inline, changed ImpactPar to Dca, etc.
//
// Revision 1.9  2000/02/18 22:49:55  posk
// Added PID and centrality.
//
// Revision 1.5  1999/12/15 22:01:26  posk
// Added StFlowConstants.hh
//
// Revision 1.4  1999/12/04 00:10:33  posk
// Works with the new StEvent
//
// Revision 1.3  1999/11/30 18:52:52  snelling
// First modification for the new StEvent
//
// Revision 1.2  1999/11/24 18:17:14  posk
// Put the methods which act on the data in with the data in StFlowEvent.
//
// Revision 1.1  1999/11/04 19:02:06  snelling
// First check in of StFlowMaker. It contains the common code from
// StFlowTagMaker and StFlowAnalysisMaker.
//
//////////////////////////////////////////////////////////////////////
