SaveParameterFile.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 "MantidDataHandling/SaveParameterFile.h"
 
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/InstrumentValidator.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidGeometry/Instrument/InstrumentMetadata.h"
#include "MantidGeometry/Instrument/ParameterMap.h"
 
#include <boost/lexical_cast.hpp>
#include <boost/tuple/tuple.hpp>
 
#include <fstream>
 
namespace Mantid::DataHandling {
 
// Register the algorithm into the AlgorithmFactory
DECLARE_ALGORITHM(SaveParameterFile)
 
using namespace Kernel;
using namespace API;
using namespace Geometry;
 
using namespace Poco;
 
//----------------------------------------------------------------------------------------------
const std::string SaveParameterFile::name() const { return "SaveParameterFile"; }
 
int SaveParameterFile::version() const { return 1; }
 
const std::string SaveParameterFile::category() const { return "DataHandling\\Instrument"; }
 
//----------------------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------------------
void SaveParameterFile::init() {
  declareProperty(
      std::make_unique<WorkspaceProperty<>>("Workspace", "", Direction::Input, std::make_shared<InstrumentValidator>()),
      "Workspace to save the instrument parameters from.");
 
  declareProperty(std::make_unique<API::FileProperty>("Filename", "", API::FileProperty::Save, ".xml"),
                  "The name of the file into which the instrument parameters will be "
                  "saved.");
 
  declareProperty("LocationParameters", false, "Save the location parameters used to calibrate the instrument.",
                  Direction::Input);
}
 
//----------------------------------------------------------------------------------------------
void SaveParameterFile::exec() {
  const MatrixWorkspace_const_sptr ws = getProperty("Workspace");
  const bool saveLocationParams = getProperty("LocationParameters");
  const std::string filename = getProperty("Filename");
 
  const Instrument_const_sptr instrument = ws->getInstrument();
  // The parameters, with positions and other parameters extracted from DetectorInfo
  const auto params = instrument->legacyParameters();
 
  const auto &componentInfo = ws->componentInfo();
  const auto &detectorInfo = ws->detectorInfo();
 
  // maps component indices to a tuple of parameters' name, type, and value
  std::map<size_t, std::vector<boost::tuple<std::string, std::string, std::string>>> toSave;
 
  // Set up a progress bar
  Progress prog(this, 0.0, 0.3, params.size());
 
  // Build a list of parameters to save;
  for (auto const &paramsIt : params) {
    if (prog.hasCancellationBeenRequested())
      break;
    prog.report("Generating parameters");
    const size_t cID = paramsIt.first;
    const std::string pName = paramsIt.second->name();
    const std::string pType = paramsIt.second->type();
    const std::string pValue = paramsIt.second->asString();
 
    if (pName == "x" || pName == "y" || pName == "z" || pName == "r-position" || pName == "t-position" ||
        pName == "p-position" || pName == "rotx" || pName == "roty" || pName == "rotz") {
      g_log.warning() << "The parameter name '" << pName << "' is reserved and has not been saved. "
                      << "Please contact the Mantid team for more information.";
      continue;
    }
 
    if (pName == "pos") {
      if (saveLocationParams) {
        V3D pos;
        std::istringstream pValueSS(pValue);
        pos.readPrinted(pValueSS);
        toSave[cID].emplace_back("x", "double", boost::lexical_cast<std::string>(pos.X()));
        toSave[cID].emplace_back("y", "double", boost::lexical_cast<std::string>(pos.Y()));
        toSave[cID].emplace_back("z", "double", boost::lexical_cast<std::string>(pos.Z()));
      }
    } else if (pName == "rot") {
      if (saveLocationParams) {
        V3D rot;
        std::istringstream pValueSS(pValue);
        rot.readPrinted(pValueSS);
        toSave[cID].emplace_back("rotx", "double", boost::lexical_cast<std::string>(rot.X()));
        toSave[cID].emplace_back("roty", "double", boost::lexical_cast<std::string>(rot.Y()));
        toSave[cID].emplace_back("rotz", "double", boost::lexical_cast<std::string>(rot.Z()));
      }
    }
    // If it isn't a position or rotation parameter, we can just add it to the
    // list to save directly and move on.
    else {
      if (pType == "fitting") {
        // With fitting parameters we do something special (i.e. silly)
        // We create an entire XML element to be inserted into the output,
        // instead of just giving a single fixed value
        const auto &fitParam = paramsIt.second->value<FitParameter>();
        const std::string fpName = fitParam.getFunction() + ":" + fitParam.getName();
        std::stringstream fpValue;
        fpValue << "<formula";
        fpValue << " eq=\"" << fitParam.getFormula() << "\"";
        fpValue << " unit=\"" << fitParam.getFormulaUnit() << "\"";
        fpValue << " result-unit=\"" << fitParam.getResultUnit() << "\"";
        fpValue << "/>";
        toSave[cID].emplace_back(boost::make_tuple(fpName, "fitting", fpValue.str()));
      } else
        toSave[cID].emplace_back(boost::make_tuple(pName, pType, pValue));
    }
  }
 
  // Begin writing the XML manually
  std::ofstream file(filename.c_str(), std::ofstream::trunc);
  file << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
  file << "<parameter-file instrument=\"" << ws->getInstrumentName() << "\"";
  file << " valid-from=\"" << ws->instrumentMetadata().validFromDate().toISO8601String() << "\">\n";
 
  prog.resetNumSteps(static_cast<int64_t>(toSave.size()), 0.6, 1.0);
  // Iterate through all the parameters we want to save and build an XML
  // document out of them.
  for (const auto &comp : toSave) {
    if (prog.hasCancellationBeenRequested())
      break;
    prog.report("Saving parameters");
    // Component data
    const size_t cID = comp.first;
    const std::string cFullName = componentInfo.fullName(cID);
    const detid_t cDetID = componentInfo.isDetector(cID) ? detectorInfo.detectorIDs()[cID] : 0;
 
    file << "   <component-link";
    if (cDetID != 0)
      file << " id=\"" << cDetID << "\"";
    file << " name=\"" << cFullName << "\">\n";
    for (const auto &param : comp.second) {
      const std::string pName = param.get<0>();
      const std::string pType = param.get<1>();
      const std::string pValue = param.get<2>();
 
      // With fitting parameters, we're actually inserting an entire element, as
      // constructed above
      if (pType == "fitting") {
        file << "               <parameter name=\"" << pName << "\" type=\"fitting\" >\n";
        file << "   " << pValue << "\n";
        file << "               </parameter>\n";
      } else {
        file << "               <parameter name=\"" << pName << "\"" << (pType == "string" ? " type=\"string\"" : "")
             << ">\n";
        file << "                       <value val=\"" << pValue << "\"/>\n";
        file << "               </parameter>\n";
      }
    }
    file << "   </component-link>\n";
  }
  file << "</parameter-file>\n";
 
  file.flush();
  file.close();
}
 
} // namespace Mantid::DataHandling