/**
* Groups together a vector of workspaces. This is done "manually", since the
* workspaces being passed will be outside of the ADS and so the GroupWorkspaces
* alg is not an option here.
*
* @param wsList :: the list of workspaces to group
*/
API::WorkspaceGroup_sptr
Load::groupWsList(const std::vector<API::Workspace_sptr> &wsList) {
auto group = boost::make_shared<WorkspaceGroup>();
for (const auto &ws : wsList) {
WorkspaceGroup_sptr isGroup =
boost::dynamic_pointer_cast<WorkspaceGroup>(ws);
// If the ws to add is already a group, then add its children individually.
if (isGroup) {
std::vector<std::string> childrenNames = isGroup->getNames();
size_t count = 1;
for (auto childName = childrenNames.begin();
childName != childrenNames.end(); ++childName, ++count) {
Workspace_sptr childWs = isGroup->getItem(*childName);
isGroup->remove(*childName);
// childWs->setName(isGroup->getName() + "_" +
// boost::lexical_cast<std::string>(count));
group->addWorkspace(childWs);
}
// Remove the old group from the ADS
AnalysisDataService::Instance().remove(isGroup->getName());
} else {
group->addWorkspace(ws);
}
}
return group;
}
/**
* Handles the plotting of workspace post algorithm completion
*/
void Stretch::plotWorkspaces() {
WorkspaceGroup_sptr fitWorkspace;
fitWorkspace = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
m_fitWorkspaceName);
auto sigma = QString::fromStdString(fitWorkspace->getItem(0)->getName());
auto beta = QString::fromStdString(fitWorkspace->getItem(1)->getName());
// Check Sigma and Beta workspaces exist
if (sigma.right(5).compare("Sigma") == 0) {
if (beta.right(4).compare("Beta") == 0) {
// Plot Beta workspace
QString pyInput = "from mantidplot import plot2D\n";
if (m_plotType.compare("All") == 0 || m_plotType.compare("Beta") == 0) {
pyInput += "importMatrixWorkspace('";
pyInput += beta;
pyInput += "').plotGraph2D()\n";
}
// Plot Sigma workspace
if (m_plotType.compare("All") == 0 || m_plotType.compare("Sigma") == 0) {
pyInput += "importMatrixWorkspace('";
pyInput += sigma;
pyInput += "').plotGraph2D()\n";
}
m_pythonRunner.runPythonCode(pyInput);
}
} else {
g_log.error(
"Beta and Sigma workspace were not found and could not be plotted.");
}
}
/** Process WorkspaceGroup inputs.
*
* Overriden from Algorithm base class.
*
* This should be called after checkGroups(), which sets up required members.
* It goes through each member of the group(s), creates and sets an algorithm
* for each and executes them one by one.
*
* If there are several group input workspaces, then the member of each group
* is executed pair-wise.
*
* @param sourceAlg : Source algorithm
* @param vecMultiPeriodGroups : Vector of pre-identified multiperiod groups.
* @return true - if all the workspace members are executed.
*/
bool MultiPeriodGroupWorker::processGroups(
Algorithm *const sourceAlg,
const VecWSGroupType &vecMultiPeriodGroups) const {
// If we are not processing multiperiod groups, use the base behaviour.
if (vecMultiPeriodGroups.empty()) {
return false; // Indicates that this is not a multiperiod group workspace.
}
Property *outputWorkspaceProperty = sourceAlg->getProperty("OutputWorkspace");
const std::string outName = outputWorkspaceProperty->value();
const size_t nPeriods = vecMultiPeriodGroups[0]->size();
WorkspaceGroup_sptr outputWS = boost::make_shared<WorkspaceGroup>();
AnalysisDataService::Instance().addOrReplace(outName, outputWS);
double progress_proportion = 1.0 / static_cast<double>(nPeriods);
// Loop through all the periods. Create spawned algorithms of the same type as
// this to process pairs from the input groups.
for (size_t i = 0; i < nPeriods; ++i) {
const int periodNumber = static_cast<int>(i + 1);
// use create Child Algorithm that look like this one
Algorithm_sptr alg = sourceAlg->createChildAlgorithm(
sourceAlg->name(), progress_proportion * periodNumber,
progress_proportion * (1 + periodNumber), sourceAlg->isLogging(),
sourceAlg->version());
if (!alg) {
throw std::runtime_error("Algorithm creation failed.");
}
// Don't make the new algorithm a child so that it's workspaces are stored
// correctly
alg->setChild(false);
alg->setRethrows(true);
alg->initialize();
// Copy properties that aren't workspaces properties.
sourceAlg->copyNonWorkspaceProperties(alg.get(), periodNumber);
if (this->useCustomWorkspaceProperty()) {
const std::string inputWorkspaces =
createFormattedInputWorkspaceNames(i, vecMultiPeriodGroups);
// Set the input workspace property.
alg->setPropertyValue(this->m_workspacePropertyName, inputWorkspaces);
} else {
// Configure input properties that are group workspaces.
copyInputWorkspaceProperties(alg.get(), sourceAlg, periodNumber);
}
const std::string outName_i = outName + "_" + Strings::toString(i + 1);
alg->setPropertyValue("OutputWorkspace", outName_i);
// Run the spawned algorithm.
if (!alg->execute()) {
throw std::runtime_error("Execution of " + sourceAlg->name() +
" for group entry " + Strings::toString(i + 1) +
" failed.");
}
// Add the output workpace from the spawned algorithm to the group.
outputWS->add(outName_i);
}
sourceAlg->setProperty("OutputWorkspace", outputWS);
return true;
}
/**
* Handles completion of algorithm
*
* @param error True if the chain was stopped due to error
*/
void IndirectDiffractionReduction::algorithmComplete(bool error) {
// Handles completion of the diffraction algorithm chain
disconnect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this,
SLOT(algorithmComplete(bool)));
if (error) {
showInformationBox(
"Error running diffraction reduction.\nSee Results Log for details.");
return;
}
// Ungroup the output workspace if generic reducer was used
if (AnalysisDataService::Instance().doesExist(
"IndirectDiffraction_Workspaces")) {
WorkspaceGroup_sptr diffResultsGroup =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
"IndirectDiffraction_Workspaces");
m_plotWorkspaces.clear();
m_plotWorkspaces = diffResultsGroup->getNames();
diffResultsGroup->removeAll();
AnalysisDataService::Instance().remove("IndirectDiffraction_Workspaces");
}
// Enable plotting
m_uiForm.pbPlot->setEnabled(true);
m_uiForm.cbPlotType->setEnabled(true);
// Enable saving
m_uiForm.ckAscii->setEnabled(true);
m_uiForm.ckGSS->setEnabled(true);
m_uiForm.ckNexus->setEnabled(true);
m_uiForm.pbSave->setEnabled(true);
}
/**
* Handles the plotting of workspace post algorithm completion
*/
void Stretch::plotWorkspaces() {
setPlotResultIsPlotting(true);
WorkspaceGroup_sptr fitWorkspace;
fitWorkspace = getADSWorkspaceGroup(m_fitWorkspaceName);
auto sigma = QString::fromStdString(fitWorkspace->getItem(0)->getName());
auto beta = QString::fromStdString(fitWorkspace->getItem(1)->getName());
// Check Sigma and Beta workspaces exist
if (sigma.right(5).compare("Sigma") == 0 &&
beta.right(4).compare("Beta") == 0) {
QString pyInput = "from mantidplot import plot2D\n";
std::string const plotType = m_uiForm.cbPlot->currentText().toStdString();
if (plotType == "All" || plotType == "Beta") {
pyInput += "importMatrixWorkspace('";
pyInput += beta;
pyInput += "').plotGraph2D()\n";
}
if (plotType == "All" || plotType == "Sigma") {
pyInput += "importMatrixWorkspace('";
pyInput += sigma;
pyInput += "').plotGraph2D()\n";
}
m_pythonRunner.runPythonCode(pyInput);
} else {
g_log.error(
"Beta and Sigma workspace were not found and could not be plotted.");
}
setPlotResultIsPlotting(false);
}
/**
* Handles completion of the algorithm.
*
* @param error If the algorithm failed
*/
void ISISDiagnostics::algorithmComplete(bool error) {
disconnect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this,
SLOT(algorithmComplete(bool)));
if (error)
return;
WorkspaceGroup_sptr sliceOutputGroup =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
"IndirectDiagnostics_Workspaces");
if (sliceOutputGroup->size() == 0) {
g_log.warning("No result workspaces, cannot plot preview.");
return;
}
for (size_t i = 0; i < sliceOutputGroup->size(); i++) {
QString wsName =
QString::fromStdString(sliceOutputGroup->getItem(i)->name());
}
// Enable plot and save buttons
m_uiForm.pbSave->setEnabled(true);
m_uiForm.pbPlot->setEnabled(true);
// Update the preview plots
sliceAlgDone(false);
m_batchAlgoRunner->executeBatchAsync();
}
WorkspaceGroup_sptr PolarizationCorrection::execPNR(WorkspaceGroup_sptr inWS) {
size_t itemIndex = 0;
MatrixWorkspace_sptr Ip =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr Ia =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr ones = copyShapeAndFill(Ip, 1.0);
const VecDouble c_rho = getProperty(crhoLabel());
const VecDouble c_pp = getProperty(cppLabel());
const auto rho = this->execPolynomialCorrection(
ones, c_rho); // Execute polynomial expression
const auto pp = this->execPolynomialCorrection(
ones, c_pp); // Execute polynomial expression
const auto D = pp * (rho + 1);
const auto nIp = (Ip * (rho * pp + 1.0) + Ia * (pp - 1.0)) / D;
const auto nIa = (Ip * (rho * pp - 1.0) + Ia * (pp + 1.0)) / D;
// Preserve the history of the inside workspaces
nIp->history().addHistory(Ip->getHistory());
nIa->history().addHistory(Ia->getHistory());
WorkspaceGroup_sptr dataOut = boost::make_shared<WorkspaceGroup>();
dataOut->addWorkspace(nIp);
dataOut->addWorkspace(nIa);
return dataOut;
}
/**
* Handle completion of the algorithm.
*
* @param error If the algorithm failed
*/
void ResNorm::handleAlgorithmComplete(bool error) {
if (error)
return;
QString outputBase = (m_uiForm.dsResolution->getCurrentDataName()).toLower();
const int indexCut = outputBase.lastIndexOf("_");
outputBase = outputBase.left(indexCut);
outputBase += "_ResNorm";
std::string outputBaseStr = outputBase.toStdString();
WorkspaceGroup_sptr fitWorkspaces =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
outputBaseStr + "_Fit_Workspaces");
QString fitWsName("");
if (fitWorkspaces)
fitWsName =
QString::fromStdString(fitWorkspaces->getItem(m_previewSpec)->name());
// MantidPlot plotting
QString plotOptions(m_uiForm.cbPlot->currentText());
if (plotOptions == "Intensity" || plotOptions == "All")
plotSpectrum(QString::fromStdString(m_pythonExportWsName) + "_Intensity");
if (plotOptions == "Stretch" || plotOptions == "All")
plotSpectrum(QString::fromStdString(m_pythonExportWsName) + "_Stretch");
if (plotOptions == "Fit" || plotOptions == "All")
plotSpectrum(fitWsName, 0, 1);
loadFile(m_uiForm.dsResolution->getFullFilePath(),
m_uiForm.dsResolution->getCurrentDataName());
// Update preview plot
previewSpecChanged(m_previewSpec);
}
/**
* Replots the energy mini plot
*/
void ISISCalibration::calPlotEnergy()
{
if ( ! m_uiForm.leRunNo->isValid() )
{
emit showMessageBox("Run number not valid.");
return;
}
QString files = m_uiForm.leRunNo->getFilenames().join(",");
QFileInfo fi(m_uiForm.leRunNo->getFirstFilename());
QString detRange = QString::number(m_dblManager->value(m_properties["ResSpecMin"])) + ","
+ QString::number(m_dblManager->value(m_properties["ResSpecMax"]));
IAlgorithm_sptr reductionAlg = AlgorithmManager::Instance().create("ISISIndirectEnergyTransfer");
reductionAlg->initialize();
reductionAlg->setProperty("Instrument", getInstrumentConfiguration()->getInstrumentName().toStdString());
reductionAlg->setProperty("Analyser", getInstrumentConfiguration()->getAnalyserName().toStdString());
reductionAlg->setProperty("Reflection", getInstrumentConfiguration()->getReflectionName().toStdString());
reductionAlg->setProperty("InputFiles", files.toStdString());
reductionAlg->setProperty("OutputWorkspace", "__IndirectCalibration_reduction");
reductionAlg->setProperty("SpectraRange", detRange.toStdString());
reductionAlg->execute();
if(!reductionAlg->isExecuted())
{
g_log.warning("Could not generate energy preview plot.");
return;
}
WorkspaceGroup_sptr reductionOutputGroup = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>("__IndirectCalibration_reduction");
if(reductionOutputGroup->size() == 0)
{
g_log.warning("No result workspaces, cannot plot energy preview.");
return;
}
MatrixWorkspace_sptr energyWs = boost::dynamic_pointer_cast<MatrixWorkspace>(reductionOutputGroup->getItem(0));
if(!energyWs)
{
g_log.warning("No result workspaces, cannot plot energy preview.");
return;
}
const Mantid::MantidVec & dataX = energyWs->readX(0);
QPair<double, double> range(dataX.front(), dataX.back());
auto resBackground = m_uiForm.ppResolution->getRangeSelector("ResBackground");
setPlotPropertyRange(resBackground, m_properties["ResStart"], m_properties["ResEnd"], range);
m_uiForm.ppResolution->clear();
m_uiForm.ppResolution->addSpectrum("Energy", energyWs, 0);
m_uiForm.ppResolution->resizeX();
calSetDefaultResolution(energyWs);
m_uiForm.ppResolution->replot();
}
/**
* Sort members by Workspace name. The group must be in the ADS.
* @param groupName :: A group name.
*/
void AnalysisDataServiceImpl::sortGroupByName(const std::string &groupName) {
WorkspaceGroup_sptr group = retrieveWS<WorkspaceGroup>(groupName);
if (!group) {
throw std::runtime_error("Workspace " + groupName +
" is not a workspace group.");
}
group->sortMembersByName();
notificationCenter.postNotification(new GroupUpdatedNotification(groupName));
}
/** Execute the algorithm.
*/
void PolarizationCorrection::exec() {
WorkspaceGroup_sptr inWS = getProperty("InputWorkspace");
const std::string analysisMode = getProperty("PolarizationAnalysis");
const size_t nWorkspaces = inWS->size();
validateInputWorkspace(inWS);
Instrument_const_sptr instrument = fetchInstrument(inWS.get());
// Check if we need to fetch polarization parameters from the instrument's
// parameters
std::map<std::string, std::string> loadableProperties;
loadableProperties[crhoLabel()] = "crho";
loadableProperties[cppLabel()] = "cPp";
// In PA mode, we also require cap and calpha
if (analysisMode == pALabel()) {
loadableProperties[cApLabel()] = "cAp";
loadableProperties[cAlphaLabel()] = "calpha";
}
for (auto propName = loadableProperties.begin();
propName != loadableProperties.end(); ++propName) {
Property *prop = getProperty(propName->first);
if (!prop)
continue;
if (prop->isDefault()) {
auto vals = instrument->getStringParameter(propName->second);
if (vals.empty())
throw std::runtime_error(
"Cannot find value for " + propName->first +
" in parameter file. Please specify this property manually.");
prop->setValue(vals[0]);
}
}
WorkspaceGroup_sptr outWS;
if (analysisMode == pALabel()) {
if (nWorkspaces != 4) {
throw std::invalid_argument(
"For PA analysis, input group must have 4 periods.");
}
g_log.notice("PA polarization correction");
outWS = execPA(inWS);
} else if (analysisMode == pNRLabel()) {
if (nWorkspaces != 2) {
throw std::invalid_argument(
"For PNR analysis, input group must have 2 periods.");
}
outWS = execPNR(inWS);
g_log.notice("PNR polarization correction");
}
this->setProperty("OutputWorkspace", outWS);
}
/**
* Add a workspace to a group. The group and the workspace must be in the ADS.
* @param groupName :: A group name.
* @param wsName :: Name of a workspace to add to the group.
*/
void AnalysisDataServiceImpl::addToGroup(const std::string &groupName,
const std::string &wsName) {
WorkspaceGroup_sptr group = retrieveWS<WorkspaceGroup>(groupName);
if (!group) {
throw std::runtime_error("Workspace " + groupName +
" is not a workspace group.");
}
auto ws = retrieve(wsName);
group->addWorkspace(ws);
notificationCenter.postNotification(new GroupUpdatedNotification(groupName));
}
/**
* Try to add the input workspace to the multiperiod input group list.
* @param ws: candidate workspace
* @param vecMultiPeriodWorkspaceGroups: Vector of multi period workspace
* groups.
* @param vecWorkspaceGroups: Vector of non-multi period workspace groups.
*/
void MultiPeriodGroupWorker::tryAddInputWorkspaceToInputGroups(
Workspace_sptr ws,
MultiPeriodGroupWorker::VecWSGroupType &vecMultiPeriodWorkspaceGroups,
MultiPeriodGroupWorker::VecWSGroupType &vecWorkspaceGroups) const {
WorkspaceGroup_sptr inputGroup =
boost::dynamic_pointer_cast<WorkspaceGroup>(ws);
if (inputGroup) {
if (inputGroup->isMultiperiod()) {
vecMultiPeriodWorkspaceGroups.push_back(inputGroup);
} else {
vecWorkspaceGroups.push_back(inputGroup);
}
}
}
/**
* Remove a workspace from a group but not from the ADS.
*
* @param groupName :: Name of a workspace group.
* @param wsName :: Name of a workspace to remove.
*/
void AnalysisDataServiceImpl::removeFromGroup(const std::string &groupName,
const std::string &wsName) {
WorkspaceGroup_sptr group = retrieveWS<WorkspaceGroup>(groupName);
if (!group) {
throw std::runtime_error("Workspace " + groupName +
" is not a workspace group.");
}
if (!group->contains(wsName)) {
throw std::runtime_error("WorkspaceGroup " + groupName +
" does not containt workspace " + wsName);
}
group->removeByADS(wsName);
notificationCenter.postNotification(new GroupUpdatedNotification(groupName));
}
void IqtFit::updatePlot() {
if (!m_ffInputWS) {
g_log.error("No workspace loaded, cannot create preview plot.");
return;
}
int specNo = m_uiForm.spPlotSpectrum->value();
m_uiForm.ppPlot->clear();
m_uiForm.ppPlot->addSpectrum("Sample", m_ffInputWS, specNo);
try {
const QPair<double, double> curveRange =
m_uiForm.ppPlot->getCurveRange("Sample");
const std::pair<double, double> range(curveRange.first, curveRange.second);
m_uiForm.ppPlot->getRangeSelector("FuryFitRange")
->setRange(range.first, range.second);
m_ffRangeManager->setRange(m_properties["StartX"], range.first,
range.second);
m_ffRangeManager->setRange(m_properties["EndX"], range.first, range.second);
setDefaultParameters("Exponential1");
setDefaultParameters("Exponential2");
setDefaultParameters("StretchedExp");
m_uiForm.ppPlot->resizeX();
m_uiForm.ppPlot->setAxisRange(qMakePair(0.0, 1.0), QwtPlot::yLeft);
} catch (std::invalid_argument &exc) {
showMessageBox(exc.what());
}
// If there is a result plot then plot it
if (AnalysisDataService::Instance().doesExist(m_pythonExportWsName)) {
WorkspaceGroup_sptr outputGroup =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
m_pythonExportWsName);
if (specNo >= static_cast<int>(outputGroup->size()))
return;
MatrixWorkspace_sptr ws = boost::dynamic_pointer_cast<MatrixWorkspace>(
outputGroup->getItem(specNo));
if (ws) {
if (m_uiForm.ckPlotGuess->isChecked()) {
m_uiForm.ppPlot->removeSpectrum("Guess");
}
m_uiForm.ppPlot->addSpectrum("Fit", ws, 1, Qt::red);
m_uiForm.ppPlot->addSpectrum("Diff", ws, 2, Qt::blue);
}
}
}
/**
* Handles completion of the correction algorithm.
*
* @param error True of the algorithm failed
*/
void CalculatePaalmanPings::absCorComplete(bool error) {
disconnect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this,
SLOT(absCorComplete(bool)));
if (error) {
emit showMessageBox("Absorption correction calculation failed.\nSee "
"Results Log for more details.");
return;
}
// Convert the spectrum axis of correction factors to Q
const auto sampleWsName =
m_uiForm.dsSample->getCurrentDataName().toStdString();
MatrixWorkspace_sptr sampleWs =
AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(sampleWsName);
WorkspaceGroup_sptr corrections =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
m_pythonExportWsName);
for (size_t i = 0; i < corrections->size(); i++) {
MatrixWorkspace_sptr factorWs =
boost::dynamic_pointer_cast<MatrixWorkspace>(corrections->getItem(i));
if (!factorWs || !sampleWs)
continue;
if (getEMode(sampleWs) == "Indirect") {
API::BatchAlgorithmRunner::AlgorithmRuntimeProps convertSpecProps;
IAlgorithm_sptr convertSpecAlgo =
AlgorithmManager::Instance().create("ConvertSpectrumAxis");
convertSpecAlgo->initialize();
convertSpecAlgo->setProperty("InputWorkspace", factorWs);
convertSpecAlgo->setProperty("OutputWorkspace", factorWs->getName());
convertSpecAlgo->setProperty("Target", "ElasticQ");
convertSpecAlgo->setProperty("EMode", "Indirect");
try {
convertSpecAlgo->setProperty("EFixed", getEFixed(factorWs));
} catch (std::runtime_error &) {
}
m_batchAlgoRunner->addAlgorithm(convertSpecAlgo);
}
}
// Run algorithm queue
connect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this,
SLOT(postProcessComplete(bool)));
m_batchAlgoRunner->executeBatchAsync();
}
/**
* Handles plotting result spectra from algorithm chains.
*
* @param error True if the chain was stopped due to error
*/
void IndirectDiffractionReduction::plotResults(bool error) {
// Handles completion of the diffraction algorithm chain
disconnect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this,
SLOT(plotResults(bool)));
// Nothing can be plotted
if (error) {
showInformationBox(
"Error running diffraction reduction.\nSee Results Log for details.");
return;
}
// Ungroup the output workspace if generic reducer was used
if (AnalysisDataService::Instance().doesExist(
"IndirectDiffraction_Workspaces")) {
WorkspaceGroup_sptr diffResultsGroup =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
"IndirectDiffraction_Workspaces");
m_plotWorkspaces.clear();
m_plotWorkspaces = diffResultsGroup->getNames();
diffResultsGroup->removeAll();
AnalysisDataService::Instance().remove("IndirectDiffraction_Workspaces");
saveGenericReductions();
}
QString instName = m_uiForm.iicInstrumentConfiguration->getInstrumentName();
QString mode = m_uiForm.iicInstrumentConfiguration->getReflectionName();
QString plotType = m_uiForm.cbPlotType->currentText();
QString pyInput = "from mantidplot import plotSpectrum, plot2D\n";
if (plotType == "Spectra" || plotType == "Both") {
for (auto it = m_plotWorkspaces.begin(); it != m_plotWorkspaces.end(); ++it)
pyInput += "plotSpectrum('" + QString::fromStdString(*it) + "', 0)\n";
}
if (plotType == "Contour" || plotType == "Both") {
for (auto it = m_plotWorkspaces.begin(); it != m_plotWorkspaces.end(); ++it)
pyInput += "plot2D('" + QString::fromStdString(*it) + "')\n";
}
runPythonCode(pyInput);
}
/**
* Handles completion of the algorithm.
*
* Sets result workspace for Python export and ungroups result WorkspaceGroup.
*
* @param error True if the algorithm was stopped due to error, false otherwise
*/
void IndirectConvertToEnergy::algorithmComplete(bool error)
{
disconnect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this, SLOT(algorithmComplete(bool)));
if(error)
return;
WorkspaceGroup_sptr energyTransferOutputGroup = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>("IndirectEnergyTransfer_Workspaces");
if(energyTransferOutputGroup->size() == 0)
return;
// Set workspace for Python export as the first result workspace
m_pythonExportWsName = energyTransferOutputGroup->getNames()[0];
// Ungroup the output workspace
energyTransferOutputGroup->removeAll();
AnalysisDataService::Instance().remove("IndirectEnergyTransfer_Workspaces");
}
/**
* Returns a workspace for the first period as specified using FirstPeriod
* property.
* @param group :: Loaded group of workspaces to use
* @return Workspace for the period
*/
MatrixWorkspace_sptr MuonLoad::getFirstPeriodWS(WorkspaceGroup_sptr group) {
int firstPeriod = getProperty("FirstPeriod");
MatrixWorkspace_sptr resultWS;
if (firstPeriod < 0 || firstPeriod >= static_cast<int>(group->size()))
throw std::invalid_argument(
"Workspace doesn't contain specified first period");
resultWS =
boost::dynamic_pointer_cast<MatrixWorkspace>(group->getItem(firstPeriod));
if (!resultWS)
throw std::invalid_argument(
"First period workspace is not a MatrixWorkspace");
return resultWS;
}
/**
* Run instead of exec when operating on groups
*/
bool SaveNXTomo::processGroups() {
try {
std::string name = getPropertyValue("InputWorkspaces");
WorkspaceGroup_sptr groupWS =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(name);
for (int i = 0; i < groupWS->getNumberOfEntries(); ++i) {
m_workspaces.push_back(
boost::dynamic_pointer_cast<Workspace2D>(groupWS->getItem(i)));
}
} catch (...) {
}
if (m_workspaces.size() != 0)
processAll();
return true;
}
/** Extract a spectrum from the Efficiencies workspace as a 1D workspace.
* @param label :: A label of the spectrum to extract.
* @return :: A workspace with a single spectrum.
*/
boost::shared_ptr<Mantid::API::MatrixWorkspace>
PolarizationCorrectionFredrikze::getEfficiencyWorkspace(
const std::string &label) {
MatrixWorkspace_sptr efficiencies = getProperty(efficienciesLabel);
auto const &axis = dynamic_cast<TextAxis &>(*efficiencies->getAxis(1));
size_t index = axis.length();
for (size_t i = 0; i < axis.length(); ++i) {
if (axis.label(i) == label) {
index = i;
break;
}
}
if (index == axis.length()) {
// Check if we need to fetch polarization parameters from the instrument's
// parameters
static std::map<std::string, std::string> loadableProperties{
{crhoLabel, "crho"},
{cppLabel, "cPp"},
{cApLabel, "cAp"},
{cAlphaLabel, "calpha"}};
WorkspaceGroup_sptr inWS = getProperty("InputWorkspace");
Instrument_const_sptr instrument = fetchInstrument(inWS.get());
auto vals = instrument->getStringParameter(loadableProperties[label]);
if (vals.empty()) {
throw std::invalid_argument("Efficiencey property not found: " + label);
}
auto extract = createChildAlgorithm("CreatePolarizationEfficiencies");
extract->initialize();
extract->setProperty("InputWorkspace", efficiencies);
extract->setProperty(label, vals.front());
extract->execute();
MatrixWorkspace_sptr outWS = extract->getProperty("OutputWorkspace");
return outWS;
} else {
auto extract = createChildAlgorithm("ExtractSingleSpectrum");
extract->initialize();
extract->setProperty("InputWorkspace", efficiencies);
extract->setProperty("WorkspaceIndex", static_cast<int>(index));
extract->execute();
MatrixWorkspace_sptr outWS = extract->getProperty("OutputWorkspace");
return outWS;
}
}
MatrixWorkspace_sptr MuonPairingAsymmetry::execGroupWorkspaceInput() {
// Get the input workspace into a useful form
Workspace_sptr tmpWS1 = getProperty("InputWorkspace1");
Workspace_sptr tmpWS2 = getProperty("InputWorkspace2");
WorkspaceGroup_sptr ws1 = workspaceToWorkspaceGroup(tmpWS1);
WorkspaceGroup_sptr ws2 = workspaceToWorkspaceGroup(tmpWS2);
WorkspaceGroup_sptr groupedPeriods = boost::make_shared<WorkspaceGroup>();
for (int i = 0; i < countPeriods(ws1); i++) {
groupedPeriods->addWorkspace(
appendSpectra(getWorkspace(ws1, i), getWorkspace(ws2, i)));
}
// Do the asymmetry calculation
const double alpha = static_cast<double>(getProperty("Alpha"));
std::vector<int> summedPeriods = getProperty("SummedPeriods");
std::vector<int> subtractedPeriods = getProperty("SubtractedPeriods");
return calcPairAsymmetryWithSummedAndSubtractedPeriods(
summedPeriods, subtractedPeriods, groupedPeriods, alpha);
}
/**
* Returns a workspace for the second period as specified using SecondPeriod
* property.
* @param group :: Loaded group of workspaces to use
* @return Workspace for the period
*/
MatrixWorkspace_sptr MuonLoad::getSecondPeriodWS(WorkspaceGroup_sptr group) {
int secondPeriod = getProperty("SecondPeriod");
MatrixWorkspace_sptr resultWS;
if (secondPeriod != EMPTY_INT()) {
if (secondPeriod < 0 || secondPeriod >= static_cast<int>(group->size()))
throw std::invalid_argument(
"Workspace doesn't contain specified second period");
resultWS = boost::dynamic_pointer_cast<MatrixWorkspace>(
group->getItem(secondPeriod));
if (!resultWS)
throw std::invalid_argument(
"Second period workspace is not a MatrixWorkspace");
}
return resultWS;
}
/**
* Handles plotting the preview plot when the algorithm finishes.
*
* @param error True if the algorithm exited due to error, false otherwise
*/
void IndirectMoments::momentsAlgComplete(bool error)
{
if(error)
return;
QString workspaceName = m_uiForm.dsInput->getCurrentDataName();
QString outputName = workspaceName.left(workspaceName.length() - 4);
std::string outputWorkspaceName = outputName.toStdString() + "_Moments";
WorkspaceGroup_sptr resultWsGroup = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(outputWorkspaceName);
std::vector<std::string> resultWsNames = resultWsGroup->getNames();
if(resultWsNames.size() < 4)
return;
// Plot each spectrum
m_uiForm.ppMomentsPreview->clear();
m_uiForm.ppMomentsPreview->addSpectrum("M0", QString::fromStdString(resultWsNames[0]), 0, Qt::green);
m_uiForm.ppMomentsPreview->addSpectrum("M1", QString::fromStdString(resultWsNames[2]), 0, Qt::black);
m_uiForm.ppMomentsPreview->addSpectrum("M2", QString::fromStdString(resultWsNames[3]), 0, Qt::red);
m_uiForm.ppMomentsPreview->resizeX();
}
void SmoothNeighboursDialog::inputWorkspaceChanged(const QString& pName)
{
UNUSED_ARG(pName);
m_propertiesWidget->m_groupWidgets[RECTANGULAR_GROUP]->setVisible(false);
m_propertiesWidget->m_groupWidgets[NON_UNIFORM_GROUP]->setVisible(false);
std::string inWsName = INPUT_WORKSPACE.toStdString();
// Workspace should have been set by PropertyWidget before emitting valueChanged
MatrixWorkspace_sptr inWs = this->getAlgorithm()->getProperty(inWsName);
if(!inWs)
{
// Workspace groups are NOT returned by IWP->getWorkspace(), as they are not MatrixWorkspace,
// so check the ADS for the GroupWorkspace with the same name
std::string inWsValue = this->getAlgorithm()->getPointerToProperty(inWsName)->value();
// If it really doesn't exist, don't do anything
if(!AnalysisDataService::Instance().doesExist(inWsValue))
return;
WorkspaceGroup_sptr inGroupWs = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(inWsValue);
if(inGroupWs)
// If is a group workspace, use the first workspace to determine the instrument type,
// as most of the times it will be the same for all the workspaces
inWs = boost::dynamic_pointer_cast<MatrixWorkspace>(inGroupWs->getItem(0));
else
// If is not a GroupWorkspace as well, do nothing
return;
}
Instrument::ContainsState containsRectDetectors = inWs->getInstrument()->containsRectDetectors();
if(containsRectDetectors == Instrument::ContainsState::Full)
m_propertiesWidget->m_groupWidgets[RECTANGULAR_GROUP]->setVisible(true);
else
m_propertiesWidget->m_groupWidgets[NON_UNIFORM_GROUP]->setVisible(true);
}
/**
* Updates the preview plot when the algorithm is complete.
*
* @param error True if the algorithm was stopped due to error, false otherwise
*/
void ISISDiagnostics::sliceAlgDone(bool error) {
disconnect(m_batchAlgoRunner, SIGNAL(batchComplete(bool)), this,
SLOT(sliceAlgDone(bool)));
if (error)
return;
QStringList filenames = m_uiForm.dsInputFiles->getFilenames();
if (filenames.size() < 1)
return;
WorkspaceGroup_sptr sliceOutputGroup =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
"IndirectDiagnostics_Workspaces");
if (sliceOutputGroup->size() == 0) {
g_log.warning("No result workspaces, cannot plot preview.");
return;
}
MatrixWorkspace_sptr sliceWs = boost::dynamic_pointer_cast<MatrixWorkspace>(
sliceOutputGroup->getItem(0));
if (!sliceWs) {
g_log.warning("No result workspaces, cannot plot preview.");
return;
}
// Set workspace for Python export as the first result workspace
m_pythonExportWsName = sliceWs->getName();
// Plot result spectrum
m_uiForm.ppSlicePreview->clear();
m_uiForm.ppSlicePreview->addSpectrum("Slice", sliceWs, 0);
m_uiForm.ppSlicePreview->resizeX();
// Ungroup the output workspace
sliceOutputGroup->removeAll();
AnalysisDataService::Instance().remove("IndirectDiagnostics_Workspaces");
}
/**
* Updates the preview plot when the algorithm is complete.
*
* @param error True if the algorithm was stopped due to error, false otherwise
*/
void IndirectDiagnostics::sliceAlgDone(bool error)
{
if(error)
return;
QStringList filenames = m_uiForm.dsInputFiles->getFilenames();
if(filenames.size() < 1)
return;
WorkspaceGroup_sptr sliceOutputGroup = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>("IndirectDiagnostics_Workspaces");
if(sliceOutputGroup->size() == 0)
{
g_log.warning("No result workspaces, cannot plot preview.");
return;
}
MatrixWorkspace_sptr sliceWs = boost::dynamic_pointer_cast<MatrixWorkspace>(sliceOutputGroup->getItem(0));
if(!sliceWs)
{
g_log.warning("No result workspaces, cannot plot preview.");
return;
}
// Set workspace for Python export as the first result workspace
m_pythonExportWsName = sliceWs->getName();
// Plot result spectrum
plotMiniPlot(sliceWs, 0, "SlicePreviewPlot", "SlicePreviewCurve");
// Set X range to data range
setXAxisToCurve("SlicePreviewPlot", "SlicePreviewCurve");
m_plots["SlicePreviewPlot"]->replot();
// Ungroup the output workspace
sliceOutputGroup->removeAll();
AnalysisDataService::Instance().remove("IndirectDiagnostics_Workspaces");
}
/**
* Sum transmission workspaces that belong to a workspace group
* @param transGroup : The transmission group containing the transmission runs
* @return :: A workspace pointer containing the sum of transmission workspaces
*/
MatrixWorkspace_sptr ReflectometryReductionOneAuto2::sumTransmissionWorkspaces(
WorkspaceGroup_sptr &transGroup) {
const std::string transSum = "trans_sum";
Workspace_sptr sumWS = transGroup->getItem(0)->clone();
/// For this step to appear in the history of the output workspaces I need to
/// set child to false and work with the ADS
auto plusAlg = createChildAlgorithm("Plus");
plusAlg->setChild(false);
plusAlg->initialize();
for (size_t item = 1; item < transGroup->size(); item++) {
plusAlg->setProperty("LHSWorkspace", sumWS);
plusAlg->setProperty("RHSWorkspace", transGroup->getItem(item));
plusAlg->setProperty("OutputWorkspace", transSum);
plusAlg->execute();
sumWS = AnalysisDataService::Instance().retrieve(transSum);
}
MatrixWorkspace_sptr result =
boost::dynamic_pointer_cast<MatrixWorkspace>(sumWS);
AnalysisDataService::Instance().remove(transSum);
return result;
}
/**
* Sets a new preview spectrum for the mini plot.
*
* @param value workspace index
*/
void ResNorm::previewSpecChanged(int value) {
m_previewSpec = value;
// Update vanadium plot
if (m_uiForm.dsVanadium->isValid())
m_uiForm.ppPlot->addSpectrum(
"Vanadium", m_uiForm.dsVanadium->getCurrentDataName(), m_previewSpec);
// Update fit plot
std::string fitWsGroupName(m_pythonExportWsName + "_Fit_Workspaces");
std::string fitParamsName(m_pythonExportWsName + "_Fit");
if (AnalysisDataService::Instance().doesExist(fitWsGroupName)) {
WorkspaceGroup_sptr fitWorkspaces =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
fitWsGroupName);
ITableWorkspace_sptr fitParams =
AnalysisDataService::Instance().retrieveWS<ITableWorkspace>(
fitParamsName);
if (fitWorkspaces && fitParams) {
Column_const_sptr scaleFactors = fitParams->getColumn("Scaling");
std::string fitWsName(fitWorkspaces->getItem(m_previewSpec)->name());
MatrixWorkspace_const_sptr fitWs =
AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
fitWsName);
MatrixWorkspace_sptr fit = WorkspaceFactory::Instance().create(fitWs, 1);
fit->setX(0, fitWs->readX(1));
fit->getSpectrum(0)->setData(fitWs->readY(1), fitWs->readE(1));
for (size_t i = 0; i < fit->blocksize(); i++)
fit->dataY(0)[i] /= scaleFactors->cell<double>(m_previewSpec);
m_uiForm.ppPlot->addSpectrum("Fit", fit, 0, Qt::red);
}
}
}
/**
* Handle plotting of mantid workspace
*/
void IndirectMolDyn::plotClicked() {
QString filename = m_uiForm.mwRun->getFirstFilename();
QFileInfo fi(filename);
QString baseName = fi.baseName();
if (checkADSForPlotSaveWorkspace(baseName.toStdString(), true)) {
WorkspaceGroup_sptr diffResultsGroup =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(
baseName.toStdString());
auto names = diffResultsGroup->getNames();
auto plotType = m_uiForm.cbPlot->currentText();
for (const auto wsName : names) {
if (plotType == "Spectra" || plotType == "Both")
plotSpectrum(QString::fromStdString(wsName));
if (plotType == "Contour" || plotType == "Both")
plot2D(QString::fromStdString(wsName));
}
}
}