FilterEvents.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/ISplittersWorkspace.h"
#include "MantidAPI/ITableWorkspace_fwd.h"
#include "MantidAlgorithms/DllConfig.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/SplittersWorkspace.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidKernel/TimeSplitter.h"
 
namespace Mantid {
namespace Algorithms {
 
class TimeAtSampleStrategy;
 
class MANTID_ALGORITHMS_DLL FilterEvents final : public API::Algorithm {
 
  enum TOFCorrectionType { NoneCorrect, CustomizedCorrect, DirectCorrect, ElasticCorrect, IndirectCorrect };
  enum TOFCorrectionOp { MultiplyOp, ShiftOp };
  enum EVENTFILTERSKIP { EventFilterSkipNoDet, EventFilterSkipNoDetTOFCorr };
 
public:
  FilterEvents();
 
  const std::string name() const override { return "FilterEvents"; }
  const std::string summary() const override {
    return "Filter events from an EventWorkspace to one or multiple "
           "EventWorkspaces according to a series of splitters.";
  }
 
  int version() const override { return 1; }
  const std::vector<std::string> seeAlso() const override {
    return {"GenerateEventsFilter", "FilterByTime", "FilterByLogValue"};
  }
 
  const std::string category() const override { return "Events\\EventFiltering"; }
  std::map<std::string, std::string> validateInputs() override;
 
private:
  // Implement abstract Algorithm methods
  void init() override;
  // Implement abstract Algorithm methods
  void exec() override;
 
  void processAlgorithmProperties();
 
  void processSplittersWorkspace();
 
  void processTableSplittersWorkspace();
 
  void processMatrixSplitterWorkspace();
 
  std::shared_ptr<DataObjects::EventWorkspace> createEventWorkspaceNoLog();
  void createOutputWorkspacesSplitters();
  void createOutputWorkspacesTableSplitterCase();
  void createOutputWorkspacesMatrixCase();
 
  void setupDetectorTOFCalibration();
 
  TimeAtSampleStrategy *setupElasticTOFCorrection() const;
 
  TimeAtSampleStrategy *setupDirectTOFCorrection() const;
 
  TimeAtSampleStrategy *setupIndirectTOFCorrection() const;
 
  void setupCustomizedTOFCorrection();
 
  void filterEventsBySplitters(double progressamount);
 
  void filterEventsByVectorSplitters(double progressamount);
 
  void examineAndSortEventWS();
 
  void convertSplittersWorkspaceToVectors();
 
  void splitTimeSeriesLogs(const std::vector<Kernel::TimeSeriesProperty<int> *> &int_tsp_vector,
                           const std::vector<Kernel::TimeSeriesProperty<double> *> &dbl_tsp_vector,
                           const std::vector<Kernel::TimeSeriesProperty<bool> *> &bool_tsp_vector,
                           const std::vector<Kernel::TimeSeriesProperty<std::string> *> &string_tsp_vector);
 
  std::vector<std::string> getTimeSeriesLogNames();
 
  void generateSplitterTSP(std::vector<std::unique_ptr<Kernel::TimeSeriesProperty<int>>> &split_tsp_vec);
 
  void generateSplitterTSPalpha(std::vector<std::unique_ptr<Kernel::TimeSeriesProperty<int>>> &split_tsp_vec);
 
  void mapSplitterTSPtoWorkspaces(std::vector<std::unique_ptr<Kernel::TimeSeriesProperty<int>>> &split_tsp_vec);
 
  void copyNoneSplitLogs(std::vector<Kernel::TimeSeriesProperty<int> *> &int_tsp_name_vector,
                         std::vector<Kernel::TimeSeriesProperty<double> *> &dbl_tsp_name_vector,
                         std::vector<Kernel::TimeSeriesProperty<bool> *> &bool_tsp_name_vector,
                         std::vector<Kernel::TimeSeriesProperty<std::string> *> &string_tsp_vector);
 
  template <typename TYPE>
  void splitTimeSeriesProperty(Kernel::TimeSeriesProperty<TYPE> *tsp,
                               std::vector<Types::Core::DateAndTime> &split_datetime_vec, const int max_target_index);
 
  void groupOutputWorkspace();
 
  double calculate_duration(std::unique_ptr<Kernel::TimeSeriesProperty<int>> &splitter_tsp);
 
  DataObjects::EventWorkspace_sptr m_eventWS;
  DataObjects::SplittersWorkspace_sptr m_splittersWorkspace;
  DataObjects::TableWorkspace_sptr m_splitterTableWorkspace;
  API::MatrixWorkspace_const_sptr m_matrixSplitterWS;
  DataObjects::TableWorkspace_sptr m_detCorrectWorkspace;
 
  bool m_useSplittersWorkspace;
  bool m_useArbTableSplitters;
 
  std::set<int> m_targetWorkspaceIndexSet;
  int m_maxTargetIndex;
  Kernel::TimeSplitterType m_splitters;
  std::map<int, DataObjects::EventWorkspace_sptr> m_outputWorkspacesMap;
  std::vector<std::string> m_wsNames;
 
  std::vector<double> m_detTofOffsets;
  std::vector<double> m_detTofFactors;
 
  bool m_filterByPulseTime;
 
  DataObjects::TableWorkspace_sptr m_informationWS;
  bool m_hasInfoWS;
 
  double m_progress;
 
  std::string m_outputWSNameBase;
 
  std::map<std::string, int> m_targetIndexMap;
  std::map<int, std::string> m_wsGroupIndexTargetMap;
 
  std::map<int, uint32_t> m_yIndexMap;
  std::map<uint32_t, int> m_wsGroupdYMap;
 
  bool m_toGroupWS;
 
  std::vector<int64_t> m_vecSplitterTime;
  std::vector<int> m_vecSplitterGroup;
 
  bool m_splitSampleLogs;
 
  bool m_useDBSpectrum;
  int m_dbWSIndex;
 
  TOFCorrectionType m_tofCorrType;
 
  EVENTFILTERSKIP m_specSkipType;
  std::vector<bool> m_vecSkip;
 
  // Flag to have relative time in splitters workspace
  bool m_isSplittersRelativeTime;
  // Starting time for starting time of event filters
  Types::Core::DateAndTime m_filterStartTime;
  // EventWorkspace (aka. run)'s starting time
  Types::Core::DateAndTime m_runStartTime;
};
 
} // namespace Algorithms
} // namespace Mantid