GenerateEventsFilter.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2012 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
 
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidAlgorithms/DllConfig.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/SplittersWorkspace.h"
#include "MantidKernel/TimeSeriesProperty.h"
 
namespace Mantid {
namespace Algorithms {
 
class MANTID_ALGORITHMS_DLL GenerateEventsFilter final : public API::Algorithm {
public:
  explicit GenerateEventsFilter();
 
  const std::string name() const override { return "GenerateEventsFilter"; }
  const std::string summary() const override {
    return "Generate one or a set of event filters according to time or "
           "specified log's value.";
  }
 
  int version() const override { return 1; }
  const std::vector<std::string> seeAlso() const override {
    return {"FilterEvents", "FilterByTime", "FilterByLogValue"};
  }
  const std::string category() const override { return "Events\\EventFiltering"; }
 
private:
  void init() override;
  void exec() override;
 
  void processInOutWorkspaces();
 
  void processInputTime();
  void setFilterByTimeOnly();
  void setFilterByLogValue(const std::string &logname);
 
  void processSingleValueFilter(double minvalue, double maxvalue, bool filterincrease, bool filterdecrease);
 
  void processMultipleValueFilters(double minvalue, double valueinterval, double maxvalue, bool filterincrease,
                                   bool filterdecrease);
 
  void makeFilterBySingleValue(double min, double max, double TimeTolerance, bool centre, bool filterIncrease,
                               bool filterDecrease, Types::Core::DateAndTime startTime,
                               Types::Core::DateAndTime stopTime, int wsindex);
 
  void makeMultipleFiltersByValues(std::map<size_t, int> indexwsindexmap, const std::vector<double> &logvalueranges,
                                   bool centre, bool filterIncrease, bool filterDecrease,
                                   Types::Core::DateAndTime startTime, Types::Core::DateAndTime stopTime);
 
  void makeMultipleFiltersByValuesParallel(const std::map<size_t, int> &indexwsindexmap,
                                           const std::vector<double> &logvalueranges, bool centre, bool filterIncrease,
                                           bool filterDecrease, Types::Core::DateAndTime startTime,
                                           Types::Core::DateAndTime stopTime);
 
  void makeMultipleFiltersByValuesPartialLog(int istart, int iend, std::vector<Types::Core::DateAndTime> &vecSplitTime,
                                             std::vector<int> &vecSplitGroup, std::map<size_t, int> indexwsindexmap,
                                             const std::vector<double> &logvalueranges,
                                             const Types::Core::time_duration &tol, bool filterIncrease,
                                             bool filterDecrease, Types::Core::DateAndTime startTime,
                                             Types::Core::DateAndTime stopTime);
 
  void processIntegerValueFilter(int minvalue, int maxvalue, bool filterIncrease, bool filterDecrease,
                                 Types::Core::DateAndTime runend);
 
  size_t searchValue(const std::vector<double> &sorteddata, double value);
 
  void addNewTimeFilterSplitter(Types::Core::DateAndTime starttime, Types::Core::DateAndTime stoptime, int wsindex,
                                const std::string &info);
 
  Types::Core::DateAndTime makeSplitterInVector(std::vector<Types::Core::DateAndTime> &vecSplitTime,
                                                std::vector<int> &vecGroupIndex, Types::Core::DateAndTime start,
                                                Types::Core::DateAndTime stop, int group, int64_t tol_ns,
                                                Types::Core::DateAndTime lasttime);
 
  void generateSplittersInMatrixWorkspace();
 
  void generateSplittersInMatrixWorkspaceParallel();
 
  void generateSplittersInSplitterWS();
 
  bool identifyLogEntry(const int &index, const Types::Core::DateAndTime &currT, const bool &lastgood,
                        const double &minvalue, const double &maxvalue, const Types::Core::DateAndTime &startT,
                        const Types::Core::DateAndTime &stopT, const bool &filterIncrease, const bool &filterDecrease);
 
  int determineChangingDirection(int startindex);
 
  Types::Core::DateAndTime findRunEnd();
 
  API::MatrixWorkspace_const_sptr m_dataWS;
 
  DataObjects::SplittersWorkspace_sptr m_splitWS;
  API::MatrixWorkspace_sptr m_filterWS;
 
  API::ITableWorkspace_sptr m_filterInfoWS;
 
  Types::Core::DateAndTime m_startTime;
  Types::Core::DateAndTime m_stopTime;
 
  Types::Core::DateAndTime m_runEndTime;
 
  double m_timeUnitConvertFactorToNS;
 
  Kernel::TimeSeriesProperty<double> *m_dblLog;
  Kernel::TimeSeriesProperty<int> *m_intLog;
 
  bool m_logAtCentre;
  double m_logTimeTolerance;
 
  bool m_forFastLog;
 
  Kernel::SplittingIntervalVec m_splitters;
  std::vector<Types::Core::DateAndTime> m_vecSplitterTime;
  std::vector<int> m_vecSplitterGroup;
 
  bool m_useParallel;
 
  bool m_isReverseLogarithmic = false;
 
  std::vector<std::vector<Types::Core::DateAndTime>> m_vecSplitterTimeSet;
  std::vector<std::vector<int>> m_vecGroupIndexSet;
};
 
} // namespace Algorithms
} // namespace Mantid