/** 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; }
/** Extracts OutputWorkspace property from supplied algorithm is present. * * This methods executes the given algorithm and tries to extract the output workspace. * * @param algorithm :: Pointer to algorithm. * @return MatrixWorkspace stored in algorithm's OutputWorkspace property. */ MatrixWorkspace_sptr PoldiTruncateData::getOutputWorkspace(Algorithm_sptr algorithm) { if(!algorithm || !algorithm->execute()) { throw std::runtime_error("Workspace could not be retrieved successfully."); } MatrixWorkspace_sptr outputWorkspace = algorithm->getProperty("OutputWorkspace"); return outputWorkspace; }
/** * Run new CompareWorkspaces algorithm as a child algorithm. * * Result string formatted the same way as before; "Success!" when workspaces * match or a newline separated list of mismatch messages. * * @param group_compare Should output be formatted like group comparison? * @return A string containing either successString() or mismatch messages */ std::string CheckWorkspacesMatch::runCompareWorkspaces(bool group_compare) { // This algorithm produces a single result string std::string result; // Use new CompareWorkspaces algorithm to perform comparison Algorithm_sptr compare = this->createChildAlgorithm("CompareWorkspaces"); compare->setRethrows(true); compare->setLogging(false); // Forward workspace properties Workspace_sptr ws1 = getProperty("Workspace1"); Workspace_sptr ws2 = getProperty("Workspace2"); compare->setProperty("Workspace1", ws1); compare->setProperty("Workspace2", ws2); // Copy any other non-default properties const std::vector<Property *> &allProps = this->getProperties(); auto propCount = allProps.size(); for (size_t i = 0; i < propCount; ++i) { Property *prop = allProps[i]; const std::string &pname = prop->name(); if (!prop->isDefault() && pname != "Workspace1" && pname != "Workspace2" && pname != "Result") compare->setPropertyValue(pname, prop->value()); } // Execute comparison compare->execute(); // Generate result string if (!compare->getProperty("Result")) { ITableWorkspace_sptr table = compare->getProperty("Messages"); auto rowcount = table->rowCount(); for (size_t i = 0; i < rowcount; ++i) { result += table->cell<std::string>(i, 0); // Emulate special case output format when comparing groups if (group_compare && table->cell<std::string>(i, 0) != "Type mismatch. One workspace is a group, the other is not." && table->cell<std::string>(i, 0) != "GroupWorkspaces size mismatch.") { result += ". Inputs=[" + table->cell<std::string>(i, 1) + "," + table->cell<std::string>(i, 2) + "]"; } if (i < (rowcount - 1)) result += "\n"; } } else { result = successString(); } return result; }
void EstimatePDDetectorResolution::retrieveInstrumentParameters() { #if 0 // Call SolidAngle to get solid angles for all detectors Algorithm_sptr calsolidangle = createChildAlgorithm("SolidAngle", -1, -1, true); calsolidangle->initialize(); calsolidangle->setProperty("InputWorkspace", m_inputWS); calsolidangle->execute(); if (!calsolidangle->isExecuted()) throw runtime_error("Unable to run solid angle. "); m_solidangleWS = calsolidangle->getProperty("OutputWorkspace"); if (!m_solidangleWS) throw runtime_error("Unable to get solid angle workspace from SolidAngle(). "); size_t numspec = m_solidangleWS->getNumberHistograms(); for (size_t i = 0; i < numspec; ++i) g_log.debug() << "[DB]: " << m_solidangleWS->readY(i)[0] << "\n"; #endif // Calculate centre neutron velocity Property* cwlproperty = m_inputWS->run().getProperty("LambdaRequest"); if (!cwlproperty) throw runtime_error("Unable to locate property LambdaRequest as central wavelength. "); TimeSeriesProperty<double>* cwltimeseries = dynamic_cast<TimeSeriesProperty<double>* >(cwlproperty); if (!cwltimeseries) throw runtime_error("LambdaReqeust is not a TimeSeriesProperty in double. "); if (cwltimeseries->size() != 1) throw runtime_error("LambdaRequest should contain 1 and only 1 entry. "); double centrewavelength = cwltimeseries->nthValue(0); string unit = cwltimeseries->units(); if (unit.compare("Angstrom") == 0) centrewavelength *= 1.0E-10; else throw runtime_error("Unit is not recognized"); m_centreVelocity = PhysicalConstants::h/PhysicalConstants::NeutronMass/centrewavelength; g_log.notice() << "Centre wavelength = " << centrewavelength << ", Centre neutron velocity = " << m_centreVelocity << "\n"; // Calcualte L1 sample to source Instrument_const_sptr instrument = m_inputWS->getInstrument(); V3D samplepos = instrument->getSample()->getPos(); V3D sourcepos = instrument->getSource()->getPos(); m_L1 = samplepos.distance(sourcepos); g_log.notice() << "L1 = " << m_L1 << "\n"; return; }
//----------------------------------------------------------------------------------------------------------------------- /// Run the Child Algorithm LoadInstrument (or LoadInstrumentFromRaw) void LoadInstrument::runLoadParameterFile() { g_log.debug("Loading the parameter definition..."); // First search for XML parameter file in same folder as IDF file const std::string::size_type dir_end = m_filename.find_last_of("\\/"); std::string directoryName = m_filename.substr(0, dir_end + 1); // include final '/'. std::string fullPathParamIDF = getFullPathParamIDF(directoryName); if (fullPathParamIDF.empty()) { // Not found, so search the other places were it may occur Kernel::ConfigServiceImpl &configService = Kernel::ConfigService::Instance(); std::vector<std::string> directoryNames = configService.getInstrumentDirectories(); for (auto directoryName : directoryNames) { // This will iterate around the directories from user ->etc ->install, and // find the first beat file fullPathParamIDF = getFullPathParamIDF(directoryName); // stop when you find the first one if (!fullPathParamIDF.empty()) break; } } if (!fullPathParamIDF.empty()) { g_log.debug() << "Parameter file: " << fullPathParamIDF << std::endl; // Now execute the Child Algorithm. Catch and log any error, but don't stop. try { // To allow the use of ExperimentInfo instead of workspace, we call it // manually Algorithm_sptr loadParamAlg = createChildAlgorithm("LoadParameterFile"); loadParamAlg->setProperty("Filename", fullPathParamIDF); loadParamAlg->setProperty("Workspace", m_workspace); loadParamAlg->execute(); g_log.debug("Parameters loaded successfully."); } catch (std::invalid_argument &e) { g_log.information( "LoadParameterFile: No parameter file found for this instrument"); g_log.information(e.what()); } catch (std::runtime_error &e) { g_log.information( "Unable to successfully run LoadParameterFile Child Algorithm"); g_log.information(e.what()); } } else { g_log.information("No parameter file found for this instrument"); } }
/** * Process the two groups together and set the result accordingly * @param groupOne :: Input group 1 * @param groupTwo :: Input group 2 */ void CheckWorkspacesMatch::processGroups( boost::shared_ptr<const API::WorkspaceGroup> groupOne, boost::shared_ptr<const API::WorkspaceGroup> groupTwo) { // Check their sizes const size_t totalNum = static_cast<size_t>(groupOne->getNumberOfEntries()); if (groupOne->getNumberOfEntries() != groupTwo->getNumberOfEntries()) { this->result = "GroupWorkspaces size mismatch."; return; } // See if there are any other properties that require setting const std::vector<Property *> &allProps = this->getProperties(); std::vector<Property *> nonDefaultProps; nonDefaultProps.reserve(allProps.size()); for (size_t i = 0; i < allProps.size(); ++i) { Property *p = allProps[i]; const std::string &propName = p->name(); // Skip those not set and the input workspaces if (p->isDefault() || propName == "Workspace1" || propName == "Workspace2") continue; nonDefaultProps.push_back(p); } const size_t numNonDefault = nonDefaultProps.size(); const double progressFraction = 1.0 / static_cast<double>(totalNum); std::vector<std::string> namesOne = groupOne->getNames(); std::vector<std::string> namesTwo = groupTwo->getNames(); for (size_t i = 0; i < totalNum; ++i) { // We should use an algorithm for each so that the output properties are // reset properly Algorithm_sptr checker = this->createChildAlgorithm( this->name(), progressFraction * (double)i, progressFraction * (double)(i + 1), false, this->version()); checker->setPropertyValue("Workspace1", namesOne[i]); checker->setPropertyValue("Workspace2", namesTwo[i]); for (size_t j = 0; j < numNonDefault; ++j) { Property *p = nonDefaultProps[j]; checker->setPropertyValue(p->name(), p->value()); } checker->execute(); std::string success = checker->getProperty("Result"); if (success != this->successString()) { if (!this->result.empty()) this->result += "\n"; this->result += success + ". Inputs=[" + namesOne[i] + "," + namesTwo[i] + "]"; } } }
/** * @brief CompareWorkspaces::processGroups * @param groupOne * @param groupTwo */ void CompareWorkspaces::processGroups( boost::shared_ptr<const API::WorkspaceGroup> groupOne, boost::shared_ptr<const API::WorkspaceGroup> groupTwo) { // Check their sizes const size_t totalNum = static_cast<size_t>(groupOne->getNumberOfEntries()); if (groupOne->getNumberOfEntries() != groupTwo->getNumberOfEntries()) { recordMismatch("GroupWorkspaces size mismatch."); return; } // See if there are any other properties that require setting const std::vector<Property *> &allProps = this->getProperties(); std::vector<Property *> nonDefaultProps; nonDefaultProps.reserve(allProps.size()); for (auto p : allProps) { const std::string &propName = p->name(); // Skip those not set and the input workspaces if (p->isDefault() || propName == "Workspace1" || propName == "Workspace2") continue; nonDefaultProps.push_back(p); } const size_t numNonDefault = nonDefaultProps.size(); const double progressFraction = 1.0 / static_cast<double>(totalNum); std::vector<std::string> namesOne = groupOne->getNames(); std::vector<std::string> namesTwo = groupTwo->getNames(); for (size_t i = 0; i < totalNum; ++i) { // We should use an algorithm for each so that the output properties are // reset properly Algorithm_sptr checker = this->createChildAlgorithm( this->name(), progressFraction * static_cast<double>(i), progressFraction * static_cast<double>(i + 1), false, this->version()); checker->setPropertyValue("Workspace1", namesOne[i]); checker->setPropertyValue("Workspace2", namesTwo[i]); for (size_t j = 0; j < numNonDefault; ++j) { Property *p = nonDefaultProps[j]; checker->setPropertyValue(p->name(), p->value()); } checker->execute(); bool success = checker->getProperty("Result"); if (!success) { ITableWorkspace_sptr table = checker->getProperty("Messages"); recordMismatch(table->cell<std::string>(0, 0), namesOne[i], namesTwo[i]); } } }
void SofQW::exec() { // Find the approopriate algorithm std::string method = this->getProperty("Method"); std::string child = "SofQW" + method; // Setup and run Algorithm_sptr childAlg = boost::dynamic_pointer_cast<Algorithm>( createChildAlgorithm(child, 0.0, 1.0)); // This will add the Method property to the child algorithm but it will be // ignored anyway... childAlg->copyPropertiesFrom(*this); childAlg->execute(); MatrixWorkspace_sptr outputWS = childAlg->getProperty("OutputWorkspace"); this->setProperty("OutputWorkspace", outputWS); }
// Private function to load parameter file specified by a full path name into // given workspace, returning success. bool LoadIDFFromNexus::loadParameterFile( const std::string &fullPathName, const MatrixWorkspace_sptr localWorkspace) { try { // load and also populate instrument parameters from this 'fallback' // parameter file Algorithm_sptr loadParamAlg = createChildAlgorithm("LoadParameterFile"); loadParamAlg->setProperty("Filename", fullPathName); loadParamAlg->setProperty("Workspace", localWorkspace); loadParamAlg->execute(); g_log.notice() << "Instrument parameter file: " << fullPathName << " has been loaded.\n\n"; return true; // Success } catch (std::runtime_error &) { g_log.debug() << "Instrument parameter file: " << fullPathName << " not found or un-parsable.\n"; return false; // Failure } }
void SofQW::exec() { // Find the approopriate algorithm std::string method = this->getProperty("Method"); std::string child = "SofQW" + method; // Setup and run Algorithm_sptr childAlg = boost::dynamic_pointer_cast<Algorithm>( createChildAlgorithm(child, 0.0, 1.0)); // This will add the Method property to the child algorithm but it will be // ignored anyway... childAlg->copyPropertiesFrom(*this); childAlg->execute(); MatrixWorkspace_sptr outputWS = childAlg->getProperty("OutputWorkspace"); this->setProperty("OutputWorkspace", outputWS); // Progress reports & cancellation MatrixWorkspace_const_sptr inputWorkspace = getProperty("InputWorkspace"); const size_t nHistos = inputWorkspace->getNumberHistograms(); auto m_progress = make_unique<Progress>(this, 0.0, 1.0, nHistos); m_progress->report("Creating output workspace"); }
bool ReflectometryReductionOneAuto::processGroups() { auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>( getPropertyValue("InputWorkspace")); const std::string outputIvsQ = this->getPropertyValue("OutputWorkspace"); const std::string outputIvsLam = this->getPropertyValue("OutputWorkspaceWavelength"); // Create a copy of ourselves Algorithm_sptr alg = this->createChildAlgorithm( this->name(), -1, -1, this->isLogging(), this->version()); alg->setChild(false); alg->setRethrows(true); // Copy all the non-workspace properties over std::vector<Property *> props = this->getProperties(); for (auto prop = props.begin(); prop != props.end(); ++prop) { if (*prop) { IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(*prop); if (!wsProp) alg->setPropertyValue((*prop)->name(), (*prop)->value()); } } // Check if the transmission runs are groups or not const std::string firstTrans = this->getPropertyValue("FirstTransmissionRun"); WorkspaceGroup_sptr firstTransG; if (!firstTrans.empty()) { auto firstTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans); firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS); if (!firstTransG) alg->setProperty("FirstTransmissionRun", firstTrans); else if (group->size() != firstTransG->size()) throw std::runtime_error("FirstTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } const std::string secondTrans = this->getPropertyValue("SecondTransmissionRun"); WorkspaceGroup_sptr secondTransG; if (!secondTrans.empty()) { auto secondTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans); secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS); if (!secondTransG) alg->setProperty("SecondTransmissionRun", secondTrans); else if (group->size() != secondTransG->size()) throw std::runtime_error("SecondTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } std::vector<std::string> IvsQGroup, IvsLamGroup; // Execute algorithm over each group member (or period, if this is // multiperiod) size_t numMembers = group->size(); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); alg->setProperty("InputWorkspace", group->getItem(i)->name()); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); // Handle transmission runs if (firstTransG) alg->setProperty("FirstTransmissionRun", firstTransG->getItem(i)->name()); if (secondTransG) alg->setProperty("SecondTransmissionRun", secondTransG->getItem(i)->name()); alg->execute(); IvsQGroup.push_back(IvsQName); IvsLamGroup.push_back(IvsLamName); // We use the first group member for our thetaout value if (i == 0) this->setPropertyValue("ThetaOut", alg->getPropertyValue("ThetaOut")); } // Group the IvsQ and IvsLam workspaces Algorithm_sptr groupAlg = this->createChildAlgorithm("GroupWorkspaces"); groupAlg->setChild(false); groupAlg->setRethrows(true); groupAlg->setProperty("InputWorkspaces", IvsLamGroup); groupAlg->setProperty("OutputWorkspace", outputIvsLam); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQ); groupAlg->execute(); // If this is a multiperiod workspace and we have polarization corrections // enabled if (this->getPropertyValue("PolarizationAnalysis") != noPolarizationCorrectionMode()) { if (group->isMultiperiod()) { // Perform polarization correction over the IvsLam group Algorithm_sptr polAlg = this->createChildAlgorithm("PolarizationCorrection"); polAlg->setChild(false); polAlg->setRethrows(true); polAlg->setProperty("InputWorkspace", outputIvsLam); polAlg->setProperty("OutputWorkspace", outputIvsLam); polAlg->setProperty("PolarizationAnalysis", this->getPropertyValue("PolarizationAnalysis")); polAlg->setProperty("CPp", this->getPropertyValue(cppLabel())); polAlg->setProperty("CRho", this->getPropertyValue(crhoLabel())); polAlg->setProperty("CAp", this->getPropertyValue(cApLabel())); polAlg->setProperty("CAlpha", this->getPropertyValue(cAlphaLabel())); polAlg->execute(); // Now we've overwritten the IvsLam workspaces, we'll need to recalculate // the IvsQ ones alg->setProperty("FirstTransmissionRun", ""); alg->setProperty("SecondTransmissionRun", ""); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); alg->setProperty("InputWorkspace", IvsLamName); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); } } else { g_log.warning("Polarization corrections can only be performed on " "multiperiod workspaces."); } } // We finished successfully this->setPropertyValue("OutputWorkspace", outputIvsQ); this->setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); setExecuted(true); notificationCenter().postNotification( new FinishedNotification(this, isExecuted())); return true; }
/** Execute the algorithm. */ void LoadLiveData::exec() { // The full, post-processed output workspace m_outputWS = this->getProperty("OutputWorkspace"); // Validate inputs if (this->hasPostProcessing()) { if (this->getPropertyValue("AccumulationWorkspace").empty()) throw std::invalid_argument("Must specify the AccumulationWorkspace " "parameter if using PostProcessing."); // The accumulated but not post-processed output workspace m_accumWS = this->getProperty("AccumulationWorkspace"); } else { // No post-processing, so the accumulation and output are the same m_accumWS = m_outputWS; } // Get or create the live listener ILiveListener_sptr listener = this->getLiveListener(); // Do we need to reset the data? bool dataReset = listener->dataReset(); // The listener returns a MatrixWorkspace containing the chunk of live data. Workspace_sptr chunkWS; bool dataNotYetGiven = true; while (dataNotYetGiven) { try { chunkWS = listener->extractData(); dataNotYetGiven = false; } catch (Exception::NotYet &ex) { g_log.warning() << "The " << listener->name() << " is not ready to return data: " << ex.what() << "\n"; g_log.warning() << "Trying again in 10 seconds - cancel the algorithm to stop.\n"; const int tenSeconds = 40; for (int i = 0; i < tenSeconds; ++i) { Poco::Thread::sleep(10000 / tenSeconds); // 250 ms this->interruption_point(); } } } // TODO: Have the ILiveListener tell me exactly the time stamp DateAndTime lastTimeStamp = DateAndTime::getCurrentTime(); this->setPropertyValue("LastTimeStamp", lastTimeStamp.toISO8601String()); // Now we process the chunk Workspace_sptr processed = this->processChunk(chunkWS); bool PreserveEvents = this->getProperty("PreserveEvents"); EventWorkspace_sptr processedEvent = boost::dynamic_pointer_cast<EventWorkspace>(processed); if (!PreserveEvents && processedEvent) { // Convert the monitor workspace, if there is one and it's necessary MatrixWorkspace_sptr monitorWS = processedEvent->monitorWorkspace(); auto monitorEventWS = boost::dynamic_pointer_cast<EventWorkspace>(monitorWS); if (monitorEventWS) { auto monAlg = this->createChildAlgorithm("ConvertToMatrixWorkspace"); monAlg->setProperty("InputWorkspace", monitorEventWS); monAlg->executeAsChildAlg(); if (!monAlg->isExecuted()) g_log.error( "Failed to convert monitors from events to histogram form."); monitorWS = monAlg->getProperty("OutputWorkspace"); } // Now do the main workspace Algorithm_sptr alg = this->createChildAlgorithm("ConvertToMatrixWorkspace"); alg->setProperty("InputWorkspace", processedEvent); std::string outputName = "__anonymous_livedata_convert_" + this->getPropertyValue("OutputWorkspace"); alg->setPropertyValue("OutputWorkspace", outputName); alg->execute(); if (!alg->isExecuted()) throw std::runtime_error("Error when calling ConvertToMatrixWorkspace " "(since PreserveEvents=False). See log."); // Replace the "processed" workspace with the converted one. MatrixWorkspace_sptr temp = alg->getProperty("OutputWorkspace"); if (monitorWS) temp->setMonitorWorkspace(monitorWS); // Set back the monitor workspace processed = temp; } // How do we accumulate the data? std::string accum = this->getPropertyValue("AccumulationMethod"); // If the AccumulationWorkspace does not exist, we always replace the // AccumulationWorkspace. // Also, if the listener said we are resetting the data, then we clear out the // old. if (!m_accumWS || dataReset) accum = "Replace"; g_log.notice() << "Performing the " << accum << " operation.\n"; // Perform the accumulation and set the AccumulationWorkspace workspace if (accum == "Replace") this->replaceChunk(processed); else if (accum == "Append") this->appendChunk(processed); else // Default to Add. this->addChunk(processed); // At this point, m_accumWS is set. if (this->hasPostProcessing()) { // ----------- Run post-processing ------------- this->runPostProcessing(); // Set both output workspaces this->setProperty("AccumulationWorkspace", m_accumWS); this->setProperty("OutputWorkspace", m_outputWS); doSortEvents(m_outputWS); } else { // ----------- No post-processing ------------- m_outputWS = m_accumWS; // We DO NOT set AccumulationWorkspace. this->setProperty("OutputWorkspace", m_outputWS); } // Output group requires some additional handling WorkspaceGroup_sptr out_gws = boost::dynamic_pointer_cast<WorkspaceGroup>(m_outputWS); if (out_gws) { size_t n = static_cast<size_t>(out_gws->getNumberOfEntries()); for (size_t i = 0; i < n; ++i) { auto ws = out_gws->getItem(i); std::string itemName = ws->name(); std::string wsName = getPropertyValue("OutputWorkspace") + "_" + std::to_string(i + 1); if (wsName != itemName) { if (AnalysisDataService::Instance().doesExist(itemName)) { // replace the temporary name with the proper one AnalysisDataService::Instance().rename(itemName, wsName); } } else { // touch the workspace in the ADS to issue a notification to update the // GUI AnalysisDataService::Instance().addOrReplace(itemName, ws); } } } }
/** Process groups. Groups are processed differently depending on transmission * runs and polarization analysis. If transmission run is a matrix workspace, it * will be applied to each of the members in the input workspace group. If * transmission run is a workspace group, the behaviour is different depending * on polarization analysis. If polarization analysis is off (i.e. * 'PolarizationAnalysis' is set to 'None') each item in the transmission group * is associated with the corresponding item in the input workspace group. If * polarization analysis is on (i.e. 'PolarizationAnalysis' is 'PA' or 'PNR') * items in the transmission group will be summed to produce a matrix workspace * that will be applied to each of the items in the input workspace group. See * documentation of this algorithm for more details. */ bool ReflectometryReductionOneAuto2::processGroups() { // this algorithm effectively behaves as MultiPeriodGroupAlgorithm m_usingBaseProcessGroups = true; // Get our input workspace group auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>( getPropertyValue("InputWorkspace")); // Get name of IvsQ workspace (native binning) const std::string outputIvsQ = getPropertyValue("OutputWorkspace"); // Get name of IvsQ (native binning) workspace const std::string outputIvsQBinned = getPropertyValue("OutputWorkspaceBinned"); // Get name of IvsLam workspace const std::string outputIvsLam = getPropertyValue("OutputWorkspaceWavelength"); // Create a copy of ourselves Algorithm_sptr alg = createChildAlgorithm(name(), -1, -1, isLogging(), version()); alg->setChild(false); alg->setRethrows(true); // Copy all the non-workspace properties over const std::vector<Property *> props = getProperties(); for (auto &prop : props) { if (prop) { IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop); if (!wsProp) alg->setPropertyValue(prop->name(), prop->value()); } } const bool polarizationAnalysisOn = getPropertyValue("PolarizationAnalysis") != "None"; // Check if the transmission runs are groups or not const std::string firstTrans = getPropertyValue("FirstTransmissionRun"); WorkspaceGroup_sptr firstTransG; MatrixWorkspace_sptr firstTransSum; if (!firstTrans.empty()) { auto firstTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans); firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS); if (!firstTransG) { alg->setProperty("FirstTransmissionRun", firstTrans); } else if (polarizationAnalysisOn) { firstTransSum = sumTransmissionWorkspaces(firstTransG); } } const std::string secondTrans = getPropertyValue("SecondTransmissionRun"); WorkspaceGroup_sptr secondTransG; MatrixWorkspace_sptr secondTransSum; if (!secondTrans.empty()) { auto secondTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans); secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS); if (!secondTransG) { alg->setProperty("SecondTransmissionRun", secondTrans); } else if (polarizationAnalysisOn) { secondTransSum = sumTransmissionWorkspaces(secondTransG); } } std::vector<std::string> IvsQGroup, IvsQUnbinnedGroup, IvsLamGroup; // Execute algorithm over each group member for (size_t i = 0; i < group->size(); ++i) { const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1); const std::string IvsQBinnedName = outputIvsQBinned + "_" + std::to_string(i + 1); const std::string IvsLamName = outputIvsLam + "_" + std::to_string(i + 1); if (firstTransG) { if (!polarizationAnalysisOn) alg->setProperty("FirstTransmissionRun", firstTransG->getItem(i)->getName()); else alg->setProperty("FirstTransmissionRun", firstTransSum); } if (secondTransG) { if (!polarizationAnalysisOn) alg->setProperty("SecondTransmissionRun", secondTransG->getItem(i)->getName()); else alg->setProperty("SecondTransmissionRun", secondTransSum); } alg->setProperty("InputWorkspace", group->getItem(i)->getName()); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceBinned", IvsQBinnedName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); IvsQGroup.push_back(IvsQName); IvsQUnbinnedGroup.push_back(IvsQBinnedName); IvsLamGroup.push_back(IvsLamName); } // Group the IvsQ and IvsLam workspaces Algorithm_sptr groupAlg = createChildAlgorithm("GroupWorkspaces"); groupAlg->setChild(false); groupAlg->setRethrows(true); groupAlg->setProperty("InputWorkspaces", IvsLamGroup); groupAlg->setProperty("OutputWorkspace", outputIvsLam); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQ); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQUnbinnedGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQBinned); groupAlg->execute(); // Set other properties so they can be updated in the Reflectometry interface setPropertyValue("ThetaIn", alg->getPropertyValue("ThetaIn")); setPropertyValue("MomentumTransferMin", alg->getPropertyValue("MomentumTransferMin")); setPropertyValue("MomentumTransferMax", alg->getPropertyValue("MomentumTransferMax")); setPropertyValue("MomentumTransferStep", alg->getPropertyValue("MomentumTransferStep")); setPropertyValue("ScaleFactor", alg->getPropertyValue("ScaleFactor")); if (!polarizationAnalysisOn) { // No polarization analysis. Reduction stops here setPropertyValue("OutputWorkspace", outputIvsQ); setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned); setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); return true; } if (!group->isMultiperiod()) { g_log.warning("Polarization corrections can only be performed on " "multiperiod workspaces."); setPropertyValue("OutputWorkspace", outputIvsQ); setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned); setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); return true; } Algorithm_sptr polAlg = createChildAlgorithm("PolarizationCorrection"); polAlg->setChild(false); polAlg->setRethrows(true); polAlg->setProperty("InputWorkspace", outputIvsLam); polAlg->setProperty("OutputWorkspace", outputIvsLam); polAlg->setProperty("PolarizationAnalysis", getPropertyValue("PolarizationAnalysis")); polAlg->setProperty("CPp", getPropertyValue("CPp")); polAlg->setProperty("CRho", getPropertyValue("CRho")); polAlg->setProperty("CAp", getPropertyValue("CAp")); polAlg->setProperty("CAlpha", getPropertyValue("CAlpha")); polAlg->execute(); // Now we've overwritten the IvsLam workspaces, we'll need to recalculate // the IvsQ ones alg->setProperty("FirstTransmissionRun", ""); alg->setProperty("SecondTransmissionRun", ""); alg->setProperty("CorrectionAlgorithm", "None"); alg->setProperty("ThetaIn", Mantid::EMPTY_DBL()); alg->setProperty("ProcessingInstructions", "0"); for (size_t i = 0; i < group->size(); ++i) { const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1); const std::string IvsQBinnedName = outputIvsQBinned + "_" + std::to_string(i + 1); const std::string IvsLamName = outputIvsLam + "_" + std::to_string(i + 1); alg->setProperty("InputWorkspace", IvsLamName); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceBinned", IvsQBinnedName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); } setPropertyValue("OutputWorkspace", outputIvsQ); setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned); setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); return true; }
void Load::loadMultipleFiles() { // allFilenames contains "rows" of filenames. If the row has more than 1 file // in it // then that row is to be summed across each file in the row const std::vector<std::vector<std::string>> allFilenames = getProperty("Filename"); std::string outputWsName = getProperty("OutputWorkspace"); std::vector<std::string> wsNames(allFilenames.size()); std::transform(allFilenames.begin(), allFilenames.end(), wsNames.begin(), generateWsNameFromFileNames); auto wsName = wsNames.cbegin(); assert(allFilenames.size() == wsNames.size()); std::vector<API::Workspace_sptr> loadedWsList; loadedWsList.reserve(allFilenames.size()); Workspace_sptr tempWs; // Cycle through the filenames and wsNames. for (auto filenames = allFilenames.cbegin(); filenames != allFilenames.cend(); ++filenames, ++wsName) { auto filename = filenames->cbegin(); Workspace_sptr sumWS = loadFileToWs(*filename, *wsName); ++filename; for (; filename != filenames->cend(); ++filename) { tempWs = loadFileToWs(*filename, "__@loadsum_temp@"); sumWS = plusWs(sumWS, tempWs); } API::WorkspaceGroup_sptr group = boost::dynamic_pointer_cast<WorkspaceGroup>(sumWS); if (group) { std::vector<std::string> childWsNames = group->getNames(); auto childWsName = childWsNames.begin(); size_t count = 1; for (; childWsName != childWsNames.end(); ++childWsName, ++count) { Workspace_sptr childWs = group->getItem(*childWsName); const std::string childName = group->getName() + "_" + std::to_string(count); API::AnalysisDataService::Instance().addOrReplace(childName, childWs); // childWs->setName(group->getName() + "_" + // boost::lexical_cast<std::string>(count)); } } // Add the sum to the list of loaded workspace names. loadedWsList.push_back(sumWS); } // If we only have one loaded ws, set it as the output. if (loadedWsList.size() == 1) { setProperty("OutputWorkspace", loadedWsList[0]); AnalysisDataService::Instance().rename(loadedWsList[0]->getName(), outputWsName); } // Else we have multiple loaded workspaces - group them and set the group as // output. else { API::WorkspaceGroup_sptr group = groupWsList(loadedWsList); setProperty("OutputWorkspace", group); std::vector<std::string> childWsNames = group->getNames(); size_t count = 1; for (auto &childWsName : childWsNames) { if (childWsName == outputWsName) { Mantid::API::Workspace_sptr child = group->getItem(childWsName); // child->setName(child->getName() + "_" + // boost::lexical_cast<std::string>(count)); const std::string childName = child->getName() + "_" + std::to_string(count); API::AnalysisDataService::Instance().addOrReplace(childName, child); count++; } } childWsNames = group->getNames(); count = 1; for (auto &childWsName : childWsNames) { Workspace_sptr childWs = group->getItem(childWsName); std::string outWsPropName = "OutputWorkspace_" + std::to_string(count); ++count; declareProperty(Kernel::make_unique<WorkspaceProperty<Workspace>>( outWsPropName, childWsName, Direction::Output)); setProperty(outWsPropName, childWs); } } // Clean up. if (tempWs) { Algorithm_sptr alg = AlgorithmManager::Instance().createUnmanaged("DeleteWorkspace"); alg->initialize(); alg->setChild(true); alg->setProperty("Workspace", tempWs); alg->execute(); } }
bool ReflectometryReductionOneAuto::processGroups() { // isPolarizationCorrectionOn is used to decide whether // we should process our Transmission WorkspaceGroup members // as individuals (not multiperiod) when PolarizationCorrection is off, // or sum over all of the workspaces in the group // and used that sum as our TransmissionWorkspace when PolarizationCorrection // is on. const bool isPolarizationCorrectionOn = this->getPropertyValue("PolarizationAnalysis") != noPolarizationCorrectionMode(); // Get our input workspace group auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>( getPropertyValue("InputWorkspace")); // Get name of IvsQ workspace const std::string outputIvsQ = this->getPropertyValue("OutputWorkspace"); // Get name of IvsLam workspace const std::string outputIvsLam = this->getPropertyValue("OutputWorkspaceWavelength"); // Create a copy of ourselves Algorithm_sptr alg = this->createChildAlgorithm( this->name(), -1, -1, this->isLogging(), this->version()); alg->setChild(false); alg->setRethrows(true); // Copy all the non-workspace properties over std::vector<Property *> props = this->getProperties(); for (auto &prop : props) { if (prop) { IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop); if (!wsProp) alg->setPropertyValue(prop->name(), prop->value()); } } // Check if the transmission runs are groups or not const std::string firstTrans = this->getPropertyValue("FirstTransmissionRun"); WorkspaceGroup_sptr firstTransG; if (!firstTrans.empty()) { auto firstTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans); firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS); if (!firstTransG) { // we only have one transmission workspace, so we use it as it is. alg->setProperty("FirstTransmissionRun", firstTrans); } else if (group->size() != firstTransG->size() && !isPolarizationCorrectionOn) { // if they are not the same size then we cannot associate a transmission // group workspace member with every input group workpspace member. throw std::runtime_error("FirstTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } } const std::string secondTrans = this->getPropertyValue("SecondTransmissionRun"); WorkspaceGroup_sptr secondTransG; if (!secondTrans.empty()) { auto secondTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans); secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS); if (!secondTransG) // we only have one transmission workspace, so we use it as it is. alg->setProperty("SecondTransmissionRun", secondTrans); else if (group->size() != secondTransG->size() && !isPolarizationCorrectionOn) { // if they are not the same size then we cannot associate a transmission // group workspace member with every input group workpspace member. throw std::runtime_error("SecondTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } } std::vector<std::string> IvsQGroup, IvsLamGroup; // Execute algorithm over each group member (or period, if this is // multiperiod) size_t numMembers = group->size(); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); // If our transmission run is a group and PolarizationCorrection is on // then we sum our transmission group members. // // This is done inside of the for loop to avoid the wrong workspace being // used when these arguments are passed through to the exec() method. // If this is not set in the loop, exec() will fetch the first workspace // from the specified Transmission Group workspace that the user entered. if (firstTransG && isPolarizationCorrectionOn) { auto firstTransmissionSum = sumOverTransmissionGroup(firstTransG); alg->setProperty("FirstTransmissionRun", firstTransmissionSum); } if (secondTransG && isPolarizationCorrectionOn) { auto secondTransmissionSum = sumOverTransmissionGroup(secondTransG); alg->setProperty("SecondTransmissionRun", secondTransmissionSum); } // Otherwise, if polarization correction is off, we process them // using one transmission group member at a time. if (firstTransG && !isPolarizationCorrectionOn) // polarization off alg->setProperty("FirstTransmissionRun", firstTransG->getItem(i)->name()); if (secondTransG && !isPolarizationCorrectionOn) // polarization off alg->setProperty("SecondTransmissionRun", secondTransG->getItem(i)->name()); alg->setProperty("InputWorkspace", group->getItem(i)->name()); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); MatrixWorkspace_sptr tempFirstTransWS = alg->getProperty("FirstTransmissionRun"); IvsQGroup.push_back(IvsQName); IvsLamGroup.push_back(IvsLamName); // We use the first group member for our thetaout value if (i == 0) this->setPropertyValue("ThetaOut", alg->getPropertyValue("ThetaOut")); } // Group the IvsQ and IvsLam workspaces Algorithm_sptr groupAlg = this->createChildAlgorithm("GroupWorkspaces"); groupAlg->setChild(false); groupAlg->setRethrows(true); groupAlg->setProperty("InputWorkspaces", IvsLamGroup); groupAlg->setProperty("OutputWorkspace", outputIvsLam); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQ); groupAlg->execute(); // If this is a multiperiod workspace and we have polarization corrections // enabled if (isPolarizationCorrectionOn) { if (group->isMultiperiod()) { // Perform polarization correction over the IvsLam group Algorithm_sptr polAlg = this->createChildAlgorithm("PolarizationCorrection"); polAlg->setChild(false); polAlg->setRethrows(true); polAlg->setProperty("InputWorkspace", outputIvsLam); polAlg->setProperty("OutputWorkspace", outputIvsLam); polAlg->setProperty("PolarizationAnalysis", this->getPropertyValue("PolarizationAnalysis")); polAlg->setProperty("CPp", this->getPropertyValue(cppLabel())); polAlg->setProperty("CRho", this->getPropertyValue(crhoLabel())); polAlg->setProperty("CAp", this->getPropertyValue(cApLabel())); polAlg->setProperty("CAlpha", this->getPropertyValue(cAlphaLabel())); polAlg->execute(); // Now we've overwritten the IvsLam workspaces, we'll need to recalculate // the IvsQ ones alg->setProperty("FirstTransmissionRun", ""); alg->setProperty("SecondTransmissionRun", ""); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); alg->setProperty("InputWorkspace", IvsLamName); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("CorrectionAlgorithm", "None"); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); } } else { g_log.warning("Polarization corrections can only be performed on " "multiperiod workspaces."); } } // We finished successfully this->setPropertyValue("OutputWorkspace", outputIvsQ); this->setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); setExecuted(true); notificationCenter().postNotification( new FinishedNotification(this, isExecuted())); return true; }