Пример #1
0
/**
Make dimensions from the currently selected input workspace. Also fills
the inputs with default values.
@param propertyPrefix: The prefix for the property in the algorithm, i.e.
AxisAligned.
@param owningLayout: The layout that will take ownership of the widgets once
generated.
@param format: function pointer to the formatting function
@param history : Whether to remember of forget property history.
*/
void SlicingAlgorithmDialog::makeDimensionInputs(
    const QString &propertyPrefix, QLayout *owningLayout,
    QString (*format)(IMDDimension_const_sptr), History history) {
  // Remove excess dimensions from the tied properties and the stored property
  // values
  size_t indexRemoved = 0;
  QString propertyNameRemoved = propertyPrefix;
  propertyNameRemoved.append(QString().number(indexRemoved));
  Mantid::Kernel::Property *propertyRemoved =
      getAlgorithmProperty(propertyNameRemoved);

  while (propertyRemoved) {
    untie(propertyNameRemoved);
    removePropertyValue(propertyNameRemoved);

    indexRemoved++;
    propertyNameRemoved = propertyPrefix;
    propertyNameRemoved.append(QString().number(indexRemoved));
    propertyRemoved = getAlgorithmProperty(propertyNameRemoved);
  }

  const QString &txt = getCurrentInputWorkspaceName();
  if (!txt.isEmpty()) {
    IMDWorkspace_sptr ws = boost::dynamic_pointer_cast<IMDWorkspace>(
        AnalysisDataService::Instance().retrieve(txt.toStdString()));

    size_t nDimensions = ws->getNumDims();

    for (size_t index = 0; index < nDimensions; ++index) {
      Mantid::Geometry::IMDDimension_const_sptr dim = ws->getDimension(index);

      // Configure the label
      QString propertyName = propertyPrefix;
      propertyName.append(QString().number(index));

      QLabel *dimensionLabel = new QLabel(propertyName);

      // Configure the default input.
      const QString dimensionInfo = format(dim);

      QLineEdit *txtDimension = new QLineEdit(dimensionInfo);

      // Create a widget to contain the dimension components.
      QHBoxLayout *layout = new QHBoxLayout;
      QWidget *w = new QWidget;
      w->setLayout(layout);

      tie(txtDimension, propertyName, layout, (history == Remember));

      // Add components to the layout.
      layout->addWidget(dimensionLabel);
      layout->addWidget(txtDimension);

      owningLayout->addWidget(w);
    }
  }
}
Пример #2
0
/**
* Load all of the affine matrices from the file, create the
* appropriate coordinate transform and set those on the workspace.
* @param ws : workspace to set the coordinate transforms on
*/
void LoadMD::loadAffineMatricies(IMDWorkspace_sptr ws) {
  std::map<std::string, std::string> entries;
  m_file->getEntries(entries);

  if (entries.find("transform_to_orig") != entries.end()) {
    CoordTransform *transform = this->loadAffineMatrix("transform_to_orig");
    ws->setTransformToOriginal(transform);
  }
  if (entries.find("transform_from_orig") != entries.end()) {
    CoordTransform *transform = this->loadAffineMatrix("transform_from_orig");
    ws->setTransformFromOriginal(transform);
  }
}
Пример #3
0
MantidMDCurveDialog::MantidMDCurveDialog(QWidget *parent, QString wsName)
    : QDialog(parent), m_wsName(wsName) {
  ui.setupUi(this);
  m_lineOptions = new LinePlotOptions(this);
  ui.mainLayout->insertWidget(0, m_lineOptions);

  // To set the right dimension labels
  IMDWorkspace_sptr ws = boost::dynamic_pointer_cast<IMDWorkspace>(
      AnalysisDataService::Instance().retrieve(m_wsName.toStdString()));
  if (ws) {
    // Retrieve the original workspace. Prefer the "intermediate" one if
    // available.
    if (ws->hasOriginalWorkspace())
      ws = boost::dynamic_pointer_cast<IMDWorkspace>(
          ws->getOriginalWorkspace(ws->numOriginalWorkspaces() - 1));
    if (ws)
      m_lineOptions->setOriginalWorkspace(ws);
  }

  // Connect the button slots
  QMetaObject::connectSlotsByName(this);
}
Пример #4
0
std::map<std::string, std::string> MaskMD::validateInputs() {
  // Create the map
  std::map<std::string, std::string> validation_output;

  // Get properties to validate
  IMDWorkspace_sptr ws = getProperty("Workspace");
  std::string dimensions_string = getPropertyValue("Dimensions");
  std::vector<double> extents = getProperty("Extents");

  std::vector<std::string> dimensions = parseDimensionNames(dimensions_string);

  std::stringstream messageStream;

  // Check named dimensions can be found in workspace
  for (const auto &dimension_name : dimensions) {
    try {
      tryFetchDimensionIndex(ws, dimension_name);
    } catch (const std::runtime_error &) {
      messageStream << "Dimension '" << dimension_name << "' not found. ";
    }
  }
  if (messageStream.rdbuf()->in_avail() != 0) {
    validation_output["Dimensions"] = messageStream.str();
    messageStream.str(std::string());
  }

  size_t nDims = ws->getNumDims();
  size_t nDimensionIds = dimensions.size();

  // Check cardinality on names/ids
  if (nDimensionIds % nDims != 0) {
    messageStream << "Number of dimension ids/names must be n * " << nDims
                  << ". The following names were given: ";
    for (const auto &name : dimensions) {
      messageStream << name << ", ";
    }

    validation_output["Dimensions"] = messageStream.str();
    messageStream.str(std::string());
  }

  // Check cardinality on extents
  if (extents.size() != (2 * dimensions.size())) {
    messageStream << "Number of extents must be " << 2 * dimensions.size()
                  << ". ";
    validation_output["Extents"] = messageStream.str();
  }
  // Check extent value provided.
  for (size_t i = 0; (i < nDimensionIds) && ((i * 2 + 1) < extents.size());
       ++i) {
    double min = extents[i * 2];
    double max = extents[(i * 2) + 1];
    if (min > max) {
      messageStream << "Cannot have minimum extents " << min
                    << " larger than maximum extents " << max << ". ";
      validation_output["Extents"] = messageStream.str();
    }
  }

  return validation_output;
}
Пример #5
0
/** Execute the algorithm.
 */
