VtVertex.hh

Go to the documentation of this file.

#ifndef __VTVERTEX_HH
#define __VTVERTEX_HH
// *****************************************************************************
//
// source:
//
// type:      source code
//
// created:   21. Aug 2000
//
// author:    Thorsten Glebe
//            HERA-B Collaboration
//            Max-Planck-Institut fuer Kernphysik
//            Saupfercheckweg 1
//            69117 Heidelberg
//            Germany
//            E-mail: T.Glebe@mpi-hd.mpg.de
//
// Description: Vertex class
//
// changes:
// 21 Aug 2000 (TG) creation
// 25 Aug 2000 (TG) remove_worst added
// 04 Sep 2000 (TG) member function ndf() added. chi2() returns now chi2
//                  and not chi2/ndf any more
// 04 Sep 2000 (TG) Modified argument of VtRemoveTrack()
// 05 Sep 2000 (TG) declared some member functions as inline
// 05 Sep 2000 (TG) erase() member function added
// 12 Sep 2000 (TG) private member function bigdim() added
// 12 Sep 2000 (TG) member function bigcov() added
// 13 Sep 2000 (TG) added xmass member and add() member function
// 14 Sep 2000 (TG) added v_CINV member
// 14 Sep 2000 (TG) bug fix in documentation
// 02 Okt 2000 (TG) added chi2l() member function
// 04 Okt 2000 (TG) removed v_use_momentum data member
// 17 Okt 2000 (TG) modified comments
// 18 Okt 2000 (TG) MassConstr() member function added
// 24 Okt 2000 (TG) invalid() member function added, v_covn, v_Mvalid member added,
//                  changed return type of bigcov()
// 25 Okt 2000 (TG) covn() member function added
// 26 Okt 2000 (TG) #ifndef NO_ARTE added (for integration into CLUE)
// 14 Nov 2000 (TG) added constructors for CLUE (RecoSegment, ArtePointer<RecoTrack>)
// 31 Jan 2001 (TG) added prob() member function
// 02 Feb 2001 (TG) added global ClMember declarations
// 20 Feb 2001 (TG) pmaxfrac() added, ClMember pmaxfrac added
// 27 Feb 2001 (TG) improved ndf() (mass constrained vertex fit case added)
// 28 Feb 2001 (TG) added default argument to calc_mother()
// 06 Mar 2001 (TG) v_angdist added, angle() and dist() check now whether they
//                  are computed.
// 12 Mar 2001 (TG) set_invalid() added
// 09 Jul 2001 (TG) changed return type of ntracks() to unsigned int, added clear()
// 04 Sep 2001 (TG) added push_back(TrackIf), added VertexIf inheritance
// 17 Okt 2001 (TG) added/improved #defines for ARTE
//
// *****************************************************************************
 
#include <iosfwd>
#include <vector>
#include "CMatrix.hh"
#include "VtVector.hh"
#include "VtTrack.hh"
#include "VtMassC_list.hh"
 
#ifdef WIN32
#   include "Rtypes.h"
#endif
 
void Dinv1(int *n, double *a, int *idim, double *ir, int *ifail);
 
namespace VERTEX {
  //
  // Some Declarations
  //
  class Track;
  class Vertex;
 
  typedef std::vector<double>                 Vector_d;
 
  typedef std::vector<Track*>                 Track_v;
  typedef std::vector<Track*>::iterator       Track_it;
  typedef std::vector<Track*>::const_iterator Track_cit;
 
  //============================================================================
  // Class Vertex
  //============================================================================
  class Vertex: public Track
 {
  public:
    
    Vertex();
    Vertex(const Vertex& rhs);
    Vertex(const Track_v& v);
    Vertex(Track& t1, Track& t2);
    ~Vertex();
 
    float vx()      const;
    float vy()      const;
    float vz()      const;
    float chi2()    const;
    float prob()    const;
    unsigned short int ndf() const;
    unsigned short int ntracks() const;
 
#if defined USE_ROOT && !defined __CINT__
    SVector<double,3> vpos() const;
    const SMatrix<double,3>& VCOV() const;
#endif
 
    float vtx_cov_x()   const;
    float vtx_cov_y()   const;
    float vtx_cov_z()   const;
 
    double angle()   const;
    double dist()    const;
    double vxerr()   const;
    double vyerr()   const;
    double vzerr()   const;
 
