LoadISISNexus2.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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/Algorithm.h"
#include "MantidAPI/IFileLoader.h"
#include "MantidAPI/SpectrumDetectorMapping.h"
#include "MantidDataHandling/DataBlockComposite.h"
#include "MantidDataHandling/ISISRunLogs.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/NexusDescriptor.h"
#include "MantidNexus/NexusClasses.h"
#include <nexus/NeXusFile.hpp>
 
#include <boost/scoped_ptr.hpp>
 
#include <climits>
 
//----------------------------------------------------------------------
// Forward declaration
//----------------------------------------------------------------------
namespace Mantid {
namespace DataHandling {
 
class MANTID_DATAHANDLING_DLL LoadISISNexus2 : public API::IFileLoader<Kernel::NexusDescriptor> {
public:
  LoadISISNexus2();
  const std::string name() const override { return "LoadISISNexus"; }
  int version() const override { return 2; }
  const std::vector<std::string> seeAlso() const override { return {"LoadEventNexus", "SaveISISNexus"}; }
  const std::string category() const override { return "DataHandling\\Nexus"; }
  const std::string summary() const override { return "Loads a file in ISIS NeXus format."; }
 
  int confidence(Kernel::NexusDescriptor &descriptor) const override;
 
  struct SpectraBlock {
    SpectraBlock(int64_t f, int64_t l, bool is_mon, const std::string &monname)
        : first(f), last(l), isMonitor(is_mon), monName(monname) {}
 
    int64_t first;  
    int64_t last;   
    bool isMonitor; 
    std::string monName;
  };
 
private:
  void init() override;
  void exec() override;
  // Validate the optional input properties
  bool checkOptionalProperties(bool bseparateMonitors, bool bexcludeMonitor);
 
  size_t prepareSpectraBlocks(std::map<specnum_t, std::string> &monitors, DataBlockComposite &LoadBlock);
  void runLoadInstrument(DataObjects::Workspace2D_sptr &);
  void loadRunDetails(DataObjects::Workspace2D_sptr &local_workspace, Mantid::NeXus::NXEntry &entry);
  void loadSampleData(DataObjects::Workspace2D_sptr &, const Mantid::NeXus::NXEntry &entry);
  void loadLogs(DataObjects::Workspace2D_sptr &ws);
  // Load a given period into the workspace
  void loadPeriodData(int64_t period, Mantid::NeXus::NXEntry &entry, DataObjects::Workspace2D_sptr &local_workspace,
                      bool update_spectra2det_mapping = false);
  // Load a data block
  void loadBlock(Mantid::NeXus::NXDataSetTyped<int> &data, int64_t blocksize, int64_t period, int64_t start,
                 int64_t &hist, int64_t &spec_num, DataObjects::Workspace2D_sptr &local_workspace);
 
  // Create period logs
  void createPeriodLogs(int64_t period, DataObjects::Workspace2D_sptr &local_workspace);
  // Validate multi-period logs
  void validateMultiPeriodLogs(const Mantid::API::MatrixWorkspace_sptr &);
 
  // build the list of spectra numbers to load and include in the spectra list
  void buildSpectraInd2SpectraNumMap(bool range_supplied, bool hasSpectraList, DataBlockComposite &dataBlockComposite);
 
  void checkOverlappingSpectraRange();
 
  std::string m_filename;
  std::string m_instrument_name;
  std::string m_samplename;
  // the description of the data block in the file to load.
  // the description of single time-range data block, obtained from detectors
  DataBlockComposite m_detBlockInfo;
  // the description of single time-range data block, obtained from monitors
  DataBlockComposite m_monBlockInfo;
  // description of the block to be loaded may include monitors and detectors
  // with the same time binning if the detectors and monitors are loaded
  // together
  // in single workspace or equal to the detectorBlock if monitors are excluded
  // or monBlockInfo if only monitors are loaded.
  DataBlockComposite m_loadBlockInfo;
  bool m_have_detector;
  // Is there a VMS block
  bool m_hasVMSBlock;
  bool m_load_selected_spectra;
  std::map<int64_t, specnum_t> m_wsInd2specNum_map;
  API::SpectrumDetectorMapping m_spec2det_map;
  int64_t m_entrynumber;
  std::vector<SpectraBlock> m_spectraBlocks;
  std::shared_ptr<HistogramData::HistogramX> m_tof_data;
  std::vector<specnum_t> m_spec;
  const specnum_t *m_spec_end;
  std::map<specnum_t, std::string> m_monitors;
  boost::scoped_ptr<ISISRunLogs> m_logCreator;
  std::shared_ptr<API::Progress> m_progress;
  static double dblSqrt(double in);
  // Handle to the NeXus file
  // clang-format off
  boost::scoped_ptr< ::NeXus::File> m_nexusFile;
  // clang-format on
 
  bool findSpectraDetRangeInFile(NeXus::NXEntry &entry, std::vector<specnum_t> &spectrum_index, int64_t ndets,
                                 int64_t n_vms_compat_spectra, std::map<specnum_t, std::string> &monitors,
                                 bool excludeMonitors, bool separateMonitors);
 
  bool isMultipleTimeRegimeFile(const NeXus::NXEntry &entry) const;
};
 
} // namespace DataHandling
} // namespace Mantid