StEpdEpInfo.h

#ifndef StEpdEpInfo_H
#define StEpdEpInfo_H

#define _EpOrderMax 3   // maximum order of EP to worry about.

#include "TVector2.h"

class StEpdEpInfo{

  // making StEpdEpFinder a "friend class" just gives it direct access to the arrays.
  // But the general User is required to use accessors, since the numbering/index convention can be confusing
  friend class StEpdEpFinder;


 public:
  StEpdEpInfo();
  ~StEpdEpInfo(){/* no op */};

  
  // in the below, when it says "of order," then "order" begins at 1.  E.g. order=2 means second-order q vector

  //-----------------------------------------------------------------------------------------
  TVector2 EastRawQ(int order);
  TVector2 WestRawQ(int order);

  //-----------------------------------------------------------------------------------------
  TVector2 EastPhiWeightedQ(int order);
  TVector2 WestPhiWeightedQ(int order);

  //-----------------------------------------------------------------------------------------
  double EastRawPsi(int order);
  double WestRawPsi(int order);
  double FullRawPsi(int order);

  //-----------------------------------------------------------------------------------------
  double EastPhiWeightedPsi(int order);
  double WestPhiWeightedPsi(int order);
  double FullPhiWeightedPsi(int order);

  //-----------------------------------------------------------------------------------------
  double EastPhiWeightedAndShiftedPsi(int order);
  double WestPhiWeightedAndShiftedPsi(int order);
  double FullPhiWeightedAndShiftedPsi(int order);

  // ============================== Ring-by-ring stuff below ========================

  //-----------------------------------------------------------------------------------------
  TVector2 EastRingRawQ(int order, int ring);
  TVector2 WestRingRawQ(int order, int ring);

  //-----------------------------------------------------------------------------------------
  TVector2 EastRingPhiWeightedQ(int order, int ring);
  TVector2 WestRingPhiWeightedQ(int order, int ring);

  //-----------------------------------------------------------------------------------------
  double EastRingRawPsi(int order, int ring);
  double WestRingRawPsi(int order, int ring);

  //-----------------------------------------------------------------------------------------
  double EastRingPhiWeightedPsi(int order, int ring);
  double WestRingPhiWeightedPsi(int order, int ring);

  //-----------------------------------------------------------------------------------------
  double EastRingSumWeightsRaw(int ring);
  double WestRingSumWeightsRaw(int ring);

  //-----------------------------------------------------------------------------------------
  double EastRingSumWeightsPhiWeighted(int ring);
  double WestRingSumWeightsPhiWeighted(int ring);

  //-----------------------------------------------------------------------------------------
  double EastSumWeightsRaw(int order);
  double WestSumWeightsRaw(int order);

  //-----------------------------------------------------------------------------------------
  double EastSumWeightsPhiWeighted(int order);
  double WestSumWeightsPhiWeighted(int order);



 private:

  bool ArgumentOutOfBounds(int order);              
  bool ArgumentOutOfBounds(int order, int ring);    

  TVector2 RawQ(int ew, int order);                        
  TVector2 PhiWeightedQ(int ew, int order);                
  TVector2 RingRawQ(int ew, int order, int ring);          
  TVector2 RingPhiWeightedQ(int ew, int order, int ring);  

  double RawPsi(int ewfull, int order);                    
  double PhiWeightedPsi(int ewfull, int order);            
  double PhiWeightedAndShiftedPsi(int ewfull, int order);  
  double RingRawPsi(int ew, int order, int ring);          
  double RingPhiWeightedPsi(int ew, int order, int ring);  

  double RingSW_Raw(int ew, int ring);              
  double RingSW_PhiWeighted(int ew, int ring);      
  double WheelSW_Raw(int ew, int order);            
  double WheelSW_PhiWeighted(int ew, int order);    

  double Range(double psi, int order);                     



  double QrawOneSide[2][_EpOrderMax][2];           
  double QphiWeightedOneSide[2][_EpOrderMax][2];   
  double PsiRaw[3][_EpOrderMax];                   
  double PsiPhiWeighted[3][_EpOrderMax];           
  double PsiPhiWeightedAndShifted[3][_EpOrderMax]; 
  // ring-by-ring
  double QringRaw[2][_EpOrderMax][2][16];          
  double QringPhiWeighted[2][_EpOrderMax][2][16];  
  double PsiRingRaw[2][_EpOrderMax][16];           
  double PsiRingPhiWeighted[2][_EpOrderMax][16];   
  // following are sums of weights so that Xiaoyu can "unnormalize" the Q-vectors
  double RingSumWeightsRaw[2][16];                 
  double RingSumWeightsPhiWeighted[2][16];         
  double WheelSumWeightsRaw[2][_EpOrderMax];       
  double WheelSumWeightsPhiWeighted[2][_EpOrderMax]; 

};

#endif