int PeakIntegration::fitneighbours(int ipeak, std::string det_name, int x0, int y0, int idet, double qspan, PeaksWorkspace_sptr &Peaks, const detid2index_map &pixel_to_wi) { UNUSED_ARG(ipeak); UNUSED_ARG(det_name); UNUSED_ARG(x0); UNUSED_ARG(y0); Geometry::IPeak &peak = Peaks->getPeak(ipeak); // Number of slices int TOFmax = 0; IAlgorithm_sptr slice_alg = createChildAlgorithm("IntegratePeakTimeSlices"); slice_alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputW); std::ostringstream tab_str; tab_str << "LogTable" << ipeak; slice_alg->setPropertyValue("OutputWorkspace", tab_str.str()); slice_alg->setProperty<PeaksWorkspace_sptr>("Peaks", Peaks); slice_alg->setProperty("PeakIndex", ipeak); slice_alg->setProperty("PeakQspan", qspan); int nPixels = std::max<int>(0, getProperty("NBadEdgePixels")); slice_alg->setProperty("NBadEdgePixels", nPixels); slice_alg->executeAsChildAlg(); Mantid::API::MemoryManager::Instance().releaseFreeMemory(); MantidVec &Xout = outputW->dataX(idet); MantidVec &Yout = outputW->dataY(idet); MantidVec &Eout = outputW->dataE(idet); TableWorkspace_sptr logtable = slice_alg->getProperty("OutputWorkspace"); peak.setIntensity(slice_alg->getProperty("Intensity")); peak.setSigmaIntensity(slice_alg->getProperty("SigmaIntensity")); TOFmax = static_cast<int>(logtable->rowCount()); for (int iTOF = 0; iTOF < TOFmax; iTOF++) { Xout[iTOF] = logtable->getRef<double>(std::string("Time"), iTOF); if (m_IC) // Ikeda-Carpenter fit { Yout[iTOF] = logtable->getRef<double>(std::string("TotIntensity"), iTOF); Eout[iTOF] = logtable->getRef<double>(std::string("TotIntensityError"), iTOF); } else { Yout[iTOF] = logtable->getRef<double>(std::string("ISAWIntensity"), iTOF); Eout[iTOF] = logtable->getRef<double>(std::string("ISAWIntensityError"), iTOF); } } outputW->getSpectrum(idet)->clearDetectorIDs(); // Find the pixel ID at that XY position on the rectangular detector int pixelID = peak.getDetectorID(); // det->getAtXY(x0,y0)->getID(); // Find the corresponding workspace index, if any auto wiEntry = pixel_to_wi.find(pixelID); if (wiEntry != pixel_to_wi.end()) { size_t wi = wiEntry->second; // Set detectorIDs outputW->getSpectrum(idet) ->addDetectorIDs(inputW->getSpectrum(wi)->getDetectorIDs()); } return TOFmax - 1; }
void HFIRDarkCurrentSubtraction::exec() { std::string output_message = ""; // Reduction property manager const std::string reductionManagerName = getProperty("ReductionProperties"); boost::shared_ptr<PropertyManager> reductionManager; if (PropertyManagerDataService::Instance().doesExist(reductionManagerName)) { reductionManager = PropertyManagerDataService::Instance().retrieve(reductionManagerName); } else { reductionManager = boost::make_shared<PropertyManager>(); PropertyManagerDataService::Instance().addOrReplace(reductionManagerName, reductionManager); } // If the load algorithm isn't in the reduction properties, add it const bool persistent = getProperty("PersistentCorrection"); if (!reductionManager->existsProperty("DarkCurrentAlgorithm") && persistent) { AlgorithmProperty *algProp = new AlgorithmProperty("DarkCurrentAlgorithm"); algProp->setValue(toString()); reductionManager->declareProperty(algProp); } Progress progress(this,0.0,1.0,10); MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace"); const std::string fileName = getPropertyValue("Filename"); MatrixWorkspace_sptr darkWS; std::string darkWSName = getPropertyValue("OutputDarkCurrentWorkspace"); progress.report("Subtracting dark current"); // Look for an entry for the dark current in the reduction table Poco::Path path(fileName); const std::string entryName = "DarkCurrent"+path.getBaseName(); if (reductionManager->existsProperty(entryName)) { darkWS = reductionManager->getProperty(entryName); darkWSName = reductionManager->getPropertyValue(entryName); output_message += darkWSName + '\n'; } else { // Load the dark current if we don't have it already if (darkWSName.size()==0) { darkWSName = "__dark_current_"+path.getBaseName(); setPropertyValue("OutputDarkCurrentWorkspace", darkWSName); } IAlgorithm_sptr loadAlg; if (!reductionManager->existsProperty("LoadAlgorithm")) { loadAlg = createChildAlgorithm("HFIRLoad", 0.1, 0.3); loadAlg->setProperty("Filename", fileName); loadAlg->setProperty("ReductionProperties", reductionManagerName); loadAlg->executeAsChildAlg(); } else { IAlgorithm_sptr loadAlg0 = reductionManager->getProperty("LoadAlgorithm"); const std::string loadString = loadAlg0->toString(); loadAlg = Algorithm::fromString(loadString); loadAlg->setChild(true); loadAlg->setProperty("Filename", fileName); loadAlg->setProperty("ReductionProperties", reductionManagerName); loadAlg->setPropertyValue("OutputWorkspace", darkWSName); loadAlg->execute(); } darkWS = loadAlg->getProperty("OutputWorkspace"); output_message += "\n Loaded " + fileName + "\n"; if (loadAlg->existsProperty("OutputMessage")) { std::string msg = loadAlg->getPropertyValue("OutputMessage"); output_message += " |" + Poco::replace(msg, "\n", "\n |") + "\n"; } setProperty("OutputDarkCurrentWorkspace", darkWS); reductionManager->declareProperty(new WorkspaceProperty<>(entryName,"",Direction::Output)); reductionManager->setPropertyValue(entryName, darkWSName); reductionManager->setProperty(entryName, darkWS); } progress.report(3, "Loaded dark current"); // Perform subtraction double darkTimer = getCountingTime(darkWS); double dataTimer = getCountingTime(inputWS); IAlgorithm_sptr scaleAlg = createChildAlgorithm("Scale", 0.3, 0.5); scaleAlg->setProperty("InputWorkspace", darkWS); scaleAlg->setProperty("Factor", dataTimer/darkTimer); scaleAlg->setProperty("Operation", "Multiply"); scaleAlg->executeAsChildAlg(); MatrixWorkspace_sptr scaledDarkWS = scaleAlg->getProperty("OutputWorkspace"); // Zero out timer and monitor so that we don't subtract them out for(size_t i=0; i<scaledDarkWS->dataY(0).size(); i++) { scaledDarkWS->dataY(DEFAULT_TIMER_ID)[i]=0.0; scaledDarkWS->dataE(DEFAULT_TIMER_ID)[i]=0.0; scaledDarkWS->dataY(DEFAULT_MONITOR_ID)[i]=0.0; scaledDarkWS->dataE(DEFAULT_MONITOR_ID)[i]=0.0; } IAlgorithm_sptr minusAlg = createChildAlgorithm("Minus", 0.5, 0.7); minusAlg->setProperty("LHSWorkspace", inputWS); minusAlg->setProperty("RHSWorkspace", scaledDarkWS); MatrixWorkspace_sptr outputWS = getProperty("OutputWorkspace"); minusAlg->setProperty("OutputWorkspace", outputWS); minusAlg->executeAsChildAlg(); MatrixWorkspace_sptr correctedWS = minusAlg->getProperty("OutputWorkspace"); setProperty("OutputWorkspace", correctedWS); setProperty("OutputMessage", "Dark current subtracted: "+output_message); progress.report("Subtracted dark current"); }
} IAlgorithm_sptr algo = createChildAlgorithm("CreateWorkspace", 0.7, 1.0); algo->setProperty< std::vector<double> >("DataX", std::vector<double>(2,0.0) ); algo->setProperty< std::vector<double> >("DataY", y_values ); algo->setProperty< std::vector<double> >("DataE", e_values ); algo->setProperty<int>("NSpec", numSpec ); algo->execute(); inputWS = algo->getProperty("OutputWorkspace"); WorkspaceFactory::Instance().initializeFromParent(inputWSWvl, inputWS, false); } else { // Sum up all the wavelength bins IAlgorithm_sptr childAlg = createChildAlgorithm("Integration"); childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", inputWSWvl); childAlg->executeAsChildAlg(); inputWS = childAlg->getProperty("OutputWorkspace"); } // Define box around center of mass so that only pixels in an area // _centered_ on the latest center position are considered. At each // iteration we will recompute the bounding box, and we will make // it as large as possible. The largest box is defined as: double xmin0 = 0; double xmax0 = 0; double ymin0 = 0; double ymax0 = 0; // Starting values for the bounding box and the center
/** * Converts the output workspace back to histogram data if it was * converted to point data previously */ void SplineSmoothing::convertToHistogram() { auto alg = createChildAlgorithm("ConvertToHistogram"); alg->setProperty("InputWorkspace", m_outputWorkspace); alg->execute(); m_outputWorkspace = alg->getProperty("OutputWorkspace"); }
/* Call Fit as child algorithm for each spectra * @param index : the workspace index */ void FindEPP::fitGaussian(int64_t index) { size_t spectrum = static_cast<size_t>(index); m_outWS->cell<int>(spectrum, 0) = static_cast<int>(spectrum); const auto &x = m_inWS->x(spectrum).rawData(); const auto &y = m_inWS->y(spectrum).rawData(); const auto &e = m_inWS->e(spectrum).rawData(); // Find the maximum value and it's index const auto maxIt = std::max_element(y.begin(), y.end()); const double height = *maxIt; size_t maxIndex = static_cast<size_t>(std::distance(y.begin(), maxIt)); if (height > 0) { // Find how many bins are around maximum, that are above half-maximum // Initialize the distances of the half-maxima bins from maximum size_t leftHalf = maxIndex, rightHalf = x.size() - maxIndex - 1; // Find the first bin on the right side of maximum, that drops below // half-maximum for (auto it = maxIt; it != y.end(); ++it) { if (*it < 0.5 * height) { rightHalf = it - maxIt - 1; break; } } // Find the first bin on the left side of maximum, that drops below // half-maximum for (auto it = maxIt; it != y.begin(); --it) { if (*it < 0.5 * height) { leftHalf = maxIt - it - 1; break; } } g_log.debug() << "Peak in spectrum #" << spectrum << " has last bins above 0.5*max at " << leftHalf << "\t" << rightHalf << "\n"; // We want to fit only if there are at least 3 bins (including the maximum // itself) above half-maximum if (rightHalf + leftHalf >= 2) { // Prepare the initial parameters for the fit double fwhm = x[maxIndex + rightHalf] - x[maxIndex - leftHalf]; double sigma = fwhm / (2. * sqrt(2. * log(2.))); double center = x[maxIndex]; double start = center - 3. * fwhm; double end = center + 3. * fwhm; std::stringstream function; function << "name=Gaussian,PeakCentre="; function << center << ",Height=" << height << ",Sigma=" << sigma; g_log.debug() << "Fitting spectrum #" << spectrum << " with: " << function.str() << "\n"; IAlgorithm_sptr fitAlg = createChildAlgorithm("Fit", 0., 0., false); fitAlg->setProperty("Function", function.str()); fitAlg->setProperty("InputWorkspace", m_inWS); fitAlg->setProperty("WorkspaceIndex", static_cast<int>(spectrum)); fitAlg->setProperty("StartX", start); fitAlg->setProperty("EndX", end); fitAlg->setProperty("CreateOutput", true); fitAlg->setProperty("OutputParametersOnly", true); fitAlg->executeAsChildAlg(); const std::string status = fitAlg->getProperty("OutputStatus"); ITableWorkspace_sptr fitResult = fitAlg->getProperty("OutputParameters"); if (status == "success") { m_outWS->cell<double>(spectrum, 1) = fitResult->cell<double>(1, 1); m_outWS->cell<double>(spectrum, 2) = fitResult->cell<double>(1, 2); m_outWS->cell<double>(spectrum, 3) = fitResult->cell<double>(2, 1); m_outWS->cell<double>(spectrum, 4) = fitResult->cell<double>(2, 2); m_outWS->cell<double>(spectrum, 5) = fitResult->cell<double>(0, 1); m_outWS->cell<double>(spectrum, 6) = fitResult->cell<double>(0, 2); m_outWS->cell<double>(spectrum, 7) = fitResult->cell<double>(3, 1); m_outWS->cell<std::string>(spectrum, 8) = status; } else { g_log.debug() << "Fit failed in spectrum #" << spectrum << ". \nReason :" << status << ". \nSetting the maximum.\n"; m_outWS->cell<std::string>(spectrum, 8) = "fitFailed"; m_outWS->cell<double>(spectrum, 1) = x[maxIndex]; m_outWS->cell<double>(spectrum, 2) = 0.; m_outWS->cell<double>(spectrum, 5) = height; m_outWS->cell<double>(spectrum, 6) = e[maxIndex]; } } else { g_log.information() << "Found <=3 bins above half maximum in spectrum #" << index << ". Not fitting.\n"; m_outWS->cell<std::string>(spectrum, 8) = "narrowPeak"; m_outWS->cell<double>(spectrum, 1) = x[maxIndex]; m_outWS->cell<double>(spectrum, 2) = 0.; m_outWS->cell<double>(spectrum, 5) = height; m_outWS->cell<double>(spectrum, 6) = e[maxIndex]; } } else { g_log.notice() << "Negative maximum in spectrum #" << spectrum << ". Skipping.\n"; m_outWS->cell<std::string>(spectrum, 8) = "negativeMaximum"; } m_progress->report(); }
void SANSSensitivityCorrection::exec() { // Output log m_output_message = ""; Progress progress(this, 0.0, 1.0, 10); // Reduction property manager const std::string reductionManagerName = getProperty("ReductionProperties"); boost::shared_ptr<PropertyManager> reductionManager; if (PropertyManagerDataService::Instance().doesExist(reductionManagerName)) { reductionManager = PropertyManagerDataService::Instance().retrieve(reductionManagerName); } else { reductionManager = boost::make_shared<PropertyManager>(); PropertyManagerDataService::Instance().addOrReplace(reductionManagerName, reductionManager); } if (!reductionManager->existsProperty("SensitivityAlgorithm")) { auto algProp = make_unique<AlgorithmProperty>("SensitivityAlgorithm"); algProp->setValue(toString()); reductionManager->declareProperty(std::move(algProp)); } progress.report("Loading sensitivity file"); const std::string fileName = getPropertyValue("Filename"); // Look for an entry for the dark current in the reduction table Poco::Path path(fileName); const std::string entryName = "Sensitivity" + path.getBaseName(); MatrixWorkspace_sptr floodWS; std::string floodWSName = "__sensitivity_" + path.getBaseName(); if (reductionManager->existsProperty(entryName)) { std::string wsName = reductionManager->getPropertyValue(entryName); floodWS = boost::dynamic_pointer_cast<MatrixWorkspace>( AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(wsName)); m_output_message += " |Using " + wsName + "\n"; g_log.debug() << "SANSSensitivityCorrection :: Using sensitivity workspace: " << wsName << "\n"; } else { // Load the flood field if we don't have it already // First, try to determine whether we need to load data or a sensitivity // workspace... if (!floodWS && fileCheck(fileName)) { g_log.debug() << "SANSSensitivityCorrection :: Loading sensitivity file: " << fileName << "\n"; IAlgorithm_sptr loadAlg = createChildAlgorithm("Load", 0.1, 0.3); loadAlg->setProperty("Filename", fileName); loadAlg->executeAsChildAlg(); Workspace_sptr floodWS_ws = loadAlg->getProperty("OutputWorkspace"); floodWS = boost::dynamic_pointer_cast<MatrixWorkspace>(floodWS_ws); // Check that it's really a sensitivity file if (!floodWS->run().hasProperty("is_sensitivity")) { // Reset pointer floodWS.reset(); g_log.error() << "A processed Mantid workspace was loaded but it " "wasn't a sensitivity file!\n"; } } // ... if we don't, just load the data and process it if (!floodWS) { // Read in default beam center double center_x = getProperty("BeamCenterX"); double center_y = getProperty("BeamCenterY"); if (isEmpty(center_x) || isEmpty(center_y)) { if (reductionManager->existsProperty("LatestBeamCenterX") && reductionManager->existsProperty("LatestBeamCenterY")) { center_x = reductionManager->getProperty("LatestBeamCenterX"); center_y = reductionManager->getProperty("LatestBeamCenterY"); m_output_message += " |Setting beam center to [" + Poco::NumberFormatter::format(center_x, 1) + ", " + Poco::NumberFormatter::format(center_y, 1) + "]\n"; } else m_output_message += " |No beam center provided: skipping!\n"; } const std::string rawFloodWSName = "__flood_data_" + path.getBaseName(); MatrixWorkspace_sptr rawFloodWS; if (!reductionManager->existsProperty("LoadAlgorithm")) { IAlgorithm_sptr loadAlg = createChildAlgorithm("Load", 0.1, 0.3); loadAlg->setProperty("Filename", fileName); if (!isEmpty(center_x) && loadAlg->existsProperty("BeamCenterX")) loadAlg->setProperty("BeamCenterX", center_x); if (!isEmpty(center_y) && loadAlg->existsProperty("BeamCenterY")) loadAlg->setProperty("BeamCenterY", center_y); loadAlg->setPropertyValue("OutputWorkspace", rawFloodWSName); loadAlg->executeAsChildAlg(); Workspace_sptr tmpWS = loadAlg->getProperty("OutputWorkspace"); rawFloodWS = boost::dynamic_pointer_cast<MatrixWorkspace>(tmpWS); m_output_message += " | Loaded " + fileName + " (Load algorithm)\n"; } else { // Get load algorithm as a string so that we can create a completely // new proxy and ensure that we don't overwrite existing properties IAlgorithm_sptr loadAlg0 = reductionManager->getProperty("LoadAlgorithm"); const std::string loadString = loadAlg0->toString(); IAlgorithm_sptr loadAlg = Algorithm::fromString(loadString); loadAlg->setChild(true); loadAlg->setProperty("Filename", fileName); loadAlg->setPropertyValue("OutputWorkspace", rawFloodWSName); if (!isEmpty(center_x) && loadAlg->existsProperty("BeamCenterX")) loadAlg->setProperty("BeamCenterX", center_x); if (!isEmpty(center_y) && loadAlg->existsProperty("BeamCenterY")) loadAlg->setProperty("BeamCenterY", center_y); loadAlg->execute(); rawFloodWS = loadAlg->getProperty("OutputWorkspace"); m_output_message += " |Loaded " + fileName + "\n"; if (loadAlg->existsProperty("OutputMessage")) { std::string msg = loadAlg->getPropertyValue("OutputMessage"); m_output_message += " |" + Poco::replace(msg, "\n", "\n |") + "\n"; } } // Check whether we just loaded a flood field data set, or the actual // sensitivity if (!rawFloodWS->run().hasProperty("is_sensitivity")) { const std::string darkCurrentFile = getPropertyValue("DarkCurrentFile"); // Look for a dark current subtraction algorithm std::string dark_result; if (reductionManager->existsProperty("DarkCurrentAlgorithm")) { IAlgorithm_sptr darkAlg = reductionManager->getProperty("DarkCurrentAlgorithm"); darkAlg->setChild(true); darkAlg->setProperty("InputWorkspace", rawFloodWS); darkAlg->setProperty("OutputWorkspace", rawFloodWS); // Execute as-is if we use the sample dark current, otherwise check // whether a dark current file was provided. // Otherwise do nothing if (getProperty("UseSampleDC")) { darkAlg->execute(); if (darkAlg->existsProperty("OutputMessage")) dark_result = darkAlg->getPropertyValue("OutputMessage"); } else if (!darkCurrentFile.empty()) { darkAlg->setProperty("Filename", darkCurrentFile); darkAlg->setProperty("PersistentCorrection", false); darkAlg->execute(); if (darkAlg->existsProperty("OutputMessage")) dark_result = darkAlg->getPropertyValue("OutputMessage"); else dark_result = " Dark current subtracted\n"; } } else if (!darkCurrentFile.empty()) { // We need to subtract the dark current for the flood field but no // dark // current subtraction was set for the sample! Use the default dark // current algorithm if we can find it. if (reductionManager->existsProperty("DefaultDarkCurrentAlgorithm")) { IAlgorithm_sptr darkAlg = reductionManager->getProperty("DefaultDarkCurrentAlgorithm"); darkAlg->setChild(true); darkAlg->setProperty("InputWorkspace", rawFloodWS); darkAlg->setProperty("OutputWorkspace", rawFloodWS); darkAlg->setProperty("Filename", darkCurrentFile); darkAlg->setProperty("PersistentCorrection", false); darkAlg->execute(); if (darkAlg->existsProperty("OutputMessage")) dark_result = darkAlg->getPropertyValue("OutputMessage"); } else { // We are running out of options g_log.error() << "No dark current algorithm provided to load [" << getPropertyValue("DarkCurrentFile") << "]: skipped!\n"; dark_result = " No dark current algorithm provided: skipped\n"; } } m_output_message += " |" + Poco::replace(dark_result, "\n", "\n |") + "\n"; // Look for solid angle correction algorithm if (reductionManager->existsProperty("SANSSolidAngleCorrection")) { IAlgorithm_sptr solidAlg = reductionManager->getProperty("SANSSolidAngleCorrection"); solidAlg->setChild(true); solidAlg->setProperty("InputWorkspace", rawFloodWS); solidAlg->setProperty("OutputWorkspace", rawFloodWS); solidAlg->execute(); std::string msg = "Solid angle correction applied\n"; if (solidAlg->existsProperty("OutputMessage")) msg = solidAlg->getPropertyValue("OutputMessage"); m_output_message += " |" + Poco::replace(msg, "\n", "\n |") + "\n"; } // Apply transmission correction as needed double floodTransmissionValue = getProperty("FloodTransmissionValue"); double floodTransmissionError = getProperty("FloodTransmissionError"); if (!isEmpty(floodTransmissionValue)) { g_log.debug() << "SANSSensitivityCorrection :: Applying transmission " "to flood field\n"; IAlgorithm_sptr transAlg = createChildAlgorithm("ApplyTransmissionCorrection"); transAlg->setProperty("InputWorkspace", rawFloodWS); transAlg->setProperty("OutputWorkspace", rawFloodWS); transAlg->setProperty("TransmissionValue", floodTransmissionValue); transAlg->setProperty("TransmissionError", floodTransmissionError); transAlg->setProperty("ThetaDependent", true); transAlg->execute(); rawFloodWS = transAlg->getProperty("OutputWorkspace"); m_output_message += " |Applied transmission to flood field\n"; } // Calculate detector sensitivity IAlgorithm_sptr effAlg = createChildAlgorithm("CalculateEfficiency"); effAlg->setProperty("InputWorkspace", rawFloodWS); const double minEff = getProperty("MinEfficiency"); const double maxEff = getProperty("MaxEfficiency"); const std::string maskFullComponent = getPropertyValue("MaskedFullComponent"); const std::string maskEdges = getPropertyValue("MaskedEdges"); const std::string maskComponent = getPropertyValue("MaskedComponent"); effAlg->setProperty("MinEfficiency", minEff); effAlg->setProperty("MaxEfficiency", maxEff); effAlg->setProperty("MaskedFullComponent", maskFullComponent); effAlg->setProperty("MaskedEdges", maskEdges); effAlg->setProperty("MaskedComponent", maskComponent); effAlg->execute(); floodWS = effAlg->getProperty("OutputWorkspace"); } else { floodWS = rawFloodWS; } // Patch as needed if (reductionManager->existsProperty("SensitivityPatchAlgorithm")) { IAlgorithm_sptr patchAlg = reductionManager->getProperty("SensitivityPatchAlgorithm"); patchAlg->setChild(true); patchAlg->setProperty("Workspace", floodWS); patchAlg->execute(); m_output_message += " |Sensitivity patch applied\n"; } floodWS->mutableRun().addProperty("is_sensitivity", 1, "", true); } std::string floodWSOutputName = getPropertyValue("OutputSensitivityWorkspace"); if (floodWSOutputName.empty()) { setPropertyValue("OutputSensitivityWorkspace", floodWSName); AnalysisDataService::Instance().addOrReplace(floodWSName, floodWS); reductionManager->declareProperty( Kernel::make_unique<WorkspaceProperty<>>(entryName, floodWSName, Direction::InOut)); reductionManager->setPropertyValue(entryName, floodWSName); reductionManager->setProperty(entryName, floodWS); } setProperty("OutputSensitivityWorkspace", floodWS); } progress.report(3, "Loaded flood field"); // Check whether we need to apply the correction to a workspace MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace"); if (inputWS) { // Divide sample data by detector efficiency IAlgorithm_sptr divideAlg = createChildAlgorithm("Divide", 0.6, 0.7); divideAlg->setProperty("LHSWorkspace", inputWS); divideAlg->setProperty("RHSWorkspace", floodWS); divideAlg->executeAsChildAlg(); MatrixWorkspace_sptr outputWS = divideAlg->getProperty("OutputWorkspace"); // Copy over the efficiency's masked pixels to the reduced workspace IAlgorithm_sptr maskAlg = createChildAlgorithm("MaskDetectors", 0.75, 0.85); maskAlg->setProperty("Workspace", outputWS); maskAlg->setProperty("MaskedWorkspace", floodWS); maskAlg->executeAsChildAlg(); setProperty("OutputWorkspace", outputWS); } setProperty("OutputMessage", "Sensitivity correction computed\n" + m_output_message); progress.report("Performed sensitivity correction"); }