Reconstruction/TrkReco/include/TrkReco/TTrackManager.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// $Id: TTrackManager.h,v 1.17 2012/05/28 05:16:29 maoh Exp $
//-----------------------------------------------------------------------------
// Filename : TTrackManager.h
// Section  : Tracking
// Owner    : Yoshi Iwasaki
// Email    : yoshihito.iwasaki@kek.jp
//-----------------------------------------------------------------------------
// Description : A manager of TTrack information to make outputs as Reccdc_trk.
//               See http://bsunsrv1.kek.jp/~yiwasaki/tracking/
//-----------------------------------------------------------------------------
 
#ifndef TTRACKMANAGER_FLAG_
#define TTRACKMANAGER_FLAG_
 
#ifdef TRKRECO_DEBUG_DETAIL
#  ifndef TRKRECO_DEBUG
#    define TRKRECO_DEBUG
#  endif
#endif
 
#include <string>
 
// #define HEP_SHORT_NAMES
#include "CLHEP/Alist/AList.h"
#include "MdcRecEvent/RecMdcHit.h"
#include "MdcRecEvent/RecMdcTrack.h"
#include "TrkReco/TCosmicFitter.h"
#include "TrkReco/THelixFitter.h"
#include "TrkReco/TUpdater.h"
class TMDCWireHit;
class TTrack;
// struct reccdc_trk;
// struct reccdc_trk_add;
// struct reccdc_mctrk;
// struct rectrk;
#include "MdcTables/MdcTables.h"
#include "MdcTables/TrkTables.h"
#include "RawDataProviderSvc/IRawDataProviderSvc.h"
 
class StatusCode;
 
/// A manager of TTrack information to make outputs as MdcRec_trk.
class TTrackManager : public TUpdater {
 
public:
  /// Constructor.
  TTrackManager();
 
  /// Destructor.
  virtual ~TTrackManager();
 
  /// dumps debug information.
  void dump( const std::string& message = std::string( "" ),
             const std::string& prefix  = std::string( "" ) ) const;
 
public: // to access information
  /// returns name.
  std::string name( void ) const;
 
  /// returns version.
  std::string version( void ) const;
 
  /// returns a list of all reconstructed tracks including junks.
  const AList<TTrack>& allTracks( void ) const;
 
  /// returns a list of reconstructed tracks.
  const AList<TTrack>& tracks( void ) const;
 
  /// returns a list of 2D tracks.
  const AList<TTrack>& tracks2D( void ) const;
 
  /// returns a list of tracks writen to MdcRec_trk.
  const AList<TTrack>& tracksFinal( void ) const;
 
public: // parameters
  /// sets fitting flag.
  void fittingFlag( unsigned );
 
  /// sets the max. momentum.
  double maxMomentum( double );
 
  /// returns/sets debug level.
  int debugLevel( void ) const;
  int debugLevel( int );
 
  // 6para T0... Liuqg
  float paraT0( void ) const;
 
public: // track manipulations
  /// clears all internal information.
  void clear( void );
 
  /// checks goodness of a track.
  static bool goodTrack( const TTrack&, bool track2D = false );
 
  /// appends (2D) tracks. 'list' will be cleaned up.
  void append( AList<TTrack>& list );
  void append2D( AList<TTrack>& list );
 
  /// refits tracks.
  void refit( void );
 
  /// finishes tracks.
  void finish( void );
 
  /// moves pivot of tracks.
  void movePivot( void );
 
  /// determines T0 and refit all tracks.
  StatusCode determineT0( unsigned level, unsigned nMaxTracks );
 
  /// tests for curlers.
  void setCurlerFlags( void );
 
  /// sorts tracks.
  void sortTracksByQuality( void );
  void sortTracksByPt( void );
 
public: // table manipulations
  /// clears tables.
  void clearTables( void ) const;
 
  /// stores track info. into TDS. by Zang Shilei
  // yzhang changed 2010-01-12
  // StatusCode makeTds(bool doClear = true, int tkStat = 0);
  StatusCode makeTds( RecMdcTrackCol* trackList, RecMdcHitCol* hitList, int tkStat = 1,
                      int runge = 0, int cal = 0 );
 
  /// stores track info. into Panther table.
  void saveTables( void );
 
  /// stores MC track info. into Panther table.
  void saveMCTables( void ) const;
 
  /// sorts RECMDC_TRK tables.
  void sortBanksByPt( void ) const;
 
private: // table manipulations in private
  /// copies a track. Non-zero will be returned if error happens.
  int copyTrack( TTrack& t, MdcRec_trk** r, MdcRec_trk_add** a ) const;
  /// sorts banks.
  void swapReccdc( MdcRec_trk& cdc0, MdcRec_trk_add& add0, MdcRec_mctrk& mc0, MdcRec_trk& cdc1,
                   MdcRec_trk_add& add1, MdcRec_mctrk& mc1 ) const;
  void swapRectrk( MdcTrk& trk0, MdcTrk& tkr1 ) const;
  void tagReccdc( unsigned* id, unsigned n ) const;
  void tagRectrk( unsigned* id, unsigned n ) const;
 
public: // functions for after trak
  /// final decision for a curler.
  void treatCurler( MdcTrk& curl, MdcRec_trk_add& cdc, unsigned flag ) const;
 
