/** Validate the properties together */
std::map<std::string, std::string> LiveDataAlgorithm::validateInputs()
{
std::map<std::string, std::string> out;
const std::string instrument = getPropertyValue("Instrument");
const bool eventListener = LiveListenerFactory::Instance().create(instrument,false)->buffersEvents();
if ( !eventListener && getPropertyValue("AccumulationMethod") == "Add" )
{
out["AccumulationMethod"] = "The " + instrument + " live stream produces histograms. Add is not a sensible accumulation method.";
}
if (this->getPropertyValue("OutputWorkspace").empty())
out["OutputWorkspace"] = "Must specify the OutputWorkspace.";
// Validate inputs
if (this->hasPostProcessing())
{
if (this->getPropertyValue("AccumulationWorkspace").empty())
out["AccumulationWorkspace"] = "Must specify the AccumulationWorkspace parameter if using PostProcessing.";
if (this->getPropertyValue("AccumulationWorkspace") == this->getPropertyValue("OutputWorkspace"))
out["AccumulationWorkspace"] = "The AccumulationWorkspace must be different than the OutputWorkspace, when using PostProcessing.";
}
// For StartLiveData and MonitorLiveData, make sure another thread is not already using these names
if (this->name() != "LoadLiveData")
{
/** Validate that the workspace names chosen are not in use already */
std::string outName = this->getPropertyValue("OutputWorkspace");
std::string accumName = this->getPropertyValue("AccumulationWorkspace");
// Check that no other MonitorLiveData thread is running with the same settings
auto it = AlgorithmManager::Instance().algorithms().begin();
for (; it != AlgorithmManager::Instance().algorithms().end(); it++)
{
IAlgorithm_sptr alg = *it;
// MonitorLiveData thread that is running, except THIS one.
if (alg->name() == "MonitorLiveData" && (alg->getAlgorithmID() != this->getAlgorithmID())
&& alg->isRunning())
{
if (!accumName.empty() && alg->getPropertyValue("AccumulationWorkspace") == accumName)
out["AccumulationWorkspace"] += "Another MonitorLiveData thread is running with the same AccumulationWorkspace.\n"
"Please specify a different AccumulationWorkspace name.";
if (alg->getPropertyValue("OutputWorkspace") == outName)
out["OutputWorkspace"] += "Another MonitorLiveData thread is running with the same OutputWorkspace.\n"
"Please specify a different OutputWorkspace name.";
}
}
}
return out;
}
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");
}
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");
}
