SlicingAlgorithmDialog.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 "MantidQtWidgets/Common/SlicingAlgorithmDialog.h"
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/IMDEventWorkspace.h"
#include "MantidQtWidgets/Common/AlgorithmInputHistory.h"
 
#include <QDir>
#include <QFileDialog>
#include <QIntValidator>
#include <QSettings>
 
using namespace Mantid::API;
using namespace Mantid::Geometry;
 
namespace MantidQt {
namespace MantidWidgets {
DECLARE_DIALOG(SliceMDDialog)
DECLARE_DIALOG(BinMDDialog)
 
 
SlicingAlgorithmDialog::SlicingAlgorithmDialog(QWidget *parent) : AlgorithmDialog(parent) {}
 
void SlicingAlgorithmDialog::initLayout() {
  ui.setupUi(this);
  this->setWindowTitle(m_algName);
 
  loadSettings();
 
  // Tie core widgets to core properties.
  tie(ui.workspace_selector, "InputWorkspace", ui.input_layout);
  tie(ui.ck_axis_aligned, "AxisAligned");
  tie(ui.txt_output, "OutputWorkspace", ui.output_layout);
  tie(ui.txt_output_extents, "OutputExtents", ui.output_extents_layout);
  tie(ui.txt_output_bins, "OutputBins", ui.output_bins_layout);
  tie(ui.ck_normalisebasisvectors, "NormalizeBasisVectors");
  tie(ui.ck_force_orthogonal, "ForceOrthogonal");
  tie(ui.txt_translation, "Translation");
 
  ui.txt_memory->setValidator(new QIntValidator(this));
  ui.txt_resursion_depth->setValidator(new QIntValidator(this));
 
  /*
   Do not need to connect up Accept/Reject. This gets done automatically, and
   the AlgorithmDialog base class
   handles the slots.
   */
  connect(ui.workspace_selector, SIGNAL(activated(int)), this, SLOT(onWorkspaceChanged()));
  connect(ui.ck_axis_aligned, SIGNAL(clicked(bool)), this, SLOT(onAxisAlignedChanged(bool)));
  connect(ui.ck_max_from_input, SIGNAL(clicked(bool)), this, SLOT(onMaxFromInput(bool)));
  connect(ui.ck_calculate, SIGNAL(clicked(bool)), this, SLOT(onCalculateChanged(bool)));
  connect(ui.btn_browse, SIGNAL(clicked()), this, SLOT(onBrowse()));
  connect(ui.btn_help, SIGNAL(clicked()), this, SLOT(helpClicked()));
  connect(ui.btn_calculate, SIGNAL(clicked()), this, SLOT(onRebuildDimensions()));
 
  // Configure workspace selector
  ui.workspace_selector->setValidatingAlgorithm(m_algName);
  ui.workspace_selector->clear();
  auto names = AnalysisDataService::Instance().getObjectNames();
  auto it = names.begin();
  while (it != names.end()) {
    IMDEventWorkspace_sptr ws =
        std::dynamic_pointer_cast<IMDEventWorkspace>(AnalysisDataService::Instance().retrieve(*it));
    if (ws) {
      ui.workspace_selector->addItem((*it).c_str());
    }
    ++it;
  }
  QString lastUsedInputWorkspaceName = getHistoricalInputWorkspaceName();
  int index = ui.workspace_selector->findText(lastUsedInputWorkspaceName);
  if (index >= 0) {
    ui.workspace_selector->setCurrentIndex(index);
  }
 
  // Derived algorithms may use this to apply any additional ties.
  customiseInitLayout();
 
  // Dynamically create the input dimensions.
  buildDimensionInputs(this->doAutoFillDimensions());
}
 
SlicingAlgorithmDialog::~SlicingAlgorithmDialog() { saveSettings(); }
 
QString formattedAlignedDimensionInput(const Mantid::Geometry::IMDDimension_const_sptr &dim) {
  QString min, max, nbins, result;
  QString name(dim->getName().c_str());
  min.setNum(dim->getMinimum());
  max.setNum(dim->getMaximum());
  nbins.setNum(dim->getNBins());
  result.append(name).append(",").append(min).append(",").append(max).append(",").append(nbins);
  return result;
}
 
QString formatNonAlignedDimensionInput(const Mantid::Geometry::IMDDimension_const_sptr & /*unused*/) {
  // Deliberately return an empty string here, because it's not obvious how the
  // basis vectors could be automatically formed.
  return QString("");
}
 
void SlicingAlgorithmDialog::cleanLayoutOfDimensions(QLayout *layout) {
  int itemCount = layout->count();
  for (int i = 0; i < itemCount; ++i) {
    QLayoutItem *pLayoutItem = layout->itemAt(i);
    QWidget *pWidget = pLayoutItem->widget();
    if (pWidget != nullptr) {
      // The label text contains the property name.
      auto *propertyLabel = dynamic_cast<QLabel *>(pWidget->layout()->itemAt(0)->widget());
      untie(propertyLabel->text());
      pWidget->setHidden(true);
      this->layout()->removeItem(pLayoutItem);
    }
  }
}
 
void SlicingAlgorithmDialog::clearExistingDimensions() {
  QLayout *alignedLayout = this->ui.axis_aligned_layout->layout();
  QLayout *nonAlignedLayout = this->ui.non_axis_aligned_layout->layout();
 
  cleanLayoutOfDimensions(alignedLayout);
  cleanLayoutOfDimensions(nonAlignedLayout);
}
 
bool SlicingAlgorithmDialog::doAxisAligned() const { return ui.ck_axis_aligned->isChecked(); }
 
QString SlicingAlgorithmDialog::getCurrentInputWorkspaceName() const { return ui.workspace_selector->currentText(); }
 
QString SlicingAlgorithmDialog::getCurrentOutputWorkspaceName() const { return ui.txt_output->text(); }
 
QString SlicingAlgorithmDialog::getHistoricalInputWorkspaceName() const {
  return MantidQt::API::AlgorithmInputHistory::Instance().previousInput(m_algName, "InputWorkspace");
}
 
SlicingAlgorithmDialog::HistoryChanged SlicingAlgorithmDialog::hasDimensionHistoryChanged() const {
  SlicingAlgorithmDialog::HistoryChanged result = HasNotChanged;
 
  const QString &currentWorkspaceName = getCurrentInputWorkspaceName();
  const QString previousInputWorkspaceName =
      MantidQt::API::AlgorithmInputHistory::Instance().previousInput(m_algName, "InputWorkspace");
  if (currentWorkspaceName.isEmpty()) {
    result = HasChanged; // Force a rebuild because the dialog cant find any
                         // eligable input workspaces. That's why there is an
                         // empty entry.
  } else if (AnalysisDataService::Instance().doesExist(previousInputWorkspaceName.toStdString())) {
    const auto oldWS =
        AnalysisDataService::Instance().retrieveWS<IMDWorkspace>(previousInputWorkspaceName.toStdString());
    const auto newWS = AnalysisDataService::Instance().retrieveWS<IMDWorkspace>(currentWorkspaceName.toStdString());
    if (oldWS->getNumDims() != newWS->getNumDims()) {
      result = HasChanged;
    }
  }
 
  return result;
}
 
SlicingAlgorithmDialog::History SlicingAlgorithmDialog::useHistory(const HistoryChanged &criticalChange,
                                                                   const bool bForceForget) {
  History history;
  if (criticalChange == HasChanged || bForceForget) {
    history = Forget;
  } else {
    history = Remember;
  }
  return history;
}
 
/*
Decide and command the type of dimension inputs to provide.
@param bForceForget : Force the use of inputworkspace dimensions when
configuring the dialog.
*/
void SlicingAlgorithmDialog::buildDimensionInputs(const bool bForceForget) {
  clearExistingDimensions();
  const bool axisAligned = doAxisAligned();
  ui.non_axis_aligned_layout->setEnabled(!axisAligned);
 
  HistoryChanged criticalChange = this->hasDimensionHistoryChanged();
  History useHistory = this->useHistory(criticalChange, bForceForget);
 
  if (axisAligned) {
    makeDimensionInputs("AlignedDim", this->ui.axis_aligned_layout->layout(), formattedAlignedDimensionInput,
                        useHistory);
  } else {
    makeDimensionInputs("BasisVector", this->ui.non_axis_aligned_layout->layout(), formatNonAlignedDimensionInput,
                        Remember);
  }
}
 
void SlicingAlgorithmDialog::makeDimensionInputs(const QString &propertyPrefix, QLayout *owningLayout,
                                                 QString (*format)(const 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 =
        std::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);
 
      auto *txtDimension = new QLineEdit(dimensionInfo);
 
      // Create a widget to contain the dimension components.
      auto *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);
    }
  }
}
 
