Measurement.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_Measurement_H
#define TrackEvent_Measurement_H 1

// Include files
#include "Kernel/LHCbID.h"
#include "GaudiKernel/KeyedObject.h"
#include "GaudiKernel/KeyedContainer.h"


// Forward declarations

class Measurement: public KeyedObject<int>
{
public:

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

  Measurement() : m_mtype(0),
                  m_z(0.0),
                  m_measure(0.0),
                  m_errMeasure(0.0),
                  m_lhcbID() {}

  virtual ~Measurement() {}

  double errMeasure2() const;

  Type type() const;

  virtual Measurement* clone() const;

  void setType(const Type& value);

  bool checkType(const Type& value) const;

  double z() const;

  void setZ(double value);

  double measure() const;

  void setMeasure(double value);

  double errMeasure() const;

  void setErrMeasure(double value);

  const LHCbID& lhcbID() const;

  LHCbID& lhcbID();

  void setLhcbID(const LHCbID& value);

protected:

  enum mtypeBits{typeBits = 0};

  enum mtypeMasks{typeMask = 0x3FL};


  unsigned int m_mtype;      
  double   m_z;          
  double   m_measure;    
  double   m_errMeasure; 
  LHCbID   m_lhcbID;     

private:

};

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

// Including forward declarations

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

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

inline double Measurement::z() const 
{
  return m_z;
}

inline void Measurement::setZ(double value) 
{
  m_z = value;
}

inline double Measurement::measure() const 
{
  return m_measure;
}

inline void Measurement::setMeasure(double value) 
{
  m_measure = value;
}

inline double Measurement::errMeasure() const 
{
  return m_errMeasure;
}

inline void Measurement::setErrMeasure(double value) 
{
  m_errMeasure = value;
}

inline const LHCbID& Measurement::lhcbID() const 
{
  return m_lhcbID;
}

inline LHCbID& Measurement::lhcbID() 
{
  return m_lhcbID;
}

inline void Measurement::setLhcbID(const LHCbID& value) 
{
  m_lhcbID = value;
}

inline double Measurement::errMeasure2() const 
{

  return m_errMeasure*m_errMeasure;
        
}

inline Measurement::Type Measurement::type() const 
{

  return (Measurement::Type)((m_mtype & typeMask) >> typeBits);
        
}

inline Measurement* Measurement::clone() const 
{

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

// Definition of Keyed Container for Measurement
typedef KeyedContainer<Measurement, Containers::HashMap> Measurements;



#endif 

---