Events.cpp

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 +
#include "MantidDataObjects/Events.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidDataObjects/EventList.h"
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/Exception.h"
#include <cmath>
#include <functional>
#include <stdexcept>
 
using std::ostream;
using std::size_t;
 
namespace Mantid::DataObjects {
using Types::Event::TofEvent;
 
//==========================================================================
//==========================================================================
 
WeightedEvent::WeightedEvent(double time_of_flight) : TofEvent(time_of_flight), m_weight(1.0), m_errorSquared(1.0) {}
 
WeightedEvent::WeightedEvent(double tof, const Mantid::Types::Core::DateAndTime pulsetime, double weight,
                             double errorSquared)
    : TofEvent(tof, pulsetime), m_weight(static_cast<float>(weight)), m_errorSquared(static_cast<float>(errorSquared)) {
}
 
WeightedEvent::WeightedEvent(double tof, const Mantid::Types::Core::DateAndTime pulsetime, float weight,
                             float errorSquared)
    : TofEvent(tof, pulsetime), m_weight(weight), m_errorSquared(errorSquared) {}
 
WeightedEvent::WeightedEvent(const TofEvent &rhs, double weight, double errorSquared)
    : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(static_cast<float>(weight)),
      m_errorSquared(static_cast<float>(errorSquared)) {}
 
WeightedEvent::WeightedEvent(const TofEvent &rhs, float weight, float errorSquared)
    : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(weight), m_errorSquared(errorSquared) {}
 
WeightedEvent::WeightedEvent(const TofEvent &rhs)
    : TofEvent(rhs.m_tof, rhs.m_pulsetime), m_weight(1.0), m_errorSquared(1.0) {}
 
WeightedEvent::WeightedEvent() : TofEvent(), m_weight(1.0), m_errorSquared(1.0) {}
 
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);
}
 
bool WeightedEvent::equals(const WeightedEvent &rhs, const double tolTof, const double tolWeight,
                           const int64_t tolPulse) const {
  if (std::fabs(this->m_tof - rhs.m_tof) > tolTof)
    return false;
  if (std::fabs(this->m_weight - rhs.m_weight) > tolWeight)
    return false;
  if (std::fabs(this->m_errorSquared - rhs.m_errorSquared) > tolWeight)
    return false;
  // then it is just if the pulse-times are equal
  return (this->m_pulsetime.equals(rhs.m_pulsetime, tolPulse));
}
 
ostream &operator<<(ostream &os, const WeightedEvent &event) {
  os << event.m_tof << "," << event.m_pulsetime.toSimpleString() << " (W" << event.m_weight << " +- " << event.error()
     << ")";
  return os;
}
 
//==========================================================================
//==========================================================================
 
WeightedEventNoTime::WeightedEventNoTime(double time_of_flight)
    : m_tof(time_of_flight), m_weight(1.0), m_errorSquared(1.0) {}
 
WeightedEventNoTime::WeightedEventNoTime(double tof, double weight, double errorSquared)
    : m_tof(tof), m_weight(static_cast<float>(weight)), m_errorSquared(static_cast<float>(errorSquared)) {}
 
WeightedEventNoTime::WeightedEventNoTime(double tof, float weight, float errorSquared)
    : m_tof(tof), m_weight(weight), m_errorSquared(errorSquared) {}
 
WeightedEventNoTime::WeightedEventNoTime(double tof, const Mantid::Types::Core::DateAndTime /*unused*/, double weight,
                                         double errorSquared)
    : m_tof(tof), m_weight(static_cast<float>(weight)), m_errorSquared(static_cast<float>(errorSquared)) {}
 
WeightedEventNoTime::WeightedEventNoTime(double tof, const Mantid::Types::Core::DateAndTime /*unused*/, float weight,
                                         float errorSquared)
    : m_tof(tof), m_weight(weight), m_errorSquared(errorSquared) {}
 
WeightedEventNoTime::WeightedEventNoTime(const TofEvent &rhs, double weight, double errorSquared)
    : m_tof(rhs.m_tof), m_weight(static_cast<float>(weight)), m_errorSquared(static_cast<float>(errorSquared)) {}
 
WeightedEventNoTime::WeightedEventNoTime(const TofEvent &rhs, float weight, float errorSquared)
    : m_tof(rhs.m_tof), m_weight(weight), m_errorSquared(errorSquared) {}
 
WeightedEventNoTime::WeightedEventNoTime(const WeightedEvent &rhs)
    : m_tof(rhs.m_tof), m_weight(rhs.m_weight), m_errorSquared(rhs.m_errorSquared) {}
 
WeightedEventNoTime::WeightedEventNoTime(const TofEvent &rhs) : m_tof(rhs.m_tof), m_weight(1.0), m_errorSquared(1.0) {}
 
WeightedEventNoTime::WeightedEventNoTime() : m_tof(0.0), m_weight(1.0), m_errorSquared(1.0) {}
 
bool WeightedEventNoTime::operator==(const WeightedEventNoTime &rhs) const {
  return (this->m_tof == rhs.m_tof) && (this->m_weight == rhs.m_weight) && (this->m_errorSquared == rhs.m_errorSquared);
}
 
bool WeightedEventNoTime::equals(const WeightedEventNoTime &rhs, const double tolTof, const double tolWeight) const {
  if (std::fabs(this->m_tof - rhs.m_tof) > tolTof)
    return false;
  if (std::fabs(this->m_weight - rhs.m_weight) > tolWeight)
    return false;
  if (std::fabs(this->m_errorSquared - rhs.m_errorSquared) > tolWeight)
    return false;
  // then it is just if the pulse-times are equal
  return true;
}
 
} // namespace Mantid::DataObjects