/**
* Calls Gaussian1D as a child algorithm to fit the offset peak in a spectrum
* @param mosaic
* @param rcrystallite
* @param inname
* @param corrOption
* @param pointOption
* @param tofParams
* @return
*/
double OptimizeExtinctionParameters::fitMosaic(
double mosaic, double rcrystallite, std::string inname,
std::string corrOption, std::string pointOption, std::string tofParams) {
PeaksWorkspace_sptr inputW = boost::dynamic_pointer_cast<PeaksWorkspace>(
AnalysisDataService::Instance().retrieve(inname));
std::vector<double> tofParam =
Kernel::VectorHelper::splitStringIntoVector<double>(tofParams);
if (mosaic < 0.0 || rcrystallite < 0.0)
return 1e300;
API::IAlgorithm_sptr tofextinction =
createChildAlgorithm("TOFExtinction", 0.0, 0.2);
tofextinction->setProperty("InputWorkspace", inputW);
tofextinction->setProperty("OutputWorkspace", "tmp");
tofextinction->setProperty("ExtinctionCorrectionType", corrOption);
tofextinction->setProperty<double>("Mosaic", mosaic);
tofextinction->setProperty<double>("Cell", tofParam[0]);
tofextinction->setProperty<double>("RCrystallite", rcrystallite);
tofextinction->executeAsChildAlg();
PeaksWorkspace_sptr peaksW = tofextinction->getProperty("OutputWorkspace");
API::IAlgorithm_sptr sorthkl = createChildAlgorithm("SortHKL", 0.0, 0.2);
sorthkl->setProperty("InputWorkspace", peaksW);
sorthkl->setProperty("OutputWorkspace", peaksW);
sorthkl->setProperty("PointGroup", pointOption);
sorthkl->executeAsChildAlg();
double Chisq = sorthkl->getProperty("OutputChi2");
std::cout << mosaic << " " << rcrystallite << " " << Chisq << "\n";
return Chisq;
}
/**
* Places the detector at the right sample_detector_distance
*/
void LoadSpice2D::moveDetector(double sample_detector_distance,
double translation_distance) {
// Some tests fail if the detector is moved here.
// TODO: Move the detector here and not the SANSLoad
UNUSED_ARG(translation_distance);
// Move the detector to the right position
API::IAlgorithm_sptr mover = createChildAlgorithm("MoveInstrumentComponent");
// Finding the name of the detector object.
std::string detID =
m_workspace->getInstrument()->getStringParameter("detector-name")[0];
g_log.information("Moving " + detID);
try {
mover->setProperty<API::MatrixWorkspace_sptr>("Workspace", m_workspace);
mover->setProperty("ComponentName", detID);
mover->setProperty("Z", sample_detector_distance / 1000.0);
// mover->setProperty("X", -translation_distance);
mover->execute();
} catch (std::invalid_argument &e) {
g_log.error("Invalid argument to MoveInstrumentComponent Child Algorithm");
g_log.error(e.what());
} catch (std::runtime_error &e) {
g_log.error(
"Unable to successfully run MoveInstrumentComponent Child Algorithm");
g_log.error(e.what());
}
}
/** Handler of the start notifications. Adds an algorithm call to the script.
* @param alg :: Shared pointer to the starting algorithm.
*/
void RecordPythonScript::startingHandle(API::IAlgorithm_sptr alg)
{
auto props= alg->getProperties();
std::string algString;
for(auto p = props.begin() ; p != props.end(); ++p)
{
std::string opener = "='";
if ((**p).value().find('\\') != std::string::npos )
{
opener= "=r'";
}
std::string paramString = (**p).name() + opener + (**p).value() + "'";
// Miss out parameters that are empty.
if(paramString.length() != 0)
{
if(algString.length() != 0)
{
algString += ",";
}
algString += paramString;
}
}
m_generatedScript += alg->name() + "(" + algString + ")\n";
}
/**
* Removes exponential decay from a workspace
* @param wsInput :: [input] Workspace to work on
* @return :: Workspace with decay removed
*/
API::MatrixWorkspace_sptr CalMuonDetectorPhases::removeExpDecay(
const API::MatrixWorkspace_sptr &wsInput) {
API::IAlgorithm_sptr remove = createChildAlgorithm("RemoveExpDecay");
remove->setProperty("InputWorkspace", wsInput);
remove->executeAsChildAlg();
API::MatrixWorkspace_sptr wsRem = remove->getProperty("OutputWorkspace");
return wsRem;
}
/** Call edit instrument geometry
*/
API::MatrixWorkspace_sptr AlignAndFocusPowder::editInstrument(
API::MatrixWorkspace_sptr ws, std::vector<double> polars,
std::vector<specnum_t> specids, std::vector<double> l2s,
std::vector<double> phis) {
g_log.information() << "running EditInstrumentGeometry started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr editAlg = createChildAlgorithm("EditInstrumentGeometry");
editAlg->setProperty("Workspace", ws);
if (m_l1 > 0.)
editAlg->setProperty("PrimaryFlightPath", m_l1);
if (!polars.empty())
editAlg->setProperty("Polar", polars);
if (!specids.empty())
editAlg->setProperty("SpectrumIDs", specids);
if (!l2s.empty())
editAlg->setProperty("L2", l2s);
if (!phis.empty())
editAlg->setProperty("Azimuthal", phis);
editAlg->executeAsChildAlg();
ws = editAlg->getProperty("Workspace");
return ws;
}
std::string FrameworkManagerProxy::createAlgorithmDocs(const std::string& algName, const int version)
{
const std::string EOL="\n";
API::IAlgorithm_sptr algm = API::AlgorithmManager::Instance().createUnmanaged(algName, version);
algm->initialize();
// Put in the quick overview message
std::stringstream buffer;
std::string temp = algm->getOptionalMessage();
if (temp.size() > 0)
buffer << temp << EOL << EOL;
// get a sorted copy of the properties
PropertyVector properties(algm->getProperties());
std::sort(properties.begin(), properties.end(), PropertyOrdering());
// generate the sanitized names
StringVector names(properties.size());
size_t numProps = properties.size();
for ( size_t i = 0; i < numProps; ++i)
{
names[i] = removeCharacters(properties[i]->name(), "");
}
buffer << "Property descriptions: " << EOL << EOL;
// write the actual property descriptions
Mantid::Kernel::Property *prop;
for ( size_t i = 0; i < numProps; ++i)
{
prop = properties[i];
buffer << names[i] << "("
<< Mantid::Kernel::Direction::asText(prop->direction());
if (!prop->isValid().empty())
buffer << ":req";
buffer << ") *" << prop->type() << "* ";
std::set<std::string> allowed = prop->allowedValues();
if (!prop->documentation().empty() || !allowed.empty())
{
buffer << " " << prop->documentation();
if (!allowed.empty())
{
buffer << " [" << Kernel::Strings::join(allowed.begin(), allowed.end(), ", ");
buffer << "]";
}
buffer << EOL;
if( i < numProps - 1 ) buffer << EOL;
}
}
return buffer.str();
}
/**
* Create the concrete instance use for the actual loading.
* @param startProgress :: The percentage progress value of the overall
* algorithm where this child algorithm starts
* @param endProgress :: The percentage progress value of the overall
* algorithm where this child algorithm ends
* @param logging :: Set to false to disable logging from the child algorithm
*/
API::IAlgorithm_sptr Load::createLoader(const double startProgress,
const double endProgress,
const bool logging) const {
std::string name = getPropertyValue("LoaderName");
int version = getProperty("LoaderVersion");
API::IAlgorithm_sptr loader =
API::AlgorithmManager::Instance().createUnmanaged(name, version);
loader->initialize();
if (!loader) {
throw std::runtime_error("Cannot create loader for \"" +
getPropertyValue("Filename") + "\"");
}
setUpLoader(loader, startProgress, endProgress, logging);
return loader;
}
/// Run ConvertUnits as a sub-algorithm to convert to dSpacing
MatrixWorkspace_sptr DiffractionFocussing::convertUnitsToDSpacing(const API::MatrixWorkspace_sptr& workspace)
{
const std::string CONVERSION_UNIT = "dSpacing";
Unit_const_sptr xUnit = workspace->getAxis(0)->unit();
g_log.information() << "Converting units from "<< xUnit->label() << " to " << CONVERSION_UNIT<<".\n";
API::IAlgorithm_sptr childAlg = createSubAlgorithm("ConvertUnits", 0.34, 0.66);
childAlg->setProperty("InputWorkspace", workspace);
childAlg->setPropertyValue("Target",CONVERSION_UNIT);
childAlg->executeAsSubAlg();
return childAlg->getProperty("OutputWorkspace");
}
/**
* Declare any additional properties of the concrete loader here
* @param loader A pointer to the concrete loader
*/
void Load::declareLoaderProperties(const API::IAlgorithm_sptr &loader) {
// If we have switch loaders then the concrete loader will have different
// properties
// so take care of ensuring Load has the correct ones
// THIS IS A COPY as the properties are mutated as we move through them
const std::vector<Property *> existingProps = this->getProperties();
for (auto existingProp : existingProps) {
const std::string &name = existingProp->name();
// Wipe all properties except the Load native ones
if (m_baseProps.find(name) == m_baseProps.end()) {
this->removeProperty(name);
}
}
const std::vector<Property *> &loaderProps = loader->getProperties();
size_t numProps(loaderProps.size());
for (size_t i = 0; i < numProps; ++i) {
Property *loadProp = loaderProps[i];
if (loadProp->name() == m_filenamePropName)
continue;
try {
auto propClone = std::unique_ptr<Property>(loadProp->clone());
propClone->clearSettings(); // Get rid of special settings because it
// does not work in custom GUI.
declareProperty(std::move(propClone), loadProp->documentation());
} catch (Exception::ExistsError &) {
// Already exists as a static property
continue;
}
}
}
void LoadNexusMonitors2::runLoadLogs(const std::string filename,
API::MatrixWorkspace_sptr localWorkspace) {
// do the actual work
API::IAlgorithm_sptr loadLogs = createChildAlgorithm("LoadNexusLogs");
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
g_log.information() << "Loading logs from NeXus file..." << std::endl;
loadLogs->setPropertyValue("Filename", filename);
loadLogs->setProperty<API::MatrixWorkspace_sptr>("Workspace",
localWorkspace);
loadLogs->execute();
} catch (...) {
g_log.error() << "Error while loading Logs from Nexus. Some sample logs "
"may be missing." << std::endl;
}
}
/**
* Set the output workspace(s) if the load's return workspace has type
* API::Workspace
* @param loader :: Shared pointer to load algorithm
*/
void Load::setOutputWorkspace(const API::IAlgorithm_sptr &loader) {
// Go through each OutputWorkspace property and check whether we need to make
// a counterpart here
const std::vector<Property *> &loaderProps = loader->getProperties();
const size_t count = loader->propertyCount();
for (size_t i = 0; i < count; ++i) {
Property *prop = loaderProps[i];
if (dynamic_cast<IWorkspaceProperty *>(prop) &&
prop->direction() == Direction::Output) {
const std::string &name = prop->name();
if (!this->existsProperty(name)) {
declareProperty(Kernel::make_unique<WorkspaceProperty<Workspace>>(
name, loader->getPropertyValue(name), Direction::Output));
}
Workspace_sptr wkspace = getOutputWorkspace(name, loader);
setProperty(name, wkspace);
}
}
}
/// Run Rebin as a Child Algorithm to harmonise the bin boundaries
void DiffractionFocussing::RebinWorkspace(
API::MatrixWorkspace_sptr &workspace) {
double min = 0;
double max = 0;
double step = 0;
calculateRebinParams(workspace, min, max, step);
std::vector<double> paramArray{min, -step, max};
g_log.information() << "Rebinning from " << min << " to " << max << " in "
<< step << " logaritmic steps.\n";
API::IAlgorithm_sptr childAlg = createChildAlgorithm("Rebin");
childAlg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", workspace);
childAlg->setProperty<std::vector<double>>("Params", paramArray);
childAlg->executeAsChildAlg();
workspace = childAlg->getProperty("OutputWorkspace");
}
/**
* Return an output workspace property dealing with the lack of connection
* between of
* WorkspaceProperty types
* @param propName :: The name of the property
* @param loader :: The loader algorithm
* @returns A pointer to the OutputWorkspace property of the Child Algorithm
*/
API::Workspace_sptr
Load::getOutputWorkspace(const std::string &propName,
const API::IAlgorithm_sptr &loader) const {
// @todo Need to try and find a better way using the getValue methods
try {
return loader->getProperty(propName);
} catch (std::runtime_error &) {
}
// Try a MatrixWorkspace
try {
MatrixWorkspace_sptr childWS = loader->getProperty(propName);
return childWS;
} catch (std::runtime_error &) {
}
// EventWorkspace
try {
IEventWorkspace_sptr childWS = loader->getProperty(propName);
return childWS;
} catch (std::runtime_error &) {
}
// IMDEventWorkspace
try {
IMDEventWorkspace_sptr childWS = loader->getProperty(propName);
return childWS;
} catch (std::runtime_error &) {
}
// General IMDWorkspace
try {
IMDWorkspace_sptr childWS = loader->getProperty(propName);
return childWS;
} catch (std::runtime_error &) {
}
// ITableWorkspace?
try {
ITableWorkspace_sptr childWS = loader->getProperty(propName);
return childWS;
} catch (std::runtime_error &) {
}
// Just workspace?
try {
Workspace_sptr childWS = loader->getProperty(propName);
return childWS;
} catch (std::runtime_error &) {
}
g_log.debug() << "Workspace property " << propName
<< " did not return to MatrixWorkspace, EventWorkspace, "
"IMDEventWorkspace, IMDWorkspace\n";
return Workspace_sptr();
}
/** Run the Child Algorithm LoadInstrument (as for LoadRaw)
* @param inst_name :: The name written in the Nexus file
* @param localWorkspace :: The workspace to insert the instrument into
*/
void LoadSpice2D::runLoadInstrument(
const std::string &inst_name,
DataObjects::Workspace2D_sptr localWorkspace) {
API::IAlgorithm_sptr loadInst = createChildAlgorithm("LoadInstrument");
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
loadInst->setPropertyValue("InstrumentName", inst_name);
loadInst->setProperty<API::MatrixWorkspace_sptr>("Workspace",
localWorkspace);
loadInst->setProperty("RewriteSpectraMap",
Mantid::Kernel::OptionalBool(true));
loadInst->execute();
} catch (std::invalid_argument &) {
g_log.information("Invalid argument to LoadInstrument Child Algorithm");
} catch (std::runtime_error &) {
g_log.information(
"Unable to successfully run LoadInstrument Child Algorithm");
}
}
void Load::findFilenameProperty(const API::IAlgorithm_sptr &loader) {
// Use the first file property as the main Filename
const auto &props = loader->getProperties();
for (auto prop : props) {
auto *fp = dynamic_cast<API::MultipleFileProperty *>(prop);
auto *fp2 = dynamic_cast<API::FileProperty *>(prop);
if (fp) {
m_filenamePropName = fp->name();
break;
}
if (fp2) {
m_filenamePropName = fp2->name();
break;
}
}
if (m_filenamePropName.empty()) {
setPropertyValue("LoaderName", "");
setProperty("LoaderVersion", -1);
throw std::runtime_error("Cannot find FileProperty on " + loader->name() +
" algorithm.");
}
}
/**
* Set the loader option for use as a Child Algorithm.
* @param loader :: Concrete loader
* @param startProgress :: The start progress fraction
* @param endProgress :: The end progress fraction
* @param logging:: If true, enable logging
*/
void Load::setUpLoader(API::IAlgorithm_sptr &loader, const double startProgress,
const double endProgress, const bool logging) const {
// Set as a child so that we are in control of output storage
loader->setChild(true);
loader->setLogging(logging);
// If output workspaces are nameless, give them a temporary name to satisfy
// validator
const std::vector<Property *> &props = loader->getProperties();
for (auto prop : props) {
auto wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
if (wsProp && !wsProp->isOptional() &&
prop->direction() == Direction::Output) {
if (prop->value().empty())
prop->setValue("LoadChildWorkspace");
}
}
if (startProgress >= 0. && endProgress > startProgress && endProgress <= 1.) {
loader->addObserver(this->progressObserver());
setChildStartProgress(startProgress);
setChildEndProgress(endProgress);
}
}
/** Group detectors in the workspace.
* @param ws :: A local workspace
* @param spectraList :: A list of spectra to group.
*/
void PlotAsymmetryByLogValue::groupDetectors(API::MatrixWorkspace_sptr& ws,const std::vector<int>& spectraList)
{
API::IAlgorithm_sptr group = createChildAlgorithm("GroupDetectors");
group->setProperty("InputWorkspace",ws);
group->setProperty("SpectraList",spectraList);
group->setProperty("KeepUngroupedSpectra",true);
group->execute();
ws = group->getProperty("OutputWorkspace");
}
/** Rebin
*/
API::MatrixWorkspace_sptr
AlignAndFocusPowder::rebin(API::MatrixWorkspace_sptr matrixws) {
if (m_resampleX != 0) {
// ResampleX
g_log.information() << "running ResampleX(NumberBins=" << abs(m_resampleX)
<< ", LogBinning=" << (m_resampleX < 0) << ", dMin("
<< m_dmins.size() << "), dmax(" << m_dmaxs.size()
<< ")) started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr alg = createChildAlgorithm("ResampleX");
alg->setProperty("InputWorkspace", matrixws);
alg->setProperty("OutputWorkspace", matrixws);
if ((!m_dmins.empty()) && (!m_dmaxs.empty())) {
size_t numHist = m_outputW->getNumberHistograms();
if ((numHist == m_dmins.size()) && (numHist == m_dmaxs.size())) {
alg->setProperty("XMin", m_dmins);
alg->setProperty("XMax", m_dmaxs);
} else {
g_log.information()
<< "Number of dmin and dmax values don't match the "
<< "number of workspace indices. Ignoring the parameters.\n";
}
}
alg->setProperty("NumberBins", abs(m_resampleX));
alg->setProperty("LogBinning", (m_resampleX < 0));
alg->executeAsChildAlg();
matrixws = alg->getProperty("OutputWorkspace");
return matrixws;
} else {
g_log.information() << "running Rebin( ";
for (double param : m_params)
g_log.information() << param << " ";
g_log.information() << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr rebin3Alg = createChildAlgorithm("Rebin");
rebin3Alg->setProperty("InputWorkspace", matrixws);
rebin3Alg->setProperty("OutputWorkspace", matrixws);
rebin3Alg->setProperty("Params", m_params);
rebin3Alg->executeAsChildAlg();
matrixws = rebin3Alg->getProperty("OutputWorkspace");
return matrixws;
}
}
/** Extracts relevant data from a workspace
* @param startTime :: [input] First X value to consider
* @param endTime :: [input] Last X value to consider
* @return :: Pre-processed workspace to fit
*/
API::MatrixWorkspace_sptr
CalMuonDetectorPhases::extractDataFromWorkspace(double startTime,
double endTime) {
// Extract counts from startTime to endTime
API::IAlgorithm_sptr crop = createChildAlgorithm("CropWorkspace");
crop->setProperty("InputWorkspace", m_inputWS);
crop->setProperty("XMin", startTime);
crop->setProperty("XMax", endTime);
crop->executeAsChildAlg();
boost::shared_ptr<API::MatrixWorkspace> wsCrop =
crop->getProperty("OutputWorkspace");
return wsCrop;
}
/** Call diffraction focus to a matrix workspace.
*/
API::MatrixWorkspace_sptr
AlignAndFocusPowder::diffractionFocus(API::MatrixWorkspace_sptr ws) {
if (!m_groupWS) {
g_log.information() << "not focussing data\n";
return ws;
}
g_log.information() << "running DiffractionFocussing. \n";
API::IAlgorithm_sptr focusAlg = createChildAlgorithm("DiffractionFocussing");
focusAlg->setProperty("InputWorkspace", ws);
focusAlg->setProperty("OutputWorkspace", ws);
focusAlg->setProperty("GroupingWorkspace", m_groupWS);
focusAlg->setProperty("PreserveEvents", m_preserveEvents);
focusAlg->executeAsChildAlg();
ws = focusAlg->getProperty("OutputWorkspace");
return ws;
}
void LoadILLSANS::moveDetectorVertical(double shift,
const std::string &componentName) {
API::IAlgorithm_sptr mover = createChildAlgorithm("MoveInstrumentComponent");
V3D pos = getComponentPosition(componentName);
try {
mover->setProperty<MatrixWorkspace_sptr>("Workspace", m_localWorkspace);
mover->setProperty("ComponentName", componentName);
mover->setProperty("X", pos.X());
mover->setProperty("Y", shift);
mover->setProperty("Z", pos.Z());
mover->setProperty("RelativePosition", false);
mover->executeAsChildAlg();
g_log.debug() << "Moving component '" << componentName
<< "' to Y = " << shift << '\n';
} catch (std::exception &e) {
g_log.error() << "Cannot move the component '" << componentName
<< "' to Y = " << shift << '\n';
g_log.error() << e.what() << '\n';
}
}
/** Fit background function
*/
void ProcessBackground::fitBackgroundFunction(std::string bkgdfunctiontype) {
// Get background type and create bakground function
BackgroundFunction_sptr bkgdfunction =
createBackgroundFunction(bkgdfunctiontype);
int bkgdorder = getProperty("OutputBackgroundOrder");
bkgdfunction->setAttributeValue("n", bkgdorder);
if (bkgdfunctiontype == "Chebyshev") {
double xmin = m_outputWS->readX(0).front();
double xmax = m_outputWS->readX(0).back();
g_log.information() << "Chebyshev Fit range: " << xmin << ", " << xmax
<< "\n";
bkgdfunction->setAttributeValue("StartX", xmin);
bkgdfunction->setAttributeValue("EndX", xmax);
}
g_log.information() << "Fit selected background " << bkgdfunctiontype
<< " to data workspace with "
<< m_outputWS->getNumberHistograms() << " spectra."
<< "\n";
// Fit input (a few) background pionts to get initial guess
API::IAlgorithm_sptr fit;
try {
fit = this->createChildAlgorithm("Fit", 0.9, 1.0, true);
} catch (Exception::NotFoundError &) {
g_log.error() << "Requires CurveFitting library." << std::endl;
throw;
}
g_log.information() << "Fitting background function: "
<< bkgdfunction->asString() << "\n";
double startx = m_lowerBound;
double endx = m_upperBound;
fit->setProperty("Function",
boost::dynamic_pointer_cast<API::IFunction>(bkgdfunction));
fit->setProperty("InputWorkspace", m_outputWS);
fit->setProperty("WorkspaceIndex", 0);
fit->setProperty("MaxIterations", 500);
fit->setProperty("StartX", startx);
fit->setProperty("EndX", endx);
fit->setProperty("Minimizer", "Levenberg-MarquardtMD");
fit->setProperty("CostFunction", "Least squares");
fit->executeAsChildAlg();
// Get fit status and chi^2
std::string fitStatus = fit->getProperty("OutputStatus");
bool allowedfailure = (fitStatus.find("cannot") < fitStatus.size()) &&
(fitStatus.find("tolerance") < fitStatus.size());
if (fitStatus.compare("success") != 0 && !allowedfailure) {
g_log.error() << "ProcessBackground: Fit Status = " << fitStatus
<< ". Not to update fit result" << std::endl;
throw std::runtime_error("Bad Fit");
}
const double chi2 = fit->getProperty("OutputChi2overDoF");
g_log.information() << "Fit background: Fit Status = " << fitStatus
<< ", chi2 = " << chi2 << "\n";
// Get out the parameter names
API::IFunction_sptr funcout = fit->getProperty("Function");
TableWorkspace_sptr outbkgdparws = boost::make_shared<TableWorkspace>();
outbkgdparws->addColumn("str", "Name");
outbkgdparws->addColumn("double", "Value");
TableRow typerow = outbkgdparws->appendRow();
typerow << bkgdfunctiontype << 0.;
vector<string> parnames = funcout->getParameterNames();
size_t nparam = funcout->nParams();
for (size_t i = 0; i < nparam; ++i) {
TableRow newrow = outbkgdparws->appendRow();
newrow << parnames[i] << funcout->getParameter(i);
}
TableRow chi2row = outbkgdparws->appendRow();
chi2row << "Chi-square" << chi2;
g_log.information() << "Set table workspace (#row = "
<< outbkgdparws->rowCount()
<< ") to OutputBackgroundParameterTable. "
<< "\n";
setProperty("OutputBackgroundParameterWorkspace", outbkgdparws);
// Set output workspace
const MantidVec &vecX = m_outputWS->readX(0);
const MantidVec &vecY = m_outputWS->readY(0);
FunctionDomain1DVector domain(vecX);
FunctionValues values(domain);
funcout->function(domain, values);
MantidVec &dataModel = m_outputWS->dataY(1);
MantidVec &dataDiff = m_outputWS->dataY(2);
for (size_t i = 0; i < dataModel.size(); ++i) {
dataModel[i] = values[i];
dataDiff[i] = vecY[i] - dataModel[i];
}
return;
}
/** Select background automatically
*/
DataObjects::Workspace2D_sptr
ProcessBackground::autoBackgroundSelection(Workspace2D_sptr bkgdWS) {
// Get background type and create bakground function
BackgroundFunction_sptr bkgdfunction = createBackgroundFunction(m_bkgdType);
int bkgdorder = getProperty("BackgroundOrder");
if (bkgdorder == 0)
g_log.warning("(Input) background function order is 0. It might not be "
"able to give a good estimation.");
bkgdfunction->setAttributeValue("n", bkgdorder);
bkgdfunction->initialize();
g_log.information() << "Input background points has "
<< bkgdWS->readX(0).size() << " data points for fit "
<< bkgdorder << "-th order " << bkgdfunction->name()
<< " (background) function" << bkgdfunction->asString()
<< "\n";
// Fit input (a few) background pionts to get initial guess
API::IAlgorithm_sptr fit;
try {
fit = this->createChildAlgorithm("Fit", 0.0, 0.2, true);
} catch (Exception::NotFoundError &) {
g_log.error() << "Requires CurveFitting library." << std::endl;
throw;
}
double startx = m_lowerBound;
double endx = m_upperBound;
fit->setProperty("Function",
boost::dynamic_pointer_cast<API::IFunction>(bkgdfunction));
fit->setProperty("InputWorkspace", bkgdWS);
fit->setProperty("WorkspaceIndex", 0);
fit->setProperty("MaxIterations", 500);
fit->setProperty("StartX", startx);
fit->setProperty("EndX", endx);
fit->setProperty("Minimizer", "Levenberg-Marquardt");
fit->setProperty("CostFunction", "Least squares");
fit->executeAsChildAlg();
// Get fit result
// a) Status
std::string fitStatus = fit->getProperty("OutputStatus");
bool allowedfailure = (fitStatus.find("cannot") < fitStatus.size()) &&
(fitStatus.find("tolerance") < fitStatus.size());
if (fitStatus.compare("success") != 0 && !allowedfailure) {
g_log.error() << "ProcessBackground: Fit Status = " << fitStatus
<< ". Not to update fit result" << std::endl;
throw std::runtime_error("Bad Fit");
}
// b) check that chi2 got better
const double chi2 = fit->getProperty("OutputChi2overDoF");
g_log.information() << "Fit background: Fit Status = " << fitStatus
<< ", chi2 = " << chi2 << "\n";
// Filter and construct for the output workspace
Workspace2D_sptr outws = filterForBackground(bkgdfunction);
return outws;
} // END OF FUNCTION
/** Executes the algorithm
* @throw Exception::FileError If the grouping file cannot be opened or read
* successfully
* @throw runtime_error If unable to run one of the Child Algorithms
* successfully
*/
void AlignAndFocusPowder::exec() {
// retrieve the properties
m_inputW = getProperty("InputWorkspace");
m_inputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_inputW);
m_instName = m_inputW->getInstrument()->getName();
m_instName =
Kernel::ConfigService::Instance().getInstrument(m_instName).shortName();
std::string calFilename = getPropertyValue("CalFileName");
std::string groupFilename = getPropertyValue("GroupFilename");
m_calibrationWS = getProperty("CalibrationWorkspace");
m_maskWS = getProperty("MaskWorkspace");
m_groupWS = getProperty("GroupingWorkspace");
DataObjects::TableWorkspace_sptr maskBinTableWS = getProperty("MaskBinTable");
m_l1 = getProperty("PrimaryFlightPath");
specids = getProperty("SpectrumIDs");
l2s = getProperty("L2");
tths = getProperty("Polar");
phis = getProperty("Azimuthal");
m_params = getProperty("Params");
dspace = getProperty("DSpacing");
auto dmin = getVecPropertyFromPmOrSelf("DMin", m_dmins);
auto dmax = getVecPropertyFromPmOrSelf("DMax", m_dmaxs);
LRef = getProperty("UnwrapRef");
DIFCref = getProperty("LowResRef");
minwl = getProperty("CropWavelengthMin");
maxwl = getProperty("CropWavelengthMax");
if (maxwl == 0.)
maxwl = EMPTY_DBL(); // python can only specify 0 for unused
tmin = getProperty("TMin");
tmax = getProperty("TMax");
m_preserveEvents = getProperty("PreserveEvents");
m_resampleX = getProperty("ResampleX");
// determine some bits about d-space and binning
if (m_resampleX != 0) {
m_params.clear(); // ignore the normal rebin parameters
} else if (m_params.size() == 1) {
if (dmax > 0.)
dspace = true;
else
dspace = false;
}
if (dspace) {
if (m_params.size() == 1 && dmax > 0) {
double step = m_params[0];
m_params.clear();
if (step > 0 || dmin > 0) {
m_params.push_back(dmin);
m_params.push_back(step);
m_params.push_back(dmax);
g_log.information() << "d-Spacing Binning: " << m_params[0] << " "
<< m_params[1] << " " << m_params[2] << "\n";
}
}
} else {
if (m_params.size() == 1 && tmax > 0) {
double step = m_params[0];
if (step > 0 || tmin > 0) {
m_params[0] = tmin;
m_params.push_back(step);
m_params.push_back(tmax);
g_log.information() << "TOF Binning: " << m_params[0] << " "
<< m_params[1] << " " << m_params[2] << "\n";
}
}
}
xmin = 0.;
xmax = 0.;
if (tmin > 0.) {
xmin = tmin;
}
if (tmax > 0.) {
xmax = tmax;
}
if (!dspace && m_params.size() == 3) {
xmin = m_params[0];
xmax = m_params[2];
}
// Low resolution
int lowresoffset = getProperty("LowResSpectrumOffset");
if (lowresoffset < 0) {
m_processLowResTOF = false;
} else {
m_processLowResTOF = true;
m_lowResSpecOffset = static_cast<size_t>(lowresoffset);
}
loadCalFile(calFilename, groupFilename);
// Now setup the output workspace
m_outputW = getProperty("OutputWorkspace");
if (m_inputEW) {
if (m_outputW != m_inputW) {
m_outputEW = m_inputEW->clone();
}
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
} else {
if (m_outputW != m_inputW) {
m_outputW = WorkspaceFactory::Instance().create(m_inputW);
}
}
if (m_processLowResTOF) {
if (!m_inputEW) {
throw std::runtime_error(
"Input workspace is not EventWorkspace. It is not supported now.");
} else {
// Make a brand new EventWorkspace
m_lowResEW = boost::dynamic_pointer_cast<EventWorkspace>(
WorkspaceFactory::Instance().create(
"EventWorkspace", m_inputEW->getNumberHistograms(), 2, 1));
// Cast to the matrixOutputWS and save it
m_lowResW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_lowResEW);
// m_lowResW->setName(lowreswsname);
}
}
// set up a progress bar with the "correct" number of steps
m_progress = new Progress(this, 0., 1., 22);
if (m_inputEW) {
double tolerance = getProperty("CompressTolerance");
if (tolerance > 0.) {
g_log.information() << "running CompressEvents(Tolerance=" << tolerance
<< ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr compressAlg = createChildAlgorithm("CompressEvents");
compressAlg->setProperty("InputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("Tolerance", tolerance);
compressAlg->executeAsChildAlg();
m_outputEW = compressAlg->getProperty("OutputWorkspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_outputEW);
} else {
g_log.information() << "Not compressing event list\n";
doSortEvents(m_outputW); // still sort to help some thing out
}
}
m_progress->report();
if (xmin > 0. || xmax > 0.) {
double tempmin;
double tempmax;
m_outputW->getXMinMax(tempmin, tempmax);
g_log.information() << "running CropWorkspace(TOFmin=" << xmin
<< ", TOFmax=" << xmax << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr cropAlg = createChildAlgorithm("CropWorkspace");
cropAlg->setProperty("InputWorkspace", m_outputW);
cropAlg->setProperty("OutputWorkspace", m_outputW);
if ((xmin > 0.) && (xmin > tempmin))
cropAlg->setProperty("Xmin", xmin);
if ((xmax > 0.) && (xmax < tempmax))
cropAlg->setProperty("Xmax", xmax);
cropAlg->executeAsChildAlg();
m_outputW = cropAlg->getProperty("OutputWorkspace");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
}
m_progress->report();
// filter the input events if appropriate
double removePromptPulseWidth = getProperty("RemovePromptPulseWidth");
if (removePromptPulseWidth > 0.) {
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (m_outputEW->getNumberEvents() > 0) {
g_log.information() << "running RemovePromptPulse(Width="
<< removePromptPulseWidth << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr filterPAlg =
createChildAlgorithm("RemovePromptPulse");
filterPAlg->setProperty("InputWorkspace", m_outputW);
filterPAlg->setProperty("OutputWorkspace", m_outputW);
filterPAlg->setProperty("Width", removePromptPulseWidth);
filterPAlg->executeAsChildAlg();
m_outputW = filterPAlg->getProperty("OutputWorkspace");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
} else {
g_log.information("skipping RemovePromptPulse on empty EventWorkspace");
}
}
m_progress->report();
if (maskBinTableWS) {
g_log.information() << "running MaskBinsFromTable started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr alg = createChildAlgorithm("MaskBinsFromTable");
alg->setProperty("InputWorkspace", m_outputW);
alg->setProperty("OutputWorkspace", m_outputW);
alg->setProperty("MaskingInformation", maskBinTableWS);
alg->executeAsChildAlg();
m_outputW = alg->getProperty("OutputWorkspace");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
}
m_progress->report();
if (m_maskWS) {
g_log.information() << "running MaskDetectors started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr maskAlg = createChildAlgorithm("MaskDetectors");
maskAlg->setProperty("Workspace", m_outputW);
maskAlg->setProperty("MaskedWorkspace", m_maskWS);
maskAlg->executeAsChildAlg();
Workspace_sptr tmpW = maskAlg->getProperty("Workspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(tmpW);
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
}
m_progress->report();
if (!dspace)
m_outputW = rebin(m_outputW);
m_progress->report();
if (m_calibrationWS) {
g_log.information() << "running AlignDetectors started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr alignAlg = createChildAlgorithm("AlignDetectors");
alignAlg->setProperty("InputWorkspace", m_outputW);
alignAlg->setProperty("OutputWorkspace", m_outputW);
alignAlg->setProperty("CalibrationWorkspace", m_calibrationWS);
alignAlg->executeAsChildAlg();
m_outputW = alignAlg->getProperty("OutputWorkspace");
} else {
m_outputW = convertUnits(m_outputW, "dSpacing");
}
m_progress->report();
if (LRef > 0. || minwl > 0. || DIFCref > 0. || (!isEmpty(maxwl))) {
m_outputW = convertUnits(m_outputW, "TOF");
}
m_progress->report();
// Beyond this point, low resolution TOF workspace is considered.
if (LRef > 0.) {
g_log.information() << "running UnwrapSNS(LRef=" << LRef << ",Tmin=" << tmin
<< ",Tmax=" << tmax << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr removeAlg = createChildAlgorithm("UnwrapSNS");
removeAlg->setProperty("InputWorkspace", m_outputW);
removeAlg->setProperty("OutputWorkspace", m_outputW);
removeAlg->setProperty("LRef", LRef);
if (tmin > 0.)
removeAlg->setProperty("Tmin", tmin);
if (tmax > tmin)
removeAlg->setProperty("Tmax", tmax);
removeAlg->executeAsChildAlg();
m_outputW = removeAlg->getProperty("OutputWorkspace");
}
m_progress->report();
if (minwl > 0. || (!isEmpty(maxwl))) { // just crop the worksapce
// turn off the low res stuff
m_processLowResTOF = false;
EventWorkspace_sptr ews =
boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (ews)
g_log.information() << "Number of events = " << ews->getNumberEvents()
<< ". ";
g_log.information("\n");
m_outputW = convertUnits(m_outputW, "Wavelength");
g_log.information() << "running CropWorkspace(WavelengthMin=" << minwl;
if (!isEmpty(maxwl))
g_log.information() << ", WavelengthMax=" << maxwl;
g_log.information() << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr removeAlg = createChildAlgorithm("CropWorkspace");
removeAlg->setProperty("InputWorkspace", m_outputW);
removeAlg->setProperty("OutputWorkspace", m_outputW);
removeAlg->setProperty("XMin", minwl);
removeAlg->setProperty("XMax", maxwl);
removeAlg->executeAsChildAlg();
m_outputW = removeAlg->getProperty("OutputWorkspace");
if (ews)
g_log.information() << "Number of events = " << ews->getNumberEvents()
<< ".\n";
} else if (DIFCref > 0.) {
g_log.information() << "running RemoveLowResTof(RefDIFC=" << DIFCref
<< ",K=3.22) started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
EventWorkspace_sptr ews =
boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (ews)
g_log.information() << "Number of events = " << ews->getNumberEvents()
<< ". ";
g_log.information("\n");
API::IAlgorithm_sptr removeAlg = createChildAlgorithm("RemoveLowResTOF");
removeAlg->setProperty("InputWorkspace", m_outputW);
removeAlg->setProperty("OutputWorkspace", m_outputW);
removeAlg->setProperty("ReferenceDIFC", DIFCref);
removeAlg->setProperty("K", 3.22);
if (tmin > 0.)
removeAlg->setProperty("Tmin", tmin);
if (m_processLowResTOF)
removeAlg->setProperty("LowResTOFWorkspace", m_lowResW);
removeAlg->executeAsChildAlg();
m_outputW = removeAlg->getProperty("OutputWorkspace");
if (m_processLowResTOF)
m_lowResW = removeAlg->getProperty("LowResTOFWorkspace");
}
m_progress->report();
EventWorkspace_sptr ews =
boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (ews) {
size_t numhighevents = ews->getNumberEvents();
if (m_processLowResTOF) {
EventWorkspace_sptr lowes =
boost::dynamic_pointer_cast<EventWorkspace>(m_lowResW);
size_t numlowevents = lowes->getNumberEvents();
g_log.information() << "Number of high TOF events = " << numhighevents
<< "; "
<< "Number of low TOF events = " << numlowevents
<< ".\n";
}
}
m_progress->report();
// Convert units
if (LRef > 0. || minwl > 0. || DIFCref > 0. || (!isEmpty(maxwl))) {
m_outputW = convertUnits(m_outputW, "dSpacing");
if (m_processLowResTOF)
m_lowResW = convertUnits(m_lowResW, "dSpacing");
}
m_progress->report();
if (dspace) {
m_outputW = rebin(m_outputW);
if (m_processLowResTOF)
m_lowResW = rebin(m_lowResW);
}
m_progress->report();
doSortEvents(m_outputW);
if (m_processLowResTOF)
doSortEvents(m_lowResW);
m_progress->report();
// Diffraction focus
m_outputW = diffractionFocus(m_outputW);
if (m_processLowResTOF)
m_lowResW = diffractionFocus(m_lowResW);
m_progress->report();
doSortEvents(m_outputW);
if (m_processLowResTOF)
doSortEvents(m_lowResW);
m_progress->report();
// this next call should probably be in for rebin as well
// but it changes the system tests
if (dspace && m_resampleX != 0) {
m_outputW = rebin(m_outputW);
if (m_processLowResTOF)
m_lowResW = rebin(m_lowResW);
}
m_progress->report();
// edit the instrument geometry
if (m_groupWS &&
(m_l1 > 0 || !tths.empty() || !l2s.empty() || !phis.empty())) {
size_t numreg = m_outputW->getNumberHistograms();
try {
// set up the vectors for doing everything
auto specidsSplit = splitVectors(specids, numreg, "specids");
auto tthsSplit = splitVectors(tths, numreg, "two-theta");
auto l2sSplit = splitVectors(l2s, numreg, "L2");
auto phisSplit = splitVectors(phis, numreg, "phi");
// Edit instrument
m_outputW = editInstrument(m_outputW, tthsSplit.reg, specidsSplit.reg,
l2sSplit.reg, phisSplit.reg);
if (m_processLowResTOF) {
m_lowResW = editInstrument(m_lowResW, tthsSplit.low, specidsSplit.low,
l2sSplit.low, phisSplit.low);
}
} catch (std::runtime_error &e) {
g_log.warning("Not editing instrument geometry:");
g_log.warning(e.what());
}
}
m_progress->report();
// Conjoin 2 workspaces if there is low resolution
if (m_processLowResTOF) {
m_outputW = conjoinWorkspaces(m_outputW, m_lowResW, m_lowResSpecOffset);
}
m_progress->report();
// Convert units to TOF
m_outputW = convertUnits(m_outputW, "TOF");
m_progress->report();
// compress again if appropriate
double tolerance = getProperty("CompressTolerance");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if ((m_outputEW) && (tolerance > 0.)) {
g_log.information() << "running CompressEvents(Tolerance=" << tolerance
<< ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr compressAlg = createChildAlgorithm("CompressEvents");
compressAlg->setProperty("InputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("Tolerance", tolerance);
compressAlg->executeAsChildAlg();
m_outputEW = compressAlg->getProperty("OutputWorkspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_outputEW);
}
m_progress->report();
if ((!m_params.empty()) && (m_params.size() != 1)) {
m_params.erase(m_params.begin());
m_params.pop_back();
}
if (!m_dmins.empty())
m_dmins.clear();
if (!m_dmaxs.empty())
m_dmaxs.clear();
m_outputW = rebin(m_outputW);
m_progress->report();
// return the output workspace
setProperty("OutputWorkspace", m_outputW);
}
/** Fit function
* Minimizer: "Levenberg-MarquardtMD"/"Simplex"
*/
bool RefinePowderInstrumentParameters2::doFitFunction(IFunction_sptr function, Workspace2D_sptr dataws, int wsindex,
string minimizer, int numiters, double& chi2, string& fitstatus)
{
// 0. Debug output
stringstream outss;
outss << "Fit function: " << m_positionFunc->asString() << endl << "Data To Fit: \n";
for (size_t i = 0; i < dataws->readX(0).size(); ++i)
outss << dataws->readX(wsindex)[i] << "\t\t" << dataws->readY(wsindex)[i] << "\t\t"
<< dataws->readE(wsindex)[i] << "\n";
g_log.information() << outss.str();
// 1. Create and setup fit algorithm
API::IAlgorithm_sptr fitalg = createChildAlgorithm("Fit", 0.0, 0.2, true);
fitalg->initialize();
fitalg->setProperty("Function", function);
fitalg->setProperty("InputWorkspace", dataws);
fitalg->setProperty("WorkspaceIndex", wsindex);
fitalg->setProperty("Minimizer", minimizer);
fitalg->setProperty("CostFunction", "Least squares");
fitalg->setProperty("MaxIterations", numiters);
fitalg->setProperty("CalcErrors", true);
// 2. Fit
bool successfulfit = fitalg->execute();
if (!fitalg->isExecuted() || ! successfulfit)
{
// Early return due to bad fit
g_log.warning("Fitting to instrument geometry function failed. ");
chi2 = DBL_MAX;
fitstatus = "Minimizer throws exception.";
return false;
}
// 3. Understand solution
chi2 = fitalg->getProperty("OutputChi2overDoF");
string tempfitstatus = fitalg->getProperty("OutputStatus");
fitstatus = tempfitstatus;
bool goodfit = fitstatus.compare("success") == 0;
stringstream dbss;
dbss << "Fit Result (GSL): Chi^2 = " << chi2
<< "; Fit Status = " << fitstatus << ", Return Bool = " << goodfit << std::endl;
vector<string> funcparnames = function->getParameterNames();
for (size_t i = 0; i < funcparnames.size(); ++i)
dbss << funcparnames[i] << " = " << setw(20) << function->getParameter(funcparnames[i])
<< " +/- " << function->getError(i) << "\n";
g_log.debug() << dbss.str();
return goodfit;
}
/**
* Execute the algorithm.
*/
void LoadBBY::exec() {
// Delete the output workspace name if it existed
std::string outName = getPropertyValue("OutputWorkspace");
if (API::AnalysisDataService::Instance().doesExist(outName))
API::AnalysisDataService::Instance().remove(outName);
// Get the name of the data file.
std::string filename = getPropertyValue(FilenameStr);
ANSTO::Tar::File tarFile(filename);
if (!tarFile.good())
throw std::invalid_argument("invalid BBY file");
// region of intreset
std::vector<bool> roi = createRoiVector(getPropertyValue(MaskStr));
double tofMinBoundary = getProperty(FilterByTofMinStr);
double tofMaxBoundary = getProperty(FilterByTofMaxStr);
double timeMinBoundary = getProperty(FilterByTimeStartStr);
double timeMaxBoundary = getProperty(FilterByTimeStopStr);
if (isEmpty(tofMaxBoundary))
tofMaxBoundary = std::numeric_limits<double>::infinity();
if (isEmpty(timeMaxBoundary))
timeMaxBoundary = std::numeric_limits<double>::infinity();
API::Progress prog(this, 0.0, 1.0, Progress_Total);
prog.doReport("creating instrument");
// create workspace
DataObjects::EventWorkspace_sptr eventWS =
boost::make_shared<DataObjects::EventWorkspace>();
eventWS->initialize(HISTO_BINS_Y * HISTO_BINS_X,
2, // number of TOF bin boundaries
1);
// set the units
eventWS->getAxis(0)->unit() = Kernel::UnitFactory::Instance().create("TOF");
eventWS->setYUnit("Counts");
// set title
const std::vector<std::string> &subFiles = tarFile.files();
for (const auto &subFile : subFiles)
if (subFile.compare(0, 3, "BBY") == 0) {
std::string title = subFile;
if (title.rfind(".hdf") == title.length() - 4)
title.resize(title.length() - 4);
if (title.rfind(".nx") == title.length() - 3)
title.resize(title.length() - 3);
eventWS->setTitle(title);
break;
}
// create instrument
InstrumentInfo instrumentInfo;
// Geometry::Instrument_sptr instrument =
createInstrument(tarFile, /* ref */ instrumentInfo);
// eventWS->setInstrument(instrument);
// load events
size_t numberHistograms = eventWS->getNumberHistograms();
std::vector<EventVector_pt> eventVectors(numberHistograms, nullptr);
std::vector<size_t> eventCounts(numberHistograms, 0);
// phase correction
Kernel::Property *periodMasterProperty =
getPointerToProperty(PeriodMasterStr);
Kernel::Property *periodSlaveProperty = getPointerToProperty(PeriodSlaveStr);
Kernel::Property *phaseSlaveProperty = getPointerToProperty(PhaseSlaveStr);
double periodMaster;
double periodSlave;
double phaseSlave;
if (periodMasterProperty->isDefault() || periodSlaveProperty->isDefault() ||
phaseSlaveProperty->isDefault()) {
if (!periodMasterProperty->isDefault() ||
!periodSlaveProperty->isDefault() || !phaseSlaveProperty->isDefault()) {
throw std::invalid_argument("Please specify PeriodMaster, PeriodSlave "
"and PhaseSlave or none of them.");
}
// if values have not been specified in loader then use values from hdf file
periodMaster = instrumentInfo.period_master;
periodSlave = instrumentInfo.period_slave;
phaseSlave = instrumentInfo.phase_slave;
} else {
periodMaster = getProperty(PeriodMasterStr);
periodSlave = getProperty(PeriodSlaveStr);
phaseSlave = getProperty(PhaseSlaveStr);
if ((periodMaster < 0.0) || (periodSlave < 0.0))
throw std::invalid_argument(
"Please specify a positive value for PeriodMaster and PeriodSlave.");
}
double period = periodSlave;
double shift = -1.0 / 6.0 * periodMaster - periodSlave * phaseSlave / 360.0;
// count total events per pixel to reserve necessary memory
ANSTO::EventCounter eventCounter(
roi, HISTO_BINS_Y, period, shift, tofMinBoundary, tofMaxBoundary,
timeMinBoundary, timeMaxBoundary, eventCounts);
loadEvents(prog, "loading neutron counts", tarFile, eventCounter);
// prepare event storage
ANSTO::ProgressTracker progTracker(prog, "creating neutron event lists",
numberHistograms, Progress_ReserveMemory);
for (size_t i = 0; i != numberHistograms; ++i) {
DataObjects::EventList &eventList = eventWS->getEventList(i);
eventList.setSortOrder(DataObjects::PULSETIME_SORT);
eventList.reserve(eventCounts[i]);
eventList.setDetectorID(static_cast<detid_t>(i));
eventList.setSpectrumNo(static_cast<detid_t>(i));
DataObjects::getEventsFrom(eventList, eventVectors[i]);
progTracker.update(i);
}
progTracker.complete();
ANSTO::EventAssigner eventAssigner(
roi, HISTO_BINS_Y, period, shift, tofMinBoundary, tofMaxBoundary,
timeMinBoundary, timeMaxBoundary, eventVectors);
loadEvents(prog, "loading neutron events", tarFile, eventAssigner);
Kernel::cow_ptr<MantidVec> axis;
MantidVec &xRef = axis.access();
xRef.resize(2, 0.0);
xRef[0] = std::max(
0.0,
floor(eventCounter.tofMin())); // just to make sure the bins hold it all
xRef[1] = eventCounter.tofMax() + 1;
eventWS->setAllX(axis);
// count total number of masked bins
size_t maskedBins = 0;
for (size_t i = 0; i != roi.size(); i++)
if (!roi[i])
maskedBins++;
if (maskedBins > 0) {
// create list of masked bins
std::vector<size_t> maskIndexList(maskedBins);
size_t maskIndex = 0;
for (size_t i = 0; i != roi.size(); i++)
if (!roi[i])
maskIndexList[maskIndex++] = i;
API::IAlgorithm_sptr maskingAlg = createChildAlgorithm("MaskDetectors");
maskingAlg->setProperty("Workspace", eventWS);
maskingAlg->setProperty("WorkspaceIndexList", maskIndexList);
maskingAlg->executeAsChildAlg();
}
// set log values
API::LogManager &logManager = eventWS->mutableRun();
logManager.addProperty("filename", filename);
logManager.addProperty("att_pos", static_cast<int>(instrumentInfo.att_pos));
logManager.addProperty("frame_count",
static_cast<int>(eventCounter.numFrames()));
logManager.addProperty("period", period);
// currently beam monitor counts are not available, instead number of frames
// times period is used
logManager.addProperty(
"bm_counts", static_cast<double>(eventCounter.numFrames()) * period /
1.0e6); // static_cast<double>(instrumentInfo.bm_counts)
// currently
Kernel::time_duration duration =
boost::posix_time::microseconds(static_cast<boost::int64_t>(
static_cast<double>(eventCounter.numFrames()) * period));
Kernel::DateAndTime start_time("2000-01-01T00:00:00");
Kernel::DateAndTime end_time(start_time + duration);
logManager.addProperty("start_time", start_time.toISO8601String());
logManager.addProperty("end_time", end_time.toISO8601String());
std::string time_str = start_time.toISO8601String();
AddSinglePointTimeSeriesProperty(logManager, time_str, "L1_chopper_value",
instrumentInfo.L1_chopper_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "L2_det_value",
instrumentInfo.L2_det_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "L2_curtainl_value",
instrumentInfo.L2_curtainl_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "L2_curtainr_value",
instrumentInfo.L2_curtainr_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "L2_curtainu_value",
instrumentInfo.L2_curtainu_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "L2_curtaind_value",
instrumentInfo.L2_curtaind_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "D_det_value",
instrumentInfo.D_det_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "D_curtainl_value",
instrumentInfo.D_curtainl_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "D_curtainr_value",
instrumentInfo.D_curtainr_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "D_curtainu_value",
instrumentInfo.D_curtainu_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "D_curtaind_value",
instrumentInfo.D_curtaind_value);
AddSinglePointTimeSeriesProperty(logManager, time_str, "curtain_rotation",
10.0);
API::IAlgorithm_sptr loadInstrumentAlg =
createChildAlgorithm("LoadInstrument");
loadInstrumentAlg->setProperty("Workspace", eventWS);
loadInstrumentAlg->setPropertyValue("InstrumentName", "BILBY");
loadInstrumentAlg->setProperty("RewriteSpectraMap",
Mantid::Kernel::OptionalBool(false));
loadInstrumentAlg->executeAsChildAlg();
setProperty("OutputWorkspace", eventWS);
}
/**
* Gaussian fit to determine peak position if no user position given.
*
* @return :: detector position of the peak: Gaussian fit and position
* of the maximum (serves as start value for the optimization)
*/
double LoadILLReflectometry::reflectometryPeak() {
if (!isDefault("BeamCentre")) {
return getProperty("BeamCentre");
}
size_t startIndex;
size_t endIndex;
std::tie(startIndex, endIndex) =
fitIntegrationWSIndexRange(*m_localWorkspace);
IAlgorithm_sptr integration = createChildAlgorithm("Integration");
integration->initialize();
integration->setProperty("InputWorkspace", m_localWorkspace);
integration->setProperty("OutputWorkspace", "__unused_for_child");
integration->setProperty("StartWorkspaceIndex", static_cast<int>(startIndex));
integration->setProperty("EndWorkspaceIndex", static_cast<int>(endIndex));
integration->execute();
MatrixWorkspace_sptr integralWS = integration->getProperty("OutputWorkspace");
IAlgorithm_sptr transpose = createChildAlgorithm("Transpose");
transpose->initialize();
transpose->setProperty("InputWorkspace", integralWS);
transpose->setProperty("OutputWorkspace", "__unused_for_child");
transpose->execute();
integralWS = transpose->getProperty("OutputWorkspace");
rebinIntegralWorkspace(*integralWS);
// determine initial height: maximum value
const auto maxValueIt =
std::max_element(integralWS->y(0).cbegin(), integralWS->y(0).cend());
const double height = *maxValueIt;
// determine initial centre: index of the maximum value
const size_t maxIndex = std::distance(integralWS->y(0).cbegin(), maxValueIt);
const double centreByMax = static_cast<double>(maxIndex);
g_log.debug() << "Peak maximum position: " << centreByMax << '\n';
// determine sigma
const auto &ys = integralWS->y(0);
auto lessThanHalfMax = [height](const double x) { return x < 0.5 * height; };
using IterType = HistogramData::HistogramY::const_iterator;
std::reverse_iterator<IterType> revMaxValueIt{maxValueIt};
auto revMinFwhmIt = std::find_if(revMaxValueIt, ys.crend(), lessThanHalfMax);
auto maxFwhmIt = std::find_if(maxValueIt, ys.cend(), lessThanHalfMax);
std::reverse_iterator<IterType> revMaxFwhmIt{maxFwhmIt};
if (revMinFwhmIt == ys.crend() || maxFwhmIt == ys.cend()) {
g_log.warning() << "Couldn't determine fwhm of beam, using position of max "
"value as beam center.\n";
return centreByMax;
}
const double fwhm =
static_cast<double>(std::distance(revMaxFwhmIt, revMinFwhmIt) + 1);
g_log.debug() << "Initial fwhm (full width at half maximum): " << fwhm
<< '\n';
// generate Gaussian
auto func =
API::FunctionFactory::Instance().createFunction("CompositeFunction");
auto sum = boost::dynamic_pointer_cast<API::CompositeFunction>(func);
func = API::FunctionFactory::Instance().createFunction("Gaussian");
auto gaussian = boost::dynamic_pointer_cast<API::IPeakFunction>(func);
gaussian->setHeight(height);
gaussian->setCentre(centreByMax);
gaussian->setFwhm(fwhm);
sum->addFunction(gaussian);
func = API::FunctionFactory::Instance().createFunction("LinearBackground");
func->setParameter("A0", 0.);
func->setParameter("A1", 0.);
sum->addFunction(func);
// call Fit child algorithm
API::IAlgorithm_sptr fit = createChildAlgorithm("Fit");
fit->initialize();
fit->setProperty("Function",
boost::dynamic_pointer_cast<API::IFunction>(sum));
fit->setProperty("InputWorkspace", integralWS);
fit->setProperty("StartX", centreByMax - 3 * fwhm);
fit->setProperty("EndX", centreByMax + 3 * fwhm);
fit->execute();
const std::string fitStatus = fit->getProperty("OutputStatus");
if (fitStatus != "success") {
g_log.warning("Fit not successful, using position of max value.\n");
return centreByMax;
}
const auto centre = gaussian->centre();
g_log.debug() << "Sigma: " << gaussian->fwhm() << '\n';
g_log.debug() << "Estimated peak position: " << centre << '\n';
return centre;
}
/** Calls Gaussian1D as a child algorithm to fit the offset peak in a spectrum
*
* @param wi :: The Workspace Index to fit.
* @param inputW :: Input workspace.
* @param peakPositions :: Peak positions.
* @param fitWindows :: Fit windows.
* @param nparams :: Number of parameters.
* @param minD :: Min distance.
* @param maxD :: Max distance.
* @param peakPosToFit :: Actual peak positions to fit (output).
* @param peakPosFitted :: Actual peak positions fitted (output).
* @param chisq :: chisq.
* @param peakHeights :: vector for fitted heights of peaks
* @param i_highestpeak:: index of the highest peak among all peaks
* @param resolution :: spectrum's resolution delta(d)/d
* @param dev_resolution :: standard deviation resolution
* @return The number of peaks in range
*/
int GetDetOffsetsMultiPeaks::fitSpectra(
const int64_t wi, MatrixWorkspace_sptr inputW,
const std::vector<double> &peakPositions,
const std::vector<double> &fitWindows, size_t &nparams, double &minD,
double &maxD, std::vector<double> &peakPosToFit,
std::vector<double> &peakPosFitted, std::vector<double> &chisq,
std::vector<double> &peakHeights, int &i_highestpeak, double &resolution,
double &dev_resolution) {
// Default overall fit range is the whole spectrum
const MantidVec &X = inputW->readX(wi);
minD = X.front();
maxD = X.back();
// Trim in the edges based on where the data turns off of zero
const MantidVec &Y = inputW->readY(wi);
size_t minDindex = 0;
for (; minDindex < Y.size(); ++minDindex) {
if (Y[minDindex] > 0.) {
minD = X[minDindex];
break;
}
}
if (minD >= maxD) {
// throw if minD >= maxD
std::stringstream ess;
ess << "Stuff went wrong with wkspIndex=" << wi
<< " specIndex=" << inputW->getSpectrum(wi)->getSpectrumNo();
throw std::runtime_error(ess.str());
}
size_t maxDindex = Y.size() - 1;
for (; maxDindex > minDindex; --maxDindex) {
if (Y[maxDindex] > 0.) {
maxD = X[maxDindex];
break;
}
}
std::stringstream dbss;
dbss << "D-RANGE[" << inputW->getSpectrum(wi)->getSpectrumNo()
<< "]: " << minD << " -> " << maxD;
g_log.debug(dbss.str());
// Setup the fit windows
bool useFitWindows = (!fitWindows.empty());
std::vector<double> fitWindowsToUse;
for (int i = 0; i < static_cast<int>(peakPositions.size()); ++i) {
if ((peakPositions[i] > minD) && (peakPositions[i] < maxD)) {
if (m_useFitWindowTable) {
fitWindowsToUse.push_back(std::max(m_vecFitWindow[wi][2 * i], minD));
fitWindowsToUse.push_back(
std::min(m_vecFitWindow[wi][2 * i + 1], maxD));
} else if (useFitWindows) {
fitWindowsToUse.push_back(std::max(fitWindows[2 * i], minD));
fitWindowsToUse.push_back(std::min(fitWindows[2 * i + 1], maxD));
}
peakPosToFit.push_back(peakPositions[i]);
}
}
int numPeaksInRange = static_cast<int>(peakPosToFit.size());
if (numPeaksInRange == 0) {
std::stringstream outss;
outss << "Spectrum " << wi << " has no peak in range (" << minD << ", "
<< maxD << ")";
g_log.information(outss.str());
return 0;
}
// Fit peaks
API::IAlgorithm_sptr findpeaks =
createChildAlgorithm("FindPeaks", -1, -1, false);
findpeaks->setProperty("InputWorkspace", inputW);
findpeaks->setProperty<int>("FWHM", 7);
findpeaks->setProperty<int>("Tolerance", 4);
// FindPeaks will do the checking on the validity of WorkspaceIndex
findpeaks->setProperty("WorkspaceIndex", static_cast<int>(wi));
// Get the specified peak positions, which is optional
findpeaks->setProperty("PeakPositions", peakPosToFit);
if (useFitWindows)
findpeaks->setProperty("FitWindows", fitWindowsToUse);
findpeaks->setProperty<std::string>("PeakFunction", m_peakType);
findpeaks->setProperty<std::string>("BackgroundType", m_backType);
findpeaks->setProperty<bool>("HighBackground",
this->getProperty("HighBackground"));
findpeaks->setProperty<int>("MinGuessedPeakWidth", 4);
findpeaks->setProperty<int>("MaxGuessedPeakWidth", 4);
findpeaks->setProperty<double>("MinimumPeakHeight", m_minPeakHeight);
findpeaks->setProperty("StartFromObservedPeakCentre", true);
findpeaks->executeAsChildAlg();
// Collect fitting resutl of all peaks
ITableWorkspace_sptr peakslist = findpeaks->getProperty("PeaksList");
// use tmpPeakPosToFit to shuffle the vectors
std::vector<double> tmpPeakPosToFit;
generatePeaksList(peakslist, static_cast<int>(wi), peakPosToFit,
tmpPeakPosToFit, peakPosFitted, peakHeights, chisq,
(useFitWindows || m_useFitWindowTable), fitWindowsToUse,
minD, maxD, resolution, dev_resolution);
peakPosToFit = tmpPeakPosToFit;
nparams = peakPosFitted.size();
// Find the highest peak
i_highestpeak = -1;
double maxheight = 0;
for (int i = 0; i < static_cast<int>(peakPosFitted.size()); ++i) {
double tmpheight = peakHeights[i];
if (tmpheight > maxheight) {
maxheight = tmpheight;
i_highestpeak = i;
}
}
return numPeaksInRange;
}
/**
* Creates a managed version of a specified algorithm.
* @param algName :: The name of the algorithm to execute.
* @param version :: The version number (default=-1=highest version).
* @return Pointer to algorithm.
**/
API::IAlgorithm_sptr FrameworkManagerProxy::createUnmanagedAlgorithm(const std::string& algName, const int version)
{
API::IAlgorithm_sptr alg = API::AlgorithmManager::Instance().createUnmanaged(algName, version);
alg->initialize();
return alg;
}
/** Perform SortHKL on the output workspaces
*
* @param ws :: any PeaksWorkspace
* @param runName :: string to put in statistics table
*/
void StatisticsOfPeaksWorkspace::doSortHKL(Mantid::API::Workspace_sptr ws,
std::string runName) {
std::string pointGroup = getPropertyValue("PointGroup");
std::string latticeCentering = getPropertyValue("LatticeCentering");
std::string wkspName = getPropertyValue("OutputWorkspace");
std::string tableName = getPropertyValue("StatisticsTable");
API::IAlgorithm_sptr statsAlg = createChildAlgorithm("SortHKL");
statsAlg->setProperty("InputWorkspace", ws);
statsAlg->setPropertyValue("OutputWorkspace", wkspName);
statsAlg->setPropertyValue("StatisticsTable", tableName);
statsAlg->setProperty("PointGroup", pointGroup);
statsAlg->setProperty("LatticeCentering", latticeCentering);
statsAlg->setProperty("RowName", runName);
if (runName.compare("Overall") != 0)
statsAlg->setProperty("Append", true);
statsAlg->executeAsChildAlg();
PeaksWorkspace_sptr statsWksp = statsAlg->getProperty("OutputWorkspace");
ITableWorkspace_sptr tablews = statsAlg->getProperty("StatisticsTable");
if (runName.compare("Overall") == 0)
setProperty("OutputWorkspace", statsWksp);
setProperty("StatisticsTable", tablews);
}