SVertex.hh

Go to the documentation of this file.

#ifndef __SVERTEX_HH
#define __SVERTEX_HH
// ********************************************************************
//
// source:
//
// type:      source code
//
// created:   06. Apr 2001
//
// 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: A fixed size Vertex class
//
// changes:
// 06 Apr 2001 (TG) creation
// 07 Apr 2001 (TG) mass() added
// 10 Apr 2001 (TG) findVertexVt(), kalman_, v_bk13, template parameter use_mom
//                  added
// 12 Apr 2001 (TG) set_track, track(), calc_mother(), calc_mother_tr(),
//                  bigcov(), mother() added 
// 17 Apr 2001 (TG) Track inheritance added, calc_mother_cov() added
// 18 Apr 2001 (TG) removed use_mom template parameter, added mass_tr
// 24 Apr 2001 (TG) valid_, valid(), invalid() added
// 24 Apr 2001 (TG) renamed calc_mother() to calc_mother_tr() and
//                  calc_mother_tr() to calc_mother_trtr(). Added new calc_mother().
// 24 Apr 2001 (TG) added prob()
// 30 Apr 2001 (TG) added pt() and xfabs()
// 02 Mai 2001 (TG) phi(), theta(), eta() added
// 03 Mai 2001 (TG) added read/write vposR(), added findVertexNe()
// 03 Mai 2001 (TG) CTOR added, size added
// 08 Jun 2001 (TG) added massError()
// 11 Jun 2001 (TG) added cov_tx(), cov_ty(), cov_p()
// 28 Jun 2001 (TG) added charge(), pz(), energy(), xf(), rap(), removed xfabs()
// 04 Jul 2001 (TG) moth_tr, moth_cov added
// 05 Jul 2001 (TG) collect() added
// 09 Jul 2001 (TG) added valid(), invalid(), isValid() from Track, removed
//                  valid(), invalid() from Vertex, added ntracks()
// 10 Jul 2001 (TG) operator==() added
// 23 Aug 2001 (TG) added CTOR, added copy CTOR
// 03 Sep 2001 (TG) added operator=()
// 02 Okt 2001 (TG) set_vpos() added
// 07 Nov 2001 (TG) documentation improved
// 03 Jan 2002 (TG) isMotherTr(), isMotherCov() added, renamed valid_ to
//                  validKalmanFit, changed return type of calcVertex2D
// 04 Jan 2002 (TG) added isKalmanFit()
// 09 Jan 2002 (TG) changed return type of propagate() to bool
// 11 Jan 2002 (TG) added v_ndf member
// 16 Jan 2002 (TG) added operator=(SVertex<NTR>)
//
// ********************************************************************
#include <cmath>
#include <iosfwd>
#include "vt++/VtVertex.hh"
#include "vt++/VtTrack.hh"
#include "smatrix/SVector.hh"
#include "smatrix/SKalman.hh"
 
//==============================================================================
// SVertex
//==============================================================================
template <unsigned int NTR>
class SVertex : public Vertex, public Track {
public:
  SVertex();
  SVertex(const SVertex<NTR>& rhs);
  SVertex(const Track& t);
  SVertex(const Track& t1, const Track& t2);
  SVertex(const Track& t1, const Track& t2, const Track& t3);
  SVertex(const Track& t1, const Track& t2, const Track& t3,
      const Track& t4);
  SVertex(const SVertex<NTR-1>& vtx, const Track& t);
 
  SVertex<NTR>& operator=(const SVertex<NTR>& rhs);
 
  static const unsigned int size = NTR;
 
  float vx()   const;
  float vy()   const;
  float vz()   const;
  float chi2() const;
  unsigned short int ndf()  const;
  float prob() const;
  unsigned short int ntracks() const;
  const Track* track(unsigned int i) const;
  const Track*& track(unsigned int i);
  
  SVector<double,3> vpos() const;
  const SMatrix<double,3>& VCOV() const;
 
