/** * Integrate each spectra to get the number of counts * @param inputWS :: The workspace to integrate * @param indexMin :: The lower bound of the spectra to integrate * @param indexMax :: The upper bound of the spectra to integrate * @param lower :: The lower bound * @param upper :: The upper bound * @param outputWorkspace2D :: set to true to output a workspace 2D even if the input is an EventWorkspace * @returns A workspace containing the integrated counts */ MatrixWorkspace_sptr DetectorDiagnostic::integrateSpectra(MatrixWorkspace_sptr inputWS, const int indexMin, const int indexMax, const double lower, const double upper, const bool outputWorkspace2D) { g_log.debug() << "Integrating input spectra.\n"; // If the input spectra only has one bin, assume it has been integrated already // but we need to pass it to the algorithm so that a copy of the input workspace is // actually created to use for further calculations // get percentage completed estimates for now, t0 and when we've finished t1 double t0 = m_fracDone, t1 = advanceProgress(RTGetTotalCounts); IAlgorithm_sptr childAlg = createChildAlgorithm("Integration", t0, t1 ); childAlg->setProperty( "InputWorkspace", inputWS ); childAlg->setProperty( "StartWorkspaceIndex", indexMin ); childAlg->setProperty( "EndWorkspaceIndex", indexMax ); // pass inputed values straight to this integration trusting the checking done there childAlg->setProperty("RangeLower", lower ); childAlg->setProperty("RangeUpper", upper); childAlg->setPropertyValue("IncludePartialBins", "1"); childAlg->executeAsChildAlg(); // Convert to 2D if desired, and if the input was an EventWorkspace. MatrixWorkspace_sptr outputW = childAlg->getProperty("OutputWorkspace"); MatrixWorkspace_sptr finalOutputW = outputW; if (outputWorkspace2D && boost::dynamic_pointer_cast<EventWorkspace>(outputW)) { g_log.debug() << "Converting output Event Workspace into a Workspace2D." << std::endl; childAlg = createChildAlgorithm("ConvertToMatrixWorkspace", t0, t1 ); childAlg->setProperty("InputWorkspace", outputW); childAlg->executeAsChildAlg(); finalOutputW = childAlg->getProperty("OutputWorkspace"); } return finalOutputW; }
/** Carries out a normalisation based on the integrated count of the monitor over a range * @param inputWorkspace The input workspace * @param outputWorkspace The result workspace */ void NormaliseToMonitor::normaliseByIntegratedCount(API::MatrixWorkspace_sptr inputWorkspace, API::MatrixWorkspace_sptr& outputWorkspace) { // Add up all the bins so it's just effectively a single value with an error IAlgorithm_sptr integrate = createChildAlgorithm("Integration"); integrate->setProperty<MatrixWorkspace_sptr>("InputWorkspace", m_monitor); integrate->setProperty("RangeLower",m_integrationMin); integrate->setProperty("RangeUpper",m_integrationMax); integrate->setProperty<bool>("IncludePartialBins",getProperty("IncludePartialBins")); integrate->executeAsChildAlg(); // Get back the result m_monitor = integrate->getProperty("OutputWorkspace"); // Run the divide algorithm explicitly to enable progress reporting IAlgorithm_sptr divide = createChildAlgorithm("Divide",0.0,1.0); divide->setProperty<MatrixWorkspace_sptr>("LHSWorkspace", inputWorkspace); divide->setProperty<MatrixWorkspace_sptr>("RHSWorkspace", m_monitor); divide->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", outputWorkspace); divide->executeAsChildAlg(); // Get back the result outputWorkspace = divide->getProperty("OutputWorkspace"); }
/** Runs MaskDetectors as a child algorithm on the input workspace. * @param inputWS The input workspace * @param maskWS A masking workspace */ void StepScan::runMaskDetectors(MatrixWorkspace_sptr inputWS, MatrixWorkspace_sptr maskWS) { IAlgorithm_sptr maskingAlg = createChildAlgorithm("MaskDetectors"); maskingAlg->setProperty<MatrixWorkspace_sptr>("Workspace", inputWS); maskingAlg->setProperty<MatrixWorkspace_sptr>("MaskedWorkspace", maskWS); maskingAlg->executeAsChildAlg(); }
/** * It's assumed that both the flux reference files are simple Nexus * files since they have to produced by hand by the instrument * scientists. A simple Load algorithm should suffice. */ MatrixWorkspace_sptr SANSBeamFluxCorrection::loadReference() { const std::string referenceFluxFile = getPropertyValue("ReferenceFluxFilename"); Poco::Path path(referenceFluxFile); const std::string entryName = "SANSBeamFluxCorrection_" + path.getBaseName(); std::string fluxRefWSName = "__beam_flux_reference_" + path.getBaseName(); // Load reference flux as needed MatrixWorkspace_sptr fluxRefWS; if (m_reductionManager->existsProperty(entryName)) { fluxRefWS = m_reductionManager->getProperty(entryName); fluxRefWSName = m_reductionManager->getPropertyValue(entryName); m_output_message += " | Using flux reference " + referenceFluxFile + "\n"; } else { IAlgorithm_sptr loadAlg = createChildAlgorithm("Load"); loadAlg->setProperty("Filename", referenceFluxFile); loadAlg->executeAsChildAlg(); Workspace_sptr tmpWS = loadAlg->getProperty("OutputWorkspace"); fluxRefWS = boost::dynamic_pointer_cast<MatrixWorkspace>(tmpWS); m_output_message += " | Loaded flux reference " + referenceFluxFile + "\n"; // Keep the reference data for later use AnalysisDataService::Instance().addOrReplace(fluxRefWSName, fluxRefWS); m_reductionManager->declareProperty( new WorkspaceProperty<>(entryName, fluxRefWSName, Direction::InOut)); m_reductionManager->setPropertyValue(entryName, fluxRefWSName); m_reductionManager->setProperty(entryName, fluxRefWS); } return fluxRefWS; }
/** Uses Polynomial as a ChildAlgorithm to fit the log of the exponential curve * expected for the transmission. * @param[in] WS The single-spectrum workspace to fit * @param[in] order The order of the polynomial from 2 to 6 * @param[out] coeficients of the polynomial. c[0] + c[1]x + c[2]x^2 + ... */ API::MatrixWorkspace_sptr CalculateTransmission::fitPolynomial(API::MatrixWorkspace_sptr WS, int order, std::vector<double> &coeficients) { g_log.notice("Fitting the experimental transmission curve fitpolyno"); double start = m_done; IAlgorithm_sptr childAlg = createChildAlgorithm("Fit", start, m_done = 0.9); auto polyfit = API::FunctionFactory::Instance().createFunction("Polynomial"); polyfit->setAttributeValue("n", order); polyfit->initialize(); childAlg->setProperty("Function", polyfit); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", WS); childAlg->setProperty("Minimizer", "Levenberg-MarquardtMD"); childAlg->setProperty("CreateOutput", true); childAlg->setProperty("IgnoreInvalidData", true); childAlg->executeAsChildAlg(); std::string fitStatus = childAlg->getProperty("OutputStatus"); if (fitStatus != "success") { g_log.error("Unable to successfully fit the data: " + fitStatus); throw std::runtime_error("Unable to successfully fit the data"); } // Only get to here if successful coeficients.resize(order + 1); for (int i = 0; i <= order; i++) { coeficients[i] = polyfit->getParameter(i); } return this->extractSpectra(childAlg->getProperty("OutputWorkspace"), std::vector<size_t>(1, 1)); }
/** * This function gets the input workspace. In the case for a RebinnedOutput * workspace, it must be cleaned before proceeding. Other workspaces are * untouched. * @return the input workspace, cleaned if necessary */ MatrixWorkspace_sptr Integration::getInputWorkspace() { MatrixWorkspace_sptr temp = getProperty("InputWorkspace"); if (temp->id() == "RebinnedOutput") { // Clean the input workspace in the RebinnedOutput case for nan's and // inf's in order to treat the data correctly later. IAlgorithm_sptr alg = this->createChildAlgorithm("ReplaceSpecialValues"); alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", temp); std::string outName = "_" + temp->getName() + "_clean"; alg->setProperty("OutputWorkspace", outName); alg->setProperty("NaNValue", 0.0); alg->setProperty("NaNError", 0.0); alg->setProperty("InfinityValue", 0.0); alg->setProperty("InfinityError", 0.0); alg->executeAsChildAlg(); temp = alg->getProperty("OutputWorkspace"); } // To integrate point data it will be converted to histograms if (!temp->isHistogramData()) { auto alg = this->createChildAlgorithm("ConvertToHistogram"); alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", temp); std::string outName = "_" + temp->getName() + "_histogram"; alg->setProperty("OutputWorkspace", outName); alg->executeAsChildAlg(); temp = alg->getProperty("OutputWorkspace"); temp->setDistribution(true); } return temp; }
/** Execute the algorithm. */ void ConvertDiffCal::exec() { OffsetsWorkspace_const_sptr offsetsWS = getProperty("OffsetsWorkspace"); // initial setup of new style config ITableWorkspace_sptr configWksp = boost::make_shared<TableWorkspace>(); configWksp->addColumn("int", "detid"); configWksp->addColumn("double", "difc"); configWksp->addColumn("double", "difa"); configWksp->addColumn("double", "tzero"); // create values in the table const size_t numberOfSpectra = offsetsWS->getNumberHistograms(); Progress progress(this, 0.0, 1.0, numberOfSpectra); for (size_t i = 0; i < numberOfSpectra; ++i) { API::TableRow newrow = configWksp->appendRow(); newrow << static_cast<int>(getDetID(offsetsWS, i)); newrow << calculateDIFC(offsetsWS, i); newrow << 0.; // difa newrow << 0.; // tzero progress.report(); } // sort the results IAlgorithm_sptr sortTable = createChildAlgorithm("SortTableWorkspace"); sortTable->setProperty("InputWorkspace", configWksp); sortTable->setProperty("OutputWorkspace", configWksp); sortTable->setPropertyValue("Columns", "detid"); sortTable->executeAsChildAlg(); // copy over the results configWksp = sortTable->getProperty("OutputWorkspace"); setProperty("OutputWorkspace", configWksp); }
/** Executes the algorithm * * @throw Exception::FileError If the grouping file cannot be opened or read *successfully */ void GetDetOffsetsMultiPeaks::exec() { // Process input information processProperties(); // Create information workspaces createInformationWorkspaces(); // Calculate offset of each detector calculateDetectorsOffsets(); // Return the output setProperty("OutputWorkspace", m_outputW); setProperty("NumberPeaksWorkspace", m_outputNP); setProperty("MaskWorkspace", m_maskWS); setProperty("FittedResolutionWorkspace", m_resolutionWS); setProperty("SpectraFitInfoTableWorkspace", m_infoTableWS); setProperty("PeaksOffsetTableWorkspace", m_peakOffsetTableWS); // Also save to .cal file, if requested std::string filename = getProperty("GroupingFileName"); if (!filename.empty()) { progress(0.9, "Saving .cal file"); IAlgorithm_sptr childAlg = createChildAlgorithm("SaveCalFile"); childAlg->setProperty("OffsetsWorkspace", m_outputW); childAlg->setProperty("MaskWorkspace", m_maskWS); childAlg->setPropertyValue("Filename", filename); childAlg->executeAsChildAlg(); } // Make summary progress(0.92, "Making summary"); makeFitSummary(); return; }
/** Pulls the monitor spectrum out of a larger workspace * @param WS :: The workspace containing the spectrum to extract * @param index :: The index of the spectrum to extract * @returns A workspace containing the single spectrum requested */ API::MatrixWorkspace_sptr NormaliseToMonitor::extractMonitorSpectrum(API::MatrixWorkspace_sptr WS, const std::size_t index) { IAlgorithm_sptr childAlg = createChildAlgorithm("ExtractSingleSpectrum"); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", WS); childAlg->setProperty<int>("WorkspaceIndex", static_cast<int>(index)); childAlg->executeAsChildAlg(); MatrixWorkspace_sptr outWS = childAlg->getProperty("OutputWorkspace"); IAlgorithm_sptr alg = createChildAlgorithm("ConvertToMatrixWorkspace"); alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", outWS); alg->executeAsChildAlg(); outWS = alg->getProperty("OutputWorkspace"); // Only get to here if successful return outWS; }
/** Load the logs from the input NeXus file. * * @param nexusFileName :: Name of the NeXus file to load logs from. * @param localWorkspace :: MatrixWorkspace in which to put the logs. * @param alg :: Handle of an algorithm for logging access. * @return true if successful. */ bool AppendGeometryToSNSNexus::runLoadNexusLogs( const std::string &nexusFileName, API::MatrixWorkspace_sptr localWorkspace, Algorithm *alg) { IAlgorithm_sptr loadLogs = alg->createChildAlgorithm("LoadNexusLogs", 0, 1, true); // Execute the Child Algorithm, catching errors without stopping. bool executionSuccessful(true); try { alg->getLogger().information() << "Loading logs from the NeXus file..." << std::endl; loadLogs->setPropertyValue("Filename", nexusFileName); loadLogs->setProperty<MatrixWorkspace_sptr>("Workspace", localWorkspace); loadLogs->executeAsChildAlg(); } catch (std::invalid_argument &e) { alg->getLogger().information( "Invalid argument to LoadNexusLogs Child Algorithm"); alg->getLogger().information(e.what()); executionSuccessful = false; } catch (std::runtime_error &) { alg->getLogger().information( "Unable to successfully run runLoadNexusLogs Child Algorithm./n"); executionSuccessful = false; } return executionSuccessful; }
/** Uses 'Linear' as a ChildAlgorithm to fit the log of the exponential curve * expected for the transmission. * @param[in] WS The single-spectrum workspace to fit * @param[out] grad The single-spectrum workspace to fit * @param[out] offset The single-spectrum workspace to fit * @return A workspace containing the fit * @throw runtime_error if the Linear algorithm fails during execution */ API::MatrixWorkspace_sptr CalculateTransmission::fitData(API::MatrixWorkspace_sptr WS, double &grad, double &offset) { g_log.information("Fitting the experimental transmission curve"); double start = m_done; IAlgorithm_sptr childAlg = createChildAlgorithm("Fit", start, m_done = 0.9); auto linearBack = API::FunctionFactory::Instance().createFunction("LinearBackground"); childAlg->setProperty("Function", linearBack); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", WS); childAlg->setProperty("Minimizer", "Levenberg-MarquardtMD"); childAlg->setProperty("CreateOutput", true); childAlg->setProperty("IgnoreInvalidData", true); childAlg->executeAsChildAlg(); std::string fitStatus = childAlg->getProperty("OutputStatus"); if (fitStatus != "success") { g_log.error("Unable to successfully fit the data: " + fitStatus); throw std::runtime_error("Unable to successfully fit the data"); } // Only get to here if successful offset = linearBack->getParameter(0); grad = linearBack->getParameter(1); return this->extractSpectra(childAlg->getProperty("OutputWorkspace"), std::vector<size_t>(1, 1)); }
/** * Extracts multiple spectra from a Workspace2D into a new workspaces, using *SumSpectra. * * @param ws :: The workspace containing the spectrum to extract * @param indices :: The workspace index of the spectrum to extract * * @returns a Workspace2D containing the extracted spectrum * @throws runtime_error if the ExtractSingleSpectrum algorithm fails during *execution */ API::MatrixWorkspace_sptr CalculateTransmission::extractSpectra(API::MatrixWorkspace_sptr ws, const std::vector<size_t> &indices) { // Compile a comma separated list of indices that we can pass to SumSpectra. std::vector<std::string> indexStrings(indices.size()); // A bug in boost 1.53: https://svn.boost.org/trac/boost/ticket/7421 // means that lexical_cast cannot be used directly as the call is ambiguous // so we need to define a function pointer that can resolve the overloaded // lexical_cast function typedef std::string (*from_size_t)(const size_t &); std::transform(indices.begin(), indices.end(), indexStrings.begin(), (from_size_t)boost::lexical_cast<std::string, size_t>); const std::string commaIndexList = boost::algorithm::join(indexStrings, ","); double start = m_done; IAlgorithm_sptr childAlg = createChildAlgorithm("SumSpectra", start, m_done += 0.1); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", ws); childAlg->setPropertyValue("ListOfWorkspaceIndices", commaIndexList); childAlg->executeAsChildAlg(); // Only get to here if successful return childAlg->getProperty("OutputWorkspace"); }
/** Execute the algorithm. */ void TransformMD::exec() { Mantid::API::IMDWorkspace_sptr inWS; Mantid::API::IMDWorkspace_sptr outWS; inWS = getProperty("InputWorkspace"); outWS = getProperty("OutputWorkspace"); if (boost::dynamic_pointer_cast<MatrixWorkspace>(inWS)) throw std::runtime_error("TransformMD can only transform a " "MDHistoWorkspace or a MDEventWorkspace."); if (outWS != inWS) { // NOT in-place. So first we clone inWS into outWS IAlgorithm_sptr clone = this->createChildAlgorithm("CloneMDWorkspace", 0.0, 0.5, true); clone->setProperty("InputWorkspace", inWS); clone->executeAsChildAlg(); outWS = clone->getProperty("OutputWorkspace"); } if (!outWS) throw std::runtime_error("Invalid output workspace."); size_t nd = outWS->getNumDims(); m_scaling = getProperty("Scaling"); m_offset = getProperty("Offset"); // Replicate single values if (m_scaling.size() == 1) m_scaling = std::vector<double>(nd, m_scaling[0]); if (m_offset.size() == 1) m_offset = std::vector<double>(nd, m_offset[0]); // Check the size if (m_scaling.size() != nd) throw std::invalid_argument("Scaling argument must be either length 1 or " "match the number of dimensions."); if (m_offset.size() != nd) throw std::invalid_argument("Offset argument must be either length 1 or " "match the number of dimensions."); // Transform the dimensions outWS->transformDimensions(m_scaling, m_offset); MDHistoWorkspace_sptr histo = boost::dynamic_pointer_cast<MDHistoWorkspace>(outWS); IMDEventWorkspace_sptr event = boost::dynamic_pointer_cast<IMDEventWorkspace>(outWS); if (histo) { // Recalculate all the values since the dimensions changed. histo->cacheValues(); } else if (event) { // Call the method for this type of MDEventWorkspace. CALL_MDEVENT_FUNCTION(this->doTransform, outWS); } this->setProperty("OutputWorkspace", outWS); }
void StripVanadiumPeaks2::exec(){ // 1. Process input/output API::MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace"); std::string outputWSName = getPropertyValue("OutputWorkspace"); int singleIndex = getProperty("WorkspaceIndex"); int param_fwhm = getProperty("FWHM"); int param_tolerance = getProperty("Tolerance"); bool singleSpectrum = !isEmpty(singleIndex); // 2. Call StripPeaks std::string peakpositions; std::string unit = inputWS->getAxis(0)->unit()->unitID(); if (unit == "dSpacing") { peakpositions = "0.5044,0.5191,0.5350,0.5526,0.5936,0.6178,0.6453,0.6768,0.7134,0.7566,0.8089,0.8737,0.9571,1.0701,1.2356,1.5133,2.1401"; } else if (unit == "MomentumTransfer") { g_log.error() << "Unit MomentumTransfer (Q-space) is NOT supported by StripVanadiumPeaks now.\n"; throw std::invalid_argument("Q-space is not supported"); // Comment out next line as it won't be reached. //peakpositions = "2.9359, 4.1520, 5.0851, 5.8716, 6.5648, 7.1915, 7.7676, 8.3045, 8.8074, 9.2837, 9.7368, 10.1703, 10.5849, 11.3702, 11.7443, 12.1040, 12.4568"; } else { g_log.error() << "Unit " << unit << " Is NOT supported by StripVanadiumPeaks, which only supports d-spacing" << std::endl; throw std::invalid_argument("Not supported unit"); } // Call StripPeak double pro0 = 0.0; double prof = 1.0; bool sublog = true; IAlgorithm_sptr stripPeaks = createChildAlgorithm("StripPeaks", pro0, prof, sublog); stripPeaks->setProperty("InputWorkspace", inputWS); stripPeaks->setPropertyValue("OutputWorkspace", outputWSName); stripPeaks->setProperty("FWHM", param_fwhm); stripPeaks->setProperty("Tolerance", param_tolerance); stripPeaks->setPropertyValue("PeakPositions", peakpositions); stripPeaks->setProperty<std::string>("BackgroundType", getProperty("BackgroundType")); stripPeaks->setProperty<bool>("HighBackground", getProperty("HighBackground")); if (singleSpectrum){ stripPeaks->setProperty("WorkspaceIndex", singleIndex); } stripPeaks->setProperty<double>("PeakPositionTolerance", getProperty("PeakPositionTolerance")); stripPeaks->executeAsChildAlg(); // 3. Get and set output workspace // API::MatrixWorkspace_sptr outputWS = AnalysisDataService::Instance().retrieveWS<API::MatrixWorkspace_sptr>(outputWSName); // boost::shared_ptr<API::Workspace> outputWS = AnalysisDataService::Instance().retrieve(outputWSName); API::MatrixWorkspace_sptr outputWS = stripPeaks->getProperty("OutputWorkspace"); this->setProperty("OutputWorkspace", outputWS); return; }
/** Calls the Rebin algorithm as a ChildAlgorithm. * @param workspace The workspace to use as input to the Rebin algorithms * @param params The rebin parameters * @return A shared pointer to the output (rebinned) workspace * @throw std::runtime_error If the Rebin algorithm fails */ API::MatrixWorkspace_sptr MergeRuns::rebinInput(const API::MatrixWorkspace_sptr &workspace, const std::vector<double> ¶ms) { // Create a Rebin child algorithm IAlgorithm_sptr rebin = createChildAlgorithm("Rebin"); rebin->setProperty("InputWorkspace", workspace); rebin->setProperty("Params", params); rebin->executeAsChildAlg(); return rebin->getProperty("OutputWorkspace"); }
/** * Pulls the monitor spectra out of a larger workspace * @param ws * @param workspaceIndexes The indexes of the spectra to extract * @return A workspace containing the spectra requested */ MatrixWorkspace_sptr NormaliseToMonitor::extractMonitorSpectra( const MatrixWorkspace_sptr &ws, const std::vector<std::size_t> &workspaceIndexes) { IAlgorithm_sptr childAlg = createChildAlgorithm("ExtractSpectra"); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", ws); childAlg->setProperty("WorkspaceIndexList", workspaceIndexes); childAlg->executeAsChildAlg(); MatrixWorkspace_sptr outWS = childAlg->getProperty("OutputWorkspace"); return outWS; }
/** * Function to apply a given mask to a workspace. * @param inputWS : the workspace to mask * @param maskWS : the workspace containing the masking information */ void DetectorDiagnostic::applyMask(API::MatrixWorkspace_sptr inputWS, API::MatrixWorkspace_sptr maskWS) { IAlgorithm_sptr maskAlg = createChildAlgorithm("MaskDetectors"); // should set progress bar maskAlg->setProperty("Workspace", inputWS); maskAlg->setProperty("MaskedWorkspace", maskWS); maskAlg->setProperty("StartWorkspaceIndex", m_minIndex); maskAlg->setProperty("EndWorkspaceIndex", m_maxIndex); maskAlg->executeAsChildAlg(); }
/** Runs FilterByXValue as a child algorithm on the given workspace * @param inputWS The input workspace * @param xmin The minimum value of the filter * @param xmax The maximum value of the filter */ void StepScan::runFilterByXValue(MatrixWorkspace_sptr inputWS, const double xmin, const double xmax) { std::string rangeUnit = getProperty("RangeUnit"); // Run ConvertUnits on the input workspace if xmin/max were given in a // different unit if (rangeUnit != "TOF") { IAlgorithm_sptr convertUnits = createChildAlgorithm("ConvertUnits"); convertUnits->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputWS); convertUnits->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", inputWS); convertUnits->setProperty("Target", rangeUnit); // TODO: Emode/efixed? convertUnits->executeAsChildAlg(); } IAlgorithm_sptr filter = createChildAlgorithm("FilterByXValue"); filter->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputWS); filter->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", inputWS); filter->setProperty("XMin", xmin); filter->setProperty("XMax", xmax); filter->executeAsChildAlg(); }
/** Call Integration as a Child Algorithm * @return The integrated workspace */ MatrixWorkspace_sptr SumRowColumn::integrateWorkspace() { g_log.debug() << "Integrating input workspace\n"; IAlgorithm_sptr childAlg = createChildAlgorithm("Integration"); //pass inputed values straight to this Child Algorithm, checking must be done there childAlg->setProperty<MatrixWorkspace_sptr>( "InputWorkspace", getProperty("InputWorkspace") ); childAlg->setProperty<double>( "RangeLower", getProperty("XMin") ); childAlg->setProperty<double>( "RangeUpper", getProperty("XMax") ); childAlg->executeAsChildAlg(); return childAlg->getProperty("OutputWorkspace"); }
/** Calls rebin as Child Algorithm * @param binParams this string is passed to rebin as the "Params" property * @param ws the workspace to rebin * @return the resultant rebinned workspace * @throw runtime_error if the rebin algorithm fails during execution */ API::MatrixWorkspace_sptr CalculateTransmission::rebin(std::vector<double> &binParams, API::MatrixWorkspace_sptr ws) { double start = m_done; IAlgorithm_sptr childAlg = createChildAlgorithm("Rebin", start, m_done += 0.05); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", ws); childAlg->setProperty<std::vector<double>>("Params", binParams); childAlg->executeAsChildAlg(); // Only get to here if successful return childAlg->getProperty("OutputWorkspace"); }
/// Move the detector according to the beam center void EQSANSLoad::moveToBeamCenter() { // Check that we have a beam center defined, otherwise set the // default beam center if (isEmpty(m_center_x) || isEmpty(m_center_y)) { EQSANSInstrument::getDefaultBeamCenter(dataWS, m_center_x, m_center_y); g_log.information() << "Setting beam center to [" << m_center_x << ", " << m_center_y << "]\n"; return; } // Check that the center of the detector really is at (0,0) int nx_pixels = static_cast<int>( dataWS->getInstrument()->getNumberParameter("number-of-x-pixels")[0]); int ny_pixels = static_cast<int>( dataWS->getInstrument()->getNumberParameter("number-of-y-pixels")[0]); V3D pixel_first = dataWS->getInstrument()->getDetector(0)->getPos(); int detIDx = EQSANSInstrument::getDetectorFromPixel(nx_pixels - 1, 0, dataWS); int detIDy = EQSANSInstrument::getDetectorFromPixel(0, ny_pixels - 1, dataWS); V3D pixel_last_x = dataWS->getInstrument()->getDetector(detIDx)->getPos(); V3D pixel_last_y = dataWS->getInstrument()->getDetector(detIDy)->getPos(); double x_offset = (pixel_first.X() + pixel_last_x.X()) / 2.0; double y_offset = (pixel_first.Y() + pixel_last_y.Y()) / 2.0; double beam_ctr_x = 0.0; double beam_ctr_y = 0.0; EQSANSInstrument::getCoordinateFromPixel(m_center_x, m_center_y, dataWS, beam_ctr_x, beam_ctr_y); IAlgorithm_sptr mvAlg = createChildAlgorithm("MoveInstrumentComponent", 0.5, 0.50); mvAlg->setProperty<MatrixWorkspace_sptr>("Workspace", dataWS); mvAlg->setProperty("ComponentName", "detector1"); mvAlg->setProperty("X", -x_offset - beam_ctr_x); mvAlg->setProperty("Y", -y_offset - beam_ctr_y); mvAlg->setProperty("RelativePosition", true); mvAlg->executeAsChildAlg(); m_output_message += " Beam center offset: " + Poco::NumberFormatter::format(x_offset) + ", " + Poco::NumberFormatter::format(y_offset) + " m\n"; // m_output_message += " Beam center in real-space: " + // Poco::NumberFormatter::format(-x_offset-beam_ctr_x) // + ", " + Poco::NumberFormatter::format(-y_offset-beam_ctr_y) + " m\n"; g_log.information() << "Moving beam center to " << m_center_x << " " << m_center_y << '\n'; dataWS->mutableRun().addProperty("beam_center_x", m_center_x, "pixel", true); dataWS->mutableRun().addProperty("beam_center_y", m_center_y, "pixel", true); m_output_message += " Beam center: " + Poco::NumberFormatter::format(m_center_x) + ", " + Poco::NumberFormatter::format(m_center_y) + "\n"; }
/** Execute the algorithm. */ void MergeMDFiles::exec() { // clear disk buffer which can remain from previous runs // the existence/ usage of the buffer indicates if the algorithm works with // file based or memory based target workspaces; // pDiskBuffer = NULL; MultipleFileProperty *multiFileProp = dynamic_cast<MultipleFileProperty *>(getPointerToProperty("Filenames")); if (!multiFileProp) { throw std::logic_error( "Filenames property must have MultipleFileProperty type."); } m_Filenames = MultipleFileProperty::flattenFileNames(multiFileProp->operator()()); if (m_Filenames.size() == 0) throw std::invalid_argument("Must specify at least one filename."); std::string firstFile = m_Filenames[0]; std::string outputFile = getProperty("OutputFilename"); m_fileBasedTargetWS = false; if (!outputFile.empty()) { m_fileBasedTargetWS = true; if (Poco::File(outputFile).exists()) throw std::invalid_argument( " File " + outputFile + " already exists. Can not use existing file " "as the target to MergeMD files.\n" + " Use it as one of source files if you want to add MD data to it"); } // Start by loading the first file but just the box structure, no events, and // not file-backed // m_BoxStruct.loadBoxStructure(firstFile, IAlgorithm_sptr loader = createChildAlgorithm("LoadMD", 0.0, 0.05, false); loader->setPropertyValue("Filename", firstFile); loader->setProperty("MetadataOnly", false); loader->setProperty("BoxStructureOnly", true); loader->setProperty("FileBackEnd", false); loader->executeAsChildAlg(); IMDWorkspace_sptr result = (loader->getProperty("OutputWorkspace")); auto firstWS = boost::dynamic_pointer_cast<API::IMDEventWorkspace>(result); if (!firstWS) throw std::runtime_error( "Can not load MDEventWorkspace from initial file " + firstFile); // do the job this->doExecByCloning(firstWS, outputFile); m_OutIWS->setFileNeedsUpdating(false); setProperty("OutputWorkspace", m_OutIWS); }
/** Carries out a normalization based on the integrated count of the monitor * over a range * @param inputWorkspace The input workspace * @param outputWorkspace The result workspace * @param isSingleCountWorkspace Whether or not the input workspace is point *data with single counts per spectrum */ void NormaliseToMonitor::normaliseByIntegratedCount( const MatrixWorkspace_sptr &inputWorkspace, MatrixWorkspace_sptr &outputWorkspace, const bool isSingleCountWorkspace) { m_monitor = extractMonitorSpectra(m_monitor, m_workspaceIndexes); // If single counting no need to integrate, monitor already guaranteed to be a // single count if (!isSingleCountWorkspace) { // Add up all the bins so it's just effectively a series of values with // errors IAlgorithm_sptr integrate = createChildAlgorithm("Integration"); integrate->setProperty<MatrixWorkspace_sptr>("InputWorkspace", m_monitor); integrate->setProperty("RangeLower", m_integrationMin); integrate->setProperty("RangeUpper", m_integrationMax); integrate->setProperty<bool>("IncludePartialBins", getProperty("IncludePartialBins")); integrate->executeAsChildAlg(); m_monitor = integrate->getProperty("OutputWorkspace"); } EventWorkspace_sptr inputEvent = boost::dynamic_pointer_cast<EventWorkspace>(inputWorkspace); if (inputEvent) { // Run the divide algorithm explicitly to enable progress reporting IAlgorithm_sptr divide = createChildAlgorithm("Divide", 0.0, 1.0); divide->setProperty<MatrixWorkspace_sptr>("LHSWorkspace", inputWorkspace); divide->setProperty<MatrixWorkspace_sptr>("RHSWorkspace", m_monitor); divide->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", outputWorkspace); divide->executeAsChildAlg(); // Get back the result outputWorkspace = divide->getProperty("OutputWorkspace"); } else { performHistogramDivision(inputWorkspace, outputWorkspace); } }
/// Calls CropWorkspace as a Child Algorithm to remove bins from the start or end of a square workspace void RemoveBins::crop(const double& start, const double& end) { IAlgorithm_sptr childAlg = createChildAlgorithm("CropWorkspace"); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", boost::const_pointer_cast<MatrixWorkspace>(m_inputWorkspace)); childAlg->setProperty<double>("XMin", start); childAlg->setProperty<double>("XMax", end); childAlg->executeAsChildAlg(); // Only get to here if successful // Assign the result to the output workspace property MatrixWorkspace_sptr outputWS = childAlg->getProperty("OutputWorkspace"); setProperty("OutputWorkspace",outputWS); return; }
void AlignAndFocusPowder::convertOffsetsToCal( DataObjects::OffsetsWorkspace_sptr &offsetsWS) { if (!offsetsWS) return; IAlgorithm_sptr alg = createChildAlgorithm("ConvertDiffCal"); alg->setProperty("OffsetsWorkspace", offsetsWS); alg->setPropertyValue("OutputWorkspace", m_instName + "_cal"); alg->executeAsChildAlg(); m_calibrationWS = alg->getProperty("OutputWorkspace"); AnalysisDataService::Instance().addOrReplace(m_instName + "_cal", m_calibrationWS); }
/** * Uses linear algorithm to do the fitting. * @param histogram the histogram to fit * @param background an output variable for the calculated background * @param variance an output variable for background's variance, currently always * zero. * @param startX an X value in the first bin to be included in the fit * @param endX an X value in the last bin to be included in the fit */ void CalculateFlatBackground::LinearFit( const HistogramData::Histogram &histogram, double &background, double &variance, const double startX, const double endX) { MatrixWorkspace_sptr WS = WorkspaceFactory::Instance().create( "Workspace2D", 1, histogram.x().size(), histogram.y().size()); WS->setHistogram(0, histogram); IAlgorithm_sptr childAlg = createChildAlgorithm("Fit"); IFunction_sptr func = API::FunctionFactory::Instance().createFunction("LinearBackground"); childAlg->setProperty<IFunction_sptr>("Function", func); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", WS); childAlg->setProperty<bool>("CreateOutput", true); childAlg->setProperty<int>("WorkspaceIndex", 0); childAlg->setProperty<double>("StartX", startX); childAlg->setProperty<double>("EndX", endX); // Default minimizer doesn't work properly even on the easiest cases, // so Levenberg-MarquardtMD is used instead childAlg->setProperty<std::string>("Minimizer", "Levenberg-MarquardtMD"); childAlg->executeAsChildAlg(); std::string outputStatus = childAlg->getProperty("OutputStatus"); if (outputStatus != "success") { g_log.warning("Unable to successfully fit the data: " + outputStatus); background = -1; return; } Mantid::API::ITableWorkspace_sptr output = childAlg->getProperty("OutputParameters"); // Find rows with parameters we are after size_t rowA0, rowA1; output->find(static_cast<std::string>("A0"), rowA0, 0); output->find(static_cast<std::string>("A1"), rowA1, 0); // Linear function is defined as A0 + A1*x const double intercept = output->cell<double>(rowA0, 1); const double slope = output->cell<double>(rowA1, 1); const double centre = (startX + endX) / 2.0; // Calculate the value of the flat background by taking the value at the // centre point of the fit background = slope * centre + intercept; // ATM we don't calculate the error here. variance = 0; }
/** Creates a 1D MDHistoWorkspace from the inputs arrays. Runs the CreateMDHistoWorkspace algorithm as a ChildAlgorithm. @param signals: signal collection @param errors: error collection @param extents: extents collection @param vecNBins: number of bins collection @param names: names collection @param units: units collection */ MDHistoWorkspace_sptr Stitch1DMD::create1DHistoWorkspace(const MantidVec& signals,const MantidVec& errors, const MantidVec& extents, const std::vector<int>& vecNBins, const std::vector<std::string> names, const std::vector<std::string>& units) { IAlgorithm_sptr createMDHistoWorkspace = this->createChildAlgorithm("CreateMDHistoWorkspace"); createMDHistoWorkspace->initialize(); createMDHistoWorkspace->setProperty("SignalInput", signals); createMDHistoWorkspace->setProperty("ErrorInput", errors); createMDHistoWorkspace->setProperty("Dimensionality", 1); createMDHistoWorkspace->setProperty("Extents", extents); createMDHistoWorkspace->setProperty("NumberOfBins", vecNBins); createMDHistoWorkspace->setProperty("Names", names); createMDHistoWorkspace->setProperty("Units", units); createMDHistoWorkspace->executeAsChildAlg(); IMDHistoWorkspace_sptr outWS = createMDHistoWorkspace->getProperty("OutputWorkspace"); return boost::dynamic_pointer_cast<MDHistoWorkspace>(outWS); }
/** Load in the RKH file for that has the correction information * @param corrFile :: the name of the correction to load * @return workspace containing the loaded data * @throw runtime_error if load algorithm fails */ MatrixWorkspace_sptr CorrectToFile::loadInFile(const std::string &corrFile) { g_log.information() << "Loading file " << corrFile << '\n'; progress(0, "Loading file"); IAlgorithm_sptr loadRKH = createChildAlgorithm("LoadRKH", 0, 1.0 /*LOAD_TIME*/); std::string rkhfile = getProperty("Filename"); loadRKH->setPropertyValue("Filename", rkhfile); loadRKH->setPropertyValue("OutputWorkspace", "rkhout"); std::string columnValue = getProperty("FirstColumnValue"); loadRKH->setPropertyValue("FirstColumnValue", columnValue); loadRKH->executeAsChildAlg(); g_log.debug() << corrFile << " loaded\n"; return loadRKH->getProperty("OutputWorkspace"); }
/** * Runs the BinMD algorithm on the input to provide the output workspace * All slicing algorithm properties are passed along * @return MDHistoWorkspace as a result of the binning */ MDHistoWorkspace_sptr MDNormDirectSC::binInputWS() { const auto &props = getProperties(); IAlgorithm_sptr binMD = createChildAlgorithm("BinMD", 0.0, 0.3); binMD->setPropertyValue("AxisAligned", "1"); for (auto it = props.begin(); it != props.end(); ++it) { const auto &propName = (*it)->name(); if (propName != "SolidAngleWorkspace" && propName != "OutputNormalizationWorkspace") { binMD->setPropertyValue(propName, (*it)->value()); } } binMD->executeAsChildAlg(); Workspace_sptr outputWS = binMD->getProperty("OutputWorkspace"); return boost::dynamic_pointer_cast<MDHistoWorkspace>(outputWS); }
API::MatrixWorkspace_sptr HRPDSlabCanAbsorption::runFlatPlateAbsorption() { MatrixWorkspace_sptr m_inputWS = getProperty("InputWorkspace"); double sigma_atten = getProperty("SampleAttenuationXSection"); // in barns double sigma_s = getProperty("SampleScatteringXSection"); // in barns double rho = getProperty("SampleNumberDensity"); // in Angstroms-3 const Material &sampleMaterial = m_inputWS->sample().getMaterial(); if (sampleMaterial.totalScatterXSection(NeutronAtom::ReferenceLambda) != 0.0) { if (rho == EMPTY_DBL()) rho = sampleMaterial.numberDensity(); if (sigma_s == EMPTY_DBL()) sigma_s = sampleMaterial.totalScatterXSection(NeutronAtom::ReferenceLambda); if (sigma_atten == EMPTY_DBL()) sigma_atten = sampleMaterial.absorbXSection(NeutronAtom::ReferenceLambda); } else // Save input in Sample with wrong atomic number and name { NeutronAtom neutron(static_cast<uint16_t>(EMPTY_DBL()), static_cast<uint16_t>(0), 0.0, 0.0, sigma_s, 0.0, sigma_s, sigma_atten); Object shape = m_inputWS->sample().getShape(); // copy shape.setMaterial(Material("SetInSphericalAbsorption", neutron, rho)); m_inputWS->mutableSample().setShape(shape); } // Call FlatPlateAbsorption as a Child Algorithm IAlgorithm_sptr childAlg = createChildAlgorithm("FlatPlateAbsorption", 0.0, 0.9); // Pass through all the properties childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", m_inputWS); childAlg->setProperty<double>("AttenuationXSection", sigma_atten); childAlg->setProperty<double>("ScatteringXSection", sigma_s); childAlg->setProperty<double>("SampleNumberDensity", rho); childAlg->setProperty<int64_t>("NumberOfWavelengthPoints", getProperty("NumberOfWavelengthPoints")); childAlg->setProperty<std::string>("ExpMethod", getProperty("ExpMethod")); // The height and width of the sample holder are standard for HRPD const double HRPDCanHeight = 2.3; const double HRPDCanWidth = 1.8; childAlg->setProperty("SampleHeight", HRPDCanHeight); childAlg->setProperty("SampleWidth", HRPDCanWidth); // Valid values are 0.2,0.5,1.0 & 1.5 - would be nice to have a numeric list // validator const std::string thickness = getPropertyValue("Thickness"); childAlg->setPropertyValue("SampleThickness", thickness); childAlg->executeAsChildAlg(); return childAlg->getProperty("OutputWorkspace"); }