//----------------------------------------------------------------------------------------------
/// @copydoc Mantid::API::Algorithm::init()
void LoadPreNexus::init()
{
// runfile to read in
declareProperty(new FileProperty(RUNINFO_PARAM, "", FileProperty::Load, "_runinfo.xml"),
"The name of the runinfo file to read, including its full or relative path.");
// copied (by hand) from LoadEventPreNexus2
declareProperty(new FileProperty(MAP_PARAM, "", FileProperty::OptionalLoad, ".dat"),
"File containing the pixel mapping (DAS pixels to pixel IDs) file (typically INSTRUMENT_TS_YYYY_MM_DD.dat). The filename will be found automatically if not specified.");
auto mustBePositive = boost::make_shared<BoundedValidator<int> >();
mustBePositive->setLower(1);
declareProperty("ChunkNumber", EMPTY_INT(), mustBePositive,
"If loading the file by sections ('chunks'), this is the section number of this execution of the algorithm.");
declareProperty("TotalChunks", EMPTY_INT(), mustBePositive,
"If loading the file by sections ('chunks'), this is the total number of sections.");
// TotalChunks is only meaningful if ChunkNumber is set
// Would be nice to be able to restrict ChunkNumber to be <= TotalChunks at validation
setPropertySettings("TotalChunks", new VisibleWhenProperty("ChunkNumber", IS_NOT_DEFAULT));
std::vector<std::string> propOptions;
propOptions.push_back("Auto");
propOptions.push_back("Serial");
propOptions.push_back("Parallel");
declareProperty("UseParallelProcessing", "Auto", boost::make_shared<StringListValidator>(propOptions),
"Use multiple cores for loading the data?\n"
" Auto: Use serial loading for small data sets, parallel for large data sets.\n"
" Serial: Use a single core.\n"
" Parallel: Use all available cores.");
declareProperty(new PropertyWithValue<bool>("LoadMonitors", true, Direction::Input),
"Load the monitors from the file.");
declareProperty(new WorkspaceProperty<>("OutputWorkspace","",Direction::Output), "An output workspace.");
}
void NLPlayRangeWidget::updateRangeFromSynthesizer(){
// Block signals here so that changing control
// values don't rebound and set the synthesizer.
blockSignals(true);
int firstFrame = _synthesizer->firstFrame();
int lastFrame = _synthesizer->lastFrame();
if(lastFrame < firstFrame){
std::cerr<<"WARNING! NLPlayRangeWidget.cpp: first frame exceeds last frame.\n";
std::cerr<<"Setting last frame = first frame.\n";
lastFrame = firstFrame;
}
setLower(firstFrame);
setUpper(lastFrame);
if (firstFrame != _startFrameBox->value()){
if (firstFrame >= _lower){
_startFrameBox->setValue(firstFrame);
}
}
if (lastFrame != _endFrameBox->value()){
if (lastFrame <= _upper){
_endFrameBox->setValue(lastFrame);
}
}
_curFrameBox->setValue(_synthesizer->getCurrentPreviewFrame());
blockSignals(false);
}
//-----------------------------------------------------------------------
void FilterByTime2::init()
{
std::string commonHelp("\nYou can only specify the relative or absolute start/stop times, not both.");
declareProperty(
new WorkspaceProperty<DataObjects::EventWorkspace>("InputWorkspace","",Direction::Input),
"An input event workspace" );
declareProperty(
new WorkspaceProperty<DataObjects::EventWorkspace>("OutputWorkspace","",Direction::Output),
"The name to use for the output workspace" );
auto min = boost::make_shared<BoundedValidator<double> >();
min->setLower(0.0);
declareProperty("StartTime", 0.0, min,
"The start time, in seconds, since the start of the run. Events before this time are filtered out. \nThe time of the first pulse (i.e. the first entry in the ProtonCharge sample log) is used as the zero. " + commonHelp);
declareProperty("StopTime", 0.0,
"The stop time, in seconds, since the start of the run. Events at or after this time are filtered out. \nThe time of the first pulse (i.e. the first entry in the ProtonCharge sample log) is used as the zero. " + commonHelp);
std::string absoluteHelp("Specify date and UTC time in ISO8601 format, e.g. 2010-09-14T04:20:12." + commonHelp);
declareProperty("AbsoluteStartTime", "",
"Absolute start time; events before this time are filtered out. " + absoluteHelp );
declareProperty("AbsoluteStopTime", "",
"Absolute stop time; events at of after this time are filtered out. " + absoluteHelp );
}
/** Initialize the algorithm's properties.
*/
void ReflectometrySumInQ::init() {
auto inputWSValidator = boost::make_shared<Kernel::CompositeValidator>();
inputWSValidator->add<API::WorkspaceUnitValidator>("Wavelength");
inputWSValidator->add<API::InstrumentValidator>();
auto mandatoryNonnegative = boost::make_shared<Kernel::CompositeValidator>();
mandatoryNonnegative->add<Kernel::MandatoryValidator<double>>();
auto nonnegative = boost::make_shared<Kernel::BoundedValidator<double>>();
nonnegative->setLower(0.);
mandatoryNonnegative->add(nonnegative);
declareWorkspaceInputProperties<API::MatrixWorkspace,
API::IndexType::SpectrumNum |
API::IndexType::WorkspaceIndex>(
Prop::INPUT_WS, "A workspace in X units of wavelength to be summed.",
inputWSValidator);
declareProperty(
Kernel::make_unique<API::WorkspaceProperty<API::MatrixWorkspace>>(
Prop::OUTPUT_WS, "", Kernel::Direction::Output),
"A single histogram workspace containing the result of summation in Q.");
declareProperty(
Prop::BEAM_CENTRE, EMPTY_DBL(), mandatoryNonnegative,
"Fractional workspace index of the specular reflection centre.");
declareProperty(Prop::IS_FLAT_SAMPLE, true,
"If true, the summation is handled as the standard divergent "
"beam case, otherwise as the non-flat sample case.");
declareProperty(Prop::PARTIAL_BINS, false,
"If true, use the full projected wavelength range possibly "
"including partially filled bins.");
}
/** Add Box-controller-specific properties to this algorithm
*
* @param SplitInto :: default parameter value
* @param SplitThreshold :: default parameter value
* @param MaxRecursionDepth :: default parameter value
*/
void BoxControllerSettingsAlgorithm::initBoxControllerProps(
const std::string &SplitInto, int SplitThreshold, int MaxRecursionDepth) {
auto mustBePositive = boost::make_shared<BoundedValidator<int>>();
mustBePositive->setLower(0);
auto mustBeMoreThen1 = boost::make_shared<BoundedValidator<int>>();
mustBeMoreThen1->setLower(1);
// Split up comma-separated properties
std::vector<int> value;
typedef Poco::StringTokenizer tokenizer;
tokenizer values(SplitInto, ",",
tokenizer::TOK_IGNORE_EMPTY | tokenizer::TOK_TRIM);
value.clear();
value.reserve(values.count());
for (tokenizer::Iterator it = values.begin(); it != values.end(); ++it)
value.push_back(boost::lexical_cast<int>(*it));
declareProperty(
new ArrayProperty<int>("SplitInto", value),
"A comma separated list of into how many sub-grid elements each "
"dimension should split; "
"or just one to split into the same number for all dimensions. Default " +
SplitInto + ".");
declareProperty(
new PropertyWithValue<int>("SplitThreshold", SplitThreshold,
mustBePositive),
"How many events in a box before it should be split. Default " +
Strings::toString(SplitThreshold) + ".");
declareProperty(new PropertyWithValue<int>(
"MaxRecursionDepth", MaxRecursionDepth, mustBeMoreThen1),
"How many levels of box splitting recursion are allowed. "
"The smallest box will have each side length :math:`l = "
"(extents) / (SplitInto^{MaxRecursionDepth}).` "
"Default " +
Strings::toString(MaxRecursionDepth) + ".");
std::string grp = getBoxSettingsGroupName();
setPropertyGroup("SplitInto", grp);
setPropertyGroup("SplitThreshold", grp);
setPropertyGroup("MaxRecursionDepth", grp);
}
static void onRsnSetInfo( HWND hwnd, const RS_INFO *pInfo ) {
setLower ( hwnd, pInfo->_lower );
setUpper ( hwnd, pInfo->_upper );
setSaveStart2 ( hwnd, pInfo->_lower );
setSaveEnd2 ( hwnd, pInfo->_upper );
setStart ( hwnd, pInfo->_start );
setEnd ( hwnd, pInfo->_end );
setMinRange ( hwnd, pInfo->_minRange );
setGranularity( hwnd, pInfo->_granularity );
invalidateRect( hwnd );
invalidateCursor();
}
//--------------------------------------------------------------------------
// Private methods
//--------------------------------------------------------------------------
/// Initialisation method.
void LoadAscii::init() {
const std::vector<std::string> extensions{".dat", ".txt", ".csv", ""};
declareProperty(Kernel::make_unique<FileProperty>(
"Filename", "", FileProperty::Load, extensions),
"The name of the text file to read, including its full or "
"relative path. The file extension must be .txt, .dat, or "
".csv");
declareProperty(Kernel::make_unique<WorkspaceProperty<Workspace>>(
"OutputWorkspace", "", Direction::Output),
"The name of the workspace that will be created, filled with "
"the read-in data and stored in the [[Analysis Data "
"Service]].");
std::string spacers[6][6] = {{"Automatic", ",\t:; "},
{"CSV", ","},
{"Tab", "\t"},
{"Space", " "},
{"Colon", ":"},
{"SemiColon", ";"}};
// For the ListValidator
std::vector<std::string> sepOptions;
for (size_t i = 0; i < 5; ++i) {
std::string option = spacers[i][0];
m_separatorIndex.insert(
std::pair<std::string, std::string>(option, spacers[i][1]));
sepOptions.push_back(option);
}
declareProperty(
"Separator", "Automatic",
boost::make_shared<StringListValidator>(sepOptions),
"The separator between data columns in the data file. The possible "
"values are \"CSV\", \"Tab\", "
"\"Space\", \"SemiColon\", or \"Colon\" (default: Automatic selection).");
std::vector<std::string> units = UnitFactory::Instance().getKeys();
units.insert(units.begin(), "Dimensionless");
declareProperty("Unit", "Energy",
boost::make_shared<StringListValidator>(units),
"The unit to assign to the X axis (anything known to the "
"[[Unit Factory]] or \"Dimensionless\")");
auto mustBePosInt = boost::make_shared<BoundedValidator<int>>();
mustBePosInt->setLower(0);
declareProperty(
"SkipNumLines", EMPTY_INT(), mustBePosInt,
"If given, skip this number of lines at the start of the file.");
}
/** Initialisation method
*/
void Fit1D::init() {
declareProperty(new WorkspaceProperty<MatrixWorkspace>("InputWorkspace", "",
Direction::Input),
"Name of the input Workspace");
auto mustBePositive = boost::make_shared<BoundedValidator<int>>();
mustBePositive->setLower(0);
declareProperty("WorkspaceIndex", 0, mustBePositive,
"The Workspace to fit, uses the workspace numbering of the "
"spectra (default 0)");
declareProperty("StartX", EMPTY_DBL(), "A value of x in, or on the low x "
"boundary of, the first bin to "
"include in\n"
"the fit (default lowest value of x)");
declareProperty("EndX", EMPTY_DBL(), "A value in, or on the high x boundary "
"of, the last bin the fitting range\n"
"(default the highest value of x)");
size_t i0 = getProperties().size();
// declare parameters specific to a given fitting function
declareParameters();
// load the name of these specific parameter into a vector for later use
const std::vector<Property *> props = getProperties();
for (size_t i = i0; i < props.size(); i++) {
m_parameterNames.push_back(props[i]->name());
}
declareProperty("Fix", "", "A list of comma separated parameter names which "
"should be fixed in the fit");
declareProperty(
"MaxIterations", 500, mustBePositive,
"Stop after this number of iterations if a good fit is not found");
declareProperty("OutputStatus", "", Direction::Output);
declareProperty("OutputChi2overDoF", 0.0, Direction::Output);
// Disable default gsl error handler (which is to call abort!)
gsl_set_error_handler_off();
declareAdditionalProperties();
declareProperty("Output", "", "If not empty OutputParameters TableWorksace "
"and OutputWorkspace will be created.");
}
/**
* Initialize common properties
*/
void SpecularReflectionAlgorithm::initCommonProperties() {
std::stringstream message;
message << "The type of analysis to perform. " << multiDetectorAnalysis
<< ", " << lineDetectorAnalysis << " or " << multiDetectorAnalysis
<< ". Used to help automatically determine the detector components "
"to move";
std::vector<std::string> propOptions;
propOptions.push_back(pointDetectorAnalysis);
propOptions.push_back(lineDetectorAnalysis);
propOptions.push_back(multiDetectorAnalysis);
declareProperty("AnalysisMode", pointDetectorAnalysis,
boost::make_shared<StringListValidator>(propOptions),
message.str());
declareProperty(make_unique<PropertyWithValue<std::string>>(
"DetectorComponentName", "", Direction::Input),
"Name of the detector component i.e. point-detector. If "
"these are not specified, the algorithm will attempt lookup "
"using a standard naming convention.");
declareProperty(make_unique<PropertyWithValue<std::string>>(
"SampleComponentName", "", Direction::Input),
"Name of the sample component i.e. some-surface-holder. If "
"these are not specified, the algorithm will attempt lookup "
"using a standard naming convention.");
auto boundedArrayValidator = boost::make_shared<ArrayBoundedValidator<int>>();
boundedArrayValidator->setLower(0);
declareProperty(
make_unique<ArrayProperty<int>>("SpectrumNumbersOfDetectors",
boundedArrayValidator, Direction::Input),
"A list of spectrum numbers making up an effective point detector.");
declareProperty(make_unique<PropertyWithValue<bool>>("StrictSpectrumChecking",
true, Direction::Input),
"Enable, disable strict spectrum checking. Strict spectrum "
"checking protects against non-sequential integers in which "
"spectrum numbers are not in {min, min+1, ..., max}");
setPropertySettings("SpectrumNumbersOfDetectors",
make_unique<Kernel::EnabledWhenProperty>(
"SampleComponentName", IS_NOT_DEFAULT));
}
/**
* Init index properties.
*/
void ReflectometryWorkflowBase::initIndexInputs()
{
boost::shared_ptr<CompositeValidator> mandatoryWorkspaceIndex = boost::make_shared<
CompositeValidator>();
mandatoryWorkspaceIndex->add(boost::make_shared<MandatoryValidator<int> >());
auto boundedIndex = boost::make_shared<BoundedValidator<int> >();
boundedIndex->setLower(0);
mandatoryWorkspaceIndex->add(boundedIndex);
declareProperty(
new PropertyWithValue<int>("I0MonitorIndex", Mantid::EMPTY_INT(), mandatoryWorkspaceIndex),
"I0 monitor index");
declareProperty(
new PropertyWithValue<std::string>("ProcessingInstructions", "",
boost::make_shared<MandatoryValidator<std::string> >(), Direction::Input),
"Processing instructions on workspace indexes to yield only the detectors of interest. See [[PerformIndexOperations]] for details.");
}
// time to get connected
connectSlots();
layout = new QVBoxLayout();
Logger::getInstance().log("SMEngine->STARTENGINE: initialized", loglevel);
}
void SMEngine::connectSlots(){
//QObject::connect(this, SIGNAL(getWidget(QString,WidgetInterface*)), widgetFactory, SLOT(getWidget(QString,WidgetInterface*)));
QObject::connect(this, SIGNAL(enablePreviousButton(bool)), controlWidget, SLOT(enablePreviousButton(bool)));
QObject::connect(this, SIGNAL(enableSkipButton(bool)), controlWidget, SLOT(enableSkipButton(bool)));
QObject::connect(this, SIGNAL(setWidget(QWidget*)), smGui, SLOT(setCurrentWidget(QWidget*)));
QObject::connect(this, SIGNAL(setLayout(QLayout*)), smGui, SLOT(setCurrentLayout(QLayout*)));
QObject::connect(this, SIGNAL(moveToLowerScreen()), smGui, SLOT(setLower()));
QObject::connect(this, SIGNAL(moveToMiddleOfScreen()), smGui, SLOT(setCenter()));
Logger::getInstance().log("SMENGINE->CONNECTSSLOT: SLOTS connected", loglevel);
}
void SMEngine::addLayout(){
Logger::getInstance().log("SMENGINE->ADDLAYOUT: adding widget to gui: " , loglevel);
emit setLayout(layout);
}
// removes all the widget from gui-layout and disconnect the slot from signals
void SMEngine::removeWidgetFromLayout(const QString name){
QWidget *myWidget = layout->findChild<QWidget*>(name);
QObject::disconnect(controlWidget);
layout->removeWidget(myWidget);
/** Initialize the algorithm, i.e, declare properties
*/
void LoadEventPreNexus2::init() {
// which files to use
vector<string> eventExts(EVENT_EXTS, EVENT_EXTS + NUM_EXT);
declareProperty(
Kernel::make_unique<FileProperty>(EVENT_PARAM, "", FileProperty::Load,
eventExts),
"The name of the neutron event file to read, including its full or "
"relative path. In most cases, the file typically ends in "
"neutron_event.dat (N.B. case sensitive if running on Linux).");
vector<string> pulseExts(PULSE_EXTS, PULSE_EXTS + NUM_EXT);
declareProperty(Kernel::make_unique<FileProperty>(
PULSEID_PARAM, "", FileProperty::OptionalLoad, pulseExts),
"File containing the accelerator pulse information; the "
"filename will be found automatically if not specified.");
declareProperty(
Kernel::make_unique<FileProperty>(MAP_PARAM, "",
FileProperty::OptionalLoad, ".dat"),
"File containing the pixel mapping (DAS pixels to pixel IDs) file "
"(typically INSTRUMENT_TS_YYYY_MM_DD.dat). The filename will be found "
"automatically if not specified.");
// which pixels to load
declareProperty(Kernel::make_unique<ArrayProperty<int64_t>>(PID_PARAM),
"A list of individual spectra (pixel IDs) to read, specified "
"as e.g. 10:20. Only used if set.");
auto mustBePositive = boost::make_shared<BoundedValidator<int>>();
mustBePositive->setLower(1);
declareProperty("ChunkNumber", EMPTY_INT(), mustBePositive,
"If loading the file by sections ('chunks'), this is the "
"section number of this execution of the algorithm.");
declareProperty("TotalChunks", EMPTY_INT(), mustBePositive,
"If loading the file by sections ('chunks'), this is the "
"total number of sections.");
// TotalChunks is only meaningful if ChunkNumber is set
// Would be nice to be able to restrict ChunkNumber to be <= TotalChunks at
// validation
setPropertySettings("TotalChunks", make_unique<VisibleWhenProperty>(
"ChunkNumber", IS_NOT_DEFAULT));
std::vector<std::string> propOptions{"Auto", "Serial", "Parallel"};
declareProperty("UseParallelProcessing", "Auto",
boost::make_shared<StringListValidator>(propOptions),
"Use multiple cores for loading the data?\n"
" Auto: Use serial loading for small data sets, parallel "
"for large data sets.\n"
" Serial: Use a single core.\n"
" Parallel: Use all available cores.");
// the output workspace name
declareProperty(Kernel::make_unique<WorkspaceProperty<IEventWorkspace>>(
OUT_PARAM, "", Direction::Output),
"The name of the workspace that will be created, filled "
"with the read-in "
"data and stored in the [[Analysis Data Service]].");
declareProperty(Kernel::make_unique<WorkspaceProperty<MatrixWorkspace>>(
"EventNumberWorkspace", "", Direction::Output,
PropertyMode::Optional),
"Workspace with number of events per pulse");
// Some debugging options
auto mustBeNonNegative = boost::make_shared<BoundedValidator<int>>();
mustBeNonNegative->setLower(0);
declareProperty("DBOutputBlockNumber", EMPTY_INT(), mustBeNonNegative,
"Index of the loading block for debugging output. ");
declareProperty("DBNumberOutputEvents", 40, mustBePositive,
"Number of output events for debugging purpose. Must be "
"defined with DBOutputBlockNumber.");
declareProperty("DBNumberOutputPulses", EMPTY_INT(), mustBePositive,
"Number of output pulses for debugging purpose. ");
std::string dbgrp = "Investigation Use";
setPropertyGroup("EventNumberWorkspace", dbgrp);
setPropertyGroup("DBOutputBlockNumber", dbgrp);
setPropertyGroup("DBNumberOutputEvents", dbgrp);
setPropertyGroup("DBNumberOutputPulses", dbgrp);
}
/** Initialisation method
*/
void Fit::init()
{
declareProperty(new API::FunctionProperty("Function"),"Parameters defining the fitting function and its initial values");
declareProperty(new API::WorkspaceProperty<API::Workspace>("InputWorkspace","",Kernel::Direction::Input), "Name of the input Workspace");
std::vector<std::string> domainTypes;
domainTypes.push_back( "Simple" );
domainTypes.push_back( "Sequential" );
domainTypes.push_back( "Parallel" );
declareProperty("DomainType","Simple",
Kernel::IValidator_sptr(new Kernel::ListValidator<std::string>(domainTypes)),
"The type of function domain to use: Simple, Sequential, or Parallel.", Kernel::Direction::Input);
declareProperty("Ties","", Kernel::Direction::Input);
getPointerToProperty("Ties")->setDocumentation("Math expressions defining ties between parameters of the fitting function.");
declareProperty("Constraints","", Kernel::Direction::Input);
getPointerToProperty("Constraints")->setDocumentation("List of constraints");
auto mustBePositive = boost::shared_ptr< Kernel::BoundedValidator<int> >( new Kernel::BoundedValidator<int>() );
mustBePositive->setLower(0);
declareProperty("MaxIterations", 500, mustBePositive->clone(),
"Stop after this number of iterations if a good fit is not found" );
declareProperty("IgnoreInvalidData",false,"Flag to ignore infinities, NaNs and data with zero errors.");
declareProperty("OutputStatus","", Kernel::Direction::Output);
getPointerToProperty("OutputStatus")->setDocumentation( "Whether the fit was successful" );
declareProperty("OutputChi2overDoF",0.0, "Returns the goodness of the fit", Kernel::Direction::Output);
// Disable default gsl error handler (which is to call abort!)
gsl_set_error_handler_off();
std::vector<std::string> minimizerOptions = API::FuncMinimizerFactory::Instance().getKeys();
declareProperty("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::vector<std::string> costFuncOptions = API::CostFunctionFactory::Instance().getKeys();
// select only CostFuncFitting variety
for(auto it = costFuncOptions.begin(); it != costFuncOptions.end(); ++it)
{
auto costFunc = boost::dynamic_pointer_cast<CostFuncFitting>(
API::CostFunctionFactory::Instance().create(*it)
);
if (!costFunc)
{
*it = "";
}
}
declareProperty("CostFunction","Least squares",
Kernel::IValidator_sptr(new Kernel::ListValidator<std::string>(costFuncOptions)),
"The cost function to be used for the fit, default is Least squares", Kernel::Direction::InOut);
declareProperty("CreateOutput", false,
"Set to true to create output workspaces with the results of the fit"
"(default is false)." );
declareProperty("Output", "",
"A base name for the output workspaces (if not given default names will be created)." );
declareProperty("CalcErrors", false,
"Set to true to calcuate errors when output isn't created "
"(default is false)." );
declareProperty("OutputCompositeMembers",false,
"If true and CreateOutput is true then the value of each member of a Composite Function is also output.");
declareProperty(new Kernel::PropertyWithValue<bool>("ConvolveMembers", false),
"If true and OutputCompositeMembers is true members of any Convolution are output convolved\n"
"with corresponding resolution");
declareProperty("OutputParametersOnly", false,
"Set to true to output only the parameters and not workspace(s) with the calculated values\n"
"(default is false, ignored if CreateOutput is false and Output is an empty string)." );
}