  /// determines IP.
  void determineIP( void );
 
public: // hit manipulations
  /// masks hits on found curl tracks.
  void maskCurlHits( const AList<TMDCWireHit>& axial, const AList<TMDCWireHit>& stereo,
                     const AList<TTrack>& tracks ) const;
 
  /// masks hits with large chisq as associated hits. Pull in TMLink is used.
  static void maskBadHits( const AList<TTrack>&, float maxSigma2 );
 
  /// salvages hits for dE/dx(not for track fitting).
  void salvageAssociateHits( const AList<TMDCWireHit>&, float maxSigma2 );
 
  /// associates SVD and then adds track information.
  //    void addSvd(const int) const;
 
private: // internal functions
  /// checks track quality.
  AList<TTrack> selectGoodTracks( const AList<TTrack>&, bool track2D = false ) const;
  static bool   checkNumberOfHits( const TTrack&, bool track2D = false );
 
  /// names tracks.
  void nameTracks( void );
 
  /// returns T0 by old methode(expensive).
  float T0( unsigned n );
 
  /// returns T0 by T0 fitting.
  float T0Fit( unsigned n );
  float minimum( float y0, float y1, float y2 ) const;
 
public: // obsolete
  TMLink& divide( const TTrack& t, AList<TMLink>* l ) const;
  TMLink& divideByIp( const TTrack& t, AList<TMLink>* l ) const;
  void    removeHitsAcrossOverIp( AList<TMLink>& ) const;
  /// returns a track which is the closest to a hit.
  TTrack* closest( const AList<TTrack>&, const TMDCWireHit& ) const;
  /// salvages remaining hits.
  void salvage( const AList<TMDCWireHit>& ) const;
  /// masks hits out which are in tail of curly tracks.
  void mask( void ) const;
  void maskNormal( TTrack& ) const;
  void maskCurl( TTrack& ) const;
  void maskOut( TTrack&, const AList<TMLink>& ) const;
  void maskMultiHits( TTrack& ) const;
  void merge( void );
 
  void sett0bes( double t0 ) { t0bes = t0; }
 
private:
  IBesMagFieldSvc*     getPmgnIMF() const;
  IRawDataProviderSvc* getRawDataProviderSvc() const;
 
  mutable IBesMagFieldSvc*     m_pmgnIMF;
  mutable IRawDataProviderSvc* m_rawDataProviderSvc;
  double                       t0bes;
  int                          _debugLevel;
  double                       _maxMomentum;
  double                       _sigmaCurlerMergeTest;
  unsigned                     _nCurlerMergeTest;
 
  THelixFitter _fitter;
  THelixFitter _cFitter;
 
  AList<TTrack> _tracksAll;   // all tracks found by the finders
  AList<TTrack> _tracks;      // good 3D tracks determined by the mgr
  AList<TTrack> _tracks2D;    // good 2D tracks determined by the mgr
  AList<TTrack> _tracksFinal; // final tracks output to tables
 
  AList<TMLink> _associateHits;
 
  struct summary {
    unsigned _nEvents;
    unsigned _nTracks;
    unsigned _nTracksAll;
    unsigned _nTracks2D;
    unsigned _nTracksFinal;
    unsigned _nSuperMoms;
    unsigned _nToBeMerged;
    unsigned _nToBeMergedMoreThanTwo;
  };
  struct summary* _s;
 
  // t0 in 6 para helix fitting... Liuqg
  float _t0;
};
 
//-----------------------------------------------------------------------------
 
#ifdef TRKRECO_NO_INLINE
#  define inline
#else
#  undef inline
#  define TTRACKMANAGER_INLINE_DEFINE_HERE
#endif
 
#ifdef TTRACKMANAGER_INLINE_DEFINE_HERE
 
inline std::string TTrackManager::name( void ) const { return std::string( "Track Manager" ); }
 
inline const AList<TTrack>& TTrackManager::tracks( void ) const { return _tracks; }
 
inline const AList<TTrack>& TTrackManager::tracks2D( void ) const { return _tracks2D; }
 
inline const AList<TTrack>& TTrackManager::allTracks( void ) const { return _tracksAll; }
 
inline double TTrackManager::maxMomentum( double a ) { return _maxMomentum = a; }
 
inline int TTrackManager::debugLevel( void ) const { return _debugLevel; }
 
inline int TTrackManager::debugLevel( int a ) { return _debugLevel = a; }
 
inline void TTrackManager::fittingFlag( unsigned a ) {
  if ( a & 1 ) _fitter.sag( true );
  if ( a & 2 ) _fitter.propagation( true );
  if ( a & 4 ) _fitter.tof( true );
  if ( a & 8 ) _fitter.freeT0( true );
}
 
inline const AList<TTrack>& TTrackManager::tracksFinal( void ) const { return _tracksFinal; }
 
inline float TTrackManager::paraT0( void ) const { return _t0; }
 
#endif
 
#undef inline
 
#endif /* TTRACKMANAGER_FLAG_ */