LoadDetectorsGroupingFile.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 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 "MantidDataHandling/DllConfig.h"
#include "MantidDataObjects/GroupingWorkspace.h"
 
#include <Poco/DOM/Document.h>
 
#include <fstream>
 
namespace Poco {
namespace XML {
class Element;
class Node;
} // namespace XML
} // namespace Poco
 
namespace Mantid {
namespace DataHandling {
 
class MANTID_DATAHANDLING_DLL LoadDetectorsGroupingFile final : public API::Algorithm {
public:
  const std::string name() const override { return "LoadDetectorsGroupingFile"; };
  const std::string summary() const override {
    return "Load an XML or Map file, which contains definition of detectors "
           "grouping, to a GroupingWorkspace.";
  }
 
  int version() const override { return 1; };
  const std::vector<std::string> seeAlso() const override { return {"SaveDetectorsGrouping", "GroupDetectors"}; }
  const std::string category() const override { return "DataHandling\\Grouping;Transforms\\Grouping"; }
 
private:
  void init() override;
  void exec() override;
  void initializeXMLParser(const std::string &filename);
  void parseXML();
  void intializeGroupingWorkspace();
  void setByComponents();
  void setByDetectors();
  void setBySpectrumNos();
  void parseDetectorIDs(std::string inputstring, std::vector<detid_t> &detids);
  void parseSpectrumNos(std::string inputstring, std::vector<int> &specids);
  static std::string getAttributeValueByName(Poco::XML::Node *pNode, std::string attributename, bool &found);
  void parseRangeText(std::string inputstr, std::vector<int32_t> &singles, std::vector<int32_t> &pairs);
  void generateNoInstrumentGroupWorkspace();
 
  DataObjects::GroupingWorkspace_sptr m_groupWS;
 
  Geometry::Instrument_const_sptr m_instrument;
 
  Poco::XML::Document *m_pDoc{nullptr};
  Poco::XML::Element *m_pRootElem{nullptr};
 
  std::map<int, std::vector<std::string>> m_groupComponentsMap;
  std::map<int, std::vector<detid_t>> m_groupDetectorsMap;
  std::map<int, std::vector<int>> m_groupSpectraMap;
};
 
class MANTID_DATAHANDLING_DLL LoadGroupXMLFile {
public:
  LoadGroupXMLFile();
 
  void loadXMLFile(const std::string &xmlfilename);
  void setDefaultStartingGroupID(int startgroupid) { m_startGroupID = startgroupid; }
 
  std::string getInstrumentName() { return m_instrumentName; }
  bool isGivenInstrumentName() { return m_userGiveInstrument; }
 
  std::string getDate() { return m_date; }
  bool isGivenDate() { return m_userGiveDate; }
 
  std::string getDescription() { return m_description; }
  bool isGivenDescription() { return m_userGiveDescription; }
 
  std::map<int, std::vector<std::string>> getGroupComponentsMap() { return m_groupComponentsMap; }
  std::map<int, std::vector<detid_t>> getGroupDetectorsMap() { return m_groupDetectorsMap; }
  std::map<int, std::vector<int>> getGroupSpectraMap() { return m_groupSpectraMap; }
 
  std::map<int, std::string> getGroupNamesMap() { return m_groupNamesMap; }
 
private:
  std::string m_instrumentName;
  bool m_userGiveInstrument;
 
  std::string m_date;
  bool m_userGiveDate;
 
  std::string m_description;
  bool m_userGiveDescription;
 
  Poco::AutoPtr<Poco::XML::Document> m_pDoc;
  std::map<int, std::vector<std::string>> m_groupComponentsMap;
  std::map<int, std::vector<detid_t>> m_groupDetectorsMap;
  std::map<int, std::vector<int>> m_groupSpectraMap;
  int m_startGroupID;
 
  std::map<int, std::string> m_groupNamesMap;
 
  void initializeXMLParser(const std::string &filename);
  void parseXML();
  static std::string getAttributeValueByName(Poco::XML::Node *pNode, const std::string &attributename, bool &found);
};
 
class MANTID_DATAHANDLING_DLL LoadGroupMapFile {
public:
  LoadGroupMapFile(const std::string &fileName, Kernel::Logger &log);
 
  ~LoadGroupMapFile();
 
  void parseFile();
 
  std::map<int, std::vector<int>> getGroupSpectraMap() { return m_groupSpectraMap; }
 
private:
  bool nextDataLine(std::string &line);
 
  const std::string m_fileName;
 
  Kernel::Logger &m_log;
 
  std::map<int, std::vector<int>> m_groupSpectraMap;
 
  std::ifstream m_file;
 
  int m_lastLineRead;
};
 
} // namespace DataHandling
} // namespace Mantid