LoadRawHelper.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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/IFileLoader.h"
#include "MantidAPI/ISISRunLogs.h"
#include "MantidAPI/Run.h"
#include "MantidAPI/WorkspaceGroup_fwd.h"
#include "MantidDataHandling/DllConfig.h"
#include "MantidDataObjects/Workspace2D_fwd.h"
#include "MantidGeometry/IDTypes.h"
#include "MantidHistogramData/HistogramX.h"
#include "MantidKernel/FileDescriptor.h"
#include "MantidTypes/Core/DateAndTime.h"
#include "MantidTypes/SpectrumDefinition.h"
 
#include <climits>
#include <filesystem>
#include <list>
#include <memory>
 
class ISISRAW;
class ISISRAW2;
 
namespace Mantid {
namespace API {
class SpectrumDetectorMapping;
}
 
namespace DataHandling {
class MANTID_DATAHANDLING_DLL LoadRawHelper : public API::IFileLoader<Kernel::FileDescriptor> {
public:
  LoadRawHelper();
  // Define destructor in .cpp as we have unique_ptr to forward declared
  // ISISRAW2
  ~LoadRawHelper() override;
  const std::string name() const override { return "LoadRawHelper"; }
  int version() const override { return 1; }
  const std::string summary() const override { return "Helper class for LoadRaw algorithms."; }
  FILE *openRawFile(const std::string &fileName);
  void loadRunParameters(const API::MatrixWorkspace_sptr &localWorkspace, ISISRAW *const = nullptr) const;
 
  int confidence(Kernel::FileDescriptor &descriptor) const override;
 
  static std::list<std::string> searchForLogFiles(const std::filesystem::path &pathToRawFile);
  static bool isExcludeMonitors(const std::string &monitorOption);
  static bool isSeparateMonitors(const std::string &monitorOption);
  static bool isIncludeMonitors(const std::string &monitorOption);
 
  static void ProcessLoadMonitorOptions(bool &bincludeMonitors, bool &bseparateMonitors, bool &bexcludeMonitors,
                                        const API::Algorithm *pAlgo);
  static void createMonitorWorkspace(DataObjects::Workspace2D_sptr &monws_sptr,
                                     const DataObjects::Workspace2D_sptr &normalws_sptr,
                                     API::WorkspaceGroup_sptr &mongrp_sptr, const int64_t mwsSpecs,
                                     const int64_t nwsSpecs, const int64_t numberOfPeriods, const int64_t lengthIn,
                                     const std::string &title, API::Algorithm *const pAlg);
  static API::WorkspaceGroup_sptr createGroupWorkspace();
 
  static DataObjects::Workspace2D_sptr createWorkspace(const DataObjects::Workspace2D_sptr &ws_sptr,
                                                       int64_t nVectors = -1, int64_t xLengthIn = -1,
                                                       int64_t yLengthIn = -1);
 
  static DataObjects::Workspace2D_sptr createWorkspace(int64_t nVectors, int64_t xlengthIn, int64_t ylengthIn,
                                                       const std::string &title);
 
  static void setWorkspaceProperty(const std::string &propertyName, const std::string &title,
                                   const API::WorkspaceGroup_sptr &grpws_sptr,
                                   const DataObjects::Workspace2D_sptr &ws_sptr, int64_t numberOfPeriods,
                                   [[maybe_unused]] bool bMonitor, API::Algorithm *const pAlg);
 
  static void setWorkspaceProperty(const DataObjects::Workspace2D_sptr &ws_sptr,
                                   const API::WorkspaceGroup_sptr &grpws_sptr, const int64_t period, bool bmonitors,
                                   API::Algorithm *const pAlg);
 
  static Types::Core::DateAndTime extractStartTime(ISISRAW &isisRaw);
 
  static Types::Core::DateAndTime extractEndTime(ISISRAW &isisRaw);
 
protected:
  void init() override;
  void readTitle(FILE *file, std::string &title);
  void readworkspaceParameters(specnum_t &numberOfSpectra, int &numberOfPeriods, int64_t &lengthIn,
                               int64_t &noTimeRegimes);
 
  void skipData(FILE *file, int hist);
  void skipData(FILE *file, int64_t hist);
 
  void ioRaw(FILE *file, bool from_file);
 
  bool readData(FILE *file, int hist);
  bool readData(FILE *file, int64_t hist);
 
  // Constructs the time channel (X) vector(s)
  std::vector<std::shared_ptr<HistogramData::HistogramX>> getTimeChannels(const int64_t &regimes,
                                                                          const int64_t &lengthIn);
  void runLoadInstrument(const std::string &fileName, const DataObjects::Workspace2D_sptr &, double, double);
  void runLoadInstrumentFromRaw(const std::string &fileName, const DataObjects::Workspace2D_sptr &);
  void runLoadMappingTable(const std::string &fileName, const DataObjects::Workspace2D_sptr &);
  void runLoadLog(const std::string &fileName, const DataObjects::Workspace2D_sptr &, double, double);
 
  void createPeriodLogs(int64_t period, const DataObjects::Workspace2D_sptr &local_workspace);
 
  std::vector<specnum_t> getmonitorSpectrumList(const API::SpectrumDetectorMapping &mapping);
 
  void setWorkspaceData(const DataObjects::Workspace2D_sptr &newWorkspace,
                        const std::vector<std::shared_ptr<HistogramData::HistogramX>> &timeChannelsVec, int64_t wsIndex,
                        specnum_t nspecNum, int64_t noTimeRegimes, int64_t lengthIn, int64_t binStart);
 
  float getProtonCharge() const;
  void setProtonCharge(API::Run &run);
  void setRunNumber(API::Run &run);
 
  int getNumberofTimeRegimes();
  ISISRAW2 &isisRaw() const;
  void reset();
 
  void setOptionalProperties(const int &spec_min, const int &spec_max, const std::vector<int> &spec_list);
  void checkOptionalProperties();
  specnum_t calculateWorkspaceSize();
  void calculateWorkspacesizes(const std::vector<specnum_t> &monitorSpecList, specnum_t &normalwsSpecs,
                               specnum_t &monitorwsSpecs);
  void loadSpectra(FILE *file, const int &period, const int &total_specs, const DataObjects::Workspace2D_sptr &ws_sptr,
                   const std::vector<std::shared_ptr<HistogramData::HistogramX>> &);
 
  bool m_list;
  bool m_interval;
  std::vector<specnum_t> m_spec_list;
  specnum_t m_spec_min;
  specnum_t m_spec_max;
  int m_numberOfPeriods;
 
private:
  void exec() override;
  static std::string convertMonthLabelToIntStr(std::string month);
 
  mutable std::unique_ptr<ISISRAW2> m_isis_raw;
  std::vector<std::string> m_cache_options;
  std::map<specnum_t, specnum_t> m_specTimeRegimes;
  double m_prog;
 
  specnum_t m_numberOfSpectra;
 
  std::vector<specnum_t> m_monitordetectorList;
 
  bool m_bmspeclist;
 
  specnum_t m_total_specs;
 
  std::unique_ptr<API::ISISRunLogs> m_logCreator;
 
  std::string extractLogName(const std::string &path);
};
 
} // namespace DataHandling
} // namespace Mantid