diff --git a/Framework/Algorithms/inc/MantidAlgorithms/FitPeaks.h b/Framework/Algorithms/inc/MantidAlgorithms/FitPeaks.h
index 7e0bdbe45a8ae83e0b2b80413616f93b567ce948..0aee88baa7b8d64091884b487bc12187fb31e0a8 100644
--- a/Framework/Algorithms/inc/MantidAlgorithms/FitPeaks.h
+++ b/Framework/Algorithms/inc/MantidAlgorithms/FitPeaks.h
@@ -135,7 +135,7 @@ private:
double fitIndividualPeak(size_t wi, API::IAlgorithm_sptr fitter,
const double expected_peak_center,
const std::pair<double, double> &fitwindow,
- const bool observe_peak_width,
+ const bool observe_peak_params,
API::IPeakFunction_sptr peakfunction,
API::IBackgroundFunction_sptr bkgdfunc);
@@ -146,7 +146,7 @@ private:
API::MatrixWorkspace_sptr dataws, size_t wsindex,
double xmin, double xmax,
const double &expected_peak_center,
- bool observe_peak_width, bool estimate_background);
+ bool observe_peak_shape, bool estimate_background);
double fitFunctionMD(API::IFunction_sptr fit_function,
API::MatrixWorkspace_sptr dataws, size_t wsindex,
@@ -158,7 +158,7 @@ private:
const std::pair<double, double> &fit_window,
const size_t &ws_index,
const double &expected_peak_center,
- bool observe_peak_width,
+ bool observe_peak_shape,
API::IPeakFunction_sptr peakfunction,
API::IBackgroundFunction_sptr bkgdfunc);
@@ -198,8 +198,8 @@ private:
API::IBackgroundFunction_sptr bkgdfunction,
bool observe_peak_width);
- bool decideToEstimatePeakWidth(const bool firstPeakInSpectrum,
- API::IPeakFunction_sptr peak_function);
+ bool decideToEstimatePeakParams(const bool firstPeakInSpectrum,
+ API::IPeakFunction_sptr peak_function);
/// observe peak center
int observePeakCenter(const HistogramData::Histogram &histogram,
diff --git a/Framework/Algorithms/src/FitPeaks.cpp b/Framework/Algorithms/src/FitPeaks.cpp
index f12acc80c1d32dd837b039fc9572610823196897..4b591f79a66fd184bc77056100b62fadf5973187 100644
--- a/Framework/Algorithms/src/FitPeaks.cpp
+++ b/Framework/Algorithms/src/FitPeaks.cpp
@@ -46,6 +46,39 @@ using namespace std;
namespace Mantid {
namespace Algorithms {
+namespace {
+namespace PropertyNames {
+const std::string INPUT_WKSP("InputWorkspace");
+const std::string OUTPUT_WKSP("OutputWorkspace");
+const std::string START_WKSP_INDEX("StartWorkspaceIndex");
+const std::string STOP_WKSP_INDEX("StopWorkspaceIndex");
+const std::string PEAK_CENTERS("PeakCenters");
+const std::string PEAK_CENTERS_WKSP("PeakCentersWorkspace");
+const std::string PEAK_FUNC("PeakFunction");
+const std::string BACK_FUNC("BackgroundType");
+const std::string FIT_WINDOW_LIST("FitWindowBoundaryList");
+const std::string FIT_WINDOW_WKSP("FitPeakWindowWorkspace");
+const std::string PEAK_WIDTH_PERCENT("PeakWidthPercent");
+const std::string PEAK_PARAM_NAMES("PeakParameterNames");
+const std::string PEAK_PARAM_VALUES("PeakParameterValues");
+const std::string PEAK_PARAM_TABLE("PeakParameterValueTable");
+const std::string FIT_FROM_RIGHT("FitFromRight");
+const std::string MINIMIZER("Minimizer");
+const std::string COST_FUNC("CostFunction");
+const std::string MAX_FIT_ITER("MaxFitIterations");
+const std::string BACKGROUND_Z_SCORE("FindBackgroundSigma");
+const std::string HIGH_BACKGROUND("HighBackground");
+const std::string POSITION_TOL("PositionTolerance");
+const std::string PEAK_MIN_HEIGHT("MinimumPeakHeight");
+const std::string CONSTRAIN_PEAK_POS("ConstrainPeakPositions");
+const std::string OUTPUT_WKSP_MODEL("FittedPeaksWorkspace");
+const std::string OUTPUT_WKSP_PARAMS("OutputPeakParametersWorkspace");
+const std::string OUTPUT_WKSP_PARAM_ERRS("OutputParameterFitErrorsWorkspace");
+const std::string RAW_PARAMS("RawPeakParameters");
+
+} // namespace PropertyNames
+} // namespace
+
namespace FitPeaksAlgorithm {
//----------------------------------------------------------------------------------------------
@@ -206,10 +239,10 @@ FitPeaks::FitPeaks()
*/
void FitPeaks::init() {
declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "InputWorkspace", "", Direction::Input),
+ PropertyNames::INPUT_WKSP, "", Direction::Input),
"Name of the input workspace for peak fitting.");
declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "OutputWorkspace", "", Direction::Output),
+ PropertyNames::OUTPUT_WKSP, "", Direction::Output),
"Name of the output workspace containing peak centers for "
"fitting offset."
"The output workspace is point data."
@@ -223,135 +256,132 @@ void FitPeaks::init() {
"and -3 for non-converged fitting.");
// properties about fitting range and criteria
- declareProperty("StartWorkspaceIndex", EMPTY_INT(),
+ declareProperty(PropertyNames::START_WKSP_INDEX, EMPTY_INT(),
"Starting workspace index for fit");
- declareProperty("StopWorkspaceIndex", EMPTY_INT(),
+ declareProperty(PropertyNames::STOP_WKSP_INDEX, EMPTY_INT(),
"Last workspace index to fit (which is included)");
// properties about peak positions to fit
- declareProperty(std::make_unique<ArrayProperty<double>>("PeakCenters"),
- "List of peak centers to fit against.");
declareProperty(
- std::make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "PeakCentersWorkspace", "", Direction::Input, PropertyMode::Optional),
- "MatrixWorkspace containing peak centers");
+ std::make_unique<ArrayProperty<double>>(PropertyNames::PEAK_CENTERS),
+ "List of peak centers to fit against.");
+ declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>(
+ PropertyNames::PEAK_CENTERS_WKSP, "", Direction::Input,
+ PropertyMode::Optional),
+ "MatrixWorkspace containing peak centers");
- std::string peakcentergrp("Peak Positions");
- setPropertyGroup("PeakCenters", peakcentergrp);
- setPropertyGroup("PeakCentersWorkspace", peakcentergrp);
+ const std::string peakcentergrp("Peak Positions");
+ setPropertyGroup(PropertyNames::PEAK_CENTERS, peakcentergrp);
+ setPropertyGroup(PropertyNames::PEAK_CENTERS_WKSP, peakcentergrp);
// properties about peak profile
- std::vector<std::string> peakNames =
+ const std::vector<std::string> peakNames =
FunctionFactory::Instance().getFunctionNames<API::IPeakFunction>();
- declareProperty("PeakFunction", "Gaussian",
+ declareProperty(PropertyNames::PEAK_FUNC, "Gaussian",
boost::make_shared<StringListValidator>(peakNames));
- vector<string> bkgdtypes{"Flat", "Linear", "Quadratic"};
- declareProperty("BackgroundType", "Linear",
+ const vector<string> bkgdtypes{"Flat", "Linear", "Quadratic"};
+ declareProperty(PropertyNames::BACK_FUNC, "Linear",
boost::make_shared<StringListValidator>(bkgdtypes),
"Type of Background.");
- std::string funcgroup("Function Types");
- setPropertyGroup("PeakFunction", funcgroup);
- setPropertyGroup("BackgroundType", funcgroup);
+ const std::string funcgroup("Function Types");
+ setPropertyGroup(PropertyNames::PEAK_FUNC, funcgroup);
+ setPropertyGroup(PropertyNames::BACK_FUNC, funcgroup);
// properties about peak range including fitting window and peak width
// (percentage)
declareProperty(
- std::make_unique<ArrayProperty<double>>("FitWindowBoundaryList"),
+ std::make_unique<ArrayProperty<double>>(PropertyNames::FIT_WINDOW_LIST),
"List of left boundaries of the peak fitting window corresponding to "
"PeakCenters.");
declareProperty(std::make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "FitPeakWindowWorkspace", "", Direction::Input,
+ PropertyNames::FIT_WINDOW_WKSP, "", Direction::Input,
PropertyMode::Optional),
"MatrixWorkspace for of peak windows");
auto min = boost::make_shared<BoundedValidator<double>>();
min->setLower(1e-3);
// min->setUpper(1.); TODO make this a limit
- declareProperty("PeakWidthPercent", EMPTY_DBL(), min,
+ declareProperty(PropertyNames::PEAK_WIDTH_PERCENT, EMPTY_DBL(), min,
"The estimated peak width as a "
"percentage of the d-spacing "
"of the center of the peak. Value must be less than 1.");
- std::string fitrangeegrp("Peak Range Setup");
- setPropertyGroup("PeakWidthPercent", fitrangeegrp);
- setPropertyGroup("FitWindowBoundaryList", fitrangeegrp);
- setPropertyGroup("FitPeakWindowWorkspace", fitrangeegrp);
+ const std::string fitrangeegrp("Peak Range Setup");
+ setPropertyGroup(PropertyNames::PEAK_WIDTH_PERCENT, fitrangeegrp);
+ setPropertyGroup(PropertyNames::FIT_WINDOW_LIST, fitrangeegrp);
+ setPropertyGroup(PropertyNames::FIT_WINDOW_WKSP, fitrangeegrp);
// properties about peak parameters' names and value
+ declareProperty(std::make_unique<ArrayProperty<std::string>>(
+ PropertyNames::PEAK_PARAM_NAMES),
+ "List of peak parameters' names");
declareProperty(
- std::make_unique<ArrayProperty<std::string>>("PeakParameterNames"),
- "List of peak parameters' names");
- declareProperty(
- std::make_unique<ArrayProperty<double>>("PeakParameterValues"),
+ std::make_unique<ArrayProperty<double>>(PropertyNames::PEAK_PARAM_VALUES),
"List of peak parameters' value");
declareProperty(std::make_unique<WorkspaceProperty<TableWorkspace>>(
- "PeakParameterValueTable", "", Direction::Input,
+ PropertyNames::PEAK_PARAM_TABLE, "", Direction::Input,
PropertyMode::Optional),
"Name of the an optional workspace, whose each column "
"corresponds to given peak parameter names"
", and each row corresponds to a subset of spectra.");
- std::string startvaluegrp("Starting Parameters Setup");
- setPropertyGroup("PeakParameterNames", startvaluegrp);
- setPropertyGroup("PeakParameterValues", startvaluegrp);
- setPropertyGroup("PeakParameterValueTable", startvaluegrp);
+ const std::string startvaluegrp("Starting Parameters Setup");
+ setPropertyGroup(PropertyNames::PEAK_PARAM_NAMES, startvaluegrp);
+ setPropertyGroup(PropertyNames::PEAK_PARAM_VALUES, startvaluegrp);
+ setPropertyGroup(PropertyNames::PEAK_PARAM_TABLE, startvaluegrp);
// optimization setup
- declareProperty("FitFromRight", true,
+ declareProperty(PropertyNames::FIT_FROM_RIGHT, true,
"Flag for the order to fit peaks. If true, peaks are fitted "
"from rightmost;"
"Otherwise peaks are fitted from leftmost.");
- std::vector<std::string> minimizerOptions =
+ const std::vector<std::string> minimizerOptions =
API::FuncMinimizerFactory::Instance().getKeys();
- declareProperty("Minimizer", "Levenberg-Marquardt",
+ declareProperty(PropertyNames::MINIMIZER, "Levenberg-Marquardt",
Kernel::IValidator_sptr(
new Kernel::StartsWithValidator(minimizerOptions)),
- "Minimizer to use for fitting. Minimizers available are "
- "\"Levenberg-Marquardt\", \"Simplex\","
- "\"Conjugate gradient (Fletcher-Reeves imp.)\", \"Conjugate "
- "gradient (Polak-Ribiere imp.)\", \"BFGS\", and "
- "\"Levenberg-MarquardtMD\"");
-
- std::array<string, 2> costFuncOptions = {{"Least squares", "Rwp"}};
- declareProperty("CostFunction", "Least squares",
+ "Minimizer to use for fitting.");
+
+ const std::array<string, 2> costFuncOptions = {{"Least squares", "Rwp"}};
+ declareProperty(PropertyNames::COST_FUNC, "Least squares",
Kernel::IValidator_sptr(
new Kernel::ListValidator<std::string>(costFuncOptions)),
"Cost functions");
auto min_max_iter = boost::make_shared<BoundedValidator<int>>();
min_max_iter->setLower(49);
- declareProperty("MaxFitIterations", 50, min_max_iter,
+ declareProperty(PropertyNames::MAX_FIT_ITER, 50, min_max_iter,
"Maximum number of function fitting iterations.");
- std::string optimizergrp("Optimization Setup");
- setPropertyGroup("Minimizer", optimizergrp);
- setPropertyGroup("CostFunction", optimizergrp);
+ const std::string optimizergrp("Optimization Setup");
+ setPropertyGroup(PropertyNames::MINIMIZER, optimizergrp);
+ setPropertyGroup(PropertyNames::COST_FUNC, optimizergrp);
// other helping information
declareProperty(
- "FindBackgroundSigma", 1.0,
+ PropertyNames::BACKGROUND_Z_SCORE, 1.0,
"Multiplier of standard deviations of the variance for convergence of "
"peak elimination. Default is 1.0. ");
- declareProperty("HighBackground", true,
+ declareProperty(PropertyNames::HIGH_BACKGROUND, true,
"Flag whether the data has high background comparing to "
"peaks' intensities. "
"For example, vanadium peaks usually have high background.");
declareProperty(
- std::make_unique<ArrayProperty<double>>("PositionTolerance"),
+ std::make_unique<ArrayProperty<double>>(PropertyNames::POSITION_TOL),
"List of tolerance on fitted peak positions against given peak positions."
"If there is only one value given, then ");
- declareProperty("MinimumPeakHeight", 0.,
+ declareProperty(PropertyNames::PEAK_MIN_HEIGHT, 0.,
"Minimum peak height such that all the fitted peaks with "
"height under this value will be excluded.");
declareProperty(
- "ConstrainPeakPositions", true,
+ PropertyNames::CONSTRAIN_PEAK_POS, true,
"If true peak position will be constrained by estimated positions "
"(highest Y value position) and "
"the peak width either estimted by observation or calculate.");
@@ -359,7 +389,7 @@ void FitPeaks::init() {
// additional output for reviewing
declareProperty(
std::make_unique<WorkspaceProperty<MatrixWorkspace>>(
- "FittedPeaksWorkspace", "", Direction::Output,
+ PropertyNames::OUTPUT_WKSP_MODEL, "", Direction::Output,
PropertyMode::Optional),
"Name of the output matrix workspace with fitted peak. "
"This output workspace have the same dimesion as the input workspace."
@@ -368,31 +398,29 @@ void FitPeaks::init() {
declareProperty(
std::make_unique<WorkspaceProperty<API::ITableWorkspace>>(
- "OutputPeakParametersWorkspace", "", Direction::Output),
+ PropertyNames::OUTPUT_WKSP_PARAMS, "", Direction::Output),
"Name of table workspace containing all fitted peak parameters.");
// Optional output table workspace for each individual parameter's fitting
// error
declareProperty(
std::make_unique<WorkspaceProperty<API::ITableWorkspace>>(
- "OutputParameterFitErrorsWorkspace", "", Direction::Output,
+ PropertyNames::OUTPUT_WKSP_PARAM_ERRS, "", Direction::Output,
PropertyMode::Optional),
"Name of workspace containing all fitted peak parameters' fitting error."
"It must be used along with FittedPeaksWorkspace and RawPeakParameters "
"(True)");
- declareProperty("RawPeakParameters", true,
+ declareProperty(PropertyNames::RAW_PARAMS, true,
"false generates table with effective centre/width/height "
"parameters. true generates a table with peak function "
"parameters");
- std::string addoutgrp("Analysis");
- setPropertyGroup("OutputPeakParametersWorkspace", addoutgrp);
- setPropertyGroup("FittedPeaksWorkspace", addoutgrp);
- setPropertyGroup("OutputParameterFitErrorsWorkspace", addoutgrp);
- setPropertyGroup("RawPeakParameters", addoutgrp);
-
- return;
+ const std::string addoutgrp("Analysis");
+ setPropertyGroup(PropertyNames::OUTPUT_WKSP_PARAMS, addoutgrp);
+ setPropertyGroup(PropertyNames::OUTPUT_WKSP_MODEL, addoutgrp);
+ setPropertyGroup(PropertyNames::OUTPUT_WKSP_PARAM_ERRS, addoutgrp);
+ setPropertyGroup(PropertyNames::RAW_PARAMS, addoutgrp);
}
//----------------------------------------------------------------------------------------------
@@ -404,37 +432,39 @@ std::map<std::string, std::string> FitPeaks::validateInputs() {
// check that the peak parameters are in parallel properties
bool haveCommonPeakParameters(false);
std::vector<string> suppliedParameterNames =
- getProperty("PeakParameterNames");
- std::vector<double> peakParamValues = getProperty("PeakParameterValues");
+ getProperty(PropertyNames::PEAK_PARAM_NAMES);
+ std::vector<double> peakParamValues =
+ getProperty(PropertyNames::PEAK_PARAM_VALUES);
if ((!suppliedParameterNames.empty()) || (!peakParamValues.empty())) {
haveCommonPeakParameters = true;
if (suppliedParameterNames.size() != peakParamValues.size()) {
- issues["PeakParameterNames"] =
+ issues[PropertyNames::PEAK_PARAM_NAMES] =
"must have same number of values as PeakParameterValues";
- issues["PeakParameterValues"] =
+ issues[PropertyNames::PEAK_PARAM_VALUES] =
"must have same number of values as PeakParameterNames";
}
}
// get the information out of the table
- std::string partablename = getPropertyValue("PeakParameterValueTable");
+ std::string partablename = getPropertyValue(PropertyNames::PEAK_PARAM_TABLE);
if (!partablename.empty()) {
if (haveCommonPeakParameters) {
const std::string msg = "Parameter value table and initial parameter "
"name/value vectors cannot be given "
"simultanenously.";
- issues["PeakParameterValueTable"] = msg;
- issues["PeakParameterNames"] = msg;
- issues["PeakParameterValues"] = msg;
+ issues[PropertyNames::PEAK_PARAM_TABLE] = msg;
+ issues[PropertyNames::PEAK_PARAM_NAMES] = msg;
+ issues[PropertyNames::PEAK_PARAM_VALUES] = msg;
} else {
- m_profileStartingValueTable = getProperty("PeakParameterValueTable");
+ m_profileStartingValueTable =
+ getProperty(PropertyNames::PEAK_PARAM_TABLE);
suppliedParameterNames = m_profileStartingValueTable->getColumnNames();
}
}
// check that the suggested peak parameter names exist in the peak function
if (!suppliedParameterNames.empty()) {
- std::string peakfunctiontype = getPropertyValue("PeakFunction");
+ std::string peakfunctiontype = getPropertyValue(PropertyNames::PEAK_FUNC);
m_peakFunction = boost::dynamic_pointer_cast<IPeakFunction>(
API::FunctionFactory::Instance().createFunction(peakfunctiontype));
@@ -456,22 +486,22 @@ std::map<std::string, std::string> FitPeaks::validateInputs() {
if (failed) {
std::string msg = "Specified invalid parameter for peak function";
if (haveCommonPeakParameters)
- issues["PeakParameterNames"] = msg;
+ issues[PropertyNames::PEAK_PARAM_NAMES] = msg;
else
- issues["PeakParameterValueTable"] = msg;
+ issues[PropertyNames::PEAK_PARAM_TABLE] = msg;
}
}
// check inputs for uncertainty (fitting error)
const std::string error_table_name =
- getPropertyValue("OutputParameterFitErrorsWorkspace");
+ getPropertyValue(PropertyNames::OUTPUT_WKSP_PARAM_ERRS);
if (!error_table_name.empty()) {
- const bool use_raw_params = getProperty("RawPeakParameters");
+ const bool use_raw_params = getProperty(PropertyNames::RAW_PARAMS);
if (!use_raw_params) {
const std::string msg =
"FitPeaks must output RAW peak parameters if fitting error "
"is chosen to be output";
- issues["RawPeakParameters"] = msg;
+ issues[PropertyNames::RAW_PARAMS] = msg;
}
}
@@ -501,7 +531,7 @@ void FitPeaks::exec() {
//----------------------------------------------------------------------------------------------
void FitPeaks::processInputs() {
// input workspaces
- m_inputMatrixWS = getProperty("InputWorkspace");
+ m_inputMatrixWS = getProperty(PropertyNames::INPUT_WKSP);
if (m_inputMatrixWS->getAxis(0)->unit()->unitID() == "dSpacing")
m_inputIsDSpace = true;
@@ -509,14 +539,14 @@ void FitPeaks::processInputs() {
m_inputIsDSpace = false;
// spectra to fit
- int start_wi = getProperty("StartWorkspaceIndex");
+ int start_wi = getProperty(PropertyNames::START_WKSP_INDEX);
if (isEmpty(start_wi))
m_startWorkspaceIndex = 0;
else
m_startWorkspaceIndex = static_cast<size_t>(start_wi);
// last spectrum's workspace index, which is included
- int stop_wi = getProperty("StopWorkspaceIndex");
+ int stop_wi = getProperty(PropertyNames::STOP_WKSP_INDEX);
if (isEmpty(stop_wi))
m_stopWorkspaceIndex = m_inputMatrixWS->getNumberHistograms() - 1;
else {
@@ -526,11 +556,11 @@ void FitPeaks::processInputs() {
}
// optimizer, cost function and fitting scheme
- m_minimizer = getPropertyValue("Minimizer");
- m_costFunction = getPropertyValue("CostFunction");
- m_fitPeaksFromRight = getProperty("FitFromRight");
- m_constrainPeaksPosition = getProperty("ConstrainPeakPositions");
- m_fitIterations = getProperty("MaxFitIterations");
+ m_minimizer = getPropertyValue(PropertyNames::MINIMIZER);
+ m_costFunction = getPropertyValue(PropertyNames::COST_FUNC);
+ m_fitPeaksFromRight = getProperty(PropertyNames::FIT_FROM_RIGHT);
+ m_constrainPeaksPosition = getProperty(PropertyNames::CONSTRAIN_PEAK_POS);
+ m_fitIterations = getProperty(PropertyNames::MAX_FIT_ITER);
// Peak centers, tolerance and fitting range
processInputPeakCenters();
@@ -538,7 +568,7 @@ void FitPeaks::processInputs() {
if (m_numPeaksToFit == 0)
throw std::runtime_error("number of peaks to fit is zero.");
// about how to estimate the peak width
- m_peakWidthPercentage = getProperty("PeakWidthPercent");
+ m_peakWidthPercentage = getProperty(PropertyNames::PEAK_WIDTH_PERCENT);
if (isEmpty(m_peakWidthPercentage))
m_peakWidthPercentage = -1;
if (m_peakWidthPercentage >= 1.) // TODO
@@ -546,8 +576,8 @@ void FitPeaks::processInputs() {
g_log.debug() << "peak width/value = " << m_peakWidthPercentage << "\n";
// set up background
- m_highBackground = getProperty("HighBackground");
- m_bkgdSimga = getProperty("FindBackgroundSigma");
+ m_highBackground = getProperty(PropertyNames::HIGH_BACKGROUND);
+ m_bkgdSimga = getProperty(PropertyNames::BACKGROUND_Z_SCORE);
// Set up peak and background functions
processInputFunctions();
@@ -574,12 +604,12 @@ void FitPeaks::processInputs() {
*/
void FitPeaks::processInputFunctions() {
// peak functions
- std::string peakfunctiontype = getPropertyValue("PeakFunction");
+ std::string peakfunctiontype = getPropertyValue(PropertyNames::PEAK_FUNC);
m_peakFunction = boost::dynamic_pointer_cast<IPeakFunction>(
API::FunctionFactory::Instance().createFunction(peakfunctiontype));
// background functions
- std::string bkgdfunctiontype = getPropertyValue("BackgroundType");
+ std::string bkgdfunctiontype = getPropertyValue(PropertyNames::BACK_FUNC);
std::string bkgdname;
if (bkgdfunctiontype == "Linear")
bkgdname = "LinearBackground";
@@ -599,18 +629,18 @@ void FitPeaks::processInputFunctions() {
// TODO check that both parameter names and values exist
// input peak parameters
- std::string partablename = getPropertyValue("PeakParameterValueTable");
- m_peakParamNames = getProperty("PeakParameterNames");
+ std::string partablename = getPropertyValue(PropertyNames::PEAK_PARAM_TABLE);
+ m_peakParamNames = getProperty(PropertyNames::PEAK_PARAM_NAMES);
+ m_uniformProfileStartingValue = false;
if (partablename.empty() && (!m_peakParamNames.empty())) {
// use uniform starting value of peak parameters
- m_initParamValues = getProperty("PeakParameterValues");
+ m_initParamValues = getProperty(PropertyNames::PEAK_PARAM_VALUES);
// convert the parameter name in string to parameter name in integer index
convertParametersNameToIndex();
- m_uniformProfileStartingValue = true;
+ // m_uniformProfileStartingValue = true;
} else if ((!partablename.empty()) && m_peakParamNames.empty()) {
// use non-uniform starting value of peak parameters
- m_uniformProfileStartingValue = false;
m_profileStartingValueTable = getProperty(partablename);
} else {
// user specifies nothing
@@ -628,10 +658,10 @@ void FitPeaks::processInputFunctions() {
*/
void FitPeaks::processInputFitRanges() {
// get peak fit window
- std::vector<double> peakwindow = getProperty("FitWindowBoundaryList");
- std::string peakwindowname = getPropertyValue("FitPeakWindowWorkspace");
+ std::vector<double> peakwindow = getProperty(PropertyNames::FIT_WINDOW_LIST);
+ std::string peakwindowname = getPropertyValue(PropertyNames::FIT_WINDOW_WKSP);
API::MatrixWorkspace_const_sptr peakwindowws =
- getProperty("FitPeakWindowWorkspace");
+ getProperty(PropertyNames::FIT_WINDOW_WKSP);
// in most case, calculate window by instrument resolution is False
m_calculateWindowInstrument = false;
@@ -673,7 +703,7 @@ void FitPeaks::processInputFitRanges() {
// END for uniform peak window
} else if (peakwindow.empty() && peakwindowws != nullptr) {
// use matrix workspace for non-uniform peak windows
- m_peakWindowWorkspace = getProperty("FitPeakWindowWorkspace");
+ m_peakWindowWorkspace = getProperty(PropertyNames::FIT_WINDOW_WKSP);
m_uniformPeakWindows = false;
// check size
@@ -758,13 +788,13 @@ void FitPeaks::processInputFitRanges() {
*/
void FitPeaks::processInputPeakCenters() {
// peak centers
- m_peakCenters = getProperty("PeakCenters");
+ m_peakCenters = getProperty(PropertyNames::PEAK_CENTERS);
API::MatrixWorkspace_const_sptr peakcenterws =
- getProperty("PeakCentersWorkspace");
+ getProperty(PropertyNames::PEAK_CENTERS_WKSP);
if (!peakcenterws)
g_log.error("There is no peak center workspace");
- std::string peakpswsname = getPropertyValue("PeakCentersWorkspace");
+ std::string peakpswsname = getPropertyValue(PropertyNames::PEAK_CENTERS_WKSP);
if ((!m_peakCenters.empty()) && peakcenterws == nullptr) {
// peak positions are uniform among all spectra
m_uniformPeakPositions = true;
@@ -773,7 +803,7 @@ void FitPeaks::processInputPeakCenters() {
} else if (m_peakCenters.empty() && peakcenterws != nullptr) {
// peak positions can be different among spectra
m_uniformPeakPositions = false;
- m_peakCenterWorkspace = getProperty("PeakCentersWorkspace");
+ m_peakCenterWorkspace = getProperty(PropertyNames::PEAK_CENTERS_WKSP);
// number of peaks to fit!
m_numPeaksToFit = m_peakCenterWorkspace->x(0).size();
g_log.warning() << "Input peak center workspace: "
@@ -831,7 +861,7 @@ void FitPeaks::processInputPeakTolerance() {
"ProcessInputPeakCenters()");
// peak tolerance
- m_peakPosTolerances = getProperty("PositionTolerance");
+ m_peakPosTolerances = getProperty(PropertyNames::POSITION_TOL);
if (m_peakPosTolerances.empty()) {
// case 2, 3, 4
@@ -852,7 +882,7 @@ void FitPeaks::processInputPeakTolerance() {
}
// minimum peak height: set default to zero
- m_minPeakHeight = getProperty("MinimumPeakHeight");
+ m_minPeakHeight = getProperty(PropertyNames::PEAK_MIN_HEIGHT);
if (isEmpty(m_minPeakHeight) || m_minPeakHeight < 0.)
m_minPeakHeight = 0.;
@@ -879,9 +909,9 @@ void FitPeaks::convertParametersNameToIndex() {
// map the input parameter names to parameter indexes
for (const auto ¶mName : m_peakParamNames) {
auto locator = parname_index_map.find(paramName);
- if (locator != parname_index_map.end())
+ if (locator != parname_index_map.end()) {
m_initParamIndexes.emplace_back(locator->second);
- else {
+ } else {
// a parameter name that is not defined in the peak profile function. An
// out-of-range index is thus set to this
g_log.warning() << "Given peak parameter " << paramName
@@ -1057,10 +1087,10 @@ void FitPeaks::fitSpectrumPeaks(
std::pair<double, double> peak_window_i =
getPeakFitWindow(wi, peak_index);
- bool observe_peak_width_flag =
- decideToEstimatePeakWidth(!foundAnyPeak, peakfunction);
+ bool observe_peak_params =
+ decideToEstimatePeakParams(!foundAnyPeak, peakfunction);
- if (observe_peak_width_flag &&
+ if (observe_peak_params &&
m_peakWidthEstimateApproach == EstimatePeakWidth::NoEstimation) {
g_log.warning(
"Peak width can be estimated as ZERO. The result can be wrong");
@@ -1068,9 +1098,9 @@ void FitPeaks::fitSpectrumPeaks(
// do fitting with peak and background function (no analysis at this
// point)
- cost = fitIndividualPeak(wi, peak_fitter, expected_peak_pos,
- peak_window_i, observe_peak_width_flag,
- peakfunction, bkgdfunction);
+ cost =
+ fitIndividualPeak(wi, peak_fitter, expected_peak_pos, peak_window_i,
+ observe_peak_params, peakfunction, bkgdfunction);
if (cost < 1e7) { // assume it worked and save out the result
foundAnyPeak = true;
for (size_t i = 0; i < lastGoodPeakParameters.size(); ++i)
@@ -1092,16 +1122,20 @@ void FitPeaks::fitSpectrumPeaks(
}
//----------------------------------------------------------------------------------------------
-/** Decide whether to estimate peak width. If not, then set the width related
- * peak parameters from user specified starting value
+/** Decide whether to estimate peak parameters. If not, then set the peak
+ * parameters from
+ * user specified starting value
* @param firstPeakInSpectrum :: flag whether the given peak is the first peak
* in the spectrum
* @param peak_function :: peak function to set parameter values to
* @return :: flag whether the peak width shall be observed
*/
-bool FitPeaks::decideToEstimatePeakWidth(
+bool FitPeaks::decideToEstimatePeakParams(
const bool firstPeakInSpectrum, API::IPeakFunction_sptr peak_function) {
- bool observe_peak_width(false);
+ // should observe the peak width if the user didn't supply all of the peak
+ // function parameters
+ bool observe_peak_shape(m_initParamIndexes.size() !=
+ peak_function->nParams());
if (!m_initParamIndexes.empty()) {
// user specifies starting value of peak parameters
@@ -1109,8 +1143,8 @@ bool FitPeaks::decideToEstimatePeakWidth(
// set the parameter values in a vector and loop over it
// first peak. using the user-specified value
for (size_t i = 0; i < m_initParamIndexes.size(); ++i) {
- size_t param_index = m_initParamIndexes[i];
- double param_value = m_initParamValues[i];
+ const size_t param_index = m_initParamIndexes[i];
+ const double param_value = m_initParamValues[i];
peak_function->setParameter(param_index, param_value);
}
} else {
@@ -1119,10 +1153,10 @@ bool FitPeaks::decideToEstimatePeakWidth(
}
} else {
// no previously defined peak parameters: observation is thus required
- observe_peak_width = true;
+ observe_peak_shape = true;
}
- return observe_peak_width;
+ return observe_peak_shape;
}
//----------------------------------------------------------------------------------------------
@@ -1388,8 +1422,6 @@ void FitPeaks::estimateBackground(const Histogram &histogram,
bkgd_function->setParameter(1, bkgd_a1);
if (bkgd_function->nParams() > 2)
bkgd_function->setParameter(2, 0.);
-
- return;
}
//----------------------------------------------------------------------------------------------
@@ -1627,7 +1659,7 @@ bool FitPeaks::fitBackground(const size_t &ws_index,
double FitPeaks::fitIndividualPeak(size_t wi, API::IAlgorithm_sptr fitter,
const double expected_peak_center,
const std::pair<double, double> &fitwindow,
- const bool observe_peak_width,
+ const bool observe_peak_params,
API::IPeakFunction_sptr peakfunction,
API::IBackgroundFunction_sptr bkgdfunc) {
double cost(DBL_MAX);
@@ -1641,12 +1673,12 @@ double FitPeaks::fitIndividualPeak(size_t wi, API::IAlgorithm_sptr fitter,
// fit peak with high background!
cost =
fitFunctionHighBackground(fitter, fitwindow, wi, expected_peak_center,
- observe_peak_width, peakfunction, bkgdfunc);
+ observe_peak_params, peakfunction, bkgdfunc);
} else {
// fit peak and background
cost = fitFunctionSD(fitter, peakfunction, bkgdfunc, m_inputMatrixWS, wi,
fitwindow.first, fitwindow.second,
- expected_peak_center, observe_peak_width, true);
+ expected_peak_center, observe_peak_params, true);
}
return cost;
@@ -1664,7 +1696,7 @@ double FitPeaks::fitFunctionSD(IAlgorithm_sptr fit,
API::MatrixWorkspace_sptr dataws, size_t wsindex,
double xmin, double xmax,
const double &expected_peak_center,
- bool observe_peak_width,
+ bool observe_peak_shape,
bool estimate_background) {
std::stringstream errorid;
errorid << "(WorkspaceIndex=" << wsindex
@@ -1683,7 +1715,7 @@ double FitPeaks::fitFunctionSD(IAlgorithm_sptr fit,
// Estimate peak profile parameter
peak_function->setCentre(expected_peak_center); // set expected position first
int result = estimatePeakParameters(histogram, peak_window, peak_function,
- bkgd_function, observe_peak_width);
+ bkgd_function, observe_peak_shape);
if (result != GOOD) {
peak_function->setCentre(expected_peak_center);
if (result == NOSIGNAL || result == LOWPEAK) {
@@ -1824,7 +1856,7 @@ double FitPeaks::fitFunctionMD(API::IFunction_sptr fit_function,
double FitPeaks::fitFunctionHighBackground(
IAlgorithm_sptr fit, const std::pair<double, double> &fit_window,
const size_t &ws_index, const double &expected_peak_center,
- bool observe_peak_width, API::IPeakFunction_sptr peakfunction,
+ bool observe_peak_shape, API::IPeakFunction_sptr peakfunction,
API::IBackgroundFunction_sptr bkgdfunc) {
// high background to reduce
API::IBackgroundFunction_sptr high_bkgd_function(nullptr);
@@ -1851,7 +1883,7 @@ double FitPeaks::fitFunctionHighBackground(
// Fit peak with background
double cost = fitFunctionSD(fit, peakfunction, bkgdfunc, reduced_bkgd_ws, 0,
vec_x.front(), vec_x.back(), expected_peak_center,
- observe_peak_width, false);
+ observe_peak_shape, false);
// add the reduced background back
bkgdfunc->setParameter(0, bkgdfunc->getParameter(0) +
@@ -1957,7 +1989,7 @@ void FitPeaks::setupParameterTableWorkspace(
*/
void FitPeaks::generateFittedParametersValueWorkspaces() {
// peak parameter workspace
- m_rawPeaksTable = getProperty("RawPeakParameters");
+ m_rawPeaksTable = getProperty(PropertyNames::RAW_PARAMS);
// create parameters
// peak
@@ -1982,7 +2014,7 @@ void FitPeaks::generateFittedParametersValueWorkspaces() {
// for error workspace
std::string fiterror_table_name =
- getPropertyValue("OutputParameterFitErrorsWorkspace");
+ getPropertyValue(PropertyNames::OUTPUT_WKSP_PARAM_ERRS);
// do nothing if user does not specifiy
if (fiterror_table_name.empty()) {
// not specified
@@ -2002,7 +2034,7 @@ void FitPeaks::generateFittedParametersValueWorkspaces() {
*/
void FitPeaks::generateCalculatedPeaksWS() {
// matrix workspace contained calculated peaks from fitting
- std::string fit_ws_name = getPropertyValue("FittedPeaksWorkspace");
+ std::string fit_ws_name = getPropertyValue(PropertyNames::OUTPUT_WKSP_MODEL);
if (fit_ws_name.size() == 0) {
// skip if user does not specify
m_fittedPeakWS = nullptr;
@@ -2018,12 +2050,12 @@ void FitPeaks::generateCalculatedPeaksWS() {
void FitPeaks::processOutputs(
std::vector<boost::shared_ptr<FitPeaksAlgorithm::PeakFitResult>>
fit_result_vec) {
- setProperty("OutputWorkspace", m_outputPeakPositionWorkspace);
- setProperty("OutputPeakParametersWorkspace", m_fittedParamTable);
+ setProperty(PropertyNames::OUTPUT_WKSP, m_outputPeakPositionWorkspace);
+ setProperty(PropertyNames::OUTPUT_WKSP_PARAMS, m_fittedParamTable);
if (m_fitErrorTable) {
g_log.warning("Output error table workspace");
- setProperty("OutputParameterFitErrorsWorkspace", m_fitErrorTable);
+ setProperty(PropertyNames::OUTPUT_WKSP_PARAM_ERRS, m_fitErrorTable);
} else {
g_log.warning("No error table output");
}
@@ -2032,7 +2064,7 @@ void FitPeaks::processOutputs(
if (m_fittedPeakWS && m_fittedParamTable) {
g_log.debug("about to calcualte fitted peaks");
calculateFittedPeaks(fit_result_vec);
- setProperty("FittedPeaksWorkspace", m_fittedPeakWS);
+ setProperty(PropertyNames::OUTPUT_WKSP_MODEL, m_fittedPeakWS);
}
}
diff --git a/Framework/Algorithms/test/FitPeaksTest.h b/Framework/Algorithms/test/FitPeaksTest.h
index 695e671dd6f47765886a7484571d2f18a6c975d9..eeb228f05a39b8595c4924a8fb8c0125c53c41b1 100644
--- a/Framework/Algorithms/test/FitPeaksTest.h
+++ b/Framework/Algorithms/test/FitPeaksTest.h
@@ -407,6 +407,61 @@ public:
return;
}
+ void Ntest_singlePeakMultiSpectraPseudoVoigt() {
+ // Generate input workspace
+ // std::string input_ws_name = loadVulcanHighAngleData();
+
+ // Generate peak and background parameters
+ std::vector<string> peakparnames{"Mixing"};
+ std::vector<double> peakparvalues{0.5};
+
+ // Initialize FitPeak
+ FitPeaks fitpeaks;
+
+ fitpeaks.initialize();
+ TS_ASSERT(fitpeaks.isInitialized());
+
+ TS_ASSERT_THROWS_NOTHING(
+ fitpeaks.setProperty("InputWorkspace", m_inputWorkspaceName));
+ TS_ASSERT_THROWS_NOTHING(
+ fitpeaks.setProperty("StartWorkspaceIndex", 19990));
+ TS_ASSERT_THROWS_NOTHING(fitpeaks.setProperty("StopWorkspaceIndex", 20000));
+ TS_ASSERT_THROWS_NOTHING(
+ fitpeaks.setProperty("PeakFunction", "PseudoVoigt"));
+ TS_ASSERT_THROWS_NOTHING(fitpeaks.setProperty("PeakCenters", "1.0758"));
+ TS_ASSERT_THROWS_NOTHING(
+ fitpeaks.setProperty("FitWindowLeftBoundary", "1.05"));
+ TS_ASSERT_THROWS_NOTHING(
+ fitpeaks.setProperty("FitWindowRightBoundary", "1.15"));
+ TS_ASSERT_THROWS_NOTHING(fitpeaks.setProperty("PeakRanges", "0.02"));
+ TS_ASSERT_THROWS_NOTHING(
+ fitpeaks.setProperty("PeakParameterValues", peakparvalues));
+
+ fitpeaks.setProperty("OutputWorkspace", "PeakPositionsWS3");
+ fitpeaks.setProperty("OutputPeakParametersWorkspace", "PeakParametersWS3");
+ fitpeaks.setProperty("FittedPeaksWorkspace", "FittedPeaksWS3");
+
+ fitpeaks.execute();
+ TS_ASSERT(fitpeaks.isExecuted());
+
+ // check output workspaces
+ TS_ASSERT(
+ API::AnalysisDataService::Instance().doesExist("PeakPositionsWS3"));
+ TS_ASSERT(
+ API::AnalysisDataService::Instance().doesExist("PeakParametersWS3"));
+ TS_ASSERT(API::AnalysisDataService::Instance().doesExist("FittedPeaksWS3"));
+
+ // about the parameters
+ API::MatrixWorkspace_sptr peak_params_ws =
+ boost::dynamic_pointer_cast<API::MatrixWorkspace>(
+ AnalysisDataService::Instance().retrieve("PeakParametersWS3"));
+ TS_ASSERT(peak_params_ws);
+ TS_ASSERT_EQUALS(peak_params_ws->getNumberHistograms(), 5);
+ TS_ASSERT_EQUALS(peak_params_ws->histogram(0).x().size(), 10);
+
+ return;
+ }
+
//----------------------------------------------------------------------------------------------
/** Test on init and setup
*/
diff --git a/Framework/DataHandling/src/LoadEventNexus.cpp b/Framework/DataHandling/src/LoadEventNexus.cpp
index 2ad6acd86acc42414ad9797234bb0055ff134058..f1859a515063ebbc29e7c2dd511c61c4598af6f1 100644
--- a/Framework/DataHandling/src/LoadEventNexus.cpp
+++ b/Framework/DataHandling/src/LoadEventNexus.cpp
@@ -291,6 +291,11 @@ void LoadEventNexus::init() {
"LoadNexusInstrumentXML", true, Direction::Input),
"Reads the embedded Instrument XML from the NeXus file "
"(optional, default True). ");
+
+ declareProperty("NumberOfBins", 500, mustBePositive,
+ "The number of bins intially defined. Use Rebin to change "
+ "the binning later. If there is no data loaded, or you "
+ "select meta data only you will only get 1 bin.");
}
//----------------------------------------------------------------------------------------------
@@ -1071,9 +1076,17 @@ void LoadEventNexus::loadEvents(API::Progress *const prog,
}
}
// Now, create a default X-vector for histogramming, with just 2 bins.
- if (eventsLoaded > 0)
- m_ws->setAllX(HistogramData::BinEdges{shortest_tof - 1, longest_tof + 1});
- else
+ if (eventsLoaded > 0) {
+ int nBins = getProperty("NumberOfBins");
+ auto binEdgesVec = std::vector<double>(nBins + 1);
+ binEdgesVec[0] = shortest_tof - 1;
+ binEdgesVec[nBins] = longest_tof + 1;
+ double binStep = (binEdgesVec[nBins] - binEdgesVec[0]) / nBins;
+ for (int binIndex = 1; binIndex < nBins; binIndex++) {
+ binEdgesVec[binIndex] = binEdgesVec[0] + (binStep * binIndex);
+ }
+ m_ws->setAllX(HistogramData::BinEdges{binEdgesVec});
+ } else
m_ws->setAllX(HistogramData::BinEdges{0.0, 1.0});
// if there is time_of_flight load it
diff --git a/Framework/DataHandling/test/LoadEventNexusTest.h b/Framework/DataHandling/test/LoadEventNexusTest.h
index 250c2b7c65b5631daf1a6e1878f42079927c615f..e46d7c81b4d53df1cfafb7800fb68e29c1422b3c 100644
--- a/Framework/DataHandling/test/LoadEventNexusTest.h
+++ b/Framework/DataHandling/test/LoadEventNexusTest.h
@@ -242,6 +242,24 @@ public:
}
}
+ void test_NumberOfBins() {
+ const std::string file = "SANS2D00022048.nxs";
+ int nBins = 273;
+ LoadEventNexus alg;
+ alg.setChild(true);
+ alg.setRethrows(true);
+ alg.initialize();
+ alg.setProperty("Filename", file);
+ alg.setProperty("OutputWorkspace", "dummy_for_child");
+ alg.setProperty("NumberOfBins", nBins);
+ alg.execute();
+ Workspace_sptr ws = alg.getProperty("OutputWorkspace");
+ auto eventWS = boost::dynamic_pointer_cast<EventWorkspace>(ws);
+ TS_ASSERT(eventWS);
+
+ TS_ASSERT_EQUALS(eventWS->blocksize(), nBins);
+ }
+
void test_load_event_nexus_sans2d_ess() {
const std::string file = "SANS2D_ESS_example.nxs";
LoadEventNexus alg;
@@ -250,6 +268,7 @@ public:
alg.initialize();
alg.setProperty("Filename", file);
alg.setProperty("OutputWorkspace", "dummy_for_child");
+ alg.setProperty("NumberOfBins", 1);
alg.execute();
Workspace_sptr ws = alg.getProperty("OutputWorkspace");
auto eventWS = boost::dynamic_pointer_cast<EventWorkspace>(ws);
@@ -318,6 +337,7 @@ public:
ld.setPropertyValue("Filename", "CNCS_7860_event.nxs");
ld.setPropertyValue("OutputWorkspace", outws_name);
ld.setPropertyValue("Precount", "0");
+ ld.setProperty("NumberOfBins", 1);
ld.setProperty<bool>("LoadLogs", false); // Time-saver
ld.execute();
TS_ASSERT(ld.isExecuted());
@@ -360,6 +380,7 @@ public:
ld2.setPropertyValue("OutputWorkspace", outws_name2);
ld2.setPropertyValue("Precount", "1");
ld2.setProperty<bool>("LoadLogs", false); // Time-saver
+ ld2.setProperty("NumberOfBins", 1);
ld2.execute();
TS_ASSERT(ld2.isExecuted());
diff --git a/Framework/DataHandling/test/SaveDaveGrpTest.h b/Framework/DataHandling/test/SaveDaveGrpTest.h
index f7ffe047034d8009a06c7e8bb412c60594312022..8c702bf26a7dc0eca642dc19896fafba49052979 100644
--- a/Framework/DataHandling/test/SaveDaveGrpTest.h
+++ b/Framework/DataHandling/test/SaveDaveGrpTest.h
@@ -210,6 +210,7 @@ public:
ld.setPropertyValue("Filename", "CNCS_7860_event.nxs");
ld.setPropertyValue("OutputWorkspace", outws);
ld.setPropertyValue("Precount", "0");
+ ld.setProperty("NumberOfBins", 1);
ld.execute();
TS_ASSERT(ld.isExecuted());
AnalysisDataServiceImpl &dataStore = AnalysisDataService::Instance();
diff --git a/Framework/PythonInterface/mantid/api/_workspaceops.py b/Framework/PythonInterface/mantid/api/_workspaceops.py
index f64a2b6802256a77e28e190222d7f0cb488f33c3..3e7c45f39041d4e0991ba616a6feaf62ad94cbb5 100644
--- a/Framework/PythonInterface/mantid/api/_workspaceops.py
+++ b/Framework/PythonInterface/mantid/api/_workspaceops.py
@@ -254,7 +254,8 @@ def attach_func_as_method(name, func_obj, self_param_name, workspace_types=None)
signature = func_obj.__signature__.replace(parameters=func_parameters)
else:
signature = ['self']
- signature = tuple(signature.extend(get_function_code(func_obj).co_varnames))
+ signature.extend(get_function_code(func_obj).co_varnames)
+ signature = tuple(signature)
customise_func(_method_impl, func_obj.__name__,
signature, func_obj.__doc__)
diff --git a/Framework/PythonInterface/plugins/algorithms/EnggCalibrateFull.py b/Framework/PythonInterface/plugins/algorithms/EnggCalibrateFull.py
index 67fe24bd20e64d19c334131666009107de02dd25..ca2a484fe99f53029046d69d61966ec22221e604 100644
--- a/Framework/PythonInterface/plugins/algorithms/EnggCalibrateFull.py
+++ b/Framework/PythonInterface/plugins/algorithms/EnggCalibrateFull.py
@@ -9,6 +9,7 @@ import math
from mantid.kernel import *
from mantid.api import *
+from mantid.simpleapi import SaveAscii
import EnggUtils
@@ -316,9 +317,10 @@ class EnggCalibrateFull(PythonAlgorithm):
return json.dumps(all_dict)
- def _output_det_pos_file(self, filename, tbl):
+ @staticmethod
+ def _output_det_pos_file(filename, tbl):
"""
- Writes a text (csv) file with the detector positions information that also goes into the
+ Writes a text (TSV) file with the detector positions information that also goes into the
output DetectorPostions table workspace.
@param filename :: name of the file to write. If it is empty nothing is saved/written.
@@ -327,22 +329,8 @@ class EnggCalibrateFull(PythonAlgorithm):
if not filename:
return
- if 9 > tbl.columnCount():
- return
-
- self.log().information("Saving detector positions in file: %s" % filename)
- with open(filename, "w") as f:
- f.write('# detector ID, old position (x), old position (y), old position (z), '
- 'calibrated position (x), calibrated position (y), calibrated position (z), '
- 'calib. L2, calib. 2\\theta, calib. \\phi, delta L2 (calibrated - old), difc, zero\n')
- for r in range(0, tbl.rowCount()):
- f.write('{0:d},'.format(tbl.cell(r, 0)))
- f.write('{0:.7f},{1:.7f},{2:.7f},{3:.7f},{4:.7f},{5:.7f},'.
- format(tbl.cell(r, 1).getX(), tbl.cell(r, 1).getY(), tbl.cell(r, 1).getZ(),
- tbl.cell(r, 2).getX(), tbl.cell(r, 2).getY(), tbl.cell(r, 2).getZ()))
- f.write('{0:.10f},{1:.10f},{2:.10f},{3:.10f},{4:.10f},{5:.10f}\n'.
- format(tbl.cell(r, 3), tbl.cell(r, 4), tbl.cell(r, 5),
- tbl.cell(r, 6), tbl.cell(r, 7), tbl.cell(r, 8)))
+ if filename.strip():
+ SaveAscii(InputWorkspace=tbl, Filename=filename, WriteXError=True, WriteSpectrumID=False, Separator="Tab")
def _get_calibrated_det_pos(self, new_difc, det, ws):
"""
diff --git a/Testing/SystemTests/tests/analysis/ReflectometryFloodCorrection.py b/Testing/SystemTests/tests/analysis/ReflectometryFloodCorrection.py
index 60620d7b3bcaf0db03b5123446ea749637221105..20ad5bd709bcceec5809ae71edda14c3d9fcf37c 100644
--- a/Testing/SystemTests/tests/analysis/ReflectometryFloodCorrection.py
+++ b/Testing/SystemTests/tests/analysis/ReflectometryFloodCorrection.py
@@ -73,7 +73,7 @@ class ReflectometryApplyFloodWorkspace(systemtesting.MantidSystemTest):
def runTest(self):
flood = CreateFloodWorkspace('OFFSPEC00035946.nxs', StartSpectrum=250, EndSpectrum=600,
ExcludeSpectra=[260, 261, 262, 516, 517, 518], OutputWorkspace='flood')
- data = Load('OFFSPEC00044998.nxs')
+ data = Load('OFFSPEC00044998.nxs', NumberOfBins=1)
ApplyFloodWorkspace(InputWorkspace=data, FloodWorkspace=flood, OutputWorkspace=self.out_ws_name)
def validate(self):
diff --git a/buildconfig/Jenkins/buildscript b/buildconfig/Jenkins/buildscript
index 26dbb26050040ea7a0982c2832669f954a8b6c05..79fc022df5c76ccf34933012a805006909722c5c 100755
--- a/buildconfig/Jenkins/buildscript
+++ b/buildconfig/Jenkins/buildscript
@@ -246,10 +246,18 @@ if [ -z "$MANTID_DATA_STORE" ]; then
fi
###############################################################################
-# Check if this is a Python 3 build and set CMake arguments.
+# Check if this is a Python 2 build and set CMake arguments.
###############################################################################
-DIST_FLAGS="${DIST_FLAGS} -DWITH_PYTHON3=ON"
-PARAVIEW_DIR="${PARAVIEW_DIR}-python3"
+PY2_BUILD=false
+PY3_BUILD=false
+if [[ ${JOB_NAME} == *python2* ]]; then
+ PY2_BUILD=true
+ DIST_FLAGS="${DIST_FLAGS} -DWITH_PYTHON3=OFF"
+else
+ PY3_BUILD=true
+ DIST_FLAGS="${DIST_FLAGS} -DWITH_PYTHON3=ON"
+ PARAVIEW_DIR="${PARAVIEW_DIR}-python3"
+fi
###############################################################################
# Packaging options
@@ -274,7 +282,7 @@ if [[ ${DO_BUILD_PKG} == true ]]; then
fi
if [[ ${JOB_NAME} == *release* ]] && [[ -z "${PACKAGE_SUFFIX}" ]]; then
- # Traditional install path for python 2 release build
+ # Traditional install path for release build
PACKAGINGVARS="${PACKAGINGVARS} -DCMAKE_INSTALL_PREFIX=/opt/Mantid -DCPACK_PACKAGE_SUFFIX="
else
# everything else uses lower-case values
diff --git a/docs/source/algorithms/ConvertToMatrixWorkspace-v1.rst b/docs/source/algorithms/ConvertToMatrixWorkspace-v1.rst
index a95ed0e480b1b7b07dc34d1d6baa0c6bbc4e8797..54ebf29438e2a466646ee06d4432a4ad1d40b448 100644
--- a/docs/source/algorithms/ConvertToMatrixWorkspace-v1.rst
+++ b/docs/source/algorithms/ConvertToMatrixWorkspace-v1.rst
@@ -30,8 +30,8 @@ Usage
.. testoutput:: ConvertToMatrixWorkspaceSimpleExample
- 51200 1
- 51200 1
+ 51200 500
+ 51200 500
**Example - Conversion when blocksize > 1**
diff --git a/docs/source/algorithms/EnggCalibrateFull-v1.rst b/docs/source/algorithms/EnggCalibrateFull-v1.rst
index ee01751308a8004a02cb8f6c263a5ae161984768..4c0da245c686a3debc66c508f0d79c243a1f4bd6 100644
--- a/docs/source/algorithms/EnggCalibrateFull-v1.rst
+++ b/docs/source/algorithms/EnggCalibrateFull-v1.rst
@@ -145,14 +145,16 @@ Output:
print("Got details on the peaks fitted for {0:d} detector(s)".format(peaks_info.rowCount()))
print("Was the file created? {}".format(os.path.exists(pos_filename)))
with open(pos_filename) as csvf:
- reader = csv.reader(csvf, dialect='excel')
+ reader = csv.reader(csvf, dialect='excel', delimiter="\t")
+ next(reader) # Skip the two metadata lines
next(reader)
calibOK = True
for i,row in enumerate(reader):
cal_pos = pos_table.column(2)[i]
- calibOK = calibOK and (abs(float(row[4]) - cal_pos.getX()) < 1e-6) and\
- (abs(float(row[5]) - cal_pos.getY()) < 1e-6) and\
- (abs(float(row[6]) - cal_pos.getZ()) < 1e-6)
+ detector_pos_list = row[2].strip("[]").split(',')
+ calibOK = calibOK and (float(detector_pos_list[0]) - cal_pos.getX()) < 1e-6 and\
+ (float(detector_pos_list[1]) - cal_pos.getY()) < 1e-6 and\
+ (float(detector_pos_list[2]) - cal_pos.getZ()) < 1e-6
if not calibOK: break
print("Does the calibration file have the expected values? {}".format(calibOK))
diff --git a/docs/source/algorithms/FitPeaks-v1.rst b/docs/source/algorithms/FitPeaks-v1.rst
index 544c7f8ba92e2df26fb61cb4ff017690b4a430ae..ae65477d55f18c823d90479fdc9aa4dfaa84b316 100644
--- a/docs/source/algorithms/FitPeaks-v1.rst
+++ b/docs/source/algorithms/FitPeaks-v1.rst
@@ -74,7 +74,19 @@ will be estimated via *observation*.
Estimation of values of peak profiles
#####################################
-Peak intensity and peak center are estimated by observing the maximum value within peak fit window.
+Peak height, center, and FWHM and peak center are estimated by
+observing the maximum value within peak fit window and calculating the
+first two moments.
+
+When using peak profiles that do not have a one-to-one mapping between
+effective and raw parameters, you may need to supply starting
+information for more of the parameters. This can be done by specifying
+``PeakParameterNames`` and ``PeakParameterValues`` for some or all of
+the parameters (e.g. ``Mixing`` for a :ref:`func-PseudoVoigt`) which
+will be used for the first peak fit in each spectrum. To supply *all*
+parameters, ``PeakParameterNames`` and ``PeakParameterValueTable`` can
+be used. **WARNING** Partially specifying peak parameters such as
+height and position will be overwritten by observed values.
Subalgorithms used
##################
@@ -284,21 +296,21 @@ It is a :py:obj:`MatrixWorkspace <mantid.api.MatrixWorkspace>` containing the pe
OutputPeakParametersWorkspace
=============================
-It is an output :py:obj:`MatrixWorkspace <mantid.api.ITableWorkspace>` containing function parameters' fitted values
-for all peaks that are specified to fit.
+It is an output :py:obj:`MatrixWorkspace <mantid.api.ITableWorkspace>` containing function parameters' fitted values
+for all peaks that are specified to fit.
The order of the peaks will be exactly the sequence of peaks as the order of the given positions of peaks.
-If user specifies a subset of spectra to fit, this TableWorksapce will only contain function
+If user specifies a subset of spectra to fit, this TableWorksapce will only contain function
parameters' value that corresponds to the spectra that are fitted.
OutputParameterFitErrorsWorkspace
=================================
-It is an optional output :py:obj:`MatrixWorkspace <mantid.api.ITableWorkspace>` containing function parameters' fitting error,
+It is an optional output :py:obj:`MatrixWorkspace <mantid.api.ITableWorkspace>` containing function parameters' fitting error,
i.e., uncertainties, for all peaks that are specified to fit.
The order of the peaks will be exactly the sequence of peaks as the order of the given positions of peaks.
-If user specifies a subset of spectra to fit, this TableWorksapce will only contain function
+If user specifies a subset of spectra to fit, this TableWorksapce will only contain function
parameters' uncertainties that corresponds to the spectra that are fitted.
It has one less column than OutputPeakParametersWorkspace, which is chi2.
@@ -306,7 +318,7 @@ It has one less column than OutputPeakParametersWorkspace, which is chi2.
FittedPeaksWorkspace
====================
-It is an optional output :py:obj:`MatrixWorkspace <mantid.api.MatrixWorkspace>` containing the peaks
+It is an optional output :py:obj:`MatrixWorkspace <mantid.api.MatrixWorkspace>` containing the peaks
calculated from fitting result.
diff --git a/docs/source/algorithms/LoadEventNexus-v1.rst b/docs/source/algorithms/LoadEventNexus-v1.rst
index a7f7079810a41647a453f242135d006df53a1c4c..8e000b2fb4ffa593297622206277cac556f7c39e 100644
--- a/docs/source/algorithms/LoadEventNexus-v1.rst
+++ b/docs/source/algorithms/LoadEventNexus-v1.rst
@@ -10,9 +10,9 @@ Description
-----------
The LoadEventNeXus algorithm loads data from an EventNexus file into an
-:ref:`EventWorkspace <EventWorkspace>`. The default histogram bin
-boundaries consist of a single bin able to hold all events (in all
-pixels), and will have their :ref:`units <Unit Factory>` set to time-of-flight.
+:ref:`EventWorkspace <EventWorkspace>`. The histogram bin
+boundaries depend on the setting of NumberOfBins, which by default will be the whole range of time of flight able to hold all events (in all
+pixels) split into NumberOfBins linear bins, and will have their :ref:`units <Unit Factory>` set to time-of-flight.
Since it is an :ref:`EventWorkspace <EventWorkspace>`, it can be rebinned
to finer bins with no loss of data.
diff --git a/docs/source/release/v4.3.0/diffraction.rst b/docs/source/release/v4.3.0/diffraction.rst
index 0eeb61a680d69c0a26522ff247aa86bd5f125beb..aaf0cf743f26d9a2cd3548458aa2a3466eb08d82 100644
--- a/docs/source/release/v4.3.0/diffraction.rst
+++ b/docs/source/release/v4.3.0/diffraction.rst
@@ -27,6 +27,9 @@ Powder Diffraction
Engineering Diffraction
-----------------------
+- :ref:`EnggCalibrateFull <algm-EnggCalibrateFull-v1>` now uses the new :ref:`SaveAscii <algm-SaveAscii-v2>` to save its output files as TSVs, allowing them to be loaded back into mantid.
+- :ref:`FitPeaks <algm-FitPeaks-v1>` allows for specifying some of the peak parameters (e.g. only ``Mixing`` for :ref:`func-PseudoVoigt`) and observing the other parameters. The new functionality allows for more automated execution for peak functions other than :ref:`func-Gaussian`.
+
Single Crystal Diffraction
--------------------------
diff --git a/docs/source/release/v4.3.0/framework.rst b/docs/source/release/v4.3.0/framework.rst
index 3192872c2305f966dc83fa21306db18a0ace60f2..83ada63127e2571dec6dbdc3d26896e5a8741f66 100644
--- a/docs/source/release/v4.3.0/framework.rst
+++ b/docs/source/release/v4.3.0/framework.rst
@@ -31,6 +31,7 @@ Algorithms
Improvements
############
+- :ref:`LoadEventNexus <algm-LoadEventNexus>` Now has a new propery NumberOfBins to select how many linear bins to intially apply to the data. This allows event data to be plotted immediately without having to :ref:`Rebin <algm-Rebin>` it first. This is a change from before where event data was initally loaded with a single bin, now by default it will be split into 500 linear bins.
- :ref:`SaveAscii <algm-SaveAscii>` can now save table workspaces, and :ref:`LoadAscii <algm-LoadAscii>` can load them again.
- :ref:`TotScatCalculateSelfScattering <algm-TotScatCalculateSelfScattering>` will calculate a normalized self scattering correction for foccues total scattering data.
- :ref:`MatchAndMergeWorkspaces <algm-MatchAndMergeWorkspaces>` will merge workspaces in a workspace group withing weighting from a set of limits for each workspace and using `MatchSpectra <algm-MatchSpectra>`.
diff --git a/docs/source/release/v4.3.0/mantidworkbench.rst b/docs/source/release/v4.3.0/mantidworkbench.rst
index 0f24d6eec3f4f4aef4f88be54740827e128f66ce..d32213ee50481cf5be2cefc91e9aecccf75bfb33 100644
--- a/docs/source/release/v4.3.0/mantidworkbench.rst
+++ b/docs/source/release/v4.3.0/mantidworkbench.rst
@@ -28,6 +28,7 @@ Improvements
- Normalization options have been added to 2d plots and sliceviewer.
- The images tab in figure options no longer forces the max value to be greater than the min value.
- All the relevant settings from manitdplot have been added to workbench
+- Double clicking on a workspace that only has a single bin of data (for example from a constant wavelength source) will now plot that bin, also for single bin workspaces a plot bin option has been added to the right click plot menu of the workspace.
Bugfixes
diff --git a/qt/applications/workbench/workbench/plugins/test/test_workspacewidget.py b/qt/applications/workbench/workbench/plugins/test/test_workspacewidget.py
index 3d033e6c0ea2657135cd1275a90b57108bd24c53..53bfb9f90e7b079490f6f7cedeed92df5a64d8e4 100644
--- a/qt/applications/workbench/workbench/plugins/test/test_workspacewidget.py
+++ b/qt/applications/workbench/workbench/plugins/test/test_workspacewidget.py
@@ -21,6 +21,7 @@ from mantidqt.utils.qt.testing import start_qapplication
from mantidqt.utils.qt.testing.qt_widget_finder import QtWidgetFinder
from qtpy.QtWidgets import QMainWindow, QApplication
from workbench.plugins.workspacewidget import WorkspaceWidget
+from mantid.plots.utility import MantidAxType
ALGORITHM_HISTORY_WINDOW_TYPE = "AlgorithmHistoryWindow"
ALGORITHM_HISTORY_WINDOW = "mantidqt.widgets.workspacewidget." \
@@ -28,7 +29,6 @@ ALGORITHM_HISTORY_WINDOW = "mantidqt.widgets.workspacewidget." \
MATRIXWORKSPACE_DISPLAY = "mantidqt.widgets.workspacedisplay.matrix." \
"presenter.MatrixWorkspaceDisplay"
MATRIXWORKSPACE_DISPLAY_TYPE = "StatusBarView"
-
app = QApplication([])
@@ -66,6 +66,21 @@ class WorkspaceWidgetTest(unittest.TestCase, QtWidgetFinder):
self.ws_widget._do_show_detectors([self.ws_names[0]])
self.assert_widget_type_exists(MATRIXWORKSPACE_DISPLAY_TYPE)
+ @mock.patch('workbench.plugins.workspacewidget.plot', autospec=True)
+ def test_plot_with_plot_bin(self,mock_plot):
+ self.ws_widget._do_plot_bin([self.ws_names[0]], False, False)
+ mock_plot.assert_called_once_with(mock.ANY,errors=False, overplot=False, wksp_indices=[0],
+ plot_kwargs={'axis': MantidAxType.BIN})
+
+ @mock.patch('workbench.plugins.workspacewidget.plot_from_names', autospec=True)
+ def test_plot_with_plot_spectrum(self,mock_plot_from_names):
+ self.ws_widget._do_plot_spectrum([self.ws_names[0]], False, False)
+ mock_plot_from_names.assert_called_once_with([self.ws_names[0]], False, False)
+
+ @mock.patch('workbench.plugins.workspacewidget.pcolormesh', autospec=True)
+ def test_plot_with_plot_colorfill(self,mock_plot_colorfill):
+ self.ws_widget._do_plot_colorfill([self.ws_names[0]])
+ mock_plot_colorfill.assert_called_once_with(mock.ANY)
if __name__ == '__main__':
unittest.main()
diff --git a/qt/applications/workbench/workbench/plugins/workspacewidget.py b/qt/applications/workbench/workbench/plugins/workspacewidget.py
index 7160a9c282b0ff3b7322b2092e9518c97eecb846..67a398ad1a5acfff35d6d06bd13a4c73f1d23d23 100644
--- a/qt/applications/workbench/workbench/plugins/workspacewidget.py
+++ b/qt/applications/workbench/workbench/plugins/workspacewidget.py
@@ -15,6 +15,7 @@ from qtpy.QtWidgets import QApplication, QMessageBox, QVBoxLayout
from mantid.api import AnalysisDataService, WorkspaceGroup
from mantid.kernel import logger
from mantidqt.plotting.functions import can_overplot, pcolormesh, plot, plot_from_names
+from mantid.plots.utility import MantidAxType
from mantid.simpleapi import CreateDetectorTable
from mantidqt.utils.asynchronous import BlockingAsyncTaskWithCallback
from mantidqt.widgets.instrumentview.presenter import InstrumentViewPresenter
@@ -44,6 +45,8 @@ class WorkspaceWidget(PluginWidget):
# behaviour
self.workspacewidget.plotSpectrumClicked.connect(partial(self._do_plot_spectrum,
errors=False, overplot=False))
+ self.workspacewidget.plotBinClicked.connect(partial(self._do_plot_bin,
+ errors=False, overplot=False))
self.workspacewidget.overplotSpectrumClicked.connect(partial(self._do_plot_spectrum,
errors=False, overplot=True))
self.workspacewidget.plotSpectrumWithErrorsClicked.connect(partial(self._do_plot_spectrum,
@@ -93,6 +96,24 @@ class WorkspaceWidget(PluginWidget):
plot_from_names(names, errors, overplot)
+ def _do_plot_bin(self, names, errors, overplot):
+ """
+ Plot a single bin from the selected workspaces
+
+ :param names: A list of workspace names
+ :param errors: If true then error bars will be plotted on the points
+ :param overplot: If true then the add to the current figure if one
+ exists and it is a compatible figure
+ """
+ if overplot:
+ compatible, error_msg = can_overplot()
+ if not compatible:
+ QMessageBox.warning(self, "", error_msg)
+ return
+ plot_kwargs = {"axis": MantidAxType.BIN}
+ plot(self._ads.retrieveWorkspaces(names, unrollGroups=True), errors=errors,
+ overplot=overplot,wksp_indices=[0], plot_kwargs=plot_kwargs)
+
def _do_plot_colorfill(self, names):
"""
Plot a colorfill from the selected workspaces
@@ -210,10 +231,12 @@ class WorkspaceWidget(PluginWidget):
TableWorkspaceDisplay.supports(ws)
self._do_show_data([name])
except ValueError:
- if ws.blocksize() > 1:
- plot_from_names([name], errors=False, overplot=False, show_colorfill_btn=True)
+ if ws.blocksize() == 1:
+ #this is just single bin data, it makes more sense to plot the bin
+ plot_kwargs = {"axis": MantidAxType.BIN}
+ plot([ws],errors=False, overplot=False, wksp_indices=[0], plot_kwargs=plot_kwargs)
else:
- self._do_show_data([name])
+ plot_from_names([name], errors=False, overplot=False, show_colorfill_btn=True)
def refresh_workspaces(self):
self.workspacewidget.refreshWorkspaces()
diff --git a/qt/widgets/common/inc/MantidQtWidgets/Common/WorkspacePresenter/WorkspaceTreeWidgetSimple.h b/qt/widgets/common/inc/MantidQtWidgets/Common/WorkspacePresenter/WorkspaceTreeWidgetSimple.h
index 6b29c9ad8acbff94dc4fa76fc222cce981914bb4..5405833a05a6c5d6f2c12bb92b384ea2a9b221d4 100644
--- a/qt/widgets/common/inc/MantidQtWidgets/Common/WorkspacePresenter/WorkspaceTreeWidgetSimple.h
+++ b/qt/widgets/common/inc/MantidQtWidgets/Common/WorkspacePresenter/WorkspaceTreeWidgetSimple.h
@@ -43,6 +43,7 @@ public:
signals:
void plotSpectrumClicked(const QStringList &workspaceNames);
+ void plotBinClicked(const QStringList &workspaceNames);
void overplotSpectrumClicked(const QStringList &workspaceNames);
void plotSpectrumWithErrorsClicked(const QStringList &workspaceNames);
void overplotSpectrumWithErrorsClicked(const QStringList &workspaceNames);
@@ -59,6 +60,7 @@ signals:
private slots:
void onPlotSpectrumClicked();
+ void onPlotBinClicked();
void onOverplotSpectrumClicked();
void onPlotSpectrumWithErrorsClicked();
void onOverplotSpectrumWithErrorsClicked();
@@ -71,10 +73,10 @@ private slots:
void onShowDetectorsClicked();
private:
- QAction *m_plotSpectrum, *m_overplotSpectrum, *m_plotSpectrumWithErrs,
- *m_overplotSpectrumWithErrs, *m_plotColorfill, *m_sampleLogs,
- *m_sliceViewer, *m_showInstrument, *m_showData, *m_showAlgorithmHistory,
- *m_showDetectors;
+ QAction *m_plotSpectrum, *m_plotBin, *m_overplotSpectrum,
+ *m_plotSpectrumWithErrs, *m_overplotSpectrumWithErrs, *m_plotColorfill,
+ *m_sampleLogs, *m_sliceViewer, *m_showInstrument, *m_showData,
+ *m_showAlgorithmHistory, *m_showDetectors;
};
} // namespace MantidWidgets
} // namespace MantidQt
diff --git a/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp b/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp
index 8e89e4734ea7d21a9ceac5a00a356dcdfac0d5b3..78d821f470be74094fbbaafdaeb086221b911aa3 100644
--- a/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp
+++ b/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp
@@ -31,6 +31,7 @@ WorkspaceTreeWidgetSimple::WorkspaceTreeWidgetSimple(bool viewOnly,
QWidget *parent)
: WorkspaceTreeWidget(new MantidTreeModel(), viewOnly, parent),
m_plotSpectrum(new QAction("Spectrum...", this)),
+ m_plotBin(new QAction("Bin", this)),
m_overplotSpectrum(new QAction("Overplot spectrum...", this)),
m_plotSpectrumWithErrs(new QAction("Spectrum with errors...", this)),
m_overplotSpectrumWithErrs(
@@ -50,6 +51,7 @@ WorkspaceTreeWidgetSimple::WorkspaceTreeWidgetSimple(bool viewOnly,
connect(m_plotSpectrum, SIGNAL(triggered()), this,
SLOT(onPlotSpectrumClicked()));
+ connect(m_plotBin, SIGNAL(triggered()), this, SLOT(onPlotBinClicked()));
connect(m_overplotSpectrum, SIGNAL(triggered()), this,
SLOT(onOverplotSpectrumClicked()));
connect(m_plotSpectrumWithErrs, SIGNAL(triggered()), this,
@@ -103,10 +105,6 @@ void WorkspaceTreeWidgetSimple::popupContextMenu() {
if (auto matrixWS =
boost::dynamic_pointer_cast<MatrixWorkspace>(workspace)) {
QMenu *plotSubMenu(new QMenu("Plot", menu));
- plotSubMenu->addAction(m_plotSpectrum);
- plotSubMenu->addAction(m_overplotSpectrum);
- plotSubMenu->addAction(m_plotSpectrumWithErrs);
- plotSubMenu->addAction(m_overplotSpectrumWithErrs);
// Don't plot 1D spectra if only one X value
bool multipleBins = false;
@@ -121,9 +119,14 @@ void WorkspaceTreeWidgetSimple::popupContextMenu() {
}
}
}
- // disable the actions created so far if only one bin
- for (auto action : plotSubMenu->actions()) {
- action->setEnabled(multipleBins);
+
+ if (multipleBins) {
+ plotSubMenu->addAction(m_plotSpectrum);
+ plotSubMenu->addAction(m_overplotSpectrum);
+ plotSubMenu->addAction(m_plotSpectrumWithErrs);
+ plotSubMenu->addAction(m_overplotSpectrumWithErrs);
+ } else {
+ plotSubMenu->addAction(m_plotBin);
}
plotSubMenu->addSeparator();
@@ -170,6 +173,10 @@ void WorkspaceTreeWidgetSimple::onPlotSpectrumClicked() {
emit plotSpectrumClicked(getSelectedWorkspaceNamesAsQList());
}
+void WorkspaceTreeWidgetSimple::onPlotBinClicked() {
+ emit plotBinClicked(getSelectedWorkspaceNamesAsQList());
+}
+
void WorkspaceTreeWidgetSimple::onOverplotSpectrumClicked() {
emit overplotSpectrumClicked(getSelectedWorkspaceNamesAsQList());
}
diff --git a/scripts/Engineering/gui/engineering_diffraction/settings/settings_presenter.py b/scripts/Engineering/gui/engineering_diffraction/settings/settings_presenter.py
index 3767e462ccf1f7b08ce43edff8f75c96f2a18936..eaab52bbb7dd024acab3c85deadd8433a7fe70be 100644
--- a/scripts/Engineering/gui/engineering_diffraction/settings/settings_presenter.py
+++ b/scripts/Engineering/gui/engineering_diffraction/settings/settings_presenter.py
@@ -57,6 +57,11 @@ class SettingsPresenter(object):
self.view.set_save_location(self.settings["save_location"])
self.view.set_full_calibration(self.settings["full_calibration"])
self.view.set_van_recalc(self.settings["recalc_vanadium"])
+ self._find_files()
+
+ def _find_files(self):
+ self.view.find_full_calibration()
+ self.view.find_save()
def _save_settings_to_file(self):
if self._validate_settings(self.settings):
diff --git a/scripts/Engineering/gui/engineering_diffraction/settings/settings_view.py b/scripts/Engineering/gui/engineering_diffraction/settings/settings_view.py
index 3d94d776b522c8d6aa5b6f5fa2ae3128932bb901..4d5cd69ba3d9162f1add75084049b372e5089263 100644
--- a/scripts/Engineering/gui/engineering_diffraction/settings/settings_view.py
+++ b/scripts/Engineering/gui/engineering_diffraction/settings/settings_view.py
@@ -25,9 +25,6 @@ class SettingsView(QtWidgets.QDialog, Ui_settings):
self.finder_fullCalib.setLabelText("Full Calibration")
self.finder_fullCalib.isForRunFiles(False)
- # TODO: Once it becomes possible to load the .csv containing the full calibration into mantid,
- # this can be used. Until then, this option is hidden from the user.
- self.finder_fullCalib.hide()
# ===============
# Slot Connectors
@@ -67,3 +64,13 @@ class SettingsView(QtWidgets.QDialog, Ui_settings):
def set_van_recalc(self, checked):
self.check_vanRecalc.setChecked(checked)
+
+ # =================
+ # Force Actions
+ # =================
+
+ def find_full_calibration(self):
+ self.finder_fullCalib.findFiles(True)
+
+ def find_save(self):
+ self.finder_save.findFiles(True)
diff --git a/scripts/Engineering/gui/engineering_diffraction/settings/test/test_settings_presenter.py b/scripts/Engineering/gui/engineering_diffraction/settings/test/test_settings_presenter.py
index f08c8d6a901214837dc9c98dbc964b76997075ba..06a59e2d27f8f756d79c3ba78318b2203ff54c75 100644
--- a/scripts/Engineering/gui/engineering_diffraction/settings/test/test_settings_presenter.py
+++ b/scripts/Engineering/gui/engineering_diffraction/settings/test/test_settings_presenter.py
@@ -41,6 +41,18 @@ class SettingsPresenterTest(unittest.TestCase):
self.assertEqual(self.view.set_full_calibration.call_count, 1)
self.assertEqual(self.view.set_van_recalc.call_count, 1)
+ def test_file_searched_on_opening(self):
+ self.model.get_settings_dict.return_value = {
+ "save_location": "result",
+ "full_calibration": "value",
+ "recalc_vanadium": False
+ }
+
+ self.presenter.load_existing_settings()
+
+ self.assertEqual(1, self.view.find_full_calibration.call_count)
+ self.assertEqual(1, self.view.find_save.call_count)
+
def test_load_invalid_settings(self):
self.model.get_settings_dict.return_value = {
"foo": "dud",
diff --git a/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/model.py b/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/model.py
index fd3ee96f23bc94fcc8b596fb9a2f81e6013ee224..929639cbfd3c800f16f48966ff466ea2abaaff9f 100644
--- a/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/model.py
+++ b/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/model.py
@@ -14,7 +14,7 @@ import matplotlib.pyplot as plt
from mantid.api import AnalysisDataService as Ads
from mantid.kernel import logger
from mantid.simpleapi import EnggCalibrate, DeleteWorkspace, CloneWorkspace, \
- CreateWorkspace, AppendSpectra, CreateEmptyTableWorkspace
+ CreateWorkspace, AppendSpectra, CreateEmptyTableWorkspace, LoadAscii
from mantidqt.plotting.functions import plot
from Engineering.EnggUtils import write_ENGINX_GSAS_iparam_file
from Engineering.gui.engineering_diffraction.tabs.common import vanadium_corrections
@@ -55,7 +55,7 @@ class CalibrationModel(object):
full_calib_path = get_setting(path_handling.INTERFACES_SETTINGS_GROUP,
path_handling.ENGINEERING_PREFIX, "full_calibration")
if full_calib_path is not None and path.exists(full_calib_path):
- full_calib = path_handling.load_workspace(full_calib_path)
+ full_calib = LoadAscii(full_calib_path, OutputWorkspace="det_pos", Separator="Tab")
output = self.run_calibration(sample_workspace,
van_integration,
van_curves,
diff --git a/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/test/test_calib_model.py b/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/test/test_calib_model.py
index 87fc73d965c4855f9b774b8054fe612be9894c54..d82d2152b9328233ededb0a9bc406d8769cd27d7 100644
--- a/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/test/test_calib_model.py
+++ b/scripts/Engineering/gui/engineering_diffraction/tabs/calibration/test/test_calib_model.py
@@ -58,22 +58,24 @@ class CalibrationModelTest(unittest.TestCase):
@patch(file_path + '.get_setting')
@patch(class_path + '.update_calibration_params_table')
@patch(class_path + '.create_output_files')
+ @patch(file_path + '.LoadAscii')
@patch(file_path + ".path_handling.load_workspace")
@patch(class_path + '.run_calibration')
@patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
- def test_having_full_calib_set_uses_file(self, van_corr, calibrate_alg, load_workspace,
+ def test_having_full_calib_set_uses_file(self, van_corr, calibrate_alg, load_workspace, load_ascii,
output_files, update_table, setting, path):
path.return_value = True
setting.return_value = "mocked/out/path"
van_corr.return_value = ("mocked_integration", "mocked_curves")
load_workspace.return_value = "mocked_workspace"
+ load_ascii.return_value = "mocked_det_pos"
self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, False, "ENGINX")
calibrate_alg.assert_called_with("mocked_workspace",
"mocked_integration",
"mocked_curves",
None,
None,
- full_calib_ws="mocked_workspace")
+ full_calib_ws="mocked_det_pos")
@patch(class_path + '.update_calibration_params_table')
@patch(class_path + '.create_output_files')
diff --git a/scripts/Engineering/gui/engineering_diffraction/tabs/focus/model.py b/scripts/Engineering/gui/engineering_diffraction/tabs/focus/model.py
index d4cd2e5f713959ab55c51151c63c049c16522bfd..2c246c1b8e16ee39ee502331796876c1a501228f 100644
--- a/scripts/Engineering/gui/engineering_diffraction/tabs/focus/model.py
+++ b/scripts/Engineering/gui/engineering_diffraction/tabs/focus/model.py
@@ -13,7 +13,8 @@ import matplotlib.pyplot as plt
from Engineering.gui.engineering_diffraction.tabs.common import vanadium_corrections, path_handling
from Engineering.gui.engineering_diffraction.settings.settings_helper import get_setting
-from mantid.simpleapi import EnggFocus, logger, AnalysisDataService as Ads, SaveNexus, SaveGSS, SaveFocusedXYE
+from mantid.simpleapi import EnggFocus, logger, AnalysisDataService as Ads, SaveNexus, SaveGSS, SaveFocusedXYE, \
+ LoadAscii
SAMPLE_RUN_WORKSPACE_NAME = "engggui_focusing_input_ws"
FOCUSED_OUTPUT_WORKSPACE_NAME = "engggui_focusing_output_ws_bank_"
@@ -39,7 +40,7 @@ class FocusModel(object):
full_calib_path = get_setting(path_handling.INTERFACES_SETTINGS_GROUP,
path_handling.ENGINEERING_PREFIX, "full_calibration")
if full_calib_path is not None and path.exists(full_calib_path):
- full_calib_workspace = path_handling.load_workspace(full_calib_path)
+ full_calib_workspace = LoadAscii(full_calib_path, OutputWorkspace="det_pos", Separator="Tab")
else:
full_calib_workspace = None
for name in banks: