Event/DstEvent/include/DstEvent/DstExtTrack.h

Go to the documentation of this file.

//
// File: DstExtTrack.h
// Author: L.L.Wang
 
#ifndef DSTEXTTRACK_H
#define DSTEXTTRACK_H
 
#include <vector>
 
#include "EventModel/EventModel.h"
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/ObjectVector.h"
 
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Vector/ThreeVector.h"
// #include "ExtEvent/ExtMucHit.h"
 
using namespace std;
using namespace EventModel;
 
using CLHEP::Hep3Vector;
using CLHEP::HepSymMatrix;
extern const CLID& CLID_DstExtTrack;
 
class DstExtTrack : virtual public ContainedObject {
public:
  const CLID& clID() const { return DstExtTrack::classID(); }
 
  static const CLID& classID() { return CLID_DstExtTrack; }
 
  DstExtTrack();
  ~DstExtTrack();
 
  const int GetTrackId() const { return m_trackId; }
  const int trackId() const { return m_trackId; }
 
  // Get track extrapolation data @ Tof layer1.
  // const Hep3Vector GetTof1Position() const;
  // const Hep3Vector GetTof1Momentum() const;
  // const string GetTof1VolumeName() const;
  // const int GetTof1VolumeNumber() const;
  // const double GetTof1() const;
  // const double GetTof1Path() const;
  // const double GetTof1PosSigmaAlongZ() const;
  // const double GetTof1PosSigmaAlongT() const;
  // const double GetTof1PosSigmaAlongX() const;
  // const double GetTof1PosSigmaAlongY() const;
  // const HepSymMatrix GetTof1ErrorMatrix() const;
 
  const Hep3Vector tof1Position() const { return myTof1Position[myParticleType]; };
  const Hep3Vector tof1Position( int parID ) const { return myTof1Position[parID]; };
  const Hep3Vector tof1Momentum() const { return myTof1Momentum[myParticleType]; };
  const Hep3Vector tof1Momentum( int parID ) const { return myTof1Momentum[parID]; };
  const string     tof1VolumeName() const { return myTof1VolumeName[myParticleType]; };
  const string     tof1VolumeName( int parID ) const { return myTof1VolumeName[parID]; };
  const int        tof1VolumeNumber() const { return myTof1VolumeNumber[myParticleType]; };
  const int        tof1VolumeNumber( int parID ) const { return myTof1VolumeNumber[parID]; };
  const double     tof1() const { return myTof1[myParticleType]; };
  const double     tof1( int parID ) const { return myTof1[parID]; };
  const double     tof1Path() const { return myTof1Path[myParticleType]; };
  const double     tof1Path( int parID ) const { return myTof1Path[parID]; };
  const double     tof1PosSigmaAlongZ() const { return myTof1PosSigmaAlongZ[myParticleType]; };
  const double tof1PosSigmaAlongZ( int parID ) const { return myTof1PosSigmaAlongZ[parID]; };
  const double tof1PosSigmaAlongT() const { return myTof1PosSigmaAlongT[myParticleType]; };
  const double tof1PosSigmaAlongT( int parID ) const { return myTof1PosSigmaAlongT[parID]; };
  const double tof1PosSigmaAlongX() const { return myTof1PosSigmaAlongX[myParticleType]; };
  const double tof1PosSigmaAlongX( int parID ) const { return myTof1PosSigmaAlongX[parID]; };
  const double tof1PosSigmaAlongY() const { return myTof1PosSigmaAlongY[myParticleType]; };
  const double tof1PosSigmaAlongY( int parID ) const { return myTof1PosSigmaAlongY[parID]; };
  const HepSymMatrix tof1ErrorMatrix() const { return myTof1ErrorMatrix[myParticleType]; };
  const HepSymMatrix tof1ErrorMatrix( int parID ) const { return myTof1ErrorMatrix[parID]; };
 
  // Get track extrapolation data @ Tof layer2.
  // const Hep3Vector GetTof2Position() const;
  // const Hep3Vector GetTof2Momentum() const;
  // const string GetTof2VolumeName() const;
  // const int GetTof2VolumeNumber() const;
  // const double GetTof2() const;
  // const double GetTof2Path() const;
  // const double GetTof2PosSigmaAlongZ() const;
  // const double GetTof2PosSigmaAlongT() const;
  // const double GetTof2PosSigmaAlongX() const;
  // const double GetTof2PosSigmaAlongY() const;
  // const HepSymMatrix GetTof2ErrorMatrix() const;
 
