Newer
Older
#include "MantidWorkflowAlgorithms/AlignAndFocusPowder.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidKernel/PropertyManagerDataService.h"
Federico Montesino Pouzols
committed
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidDataObjects/GroupingWorkspace.h"
#include "MantidDataObjects/MaskWorkspace.h"
#include "MantidDataObjects/OffsetsWorkspace.h"
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/EnabledWhenProperty.h"
#include "MantidKernel/PropertyManager.h"
#include "MantidKernel/RebinParamsValidator.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/InstrumentInfo.h"
#include "MantidAPI/FileFinder.h"
using Mantid::Geometry::Instrument_const_sptr;
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace Mantid::DataObjects;
namespace Mantid {
namespace WorkflowAlgorithms {
using namespace Kernel;
using API::WorkspaceProperty;
using API::MatrixWorkspace_sptr;
using API::MatrixWorkspace;
using API::FileProperty;
// Register the class into the algorithm factory
DECLARE_ALGORITHM(AlignAndFocusPowder)
AlignAndFocusPowder::AlignAndFocusPowder() : API::DataProcessorAlgorithm() {}
AlignAndFocusPowder::~AlignAndFocusPowder() {
if (m_progress)
delete m_progress;
}
const std::string AlignAndFocusPowder::name() const {
return "AlignAndFocusPowder";
}
int AlignAndFocusPowder::version() const { return 1; }
const std::string AlignAndFocusPowder::category() const {
return "Workflow\\Diffraction";
}
//----------------------------------------------------------------------------------------------
/** Initialisation method. Declares properties to be used in algorithm.
*/
void AlignAndFocusPowder::init() {
declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
"InputWorkspace", "", Direction::Input),
declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
"OutputWorkspace", "", Direction::Output),
"The result of diffraction focussing of InputWorkspace");
// declareProperty(
// new WorkspaceProperty<MatrixWorkspace>("LowResTOFWorkspace", "",
// Direction::Output, PropertyMode::Optional),
// "The name of the workspace containing the filtered low resolution TOF
// data.");
declareProperty(Kernel::make_unique<FileProperty>(
"CalFileName", "", FileProperty::OptionalLoad,
std::vector<std::string>{".h5", ".hd5", ".hdf", ".cal"}),
"The name of the calibration file with offset, masking, and "
"grouping data");
declareProperty(Kernel::make_unique<FileProperty>(
"GroupFilename", "", FileProperty::OptionalLoad,
std::vector<std::string>{".xml"}),
"Overrides grouping from CalFileName");
make_unique<WorkspaceProperty<GroupingWorkspace>>(
"GroupingWorkspace", "", Direction::InOut, PropertyMode::Optional),
"Optional: A GroupingWorkspace giving the grouping info.");
declareProperty(
make_unique<WorkspaceProperty<ITableWorkspace>>(
"CalibrationWorkspace", "", Direction::InOut, PropertyMode::Optional),
"Optional: A Workspace containing the calibration information. Either "
"this or CalibrationFile needs to be specified.");
make_unique<WorkspaceProperty<OffsetsWorkspace>>(
"OffsetsWorkspace", "", Direction::Input, PropertyMode::Optional),
"Optional: An OffsetsWorkspace giving the detector calibration values.");
declareProperty(
make_unique<WorkspaceProperty<MaskWorkspace>>(
"MaskWorkspace", "", Direction::InOut, PropertyMode::Optional),
"Optional: A workspace giving which detectors are masked.");
declareProperty(
make_unique<WorkspaceProperty<TableWorkspace>>(
"MaskBinTable", "", Direction::Input, PropertyMode::Optional),
"Optional: A workspace giving pixels and bins to mask.");
declareProperty(
make_unique<ArrayProperty<double>>(
"Params" /*, boost::make_shared<RebinParamsValidator>()*/),
"A comma separated list of first bin boundary, width, last bin boundary. "
"Optionally\n"
"this can be followed by a comma and more widths and last boundary "
"pairs.\n"
"Negative width values indicate logarithmic binning.");
declareProperty("ResampleX", 0, "Number of bins in x-axis. Non-zero value "
"overrides \"Params\" property. Negative "
"value means logarithmic binning.");
setPropertySettings(
"Params", make_unique<EnabledWhenProperty>("ResampleX", IS_DEFAULT));
declareProperty("Dspacing", true,
"Bin in Dspace. (True is Dspace; False is TOF)");
declareProperty(make_unique<ArrayProperty<double>>("DMin"),
"Minimum for Dspace axis. (Default 0.) ");
Peterson, Peter
committed
mapPropertyName("DMin", "d_min");
declareProperty(make_unique<ArrayProperty<double>>("DMax"),
"Maximum for Dspace axis. (Default 0.) ");
Peterson, Peter
committed
mapPropertyName("DMax", "d_max");
declareProperty("TMin", EMPTY_DBL(), "Minimum for TOF axis. Defaults to 0. ");
Peterson, Peter
committed
mapPropertyName("TMin", "tof_min");
declareProperty("TMax", EMPTY_DBL(),
"Maximum for TOF or dspace axis. Defaults to 0. ");
Peterson, Peter
committed
mapPropertyName("TMax", "tof_max");
declareProperty("PreserveEvents", true, "If the InputWorkspace is an "
"EventWorkspace, this will preserve "
"the full event list (warning: this "
"will use much more memory!).");
declareProperty("RemovePromptPulseWidth", 0., "Width of events (in "
"microseconds) near the prompt "
"pulse to remove. 0 disables");
declareProperty("CompressTolerance", 0.01, "Compress events (in "
"microseconds) within this "
"tolerance. (Default 0.01) ");
declareProperty("UnwrapRef", 0., "Reference total flight path for frame "
"unwrapping. Zero skips the correction");
declareProperty(
"LowResRef", 0.,
"Reference DIFC for resolution removal. Zero skips the correction");
declareProperty(
"CropWavelengthMin", 0.,
"Crop the data at this minimum wavelength. Overrides LowResRef.");
mapPropertyName("CropWavelengthMin", "wavelength_min");
declareProperty("CropWavelengthMax", EMPTY_DBL(),
"Crop the data at this maximum wavelength. Forces use of "
"CropWavelengthMin.");
mapPropertyName("CropWavelengthMax", "wavelength_max");
declareProperty("PrimaryFlightPath", -1.0,
"If positive, focus positions are changed. (Default -1) ");
declareProperty(make_unique<ArrayProperty<int32_t>>("SpectrumIDs"),
"Optional: Spectrum Nos (note that it is not detector ID or "
declareProperty(make_unique<ArrayProperty<double>>("L2"),
"Optional: Secondary flight (L2) paths for each detector");
declareProperty(make_unique<ArrayProperty<double>>("Polar"),
"Optional: Polar angles (two thetas) for detectors");
declareProperty(make_unique<ArrayProperty<double>>("Azimuthal"),
"Azimuthal angles (out-of-plain) for detectors");
declareProperty("LowResSpectrumOffset", -1,
"Offset on spectrum No of low resolution spectra from high "
"resolution one. "
"If negative, then all the low resolution TOF will not be "
"processed. Otherwise, low resolution TOF "
"will be stored in an additional set of spectra. "
"If offset is equal to 0, then the low resolution will have "
"same spectrum Nos as the normal ones. "
"Otherwise, the low resolution spectra will have spectrum "
"IDs offset from normal ones. ");
declareProperty("ReductionProperties", "__powdereduction", Direction::Input);
}
template <typename NumT> struct RegLowVectorPair {
std::vector<NumT> reg;
std::vector<NumT> low;
};
RegLowVectorPair<NumT> splitVectors(const std::vector<NumT> &orig,
const size_t numVal,
const std::string &label) {
RegLowVectorPair<NumT> out;
// check that there is work to do
if (!orig.empty()) {
// do the spliting
if (orig.size() == numVal) {
out.reg.assign(orig.begin(), orig.end());
out.low.assign(orig.begin(), orig.end());
} else if (orig.size() == 2 * numVal) {
out.reg.assign(orig.begin(), orig.begin() + numVal);
out.low.assign(orig.begin() + numVal, orig.begin());
} else {
std::stringstream msg;
msg << "Input number of " << label << " ids is not equal to "
<< "the number of histograms or empty (" << orig.size() << " != 0 or "
<< numVal << " or " << (2 * numVal) << ")";
throw std::runtime_error(msg.str());
}
Loading
Loading full blame...