void SlicingAlgorithmDialog::saveSettings() {
  QSettings settings;
  settings.beginGroup("Mantid/SlicingAlgorithm");
  settings.setValue("AlwaysCalculateExtents", (this->doAutoFillDimensions() ? 1 : 0));
  settings.endGroup();
}
 
void SlicingAlgorithmDialog::loadSettings() {
  QSettings settings;
  settings.beginGroup("Mantid/SlicingAlgorithm");
 
  const bool alwaysCalculateExtents = settings.value("AlwaysCalculateExtents", 1).toInt();
  ui.ck_calculate->setChecked(alwaysCalculateExtents);
 
  settings.endGroup();
}
 
void SlicingAlgorithmDialog::onWorkspaceChanged() { buildDimensionInputs(this->doAutoFillDimensions()); }
 
void SlicingAlgorithmDialog::onAxisAlignedChanged(bool /*unused*/) {
  buildDimensionInputs(this->doAutoFillDimensions());
}
 
void SlicingAlgorithmDialog::onMaxFromInput(bool /*unused*/) {
  const bool takeFromInputWorkspace = ui.ck_max_from_input->isChecked();
  ui.txt_resursion_depth->setEnabled(!takeFromInputWorkspace);
  ui.lbl_resursion_depth->setEnabled(!takeFromInputWorkspace);
}
 
