CreateDummyCalFile.cpp

//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAlgorithms/CreateDummyCalFile.h"
#include "MantidAPI/FileProperty.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/ConfigService.h"
#include "MantidAPI/InstrumentDataService.h"
#include "MantidGeometry/Instrument/IDFObject.h"

#include <queue>
#include <fstream>
#include <iomanip>
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/detail/classification.hpp>

using Poco::XML::DOMParser;
using Poco::XML::Document;
using Poco::XML::Element;

namespace Mantid {
namespace Algorithms {

// Register the class into the algorithm factory
DECLARE_ALGORITHM(CreateDummyCalFile)

using namespace Kernel;
using namespace API;
using namespace Geometry;
using namespace DataObjects;

CreateDummyCalFile::CreateDummyCalFile() : API::Algorithm() {}

/** Initialisation method. Declares properties to be used in algorithm.
 *
 */
void CreateDummyCalFile::init() {
  declareProperty(new WorkspaceProperty<MatrixWorkspace>("InputWorkspace", "",
                                                         Direction::Input),
                  "The workspace containing the geometry to be calibrated.");
  declareProperty(
      new FileProperty("CalFilename", "", FileProperty::Save, ".cal"),
      "The name of the output [[CalFile]]");
}

/** Executes the algorithm
 *
 *  @throw Exception::FileError If the grouping file cannot be opened or read
 *successfully
 *  @throw runtime_error If unable to run one of the Child Algorithms
 *successfully
 */
void CreateDummyCalFile::exec() {
  // Get the input workspace
  MatrixWorkspace_const_sptr inputW = getProperty("InputWorkspace");
  if (!inputW)
    throw std::invalid_argument("No InputWorkspace");

  // Get some stuff from the input workspace
  Instrument_const_sptr inst = inputW->getInstrument();
  if (!inst)
    throw std::invalid_argument("The InputWorkspace does not have an instrument definition");

  std::string instname = inst->getName();

  // Get the names of groups
  groups = instname;

  // Split the names of the group and insert in a vector, throw if group empty
  std::vector<std::string> vgroups;
  boost::split(vgroups, instname,
               boost::algorithm::detail::is_any_ofF<char>(",/*"));
  if (vgroups.empty()) {
    g_log.error("Could not determine group names. Group names should be "
                "separated by / or ,");
    throw std::runtime_error("Could not determine group names. Group names "
                             "should be separated by / or ,");
  }

  // Assign incremental number to each group
  std::map<std::string, int> group_map;
  int index = 0;
  for (std::vector<std::string>::const_iterator it = vgroups.begin();
       it != vgroups.end(); ++it)
    group_map[(*it)] = ++index;

  // Not needed anymore
  vgroups.clear();

  // Find Detectors that belong to groups
  typedef boost::shared_ptr<const Geometry::ICompAssembly> sptr_ICompAss;
  typedef boost::shared_ptr<const Geometry::IComponent> sptr_IComp;
  typedef boost::shared_ptr<const Geometry::IDetector> sptr_IDet;
  std::queue<std::pair<sptr_ICompAss, int>> assemblies;
  sptr_ICompAss current =
      boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(inst);
  sptr_IDet currentDet;
  sptr_IComp currentIComp;
  sptr_ICompAss currentchild;

  int top_group, child_group;

  if (current.get()) {
    top_group = group_map[current->getName()]; // Return 0 if not in map
    assemblies.push(std::make_pair(current, top_group));
  }

  std::string filename = getProperty("CalFilename");

  // Plan to overwrite file, so do not check if it exists
  bool overwrite = false;

  int number = 0;
  Progress prog(this, 0.0, 0.8, assemblies.size());
  while (!assemblies.empty()) // Travel the tree from the instrument point
  {
    current = assemblies.front().first;
    top_group = assemblies.front().second;
    assemblies.pop();
    int nchilds = current->nelements();
    if (nchilds != 0) {
      for (int i = 0; i < nchilds; ++i) {
        currentIComp = (*(current.get()))[i]; // Get child
        currentDet = boost::dynamic_pointer_cast<const Geometry::IDetector>(
            currentIComp);
        if (currentDet.get()) // Is detector
        {
          if (overwrite) // Map will contains udet as the key
            instrcalib[currentDet->getID()] =
                std::make_pair(number++, top_group);
          else // Map will contains the entry number as the key
            instrcalib[number++] =
                std::make_pair(currentDet->getID(), top_group);
        } else // Is an assembly, push in the queue
        {
          currentchild =
              boost::dynamic_pointer_cast<const Geometry::ICompAssembly>(
                  currentIComp);
          if (currentchild.get()) {
            child_group = group_map[currentchild->getName()];
            if (child_group == 0)
              child_group = top_group;
            assemblies.push(std::make_pair(currentchild, child_group));
          }
        }
      }
    }
    prog.report();
  }
  // Write the results in a file
  saveGroupingFile(filename, overwrite);
  progress(0.2);
  return;
}

bool
CreateDummyCalFile::groupingFileDoesExist(const std::string &filename) const {
  std::ifstream file(filename.c_str());
  // Check if the file already exists
  if (!file)
    return false;
  file.close();
  std::ostringstream mess;
  mess << "Calibration file " << filename
       << " already exist. Only grouping will be modified";
  g_log.information(mess.str());
  return true;
}

/// Creates and saves the output file
void CreateDummyCalFile::saveGroupingFile(const std::string &filename,
                                          bool overwrite) const {
  std::ostringstream message;
  std::fstream outfile;
  std::fstream infile;
  if (!overwrite) // Open the file directly
  {
    outfile.open(filename.c_str(), std::ios::out);
    if (!outfile.is_open()) {
      message << "Can't open Calibration File: " << filename;
      g_log.error(message.str());
      throw std::runtime_error(message.str());
    }
  } else {
    infile.open(filename.c_str(), std::ios::in);
    std::string newfilename = filename + "2";
    outfile.open(newfilename.c_str(), std::ios::out);
    if (!infile.is_open()) {
      message << "Can't open input Calibration File: " << filename;
      g_log.error(message.str());
      throw std::runtime_error(message.str());
    }
    if (!outfile.is_open()) {
      message << "Can't open new Calibration File: " << newfilename;
      g_log.error(message.str());
      throw std::runtime_error(message.str());
    }
  }

  // Write the headers
  writeHeaders(outfile, filename, overwrite);

  if (overwrite) {
    int number, udet, select, group;
    double offset;

    std::string str;
    while (getline(infile, str)) {
      if (str.empty() || str[0] == '#') // Skip the headers
        continue;
      std::istringstream istr(str);
      istr >> number >> udet >> offset >> select >> group;
      instrcalmap::const_iterator it = instrcalib.find(udet);
      if (it == instrcalib.end()) // Not found, don't assign a group
        group = 0;
      else
        group = ((*it).second).second; // If found then assign new group
      // write to file
      writeCalEntry(outfile, number, udet, offset, select, group);
    }
  } else //
  {
    instrcalmap::const_iterator it = instrcalib.begin();
    for (; it != instrcalib.end(); ++it)
      writeCalEntry(outfile, (*it).first, ((*it).second).first, 0.0, 1,
                    ((*it).second).second);
  }

  // Closing
  outfile.close();
  if (overwrite)
    infile.close();
  return;
}

/// Writes a single calibration line to the output file
void CreateDummyCalFile::writeCalEntry(std::ostream &os, int number, int udet,
                                       double offset, int select, int group) {
  os << std::fixed << std::setw(9) << number << std::fixed << std::setw(15)
     << udet << std::fixed << std::setprecision(7) << std::setw(15) << offset
     << std::fixed << std::setw(8) << select << std::fixed << std::setw(8)
     << group << "\n";
  return;
}

/// Writes out the header to the output file
void CreateDummyCalFile::writeHeaders(std::ostream &os,
                                      const std::string &filename,
                                      bool overwrite) const {
  os << "# Diffraction focusing calibration file created by Mantid"
     << "\n";
  os << "# Detectors have been grouped using assembly names:" << groups << "\n";
  if (overwrite) {
    os << "# Template file " << filename << " has been used"
       << "\n";
    os << "# Only grouping has been changed, offset from template file have "
          "been copied"
       << "\n";
  } else
    os << "# No template file, all offsets set to 0.0 and select to 1"
       << "\n";

  os << "#  Number           UDET         offset      select  group"
     << "\n";
  return;
}

} // namespace Algorithm
} // namespace Mantid