CompareWorkspaces.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2015 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/LeanElasticPeaksWorkspace.h"
#include "MantidDataObjects/PeaksWorkspace.h"
 
namespace Mantid {
namespace Algorithms {
 
class MANTID_ALGORITHMS_DLL CompareWorkspaces final : public API::Algorithm {
public:
  const std::string name() const override { return "CompareWorkspaces"; }
 
  int version() const override { return 1; }
  const std::vector<std::string> seeAlso() const override { return {"CompareSampleLogs", "CloneWorkspace"}; }
 
  const std::string category() const override { return "Utility\\Workspaces"; }
 
  const std::string summary() const override {
    return "Compares two workspaces for equality. This algorithm is mainly "
           "intended for use by the Mantid development team as part of the "
           "testing process.";
  }
 
  static bool withinAbsoluteTolerance(double x1, double x2, double atol, bool const nanEqual = false);
  static bool withinRelativeTolerance(double x1, double x2, double rtol, bool const nanEqual = false);
 
private:
  void init() override;
 
  void exec() override;
 
  bool processGroups() override;
 
  void processGroups(const std::shared_ptr<const API::WorkspaceGroup> &groupOne,
                     const std::shared_ptr<const API::WorkspaceGroup> &groupTwo);
 
  void doComparison();
 
  void doPeaksComparison(DataObjects::PeaksWorkspace_sptr tws1, DataObjects::PeaksWorkspace_sptr tws2);
  void doLeanElasticPeaksComparison(const DataObjects::LeanElasticPeaksWorkspace_sptr &tws1,
                                    const DataObjects::LeanElasticPeaksWorkspace_sptr &tws2);
  void doTableComparison(const API::ITableWorkspace_const_sptr &tws1, const API::ITableWorkspace_const_sptr &tws2);
  void doMDComparison(const API::Workspace_sptr &w1, const API::Workspace_sptr &w2);
  bool compareEventWorkspaces(const DataObjects::EventWorkspace &ews1, const DataObjects::EventWorkspace &ews2);
  bool checkData(const API::MatrixWorkspace_const_sptr &ws1, const API::MatrixWorkspace_const_sptr &ws2);
  bool checkAxes(const API::MatrixWorkspace_const_sptr &ws1, const API::MatrixWorkspace_const_sptr &ws2);
  bool checkSpectraMap(const API::MatrixWorkspace_const_sptr &ws1, const API::MatrixWorkspace_const_sptr &ws2);
  bool checkInstrument(const API::MatrixWorkspace_const_sptr &ws1, const API::MatrixWorkspace_const_sptr &ws2);
  bool checkMasking(const API::MatrixWorkspace_const_sptr &ws1, const API::MatrixWorkspace_const_sptr &ws2);
  bool checkSample(const API::Sample &sample1, const API::Sample &sample2);
  bool checkRunProperties(const API::Run &run1, const API::Run &run2);
 
  int compareEventsListInDetails(const DataObjects::EventList &el1, const DataObjects::EventList &el2, double tolTof,
                                 double tolWeight, int64_t tolPulse, bool printdetails, size_t &numdiffpulse,
                                 size_t &numdifftof, size_t &numdiffboth, size_t &numdiffweight) const;
 
  void recordMismatch(const std::string &msg, std::string ws1 = "", std::string ws2 = "");
 
  bool m_result{false};
 
  std::function<bool(const double, const double)> m_compare;
 
  API::ITableWorkspace_sptr m_messages;
 
  std::unique_ptr<API::Progress> m_progress = nullptr;
 
  bool m_parallelComparison{false};
};
 
} // namespace Algorithms
} // namespace Mantid