StPPVertexFinder.h

#include <array>
#include <ostream>
#include <vector>

#include "StGenericVertexMaker/StGenericVertexFinder.h"
#include "StGenericVertexMaker/StiPPVertex/TrackData.h"
#include "StGenericVertexMaker/StiPPVertex/VertexData.h"

#include "StarClassLibrary/StPhysicalHelixD.hh"

class TH1F;
class TH2F;
class TH1D;

class StiKalmanTrack;
class StEvent; 
class StiToolkit;

class StMuDst;

class St_db_Maker;
class BtofHitList;  
class CtbHitList;
class BemcHitList;
class EemcHitList;


class StPPVertexFinder: public StGenericVertexFinder
{
 private:

  int fitTracksToVertex(VertexData &vertex);

  void createTrackDcas(const VertexData &vertex);

  void findSeeds_TSpectrum();

  void findSeeds_PPVLikelihood();

  enum {mxH=32};
  bool examinTrackDca(const StiKalmanTrack*, TrackData &track);
  void matchTrack2BTOF(const StiKalmanTrack*, TrackData &track);
  void matchTrack2CTB(const StiKalmanTrack*, TrackData &track);

  void matchTrack2EEMC(TrackDataT<StiKalmanTrack> &track);
  void matchTrack2EEMC(TrackDataT<StMuTrack> &track);
  void matchTrack2EEMC(const StPhysicalHelixD& helix, TrackData &track);

  void matchTrack2BEMC(TrackDataT<StiKalmanTrack> &track);
  void matchTrack2BEMC(TrackDataT<StMuTrack> &track);
  void matchTrack2BEMC(const StPhysicalHelixD& helix, TrackData &track);

  bool matchTrack2Membrane(TrackDataT<StiKalmanTrack> &track);
  void matchTrack2Membrane(TrackDataT<StMuTrack> &track);

  bool isPostCrossingTrack(const StiKalmanTrack* stiTrack);

  bool buildLikelihoodZ();
  bool findVertexZ(VertexData &);
  bool evalVertexZ(VertexData &);
  void exportVertices(); 
  void saveHisto(TString fname);

  std::vector<TrackData>  mTrackData;
  std::vector<VertexData> mVertexData;
  int  mTotEve;
  int  eveID;
  int  nBadVertex;
  unsigned int  mAlgoSwitches; 
  enum {kSwitchOneHighPT=1}; 

  TH1F *hA[mxH];
  TH2F *hACorr;
  TH1D *hL ;      // likelyhood distribution
  TH1D *hM, *hW ; // cumulative track mult & weight distribution, for better errZ calculation
  TObjArray HList;
  std::array<int, 8> ntrk;

  // params
  double mMinTrkPt;               
  double mMaxTrkDcaRxy;           
  float  mMaxZradius;             
  int    mMinMatchTr;             
  float  mMaxZrange;              
  float  mMinZBtof;               
  float  mMaxZBtof;               
  float  mMinAdcBemc;             
  float  mMinAdcEemc;             
  float  mMinFitPfrac;            

  bool   mFitPossWeighting;

  bool   mDropPostCrossingTrack;  
  int    mStoreUnqualifiedVertex; 
  float  mCut_oneTrackPT;         
  bool   mUseBTOFmatchOnly;        

  StiToolkit     *mToolkit;
  BtofHitList    *btofList;
  CtbHitList     *ctbList;
  BemcHitList    *bemcList;
  EemcHitList    *eemcList;

  const StMuDst* mStMuDst;
  
  void dumpKalmanNodes(const StiKalmanTrack *stiTrack);
  void initHisto();

  void seed_fit_export();

  virtual void  UseVertexConstraint() {}

public:

  virtual void UsePCT(bool x=true) { mDropPostCrossingTrack = !x; }
  virtual void Finish();
  virtual void Init();
  virtual void InitRun(int run_number, const St_db_Maker* db_maker);
  virtual void Clear(); 

  StPPVertexFinder(VertexFit_t fitMode=VertexFit_t::BeamlineNoFit);

  virtual ~StPPVertexFinder() {}
  virtual int fit(StEvent*);
  virtual int fit(const StMuDst& muDst);
  virtual void SetStoreUnqualifiedVertex(int n) { mStoreUnqualifiedVertex = n; }
  virtual void UseBTOFmatchOnly(bool useBTOFmatchOnly = true) { UseBTOF(); mUseBTOFmatchOnly = useBTOFmatchOnly; }
  void printInfo(std::ostream& os = std::cout) const;
};