MuonGroupingXMLHelper.cpp

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 +
#include "MantidFrameworkTestHelpers/MuonGroupingXMLHelper.h"
 
#include "MantidAPI/GroupingLoader.h"
#include "MantidMuon/MuonAlgorithmHelper.h"
 
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/DOMWriter.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/NodeList.h>
#include <Poco/DOM/Text.h>
#include <Poco/XML/XMLWriter.h>
 
using namespace Mantid;
// using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace ScopedFileHelper;
 
namespace MuonGroupingXMLHelper {
 
ScopedFileHelper::ScopedFile createGroupingXMLSingleGroup(const std::string &groupName, const std::string &group) {
  std::string fileContents("");
  fileContents += "<detector-grouping description=\"test XML file\"> \n";
  fileContents += "\t<group name=\"" + groupName + "\"> \n";
  fileContents += "\t\t<ids val=\"" + group + "\"/>\n";
  fileContents += "\t</group>\n";
  fileContents += "\t<default name=\"" + groupName + "\"/>\n";
  fileContents += "</detector-grouping>";
 
  ScopedFileHelper::ScopedFile file(fileContents, "testXML_1.xml");
  return file;
}
 
ScopedFileHelper::ScopedFile createGroupingXMLSinglePair(const std::string &pairName, const std::string &groupName) {
 
  std::string fileContents("");
 
  fileContents += "<detector-grouping description=\"test XML file\"> \n";
  fileContents += "\t<group name=\"group1\"> \n";
  fileContents += "\t\t<ids val=\"1\"/>\n";
  fileContents += "\t</group>\n";
 
  fileContents += "<detector-grouping description=\"test XML file\"> \n";
  fileContents += "\t<group name=\"group2\"> \n";
  fileContents += "\t\t<ids val=\"2\"/>\n";
  fileContents += "\t</group>\n";
 
  fileContents += "\t<pair name=\"" + pairName + "\"> \n";
  fileContents += "\t\t<forward-group val=\"group1\"/>\n";
  fileContents += "\t\t<backward-group val=\"" + groupName + "\"/>\n";
  fileContents += "\t\t<alpha val=\"1\"/>\n";
  fileContents += "\t</pair>\n";
 
  fileContents += "\t<default name=\"" + groupName + "\"/>\n";
  fileContents += "</detector-grouping>";
 
  ScopedFileHelper::ScopedFile file(fileContents, "testXML_1.xml");
 
  return file;
}
 
ScopedFileHelper::ScopedFile createXMLwithPairsAndGroups(const int &nGroups, const int &nDetectorsPerGroup) {
 
  API::Grouping grouping;
  std::string groupIDs;
  // groups
  for (auto group = 1; group <= nGroups; group++) {
    std::string groupName = "group" + std::to_string(group);
    if (nGroups == 1) {
      groupIDs = "1";
    } else {
      groupIDs =
          std::to_string((group - 1) * nDetectorsPerGroup + 1) + "-" + std::to_string(group * nDetectorsPerGroup);
    }
    grouping.groupNames.emplace_back(groupName);
    grouping.groups.emplace_back(groupIDs);
  }
  // pairs
  for (auto pair = 1; pair < nGroups; pair++) {
    std::string pairName = "pair" + std::to_string(pair);
    std::pair<size_t, size_t> pairIndices;
    pairIndices.first = 0;
    pairIndices.second = pair;
    grouping.pairNames.emplace_back(pairName);
    grouping.pairAlphas.emplace_back(1.0);
    grouping.pairs.emplace_back(pairIndices);
  }
 
  auto fileContents = groupingToXML(grouping);
  ScopedFileHelper::ScopedFile file(fileContents, "testXML_1.xml");
  return file;
}
 
std::string groupingToXML(const Mantid::API::Grouping &grouping) {
 
  Poco::XML::DOMWriter writer;
  writer.setNewLine("\n");
  writer.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT);
 
  Poco::AutoPtr<Poco::XML::Document> mDoc = new Poco::XML::Document();
 
  // Create root element with a description
  Poco::AutoPtr<Poco::XML::Element> rootElem = mDoc->createElement("detector-grouping");
  rootElem->setAttribute("description", grouping.description);
  mDoc->appendChild(rootElem);
 
  // Create group elements
  for (size_t gi = 0; gi < grouping.groups.size(); gi++) {
    Poco::AutoPtr<Poco::XML::Element> gElem = mDoc->createElement("group");
    gElem->setAttribute("name", grouping.groupNames[gi]);
    rootElem->appendChild(gElem);
 
    Poco::AutoPtr<Poco::XML::Element> idsElem = mDoc->createElement("ids");
    idsElem->setAttribute("val", grouping.groups[gi]);
    gElem->appendChild(idsElem);
  }
 
  // Create pair elements
  for (size_t pi = 0; pi < grouping.pairs.size(); pi++) {
    Poco::AutoPtr<Poco::XML::Element> gElem = mDoc->createElement("pair");
    gElem->setAttribute("name", grouping.pairNames[pi]);
    rootElem->appendChild(gElem);
 
    Poco::AutoPtr<Poco::XML::Element> fwElem = mDoc->createElement("forward-group");
    fwElem->setAttribute("val", grouping.groupNames[grouping.pairs[pi].first]);
    gElem->appendChild(fwElem);
 
    Poco::AutoPtr<Poco::XML::Element> bwElem = mDoc->createElement("backward-group");
    bwElem->setAttribute("val", grouping.groupNames[grouping.pairs[pi].second]);
    gElem->appendChild(bwElem);
 
    Poco::AutoPtr<Poco::XML::Element> alphaElem = mDoc->createElement("alpha");
    alphaElem->setAttribute("val", boost::lexical_cast<std::string>(grouping.pairAlphas[pi]));
    gElem->appendChild(alphaElem);
  }
 
  // Create default group/pair name element
  Poco::AutoPtr<Poco::XML::Element> gElem = mDoc->createElement("default");
  gElem->setAttribute("name", grouping.defaultName);
  rootElem->appendChild(gElem);
 
  std::stringstream stream;
  writer.writeNode(stream, mDoc);
  return stream.str();
}
 
} // namespace MuonGroupingXMLHelper