MuonFitDataSelector.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/MuonFitDataSelector.h"
#include "MantidKernel/Logger.h"
 
#include "MantidQtWidgets/Common/QtPropertyBrowser/qtpropertymanager.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/qttreepropertybrowser.h"
#include <QFileInfo>
 
namespace {
Mantid::Kernel::Logger g_log("MuonFitDataSelector");
}
 
namespace MantidQt {
namespace MantidWidgets {
 
MuonFitDataSelector::MuonFitDataSelector(QWidget *parent) : MantidWidget(parent) {
  m_multiFit = false;
  m_ui.setupUi(this);
  this->setDefaultValues();
  this->setUpConnections();
  // Disable "Browse" button - use case is that first run will always be the one
  // selected on front tab. User will type in the runs they want rather than
  // using the Browse button. (If they want to "Browse" they can use front tab).
  m_ui.runs->doButtonOpt(API::FileFinderWidget::ButtonOpts::None);
}
 
MuonFitDataSelector::MuonFitDataSelector(QWidget *parent, int runNumber, const QString &instName) /*
                                  * numPeriods :: [input] Number of periods from initial workspace
                                  * groups :: [input] Group names from initial workspace
                                                                          size_t numPeriods,
                                                                          const QStringList &groups)*/
    : MuonFitDataSelector(parent) {
  m_multiFit = false;
  this->setWorkspaceDetails(QString::number(runNumber), instName, boost::optional<QString>{});
  // not used in this case
  // but leave these here as a remainder
  // for future changes that may need to assign them
 
  // this->setNumPeriods(numPeriods);
  // this->setAvailableGroups(groups);
}
 
void MuonFitDataSelector::setUpConnections() {
  connect(m_ui.runs, SIGNAL(filesFound()), this, SLOT(userChangedRuns()));
  connect(m_ui.rbCoAdd, SIGNAL(toggled(bool)), this, SLOT(fitTypeChanged(bool)));
  connect(m_ui.txtSimFitLabel, SIGNAL(editingFinished()), this, SIGNAL(simulLabelChanged()));
  connect(this, SIGNAL(workspaceChanged()), this, SLOT(checkForMultiGroupPeriodSelection()));
  connect(m_ui.cbDataset, SIGNAL(currentIndexChanged(int)), this, SIGNAL(datasetIndexChanged(int)));
  connect(m_ui.cbDataset, SIGNAL(currentIndexChanged(int)), this, SLOT(updateNormalizationFromDropDown(int)));
  connect(m_ui.btnNextDataset, SIGNAL(clicked()), this, SLOT(setNextDataset()));
  connect(m_ui.btnPrevDataset, SIGNAL(clicked()), this, SLOT(setPreviousDataset()));
}
 
void MuonFitDataSelector::fitTypeChanged(bool state) {
  (void)state;
  emit workspaceChanged();
}
 
void MuonFitDataSelector::userChangedRuns() {
  // check for single run and enable/disable radio buttons
  const auto runs = getRuns();
  if (runs.contains(',') || runs.contains('-')) {
    // record if its multi fit
    m_multiFit = true;
  } else {
    setFitType(FitType::Single);
  }
  emit workspaceChanged();
}
 
double MuonFitDataSelector::getStartTime() const {
  // Validator ensures cast to double will succeed
  return m_startX; // start.toDouble();
}
 
void MuonFitDataSelector::setStartTimeQuietly(double start) { m_startX = start; }
 
void MuonFitDataSelector::setStartTime(double start) {
  setStartTimeQuietly(start);
  emit dataPropertiesChanged();
}
 
double MuonFitDataSelector::getEndTime() const { return m_endX; }
 
void MuonFitDataSelector::setEndTimeQuietly(double end) { m_endX = end; }
 
void MuonFitDataSelector::setEndTime(double end) {
  setEndTimeQuietly(end);
  emit dataPropertiesChanged();
}
 
QStringList MuonFitDataSelector::getFilenames() const { return m_ui.runs->getFilenames(); }
 
void MuonFitDataSelector::setWorkspaceDetails(const QString &runNumbers, const QString &instName,
                                              const boost::optional<QString> &filePath) {
  // Set the file finder to the correct instrument (not Mantid's default)
  m_ui.runs->setInstrumentOverride(instName);
 
  QString runs(runNumbers);
  runs.remove(QRegExp("^[0]*")); // remove leading zeros, if any
  // Set fit type - co-add (as this comes from Home tab) or single
  if (runs.contains('-') || runs.contains(',')) {
    setFitType(FitType::CoAdd);
  } else {
    setFitType(FitType::Single);
  }
 
  // Set initial run to be run number of the workspace loaded in Home tab
  // and search for filenames. Use busy cursor until search finished.
  setBusyState();
 
  if (filePath) { // load current run: use special file path
    m_ui.runs->setUserInput(filePath.get());
    m_ui.runs->setText(runs);
  } else { // default
    m_ui.runs->setFileTextWithSearch(runs);
  }
}
 
void MuonFitDataSelector::setDefaultValues() {
  this->setStartTime(0.0);
  this->setEndTime(0.0);
  m_ui.txtSimFitLabel->setText("0");
  emit simulLabelChanged(); // make sure default "0" is set
}
QStringList MuonFitDataSelector::getPeriodSelections() const { return m_chosenPeriods; }
 
QStringList MuonFitDataSelector::getChosenGroups() const { return m_chosenGroups; }
 
QVariant MuonFitDataSelector::getUserInput() const {
  QVariant ret(QVariant::Map);
  auto map = ret.toMap();
  map.insert("Start", getStartTime());
  map.insert("End", getEndTime());
  map.insert("Runs", getRuns());
  map.insert("Groups", getChosenGroups());
  map.insert("Periods", getPeriodSelections());
  return map;
}
 
void MuonFitDataSelector::setUserInput(const QVariant &value) {
  if (value.canConvert(QVariant::Map)) {
    const auto map = value.toMap();
    if (map.contains("Start")) {
      setStartTime(map.value("Start").toDouble());
    }
    if (map.contains("End")) {
      setEndTime(map.value("End").toDouble());
    }
  }
}
 
IMuonFitDataSelector::FitType MuonFitDataSelector::getFitType() const {
  // If radio buttons disabled, it's a single fit unless multiple groups/periods
  // chosen
  if (!m_multiFit) {
    return m_chosenGroups.size() <= 1 && m_chosenPeriods.size() <= 1 ? FitType::Single : FitType::Simultaneous;
  } else {
    // which button is selected
    if (m_ui.rbCoAdd->isChecked()) {
      return FitType::CoAdd;
    } else {
      return FitType::Simultaneous;
    }
  }
}
 
void MuonFitDataSelector::setFitType(IMuonFitDataSelector::FitType type) {
  if (type == FitType::Single) {
    m_multiFit = false;
  } else {
    m_multiFit = true;
 
    m_ui.rbCoAdd->setChecked(type == FitType::CoAdd);
    m_ui.rbSimultaneous->setChecked(type == FitType::Simultaneous);
  }
  checkForMultiGroupPeriodSelection();
}
QString MuonFitDataSelector::getInstrumentName() const { return m_ui.runs->getInstrumentOverride(); }
 
QString MuonFitDataSelector::getRuns() const {
  if (m_ui.runs->isValid()) {
    return m_ui.runs->getText();
  } else {
    return "";
  }
}
 
void MuonFitDataSelector::unsetBusyState() {
  disconnect(m_ui.runs, SIGNAL(fileInspectionFinished()), this, SLOT(unsetBusyState()));
  this->setCursor(Qt::ArrowCursor);
}
 
void MuonFitDataSelector::setBusyState() {
  connect(m_ui.runs, SIGNAL(fileInspectionFinished()), this, SLOT(unsetBusyState()));
  this->setCursor(Qt::WaitCursor);
}
 
QString MuonFitDataSelector::getSimultaneousFitLabel() const { return m_ui.txtSimFitLabel->text(); }
 
void MuonFitDataSelector::setSimultaneousFitLabel(const QString &label) {
  // do some checks that it is valid
  auto safeLabel = label;
  if (label.indexOf(".") >= 0) {
    QFileInfo file(label);
    safeLabel = file.baseName();
    // trim instrument name
    auto index = safeLabel.indexOf("0");
    safeLabel = safeLabel.mid(index);
    // trim leading zeros
    safeLabel = safeLabel.remove(QRegExp("^[0]*"));
  }
  m_ui.txtSimFitLabel->setText(safeLabel);
}
 
void MuonFitDataSelector::checkForMultiGroupPeriodSelection() {
  m_ui.txtSimFitLabel->setEnabled(m_chosenGroups.size() > 1 || m_chosenPeriods.size() > 1 ||
                                  getFitType() == FitType::Simultaneous);
}
 
int MuonFitDataSelector::getDatasetIndex() const { return m_ui.cbDataset->currentIndex(); }
 
QString MuonFitDataSelector::getDatasetName() const { return m_ui.cbDataset->currentText(); }
 
void MuonFitDataSelector::setDatasetNames(const QStringList &datasetNames) {
  const auto selectedName = m_ui.cbDataset->currentText();
  // Turn off signals while names are updated
  m_ui.cbDataset->blockSignals(true);
  m_ui.cbDataset->clear();
  m_ui.cbDataset->addItems(datasetNames);
  m_ui.cbDataset->blockSignals(false);
 
  // If previously selected name is in new list, set this index again.
  int i = 0;
  while (i < m_ui.cbDataset->count()) {
    if (m_ui.cbDataset->itemText(i) == selectedName) {
      m_ui.cbDataset->setCurrentIndex(i);
      break;
    }
    i++;
  }
  // Otherwise select the first in the list.
  if (i == m_ui.cbDataset->count()) {
    m_ui.cbDataset->setCurrentIndex(0);
  }
}
void MuonFitDataSelector::updateNormalizationFromDropDown(int j) {
  for (int i = 0; i < m_ui.cbDataset->count(); i++) {
    if (i == j) {
      auto name = m_ui.cbDataset->itemText(i);
      emit nameChanged(name);
      return;
    }
  }
}
void MuonFitDataSelector::setPreviousDataset() {
  const int index = m_ui.cbDataset->currentIndex();
  if (index > 0) {
    m_ui.cbDataset->setCurrentIndex(index - 1);
  }
}
 
void MuonFitDataSelector::setNextDataset() {
  const int index = m_ui.cbDataset->currentIndex();
  const int maxIndex = m_ui.cbDataset->count() - 1;
  if (index < maxIndex) {
    m_ui.cbDataset->setCurrentIndex(index + 1);
  }
}
 
bool MuonFitDataSelector::askUserWhetherToOverwrite() {
  const int choice =
      QMessageBox::question(this, tr("MantidPlot - Overwrite Warning"),
                            getSimultaneousFitLabel() + tr(" already exists. Do you want to replace it?"),
                            QMessageBox::Yes | QMessageBox::Default, QMessageBox::No | QMessageBox::Escape);
 
  return choice == QMessageBox::Yes;
}
 
} // namespace MantidWidgets
} // namespace MantidQt