Analysis/VertexFit/include/VertexFit/TrackPool.h

Go to the documentation of this file.

#ifndef VertexFit_TrackPool_H
#define VertexFit_TrackPool_H
 
//
//  Add Track Parameters to VertexFit/KinematicFit
//  Author: K.L. He     date: 11/09/2005, created
//
 
// #include <map>
// #include <string>
// #include <utility>
 
#include "VertexFit/GammaShape.h"
#include "VertexFit/WTrackParameter.h"
#include <vector>
 
#ifndef BEAN
// #include "DstEvent/DstMdcTrack.h"
// #include "DstEvent/DstMdcKalTrack.h"
// #include "DstEvent/DstEmcTrack.h"
#  include "EmcRecEventModel/RecEmcShower.h"
#  include "MdcRecEvent/RecMdcKalTrack.h"
#  include "MdcRecEvent/RecMdcTrack.h"
#else
#  include "DstEvtRecTracks.h"
#endif
 
class TrackPool {
 
public:
  // constructor & deconstructor
  TrackPool();
  ~TrackPool() { ; }
 
  //
  //  Constructor Function
  //
  //                   event data model dependent
  void AddTrack( const int number, const double mass, const RecMdcTrack* trk );
  void AddTrack( const int number, const double mass, const RecMdcKalTrack* trk );
  void AddTrack( const int number, const double mass, const RecEmcShower* trk );
  //                   event data model independent
  void AddTrack( const int number, const WTrackParameter wtrk );
  //                   virtual track with missing parameters
  void AddMissTrack( const int number, const double mass );
  void AddMissTrack( const int number, const double mass, const HepLorentzVector p4 );
  void AddMissTrack( const int number, const double mass, const RecEmcShower* trk );
  void AddMissTrack( const int number, const RecEmcShower* trk );
  void AddMissTrack( const int number, const HepLorentzVector p4 );
  void AddTrackVertex( const int number, const double mass, const RecEmcShower* trk );
 
  std::vector<int> AddList( int n1 );
  std::vector<int> AddList( int n1, int n2 );
  std::vector<int> AddList( int n1, int n2, int n3 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5, int n6 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5, int n6, int n7 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8,
                            int n9 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8,
                            int n9, int n10 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8,
                            int n9, int n10, int n11 );
  std::vector<int> AddList( int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8,
                            int n9, int n10, int n11, int n12 );
 
  //                       Get Function
 
  std::vector<WTrackParameter> wTrackOrigin() const { return m_wtrk_origin; }
  std::vector<WTrackParameter> wTrackInfit() const { return m_wtrk_infit; }
  std::vector<int>             wTrackList() const { return m_lwtrk; }
  WTrackParameter              wTrackOrigin( int n ) const { return m_wtrk_origin[n]; }
  WTrackParameter              wTrackInfit( int n ) const { return m_wtrk_infit[n]; }
  int                          wTrackList( int n ) const { return m_lwtrk[n]; }
  //                       number of WTrack
  int numberWTrack() const { return ( (int)( m_lwtrk.size() ) ); }
  //
  // For Virtual Particles
  //
  //  std::vector<WTrackParameter> wTrackOrigin_V() const {return m_wtrk_origin_V;}
  //  std::vector<WTrackParameter> wTrackInfit_V() const {return m_wtrk_infit_V;}
  //  std::vector<int>    wTrackList_V() const {return m_lwtrk_V;}
  //  WTrackParameter wTrackOrigin_V(int n) const {return m_wtrk_origin_V[n];}
  //  WTrackParameter wTrackInfit_V(int n) const {return m_wtrk_infit_V[n];}
  //  int     wTrackList_V(int n) const {return m_lwtrk_V[n];}
  //                       number of WTrack
  //  int numberWTrack_V() const { return ((int)(m_lwtrk_V.size()));}
 
  //
  // gammashape get function
  //
  std::vector<GammaShape> GammaShapeValue() const { return m_gammashape; }
  std::vector<int>        GammaShapeList() const { return m_lgammashape; }
  GammaShape              GammaShapeValue( int n ) const { return m_gammashape[n]; }
  int                     GammaShapeList( int n ) const { return m_lgammashape[n]; }
  int numberGammaShape() const { return ( (int)( m_lgammashape.size() ) ); }
  //
  // modifier
  //
 
