Events.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#ifdef _WIN32 /* _WIN32 */
#include <time.h>
#endif
#include "MantidAPI/MatrixWorkspace_fwd.h" // get MantidVec declaration
#include "MantidDataObjects/DllConfig.h"
#include "MantidKernel/SplittingInterval.h"
#include "MantidKernel/cow_ptr.h"
#include "MantidTypes/Event/TofEvent.h"
#include <cstddef>
#include <iosfwd>
#include <set>
#include <vector>
 
namespace Mantid {
// Forward declaration needed while this needs to be a friend of TofEvent (see
// below)
namespace DataHandling {
class LoadEventNexus;
}
 
namespace DataObjects {
//==========================================================================================
#pragma pack(push, 4) // Ensure the structure is no larger than it needs to
class MANTID_DATAOBJECTS_DLL WeightedEvent : public Types::Event::TofEvent {
 
  friend class EventList;
  friend class WeightedEventNoTime;
  friend class tofGreaterOrEqual;
  friend class tofGreater;
 
public:
  float m_weight;
 
  float m_errorSquared;
 
public:
  WeightedEvent(double time_of_flight);
 
  WeightedEvent(double tof, const Mantid::Types::Core::DateAndTime pulsetime, double weight, double errorSquared);
  WeightedEvent(double tof, const Mantid::Types::Core::DateAndTime pulsetime, float weight, float errorSquared);
 
  WeightedEvent(const TofEvent &, double weight, double errorSquared);
  WeightedEvent(const TofEvent &, float weight, float errorSquared);
 
  WeightedEvent(const TofEvent &);
 
  WeightedEvent();
 
  bool operator==(const WeightedEvent &rhs) const;
  bool equals(const WeightedEvent &rhs, const double tolTof, const double tolWeight, const int64_t tolPulse) const;
 
  double weight() const;
  double error() const;
  double errorSquared() const;
 
  friend std::ostream &operator<<(std::ostream &os, const WeightedEvent &event);
};
#pragma pack(pop)
 
//==========================================================================================
#pragma pack(push, 4) // Ensure the structure is no larger than it needs to
class MANTID_DATAOBJECTS_DLL WeightedEventNoTime {
 
  friend class EventList;
  friend class tofGreaterOrEqual;
  friend class tofGreater;
 
protected:
  double m_tof;
 
public:
  float m_weight;
 
  float m_errorSquared;
 
public:
  WeightedEventNoTime(double time_of_flight);
 
  WeightedEventNoTime(double tof, double weight, double errorSquared);
  WeightedEventNoTime(double tof, float weight, float errorSquared);
 
  WeightedEventNoTime(double tof, const Mantid::Types::Core::DateAndTime pulsetime, double weight, double errorSquared);
  WeightedEventNoTime(double tof, const Mantid::Types::Core::DateAndTime pulsetime, float weight, float errorSquared);
 
  WeightedEventNoTime(const Types::Event::TofEvent &rhs, double weight, double errorSquared);
  WeightedEventNoTime(const Types::Event::TofEvent &rhs, float weight, float errorSquared);
 
  WeightedEventNoTime(const WeightedEvent &rhs);
 
  WeightedEventNoTime(const Types::Event::TofEvent &rhs);
 
  WeightedEventNoTime();
 
  bool operator==(const WeightedEventNoTime &rhs) const;
 
  bool operator<(const WeightedEventNoTime &rhs) const { return (this->m_tof < rhs.m_tof); }
 
  bool operator<(const double rhs_tof) const { return (this->m_tof < rhs_tof); }
 
  bool equals(const WeightedEventNoTime &rhs, const double tolTof, const double tolWeight) const;
 
  double operator()() const;
  double tof() const;
  const Mantid::Types::Core::DateAndTime &pulseTime() const;
  Mantid::Types::Core::DateAndTime pulseTOFTime() const;
  Mantid::Types::Core::DateAndTime pulseTOFTimeAtSample(const double &factor, const double &shift) const;
  double weight() const;
  double error() const;
  double errorSquared() const;
 
  friend std::ostream &operator<<(std::ostream &os, const WeightedEvent &event);
 
private:
  inline static const Mantid::Types::Core::DateAndTime UNSET_DATEANDTIME = Mantid::Types::Core::DateAndTime(0);
};
#pragma pack(pop)
 
//==========================================================================================
// WeightedEvent inlined member function definitions
//==========================================================================================
 
inline double WeightedEvent::weight() const { return m_weight; }
 
inline double WeightedEvent::error() const { return std::sqrt(double(m_errorSquared)); }
 
inline double WeightedEvent::errorSquared() const { return m_errorSquared; }
 
//==========================================================================================
// WeightedEventNoTime inlined member function definitions
//==========================================================================================
 
inline double WeightedEventNoTime::operator()() const { return m_tof; }
 
inline double WeightedEventNoTime::tof() const { return m_tof; }
 
inline const Types::Core::DateAndTime &WeightedEventNoTime::pulseTime() const { return UNSET_DATEANDTIME; }
inline Types::Core::DateAndTime WeightedEventNoTime::pulseTOFTime() const { return UNSET_DATEANDTIME; }
inline Types::Core::DateAndTime WeightedEventNoTime::pulseTOFTimeAtSample(const double &factor,
                                                                          const double &shift) const {
  UNUSED_ARG(factor);
  UNUSED_ARG(shift);
  return 0;
}
 
inline double WeightedEventNoTime::weight() const { return m_weight; }
 
inline double WeightedEventNoTime::error() const { return std::sqrt(double(m_errorSquared)); }
 
inline double WeightedEventNoTime::errorSquared() const { return m_errorSquared; }
 
} // namespace DataObjects
} // namespace Mantid