Node.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 TrackEvent_Node_H
#define TrackEvent_Node_H 1

// Include files
#include "Event/State.h"
#include "Event/Measurement.h"
#include "CLHEP/Matrix/Matrix.h"


// Forward declarations

class Node
{
public:

  enum Type{ Muon,
             OT,
             ST,
             TT,
             VeloR,
             VeloPhi };

  Node() : m_flags(0),
           m_measurement(),
           m_state(),
           m_residual(0.0),
           m_errResidual(0.0),
           m_projectionMatrix() {}

  ~Node();

  double chi2() const;

  Measurement & measurement();

  Measurement & measurement() const;

  State & state();

  State & state() const;

  virtual Node* clone() const;

  void setMeasurement(const Measurement& meas);

  void setState(const State& state);

  void setType(const Type& value);

  bool checkType(const Type& value) const;

  double residual() const;

  void setResidual(double value);

  double errResidual() const;

  void setErrResidual(double value);

  const HepMatrix& projectionMatrix() const;

  HepMatrix& projectionMatrix();

  void setProjectionMatrix(const HepMatrix& value);

protected:

  enum flagsBits{typeBits = 0};

  enum flagsMasks{typeMask = 0x3FL};


  unsigned int m_flags; 

private:

  Measurement* m_measurement;      
  State*       m_state;            
  double       m_residual;         
  double       m_errResidual;      
  HepMatrix    m_projectionMatrix; 

};

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

// Including forward declarations

inline Node::~Node() 
{

  delete m_measurement;
  delete m_state;
        
}

inline void Node::setType(const Type& value)
{
  unsigned int val = (unsigned int)value;
  m_flags &= ~typeMask;
  m_flags |= ((((unsigned int)val) << typeBits) & typeMask);
}

inline bool Node::checkType(const Type& value) const
{
  unsigned int val = (unsigned int)value;
  return 0 != ( m_flags & typeMask & ( val << typeBits ));
}

inline double Node::residual() const 
{
  return m_residual;
}

inline void Node::setResidual(double value) 
{
  m_residual = value;
}

inline double Node::errResidual() const 
{
  return m_errResidual;
}

inline void Node::setErrResidual(double value) 
{
  m_errResidual = value;
}

inline const HepMatrix& Node::projectionMatrix() const 
{
  return m_projectionMatrix;
}

inline HepMatrix& Node::projectionMatrix() 
{
  return m_projectionMatrix;
}

inline void Node::setProjectionMatrix(const HepMatrix& value) 
{
  m_projectionMatrix = value;
}

inline double Node::chi2() const 
{

  return (m_errResidual >0 ? m_residual/m_errResidual: 0);
        
}

inline Measurement & Node::measurement() 
{

  return *m_measurement;
        
}

inline Measurement & Node::measurement() const 
{

  return *m_measurement;
        
}

inline State & Node::state() 
{

  return *m_state;
        
}

inline State & Node::state() const 
{

  return *m_state;
        
}

inline Node* Node::clone() const 
{

  Node* me = new Node(); *me = *this; return me;
        
}

inline void Node::setMeasurement(const Measurement& meas) 
{

  m_measurement = meas.clone();
        
}

inline void Node::setState(const State& state) 
{

  m_state = state.clone();
        
}


#endif 

---