/** Run any algorithm with a variable number of parameters
*
* @param algorithmName
* @param count :: number of arguments given.
* @return the algorithm created
*/
IAlgorithm_sptr FrameworkManagerImpl::exec(const std::string& algorithmName, int count, ...)
{
// Create the algorithm
Mantid::API::IAlgorithm_sptr alg;
alg = Mantid::API::AlgorithmManager::Instance().createUnmanaged(algorithmName, -1);
alg->initialize();
if (!alg->isInitialized())
throw std::runtime_error(algorithmName + " was not initialized.");
if (count % 2 == 1)
{
throw std::runtime_error("Must have an even number of parameter/value string arguments");
}
va_list Params;
va_start(Params, count);
for(int i = 0; i < count; i += 2 )
{
std::string paramName = va_arg(Params, const char *);
std::string paramValue = va_arg(Params, const char *);
alg->setPropertyValue(paramName, paramValue);
}
va_end(Params);
alg->execute();
return alg;
}
void WorkspacePresenter::ungroupWorkspaces() {
auto view = lockView();
auto selected = view->getSelectedWorkspaceNames();
if (selected.size() == 0) {
view->showCriticalUserMessage("Error Ungrouping Workspaces",
"Select a group workspace to Ungroup.");
return;
}
try {
// workspace name
auto wsname = selected[0];
std::string algName("UnGroupWorkspace");
Mantid::API::IAlgorithm_sptr alg =
Mantid::API::AlgorithmManager::Instance().create(algName, -1);
alg->initialize();
alg->setProperty("InputWorkspace", wsname);
// execute the algorithm
bool bStatus = alg->execute();
if (!bStatus) {
view->showCriticalUserMessage("MantidPlot - Algorithm error",
" Error in UnGroupWorkspace algorithm");
}
} catch (...) {
view->showCriticalUserMessage("MantidPlot - Algorithm error",
" Error in UnGroupWorkspace algorithm");
}
}
/**
* This function: 1. loads the instrument and gets the value of deltaE-mode parameter
* 2. Based on this value, makes the necessary changes to the form setup (direct or indirect).
* @param name :: name of the instrument from the QComboBox
*/
void IndirectDataReduction::instrumentSelectChanged(const QString& name)
{
QString defFile = (Mantid::API::ExperimentInfo::getInstrumentFilename(name.toStdString())).c_str();
if((defFile == "") || !m_uiForm.cbInst->isVisible())
{
g_log.error("Instument loading failed!");
m_uiForm.cbInst->setEnabled(true);
m_uiForm.pbRun->setEnabled(true);
return;
}
QString outWS = "__empty_" + m_uiForm.cbInst->currentText();
m_curInterfaceSetup = name;
//Load the empty instrument into the workspace __empty_[name]
//This used to be done in Python
Mantid::API::IAlgorithm_sptr instLoader = Mantid::API::AlgorithmManager::Instance().create("LoadEmptyInstrument", -1);
instLoader->initialize();
instLoader->setProperty("Filename", defFile.toStdString());
instLoader->setProperty("OutputWorkspace", outWS.toStdString());
//Ensure no other algorithm is running
m_algRunner->cancelRunningAlgorithm();
m_algRunner->startAlgorithm(instLoader);
}
/**
* Get the viewable peaks. Essentially copied from the slice viewer.
* @returns A vector indicating which of the peaks are viewable.
*/
std::vector<bool> ConcretePeaksPresenterVsi::getViewablePeaks() const {
// Need to apply a transform.
// Don't bother to find peaks in the region if there are no peaks to find.
Mantid::API::ITableWorkspace_sptr outTable;
if (this->m_peaksWorkspace->getNumberPeaks() >= 1) {
double effectiveRadius = 1e-2;
std::string viewable = m_viewableRegion->toExtentsAsString();
Mantid::API::IPeaksWorkspace_sptr peaksWS = m_peaksWorkspace;
Mantid::API::IAlgorithm_sptr alg =
Mantid::API::AlgorithmManager::Instance().create("PeaksInRegion");
alg->setChild(true);
alg->setRethrows(true);
alg->initialize();
alg->setProperty("InputWorkspace", peaksWS);
alg->setProperty("OutputWorkspace", peaksWS->name() + "_peaks_in_region");
alg->setProperty("Extents", viewable);
alg->setProperty("CheckPeakExtents", true);
alg->setProperty("PeakRadius", effectiveRadius);
alg->setPropertyValue("CoordinateFrame", m_frame);
alg->execute();
outTable = alg->getProperty("OutputWorkspace");
std::vector<bool> viewablePeaks(outTable->rowCount());
for (size_t i = 0; i < outTable->rowCount(); ++i) {
viewablePeaks[i] = outTable->cell<Mantid::API::Boolean>(i, 1);
}
m_viewablePeaks = viewablePeaks;
} else {
// No peaks will be viewable
m_viewablePeaks = std::vector<bool>();
}
return m_viewablePeaks;
}
bool ConcretePeaksPresenter::deletePeaksIn(PeakBoundingBox box) {
Left left(box.left());
Right right(box.right());
Bottom bottom(box.bottom());
Top top(box.top());
SlicePoint slicePoint(box.slicePoint());
if (slicePoint() < 0) { // indicates that it should not be used.
slicePoint = SlicePoint(m_slicePoint.slicePoint());
}
PeakBoundingBox accurateBox(
left, right, top, bottom,
slicePoint /*Use the current slice position, previously unknown.*/);
// Tranform box from plot coordinates into orderd HKL, Qx,Qy,Qz etc, then find
// the visible peaks.
std::vector<size_t> deletionIndexList = findVisiblePeakIndexes(accurateBox);
// If we have things to remove, do that in one-step.
if (!deletionIndexList.empty()) {
Mantid::API::IPeaksWorkspace_sptr peaksWS =
boost::const_pointer_cast<Mantid::API::IPeaksWorkspace>(
this->m_peaksWS);
// Sort the Peaks in-place.
Mantid::API::IAlgorithm_sptr alg =
AlgorithmManager::Instance().create("DeleteTableRows");
alg->setChild(true);
alg->setRethrows(true);
alg->initialize();
alg->setProperty("TableWorkspace", peaksWS);
alg->setProperty("Rows", deletionIndexList);
alg->execute();
// Reproduce the views. Proxy representations recreated for all peaks.
this->produceViews();
// Refind visible peaks and Set the proxy representations to be visible or
// not.
doFindPeaksInRegion();
// Upstream controls need to be regenerated.
this->informOwnerUpdate();
}
return !deletionIndexList.empty();
}
/**
* Create a list of file extensions from the given algorithm
* @param algName :: The name of the algorithm
* @param propName :: The name of the property
* @returns A list of file extensions
*/
QStringList
MWRunFiles::getFileExtensionsFromAlgorithm(const QString &algName,
const QString &propName) {
Mantid::API::IAlgorithm_sptr algorithm =
Mantid::API::AlgorithmManager::Instance().createUnmanaged(
algName.toStdString());
QStringList fileExts;
if (!algorithm)
return fileExts;
algorithm->initialize();
Property *prop = algorithm->getProperty(propName.toStdString());
FileProperty *fileProp = dynamic_cast<FileProperty *>(prop);
MultipleFileProperty *multiFileProp =
dynamic_cast<MultipleFileProperty *>(prop);
std::vector<std::string> allowed;
QString preferredExt;
if (fileProp) {
allowed = fileProp->allowedValues();
preferredExt = QString::fromStdString(fileProp->getDefaultExt());
} else if (multiFileProp) {
allowed = multiFileProp->allowedValues();
preferredExt = QString::fromStdString(multiFileProp->getDefaultExt());
} else {
return fileExts;
}
std::vector<std::string>::const_iterator iend = allowed.end();
int index(0);
for (std::vector<std::string>::const_iterator it = allowed.begin();
it != iend; ++it) {
if (!it->empty()) {
QString ext = QString::fromStdString(*it);
fileExts.append(ext);
if (ext == preferredExt) {
fileExts.move(index, 0);
}
++index;
}
}
return fileExts;
}
/**
* Sorts the peak workspace by a specified column name in ascending or
* descending order.
* @param byColumnName The column by which the workspace is to be sorted.
* @param ascending If the workspace is to be sorted in a ascending or
* descending manner.
*/
void ConcretePeaksPresenterVsi::sortPeaksWorkspace(
const std::string &byColumnName, const bool ascending) {
Mantid::API::IPeaksWorkspace_sptr peaksWS =
boost::const_pointer_cast<Mantid::API::IPeaksWorkspace>(
this->m_peaksWorkspace);
// Sort the Peaks in-place.
Mantid::API::IAlgorithm_sptr alg =
Mantid::API::AlgorithmManager::Instance().create("SortPeaksWorkspace");
alg->setChild(true);
alg->setRethrows(true);
alg->initialize();
alg->setProperty("InputWorkspace", peaksWS);
alg->setPropertyValue("OutputWorkspace", "SortedPeaksWorkspace");
alg->setProperty("OutputWorkspace", peaksWS);
alg->setProperty("SortAscending", ascending);
alg->setPropertyValue("ColumnNameToSortBy", byColumnName);
alg->execute();
}
std::vector<size_t>
ConcretePeaksPresenter::findVisiblePeakIndexes(const PeakBoundingBox &box) {
std::vector<size_t> indexes;
// Don't bother to find peaks in the region if there are no peaks to find.
if (this->m_peaksWS->getNumberPeaks() >= 1) {
double radius =
m_viewPeaks
->getRadius(); // Effective radius of each peak representation.
Mantid::API::IPeaksWorkspace_sptr peaksWS =
boost::const_pointer_cast<Mantid::API::IPeaksWorkspace>(
this->m_peaksWS);
PeakBoundingBox transformedViewableRegion = box.makeSliceBox(radius);
transformedViewableRegion.transformBox(m_transform);
Mantid::API::IAlgorithm_sptr alg =
AlgorithmManager::Instance().create("PeaksInRegion");
alg->setChild(true);
alg->setRethrows(true);
alg->initialize();
alg->setProperty("InputWorkspace", peaksWS);
alg->setProperty("OutputWorkspace", peaksWS->name() + "_peaks_in_region");
alg->setProperty("Extents", transformedViewableRegion.toExtents());
alg->setProperty("CheckPeakExtents", false); // consider all peaks as points
alg->setProperty("PeakRadius", radius);
alg->setPropertyValue("CoordinateFrame", m_transform->getFriendlyName());
alg->execute();
ITableWorkspace_sptr outTable = alg->getProperty("OutputWorkspace");
for (size_t i = 0; i < outTable->rowCount(); ++i) {
const bool insideRegion = outTable->cell<Boolean>(i, 1);
if (insideRegion) {
indexes.push_back(i);
}
}
}
return indexes;
}
Mantid::API::MatrixWorkspace_sptr SANSPlotSpecial::runIQTransform() {
// Run the IQTransform algorithm for the current settings on the GUI
Mantid::API::IAlgorithm_sptr iqt =
Mantid::API::AlgorithmManager::Instance().create("IQTransform");
iqt->initialize();
try {
iqt->setPropertyValue("InputWorkspace",
m_uiForm.wsInput->currentText().toStdString());
} catch (std::invalid_argument &) {
m_uiForm.lbPlotOptionsError->setText(
"Selected input workspace is not appropriate for the IQTransform "
"algorithm. Please refer to the documentation for guidelines.");
return Mantid::API::MatrixWorkspace_sptr();
}
iqt->setPropertyValue("OutputWorkspace", "__sans_isis_display_iqt");
iqt->setPropertyValue("TransformType",
m_uiForm.cbPlotType->currentText().toStdString());
if (m_uiForm.cbBackground->currentText() == "Value") {
iqt->setProperty<double>("BackgroundValue", m_uiForm.dsBackground->value());
} else {
iqt->setPropertyValue("BackgroundWorkspace",
m_uiForm.wsBackground->currentText().toStdString());
}
if (m_uiForm.cbPlotType->currentText() == "General") {
std::vector<double> constants =
m_transforms["General"]->functionConstants();
iqt->setProperty("GeneralFunctionConstants", constants);
}
iqt->execute();
Mantid::API::MatrixWorkspace_sptr result =
boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(
Mantid::API::AnalysisDataService::Instance().retrieve(
"__sans_isis_display_iqt"));
return result;
}
void WorkspacePresenter::groupWorkspaces() {
auto view = lockView();
auto selected = view->getSelectedWorkspaceNames();
std::string groupName("NewGroup");
// get selected workspaces
if (selected.size() < 2) {
view->showCriticalUserMessage("Cannot Group Workspaces",
"Select at least two workspaces to group ");
return;
}
if (m_adapter->doesWorkspaceExist(groupName)) {
if (!view->askUserYesNo("",
"Workspace " + groupName +
" already exists. Do you want to replace it?"))
return;
}
try {
std::string algName("GroupWorkspaces");
Mantid::API::IAlgorithm_sptr alg =
Mantid::API::AlgorithmManager::Instance().create(algName, -1);
alg->initialize();
alg->setProperty("InputWorkspaces", selected);
alg->setPropertyValue("OutputWorkspace", groupName);
// execute the algorithm
bool bStatus = alg->execute();
if (!bStatus) {
view->showCriticalUserMessage("MantidPlot - Algorithm error",
" Error in GroupWorkspaces algorithm");
}
} catch (...) {
view->showCriticalUserMessage("MantidPlot - Algorithm error",
" Error in GroupWorkspaces algorithm");
}
}
/**
* Create a list of files from the given algorithm property.
*/
void FindFilesThread::getFilesFromAlgorithm() {
Mantid::API::IAlgorithm_sptr algorithm =
Mantid::API::AlgorithmManager::Instance().createUnmanaged(
m_algorithm.toStdString());
if (!algorithm)
throw std::invalid_argument("Cannot create algorithm " +
m_algorithm.toStdString() + ".");
algorithm->initialize();
const std::string propName = m_property.toStdString();
algorithm->setProperty(propName, m_text);
Property *prop = algorithm->getProperty(propName);
m_valueForProperty = QString::fromStdString(prop->value());
FileProperty *fileProp = dynamic_cast<FileProperty *>(prop);
MultipleFileProperty *multiFileProp =
dynamic_cast<MultipleFileProperty *>(prop);
if (fileProp) {
m_filenames.push_back(fileProp->value());
} else if (multiFileProp) {
// This flattens any summed files to a set of single files so that you lose
// the information about
// what was summed
std::vector<std::vector<std::string>> filenames =
algorithm->getProperty(propName);
std::vector<std::string> flattenedNames =
VectorHelper::flattenVector(filenames);
for (auto filename = flattenedNames.begin();
filename != flattenedNames.end(); ++filename) {
m_filenames.push_back(*filename);
}
}
}
bool ConcretePeaksPresenter::addPeakAt(double plotCoordsPointX,
double plotCoordsPointY) {
V3D plotCoordsPoint(plotCoordsPointX, plotCoordsPointY,
m_slicePoint.slicePoint());
V3D hkl = m_transform->transformBack(plotCoordsPoint);
Mantid::API::IPeaksWorkspace_sptr peaksWS =
boost::const_pointer_cast<Mantid::API::IPeaksWorkspace>(this->m_peaksWS);
Mantid::API::IAlgorithm_sptr alg =
AlgorithmManager::Instance().create("AddPeakHKL");
alg->setChild(true);
alg->setRethrows(true);
alg->initialize();
alg->setProperty("Workspace", peaksWS);
alg->setProperty("HKL", std::vector<double>(hkl));
// Execute the algorithm
try {
alg->execute();
} catch (...) {
g_log.warning("ConcretePeaksPresenter: Could not add the peak. Make sure "
"that it is added within a valid workspace region");
}
// Reproduce the views. Proxy representations recreated for all peaks.
this->produceViews();
// Refind visible peaks and Set the proxy representations to be visible or
// not.
doFindPeaksInRegion();
// Upstream controls need to be regenerated.
this->informOwnerUpdate();
return alg->isExecuted();
}
/**
* Groups the workspace according to grouping provided.
*
* @param ws :: Workspace to group
* @param g :: The grouping information
* @return Sptr to created grouped workspace
*/
MatrixWorkspace_sptr groupWorkspace(MatrixWorkspace_const_sptr ws, const Grouping& g)
{
// As I couldn't specify multiple groups for GroupDetectors, I am going down quite a complicated
// route - for every group distinct grouped workspace is created using GroupDetectors. These
// workspaces are then merged into the output workspace.
// Create output workspace
MatrixWorkspace_sptr outWs =
WorkspaceFactory::Instance().create(ws, g.groups.size(), ws->readX(0).size(), ws->blocksize());
for(size_t gi = 0; gi < g.groups.size(); gi++)
{
Mantid::API::IAlgorithm_sptr alg = AlgorithmManager::Instance().create("GroupDetectors");
alg->setChild(true); // So Output workspace is not added to the ADS
alg->initialize();
alg->setProperty("InputWorkspace", boost::const_pointer_cast<MatrixWorkspace>(ws));
alg->setPropertyValue("SpectraList", g.groups[gi]);
alg->setPropertyValue("OutputWorkspace", "grouped"); // Is not actually used, just to make validators happy
alg->execute();
MatrixWorkspace_sptr grouped = alg->getProperty("OutputWorkspace");
// Copy the spectrum
*(outWs->getSpectrum(gi)) = *(grouped->getSpectrum(0));
// Update spectrum number
outWs->getSpectrum(gi)->setSpectrumNo(static_cast<specid_t>(gi));
// Copy to the output workspace
outWs->dataY(gi) = grouped->readY(0);
outWs->dataX(gi) = grouped->readX(0);
outWs->dataE(gi) = grouped->readE(0);
}
return outWs;
}
void ConcretePeaksPresenter::sortPeaksWorkspace(const std::string &byColumnName,
const bool ascending) {
Mantid::API::IPeaksWorkspace_sptr peaksWS =
boost::const_pointer_cast<Mantid::API::IPeaksWorkspace>(this->m_peaksWS);
// Sort the Peaks in-place.
Mantid::API::IAlgorithm_sptr alg =
AlgorithmManager::Instance().create("SortPeaksWorkspace");
alg->setChild(true);
alg->setRethrows(true);
alg->initialize();
alg->setProperty("InputWorkspace", peaksWS);
alg->setPropertyValue("OutputWorkspace", "SortedPeaksWorkspace");
alg->setProperty("OutputWorkspace", peaksWS);
alg->setProperty("SortAscending", ascending);
alg->setPropertyValue("ColumnNameToSortBy", byColumnName);
alg->execute();
// Reproduce the views.
this->produceViews();
// Give the new views the current slice point.
m_viewPeaks->setSlicePoint(this->m_slicePoint.slicePoint(), m_viewablePeaks);
}
/**
* Move the user selected spectra in the input workspace into groups in the output workspace
* @param inputWS :: user selected input workspace for the algorithm
* @param outputWS :: user selected output workspace for the algorithm
* @param prog4Copy :: the amount of algorithm progress to attribute to moving a single spectra
* @return number of new grouped spectra
*/
size_t GroupDetectors2::formGroupsEvent( DataObjects::EventWorkspace_const_sptr inputWS, DataObjects::EventWorkspace_sptr outputWS,
const double prog4Copy)
{
// get "Behaviour" string
const std::string behaviour = getProperty("Behaviour");
int bhv = 0;
if ( behaviour == "Average" ) bhv = 1;
API::MatrixWorkspace_sptr beh = API::WorkspaceFactory::Instance().create(
"Workspace2D", static_cast<int>(m_GroupSpecInds.size()), 1, 1);
g_log.debug() << name() << ": Preparing to group spectra into " << m_GroupSpecInds.size() << " groups\n";
// where we are copying spectra to, we start copying to the start of the output workspace
size_t outIndex = 0;
// Only used for averaging behaviour. We may have a 1:1 map where a Divide would be waste as it would be just dividing by 1
bool requireDivide(false);
for ( storage_map::const_iterator it = m_GroupSpecInds.begin(); it != m_GroupSpecInds.end() ; ++it )
{
// This is the grouped spectrum
EventList & outEL = outputWS->getEventList(outIndex);
// The spectrum number of the group is the key
outEL.setSpectrumNo(it->first);
// Start fresh with no detector IDs
outEL.clearDetectorIDs();
// the Y values and errors from spectra being grouped are combined in the output spectrum
// Keep track of number of detectors required for masking
size_t nonMaskedSpectra(0);
beh->dataX(outIndex)[0] = 0.0;
beh->dataE(outIndex)[0] = 0.0;
for( std::vector<size_t>::const_iterator wsIter = it->second.begin(); wsIter != it->second.end(); ++wsIter)
{
const size_t originalWI = *wsIter;
const EventList & fromEL=inputWS->getEventList(originalWI);
//Add the event lists with the operator
outEL += fromEL;
// detectors to add to the output spectrum
outEL.addDetectorIDs(fromEL.getDetectorIDs() );
try
{
Geometry::IDetector_const_sptr det = inputWS->getDetector(originalWI);
if( !det->isMasked() ) ++nonMaskedSpectra;
}
catch(Exception::NotFoundError&)
{
// If a detector cannot be found, it cannot be masked
++nonMaskedSpectra;
}
}
if( nonMaskedSpectra == 0 ) ++nonMaskedSpectra; // Avoid possible divide by zero
if(!requireDivide) requireDivide = (nonMaskedSpectra > 1);
beh->dataY(outIndex)[0] = static_cast<double>(nonMaskedSpectra);
// make regular progress reports and check for cancelling the algorithm
if ( outIndex % INTERVAL == 0 )
{
m_FracCompl += INTERVAL*prog4Copy;
if ( m_FracCompl > 1.0 )
m_FracCompl = 1.0;
progress(m_FracCompl);
interruption_point();
}
outIndex ++;
}
// Refresh the spectraDetectorMap
outputWS->doneAddingEventLists();
if ( bhv == 1 && requireDivide )
{
g_log.debug() << "Running Divide algorithm to perform averaging.\n";
Mantid::API::IAlgorithm_sptr divide = createChildAlgorithm("Divide");
divide->initialize();
divide->setProperty<API::MatrixWorkspace_sptr>("LHSWorkspace", outputWS);
divide->setProperty<API::MatrixWorkspace_sptr>("RHSWorkspace", beh);
divide->setProperty<API::MatrixWorkspace_sptr>("OutputWorkspace", outputWS);
divide->execute();
}
g_log.debug() << name() << " created " << outIndex << " new grouped spectra\n";
return outIndex;
}
/**
* Move the user selected spectra in the input workspace into groups in the output workspace
* @param inputWS :: user selected input workspace for the algorithm
* @param outputWS :: user selected output workspace for the algorithm
* @param prog4Copy :: the amount of algorithm progress to attribute to moving a single spectra
* @return number of new grouped spectra
*/
size_t GroupDetectors2::formGroups( API::MatrixWorkspace_const_sptr inputWS, API::MatrixWorkspace_sptr outputWS,
const double prog4Copy)
{
// get "Behaviour" string
const std::string behaviour = getProperty("Behaviour");
int bhv = 0;
if ( behaviour == "Average" ) bhv = 1;
API::MatrixWorkspace_sptr beh = API::WorkspaceFactory::Instance().create(
"Workspace2D", static_cast<int>(m_GroupSpecInds.size()), 1, 1);
g_log.debug() << name() << ": Preparing to group spectra into " << m_GroupSpecInds.size() << " groups\n";
// where we are copying spectra to, we start copying to the start of the output workspace
size_t outIndex = 0;
// Only used for averaging behaviour. We may have a 1:1 map where a Divide would be waste as it would be just dividing by 1
bool requireDivide(false);
for ( storage_map::const_iterator it = m_GroupSpecInds.begin(); it != m_GroupSpecInds.end() ; ++it )
{
// This is the grouped spectrum
ISpectrum * outSpec = outputWS->getSpectrum(outIndex);
// The spectrum number of the group is the key
outSpec->setSpectrumNo(it->first);
// Start fresh with no detector IDs
outSpec->clearDetectorIDs();
// Copy over X data from first spectrum, the bin boundaries for all spectra are assumed to be the same here
outSpec->dataX() = inputWS->readX(0);
// the Y values and errors from spectra being grouped are combined in the output spectrum
// Keep track of number of detectors required for masking
size_t nonMaskedSpectra(0);
beh->dataX(outIndex)[0] = 0.0;
beh->dataE(outIndex)[0] = 0.0;
for( std::vector<size_t>::const_iterator wsIter = it->second.begin(); wsIter != it->second.end(); ++wsIter)
{
const size_t originalWI = *wsIter;
// detectors to add to firstSpecNum
const ISpectrum * fromSpectrum = inputWS->getSpectrum(originalWI);
// Add up all the Y spectra and store the result in the first one
// Need to keep the next 3 lines inside loop for now until ManagedWorkspace mru-list works properly
MantidVec &firstY = outSpec->dataY();
MantidVec::iterator fYit;
MantidVec::iterator fEit = outSpec->dataE().begin();
MantidVec::const_iterator Yit = fromSpectrum->dataY().begin();
MantidVec::const_iterator Eit = fromSpectrum->dataE().begin();
for (fYit = firstY.begin(); fYit != firstY.end(); ++fYit, ++fEit, ++Yit, ++Eit)
{
*fYit += *Yit;
// Assume 'normal' (i.e. Gaussian) combination of errors
*fEit = std::sqrt( (*fEit)*(*fEit) + (*Eit)*(*Eit) );
}
// detectors to add to the output spectrum
outSpec->addDetectorIDs(fromSpectrum->getDetectorIDs() );
try
{
Geometry::IDetector_const_sptr det = inputWS->getDetector(originalWI);
if( !det->isMasked() ) ++nonMaskedSpectra;
}
catch(Exception::NotFoundError&)
{
// If a detector cannot be found, it cannot be masked
++nonMaskedSpectra;
}
}
if( nonMaskedSpectra == 0 ) ++nonMaskedSpectra; // Avoid possible divide by zero
if(!requireDivide) requireDivide = (nonMaskedSpectra > 1);
beh->dataY(outIndex)[0] = static_cast<double>(nonMaskedSpectra);
// make regular progress reports and check for cancelling the algorithm
if ( outIndex % INTERVAL == 0 )
{
m_FracCompl += INTERVAL*prog4Copy;
if ( m_FracCompl > 1.0 )
m_FracCompl = 1.0;
progress(m_FracCompl);
interruption_point();
}
outIndex ++;
}
// Refresh the spectraDetectorMap
outputWS->generateSpectraMap();
if ( bhv == 1 && requireDivide )
{
g_log.debug() << "Running Divide algorithm to perform averaging.\n";
Mantid::API::IAlgorithm_sptr divide = createChildAlgorithm("Divide");
divide->initialize();
divide->setProperty<API::MatrixWorkspace_sptr>("LHSWorkspace", outputWS);
divide->setProperty<API::MatrixWorkspace_sptr>("RHSWorkspace", beh);
divide->setProperty<API::MatrixWorkspace_sptr>("OutputWorkspace", outputWS);
divide->execute();
}
g_log.debug() << name() << " created " << outIndex << " new grouped spectra\n";
return outIndex;
}
/**
* Fill m_uiForm.logBox with names of the log values read from one of the input files
*/
void PlotAsymmetryByLogValueDialog::fillLogBox(const QString&)
{
QString nexusFileName = m_uiForm.firstRunBox->text();
QFileInfo file(nexusFileName);
if (!file.exists())
{
return;
}
m_uiForm.logBox->clear();
Mantid::API::IAlgorithm_sptr alg = Mantid::API::AlgorithmFactory::Instance().create("LoadNexus",-1);
alg->initialize();
try
{
alg->setPropertyValue("Filename",nexusFileName.toStdString());
alg->setPropertyValue("OutputWorkspace","PlotAsymmetryByLogValueDialog_tmp");
alg->setPropertyValue("SpectrumMin","0");
alg->setPropertyValue("SpectrumMax","0");
alg->execute();
if (alg->isExecuted())
{
std::string wsName = alg->getPropertyValue("OutputWorkspace");
Mantid::API::Workspace_sptr ws = Mantid::API::AnalysisDataService::Instance().retrieve(wsName);
if ( !ws )
{
return;
}
Mantid::API::MatrixWorkspace_sptr mws = boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(ws);
Mantid::API::WorkspaceGroup_sptr gws = boost::dynamic_pointer_cast<Mantid::API::WorkspaceGroup>(ws);
if (gws)
{
if (gws->getNumberOfEntries() < 2) return;
mws = boost::dynamic_pointer_cast<Mantid::API::MatrixWorkspace>(
Mantid::API::AnalysisDataService::Instance().retrieve(gws->getNames()[1])
);
}
const std::vector< Mantid::Kernel::Property* >& props = mws->run().getLogData();
if (gws)
{
std::vector<std::string> wsNames = gws->getNames();
for(std::vector<std::string>::iterator it=wsNames.begin();it!=wsNames.end();++it)
{
Mantid::API::AnalysisDataService::Instance().remove(*it);
}
}
else
{
Mantid::API::AnalysisDataService::Instance().remove("PlotAsymmetryByLogValueDialog_tmp");
}
for(size_t i=0;i<props.size();i++)
{
m_uiForm.logBox->addItem(QString::fromStdString(props[i]->name()));
}
// Display the appropriate value
QString displayed("");
if( !isForScript() )
{
displayed = MantidQt::API::AlgorithmInputHistory::Instance().previousInput("PlotAsymmetryByLogValue", "LogValue");
}
if( !displayed.isEmpty() )
{
int index = m_uiForm.logBox->findText(displayed);
if( index >= 0 )
{
m_uiForm.logBox->setCurrentIndex(index);
}
}
}
}
catch(std::exception& )
{
}
}