void SlicingAlgorithmDialog::onRebuildDimensions() { buildDimensionInputs(true); }
 
void SlicingAlgorithmDialog::onCalculateChanged(bool /*unused*/) {
  if (ui.ck_axis_aligned->isChecked())
    buildDimensionInputs(true);
}
 
void SlicingAlgorithmDialog::onBrowse() {
  QFileDialog dialog;
  dialog.setDirectory(QDir::homePath());
  dialog.setNameFilter("Nexus files (*.nxs)");
  if (dialog.exec()) {
    ui.txt_filename->setText(dialog.selectedFiles().front());
  }
}
 
/*
Perform tasks that are almost identical for derived types except for visibility
switch.
@isSliceMD. Is the calling method from SliceMD.
*/
void SlicingAlgorithmDialog::commonSliceMDSetup(const bool isSliceMD) {
  ui.file_backend_layout->setVisible(isSliceMD);
  ui.ck_max_from_input->setVisible(isSliceMD);
  ui.lbl_resursion_depth->setVisible(isSliceMD);
  ui.txt_resursion_depth->setVisible(isSliceMD);
  ui.ck_parallel->setVisible(!isSliceMD);
}
 
bool SlicingAlgorithmDialog::doAutoFillDimensions() const { return ui.ck_calculate->isChecked(); }
 
/*---------------------------------------------------------------------------------------------
SliceMDDialog Methods
---------------------------------------------------------------------------------------------*/
void SliceMDDialog::customiseInitLayout() {
  commonSliceMDSetup(true);
 
  // Tie the widgets to properties
  tie(ui.ck_max_from_input, "TakeMaxRecursionDepthFromInput");
  tie(ui.txt_resursion_depth, "MaxRecursionDepth");
  tie(ui.txt_filename, "OutputFilename");
  tie(ui.txt_memory, "Memory");
}
 
/*---------------------------------------------------------------------------------------------
End SliceMDDialog Methods
---------------------------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------------------------
BinMDDialog Methods
---------------------------------------------------------------------------------------------*/
void BinMDDialog::customiseInitLayout() {
  // Disable the stuff that doesn't relate to BinMD
  commonSliceMDSetup(false);
 
  tie(ui.ck_parallel, "Parallel");
}
 
/*---------------------------------------------------------------------------------------------
End BinMDDialog Methods
---------------------------------------------------------------------------------------------*/
} // namespace MantidWidgets
} // namespace MantidQt