---

TrTrack.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************



#ifndef TrEvent_TrTrack_H
#define TrEvent_TrTrack_H 1

// Include files
#include <vector>
#include "Kernel/CLHEPStreams.h"
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/StreamBuffer.h"
#include "Event/TrNode.h"
#include "Event/TrState.h"


// Class ID definition
  static const CLID& CLID_TrTrack = 10003;

class TrTrack: public KeyedObject<int>
{

public: 

  enum TrackType {Velotrack,Backward,Long,Upstream,Downstream,Ttrack};   
  enum HistoryFlag {LongTrack,Seeding,TrKshort,TrMatching,VeloTrack,VeloTT};   

  TrTrack(const TrTrack& track);

  TrTrack() 
    : m_states(),
    m_nodes(),
    m_chi2(0.0),
    m_ndof(0),
    m_charge(0.0),
    m_errorFlag(0),
    m_type(0) {}

  virtual ~TrTrack() {}

  virtual const CLID& clID() const; 
  static const CLID& classID(); 

  virtual bool producedByAlgo(const TrTrack::HistoryFlag& flag);

  virtual unsigned int nStates() const;

  virtual TrState* closestState(double z) const;

  virtual unsigned int nNodes() const;

  virtual const std::vector<TrMeasurement*> measurements() const;

  virtual void setMeasurements(const const& std::vector<TrState*>);

  virtual double chi2PerDoF() const;

  virtual double chi2() const;

  virtual void setChi2(double value);

  virtual unsigned int nDoF() const;

  virtual void setNDoF(unsigned int value);

  virtual int errorFlag() const;

  virtual void setErrorFlag(int value);

  virtual void reset();

  virtual void clone(TrTrack* track);

  const std::vector<TrState*>& states() const; 

  std::vector<TrState*>& states();

  void setStates(const std::vector<TrState*>& value);

  const std::vector<TrNode*>& nodes() const; 

  std::vector<TrNode*>& nodes();

  void setNodes(const std::vector<TrNode*>& value);

  double charge() const; 

  void setCharge(double value);

  int type() const; 

  void setType(int value);

  virtual StreamBuffer& serialize(StreamBuffer& s) const;

  virtual StreamBuffer& serialize(StreamBuffer& s);

  virtual std::ostream& fillStream(std::ostream& s) const;

protected: 

private: 

  std::vector<TrState*> m_states;    
  std::vector<TrNode*>  m_nodes;     
  double                m_chi2;      
  int                   m_ndof;      
  double                m_charge;    
  int                   m_errorFlag; 
  int                   m_type;      

};

// -----------------------------------------------------------------------------
//   end of class
// -----------------------------------------------------------------------------


inline const CLID& TrTrack::clID() const 
{
  return TrTrack::classID();
}

inline const CLID& TrTrack::classID()
{
  return CLID_TrTrack;
}

inline double TrTrack::chi2PerDoF() const
{
   
   return ( ( m_ndof > 0 ) ? m_chi2/double(m_ndof) : 0. );
        
}

inline void TrTrack::reset()
{
   
   m_closestState.reset();
   m_states.clear();
   m_nodes.clear();
   m_chi2      = 0;
   m_ndof      = 0;
   m_charge    = 0;
   m_errorFlag = 0;
   m_type      = 0;
        
}

inline const std::vector<TrState*>& TrTrack::states() const 
{
  return m_states;
}

inline std::vector<TrState*>& TrTrack::states()
{
  return m_states;
}

inline void TrTrack::setStates(const std::vector<TrState*>& value)
{
  m_states = value; 
}

inline const std::vector<TrNode*>& TrTrack::nodes() const 
{
  return m_nodes;
}

inline std::vector<TrNode*>& TrTrack::nodes()
{
  return m_nodes;
}

inline void TrTrack::setNodes(const std::vector<TrNode*>& value)
{
  m_nodes = value; 
}

inline double TrTrack::charge() const 
{
  return m_charge;
}

inline void TrTrack::setCharge(double value)
{
  m_charge = value; 
}

inline int TrTrack::type() const 
{
  return m_type;
}

inline void TrTrack::setType(int value)
{
  m_type = value; 
}

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s) const 
{
  KeyedObject<int>::serialize(s);
  s << m_states
    << m_nodes
    << (float)m_chi2
    << m_ndof
    << (float)m_charge
    << m_errorFlag
    << m_type;
  return s;
}

inline StreamBuffer& TrTrack::serialize(StreamBuffer& s)
{
  float l_chi2, l_charge;
  KeyedObject<int>::serialize(s);
  s >> m_states
    >> m_nodes
    >> l_chi2
    >> m_ndof
    >> l_charge
    >> m_errorFlag
    >> m_type;
  m_chi2 = l_chi2;
  m_charge = l_charge;
  return s;
}

inline std::ostream& TrTrack::fillStream(std::ostream& s) const
{
  s << "{ "
    << " states:\t" << m_states << std::endl
    << "   nodes:\t" << m_nodes << std::endl
    << "   chi2:\t" << (float)m_chi2 << std::endl
    << "   ndof:\t" << m_ndof << std::endl
    << "   charge:\t" << (float)m_charge << std::endl
    << "   errorFlag:\t" << m_errorFlag << std::endl
    << "   type:\t" << m_type << " } ";
  return s;
}

//Definition of keyed container for TrTrack
typedef KeyedContainer<TrTrack, Containers::HashMap> TrTracks;

#endif   

---