  float vtx_cov_x()   const;
  float vtx_cov_y()   const;
  float vtx_cov_z()   const;
 
  const SVector<double,3>& vposR() const;
  SVector<double,3>& vposR();
  void set_vpos(const SVector<double,3>& pos);
  
  void set_track(unsigned int i, const Track& t);
  const SKalman<NTR>& kalman(unsigned int i) const;
  SKalman<NTR>& kalman(unsigned int i);
  const SMatrix<double,3>& VCINV() const;
  const SVector<double,6>& mother() const;
  const SMatrix<double,3*NTR+3>& covn() const;
 
  SVector<double,3> findVertex2D() const;
  bool calcVertex2D();
  bool findVertex3D(SVector<double,3>& pos) const;
  bool findVertexVt();
  bool findVertexNe();
  SVector<double,2> rmsDistAngle() const;
  SVector<double,3> EstimateVertex() const;
  double mass(const SVector<double,NTR>& rm) const;
  double massError(const SVector<double,NTR>& rm) const;
  double mass_tr(const SVector<double,NTR>& rm) const;
 
  float x()        const;
  float y()        const;
  float x(float z) const;
  float y(float z) const;
  float z()        const;
  float tx()       const;
  float ty()       const;
  float p()        const;
  float pt()       const;
  float pz()    const;
  float phi() const;
  float theta() const;
  float eta() const;
  int   charge() const;
 
  float energy(double mass = 0.) const;
  float xf(double mass = 0.) const;
  float rap(double mass = 0.) const;
 
  float cov_x(double dz=0.) const;
  float cov_y(double dz=0.) const;
  float cov_tx()            const;
  float cov_ty()            const;
  float cov_p()             const;
 
  bool isValid() const;
  void valid();
  void invalid();
 
  SVector<double,3> xvec() const;
  SVector<double,3> tvec() const;
  SVector<double,3> evec() const;
  SVector<double,3> pvec() const;
 
  const SMatrix<double,5>& COV()   const;
  const SMatrix<double,5>& CINV()  const;
 
  void collect(vector<Track*>& c) const;
  bool propagate(const double z);
  std::ostream& print( std::ostream& ) const;
 
  bool operator==(const Track& rhs) const;
 
  bool isMotherTr() const;
  bool isMotherCov() const;
  bool isKalmanFit() const;
 
  bool filter();
  bool smooth();
  bool smoothC();
  inline double bk13() const { return v_bk13; }
  bool calc_mother();
  bool calc_mother_tr();
  bool calc_mother_trtr();
  bool calc_mother_cov();
  bool bigcov();
  
private:
  SVector<double,3>    vpos_;          // vertex position
  double               v_bk13;         // vtx-z before kalman filter could be vz?
  const Track*       tracks[NTR];    // track pointers
  SKalman<NTR>         kalman_[NTR];   // kalman objects
  SMatrix<double,3>    v_CS;           // vertex cov. matrix
  SMatrix<double,3>    v_CINV;         // inverse vertex cov. matrix
  double               v_chi2;         // chi2 of vertex fit
  unsigned int         v_ndf;          // no of degrees of vertex fit
  SVector<double,6>    t_p;            // track parameter of mother particle
  SMatrix<double,3*NTR+3> v_covn;      // cov. matrix of all track parameters
  SMatrix<double,5>    cov_;           // cov. matrix of reconstructed track
  SMatrix<double,5>    cinv_;          // inv. cov. matrix of reconstructed track
  bool                 validKalmanFit; // was Kalman fit successful?
  bool                 valid_;         // is vertex valid?
  bool                 moth_tr;        // is mother track calculated?
  bool                 moth_cov;       // is mother covariance matrix calculated?
  bool                 validity;       // vertex validity, manually set
}; // class SVertex
 
 
//==============================================================================
// operator <<
//==============================================================================
template <unsigned int NTR>
inline std::ostream& operator<< (std::ostream& os, const SVertex<NTR>& vt) {
  return vt.print( os );
}
 
#include "SVertex.icc"
#endif