StMinuitVertexFinder.h

#include <vector>

#include "StGenericVertexMaker/StGenericVertexFinder.h"
#include "StarClassLibrary/StPhysicalHelixD.hh"
#include "StarClassLibrary/StThreeVectorD.hh"

class StEvent;
class StTrack;
class TMinuit;


class StMinuitVertexFinder: public StGenericVertexFinder
{
public:

    StMinuitVertexFinder(VertexFit_t fitMode=VertexFit_t::NoBeamline);

    // mandatory implementations
    virtual        ~StMinuitVertexFinder();
    Int_t           fit(StEvent*);       
    void            printInfo(ostream& = cout) const;
    virtual void    InitRun(int run_number, const St_db_Maker* db_maker);
    void            Clear();


    // Added, not part of base-class  and used by the Minuit vertex finder
    Int_t           NCtbMatches();    // returns the number of tracks matched to CTB                                                               
    void            CTBforSeed(){   mRequireCTB = kTRUE;}
    void            NoCTBforSeed(){ mRequireCTB = kFALSE;}
    void            setExternalSeed(const StThreeVectorD&);

    void            setPrintLevel(Int_t = 0);
    Int_t           statusMin() const {return mStatusMin;}     // Minuit status flag
    void            DoUseITTF(){    mUseITTF = kTRUE; }
    void            DoNotUseITTF(){ mUseITTF = kFALSE;}
    void            useOldBEMCRank() { mUseOldBEMCRank = kTRUE; }
    void            lowerSplitVtxRank() { mLowerSplitVtxRank = kTRUE; }
    void            setFlagBase();
    void            SetFitPointsCut(Int_t fitpoints) {mMinNumberOfFitPointsOnTrack = fitpoints;}
    void            SetMinimumTracks(Int_t n) {mMinTrack = n;}
    void            SetFXT(bool fxt=kTRUE) { mFXT = fxt; }

private:

    enum  {kFlagDcaz = 1, kFlagCTBMatch = 2, kFlagBEMCMatch = 4, kFlagCrossMembrane = 8};

    bool    accept(StTrack*) const;   // track filter
    void    fillBemcHits(StEvent *);
    Int_t   matchTrack2BEMC(const StTrack *);
    Int_t   checkCrossMembrane(const StTrack *);
    void    calculateRanks();
    Int_t   findSeeds();

    virtual void UseVertexConstraint() {}

    virtual double CalcChi2DCAs(const StThreeVectorD &vtx);
    
    bool                   mUseITTF;          // Use only tracks with ITTF encoded method
    bool                   mUseOldBEMCRank;   // Use old BEMC rank calculation (Cu+Cu production)
    bool                   mLowerSplitVtxRank;// Use lower rank for split vertices
    UInt_t                 mFlagBase;         // ITTF track flag
    bool                   mRequireCTB;       // Set maker to use CTB
    bool                   mFXT;              // Switch on FXT mode
    UInt_t                 mMinNumberOfFitPointsOnTrack;
    Float_t                mDcaZMax;
    Double_t               mRImpactMax;       // Max distance between helix and nominal beamline (0,0,z)
    Int_t                  mMinTrack;         // Min number of tracks
    Float_t                mZMin;             // Min z of possible vertex positions
    Float_t                mZMax;             // Max z of possible vertex positions

    enum                   {maxSeed=500};

    Int_t  mNSeed;

    Float_t                mSeedZ[maxSeed];
    Int_t                  mBemcHit[120][20][2];  // modules, eta, sub
    static std::vector<StPhysicalHelixD> mHelices;
    static std::vector<UShort_t>         mHelixFlags;
    static std::vector<Double_t>         mZImpact;
    static Bool_t                   requireCTB;
    static Int_t                    nCTBHits;
    Int_t                    mStatusMin;           // Minuit status flag 
    StThreeVectorD           mExternalSeed;
    Bool_t                   mExternalSeedPresent;
    StPrimaryVertex         *mBestVtx;    // pointer to best vertex of this event
    Float_t                  mBestRank;   // store rank of best vertex
    Float_t                  mCTBSum;
};