    double pmaxfrac() const;
 
    const MATRIX::VtSymMatrix&  CS()   const;
    const MATRIX::VtSymMatrix&  covn() const;
    bool valid() const;
    void set_invalid();
 
    double mass(const bool use = false) const;
    double massCC(const bool use = false) const;
    double mass(double m1) const;
    double mass(double m1, double m2) const;
    double mass(double m1, double m2, double m3) const;
    double mass(double m1, double m2, double m3, double m4) const;
    double mass(const Vector_d& m02, bool use = false, bool CC = false)  const;
 
    const bool findVertex2D(void);
    const bool findVertex3D(void);
    const bool findVertexVt    ();
    const bool VtEstimateVertex();
    const bool VtEstimateVertexMath(double& x, double& y, double& z);
    const bool VtEstimateVertexMathTA(double& x, double& y, double& z);
    const bool VtMass();
 
    void push_back(Track& track);
 
    double rmsDistAngle() const;
    bool calc_mother(bool use_kalman = true);
    bool calc_mother_cov();
 
    const bool remove_last();
    void remove_worst();
    double track_chi2(int i);
    int track_worst();
    void  use_momentum(const bool use);
    void  use_kalman(const bool use);
    bool  use_kalman() const;
    double distance(double x, double y, double z) const;
    double distance(Track& t) const;
    double distance(const Vertex& rhs) const;
 
    void clear();
    const bool VtFilter        ();
    const bool VtInverseFilter () const;
    void       VtSmoothX       ();
    void       VtSmoothQ       ();
    const bool VtRemoveTrack   (Relation& track);
    const bool VtFit           ();
    const MATRIX::VtVector& xv()  const;
    const MATRIX::VtVector& xvs() const;
    std::ostream& print(std::ostream& os) const;
    double chi2n() const;
    double chi2l() const;
    virtual void remove(Relation* r);
    virtual const iterator erase(const iterator& pos);
    const MATRIX::VtSymMatrix& bigcov();
 
    void MassConstr(double m);
    MassC& addMassConstr(double m=0.);
    void clearMassConstr();
    unsigned int nMassConstr() const;
 
    const Vertex& operator= (const Vertex& rhs);
    const bool    operator==(const Vertex& rhs) const;
    const double  operator- (const Vertex& rhs) const;
 
   void         add_track(Track &t);
   const Track *get_track(int i) const;
 
  private:
    const unsigned int bigdim() const;
    // flag vertex as invalid 
    void invalid();                       
    
    bool           v_use_kalman;          // use refitted track parameters
    bool           v_valid;               // is vertex information valid?
    bool           v_Mvalid;              // is mass constrained vertex information valid?
    bool           v_mother;              // is the mother particle calculated?
    mutable bool   v_angdist;             // is angle and dist calculated?
    mutable double v_angle;               // rms of opening angle
    mutable double v_dist;                // rms of distance to vertex
    double         v_bk13;                // vtx-z at begin of iteration step
                                          // (in Vt: Bk13(iv), b13)
    double         v_chi2;                // chi2 of vertex-fit
    MATRIX::VtVector     kal_xv;          // x,y,z of vtx from kalman filter
    MATRIX::VtVector     kal_xvs;         // pos of Vertex after smooth
                                          // (xv-smoothed) (in Vt: xvs(1..3,...))
    MATRIX::VtSymMatrix  v_CS;            // v_C smoothed (=v_C of last
                                          // filtered track) (in Vt: CS)
    MATRIX::VtSymMatrix  v_CINV;          // inverse of CS at initialization time
    MATRIX::VtSymMatrix* v_covn;          // (3*n+3)x(3*n+3) big cov. matrix
    Track_v    tracks;                    // tracks owned by vertex
    MassC_v    xmass;                     // vector of mass constraint pointer
 
#ifdef WIN32
    ClassDef(Vertex, 0);   //GS comment if <VersionNumber> >= 1 crash with Windows Vista
#else
    ClassDef(Vertex, 1);
#endif
  }; // class Vertex
 
 
  //==============================================================================
  // operator<<
  //==============================================================================
  inline std::ostream& operator<<(std::ostream& s, const Vertex& a) {
    return a.print(s);
  }
 
} // namespace VERTEX
 
#ifndef __CINT__
#include "VtVertex.icc"
#endif
 
#endif