ConvertSpiceDataToRealSpace.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2014 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/IMDEventWorkspace_fwd.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidGeometry/IDTypes.h"
#include "MantidKernel/FileDescriptor.h"
#include "MantidMDAlgorithms/DllConfig.h"
 
#include <deque>
 
namespace Mantid {
namespace MDAlgorithms {
 
class MANTID_MDALGORITHMS_DLL ConvertSpiceDataToRealSpace final : public API::Algorithm {
public:
  const std::string name() const override { return "ConvertSpiceDataToRealSpace"; }
 
  const std::string summary() const override { return "Load a HFIR powder diffractometer SPICE file."; }
 
  int version() const override { return (1); }
 
  const std::string category() const override { return "Diffraction\\ConstantWavelength;DataHandling\\Text"; }
 
  // virtual int confidence(Kernel::FileDescriptor &descriptor) const;
 
private:
  using DataCollectionType = std::deque<std::string>;
 
  void init() override;
 
  void exec() override;
 
  DataObjects::TableWorkspace_sptr loadSpiceData(const std::string &spicefilename);
 
  std::vector<API::MatrixWorkspace_sptr> convertToMatrixWorkspace(const DataObjects::TableWorkspace_sptr &tablews,
                                                                  const API::MatrixWorkspace_const_sptr &parentws,
                                                                  Types::Core::DateAndTime runstart,
                                                                  std::map<std::string, std::vector<double>> &logvecmap,
                                                                  std::vector<Types::Core::DateAndTime> &vectimes);
 
  API::IMDEventWorkspace_sptr createDataMDWorkspace(const std::vector<API::MatrixWorkspace_sptr> &vec_ws2d);
 
  API::IMDEventWorkspace_sptr createMonitorMDWorkspace(const std::vector<API::MatrixWorkspace_sptr> &vec_ws2d,
                                                       const std::vector<double> &vecmonitor);
 
  void readTableInfo(const DataObjects::TableWorkspace_const_sptr &tablews, size_t &ipt, size_t &irotangle,
                     size_t &itime, std::vector<std::pair<size_t, size_t>> &anodelist,
                     std::map<std::string, size_t> &samplenameindexmap);
 
  void parseSampleLogs(const DataObjects::TableWorkspace_sptr &tablews, const std::map<std::string, size_t> &indexlist,
                       std::map<std::string, std::vector<double>> &logvecmap);
 
  API::MatrixWorkspace_sptr loadRunToMatrixWS(const DataObjects::TableWorkspace_sptr &tablews, size_t irow,
                                              const API::MatrixWorkspace_const_sptr &parentws,
                                              Types::Core::DateAndTime runstart, size_t ipt, size_t irotangle,
                                              size_t itime, const std::vector<std::pair<size_t, size_t>> &anodelist,
                                              double &duration);
 
  void addExperimentInfos(const API::IMDEventWorkspace_sptr &mdws,
                          const std::vector<API::MatrixWorkspace_sptr> &vec_ws2d);
 
  void appendSampleLogs(const API::IMDEventWorkspace_sptr &mdws,
                        const std::map<std::string, std::vector<double>> &logvecmap,
                        const std::vector<Types::Core::DateAndTime> &vectimes);
 
  std::map<detid_t, double> parseDetectorEfficiencyTable(const DataObjects::TableWorkspace_sptr &detefftablews);
 
  void correctByDetectorEfficiency(std::vector<API::MatrixWorkspace_sptr> vec_ws2d,
                                   const std::map<detid_t, double> &detEffMap);
 
  std::string m_instrumentName;
 
  size_t m_numSpec = 0;
 
  std::vector<double> m_extentMins;
  std::vector<double> m_extentMaxs;
  std::vector<size_t> m_numBins;
  size_t m_nDimensions = 3;
};
 
} // namespace MDAlgorithms
} // namespace Mantid