ExperimentInfo.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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/DllConfig.h"
#include "MantidKernel/PropertyWithValue.h"
 
#include "MantidAPI/SpectraDetectorTypes.h"
#include "MantidGeometry/Instrument_fwd.h"
 
#include "MantidKernel/DeltaEMode.h"
#include "MantidKernel/cow_ptr.h"
 
#include <mutex>
 
namespace Mantid {
namespace Nexus {
class File;
}
class SpectrumDefinition;
namespace Kernel {
class Property;
}
namespace Beamline {
class ComponentInfo;
class DetectorInfo;
class SpectrumInfo;
} // namespace Beamline
namespace Geometry {
class ComponentInfo;
class DetectorInfo;
class IDetector;
class InstrumentMetadata;
class ParameterMap;
class PositionAndRotationAccumulator;
class XMLInstrumentParameter;
} // namespace Geometry
 
namespace API {
class Run;
class Sample;
class SpectrumInfo;
 
class MANTID_API_DLL ExperimentInfo {
public:
  ExperimentInfo();
  virtual ~ExperimentInfo();
  ExperimentInfo(const ExperimentInfo &);
  ExperimentInfo &operator=(const ExperimentInfo &);
 
  void copyExperimentInfoFrom(const ExperimentInfo *other);
  virtual ExperimentInfo *cloneExperimentInfo() const;
 
  const std::string toString() const;
 
  void setInstrument(const Geometry::Instrument_const_sptr &instr);
  Geometry::Instrument_const_sptr getInstrument() const;
 
  const Geometry::ParameterMap &instrumentParameters() const;
  Geometry::ParameterMap &instrumentParameters();
  const Geometry::ParameterMap &constInstrumentParameters() const;
  // Add parameters to the instrument parameter map
  void populateInstrumentParameters();
 
  void setNumberOfDetectorGroups(const size_t count) const;
  void setDetectorGrouping(const size_t index, const std::set<detid_t> &detIDs) const;
 
  const Sample &sample() const;
  Sample &mutableSample();
 
  const Run &run() const;
  Run &mutableRun();
  void setSharedRun(Kernel::cow_ptr<Run> run);
  Kernel::cow_ptr<Run> sharedRun();
 
  Kernel::Property *getLog(const std::string &log) const;
  double getLogAsSingleValue(const std::string &log) const;
 
  int getRunNumber() const;
  Kernel::DeltaEMode::Type getEMode() const;
  double getEFixed(const detid_t detID) const;
  double getEFixed(const std::shared_ptr<const Geometry::IDetector> &detector =
                       std::shared_ptr<const Geometry::IDetector>{nullptr}) const;
  double getEFixedGivenEMode(const std::shared_ptr<const Geometry::IDetector> &detector,
                             const Kernel::DeltaEMode::Type emode) const;
  double getEFixedForIndirect(const std::shared_ptr<const Geometry::IDetector> &detector,
                              const std::vector<std::string> &parameterNames) const;
  void setEFixed(const detid_t detID, const double value);
 
  void saveExperimentInfoNexus(Nexus::File *file, bool saveLegacyInstrument = true) const;
  void saveExperimentInfoNexus(Nexus::File *file, bool saveInstrument, bool saveSample, bool saveLogs) const;
 
  void loadExperimentInfoNexus(std::string const &nxFilename, Nexus::File *file, std::string &parameterStr,
                               std::string const &prefix);
 
  void loadExperimentInfoNexus(const std::string &nxFilename, Nexus::File *file, std::string &parameterStr);
  void loadInstrumentInfoNexus(const std::string &nxFilename, Nexus::File *file, std::string &parameterStr);
  void loadInstrumentInfoNexus(const std::string &nxFilename, Nexus::File *file);
  void loadInstrumentParametersNexus(Nexus::File *file, std::string &parameterStr);
 
  void loadSampleAndLogInfoNexus(Nexus::File *file, std::string const &prefix);
  void loadSampleAndLogInfoNexus(Nexus::File *file);
  void readParameterMap(const std::string &parameterStr);
 
