StRoot: StHbtMaker/Infrastructure/StHbtSectoredAnalysis.h Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StHbtSectoredAnalysis.h,v 1.4 2000/08/11 16:35:41 rcwells Exp $
00004  *
00005  * Author: Robert Willson, Ohio State, willson@bnl.gov
00006  ***************************************************************************
00007  *  
00008  * Description: part of STAR HBT Framework: StHbtMaker package.
00009  *      This is a derived class for two-particle analysis objects.  
00010  *      In this analysis, momentum space is sectored into a number of
00011  *      cubes, which are then mixed with nearest neighbors.  Several
00012  *      initializations are needed to set up the sectoring, see 
00013  *      StHbtSectoredExample.C in the /doc directory for use.
00014  *
00015  ***************************************************************************
00016  *
00017  * $Log: StHbtSectoredAnalysis.h,v $
00018  * Revision 1.4  2000/08/11 16:35:41  rcwells
00019  * Added number of events processed to each HBT analysis
00020  *
00021  * Revision 1.3  2000/06/15 18:54:08  willson
00022  * Methods to access cuts and correlation functions moved to derived analysis
00023  * classes.
00024  *
00025  * Revision 1.2  2000/05/11 21:18:56  willson
00026  * Removed StHbtThreeParticleCorrFctn's...put methods in StHbtCorrFctn
00027  * Some methods in derived analysis classes moved to base analysis class
00028  *
00029  * Revision 1.1  2000/04/12 01:46:34  willson
00030  * Initial Installation
00031  *
00032  * 
00033  ***************************************************************************/
00034 
00035 #ifndef StHbtSectoredAnalysis_hh
00036 #define StHbtSectoredAnalysis_hh
00037 
00038 #include "StHbtMaker/Base/StHbtBaseAnalysis.h"        // base analysis class
00039 #include "StHbtMaker/Base/StHbtPairCut.h"   
00040 #include "StHbtMaker/Base/StHbtEventCut.h"
00041 #include "StHbtMaker/Base/StHbtParticleCut.h"
00042 #include "StHbtMaker/Base/StHbtCorrFctn.hh" 
00043 #include "StHbtMaker/Infrastructure/StHbtCorrFctnCollection.hh"
00044 #include "StHbtMaker/Infrastructure/StHbtSectoredPicoEventCollection.hh"
00045 
00046 class StHbtSectoredAnalysis : public StHbtBaseAnalysis {
00047 
00048 public:
00049 
00050   StHbtSectoredAnalysis(); 
00051   StHbtSectoredAnalysis(const StHbtSectoredAnalysis&);  // copy constructor
00052   virtual ~StHbtSectoredAnalysis();
00053 
00054   void CreateRealPairs(StHbtParticleCollection*);
00055   void CreateRealPairs(StHbtParticleCollection*, StHbtParticleCollection*);
00056   void CreateMixedPairs(StHbtParticleCollection*, StHbtParticleCollection*);
00057   void SortHbtParticleCollection(StHbtParticleCut*, StHbtEvent*, StHbtParticleCollection**);
00058   int  Index(int, int, int);
00059  
00060   // Gets and Sets
00061   virtual StHbtPairCut*       PairCut();
00062   virtual StHbtEventCut*      EventCut();
00063   virtual StHbtParticleCut*   FirstParticleCut();
00064   virtual StHbtParticleCut*   SecondParticleCut();
00065 
00066   StHbtCorrFctnCollection* CorrFctnCollection();
00067   virtual StHbtCorrFctn* CorrFctn(int n);     // Access to CFs within the collection
00068   void AddCorrFctn(StHbtCorrFctn*);
00069 
00070   void SetPairCut(StHbtPairCut*);
00071   void SetEventCut(StHbtEventCut*);
00072   void SetFirstParticleCut(StHbtParticleCut*);
00073   void SetSecondParticleCut(StHbtParticleCut*);
00074 
00075 
00076 
00077   int                    NumBinsX();
00078   int                    NumBinsY();
00079   int                    NumBinsZ();
00080   float                  PXmax();
00081   float                  PXmin();
00082   float                  PYmax();
00083   float                  PYmin();
00084   float                  PZmax();
00085   float                  PZmin();
00086   float                  DeltaP();
00087 
00088   void SetPXmax(float);
00089   void SetPXmin(float);
00090   void SetPYmax(float);
00091   void SetPYmin(float);
00092   void SetPZmax(float);
00093   void SetPZmin(float);
00094   void SetDeltaP(float);
00095 
00096   unsigned int NumEventsToMix();
00097   void SetNumEventsToMix(const unsigned int&);
00098   StHbtSectoredPicoEventCollection* SectoredMixingBuffer();
00099   bool SectoredMixingBufferFull();
00100 
00101   bool AnalyzeIdenticalParticles();
00102   virtual StHbtString Report();       
00103 
00104   virtual void ProcessEvent(const StHbtEvent*);
00105   void EventBegin(const StHbtEvent*); //startup for EbyE
00106   void EventEnd(const StHbtEvent*);   // cleanup for EbyE
00107   int GetNeventsProcessed();
00108 
00109   virtual void Finish();
00110 
00111 
00112 private:
00113 
00114   void AddEventProcessed();
00115 
00116   StHbtPairCut*                      mPairCut;
00117   StHbtCorrFctnCollection*           mCorrFctnCollection;
00118   StHbtEventCut*                     mEventCut;
00119   StHbtParticleCut*                  mFirstParticleCut;
00120   StHbtParticleCut*                  mSecondParticleCut;
00121   float                              mPXmax;
00122   float                              mPXmin;
00123   float                              mPYmax;
00124   float                              mPYmin;
00125   float                              mPZmax;
00126   float                              mPZmin;
00127   float                              mDeltaP;
00128   int                                mNumBinsX;
00129   int                                mNumBinsY;
00130   int                                mNumBinsZ;
00131   StHbtSectoredPicoEventCollection*  mSectoredMixingBuffer;
00132   unsigned int                       mNumEventsToMix;
00133   unsigned int                       mNeventsProcessed;
00134 
00135 
00136 #ifdef __ROOT__
00137   ClassDef(StHbtSectoredAnalysis, 0)
00138 #endif
00139 
00140 };
00141 
00142 // Get's
00143 inline StHbtPairCut*                      StHbtSectoredAnalysis::PairCut() {return mPairCut;}
00144 inline StHbtEventCut*                     StHbtSectoredAnalysis::EventCut() {return mEventCut;}
00145 inline StHbtParticleCut*                  StHbtSectoredAnalysis::FirstParticleCut() {return mFirstParticleCut;}
00146 inline StHbtParticleCut*                  StHbtSectoredAnalysis::SecondParticleCut() {return mSecondParticleCut;}
00147 inline StHbtCorrFctnCollection*           StHbtSectoredAnalysis::CorrFctnCollection() {return mCorrFctnCollection;}
00148 inline unsigned int                       StHbtSectoredAnalysis::NumEventsToMix(){return mNumEventsToMix;}
00149 inline StHbtSectoredPicoEventCollection*  StHbtSectoredAnalysis::SectoredMixingBuffer() {return mSectoredMixingBuffer;}
00150 
00151 inline float                     StHbtSectoredAnalysis::PXmax() {return mPXmax;}
00152 inline float                     StHbtSectoredAnalysis::PXmin() {return mPXmin;}
00153 inline float                     StHbtSectoredAnalysis::PYmax() {return mPYmax;}
00154 inline float                     StHbtSectoredAnalysis::PYmin() {return mPYmin;}
00155 inline float                     StHbtSectoredAnalysis::PZmax() {return mPZmax;}
00156 inline float                     StHbtSectoredAnalysis::PZmin() {return mPZmin;}
00157 inline float                     StHbtSectoredAnalysis::DeltaP() {return mDeltaP;}
00158 inline int                       StHbtSectoredAnalysis::NumBinsX() {return mNumBinsX;}
00159 inline int                       StHbtSectoredAnalysis::NumBinsY() {return mNumBinsY;}
00160 inline int                       StHbtSectoredAnalysis::NumBinsZ() {return mNumBinsZ;}
00161 
00162 // Set's
00163 
00164 inline bool StHbtSectoredAnalysis::AnalyzeIdenticalParticles() {return (mFirstParticleCut==mSecondParticleCut);}
00165 inline void StHbtSectoredAnalysis::SetPairCut(StHbtPairCut* x) { mPairCut = x; x->SetAnalysis((StHbtBaseAnalysis*)this);}
00166 inline void StHbtSectoredAnalysis::AddCorrFctn(StHbtCorrFctn* cf) {mCorrFctnCollection->push_back(cf); cf->SetAnalysis((StHbtBaseAnalysis*)this);}
00167 inline void StHbtSectoredAnalysis::SetEventCut(StHbtEventCut* x) {mEventCut = x; x->SetAnalysis((StHbtBaseAnalysis*)this);}
00168 inline void StHbtSectoredAnalysis::SetFirstParticleCut(StHbtParticleCut* x) {mFirstParticleCut = x; x->SetAnalysis((StHbtBaseAnalysis*)this);}
00169 inline void StHbtSectoredAnalysis::SetSecondParticleCut(StHbtParticleCut* x) {mSecondParticleCut = x; x->SetAnalysis((StHbtBaseAnalysis*)this);}
00170 
00171 inline void StHbtSectoredAnalysis::SetNumEventsToMix(const unsigned int& nmix){ mNumEventsToMix = nmix;}
00172 inline bool StHbtSectoredAnalysis::SectoredMixingBufferFull(){return (mSectoredMixingBuffer->size() >= NumEventsToMix());}
00173 
00174 inline void StHbtSectoredAnalysis::SetPXmax(float x) {
00175   mPXmax = x;
00176   if (mPXmax<mPXmin) mNumBinsX=1;
00177   else mNumBinsX = (int)ceil((mPXmax-mPXmin)/mDeltaP);
00178   if (mNumBinsX==0) mNumBinsX=1;
00179 }
00180 inline void StHbtSectoredAnalysis::SetPXmin(float x) {
00181   mPXmin = x;
00182   if (mPXmax<mPXmin) mNumBinsX=1;
00183   else mNumBinsX = (int)ceil((mPXmax-mPXmin)/mDeltaP);
00184   if (mNumBinsX==0) mNumBinsX=1;
00185 }
00186 inline void StHbtSectoredAnalysis::SetPYmax(float x) {
00187   mPYmax = x;
00188   if (mPYmax<mPYmin) mNumBinsY=1;
00189   else mNumBinsY = (int)ceil((mPYmax-mPYmin)/mDeltaP);
00190   if (mNumBinsY==0) mNumBinsY=1;
00191 }
00192 inline void StHbtSectoredAnalysis::SetPYmin(float x) {
00193   mPYmin = x;
00194   if (mPYmax<mPYmin) mNumBinsY=1;
00195   else mNumBinsY = (int)ceil((mPYmax-mPYmin)/mDeltaP);
00196   if (mNumBinsY==0) mNumBinsY=1;
00197 }
00198 inline void StHbtSectoredAnalysis::SetPZmax(float x) {
00199   mPZmax = x;
00200   if (mPZmax<mPZmin) mNumBinsZ=1;
00201   else mNumBinsZ = (int)ceil((mPZmax-mPZmin)/mDeltaP);
00202   if (mNumBinsZ==0) mNumBinsZ=1;
00203 }
00204 inline void StHbtSectoredAnalysis::SetPZmin(float x) {
00205   mPZmin = x;
00206   if (mPZmax<mPZmin) mNumBinsZ=1;
00207   else mNumBinsZ = (int)ceil((mPZmax-mPZmin)/mDeltaP);
00208   if (mNumBinsZ==0) mNumBinsZ=1;
00209 }
00210 inline void StHbtSectoredAnalysis::SetDeltaP(float x) {
00211   if (x<=0) {
00212     mDeltaP = 1.0;
00213     cout << "****ERROR****  DeltaP must be greater than zero...setting DeltaP to 1.0" << endl;
00214   }
00215   else {
00216     mDeltaP = x;
00217     mNumBinsX = (int)ceil((mPXmax-mPXmin)/mDeltaP);
00218     if (mNumBinsX==0) mNumBinsX=1;
00219     mNumBinsY = (int)ceil((mPYmax-mPYmin)/mDeltaP);
00220     if (mNumBinsY==0) mNumBinsY=1;
00221     mNumBinsZ = (int)ceil((mPZmax-mPZmin)/mDeltaP);
00222     if (mNumBinsZ==0) mNumBinsZ=1;
00223   }
00224 }
00225 
00226 #endif
00227 
00228 inline int StHbtSectoredAnalysis::GetNeventsProcessed() {return mNeventsProcessed;}