Reconstruction/MdcPatRec/TrkBase/include/TrkBase/TrkRep.h

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//      $Id: TrkRep.h,v 1.2 2006/03/28 01:02:36 zhangy Exp $
//
// Description: Base class for internal track representation classes -- e.g.
//   HelixRep, KalRep.  Owns and maintains a TrkHotList; and keeps a
//   pointer to the track that owns the Rep.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Authors: Steve Schaffner
//
//------------------------------------------------------------------------
 
#ifndef TRKREP_HH
#define TRKREP_HH
#include "MdcRecoUtil/PdtPid.h"
#include "TrkBase/TrkDirection.h"
#include "TrkBase/TrkFit.h"
#include "TrkBase/TrkFitStatus.h"
#include "TrkBase/TrkHitOnTrkUpdater.h"
#include "TrkBase/TrkHotList.h"
#include <memory>
// These 3 are needed for the OSF compiler:
#include "CLHEP/Vector/ThreeVector.h"
#include "MdcRecoUtil/BesPointErr.h"
#include "MdcRecoUtil/BesVectorErr.h"
// the following is needed by the Sun compiler
#include "ProbTools/ChisqConsistency.h"
 
class TrkHitOnTrk;
#include <iosfwd>
class TrkDifTraj;
class TrkErrCode;
class TrkExchangePar;
class TrkRecoTrk;
class TrkVolume;
class IfdKey;
class TrkContext;
 
// Class interface //
class TrkRep : public TrkFitStatus, public TrkFit, public TrkHitOnTrkUpdater {
 
public:
  //******************************************
  // Constructors and such
  //******************************************
  // construct from a hotlist -- The rep will not take ownership of anything passed
  //                          -- it will _clone_ the hots passed on inHots
  TrkRep( const TrkHotList& inHots, TrkRecoTrk* trk, PdtPid::PidType hypo );
  TrkRep( TrkHotList& inHots, TrkRecoTrk* trk, PdtPid::PidType hypo, bool stealHots = false );
  // construct from a hotlist -- The rep will always _TAKE OWNERSHIP_ of the hots
  //                             and if takeownership==true, ALSO of the list.
  TrkRep( const TrkHotList* inHots, TrkRecoTrk* trk, PdtPid::PidType hypo );
  TrkRep( TrkHotList* inHots, TrkRecoTrk* trk, PdtPid::PidType hypo,
          bool takeownership = false );
  // For reps w/o hits stored
  TrkRep( TrkRecoTrk* trk, PdtPid::PidType hypo, int nAct, int nSvt, int nMdc,
          double startFoundRange, double endFoundRange );
  // rep without explicit hotlist
  TrkRep( TrkRecoTrk* trk, PdtPid::PidType hypo, bool createHotList = false );
  // copy ctor
  TrkRep( const TrkRep& oldRep, TrkRecoTrk* trk, PdtPid::PidType hypo );
  virtual ~TrkRep();
  // clone() used to copy tracks; cloneNewHypo() for new hypos within track
  virtual TrkRep* clone( TrkRecoTrk* newTrack ) const  = 0;
  virtual TrkRep* cloneNewHypo( PdtPid::PidType hypo ) = 0;
  bool            operator==( const TrkRep& );
 
  //******************************************
  // Global quantities:
  //******************************************
  virtual ChisqConsistency chisqConsistency() const;
  virtual int              nActive() const;
  virtual int              nSvt() const;
  virtual int              nMdc() const;
  virtual PdtPid::PidType  particleType() const;
  TrkRecoTrk*              parentTrack() { return _parentTrack; }
  const TrkRecoTrk*        parentTrack() const { return _parentTrack; }
  double                   startValidRange() const;
  double                   endValidRange() const;
  virtual double           startFoundRange() const;
  virtual double           endFoundRange() const;
  virtual const IfdKey&    myKey() const;
  double                   trackT0() const;
 
  //******************************************
  // Information about track at a given position
  //******************************************
  virtual HepPoint3D   position( double fltL ) const;
  virtual Hep3Vector   direction( double fltL ) const;
  virtual double       arrivalTime( double fltL ) const;
  virtual BesPointErr  positionErr( double fltL ) const;
  virtual BesVectorErr directionErr( double fltL ) const;
 
  //******************************************
  // Hit (list) handling
  //******************************************
  // Simple implementations of these are present in the base class;
  //   complicated reps (e.g. Kalman) may wish to override.
  virtual void              addHot( TrkHitOnTrk* theHot );
  virtual void              removeHot( TrkHitOnTrk* theHot );
  virtual void              activateHot( TrkHitOnTrk* theHot );
  virtual void              deactivateHot( TrkHitOnTrk* theHot );
  virtual TrkHotList*       hotList() { return _hotList.get(); }
  virtual const TrkHotList* hotList() const { return _hotList.get(); }
  virtual void              updateHots();
  virtual bool resid( const TrkHitOnTrk* theHot, double& residual, double& residErr,
                      bool exclude = false ) const;
 
  // Distinguishes hotLists that actually hold hits from those that just hold
  //   info (e.g. nActive) about the hits used to create the fit
  bool hitCapable() const { return hotList()->hitCapable(); }
 
  //******************************************
  // Fitting stuff
  //******************************************
  virtual TrkErrCode fit() = 0;
 
protected:
  TrkRep&           operator=( const TrkRep& );
  const TrkContext& trkContext() const;
 
  // protected, not private, so derived classes can create in copy ctor
  std::auto_ptr<TrkHotList> _hotList;
 
private:
  void init( TrkRecoTrk* trk, PdtPid::PidType hypo );
 
  PdtPid::PidType _partHypo;
  TrkRecoTrk*     _parentTrack;
  mutable double  _betainv; // cache for arrivalTime
};
 
#endif