LogFilter.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 "MantidKernel/LogFilter.h"
#include "MantidKernel/TimeSeriesProperty.h"
 
namespace Mantid::Kernel {
LogFilter::LogFilter(const TimeSeriesProperty<bool> &filter) : m_prop(), m_filter() { addFilter(filter); }
 
LogFilter::LogFilter(const Property *prop) : m_prop(), m_filter() { m_prop.reset(convertToTimeSeriesOfDouble(prop)); }
 
LogFilter::LogFilter(const TimeSeriesProperty<double> *timeSeries) : m_prop(), m_filter() {
  m_prop.reset(timeSeries->clone());
}
 
void LogFilter::addFilter(const TimeSeriesProperty<bool> &filter) {
  if (filter.size() == 0)
    return;
  if (!m_filter || m_filter->size() == 0)
    m_filter.reset(filter.clone());
  else {
    auto filterProperty = std::make_unique<TimeSeriesProperty<bool>>("tmp");
 
    TimeSeriesProperty<bool> *filter1 = m_filter.get();
    auto filter2 = std::unique_ptr<TimeSeriesProperty<bool>>(filter.clone());
 
    TimeInterval time1 = filter1->nthInterval(filter1->size() - 1);
    TimeInterval time2 = filter2->nthInterval(filter2->size() - 1);
 
    if (time1.begin() < time2.begin()) {
      filter1->addValue(time2.begin(),
                        true); // should be f1->lastValue, but it doesnt
                               // matter for boolean AND
    } else if (time2.begin() < time1.begin()) {
      filter2->addValue(time1.begin(), true);
    }
 
    int i = 0;
    int j = 0;
 
    time1 = filter1->nthInterval(i);
    time2 = filter2->nthInterval(j);
 
    // Make the two filters start at the same time. An entry is added at the
    // beginning
    // of the filter that starts later to equalise their staring times. The new
    // interval will have
    // value opposite to the one it started with originally.
    if (time1.begin() > time2.begin()) {
      filter1->addValue(time2.begin(), !filter1->nthValue(i));
      time1 = filter1->nthInterval(i);
    } else if (time2.begin() > time1.begin()) {
      filter2->addValue(time1.begin(), !filter2->nthValue(j));
      time2 = filter2->nthInterval(j);
    }
 
    for (;;) {
      TimeInterval time3;
      time3 = time1.intersection(time2);
      if (time3.isValid()) {
        filterProperty->addValue(time3.begin(), (filter1->nthValue(i) && filter2->nthValue(j)));
      }
 
      if (time1.end() < time2.end()) {
        i++;
      } else if (time2.end() < time1.end()) {
        j++;
      } else {
        i++;
        j++;
      }
 
      if (i == filter1->size() || j == filter2->size())
        break;
      time1 = filter1->nthInterval(i);
      time2 = filter2->nthInterval(j);
    }
    filterProperty->clearFilter();
    m_filter = std::move(filterProperty);
  }
  if (m_prop) {
    m_prop->clearFilter();
    m_prop->filterWith(m_filter.get());
  }
}
 
//-------------------------------------------------------------------------------------------------
void LogFilter::clear() {
  if (m_prop)
    m_prop->clearFilter();
  m_filter.reset();
}
 
//--------------------------------------------------------------------------------------------------
// Private methods
//--------------------------------------------------------------------------------------------------
namespace {
template <typename SrcType> struct ConvertToTimeSeriesDouble {
  static TimeSeriesProperty<double> *apply(const Property *prop) {
    auto srcTypeSeries = dynamic_cast<const TimeSeriesProperty<SrcType> *>(prop);
    if (!srcTypeSeries)
      return nullptr;
    auto converted = new TimeSeriesProperty<double>(prop->name());
    auto pmap = srcTypeSeries->valueAsMap();
    for (auto it = pmap.begin(); it != pmap.end(); ++it) {
      converted->addValue(it->first, double(it->second));
    }
    return converted;
  }
};
 
template <> struct ConvertToTimeSeriesDouble<double> {
  static TimeSeriesProperty<double> *apply(const Property *prop) {
    auto doubleSeries = dynamic_cast<const TimeSeriesProperty<double> *>(prop);
    if (!doubleSeries)
      return nullptr;
    return doubleSeries->clone();
  }
};
} // namespace
 
TimeSeriesProperty<double> *LogFilter::convertToTimeSeriesOfDouble(const Property *prop) {
  if (auto doubleSeries = ConvertToTimeSeriesDouble<double>::apply(prop)) {
    return doubleSeries;
  } else if (auto doubleSeries = ConvertToTimeSeriesDouble<int>::apply(prop)) {
    return doubleSeries;
  } else if (auto doubleSeries = ConvertToTimeSeriesDouble<bool>::apply(prop)) {
    return doubleSeries;
  } else {
    throw std::invalid_argument("LogFilter::convertToTimeSeriesOfDouble - Cannot convert property, \"" + prop->name() +
                                "\", to double series.");
  }
}
 
} // namespace Mantid::Kernel