  //                set Function
  void setWTrackOrigin( const int n, const WTrackParameter wtrk ) { m_wtrk_origin[n] = wtrk; }
  void setWTrackInfit( const int n, const WTrackParameter wtrk ) { m_wtrk_infit[n] = wtrk; }
  void setWTrackOrigin( const WTrackParameter wtrk ) { m_wtrk_origin.push_back( wtrk ); }
  void setWTrackInfit( const WTrackParameter wtrk ) { m_wtrk_infit.push_back( wtrk ); }
  void setWTrackList( const int n ) { m_lwtrk.push_back( n ); }
  //                clear Function
  void clearWTrackOrigin() { m_wtrk_origin.clear(); }
  void clearWTrackInfit() { m_wtrk_infit.clear(); }
  void clearWTrackList() { m_lwtrk.clear(); }
 
  void clearone() { m_numberone = 0; }
  void cleartwo() { m_numbertwo = 0; }
  int  numberone() const { return m_numberone; }
  int  numbertwo() const { return m_numbertwo; }
 
  vector<int> mappositionA() const { return m_mappositionA; }
  vector<int> mappositionB() const { return m_mappositionB; }
  vector<int> mapkinematic() const { return m_mapkinematic; }
 
  void clearMapkinematic() { m_mapkinematic.clear(); }
  void clearMappositionA() { m_mappositionA.clear(); }
  void clearMappositionB() { m_mappositionB.clear(); }
 
  void setMapkinematic( const int n ) { m_mapkinematic.push_back( n ); }
  void setMappositionA( const int n ) { m_mappositionA.push_back( n ); }
  void setMappositionB( const int n ) { m_mappositionB.push_back( n ); }
 
  //
  // set GammaShape
  //
  void setGammaShape( const int n, const GammaShape gammashape ) {
    m_gammashape[n] = gammashape;
  }
  void setGammaShape( const GammaShape gammashape ) { m_gammashape.push_back( gammashape ); }
  void setGammaShapeList( const int n ) { m_lgammashape.push_back( n ); }
  //       clear gammashape
  void clearGammaShape() { m_gammashape.clear(); }
  void clearGammaShapeList() { m_lgammashape.clear(); }
 
  //=== set beam information===
  void setBeamPosition( const HepPoint3D BeamPosition ) { m_BeamPosition = BeamPosition; }
  void setVBeamPosition( const HepSymMatrix VBeamPosition ) {
    m_VBeamPosition = VBeamPosition;
  }
 
  //=== get beam information===
  HepPoint3D   getBeamPosition() const { return m_BeamPosition; }
  HepSymMatrix getVBeamPosition() const { return m_VBeamPosition; }
 
protected:
private:
  std::vector<WTrackParameter> m_wtrk_origin; // WTrack parameter before fit
  std::vector<WTrackParameter> m_wtrk_infit;  // WTrack Parameter in fit
  std::vector<int>             m_lwtrk; // List of the WTrack number ( != DST tracklist ID)
  //
  // For Virtual Particles
  //
  //  std::vector<WTrackParameter> m_wtrk_origin_V;
  //  std::vector<WTrackParameter> m_wtrk_infit_V;
  //  std::vector<int>    m_lwtrk_V;
 
  //  std::multimap< int, int >  m_mapkinematic;        // index origin track and new track
  //  std::multimap< int, int >  m_mappositionA;
  //  std::multimap< int, int >  m_mappositionB;
  int m_numberone; // recording the number of common particlss
  int m_numbertwo; // recording the number of virtual particles
  //    Gamma dynamic error information
  //
  std::vector<GammaShape> m_gammashape;
  std::vector<int>        m_lgammashape; // maybe can share with the m_lwtrk
 
  std::vector<int> m_mapkinematic; // index origin track and new track
  std::vector<int> m_mappositionA;
  std::vector<int> m_mappositionB;
 
private:
  HepPoint3D   m_BeamPosition;
  HepSymMatrix m_VBeamPosition;
};
#endif