  std::string getWorkspaceStartDate() const;
 
  // run/experiment stat time if available, empty otherwise
  std::string getAvailableWorkspaceStartDate() const;
  // run end time if available, empty otherwise
  std::string getAvailableWorkspaceEndDate() const;
 
  const Geometry::DetectorInfo &detectorInfo() const;
  Geometry::DetectorInfo &mutableDetectorInfo();
 
  const SpectrumInfo &spectrumInfo() const;
  SpectrumInfo &mutableSpectrumInfo();
 
  const Geometry::ComponentInfo &componentInfo() const;
  Geometry::ComponentInfo &mutableComponentInfo();
 
  Geometry::ComponentInfo const &baseComponentInfo() const;
 
  Geometry::InstrumentMetadata const &instrumentMetadata() const;
 
  std::string getInstrumentName() const;
 
  void invalidateSpectrumDefinition(const size_t index);
  void updateSpectrumDefinitionIfNecessary(const size_t index) const;
 
protected:
  size_t numberOfDetectorGroups() const;
  virtual void populateIfNotLoaded() const;
 
  void setSpectrumDefinitions(Kernel::cow_ptr<std::vector<SpectrumDefinition>> spectrumDefinitions);
 
  virtual void updateCachedDetectorGrouping(const size_t index) const;
  std::shared_ptr<Geometry::ParameterMap> m_parmap;
  Geometry::Instrument_const_sptr sptr_instrument;
 
  std::shared_ptr<Geometry::ComponentInfo> m_componentInfo;
  std::shared_ptr<Geometry::DetectorInfo> m_detectorInfo;
  std::shared_ptr<Geometry::InstrumentMetadata> m_instrumentMetadata;
 
  void adoptBeamline();
 
private:
  void populateWithParameter(Geometry::ComponentInfo &compInfo, Geometry::PositionAndRotationAccumulator &posAndRot,
                             const size_t compIndex, const std::string &name,
                             const Geometry::XMLInstrumentParameter &paramInfo, const Run &runData);
 
  void loadEmbeddedInstrumentInfoNexus(Nexus::File *file, std::string &instrumentName, std::string &instrumentXml);
 
  void setInstumentFromXML(const std::string &nxFilename, std::string &instrumentName, std::string &instrumentXml);
 
  // Loads the xml from an instrument file with some basic error handling
  std::string loadInstrumentXML(const std::string &filename);
 
  Kernel::cow_ptr<Sample> m_sample;
  Kernel::cow_ptr<Run> m_run;
 
  mutable std::unordered_map<detid_t, size_t> m_det2group;
  void cacheDefaultDetectorGrouping() const; // Not thread-safe
  void invalidateAllSpectrumDefinitions();
  mutable std::once_flag m_defaultDetectorGroupingCached;
 
  mutable std::unique_ptr<Beamline::SpectrumInfo> m_spectrumInfo;
  mutable std::unique_ptr<SpectrumInfo> m_spectrumInfoWrapper;
  mutable std::mutex m_spectrumInfoMutex;
 
  mutable std::unique_ptr<Geometry::DetectorInfo> m_baseDetectorInfo;
  mutable std::unique_ptr<Geometry::ComponentInfo> m_baseComponentInfo;
  mutable std::mutex m_baseComponentInfoMutex;
  // This vector stores boolean flags but uses char to do so since std::vector<bool> is not thread-safe.
  mutable std::vector<char> m_spectrumDefinitionNeedsUpdate;
};
 
using ExperimentInfo_sptr = std::shared_ptr<ExperimentInfo>;
 
using ExperimentInfo_const_sptr = std::shared_ptr<const ExperimentInfo>;
 
} // namespace API
} // namespace Mantid
 
// Instantiated and exported by API/src/PropertyWithValue.cpp
MANTID_API_EXTERN_TEMPLATE(Mantid::Kernel::PropertyWithValue<std::shared_ptr<Mantid::API::ExperimentInfo>>);