void MaskMD::exec() {
  IMDWorkspace_sptr ws = getProperty("Workspace");
  std::string dimensions_string = getPropertyValue("Dimensions");
  std::vector<double> extents = getProperty("Extents");

  // Dimension names may contain brackets with commas (i.e. [H,0,0])
  // so getProperty would return an incorrect vector of names;
  // instead get the string and parse it here
  std::vector<std::string> dimensions = parseDimensionNames(dimensions_string);
  // Report what dimension names were found
  g_log.debug() << "Dimension names parsed as: \n";
  for (const auto &name : dimensions) {
    g_log.debug() << name << '\n';
  }

  size_t nDims = ws->getNumDims();
  size_t nDimensionIds = dimensions.size();

  size_t nGroups = nDimensionIds / nDims;

  bool bClearExistingMasks = getProperty("ClearExistingMasks");
  if (bClearExistingMasks) {
    ws->clearMDMasking();
  }
  this->interruption_point();
  this->progress(0.0);

  // Explicitly cast nGroups and group to double to avoid compiler warnings
  // loss of precision does not matter as we are only using the result
  // for reporting algorithm progress
  const double nGroups_double = static_cast<double>(nGroups);
  // Loop over all groups
  for (size_t group = 0; group < nGroups; ++group) {
    std::vector<InputArgument> arguments(nDims);

    // Loop over all arguments within the group. and construct InputArguments
    // for sorting.
    for (size_t i = 0; i < nDims; ++i) {
      size_t index = i + (group * nDims);
      InputArgument &arg = arguments[i];

      // Try to get the index of the dimension in the workspace.
      arg.index = tryFetchDimensionIndex(ws, dimensions[index]);

      arg.min = extents[index * 2];
      arg.max = extents[(index * 2) + 1];
    }

    // Sort all the inputs by the dimension index. Without this it will not be
    // possible to construct the MDImplicit function property.
    LessThanIndex comparator;
    std::sort(arguments.begin(), arguments.end(), comparator);

    // Create inputs for a box implicit function
    VMD mins(nDims);
    VMD maxs(nDims);
    for (size_t i = 0; i < nDims; ++i) {
      mins[i] = float(arguments[i].min);
      maxs[i] = float(arguments[i].max);
    }

    // Add new masking.
    ws->setMDMasking(new MDBoxImplicitFunction(mins, maxs));
    this->interruption_point();
    double group_double = static_cast<double>(group);
    this->progress(group_double / nGroups_double);
  }
  this->progress(1.0); // Ensure algorithm progress is reported as complete
}
Пример #6
0
//----------------------------------------------------------------------------------------------
/// Run the algorithm
void QueryMDWorkspace::exec() {
    // Extract the required normalisation.
    std::string strNormalisation = getPropertyValue("Normalisation");
    MDNormalization requestedNormalisation = whichNormalisation(strNormalisation);

    IMDWorkspace_sptr input = getProperty("InputWorkspace");

    const bool transformCoordsToOriginal = getProperty("TransformCoordsToOriginal");

    // Define a table workspace with a specific column schema.
    ITableWorkspace_sptr output = WorkspaceFactory::Instance().createTable();
    const std::string signalColumnName = "Signal/" + strNormalisation;
    const std::string errorColumnName = "Error/" + strNormalisation;
    output->addColumn("double", signalColumnName);
    output->addColumn("double", errorColumnName);
    output->addColumn("int", "Number of Events");

    const size_t ndims = input->getNumDims();
    for (size_t index = 0; index < ndims; ++index) {
        Mantid::Geometry::IMDDimension_const_sptr dim = input->getDimension(index);
        std::string dimInUnit = dim->getName() + "/" + dim->getUnits().ascii();
        output->addColumn("double", dimInUnit);
        // Magic numbers required to configure the X axis.
        output->getColumn(dimInUnit)->setPlotType(1);
    }

    // Magic numbers required to configure the Y axis.
    output->getColumn(signalColumnName)->setPlotType(2);
    output->getColumn(errorColumnName)->setPlotType(5);

    IMDIterator *it = input->createIterator();
    it->setNormalization(requestedNormalisation);

    bool bLimitRows = getProperty("LimitRows");
    int maxRows = 0;
    if (bLimitRows) {
        maxRows = getProperty("MaximumRows");
    }

    // Use the iterator to loop through each MDBoxBase and create a row for each
    // entry.
    int rowCounter = 0;

    Progress progress(this, 0, 1, int64_t(input->getNPoints()));
    while (true) {
        size_t cellIndex = 0;
        output->appendRow();
        output->cell<double>(rowCounter, cellIndex++) = it->getNormalizedSignal();
        output->cell<double>(rowCounter, cellIndex++) = it->getNormalizedError();
        output->cell<int>(rowCounter, cellIndex++) = int(it->getNumEvents());
        VMD center = it->getCenter();
        const size_t numberOriginal = input->getNumberTransformsToOriginal();
        if (transformCoordsToOriginal && numberOriginal > 0) {
            const size_t index = numberOriginal - 1;
            CoordTransform const *transform = input->getTransformToOriginal(index);
            VMD temp = transform->applyVMD(center);
            center = temp;
        }

        for (size_t index = 0; index < ndims; ++index) {
            output->cell<double>(rowCounter, cellIndex++) = center[index];
        }

        progress.report();
        if (!it->next() || (bLimitRows && ((rowCounter + 1) >= maxRows))) {
            break;
        }
        rowCounter++;
    }
    setProperty("OutputWorkspace", output);
    delete it;

    //
    IMDEventWorkspace_sptr mdew;
    CALL_MDEVENT_FUNCTION(this->getBoxData, input);
}
Пример #7
0
/** Execute the algorithm.
 */
