Refs #2245: Split off TofEvent classes into Events.h and .cpp. Renamed their test.

Code/Mantid/Framework/DataObjects/CMakeLists.txt

 set ( SRC_FILES src/AbsManagedWorkspace2D.cpp
                 src/CompressedWorkspace2D.cpp
+		src/Events.cpp
 		src/EventList.cpp
 		src/EventWorkspace.cpp
 		src/EventWorkspaceHelpers.cpp
@@ -14,6 +15,7 @@ set ( SRC_FILES src/AbsManagedWorkspace2D.cpp
 
 set ( INC_FILES inc/MantidDataObjects/AbsManagedWorkspace2D.h
                 inc/MantidDataObjects/CompressedWorkspace2D.h
+		inc/MantidDataObjects/Events.h
 		inc/MantidDataObjects/EventList.h
 		inc/MantidDataObjects/EventWorkspace.h
 		inc/MantidDataObjects/EventWorkspaceHelpers.h
@@ -29,7 +31,7 @@ set ( INC_FILES inc/MantidDataObjects/AbsManagedWorkspace2D.h
 
 set ( TEST_FILES test/CompressedWorkspace2DTest.h
                  test/EventListTest.h
-                 test/TofEventTest.h
+                 test/EventsTest.h
                  test/WeightedEventTest.h
 		 test/EventWorkspaceTest.h
 		 test/Histogram1DTest.h

Code/Mantid/Framework/DataObjects/inc/MantidDataObjects/EventList.h

@@ -12,6 +12,7 @@
 #include "MantidKernel/System.h"
 #include "MantidKernel/DateAndTime.h"
 #include "MantidKernel/TimeSplitter.h"
+#include "MantidDataObjects/Events.h"
 #include <set>
 
 namespace Mantid
@@ -22,137 +23,6 @@ namespace DataObjects
 
 
 
-//==========================================================================================
-/** Info about a single neutron detection event:
- *
- *  - the time of flight of the neutron (can be converted to other units)
- *  - the absolute time of the pulse at which it was produced
- */
-class DLLExport TofEvent {
-
-  /// EventList has the right to mess with TofEvent.
-  friend class EventList;
-  friend class WeightedEvent;
-  friend class tofGreaterOrEqual;
-  friend class tofGreater;
-
-protected:
-  /** The units of the time of flight index in nanoseconds. This is relative to the
-   * start of the pulse (stored in pulse_time.
-   * EXCEPT: After AlignDetectors is run, this is converted to dSpacing, in Angstroms^-1
-   * @return a double
-   * */
-  double m_tof;
-
-  /**
-   * The absolute time of the start of the pulse that generated this event.
-   * This is saved as the number of ticks (1 nanosecond if boost is compiled
-   * for nanoseconds) since a specified epoch: we use the GPS epoch of Jan 1, 1990.
-   *
-   * 64 bits gives 1 ns resolution up to +- 292 years around 1990. Should be enough.
-   * @return a DateAndTime
-   */
-  Mantid::Kernel::DateAndTime m_pulsetime;
-
-public:
-  /// Constructor, specifying the time of flight and the frame id
-  TofEvent(double tof, const Mantid::Kernel::DateAndTime pulsetime);
-
-  /// Constructor, copy from another TofEvent object
-  TofEvent(const TofEvent&);
-
-  /// Empty constructor
-  TofEvent();
-
-  /// Destructor
-  ~TofEvent();
-
-  /// Copy from another TofEvent object
-  TofEvent& operator=(const TofEvent&rhs);
-
-  double operator()() const;
-  bool operator==(const TofEvent & rhs) const;
-  bool operator<(const TofEvent & rhs) const;
-  bool operator<(const double rhs_tof) const;
-  bool operator>(const TofEvent & rhs) const;
-
-
-  /// Return the time of flight, as a double, in nanoseconds.
-  double tof() const;
-
-  /// Return the frame id
-  Mantid::Kernel::DateAndTime pulseTime() const;
-
-  /// Output a string representation of the event to a stream
-  friend std::ostream& operator<<(std::ostream &os, const TofEvent &event);
-};
-
-
-
-
-//==========================================================================================
-/** Info about a single neutron detection event, including a weight and error value:
- *
- *  - the time of flight of the neutron (can be converted to other units)
- *  - the absolute time of the pulse at which it was produced
- *  - weight of the neutron (float, can be
- */
-class DLLExport WeightedEvent : public TofEvent {
-
-  /// EventList has the right to mess with WeightedEvent.
-  friend class EventList;
-  friend class tofGreaterOrEqual;
-  friend class tofGreater;
-
-private:
-
-  /// The weight of this neutron.
-  float m_weight;
-
-  /// The SQUARE of the error that this neutron contributes.
-  float m_errorSquared;
-
-public:
-
-  /// Constructor, full
-  WeightedEvent(double time_of_flight, const Mantid::Kernel::DateAndTime pulsetime, float weight, float errorSquared);
-
-  WeightedEvent(const TofEvent&, float weight, float errorSquared);
-
-  WeightedEvent(const WeightedEvent&);
-
-  WeightedEvent(const TofEvent&);
-
-  WeightedEvent();
-
-  ~WeightedEvent();
-
-  /// Copy from another WeightedEvent object
-  WeightedEvent& operator=(const WeightedEvent & rhs);
-
-  bool operator==(const WeightedEvent & other) const;
-
-  /// Return the weight of the neutron, as a double (it is saved as a float).
-  double weight() const;
-
-  /// Return the error of the neutron, as a double (it is saved as a float).
-  double error() const;
-
-  /// Return the squared error of the neutron, as a double
-  double errorSquared() const;
-
-  /// Output a string representation of the event to a stream
-  friend std::ostream& operator<<(std::ostream &os, const WeightedEvent &event);
-
-
-};
-
-
-
-
-
-
-
 
 /// How the event list is sorted.
 enum EventSortType {UNSORTED, TOF_SORT, PULSETIME_SORT};

Code/Mantid/Framework/DataObjects/inc/MantidDataObjects/Events.h

+#ifndef MANTID_DATAOBJECTS_EVENTS_H_
+#define MANTID_DATAOBJECTS_EVENTS_H_
+
+#ifdef _WIN32 /* _WIN32 */
+#include <time.h>
+#endif
+#include <cstddef>
+#include <iostream>
+#include <vector>
+#include "MantidAPI/MatrixWorkspace.h" // get MantidVec declaration
+#include "MantidKernel/cow_ptr.h"
+#include "MantidKernel/System.h"
+#include "MantidKernel/DateAndTime.h"
+#include "MantidKernel/TimeSplitter.h"
+#include <set>
+
+namespace Mantid
+{
+namespace DataObjects
+{
+
+
+
+//==========================================================================================
+/** Info about a single neutron detection event:
+ *
+ *  - the time of flight of the neutron (can be converted to other units)
+ *  - the absolute time of the pulse at which it was produced
+ */
+class DLLExport TofEvent {
+
+  /// EventList has the right to mess with TofEvent.
+  friend class EventList;
+  friend class WeightedEvent;
+  friend class tofGreaterOrEqual;
+  friend class tofGreater;
+
+protected:
+  /** The units of the time of flight index in nanoseconds. This is relative to the
+   * start of the pulse (stored in pulse_time.
+   * EXCEPT: After AlignDetectors is run, this is converted to dSpacing, in Angstroms^-1
+   * @return a double
+   * */
+  double m_tof;
+
+  /**
+   * The absolute time of the start of the pulse that generated this event.
+   * This is saved as the number of ticks (1 nanosecond if boost is compiled
+   * for nanoseconds) since a specified epoch: we use the GPS epoch of Jan 1, 1990.
+   *
+   * 64 bits gives 1 ns resolution up to +- 292 years around 1990. Should be enough.
+   * @return a DateAndTime
+   */
+  Mantid::Kernel::DateAndTime m_pulsetime;
+
+public:
+  /// Constructor, specifying the time of flight and the frame id
+  TofEvent(double tof, const Mantid::Kernel::DateAndTime pulsetime);
+
+  /// Constructor, copy from another TofEvent object
+  TofEvent(const TofEvent&);
+
+  /// Empty constructor
+  TofEvent();
+
+  /// Destructor
+  ~TofEvent();
+
+  /// Copy from another TofEvent object
+  TofEvent& operator=(const TofEvent&rhs);
+
+  double operator()() const;
+  bool operator==(const TofEvent & rhs) const;
+  bool operator<(const TofEvent & rhs) const;
+  bool operator<(const double rhs_tof) const;
+  bool operator>(const TofEvent & rhs) const;
+
+
+  /// Return the time of flight, as a double, in nanoseconds.
+  double tof() const;
+
+  /// Return the frame id
+  Mantid::Kernel::DateAndTime pulseTime() const;
+
+  /// Output a string representation of the event to a stream
+  friend std::ostream& operator<<(std::ostream &os, const TofEvent &event);
+};
+
+
+
+
+//==========================================================================================
+/** Info about a single neutron detection event, including a weight and error value:
+ *
+ *  - the time of flight of the neutron (can be converted to other units)
+ *  - the absolute time of the pulse at which it was produced
+ *  - weight of the neutron (float, can be
+ */
+class DLLExport WeightedEvent : public TofEvent {
+
+  /// EventList has the right to mess with WeightedEvent.
+  friend class EventList;
+  friend class tofGreaterOrEqual;
+  friend class tofGreater;
+
+private:
+
+  /// The weight of this neutron.
+  float m_weight;
+
+  /// The SQUARE of the error that this neutron contributes.
+  float m_errorSquared;
+
+public:
+
+  /// Constructor, full
+  WeightedEvent(double time_of_flight, const Mantid::Kernel::DateAndTime pulsetime, float weight, float errorSquared);
+
+  WeightedEvent(const TofEvent&, float weight, float errorSquared);
+
+  WeightedEvent(const WeightedEvent&);
+
+  WeightedEvent(const TofEvent&);
+
+  WeightedEvent();
+
+  ~WeightedEvent();
+
+  /// Copy from another WeightedEvent object
+  WeightedEvent& operator=(const WeightedEvent & rhs);
+
+  bool operator==(const WeightedEvent & other) const;
+
+  /// Return the weight of the neutron, as a double (it is saved as a float).
+  double weight() const;
+
+  /// Return the error of the neutron, as a double (it is saved as a float).
+  double error() const;
+
+  /// Return the squared error of the neutron, as a double
+  double errorSquared() const;
+
+  /// Output a string representation of the event to a stream
+  friend std::ostream& operator<<(std::ostream &os, const WeightedEvent &event);
+
+
+};
+
+
+
+
+} // DataObjects
+} // Mantid
+#endif /// MANTID_DATAOBJECTS_EVENTS_H_

Code/Mantid/Framework/DataObjects/src/EventList.cpp

@@ -17,231 +17,6 @@ namespace DataObjects
 using Kernel::Exception::NotImplementedError;
 using Kernel::DateAndTime;
 
-//==========================================================================
-/// --------------------- TofEvent stuff ----------------------------------
-//==========================================================================
-  /** Constructor, specifying the time of flight and the frame id
-   * @param tof time of flight, in microseconds
-   * @param pulsetime absolute pulse time of the neutron.
-   */
-  TofEvent::TofEvent(const double tof, const DateAndTime pulsetime) :
-              m_tof(tof), m_pulsetime(pulsetime)
-  {
-  }
-
-  /** Constructor, copy from another TofEvent object
-   * @param rhs Other TofEvent to copy.
-   */
-  TofEvent::TofEvent(const TofEvent& rhs) :
-      m_tof(rhs.m_tof), m_pulsetime(rhs.m_pulsetime)
-  {
-  }
-
-  /// Empty constructor
-  TofEvent::TofEvent() :
-            m_tof(0), m_pulsetime(0)
-  {
-  }
-
-  /// Destructor
-  TofEvent::~TofEvent()
-  {
-  }
-
-  /** () operator: return the tof (X value) of the event.
-   * This is useful for std operations like comparisons
-   * and std::lower_bound
-   * @return :: double, the tof (X value) of the event.
-   */
-  double TofEvent::operator()() const
-  {
-    return this->m_tof;
-  }
-
-
-  /** Copy from another TofEvent object
-   * @param rhs Other TofEvent to copy.
-   * @return reference to this.
-   */
-  TofEvent& TofEvent::operator=(const TofEvent& rhs)
-  {
-    this->m_tof = rhs.m_tof;
-    this->m_pulsetime = rhs.m_pulsetime;
-    return *this;
-  }
-
-  /** Comparison operator.
-   * @param rhs: the other TofEvent to compare.
-   * @return true if the TofEvent's are identical.*/
-  bool TofEvent::operator==(const TofEvent & rhs) const
-  {
-    return  (this->m_tof == rhs.m_tof) &&
-            (this->m_pulsetime == rhs.m_pulsetime);
-  }
-
-  /** < comparison operator, using the TOF to do the comparison.
-   * @param rhs: the other TofEvent to compare.
-   * @return true if this->m_tof < rhs.m_tof*/
-  bool TofEvent::operator<(const TofEvent & rhs) const
-  {
-    return (this->m_tof < rhs.m_tof);
-  }
-
-  /** < comparison operator, using the TOF to do the comparison.
-   * @param rhs: the other TofEvent to compare.
-   * @return true if this->m_tof < rhs.m_tof*/
-  bool TofEvent::operator>(const TofEvent & rhs) const
-  {
-    return (this->m_tof > rhs.m_tof);
-  }
-
-  /** < comparison operator, using the TOF to do the comparison.
-   * @param rhs_tof: the other time of flight to compare.
-   * @return true if this->m_tof < rhs.m_tof*/
-  bool TofEvent::operator<(const double rhs_tof) const
-  {
-    return (this->m_tof < rhs_tof);
-  }
-
-  /// Return the time of flight, as a double, in nanoseconds.
-  double TofEvent::tof() const
-  {
-	  return this->m_tof;
-  }
-
-  /// Return the frame id
-  DateAndTime TofEvent::pulseTime() const
-  {
-	  return this->m_pulsetime;
-  }
-
-  /** Output a string representation of the event to a stream
-   * @param os Stream
-   * @param event TofEvent to output to the stream
-   */
-  ostream& operator<<(ostream &os, const TofEvent &event)
-  {
-    os << event.m_tof << "," << event.m_pulsetime.to_simple_string();
-    return os;
-  }
-
-
-
-
-
-  //==========================================================================
-  /// --------------------- WeightedEvent stuff ----------------------------------
-  //==========================================================================
-
-  /** Constructor, full:
-   * @param tof: tof in microseconds.
-   * @param pulsetime: absolute pulse time
-   * @param weight: weight of this neutron event.
-   * @param errorSquared: the square of the error on the event
-   */
-  WeightedEvent::WeightedEvent(double tof, const Mantid::Kernel::DateAndTime pulsetime, float weight, float errorSquared)
-  : TofEvent(tof, pulsetime), m_weight(weight), m_errorSquared(errorSquared)
-  {
-  }
-
-  /** Constructor, copy from a TofEvent object but add weights
-   * @param rhs: TofEvent to copy into this.
-   * @param weight: weight of this neutron event.
-   * @param errorSquared: the square of the error on the event
-  */
-  WeightedEvent::WeightedEvent(const TofEvent& rhs, float weight, float errorSquared)
-  : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(weight), m_errorSquared(errorSquared)
-  {
-  }
-
-  /** Constructor, copy from another WeightedEvent object
-   * @param rhs: source WeightedEvent
-   */
-  WeightedEvent::WeightedEvent(const WeightedEvent& rhs)
-  : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(rhs.m_weight), m_errorSquared(rhs.m_errorSquared)
-  {
-  }
-
-  /** Constructor, copy from another WeightedEvent object
-   * @param rhs: source TofEvent
-   */
-  WeightedEvent::WeightedEvent(const TofEvent& rhs)
-  : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(1.0), m_errorSquared(1.0)
-  {
-  }
-
-  /// Empty constructor
-  WeightedEvent::WeightedEvent()
-  : TofEvent(), m_weight(1.0), m_errorSquared(1.0)
-  {
-  }
-
-  /// Destructor
-  WeightedEvent::~WeightedEvent()
-  {
-  }
-
-
-  /// Copy from another WeightedEvent object
-  WeightedEvent& WeightedEvent::operator=(const WeightedEvent & rhs)
-  {
-    this->m_tof = rhs.m_tof;
-    this->m_pulsetime = rhs.m_pulsetime;
-    this->m_weight = rhs.m_weight;
-    this->m_errorSquared = rhs.m_errorSquared;
-    return *this;
-  }
-
-  /** Comparison operator.
-   * @param rhs event to which we are comparing.
-   * @return true if all elements of this event are identical
-   *  */
-  bool WeightedEvent::operator==(const WeightedEvent & rhs) const
-  {
-    return  (this->m_tof == rhs.m_tof) &&
-            (this->m_pulsetime == rhs.m_pulsetime) &&
-            (this->m_weight == rhs.m_weight) &&
-            (this->m_errorSquared == rhs.m_errorSquared);
-  }
-
-
-  /// Return the weight of the neutron, as a double (it is saved as a float).
-  double WeightedEvent::weight() const
-  {
-    return m_weight;
-  }
-
-  /** @return the error of the neutron, as a double (it is saved as a float).
-   * Note: this returns the actual error; the value is saved
-   * internally as the SQUARED error, so this function calculates sqrt().
-   * For more speed, use errorSquared().
-   *
-   */
-  double WeightedEvent::error() const
-  {
-    return std::sqrt( double(m_errorSquared) );
-  }
-
-  /** @return the square of the error for this event.
-   * This is how the error is saved internally, so this is faster than error()
-   */
-  double WeightedEvent::errorSquared() const
-  {
-    return m_errorSquared;
-  }
-
-
-  /** Output a string representation of the event to a stream
-   * @param os Stream
-   * @param event WeightedEvent to output to the stream
-   */
-  ostream& operator<<(ostream &os, const WeightedEvent &event)
-  {
-    os << event.m_tof << "," << event.m_pulsetime.to_simple_string() << " (W" << event.m_weight << " +- " << event.error() << ")";
-    return os;
-  }
-
-
 
   //==========================================================================
   /// --------------------- TofEvent Comparators ----------------------------------

Code/Mantid/Framework/DataObjects/src/Events.cpp

+#include <stdexcept>
+#include "MantidDataObjects/EventList.h"
+#include "MantidKernel/Exception.h"
+#include "MantidKernel/DateAndTime.h"
+#include <functional>
+#include <math.h>
+
+using std::ostream;
+using std::runtime_error;
+using std::size_t;
+using std::vector;
+
+namespace Mantid
+{
+namespace DataObjects
+{
+using Kernel::Exception::NotImplementedError;
+using Kernel::DateAndTime;
+
+//==========================================================================
+/// --------------------- TofEvent stuff ----------------------------------
+//==========================================================================
+  /** Constructor, specifying the time of flight and the frame id
+   * @param tof time of flight, in microseconds
+   * @param pulsetime absolute pulse time of the neutron.
+   */
+  TofEvent::TofEvent(const double tof, const DateAndTime pulsetime) :
+              m_tof(tof), m_pulsetime(pulsetime)
+  {
+  }
+
+  /** Constructor, copy from another TofEvent object
+   * @param rhs Other TofEvent to copy.
+   */
+  TofEvent::TofEvent(const TofEvent& rhs) :
+      m_tof(rhs.m_tof), m_pulsetime(rhs.m_pulsetime)
+  {
+  }
+
+  /// Empty constructor
+  TofEvent::TofEvent() :
+            m_tof(0), m_pulsetime(0)
+  {
+  }
+
+  /// Destructor
+  TofEvent::~TofEvent()
+  {
+  }
+
+  /** () operator: return the tof (X value) of the event.
+   * This is useful for std operations like comparisons
+   * and std::lower_bound
+   * @return :: double, the tof (X value) of the event.
+   */
+  double TofEvent::operator()() const
+  {
+    return this->m_tof;
+  }
+
+
+  /** Copy from another TofEvent object
+   * @param rhs Other TofEvent to copy.
+   * @return reference to this.
+   */
+  TofEvent& TofEvent::operator=(const TofEvent& rhs)
+  {
+    this->m_tof = rhs.m_tof;
+    this->m_pulsetime = rhs.m_pulsetime;
+    return *this;
+  }
+
+  /** Comparison operator.
+   * @param rhs: the other TofEvent to compare.
+   * @return true if the TofEvent's are identical.*/
+  bool TofEvent::operator==(const TofEvent & rhs) const
+  {
+    return  (this->m_tof == rhs.m_tof) &&
+            (this->m_pulsetime == rhs.m_pulsetime);
+  }
+
+  /** < comparison operator, using the TOF to do the comparison.
+   * @param rhs: the other TofEvent to compare.
+   * @return true if this->m_tof < rhs.m_tof*/
+  bool TofEvent::operator<(const TofEvent & rhs) const
+  {
+    return (this->m_tof < rhs.m_tof);
+  }
+
+  /** < comparison operator, using the TOF to do the comparison.
+   * @param rhs: the other TofEvent to compare.
+   * @return true if this->m_tof < rhs.m_tof*/
+  bool TofEvent::operator>(const TofEvent & rhs) const
+  {
+    return (this->m_tof > rhs.m_tof);
+  }
+
+  /** < comparison operator, using the TOF to do the comparison.
+   * @param rhs_tof: the other time of flight to compare.
+   * @return true if this->m_tof < rhs.m_tof*/
+  bool TofEvent::operator<(const double rhs_tof) const
+  {
+    return (this->m_tof < rhs_tof);
+  }
+
+  /// Return the time of flight, as a double, in nanoseconds.
+  double TofEvent::tof() const
+  {
+    return this->m_tof;
+  }
+
+  /// Return the frame id
+  DateAndTime TofEvent::pulseTime() const
+  {
+    return this->m_pulsetime;
+  }
+
+  /** Output a string representation of the event to a stream
+   * @param os Stream
+   * @param event TofEvent to output to the stream
+   */
+  ostream& operator<<(ostream &os, const TofEvent &event)
+  {
+    os << event.m_tof << "," << event.m_pulsetime.to_simple_string();
+    return os;
+  }
+
+
+
+
+
+  //==========================================================================
+  /// --------------------- WeightedEvent stuff ----------------------------------
+  //==========================================================================
+
+  /** Constructor, full:
+   * @param tof: tof in microseconds.
+   * @param pulsetime: absolute pulse time
+   * @param weight: weight of this neutron event.
+   * @param errorSquared: the square of the error on the event
+   */
+  WeightedEvent::WeightedEvent(double tof, const Mantid::Kernel::DateAndTime pulsetime, float weight, float errorSquared)
+  : TofEvent(tof, pulsetime), m_weight(weight), m_errorSquared(errorSquared)
+  {
+  }
+
+  /** Constructor, copy from a TofEvent object but add weights
+   * @param rhs: TofEvent to copy into this.
+   * @param weight: weight of this neutron event.
+   * @param errorSquared: the square of the error on the event
+  */
+  WeightedEvent::WeightedEvent(const TofEvent& rhs, float weight, float errorSquared)
+  : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(weight), m_errorSquared(errorSquared)
+  {
+  }
+
+  /** Constructor, copy from another WeightedEvent object
+   * @param rhs: source WeightedEvent
+   */
+  WeightedEvent::WeightedEvent(const WeightedEvent& rhs)
+  : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(rhs.m_weight), m_errorSquared(rhs.m_errorSquared)
+  {
+  }
+
+  /** Constructor, copy from another WeightedEvent object
+   * @param rhs: source TofEvent
+   */
+  WeightedEvent::WeightedEvent(const TofEvent& rhs)
+  : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(1.0), m_errorSquared(1.0)
+  {
+  }
+
+  /// Empty constructor
+  WeightedEvent::WeightedEvent()
+  : TofEvent(), m_weight(1.0), m_errorSquared(1.0)
+  {
+  }
+
+  /// Destructor
+  WeightedEvent::~WeightedEvent()
+  {
+  }
+
+
+  /// Copy from another WeightedEvent object
+  WeightedEvent& WeightedEvent::operator=(const WeightedEvent & rhs)
+  {
+    this->m_tof = rhs.m_tof;
+    this->m_pulsetime = rhs.m_pulsetime;
+    this->m_weight = rhs.m_weight;
+    this->m_errorSquared = rhs.m_errorSquared;
+    return *this;
+  }
+
+  /** Comparison operator.
+   * @param rhs event to which we are comparing.
+   * @return true if all elements of this event are identical
+   *  */
+  bool WeightedEvent::operator==(const WeightedEvent & rhs) const
+  {
+    return  (this->m_tof == rhs.m_tof) &&
+            (this->m_pulsetime == rhs.m_pulsetime) &&
+            (this->m_weight == rhs.m_weight) &&
+            (this->m_errorSquared == rhs.m_errorSquared);
+  }
+
+
+  /// Return the weight of the neutron, as a double (it is saved as a float).
+  double WeightedEvent::weight() const
+  {
+    return m_weight;
+  }
+
+  /** @return the error of the neutron, as a double (it is saved as a float).
+   * Note: this returns the actual error; the value is saved
+   * internally as the SQUARED error, so this function calculates sqrt().
+   * For more speed, use errorSquared().
+   *
+   */
+  double WeightedEvent::error() const
+  {
+    return std::sqrt( double(m_errorSquared) );
+  }
+
+  /** @return the square of the error for this event.
+   * This is how the error is saved internally, so this is faster than error()
+   */
+  double WeightedEvent::errorSquared() const
+  {
+    return m_errorSquared;
+  }
+
+
+  /** Output a string representation of the event to a stream
+   * @param os Stream
+   * @param event WeightedEvent to output to the stream
+   */
+  ostream& operator<<(ostream &os, const WeightedEvent &event)
+  {
+    os << event.m_tof << "," << event.m_pulsetime.to_simple_string() << " (W" << event.m_weight << " +- " << event.error() << ")";
+    return os;
+  }
+
+
+} // DataObjects
+} // Mantid
+