StGenericVertexFinder.h

#ifndef STAR_StGenericVertexFinder
#define STAR_StGenericVertexFinder

#include <vector>

#include "TMinuit.h"

#include "StPrimaryVertex.h"
#include "tables/St_vertexSeed_Table.h"
#include "StGenericVertexMaker/VertexFinderOptions.h"

class StEvent;
class StMuDst;
class StDcaGeometry;
class TClonesArray;
class St_db_Maker;


class StGenericVertexFinder
{
public:

  // Alias for shorthand
  using StDcaList = std::vector<const StDcaGeometry*>;

  using VertexFit_t = star_vertex::VertexFit_t;

  using SeedFinder_t = star_vertex::SeedFinder_t;

  // virtual and '=0' ; those MUST be implemented
  virtual ~StGenericVertexFinder();                           // virtual destructor
  virtual int            fit(StEvent*)=0;                     // fit the vertex

  StPrimaryVertex*       getVertex(int idx) const;
  void                   addVertex(const StPrimaryVertex& vtx);
  int                    size() const;
          void           UseVertexConstraint(const vertexSeed_st& beamline);
          void           NoVertexConstraint();
          int            IsVertexConstraint() const {return mVertexConstrain;}
  virtual void           UsePCT(bool usePCT = true);
  virtual void           UseBTOF(bool useBTOF = true){mUseBtof=useBTOF;}
  virtual void           UseCTB (bool useCTB  = true){mUseCtb =useCTB ;}

  virtual void           printInfo(ostream& = cout) const=0;

  // General (default)
  virtual void           SetMode(Int_t mode=0 ) {mMode = mode;}
  virtual int            GetMode() const        {return mMode;}
          void           SetDebugLevel(Int_t level) {mDebugLevel=level;}
  virtual void           Init(){ /* noop */;}
  virtual void           Finish(){ /* noop */;}
  virtual void           InitRun(int run_number, const St_db_Maker* db_maker);
  virtual void           Clear();
  const std::vector<StPrimaryVertex> *result() {return &mVertexList;}

  void result(TClonesArray& stMuDstPrimaryVertices);

  void                   FillStEvent(StEvent*);
  virtual void SetVertexPosition(double x,double y,double z){assert(0);}
  virtual void SetVertexError(double x,double y,double z){assert(0);}
  virtual int            IsFixed() const        {return 0;}

  virtual int            fit(const StMuDst& muDst) { return -1; }

protected:

  StGenericVertexFinder();

  StGenericVertexFinder(SeedFinder_t seedFinder, VertexFit_t fitMode);

  StPrimaryVertexOrder   mVertexOrderMethod; // will default to 0 i.e. orderByNumberOfDaughters
  bool                   mVertexConstrain;   // Use vertex constraint from db
  int                    mMode;              // used for any Finder behavior change

  VertexFit_t            mVertexFitMode;

  SeedFinder_t           mSeedFinderType;

  int                    mDebugLevel;
  bool                   mUseBtof;           // default use btof = false
  bool                   mUseCtb;            // default use ctb = false

  vertexSeed_st  mBeamline;

  StDcaList  mDCAs;

  TMinuit*  mMinuit;

  static StGenericVertexFinder* sSelf;

  std::vector<double> FindSeeds_TSpectrum();

  double beamX(double z) const;

  double beamY(double z) const;

  StThreeVectorD CalcVertexSeed(const StDcaList &trackDcas);

  virtual double CalcChi2DCAs(const StThreeVectorD &point);

  double CalcChi2Beamline(const StThreeVectorD& point);

  double CalcChi2DCAsBeamline(const StThreeVectorD &point);

  // A static interface to CalcChi2DCAs(...)
  static void fcnCalcChi2DCAs(int& npar, double* gin, double& f, double* par, Int_t iflag)
  {
     f = sSelf->CalcChi2DCAs( StThreeVectorD(par) );
  }

  static void fcnCalcChi2DCAsBeamline1D(int& npar, double* gin, double& f, double* par, Int_t iflag)
  {
     double z = par[0], x = sSelf->beamX(z), y = sSelf->beamY(z);
     f = sSelf->CalcChi2DCAs( StThreeVectorD(x, y, z) );
  }

  static void fcnCalcChi2DCAsBeamline(int& npar, double* gin, double& f, double* par, int iflag)
  {
     f = sSelf->CalcChi2DCAsBeamline( StThreeVectorD(par) );
  }

private:

  std::vector<StPrimaryVertex> mVertexList;

  virtual void  UseVertexConstraint() = 0;
};

#endif