void MaskMD::exec() {
  IMDWorkspace_sptr ws = getProperty("Workspace");
  std::vector<std::string> dimensions = getProperty("Dimensions");
  std::vector<double> extents = getProperty("Extents");

  size_t nDims = ws->getNumDims();
  size_t nDimensionIds = dimensions.size();

  std::stringstream messageStream;

  // Check cardinality on names/ids
  if (nDimensionIds % nDims != 0) {
    messageStream << "Number of dimension ids/names must be n * " << nDims;
    this->g_log.error(messageStream.str());
    throw std::invalid_argument(messageStream.str());
  }

  // Check cardinality on extents
  if (extents.size() != (2 * dimensions.size())) {
    messageStream << "Number of extents must be " << 2 * dimensions.size();
    this->g_log.error(messageStream.str());
    throw std::invalid_argument(messageStream.str());
  }

  // Check extent value provided.
  for (size_t i = 0; i < nDimensionIds; ++i) {
    double min = extents[i * 2];
    double max = extents[(i * 2) + 1];
    if (min > max) {
      messageStream << "Cannot have minimum extents " << min
                    << " larger than maximum extents " << max;
      this->g_log.error(messageStream.str());
      throw std::invalid_argument(messageStream.str());
    }
  }

  size_t nGroups = nDimensionIds / nDims;

  bool bClearExistingMasks = getProperty("ClearExistingMasks");
  if (bClearExistingMasks) {
    ws->clearMDMasking();
  }

  // Loop over all groups
  for (size_t group = 0; group < nGroups; ++group) {
    std::vector<InputArgument> arguments(nDims);

    // Loop over all arguments within the group. and construct InputArguments
    // for sorting.
    for (size_t i = 0; i < nDims; ++i) {
      size_t index = i + (group * nDims);
      InputArgument &arg = arguments[i];

      // Try to get the index of the dimension in the workspace.
      arg.index = tryFetchDimensionIndex(ws, dimensions[index]);

      arg.min = extents[index * 2];
      arg.max = extents[(index * 2) + 1];
    }

    // Sort all the inputs by the dimension index. Without this it will not be
    // possible to construct the MDImplicit function propertly.
    LessThanIndex comparitor;
    std::sort(arguments.begin(), arguments.end(), comparitor);

    // Create inputs for a box implicit function
    VMD mins(nDims);
    VMD maxs(nDims);
    for (size_t i = 0; i < nDims; ++i) {
      mins[i] = float(arguments[i].min);
      maxs[i] = float(arguments[i].max);
    }

    // Add new masking.
    ws->setMDMasking(new MDBoxImplicitFunction(mins, maxs));
  }
}