Mdc/MdcRecEvent/include/MdcRecEvent/RecMdcKalHelixSeg.h

Go to the documentation of this file.

/*
 * @class : RecMdcKalHelixSeg
 *
 * @author: wangjk
 * ********************************************************/
 
#ifndef RECMDCKALHELIXSEG_H
#define RECMDCKALHELIXSEG_H
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Vector/ThreeVector.h"
#include "EventModel/EventModel.h"
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/SmartRef.h"
#include "Identifier/Identifier.h"
#include "Identifier/MdcID.h"
 
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
typedef HepGeom::Point3D<double> HepPoint3D;
#endif
 
using namespace CLHEP;
 
extern const CLID& CLID_RecMdcKalHelixSeg;
 
class RecMdcKalTrack;
 
class RecMdcKalHelixSeg : virtual public ContainedObject {
 
public:
  virtual const CLID& clID() const { return RecMdcKalHelixSeg::classID(); }
 
  static const CLID& classID() { return CLID_RecMdcKalHelixSeg; }
  // constrcctor and destructor
  RecMdcKalHelixSeg();
  RecMdcKalHelixSeg( RecMdcKalHelixSeg& seg );
  ~RecMdcKalHelixSeg();
 
  // extractors
  int        getTrackId( void ) const { return m_trackid; }
  Identifier getMdcId( void ) const { return m_mdcid; }
  int        getFlagLR( void ) const { return m_flagLR; }
  double     getTdc( void ) const { return m_tdc; }
  double     getAdc( void ) const { return m_adc; }
  double     getZhit( void ) const { return m_zhit; }
  double     getTof( void ) const { return m_tof; }
  double     getDocaIncl( void ) const { return m_doca_incl; }
  double     getDocaExcl( void ) const { return m_doca_excl; }
  double     getDD( void ) const { return m_dd; };
  double     getEntra( void ) const { return m_entra; }
  double     getDT( void ) const { return m_dt; }
  int        getLayerId( void ) const { return m_layerId; }
 
  /// get every component of helix parameter
  double getDrIncl( void ) const { return m_helix_incl[0]; }
  double getFi0Incl( void ) const { return m_helix_incl[1]; }
  double getCpaIncl( void ) const { return m_helix_incl[2]; }
  double getDzIncl( void ) const { return m_helix_incl[3]; }
  double getTanlIncl( void ) const { return m_helix_incl[4]; }
 
  double getDrExcl( void ) const { return m_helix_excl[0]; }
  double getFi0Excl( void ) const { return m_helix_excl[1]; }
  double getCpaExcl( void ) const { return m_helix_excl[2]; }
  double getDzExcl( void ) const { return m_helix_excl[3]; }
  double getTanlExcl( void ) const { return m_helix_excl[4]; }
 
  HepVector& getHelixIncl( void ) { return m_helix_incl; }
  HepVector& getHelixExcl( void ) { return m_helix_excl; }
 
  HepSymMatrix& getErrorIncl( void ) { return m_error_incl; }
  HepSymMatrix& getErrorExcl( void ) { return m_error_excl; }
  double        getResIncl( void ) { return m_res_incl; }
  double        getResExcl( void ) { return m_res_excl; }
 
  // modifiers
  void setTrackId( int trackid ) { m_trackid = trackid; }
  void setMdcId( Identifier mdcid ) { m_mdcid = mdcid; }
  void setFlagLR( int flagLR ) { m_flagLR = flagLR; }
  void setTdc( double tdc ) { m_tdc = tdc; }
  void setAdc( double adc ) { m_adc = adc; }
  void setZhit( double zhit ) { m_zhit = zhit; }
  void setTof( double tof ) { m_tof = tof; }
  void setDocaIncl( double doca ) { m_doca_incl = doca; }
  void setDocaExcl( double doca ) { m_doca_excl = doca; }
 
  void setDD( double dd ) { m_dd = dd; }
  void setEntra( double entra ) { m_entra = entra; }
  void setDT( double dt ) { m_dt = dt; }
  void setLayerId( int layerId ) { m_layerId = layerId; }
 
  void setDrIncl( double dr ) { m_helix_incl[0] = dr; }
  void setFi0Incl( double fi0 ) { m_helix_incl[1] = fi0; }
  void setCpaIncl( double cpa ) { m_helix_incl[2] = cpa; }
  void setDzIncl( double dz ) { m_helix_incl[3] = dz; }
  void setTanlIncl( double tanl ) { m_helix_incl[4] = tanl; }
 
  void setDrExcl( double dr ) { m_helix_excl[0] = dr; }
  void setFi0Excl( double fi0 ) { m_helix_excl[1] = fi0; }
  void setCpaExcl( double cpa ) { m_helix_excl[2] = cpa; }
  void setDzExcl( double dz ) { m_helix_excl[3] = dz; }
  void setTanlExcl( double tanl ) { m_helix_excl[4] = tanl; }
 
  void setResIncl( double res ) { m_res_incl = res; }
  void setResExcl( double res ) { m_res_excl = res; }
 
  void setHelixIncl( const HepVector& helix ) { m_helix_incl = helix; }
  void setErrorIncl( const HepSymMatrix& error ) { m_error_incl = error; }
  void setHelixExcl( const HepVector& helix ) { m_helix_excl = helix; }
  void setErrorExcl( const HepSymMatrix& error ) { m_error_excl = error; }
 
  void setHelixIncl( double* helix ) {
    for ( int i = 0; i < 5; i++ ) { m_helix_incl[i] = helix[i]; }
  }
  void setErrorIncl( double* error ) {
    int k = 0;
    for ( int i = 0; i < 5; i++ )
    {
      for ( int j = 0; j <= i; j++, k++ )
      {
        m_error_incl[i][j] = error[k];
        m_error_incl[j][i] = error[k];
      }
    }
  }
 
  void setHelixExcl( double* helix ) {
    for ( int i = 0; i < 5; i++ ) { m_helix_excl[i] = helix[i]; }
  }
 
  void setErrorExcl( double* error ) {
    int k = 0;
    for ( int i = 0; i < 5; i++ )
    {
      for ( int j = 0; j <= i; j++, k++ )
      {
        m_error_excl[i][j] = error[k];
        m_error_excl[j][i] = error[k];
      }
    }
  }
 
private:
  int        m_trackid{ 0 };
  Identifier m_mdcid;
  int        m_flagLR{ 0 };
  double     m_tdc{ 0.0 };
  double     m_adc{ 0.0 };
  double     m_zhit{ 0.0 };
  double     m_tof{ 0.0 };
  double     m_doca_incl{ 0.0 };
  double     m_doca_excl{ 0.0 };
  double     m_dd{ 0.0 };
  double     m_entra{ 0.0 };
  double     m_dt{ 0.0 };
  double     m_res_incl{ 0.0 };
  double     m_res_excl{ 0.0 };
  HepVector  m_helix_incl; // 5 track parameters
  HepVector  m_helix_excl; // 5 track parameters
 
  HepSymMatrix m_error_incl; // error matrix
  HepSymMatrix m_error_excl; // error matrix
 
  int m_layerId{ 0 };
};
typedef ObjectVector<RecMdcKalHelixSeg> RecMdcKalHelixSegCol;
 
#endif