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 "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/KeyedContainer.h"
#include "CLHEP/Matrix/Matrix.h"


// Forward declarations

class Node: public KeyedObject<int>
{
public:

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

  ~Node();

  virtual void reset();

  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);

  double errResidual2() 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:

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

private:

};

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

// Including forward declarations

inline Node::~Node() 
{

  reset();
        
}

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 void Node::reset() 
{

  if (m_state != NULL) delete m_state;
  m_measurement = NULL;
  m_state = NULL;
  m_residual = 0.;
  m_errResidual = 0.;
        
}

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->setMeasurement(measurement());
  me->setState(state());
  me->setResidual(residual());
  me->setErrResidual(errResidual());
  return me;
        
}

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

  m_measurement = (Measurement*) &meas;
        
}

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

  if (m_state != NULL) delete m_state;
  m_state = state.clone();
        
}

inline double Node::errResidual2() const 
{

  return m_errResidual*m_errResidual;
        
}

// Definition of Keyed Container for Node
typedef KeyedContainer<Node, Containers::HashMap> Nodes;



#endif 

---