  const Hep3Vector tof2Position() const { return myTof2Position[myParticleType]; };
  const Hep3Vector tof2Position( int parID ) const { return myTof2Position[parID]; };
  const Hep3Vector tof2Momentum() const { return myTof2Momentum[myParticleType]; };
  const Hep3Vector tof2Momentum( int parID ) const { return myTof2Momentum[parID]; };
  const string     tof2VolumeName() const { return myTof2VolumeName[myParticleType]; };
  const string     tof2VolumeName( int parID ) const { return myTof2VolumeName[parID]; };
  const int        tof2VolumeNumber() const { return myTof2VolumeNumber[myParticleType]; };
  const int        tof2VolumeNumber( int parID ) const { return myTof2VolumeNumber[parID]; };
  const double     tof2() const { return myTof2[myParticleType]; };
  const double     tof2( int parID ) const { return myTof2[parID]; };
  const double     tof2Path() const { return myTof2Path[myParticleType]; };
  const double     tof2Path( int parID ) const { return myTof2Path[parID]; };
  const double     tof2PosSigmaAlongZ() const { return myTof2PosSigmaAlongZ[myParticleType]; };
  const double tof2PosSigmaAlongZ( int parID ) const { return myTof2PosSigmaAlongZ[parID]; };
  const double tof2PosSigmaAlongT() const { return myTof2PosSigmaAlongT[myParticleType]; };
  const double tof2PosSigmaAlongT( int parID ) const { return myTof2PosSigmaAlongT[parID]; };
  const double tof2PosSigmaAlongX() const { return myTof2PosSigmaAlongX[myParticleType]; };
  const double tof2PosSigmaAlongX( int parID ) const { return myTof2PosSigmaAlongX[parID]; };
  const double tof2PosSigmaAlongY() const { return myTof2PosSigmaAlongY[myParticleType]; };
  const double tof2PosSigmaAlongY( int parID ) const { return myTof2PosSigmaAlongY[parID]; };
  const HepSymMatrix tof2ErrorMatrix() const { return myTof2ErrorMatrix[myParticleType]; };
  const HepSymMatrix tof2ErrorMatrix( int parID ) const { return myTof2ErrorMatrix[parID]; };
 
  // Get track extrapolation data @ EMC.
  // const Hep3Vector GetEmcPosition() const;
  // const Hep3Vector GetEmcMomentum() const;
  // const string GetEmcVolumeName() const;
  // const int GetEmcVolumeNumber() const;
  // const double GetEmcPosSigmaAlongTheta() const;
  // const double GetEmcPosSigmaAlongPhi() const;
  // const HepSymMatrix GetEmcErrorMatrix() const;
 
  const Hep3Vector emcPosition() const { return myEmcPosition[myParticleType]; };
  const Hep3Vector emcPosition( int parID ) const { return myEmcPosition[parID]; };
  const Hep3Vector emcMomentum() const { return myEmcMomentum[myParticleType]; };
  const Hep3Vector emcMomentum( int parID ) const { return myEmcMomentum[parID]; };
  const string     emcVolumeName() const { return myEmcVolumeName[myParticleType]; };
  const string     emcVolumeName( int parID ) const { return myEmcVolumeName[parID]; };
  const int        emcVolumeNumber() const { return myEmcVolumeNumber[myParticleType]; };
  const int        emcVolumeNumber( int parID ) const { return myEmcVolumeNumber[parID]; };
  const double     emcPosSigmaAlongTheta() const {
    return myEmcPosSigmaAlongTheta[myParticleType];
  };
  const double emcPosSigmaAlongTheta( int parID ) const {
    return myEmcPosSigmaAlongTheta[parID];
  };
  const double emcPosSigmaAlongPhi() const { return myEmcPosSigmaAlongPhi[myParticleType]; };
  const double emcPosSigmaAlongPhi( int parID ) const { return myEmcPosSigmaAlongPhi[parID]; };
  const HepSymMatrix emcErrorMatrix() const { return myEmcErrorMatrix[myParticleType]; };
  const HepSymMatrix emcErrorMatrix( int parID ) const { return myEmcErrorMatrix[parID]; };
  const double       emcPath() const { return myEmcPath[myParticleType]; };
  const double       emcPath( int parID ) const { return myEmcPath[parID]; };
 
