LoadCanSAS1D2.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/LoadCanSAS1D2.h"
#include "MantidAPI/Axis.h"
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/RegisterFileLoader.h"
#include "MantidAPI/Run.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidAPI/WorkspaceGroup.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidGeometry/Instrument.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/UnitFactory.h"
 
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/NodeList.h>
 
using Poco::XML::Element;
using Poco::XML::Node;
using Poco::XML::NodeList;
 
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace Mantid::DataObjects;
 
namespace Mantid::DataHandling {
 
DECLARE_FILELOADER_ALGORITHM(LoadCanSAS1D2)
 
 
void LoadCanSAS1D2::init() {
  LoadCanSAS1D::init();
  declareProperty(std::make_unique<PropertyWithValue<bool>>("LoadTransmission", false, Direction::Input),
                  "Load the transmission related data from the file if it is present "
                  "(optional, default False).");
}
 
void LoadCanSAS1D2::exec() {
  LoadCanSAS1D::exec();
  bool loadTrans = getProperty("LoadTransmission");
  if (!loadTrans)
    return; // all done. It is not to load the transmission, nor check if it
            // exists.
  if (trans_gp.empty() && trans_can_gp.empty()) {
    return; // all done, not transmission inside
  }
 
  std::string out_wsname = this->getProperty("OutputWorkspace");
  processTransmission(trans_gp, "sample", out_wsname);
  processTransmission(trans_can_gp, "can", out_wsname);
}
 
void LoadCanSAS1D2::processTransmission(const std::vector<MatrixWorkspace_sptr> &trans_gp,
                                        const std::string &trans_name, const std::string &output_name) {
 
  std::string trans_wsname = std::string(output_name).append("_trans_").append(trans_name);
  const std::string fileName = getPropertyValue("Filename");
 
  std::string propertyWS;
  if (trans_name == "sample")
    propertyWS = "TransmissionWorkspace";
  else
    propertyWS = "TransmissionCanWorkspace";
  const std::string doc = "The transmission workspace";
 
  if (trans_gp.size() == 1) {
    MatrixWorkspace_sptr WS = trans_gp[0];
    WS->mutableRun().addProperty("Filename", fileName);
    declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>(propertyWS, trans_wsname, Direction::Output),
                    doc);
 
    setProperty(propertyWS, WS);
  } else if (trans_gp.size() > 1) {
    WorkspaceGroup_sptr group(new WorkspaceGroup);
    for (unsigned int i = 0; i < trans_gp.size(); i++) {
      MatrixWorkspace_sptr newWork = trans_gp[i];
 
      newWork->mutableRun().addProperty("Filename", fileName);
      std::stringstream pname;
      std::stringstream name;
      pname << propertyWS << i;
      name << trans_wsname << i;
      declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>(pname.str(), name.str(), Direction::Output),
                      doc);
      setProperty(pname.str(), newWork);
      group->addWorkspace(newWork);
    }
    std::string pname = std::string(propertyWS).append("GP");
    declareProperty(std::make_unique<WorkspaceProperty<WorkspaceGroup>>(pname, trans_wsname, Direction::Output), doc);
    setProperty(pname, group);
  }
}
 
MatrixWorkspace_sptr LoadCanSAS1D2::loadEntry(Poco::XML::Node *const workspaceData, std::string &runName) {
  MatrixWorkspace_sptr main_out = LoadCanSAS1D::loadEntry(workspaceData, runName);
  bool loadTrans = getProperty("LoadTransmission");
  if (!loadTrans)
    return main_out; // all done. It is not to load the transmission, nor check
                     // if it exists.
 
  auto *workspaceElem = dynamic_cast<Element *>(workspaceData);
  //  check(workspaceElem, "<SASentry>"); // already done at
  //  LoadCanSAS1D::loadEntry
  Poco::AutoPtr<NodeList> sasTransList = workspaceElem->getElementsByTagName("SAStransmission_spectrum");
  if (!sasTransList->length()) {
    g_log.warning() << "There is no transmission data for this file " << getPropertyValue("Filename") << '\n';
    return main_out;
  }
 
  for (unsigned short trans_index = 0; trans_index < sasTransList->length(); trans_index++) {
    // foreach SAStransmission_spectrum
    Node *idataElem = sasTransList->item(trans_index);
    auto *sasTrasElem = dynamic_cast<Element *>(idataElem);
    if (!sasTrasElem)
      continue;
    std::vector<API::MatrixWorkspace_sptr> &group =
        (sasTrasElem->getAttribute("name") == "sample") ? trans_gp : trans_can_gp;
 
    // getting number of Tdata elements in the xml file
    Poco::AutoPtr<NodeList> tdataElemList = sasTrasElem->getElementsByTagName("Tdata");
    size_t nBins = tdataElemList->length();
 
    MatrixWorkspace_sptr dataWS = WorkspaceFactory::Instance().create("Workspace2D", 1, nBins, nBins);
 
    createLogs(workspaceElem, dataWS);
 
    std::string title = main_out->getTitle();
    title += ":trans";
    title += sasTrasElem->getAttribute("name");
    dataWS->setTitle(title);
    dataWS->setDistribution(true);
    dataWS->setYUnit("");
 
    // load workspace data
    auto &X = dataWS->mutableX(0);
    auto &Y = dataWS->mutableY(0);
    auto &E = dataWS->mutableE(0);
    int vecindex = 0;
    // iterate through each Tdata element  and get the values of "Lambda",
    //"T" and "Tdev" text nodes and fill X,Y,E vectors
    for (unsigned long index = 0; index < nBins; ++index) {
      idataElem = tdataElemList->item(index);
      auto *elem = dynamic_cast<Element *>(idataElem);
      if (elem) {
        // setting X vector
        std::string nodeVal;
        Element *qElem = elem->getChildElement("Lambda");
        check(qElem, "Lambda");
        nodeVal = qElem->innerText();
        std::stringstream x(nodeVal);
        double d;
        x >> d;
        X[vecindex] = d;
 
        // setting Y vector
        Element *iElem = elem->getChildElement("T");
        check(qElem, "T");
        nodeVal = iElem->innerText();
        std::stringstream y(nodeVal);
        y >> d;
        Y[vecindex] = d;
 
        // setting the error vector
        Element *idevElem = elem->getChildElement("Tdev");
        if (idevElem) {
          check(qElem, "Tdev");
          nodeVal = idevElem->innerText();
          std::stringstream e(nodeVal);
          e >> d;
          E[vecindex] = d;
        } else {
          E[vecindex] = std::sqrt(d);
        }
 
        ++vecindex;
      }
    }
 
    runLoadInstrument(main_out->getInstrument()->getName(), dataWS);
    dataWS->getAxis(0)->setUnit("Wavelength");
 
    // add to group
    group.emplace_back(dataWS);
  }
  return main_out;
}
} // namespace Mantid::DataHandling