  // Get track extrapolation data @ MUC.
  // const Hep3Vector GetMucPosition() const;
  // const Hep3Vector GetMucMomentum() const;
  // const string GetMucVolumeName() const;
  // const int GetMucVolumeNumber() const;
  // const double GetMucPosSigmaAlongZ() const;
  // const double GetMucPosSigmaAlongT() const;
  // const double GetMucPosSigmaAlongX() const;
  // const double GetMucPosSigmaAlongY() const;
  // const HepSymMatrix GetMucErrorMatrix() const;
 
  const Hep3Vector mucPosition() const { return myMucPosition[myParticleType]; };
  const Hep3Vector mucPosition( int parID ) const { return myMucPosition[parID]; };
  const Hep3Vector mucMomentum() const { return myMucMomentum[myParticleType]; };
  const Hep3Vector mucMomentum( int parID ) const { return myMucMomentum[parID]; };
  const string     mucVolumeName() const { return myMucVolumeName[myParticleType]; };
  const string     mucVolumeName( int parID ) const { return myMucVolumeName[parID]; };
  const int        mucVolumeNumber() const { return myMucVolumeNumber[myParticleType]; };
  const int        mucVolumeNumber( int parID ) const { return myMucVolumeNumber[parID]; };
  const double     mucPosSigmaAlongZ() const { return myMucPosSigmaAlongZ[myParticleType]; };
  const double     mucPosSigmaAlongZ( int parID ) const { return myMucPosSigmaAlongZ[parID]; };
  const double     mucPosSigmaAlongT() const { return myMucPosSigmaAlongT[myParticleType]; };
  const double     mucPosSigmaAlongT( int parID ) const { return myMucPosSigmaAlongT[parID]; };
  const double     mucPosSigmaAlongX() const { return myMucPosSigmaAlongX[myParticleType]; };
  const double     mucPosSigmaAlongX( int parID ) const { return myMucPosSigmaAlongX[parID]; };
  const double     mucPosSigmaAlongY() const { return myMucPosSigmaAlongY[myParticleType]; };
  const double     mucPosSigmaAlongY( int parID ) const { return myMucPosSigmaAlongY[parID]; };
  const HepSymMatrix mucErrorMatrix() const { return myMucErrorMatrix[myParticleType]; };
  const HepSymMatrix mucErrorMatrix( int parID ) const { return myMucErrorMatrix[parID]; };
 
  //**** added by LI Chunhua
  const double MucKalchi2() const { return myMucKalchi2[1]; };
  const double MucKalchi2( int parID ) const { return myMucKalchi2[1]; }
  const int    MucKaldof() const { return myMucKaldof[1]; };
  const int    MucKaldof( int parID ) const { return myMucKaldof[1]; };
  const double MucKaldepth() const { return myMucKaldepth[1]; };
  const double MucKaldepth( int parID ) const { return myMucKaldepth[1]; };
  const int    MucKalbrLastLayer() const { return myMucKalbrLastLayer[1]; };
  const int    MucKalbrLastLayer( int parID ) const { return myMucKalbrLastLayer[1]; };
  const int    MucKalecLastLayer() const { return myMucKalecLastLayer[1]; };
  const int    MucKalecLastLayer( int parID ) const { return myMucKalecLastLayer[1]; };
  const int    MucKalnumHits() const { return myMucKalnumHits[1]; };
  const int    MucKalnumHits( int parID ) const { return myMucKalnumHits[1]; };
  //***********************************************************
 
  // Get ExtMucHitCol
  // const ExtMucHitVec GetExtMucHitVec() const {return myExtMucHitVec;};
  // const ExtMucHitVec extMucHitVec() const {return myExtMucHitVec;};
 
  // set functions
  void SetTrackId( int trackId ) { m_trackId = trackId; }
  void SetParType( int aParType = 2 ) {
    if ( aParType >= 0 && aParType <= 4 ) myParticleType = aParType;
    else
    {
      cout << "DstExtTrack::warning: Invalid particle number: " << aParType << endl;
      myParticleType = 2;
    }
  }
 
  void SetTof1Data( Hep3Vector aPosition, Hep3Vector aMomentum, string aVolumeName,
                    int aVolumeNumber, double aTof, double aPath, HepSymMatrix aErrorMatrix,
                    double aZSigma = 0., double aTSigma = 0., double aXSigma = 0.,
                    double aYSigma = 0. );
 
  void SetTof2Data( Hep3Vector aPosition, Hep3Vector aMomentum, string aVolumeName,
                    int aVolumeNumber, double aTof, double aPath, HepSymMatrix aErrorMatrix,
                    double aZSigma = 0., double aTSigma = 0., double aXSigma = 0.,
                    double aYSigma = 0. );
 
  void SetEmcData( Hep3Vector aPosition, Hep3Vector aMomentum, string aVolumeName,
                   int aVolumeNumber, double aThetaSigma, double aPhiSigma,
                   HepSymMatrix aErrorMatrix );
 
  void SetEmcPath( double path ) { myEmcPath[myParticleType] = path; };
 
  void SetMucData( Hep3Vector aPosition, Hep3Vector aMomentum, string aVolumeName,
                   int aVolumeNumber, HepSymMatrix aErrorMatrix, double aZSigma = 0.,
                   double aTSigma = 0., double aXSigma = 0., double aYSigma = 0. );
 
  //**** added by LI Chunhua
  void SetMucKalData( double chi2, int dof, double depth, int brLastLay, int ecLastLay,
                      int nhits );
 
  // void AddExtMucHit(ExtMucHit aExtMucHit) {myExtMucHitVec.push_back(aExtMucHit);}
 
protected:
  int myParticleType; // default particle type
 
private:
  int m_trackId; // Track ID wensp Add 2005-10-19
  // Tof TrkExt data.
  //
  // Tof layer1:
  vector<Hep3Vector>   myTof1Position;   // Position when the particle enters the TOF layer1.
  vector<Hep3Vector>   myTof1Momentum;   // Momentum when the particle enters the TOF layer1.
  vector<string>       myTof1VolumeName; // Scintillator volume name
  int                  myTof1VolumeNumber[5];   // Scintillator volume number
  double               myTof1[5];               // Time of flight
  double               myTof1Path[5];           // Path of flight
  double               myTof1PosSigmaAlongZ[5]; // Sigma Z
  double               myTof1PosSigmaAlongT[5]; // Sigma along Z x R
  double               myTof1PosSigmaAlongX[5]; // Sigma X
  double               myTof1PosSigmaAlongY[5]; // Sigma Y
  vector<HepSymMatrix> myTof1ErrorMatrix;       // Error matrix 6x6 (x,p)
 
  // Tof layer2:
  vector<Hep3Vector>   myTof2Position;   // Position when the particle enters the TOF layer2.
  vector<Hep3Vector>   myTof2Momentum;   // Momentum when the particle enters the TOF layer2.
  vector<string>       myTof2VolumeName; // Scintillator volume name
  int                  myTof2VolumeNumber[5];   // Scintillator volume number
  double               myTof2[5];               // Time of flight
  double               myTof2Path[5];           // Path of flight
  double               myTof2PosSigmaAlongZ[5]; // Sigma Z
  double               myTof2PosSigmaAlongT[5]; // Sigma along Z x R
  double               myTof2PosSigmaAlongX[5]; // Sigma X
  double               myTof2PosSigmaAlongY[5]; // Sigma Y
  vector<HepSymMatrix> myTof2ErrorMatrix;       // Error matrix 6x6 (x,p)
 
  // Emc TrkExt data
  vector<Hep3Vector>   myEmcPosition;
  vector<Hep3Vector>   myEmcMomentum;
  vector<string>       myEmcVolumeName;
  int                  myEmcVolumeNumber[5];
  double               myEmcPosSigmaAlongTheta[5];
  double               myEmcPosSigmaAlongPhi[5];
  vector<HepSymMatrix> myEmcErrorMatrix;
  double               myEmcPath[5];
 
  // Muc TrkExt data
  vector<Hep3Vector>   myMucPosition;
  vector<Hep3Vector>   myMucMomentum;
  vector<string>       myMucVolumeName;
  int                  myMucVolumeNumber[5];
  double               myMucPosSigmaAlongZ[5];
  double               myMucPosSigmaAlongT[5];
  double               myMucPosSigmaAlongX[5];
  double               myMucPosSigmaAlongY[5];
  vector<HepSymMatrix> myMucErrorMatrix;
 
  //**** added by LI Chunhua
  double myMucKalchi2[5];
  int    myMucKaldof[5];
  double myMucKaldepth[5];
  int    myMucKalbrLastLayer[5];
  int    myMucKalecLastLayer[5];
  int    myMucKalnumHits[5];
  //**********************
 
  // MUC Hits collection
  // ExtMucHitVec myExtMucHitVec;
};
 
typedef ObjectVector<DstExtTrack> DstExtTrackCol;
 
#endif