diff --git a/Framework/MDAlgorithms/inc/MantidMDAlgorithms/LoadDNSSCD.h b/Framework/MDAlgorithms/inc/MantidMDAlgorithms/LoadDNSSCD.h
index ccbe77a9ce6a651d724cfc6930a808bebab045fe..cf0b4e0e995c8a7fc571c37a44fcd8dd26886ffb 100644
--- a/Framework/MDAlgorithms/inc/MantidMDAlgorithms/LoadDNSSCD.h
+++ b/Framework/MDAlgorithms/inc/MantidMDAlgorithms/LoadDNSSCD.h
@@ -10,7 +10,6 @@
#include "MantidKernel/Matrix.h"
#include "MantidKernel/V3D.h"
-
namespace Mantid {
namespace MDAlgorithms {
@@ -40,64 +39,67 @@ namespace MDAlgorithms {
File change history is stored at: <https://github.com/mantidproject/mantid>
Code Documentation is available at: <http://doxygen.mantidproject.org>
*/
-class DLLExport LoadDNSSCD : public API::IFileLoader<Kernel::FileDescriptor> {
+class DLLExport LoadDNSSCD : public API::IFileLoader<Kernel::FileDescriptor> {
public:
- LoadDNSSCD();
+ LoadDNSSCD();
- /// Algorithm's name for identification
- const std::string name() const override { return "LoadDNSSCD"; }
+ /// Algorithm's name for identification
+ const std::string name() const override { return "LoadDNSSCD"; }
- /// Summary of algorithms purpose
- const std::string summary() const override {
- return "Load a list of DNS .d_dat files into a MDEventWorkspace.";
- }
+ /// Summary of algorithms purpose
+ const std::string summary() const override {
+ return "Load a list of DNS .d_dat files into a MDEventWorkspace.";
+ }
- /// Algorithm's version for identification
- int version() const override { return 1; }
+ /// Algorithm's version for identification
+ int version() const override { return 1; }
- /// Algorithm's category for identification
- const std::string category() const override {
- return "MDAlgorithms\\DataHandling";
- }
+ /// Algorithm's category for identification
+ const std::string category() const override {
+ return "MDAlgorithms\\DataHandling";
+ }
- /// Returns a confidence value that this algorithm can load a file
- int confidence(Kernel::FileDescriptor &descriptor) const override;
+ /// Returns a confidence value that this algorithm can load a file
+ int confidence(Kernel::FileDescriptor &descriptor) const override;
private:
- /// Initialise the properties
- void init() override;
- /// Run the algorithm
- void exec() override;
-
- /// number of workspace dimensions
- size_t m_nDims;
-
- /// type of normalization;
- std::string m_normtype;
- /// factor to multiply the error^2 for normalization
- double m_normfactor;
-
- /// structure for experimental data
- struct ExpData {
- double deterota;
- double huber;
- double wavelength;
- double norm;
- std::vector<double> signal;
- std::vector<int> detID;
- };
-
- std::vector<ExpData> m_data;
-
- /// Output IMDEventWorkspace
- Mantid::API::IMDEventWorkspace_sptr m_OutWS;
-
- void read_data(const std::string fname, std::map<std::string, std::string> &str_metadata, std::map<std::string, double> &num_metadata);
- void fillOutputWorkspace(double wavelength);
- API::ITableWorkspace_sptr saveHuber();
- void loadHuber(API::ITableWorkspace_sptr tws);
- template<class T>
- void updateProperties(API::Run &run, std::map<std::string, T> &metadata, std::string time);
+ /// Initialise the properties
+ void init() override;
+ /// Run the algorithm
+ void exec() override;
+
+ /// number of workspace dimensions
+ size_t m_nDims;
+
+ /// type of normalization;
+ std::string m_normtype;
+ /// factor to multiply the error^2 for normalization
+ double m_normfactor;
+
+ /// structure for experimental data
+ struct ExpData {
+ double deterota;
+ double huber;
+ double wavelength;
+ double norm;
+ std::vector<double> signal;
+ std::vector<int> detID;
+ };
+
+ std::vector<ExpData> m_data;
+
+ /// Output IMDEventWorkspace
+ Mantid::API::IMDEventWorkspace_sptr m_OutWS;
+
+ void read_data(const std::string fname,
+ std::map<std::string, std::string> &str_metadata,
+ std::map<std::string, double> &num_metadata);
+ void fillOutputWorkspace(double wavelength);
+ API::ITableWorkspace_sptr saveHuber();
+ void loadHuber(API::ITableWorkspace_sptr tws);
+ template <class T>
+ void updateProperties(API::Run &run, std::map<std::string, T> &metadata,
+ std::string time);
};
} // namespace MDAlgorithms
diff --git a/Framework/MDAlgorithms/src/LoadDNSSCD.cpp b/Framework/MDAlgorithms/src/LoadDNSSCD.cpp
index e547aa66c112efb225dc1b79ea1f8d0f85444381..af518cc46c0bb3643c5cd3be5e494fd277282c1f 100644
--- a/Framework/MDAlgorithms/src/LoadDNSSCD.cpp
+++ b/Framework/MDAlgorithms/src/LoadDNSSCD.cpp
@@ -36,52 +36,51 @@
#include "MantidDataObjects/MDBoxBase.h"
#include "MantidDataObjects/MDEventInserter.h"
-
//========================
// helper functions
namespace {
-void eraseSubStr(std::string & str, const std::string & toErase) {
- // Search for the substring in string
- size_t pos = str.find(toErase);
- if (pos != std::string::npos) {
- // If found then erase it from string
- str.erase(pos, toErase.length());
- }
+void eraseSubStr(std::string &str, const std::string &toErase) {
+ // Search for the substring in string
+ size_t pos = str.find(toErase);
+ if (pos != std::string::npos) {
+ // If found then erase it from string
+ str.erase(pos, toErase.length());
+ }
}
-std::string parseTime(std::string &str){
- // remove unnecessary symbols
- eraseSubStr(str, "#");
- eraseSubStr(str, "start");
- eraseSubStr(str, "stopped");
- eraseSubStr(str, "at");
- auto it = std::find_if(str.begin() , str.end() ,
- [](char ch){ return !std::isspace<char>(ch , std::locale::classic()) ; } );
- str.erase(str.begin(), it);
- using namespace boost::posix_time;
- // try to parse as a posix time
- try{
- auto time = time_from_string(str);
- return to_iso_extended_string(time);
- } catch (std::exception &) {
- // if time is not in posix format
- // change all sindle-digit days to 0d (otherwise get_time does not parse)
- boost::regex expr("\\s+([0-9]\\s+)");
- std::string fmt{" 0\\1"};
- str = boost::regex_replace(str, expr, fmt);
- std::istringstream ss(str);
- std::tm t = {};
- ss >> std::get_time(&t, "%a %b %d %H:%M:%S %Y");
- std::string result("");
- if (!ss.fail()) {
- auto time = ptime_from_tm(t);
- return to_iso_extended_string(time);
- }
-
- return result;
+std::string parseTime(std::string &str) {
+ // remove unnecessary symbols
+ eraseSubStr(str, "#");
+ eraseSubStr(str, "start");
+ eraseSubStr(str, "stopped");
+ eraseSubStr(str, "at");
+ auto it = std::find_if(str.begin(), str.end(), [](char ch) {
+ return !std::isspace<char>(ch, std::locale::classic());
+ });
+ str.erase(str.begin(), it);
+ using namespace boost::posix_time;
+ // try to parse as a posix time
+ try {
+ auto time = time_from_string(str);
+ return to_iso_extended_string(time);
+ } catch (std::exception &) {
+ // if time is not in posix format
+ // change all sindle-digit days to 0d (otherwise get_time does not parse)
+ boost::regex expr("\\s+([0-9]\\s+)");
+ std::string fmt{" 0\\1"};
+ str = boost::regex_replace(str, expr, fmt);
+ std::istringstream ss(str);
+ std::tm t = {};
+ ss >> std::get_time(&t, "%a %b %d %H:%M:%S %Y");
+ std::string result("");
+ if (!ss.fail()) {
+ auto time = ptime_from_tm(t);
+ return to_iso_extended_string(time);
}
-}
+ return result;
+ }
+}
} // anonymous namespace
//============================
@@ -99,7 +98,7 @@ DECLARE_FILELOADER_ALGORITHM(LoadDNSSCD)
//----------------------------------------------------------------------------------------------
/** Constructor
*/
-LoadDNSSCD::LoadDNSSCD() : m_nDims(3){}
+LoadDNSSCD::LoadDNSSCD() : m_nDims(3) {}
/**
* Return the confidence with with this algorithm can load the file
@@ -130,14 +129,14 @@ void LoadDNSSCD::init() {
"An output MDEventWorkspace.");
declareProperty(make_unique<WorkspaceProperty<IMDEventWorkspace>>(
- "NormalizationWorkspace", "", Direction::Output),
- "An output normalization MDEventWorkspace.");
+ "NormalizationWorkspace", "", Direction::Output),
+ "An output normalization MDEventWorkspace.");
const std::vector<std::string> normOptions = {"monitor", "time"};
declareProperty("Normalization", "monitor",
- boost::make_shared<StringListValidator>(normOptions),
- "Algorithm will create a separate normalization workspace. "
- "Choose whether it should contain monitor counts or time.");
+ boost::make_shared<StringListValidator>(normOptions),
+ "Algorithm will create a separate normalization workspace. "
+ "Choose whether it should contain monitor counts or time.");
auto mustBePositive = boost::make_shared<BoundedValidator<double>>();
mustBePositive->setLower(0.0);
@@ -154,55 +153,59 @@ void LoadDNSSCD::init() {
v0[2] = 1.;
declareProperty(make_unique<PropertyWithValue<double>>(
- "a", 1.0, mustBePositive, Direction::Input),
- "Lattice parameter a in Angstrom");
+ "a", 1.0, mustBePositive, Direction::Input),
+ "Lattice parameter a in Angstrom");
declareProperty(make_unique<PropertyWithValue<double>>(
- "b", 1.0, mustBePositive, Direction::Input),
- "Lattice parameter b in Angstrom");
+ "b", 1.0, mustBePositive, Direction::Input),
+ "Lattice parameter b in Angstrom");
declareProperty(make_unique<PropertyWithValue<double>>(
- "c", 1.0, mustBePositive, Direction::Input),
- "Lattice parameter c in Angstrom");
+ "c", 1.0, mustBePositive, Direction::Input),
+ "Lattice parameter c in Angstrom");
declareProperty(make_unique<PropertyWithValue<double>>(
- "alpha", 90.0, reasonableAngle, Direction::Input),
- "Angle between b and c in degrees");
+ "alpha", 90.0, reasonableAngle, Direction::Input),
+ "Angle between b and c in degrees");
declareProperty(make_unique<PropertyWithValue<double>>(
- "beta", 90.0, reasonableAngle, Direction::Input),
- "Angle between a and c in degrees");
+ "beta", 90.0, reasonableAngle, Direction::Input),
+ "Angle between a and c in degrees");
declareProperty(make_unique<PropertyWithValue<double>>(
- "gamma", 90.0, reasonableAngle, Direction::Input),
- "Angle between a and b in degrees");
+ "gamma", 90.0, reasonableAngle, Direction::Input),
+ "Angle between a and b in degrees");
declareProperty(make_unique<PropertyWithValue<double>>(
- "OmegaOffset", 0.0, boost::make_shared<BoundedValidator<double>>(),
+ "OmegaOffset", 0.0,
+ boost::make_shared<BoundedValidator<double>>(),
Direction::Input),
"Angle in degrees between (hkl1) and the beam axis"
"if the goniometer is at zero.");
declareProperty(
- Kernel::make_unique<ArrayProperty<double>>("hkl1", u0, mustBe3D),
- "Indices of the vector in reciprocal space in the horizontal plane at angle Omegaoffset, "
- "if the goniometer is at zero.");
+ Kernel::make_unique<ArrayProperty<double>>("hkl1", u0, mustBe3D),
+ "Indices of the vector in reciprocal space in the horizontal plane at "
+ "angle Omegaoffset, "
+ "if the goniometer is at zero.");
declareProperty(
- Kernel::make_unique<ArrayProperty<double>>("hkl2", v0, mustBe3D),
- "Indices of a second vector in reciprocal space in the horizontal plane not parallel to hkl1");
+ Kernel::make_unique<ArrayProperty<double>>("hkl2", v0, mustBe3D),
+ "Indices of a second vector in reciprocal space in the horizontal plane "
+ "not parallel to hkl1");
std::vector<double> ttl(2, 0);
ttl[1] = 180.0;
declareProperty(
- Kernel::make_unique<ArrayProperty<double>>("TwoThetaLimits", ttl, mustBe2D),
- "Range (min, max) of scattering angles (2theta, in degrees) to consider. "
- "Everything out of this range will be cut.");
+ Kernel::make_unique<ArrayProperty<double>>("TwoThetaLimits", ttl,
+ mustBe2D),
+ "Range (min, max) of scattering angles (2theta, in degrees) to consider. "
+ "Everything out of this range will be cut.");
declareProperty(
- Kernel::make_unique<WorkspaceProperty<API::ITableWorkspace>>(
- "LoadHuberFrom", "", Direction::Input, PropertyMode::Optional),
- "A table workspace to load a list of raw sample rotation angles. "
- "Huber angles given in the data files will be ignored.");
+ Kernel::make_unique<WorkspaceProperty<API::ITableWorkspace>>(
+ "LoadHuberFrom", "", Direction::Input, PropertyMode::Optional),
+ "A table workspace to load a list of raw sample rotation angles. "
+ "Huber angles given in the data files will be ignored.");
declareProperty(
- Kernel::make_unique<WorkspaceProperty<API::ITableWorkspace>>(
- "SaveHuberTo", "", Direction::Output, PropertyMode::Optional),
- "A workspace name to save a list of raw sample rotation angles.");
+ Kernel::make_unique<WorkspaceProperty<API::ITableWorkspace>>(
+ "SaveHuberTo", "", Direction::Output, PropertyMode::Optional),
+ "A workspace name to save a list of raw sample rotation angles.");
}
//----------------------------------------------------------------------------------------------
@@ -210,149 +213,161 @@ void LoadDNSSCD::init() {
*/
void LoadDNSSCD::loadHuber(ITableWorkspace_sptr tws) {
- ColumnVector<double> huber = tws->getVector("Huber(degrees)");
- // set huber[0] for each run in m_data
- for(auto &ds : m_data) {
- ds.huber = huber[0];
- }
- // dublicate runs for each huber in the table
- std::vector<ExpData> old(m_data);
- for (size_t i = 1; i < huber.size(); ++i){
- for(auto &ds : old) {
- ds.huber = huber[i];
- m_data.push_back(ds);
- }
+ ColumnVector<double> huber = tws->getVector("Huber(degrees)");
+ // set huber[0] for each run in m_data
+ for (auto &ds : m_data) {
+ ds.huber = huber[0];
+ }
+ // dublicate runs for each huber in the table
+ std::vector<ExpData> old(m_data);
+ for (size_t i = 1; i < huber.size(); ++i) {
+ for (auto &ds : old) {
+ ds.huber = huber[i];
+ m_data.push_back(ds);
}
+ }
}
//----------------------------------------------------------------------------------------------
/** Save Huber angles to a given table workspace.
*/
Mantid::API::ITableWorkspace_sptr LoadDNSSCD::saveHuber() {
- std::vector<double> huber;
- for(auto ds : m_data)
- huber.push_back(ds.huber);
- // remove dublicates
- std::sort(huber.begin(), huber.end());
- huber.erase(unique(huber.begin(), huber.end()), huber.end());
-
- Mantid::API::ITableWorkspace_sptr huberWS = WorkspaceFactory::Instance().createTable("TableWorkspace");
- huberWS->addColumn("double", "Huber(degrees)");
- for(size_t i=0; i< huber.size(); i++) {
- huberWS->appendRow();
- huberWS->cell<double>(i, 0) = huber[i];
- }
- return huberWS;
+ std::vector<double> huber;
+ for (auto ds : m_data)
+ huber.push_back(ds.huber);
+ // remove dublicates
+ std::sort(huber.begin(), huber.end());
+ huber.erase(unique(huber.begin(), huber.end()), huber.end());
+
+ Mantid::API::ITableWorkspace_sptr huberWS =
+ WorkspaceFactory::Instance().createTable("TableWorkspace");
+ huberWS->addColumn("double", "Huber(degrees)");
+ for (size_t i = 0; i < huber.size(); i++) {
+ huberWS->appendRow();
+ huberWS->cell<double>(i, 0) = huber[i];
+ }
+ return huberWS;
}
//----------------------------------------------------------------------------------------------
/** Execute the algorithm.
*/
void LoadDNSSCD::exec() {
- MultipleFileProperty *multiFileProp =
- dynamic_cast<MultipleFileProperty *>(getPointerToProperty("Filenames"));
- if (!multiFileProp) {
- throw std::logic_error(
- "Filenames property must have MultipleFileProperty type.");
- }
- std::vector<std::string> filenames = VectorHelper::flattenVector(multiFileProp->operator()());
- if (filenames.empty())
- throw std::invalid_argument("Must specify at least one filename.");
-
- // set type of normalization
- std::string normtype = getProperty("Normalization");
- if (normtype=="monitor") {
- m_normtype = "Monitor";
- m_normfactor = 1.0;
- } else {
- m_normtype = "Timer";
- m_normfactor = 0.0; // error for time should be 0
- }
+ MultipleFileProperty *multiFileProp =
+ dynamic_cast<MultipleFileProperty *>(getPointerToProperty("Filenames"));
+ if (!multiFileProp) {
+ throw std::logic_error(
+ "Filenames property must have MultipleFileProperty type.");
+ }
+ std::vector<std::string> filenames =
+ VectorHelper::flattenVector(multiFileProp->operator()());
+ if (filenames.empty())
+ throw std::invalid_argument("Must specify at least one filename.");
+
+ // set type of normalization
+ std::string normtype = getProperty("Normalization");
+ if (normtype == "monitor") {
+ m_normtype = "Monitor";
+ m_normfactor = 1.0;
+ } else {
+ m_normtype = "Timer";
+ m_normfactor = 0.0; // error for time should be 0
+ }
- g_log.notice() << "The normalization workspace will contain " << m_normtype << ".\n";
-
- ExperimentInfo_sptr expinfo = boost::make_shared<ExperimentInfo>();
- API::Run &run = expinfo->mutableRun();
- for (auto fname : filenames) {
- std::map<std::string, std::string> str_metadata;
- std::map<std::string, double> num_metadata;
- try {
- read_data(fname, str_metadata, num_metadata);
- //if no stop_time, take file_save_time
- std::string time(str_metadata["stop_time"]);
- if (time.empty()) {
- g_log.warning() << "stop_time is empty! File save time will be used instead." << std::endl;
- time = str_metadata["file_save_time"];
- }
- updateProperties<std::string>(run, str_metadata, time);
- updateProperties<double>(run, num_metadata, time);
- } catch(...) {
- g_log.warning() << "Failed to read file " << fname;
- g_log.warning() << ". This file will be ignored. " << std::endl;
- }
+ g_log.notice() << "The normalization workspace will contain " << m_normtype
+ << ".\n";
+
+ ExperimentInfo_sptr expinfo = boost::make_shared<ExperimentInfo>();
+ API::Run &run = expinfo->mutableRun();
+ for (auto fname : filenames) {
+ std::map<std::string, std::string> str_metadata;
+ std::map<std::string, double> num_metadata;
+ try {
+ read_data(fname, str_metadata, num_metadata);
+ // if no stop_time, take file_save_time
+ std::string time(str_metadata["stop_time"]);
+ if (time.empty()) {
+ g_log.warning()
+ << "stop_time is empty! File save time will be used instead."
+ << std::endl;
+ time = str_metadata["file_save_time"];
+ }
+ updateProperties<std::string>(run, str_metadata, time);
+ updateProperties<double>(run, num_metadata, time);
+ } catch (...) {
+ g_log.warning() << "Failed to read file " << fname;
+ g_log.warning() << ". This file will be ignored. " << std::endl;
}
+ }
- if (m_data.empty())
- throw std::runtime_error("No valid DNS files have been provided. Nothing to load.");
-
- m_OutWS = MDEventFactory::CreateMDWorkspace(m_nDims, "MDEvent");
-
- m_OutWS->addExperimentInfo(expinfo);
+ if (m_data.empty())
+ throw std::runtime_error(
+ "No valid DNS files have been provided. Nothing to load.");
- // load huber angles from a table workspace if given
- ITableWorkspace_sptr huberWS = getProperty("LoadHuberFrom");
- if(huberWS){
- g_log.notice() << "Huber angles will be loaded from " << huberWS->getName() << std::endl;
- loadHuber(huberWS);
- }
+ m_OutWS = MDEventFactory::CreateMDWorkspace(m_nDims, "MDEvent");
- // get wavelength
- TimeSeriesProperty<double> *wlprop = dynamic_cast<TimeSeriesProperty<double> *>(expinfo->run().getProperty("Lambda"));
- // assume, that lambda is in nm
- double wavelength = wlprop->minValue()*10.0; // needed to estimate extents => minValue
- run.addProperty("wavelength", wavelength);
- run.getProperty("wavelength")->setUnits("Angstrom");
+ m_OutWS->addExperimentInfo(expinfo);
- fillOutputWorkspace(wavelength);
+ // load huber angles from a table workspace if given
+ ITableWorkspace_sptr huberWS = getProperty("LoadHuberFrom");
+ if (huberWS) {
+ g_log.notice() << "Huber angles will be loaded from " << huberWS->getName()
+ << std::endl;
+ loadHuber(huberWS);
+ }
- std::string saveHuberTableWS = getProperty("SaveHuberTo");
- if (!saveHuberTableWS.empty()) {
- Mantid::API::ITableWorkspace_sptr huber_table = saveHuber();
- setProperty("SaveHuberTo", huber_table);
- }
- setProperty("OutputWorkspace", m_OutWS);
+ // get wavelength
+ TimeSeriesProperty<double> *wlprop =
+ dynamic_cast<TimeSeriesProperty<double> *>(
+ expinfo->run().getProperty("Lambda"));
+ // assume, that lambda is in nm
+ double wavelength =
+ wlprop->minValue() * 10.0; // needed to estimate extents => minValue
+ run.addProperty("wavelength", wavelength);
+ run.getProperty("wavelength")->setUnits("Angstrom");
+
+ fillOutputWorkspace(wavelength);
+
+ std::string saveHuberTableWS = getProperty("SaveHuberTo");
+ if (!saveHuberTableWS.empty()) {
+ Mantid::API::ITableWorkspace_sptr huber_table = saveHuber();
+ setProperty("SaveHuberTo", huber_table);
+ }
+ setProperty("OutputWorkspace", m_OutWS);
}
//----------------------------------------------------------------------------------------------
-template <class T> void LoadDNSSCD::updateProperties(API::Run &run, std::map<std::string, T> &metadata, std::string time) {
- typename std::map<std::string, T>::iterator it = metadata.begin();
- while(it != metadata.end()) {
- TimeSeriesProperty<T> *timeSeries(nullptr);
- std::string name(it->first);
- std::string units;
- std::regex reg ("([a-zA-Z-_]+)\\[(.*)]");
- std::smatch match;
- if (std::regex_search(name, match, reg) && match.size() > 2) {
- std::string new_name(match.str(1));
- units.assign(match.str(2));
- name = new_name;
- }
- if (run.hasProperty(name)) {
- timeSeries =
- dynamic_cast<TimeSeriesProperty<T> *>(run.getLogData(name));
- if (!timeSeries)
- throw std::invalid_argument(
- "Log '" + name +
- "' already exists but the values are a different type.");
- } else {
- timeSeries = new TimeSeriesProperty<T>(name);
- if (!units.empty())
- timeSeries->setUnits(units);
- run.addProperty(timeSeries);
- }
- timeSeries->addValue(time, it->second);
- it++;
+template <class T>
+void LoadDNSSCD::updateProperties(API::Run &run,
+ std::map<std::string, T> &metadata,
+ std::string time) {
+ typename std::map<std::string, T>::iterator it = metadata.begin();
+ while (it != metadata.end()) {
+ TimeSeriesProperty<T> *timeSeries(nullptr);
+ std::string name(it->first);
+ std::string units;
+ std::regex reg("([a-zA-Z-_]+)\\[(.*)]");
+ std::smatch match;
+ if (std::regex_search(name, match, reg) && match.size() > 2) {
+ std::string new_name(match.str(1));
+ units.assign(match.str(2));
+ name = new_name;
}
+ if (run.hasProperty(name)) {
+ timeSeries = dynamic_cast<TimeSeriesProperty<T> *>(run.getLogData(name));
+ if (!timeSeries)
+ throw std::invalid_argument(
+ "Log '" + name +
+ "' already exists but the values are a different type.");
+ } else {
+ timeSeries = new TimeSeriesProperty<T>(name);
+ if (!units.empty())
+ timeSeries->setUnits(units);
+ run.addProperty(timeSeries);
+ }
+ timeSeries->addValue(time, it->second);
+ it++;
+ }
}
//----------------------------------------------------------------------------------------------
/// Create output workspace
@@ -383,9 +398,9 @@ void LoadDNSSCD::fillOutputWorkspace(double wavelength) {
std::vector<double> v = getProperty("hkl2");
// estimate extents
- double qmax = 4.0*M_PI/wavelength;
- std::vector<double> extentMins = {-qmax*a, -qmax*b, -qmax*c};
- std::vector<double> extentMaxs = {qmax*a, qmax*b, qmax*c};
+ double qmax = 4.0 * M_PI / wavelength;
+ std::vector<double> extentMins = {-qmax * a, -qmax * b, -qmax * c};
+ std::vector<double> extentMaxs = {qmax * a, qmax * b, qmax * c};
// Get MDFrame of HKL type with RLU
auto unitFactory = makeMDUnitFactoryChain();
@@ -409,11 +424,11 @@ void LoadDNSSCD::fillOutputWorkspace(double wavelength) {
Mantid::Geometry::OrientedLattice o;
o = Mantid::Geometry::OrientedLattice(a, b, c, alpha, beta, gamma);
o.setUFromVectors(Mantid::Kernel::V3D(u[0], u[1], u[2]),
- Mantid::Kernel::V3D(v[0], v[1], v[2]));
+ Mantid::Kernel::V3D(v[0], v[1], v[2]));
double omega_offset = getProperty("OmegaOffset");
- omega_offset *= -1.0*deg2rad;
- DblMatrix rotm(3,3);
+ omega_offset *= -1.0 * deg2rad;
+ DblMatrix rotm(3, 3);
rotm[0][0] = std::cos(omega_offset);
rotm[0][1] = 0.0;
rotm[0][2] = std::sin(omega_offset);
@@ -441,152 +456,151 @@ void LoadDNSSCD::fillOutputWorkspace(double wavelength) {
// Creates a new instance of the MDEventInserter to norm workspace
MDEventWorkspace<MDEvent<3>, 3>::sptr normws_mdevt_3 =
- boost::dynamic_pointer_cast<MDEventWorkspace<MDEvent<3>, 3>>(normWS);
- MDEventInserter<MDEventWorkspace<MDEvent<3>, 3>::sptr> norm_inserter(normws_mdevt_3);
+ boost::dynamic_pointer_cast<MDEventWorkspace<MDEvent<3>, 3>>(normWS);
+ MDEventInserter<MDEventWorkspace<MDEvent<3>, 3>::sptr> norm_inserter(
+ normws_mdevt_3);
// scattering angle limits
std::vector<double> tth_limits = getProperty("TwoThetaLimits");
- double theta_min = tth_limits[0]*deg2rad/2.0;
- double theta_max = tth_limits[1]*deg2rad/2.0;
+ double theta_min = tth_limits[0] * deg2rad / 2.0;
+ double theta_max = tth_limits[1] * deg2rad / 2.0;
// Go though each element of m_data to convert to MDEvent
- for (ExpData ds: m_data) {
- uint16_t runnumber = 1;
- signal_t norm_signal(ds.norm);
- signal_t norm_error = std::sqrt(m_normfactor*norm_signal);
- double k = 2.0/ds.wavelength;
- for (size_t i=0; i< ds.detID.size(); i++){
- signal_t signal(ds.signal[i]);
- signal_t error = std::sqrt(signal);
- detid_t detid(ds.detID[i]);
- double theta = 0.5*(ds.detID[i]*5.0 - ds.deterota)*deg2rad;
- if ((theta > theta_min) && (theta < theta_max)) {
- double omega = (ds.huber - ds.deterota)*deg2rad - theta;
- V3D uphi (-cos(omega), 0, -sin(omega));
- V3D hphi = uphi*k*sin(theta);
- V3D hkl = ub_inv*hphi;
- std::vector<Mantid::coord_t> millerindex(3);
- millerindex[0] = static_cast<float>(hkl.X());
- millerindex[1] = static_cast<float>(hkl.Y());
- millerindex[2] = static_cast<float>(hkl.Z());
- inserter.insertMDEvent(
- static_cast<float>(signal), static_cast<float>(error * error),
- static_cast<uint16_t>(runnumber), detid, millerindex.data());
-
- norm_inserter.insertMDEvent(
- static_cast<float>(norm_signal), static_cast<float>(norm_error * norm_error),
- static_cast<uint16_t>(runnumber), detid, millerindex.data());
- }
-
+ for (ExpData ds : m_data) {
+ uint16_t runnumber = 1;
+ signal_t norm_signal(ds.norm);
+ signal_t norm_error = std::sqrt(m_normfactor * norm_signal);
+ double k = 2.0 / ds.wavelength;
+ for (size_t i = 0; i < ds.detID.size(); i++) {
+ signal_t signal(ds.signal[i]);
+ signal_t error = std::sqrt(signal);
+ detid_t detid(ds.detID[i]);
+ double theta = 0.5 * (ds.detID[i] * 5.0 - ds.deterota) * deg2rad;
+ if ((theta > theta_min) && (theta < theta_max)) {
+ double omega = (ds.huber - ds.deterota) * deg2rad - theta;
+ V3D uphi(-cos(omega), 0, -sin(omega));
+ V3D hphi = uphi * k * sin(theta);
+ V3D hkl = ub_inv * hphi;
+ std::vector<Mantid::coord_t> millerindex(3);
+ millerindex[0] = static_cast<float>(hkl.X());
+ millerindex[1] = static_cast<float>(hkl.Y());
+ millerindex[2] = static_cast<float>(hkl.Z());
+ inserter.insertMDEvent(
+ static_cast<float>(signal), static_cast<float>(error * error),
+ static_cast<uint16_t>(runnumber), detid, millerindex.data());
+
+ norm_inserter.insertMDEvent(static_cast<float>(norm_signal),
+ static_cast<float>(norm_error * norm_error),
+ static_cast<uint16_t>(runnumber), detid,
+ millerindex.data());
}
-
+ }
}
setProperty("NormalizationWorkspace", normWS);
-
}
-
void LoadDNSSCD::read_data(const std::string fname,
std::map<std::string, std::string> &str_metadata,
std::map<std::string, double> &num_metadata) {
- std::ifstream file (fname);
- std::string line;
- std::string::size_type n;
- std::string s;
- std::regex reg1("^#\\s+(\\w+):(.*)");
- std::regex reg2("^#\\s+((\\w+\\s)+)\\s+(-?\\d+(,\\d+)*(\\.\\d+(e\\d+)?)?)");
- std::smatch match;
- getline(file, line);
- n = line.find("DNS");
- if (n == std::string::npos) {
- throw std::invalid_argument("Not a DNS file");
- }
- // get file save time
- Poco::File pfile(fname);
- Poco::DateTime lastModified = pfile.getLastModified();
- std::string wtime(Poco::DateTimeFormatter::format(lastModified, "%Y-%m-%dT%H:%M:%S"));
- str_metadata.insert(std::make_pair("file_save_time", wtime));
-
- // get file basename
- Poco::Path p(fname);
- str_metadata.insert(std::make_pair("run_number", p.getBaseName()));
-
- // parse metadata
- while(getline(file, line)){
- n = line.find("Lambda");
- if (n != std::string::npos) {
- std::regex re("[\\s]+");
- s = line.substr(5);
- std::sregex_token_iterator it(s.begin(), s.end(), re, -1);
- std::sregex_token_iterator reg_end;
- getline(file, line);
- std::string s2 = line.substr(2);
- std::sregex_token_iterator it2(s2.begin(), s2.end(), re, -1);
- for (; (it != reg_end) && (it2 != reg_end); ++it) {
- std::string token (it->str());
- if (token.find_first_not_of(' ') == std::string::npos) {
- ++it2;
- continue;
- }
- if (token == "Mono") {
- str_metadata.insert(std::make_pair(token, it2->str()));
- } else {
- num_metadata.insert(std::make_pair(token, std::stod(it2->str())));
- }
- ++it2;
- }
- }
- // parse start and stop time
- n = line.find("start");
- if (n != std::string::npos) {
- str_metadata.insert(std::make_pair("start_time", parseTime(line)));
- getline(file, line);
- str_metadata.insert(std::make_pair("stop_time", parseTime(line)));
- getline(file, line);
- }
- if (std::regex_search(line, match, reg1) && match.size() > 2) {
- str_metadata.insert(std::make_pair(match.str(1), match.str(2)));
- }
- if (std::regex_search(line, match, reg2) && match.size() > 2) {
- s = match.str(1);
- s.erase(std::find_if_not(s.rbegin(), s.rend(), ::isspace).base(), s.end());
- num_metadata.insert(std::make_pair(s, std::stod(match.str(3))));
+ std::ifstream file(fname);
+ std::string line;
+ std::string::size_type n;
+ std::string s;
+ std::regex reg1("^#\\s+(\\w+):(.*)");
+ std::regex reg2("^#\\s+((\\w+\\s)+)\\s+(-?\\d+(,\\d+)*(\\.\\d+(e\\d+)?)?)");
+ std::smatch match;
+ getline(file, line);
+ n = line.find("DNS");
+ if (n == std::string::npos) {
+ throw std::invalid_argument("Not a DNS file");
+ }
+ // get file save time
+ Poco::File pfile(fname);
+ Poco::DateTime lastModified = pfile.getLastModified();
+ std::string wtime(
+ Poco::DateTimeFormatter::format(lastModified, "%Y-%m-%dT%H:%M:%S"));
+ str_metadata.insert(std::make_pair("file_save_time", wtime));
+
+ // get file basename
+ Poco::Path p(fname);
+ str_metadata.insert(std::make_pair("run_number", p.getBaseName()));
+
+ // parse metadata
+ while (getline(file, line)) {
+ n = line.find("Lambda");
+ if (n != std::string::npos) {
+ std::regex re("[\\s]+");
+ s = line.substr(5);
+ std::sregex_token_iterator it(s.begin(), s.end(), re, -1);
+ std::sregex_token_iterator reg_end;
+ getline(file, line);
+ std::string s2 = line.substr(2);
+ std::sregex_token_iterator it2(s2.begin(), s2.end(), re, -1);
+ for (; (it != reg_end) && (it2 != reg_end); ++it) {
+ std::string token(it->str());
+ if (token.find_first_not_of(' ') == std::string::npos) {
+ ++it2;
+ continue;
}
- n = line.find("DATA");
- if (n != std::string::npos) {
- break;
+ if (token == "Mono") {
+ str_metadata.insert(std::make_pair(token, it2->str()));
+ } else {
+ num_metadata.insert(std::make_pair(token, std::stod(it2->str())));
}
+ ++it2;
+ }
}
-
- // the algorithm does not work with TOF data for the moment
- std::map<std::string,double>::const_iterator m = num_metadata.lower_bound("TOF");
- g_log.debug() << "TOF Channels number: " << m->second << std::endl;
- if (m->second != 1)
- throw std::runtime_error("Algorithm does not support TOF data. TOF Channels number must be 1.");
-
- ExpData ds;
- ds.deterota = num_metadata["DeteRota"];
- ds.huber = num_metadata["Huber"];
- ds.wavelength = 10.0*num_metadata["Lambda[nm]"];
- ds.norm = num_metadata[m_normtype];
-
- // read data array
- getline(file, line);
- int d;
- double x;
- while(file){
- file >> d >> x;
- ds.detID.push_back(d);
- ds.signal.push_back(x);
+ // parse start and stop time
+ n = line.find("start");
+ if (n != std::string::npos) {
+ str_metadata.insert(std::make_pair("start_time", parseTime(line)));
+ getline(file, line);
+ str_metadata.insert(std::make_pair("stop_time", parseTime(line)));
+ getline(file, line);
+ }
+ if (std::regex_search(line, match, reg1) && match.size() > 2) {
+ str_metadata.insert(std::make_pair(match.str(1), match.str(2)));
+ }
+ if (std::regex_search(line, match, reg2) && match.size() > 2) {
+ s = match.str(1);
+ s.erase(std::find_if_not(s.rbegin(), s.rend(), ::isspace).base(),
+ s.end());
+ num_metadata.insert(std::make_pair(s, std::stod(match.str(3))));
}
- // DNS PA detector bank has only 24 detectors
- ds.detID.resize(24);
- ds.signal.resize(24);
- m_data.push_back(ds);
+ n = line.find("DATA");
+ if (n != std::string::npos) {
+ break;
+ }
+ }
+
+ // the algorithm does not work with TOF data for the moment
+ std::map<std::string, double>::const_iterator m =
+ num_metadata.lower_bound("TOF");
+ g_log.debug() << "TOF Channels number: " << m->second << std::endl;
+ if (m->second != 1)
+ throw std::runtime_error(
+ "Algorithm does not support TOF data. TOF Channels number must be 1.");
+
+ ExpData ds;
+ ds.deterota = num_metadata["DeteRota"];
+ ds.huber = num_metadata["Huber"];
+ ds.wavelength = 10.0 * num_metadata["Lambda[nm]"];
+ ds.norm = num_metadata[m_normtype];
+
+ // read data array
+ getline(file, line);
+ int d;
+ double x;
+ while (file) {
+ file >> d >> x;
+ ds.detID.push_back(d);
+ ds.signal.push_back(x);
+ }
+ // DNS PA detector bank has only 24 detectors
+ ds.detID.resize(24);
+ ds.signal.resize(24);
+ m_data.push_back(ds);
}
} // namespace MDAlgorithms
} // namespace Mantid
-
-
-
diff --git a/Framework/MDAlgorithms/test/LoadDNSSCDTest.h b/Framework/MDAlgorithms/test/LoadDNSSCDTest.h
index cda7a1275939c903bdb95ab04678f1c1aa5b354d..4ac9c39fad1125c19a784eef072996352742272c 100644
--- a/Framework/MDAlgorithms/test/LoadDNSSCDTest.h
+++ b/Framework/MDAlgorithms/test/LoadDNSSCDTest.h
@@ -30,15 +30,14 @@ public:
// This pair of boilerplate methods prevent the suite being created statically
// This means the constructor isn't called when running other tests
static LoadDNSSCDTest *createSuite() { return new LoadDNSSCDTest(); }
- static void destroySuite( LoadDNSSCDTest *suite ) { delete suite; }
+ static void destroySuite(LoadDNSSCDTest *suite) { delete suite; }
LoadDNSSCDTest() : m_fileName("dn134011vana.d_dat") {}
- void test_Init()
- {
- LoadDNSSCD alg;
- TS_ASSERT_THROWS_NOTHING(alg.initialize());
- TS_ASSERT(alg.isInitialized());
+ void test_Init() {
+ LoadDNSSCD alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize());
+ TS_ASSERT(alg.isInitialized());
}
void test_Name() {
@@ -56,8 +55,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
TS_ASSERT(alg.isExecuted());
@@ -74,7 +75,8 @@ public:
auto &run = expinfo->run();
double d(1e-05);
TS_ASSERT_DELTA(run.getPropertyValueAsType<double>("wavelength"), 4.2, d);
- TimeSeriesProperty<double> *p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Lambda"));
+ TimeSeriesProperty<double> *p =
+ dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Lambda"));
TS_ASSERT_DELTA(p->firstValue(), 0.42, d);
p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Energy"));
TS_ASSERT_DELTA(p->firstValue(), 4.640, d);
@@ -84,9 +86,11 @@ public:
TS_ASSERT_DELTA(p->firstValue(), -8.54, d);
p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Huber"));
TS_ASSERT_DELTA(p->firstValue(), 79.0, d);
- p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Flipper_precession"));
+ p = dynamic_cast<TimeSeriesProperty<double> *>(
+ run.getProperty("Flipper_precession"));
TS_ASSERT_DELTA(p->firstValue(), 0.970, d);
- p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Flipper_z_compensation"));
+ p = dynamic_cast<TimeSeriesProperty<double> *>(
+ run.getProperty("Flipper_z_compensation"));
TS_ASSERT_DELTA(p->firstValue(), 0.400, d);
p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("C_a"));
TS_ASSERT_DELTA(p->firstValue(), 0.0, d);
@@ -100,17 +104,22 @@ public:
TS_ASSERT_DELTA(p->firstValue(), 295.0, d);
p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("T2"));
TS_ASSERT_DELTA(p->firstValue(), 296.477, d);
- p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("sample_setpoint"));
+ p = dynamic_cast<TimeSeriesProperty<double> *>(
+ run.getProperty("sample_setpoint"));
TS_ASSERT_DELTA(p->firstValue(), 295.0, d);
p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Timer"));
TS_ASSERT_DELTA(p->firstValue(), 600.0, d);
p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("Monitor"));
TS_ASSERT_DELTA(p->firstValue(), 8332872, d);
- p = dynamic_cast<TimeSeriesProperty<double> *>(run.getProperty("TOF channels"));
+ p = dynamic_cast<TimeSeriesProperty<double> *>(
+ run.getProperty("TOF channels"));
TS_ASSERT_DELTA(p->firstValue(), 1.0, d);
- TimeSeriesProperty<std::string> *s = dynamic_cast<TimeSeriesProperty<std::string> *>(run.getProperty("start_time"));
+ TimeSeriesProperty<std::string> *s =
+ dynamic_cast<TimeSeriesProperty<std::string> *>(
+ run.getProperty("start_time"));
TS_ASSERT_EQUALS(s->firstValue(), "2013-04-16T16:11:02");
- s = dynamic_cast<TimeSeriesProperty<std::string> *>(run.getProperty("stop_time"));
+ s = dynamic_cast<TimeSeriesProperty<std::string> *>(
+ run.getProperty("stop_time"));
TS_ASSERT_EQUALS(s->firstValue(), "2013-04-16T16:21:03");
AnalysisDataService::Instance().remove(outWSName);
}
@@ -123,8 +132,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
TS_ASSERT(alg.isExecuted());
@@ -147,14 +158,14 @@ public:
// test dimensions
std::vector<std::string> v = {"H", "K", "L"};
- for (auto i=0; i<3; i++) {
- auto dim = iws->getDimension(i);
- TS_ASSERT(dim);
- TS_ASSERT_EQUALS(dim->getName(), v[i]);
- TS_ASSERT_EQUALS(dim->getNBins(), 5);
- double d(1.0e-05);
- TS_ASSERT_DELTA(dim->getMinimum(), -2.991993, d);
- TS_ASSERT_DELTA(dim->getMaximum(), 2.991993, d);
+ for (auto i = 0; i < 3; i++) {
+ auto dim = iws->getDimension(i);
+ TS_ASSERT(dim);
+ TS_ASSERT_EQUALS(dim->getName(), v[i]);
+ TS_ASSERT_EQUALS(dim->getNBins(), 5);
+ double d(1.0e-05);
+ TS_ASSERT_DELTA(dim->getMinimum(), -2.991993, d);
+ TS_ASSERT_DELTA(dim->getMaximum(), 2.991993, d);
}
AnalysisDataService::Instance().remove(outWSName);
}
@@ -169,8 +180,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
@@ -205,33 +218,34 @@ public:
// 7*24 = 168
TS_ASSERT_EQUALS(events.size(), 168);
// reference vector
- const std::vector<coord_t> ref = {4366, 4366, 1, 0, -0.09776273, -0.09776273, 0.10005156,
- 31461, 31461, 1, 1, -0.15959044, -0.15959044, 0.14884006,
- 33314, 33314, 1, 2, -0.224231616093, -0.224231616093, 0.189927174618,
- 32369, 32369, 1, 3, -0.291194311172, -0.291194311172, 0.223000198347,
- 31851, 31851, 1, 4, -0.359968893923, -0.359968893923, 0.247807429194,
- 30221, 30221, 1, 5, -0.430031948245, -0.430031948245, 0.264160069153,
- 26267, 26267, 1, 6, -0.500850251989, -0.500850251989, 0.271933664761,
- 26788, 26788, 1, 7, -0.571884835101, -0.571884835101, 0.27106905426,
- 29729, 29729, 1, 8, -0.642595081514, -0.642595081514, 0.26157281786,
- 30188, 30188, 1, 9, -0.712442843555, -0.712442843555, 0.243517227652,
- 28116, 28116, 1, 10, -0.78089653758, -0.78089653758, 0.217039697581,
- 30277, 30277, 1, 11, -0.847435189645, -0.847435189645, 0.182341737639,
- 20231, 20231, 1, 12, -0.911552400429, -0.911552400429, 0.13968742025,
- 24538, 24538, 1, 13, -0.972760199244, -0.972760199244, 0.089401370527,
- 16416, 16416, 1, 14, -1.03059275778, -1.03059275778, 0.0318662956709,
- 20225, 20225, 1, 15, -1.08460993535, -1.08460993535, -0.0324799276578,
- 19957, 19957, 1, 16, -1.13440062862, -1.13440062862, -0.103147585846,
- 19570, 19570, 1, 17, -1.17958590034, -1.17958590034, -0.179598855345,
- 20743, 20743, 1, 18, -1.21982186332, -1.21982186332, -0.261251895832,
- 22758, 22758, 1, 19, -1.25480229757, -1.25480229757, -0.347485278364,
- 23001, 23001, 1, 20, -1.28426098088, -1.28426098088, -0.437642714831,
- 21836, 21836, 1, 21, -1.30797371487, -1.30797371487, -0.531038052704,
- 23877, 23877, 1, 22, -1.32576003133, -1.32576003133, -0.626960497068,
- 13340, 13340, 1, 23, -1.33748456564, -1.33748456564, -0.724680020201};
+ const std::vector<coord_t> ref = {
+ 4366, 4366, 1, 0, -0.09776273, -0.09776273, 0.10005156, 31461, 31461, 1,
+ 1, -0.15959044, -0.15959044, 0.14884006, 33314, 33314, 1, 2,
+ -0.224231616093, -0.224231616093, 0.189927174618, 32369, 32369, 1, 3,
+ -0.291194311172, -0.291194311172, 0.223000198347, 31851, 31851, 1, 4,
+ -0.359968893923, -0.359968893923, 0.247807429194, 30221, 30221, 1, 5,
+ -0.430031948245, -0.430031948245, 0.264160069153, 26267, 26267, 1, 6,
+ -0.500850251989, -0.500850251989, 0.271933664761, 26788, 26788, 1, 7,
+ -0.571884835101, -0.571884835101, 0.27106905426, 29729, 29729, 1, 8,
+ -0.642595081514, -0.642595081514, 0.26157281786, 30188, 30188, 1, 9,
+ -0.712442843555, -0.712442843555, 0.243517227652, 28116, 28116, 1, 10,
+ -0.78089653758, -0.78089653758, 0.217039697581, 30277, 30277, 1, 11,
+ -0.847435189645, -0.847435189645, 0.182341737639, 20231, 20231, 1, 12,
+ -0.911552400429, -0.911552400429, 0.13968742025, 24538, 24538, 1, 13,
+ -0.972760199244, -0.972760199244, 0.089401370527, 16416, 16416, 1, 14,
+ -1.03059275778, -1.03059275778, 0.0318662956709, 20225, 20225, 1, 15,
+ -1.08460993535, -1.08460993535, -0.0324799276578, 19957, 19957, 1, 16,
+ -1.13440062862, -1.13440062862, -0.103147585846, 19570, 19570, 1, 17,
+ -1.17958590034, -1.17958590034, -0.179598855345, 20743, 20743, 1, 18,
+ -1.21982186332, -1.21982186332, -0.261251895832, 22758, 22758, 1, 19,
+ -1.25480229757, -1.25480229757, -0.347485278364, 23001, 23001, 1, 20,
+ -1.28426098088, -1.28426098088, -0.437642714831, 21836, 21836, 1, 21,
+ -1.30797371487, -1.30797371487, -0.531038052704, 23877, 23877, 1, 22,
+ -1.32576003133, -1.32576003133, -0.626960497068, 13340, 13340, 1, 23,
+ -1.33748456564, -1.33748456564, -0.724680020201};
double d(1.0e-06);
- for (auto i=0; i<168; i++){
- TS_ASSERT_DELTA(events[i], ref[i], d);
+ for (auto i = 0; i < 168; i++) {
+ TS_ASSERT_DELTA(events[i], ref[i], d);
}
AnalysisDataService::Instance().remove(outWSName);
@@ -245,8 +259,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
TS_ASSERT(alg.isExecuted());
@@ -269,14 +285,14 @@ public:
// test dimensions
std::vector<std::string> v = {"H", "K", "L"};
- for (auto i=0; i<3; i++) {
- auto dim = nws->getDimension(i);
- TS_ASSERT(dim);
- TS_ASSERT_EQUALS(dim->getName(), v[i]);
- TS_ASSERT_EQUALS(dim->getNBins(), 5);
- double d(1.0e-05);
- TS_ASSERT_DELTA(dim->getMinimum(), -2.991993, d);
- TS_ASSERT_DELTA(dim->getMaximum(), 2.991993, d);
+ for (auto i = 0; i < 3; i++) {
+ auto dim = nws->getDimension(i);
+ TS_ASSERT(dim);
+ TS_ASSERT_EQUALS(dim->getName(), v[i]);
+ TS_ASSERT_EQUALS(dim->getNBins(), 5);
+ double d(1.0e-05);
+ TS_ASSERT_DELTA(dim->getMinimum(), -2.991993, d);
+ TS_ASSERT_DELTA(dim->getMaximum(), 2.991993, d);
}
AnalysisDataService::Instance().remove(normWSName);
}
@@ -291,8 +307,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
@@ -327,33 +345,37 @@ public:
// 7*24 = 168
TS_ASSERT_EQUALS(events.size(), 168);
// reference vector
- const std::vector<coord_t> ref = {8332872, 8332872, 1, 0, -0.09776273, -0.09776273, 0.10005156,
- 8332872, 8332872, 1, 1, -0.15959044, -0.15959044, 0.14884006,
- 8332872, 8332872, 1, 2, -0.224231616093, -0.224231616093, 0.189927174618,
- 8332872, 8332872, 1, 3, -0.291194311172, -0.291194311172, 0.223000198347,
- 8332872, 8332872, 1, 4, -0.359968893923, -0.359968893923, 0.247807429194,
- 8332872, 8332872, 1, 5, -0.430031948245, -0.430031948245, 0.264160069153,
- 8332872, 8332872, 1, 6, -0.500850251989, -0.500850251989, 0.271933664761,
- 8332872, 8332872, 1, 7, -0.571884835101, -0.571884835101, 0.27106905426,
- 8332872, 8332872, 1, 8, -0.642595081514, -0.642595081514, 0.26157281786,
- 8332872, 8332872, 1, 9, -0.712442843555, -0.712442843555, 0.243517227652,
- 8332872, 8332872, 1, 10, -0.78089653758, -0.78089653758, 0.217039697581,
- 8332872, 8332872, 1, 11, -0.847435189645, -0.847435189645, 0.182341737639,
- 8332872, 8332872, 1, 12, -0.911552400429, -0.911552400429, 0.13968742025,
- 8332872, 8332872, 1, 13, -0.972760199244, -0.972760199244, 0.089401370527,
- 8332872, 8332872, 1, 14, -1.03059275778, -1.03059275778, 0.0318662956709,
- 8332872, 8332872, 1, 15, -1.08460993535, -1.08460993535, -0.0324799276578,
- 8332872, 8332872, 1, 16, -1.13440062862, -1.13440062862, -0.103147585846,
- 8332872, 8332872, 1, 17, -1.17958590034, -1.17958590034, -0.179598855345,
- 8332872, 8332872, 1, 18, -1.21982186332, -1.21982186332, -0.261251895832,
- 8332872, 8332872, 1, 19, -1.25480229757, -1.25480229757, -0.347485278364,
- 8332872, 8332872, 1, 20, -1.28426098088, -1.28426098088, -0.437642714831,
- 8332872, 8332872, 1, 21, -1.30797371487, -1.30797371487, -0.531038052704,
- 8332872, 8332872, 1, 22, -1.32576003133, -1.32576003133, -0.626960497068,
- 8332872, 8332872, 1, 23, -1.33748456564, -1.33748456564, -0.724680020201};
+ const std::vector<coord_t> ref = {
+ 8332872, 8332872, 1, 0, -0.09776273, -0.09776273, 0.10005156, 8332872,
+ 8332872, 1, 1, -0.15959044, -0.15959044, 0.14884006, 8332872, 8332872,
+ 1, 2, -0.224231616093, -0.224231616093, 0.189927174618, 8332872,
+ 8332872, 1, 3, -0.291194311172, -0.291194311172, 0.223000198347,
+ 8332872, 8332872, 1, 4, -0.359968893923, -0.359968893923,
+ 0.247807429194, 8332872, 8332872, 1, 5, -0.430031948245,
+ -0.430031948245, 0.264160069153, 8332872, 8332872, 1, 6,
+ -0.500850251989, -0.500850251989, 0.271933664761, 8332872, 8332872, 1,
+ 7, -0.571884835101, -0.571884835101, 0.27106905426, 8332872, 8332872, 1,
+ 8, -0.642595081514, -0.642595081514, 0.26157281786, 8332872, 8332872, 1,
+ 9, -0.712442843555, -0.712442843555, 0.243517227652, 8332872, 8332872,
+ 1, 10, -0.78089653758, -0.78089653758, 0.217039697581, 8332872, 8332872,
+ 1, 11, -0.847435189645, -0.847435189645, 0.182341737639, 8332872,
+ 8332872, 1, 12, -0.911552400429, -0.911552400429, 0.13968742025,
+ 8332872, 8332872, 1, 13, -0.972760199244, -0.972760199244,
+ 0.089401370527, 8332872, 8332872, 1, 14, -1.03059275778, -1.03059275778,
+ 0.0318662956709, 8332872, 8332872, 1, 15, -1.08460993535,
+ -1.08460993535, -0.0324799276578, 8332872, 8332872, 1, 16,
+ -1.13440062862, -1.13440062862, -0.103147585846, 8332872, 8332872, 1,
+ 17, -1.17958590034, -1.17958590034, -0.179598855345, 8332872, 8332872,
+ 1, 18, -1.21982186332, -1.21982186332, -0.261251895832, 8332872,
+ 8332872, 1, 19, -1.25480229757, -1.25480229757, -0.347485278364,
+ 8332872, 8332872, 1, 20, -1.28426098088, -1.28426098088,
+ -0.437642714831, 8332872, 8332872, 1, 21, -1.30797371487,
+ -1.30797371487, -0.531038052704, 8332872, 8332872, 1, 22,
+ -1.32576003133, -1.32576003133, -0.626960497068, 8332872, 8332872, 1,
+ 23, -1.33748456564, -1.33748456564, -0.724680020201};
double d(1.0e-06);
- for (auto i=0; i<168; i++){
- TS_ASSERT_DELTA(events[i], ref[i], d);
+ for (auto i = 0; i < 168; i++) {
+ TS_ASSERT_DELTA(events[i], ref[i], d);
}
AnalysisDataService::Instance().remove(normWSName);
@@ -369,8 +391,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "time"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
@@ -405,33 +429,34 @@ public:
// 7*24 = 168
TS_ASSERT_EQUALS(events.size(), 168);
// reference vector
- const std::vector<coord_t> ref = {600, 0, 1, 0, -0.09776273, -0.09776273, 0.10005156,
- 600, 0, 1, 1, -0.15959044, -0.15959044, 0.14884006,
- 600, 0, 1, 2, -0.224231616093, -0.224231616093, 0.189927174618,
- 600, 0, 1, 3, -0.291194311172, -0.291194311172, 0.223000198347,
- 600, 0, 1, 4, -0.359968893923, -0.359968893923, 0.247807429194,
- 600, 0, 1, 5, -0.430031948245, -0.430031948245, 0.264160069153,
- 600, 0, 1, 6, -0.500850251989, -0.500850251989, 0.271933664761,
- 600, 0, 1, 7, -0.571884835101, -0.571884835101, 0.27106905426,
- 600, 0, 1, 8, -0.642595081514, -0.642595081514, 0.26157281786,
- 600, 0, 1, 9, -0.712442843555, -0.712442843555, 0.243517227652,
- 600, 0, 1, 10, -0.78089653758, -0.78089653758, 0.217039697581,
- 600, 0, 1, 11, -0.847435189645, -0.847435189645, 0.182341737639,
- 600, 0, 1, 12, -0.911552400429, -0.911552400429, 0.13968742025,
- 600, 0, 1, 13, -0.972760199244, -0.972760199244, 0.089401370527,
- 600, 0, 1, 14, -1.03059275778, -1.03059275778, 0.0318662956709,
- 600, 0, 1, 15, -1.08460993535, -1.08460993535, -0.0324799276578,
- 600, 0, 1, 16, -1.13440062862, -1.13440062862, -0.103147585846,
- 600, 0, 1, 17, -1.17958590034, -1.17958590034, -0.179598855345,
- 600, 0, 1, 18, -1.21982186332, -1.21982186332, -0.261251895832,
- 600, 0, 1, 19, -1.25480229757, -1.25480229757, -0.347485278364,
- 600, 0, 1, 20, -1.28426098088, -1.28426098088, -0.437642714831,
- 600, 0, 1, 21, -1.30797371487, -1.30797371487, -0.531038052704,
- 600, 0, 1, 22, -1.32576003133, -1.32576003133, -0.626960497068,
- 600, 0, 1, 23, -1.33748456564, -1.33748456564, -0.724680020201};
+ const std::vector<coord_t> ref = {
+ 600, 0, 1, 0, -0.09776273, -0.09776273, 0.10005156, 600, 0, 1, 1,
+ -0.15959044, -0.15959044, 0.14884006, 600, 0, 1, 2, -0.224231616093,
+ -0.224231616093, 0.189927174618, 600, 0, 1, 3, -0.291194311172,
+ -0.291194311172, 0.223000198347, 600, 0, 1, 4, -0.359968893923,
+ -0.359968893923, 0.247807429194, 600, 0, 1, 5, -0.430031948245,
+ -0.430031948245, 0.264160069153, 600, 0, 1, 6, -0.500850251989,
+ -0.500850251989, 0.271933664761, 600, 0, 1, 7, -0.571884835101,
+ -0.571884835101, 0.27106905426, 600, 0, 1, 8, -0.642595081514,
+ -0.642595081514, 0.26157281786, 600, 0, 1, 9, -0.712442843555,
+ -0.712442843555, 0.243517227652, 600, 0, 1, 10, -0.78089653758,
+ -0.78089653758, 0.217039697581, 600, 0, 1, 11, -0.847435189645,
+ -0.847435189645, 0.182341737639, 600, 0, 1, 12, -0.911552400429,
+ -0.911552400429, 0.13968742025, 600, 0, 1, 13, -0.972760199244,
+ -0.972760199244, 0.089401370527, 600, 0, 1, 14, -1.03059275778,
+ -1.03059275778, 0.0318662956709, 600, 0, 1, 15, -1.08460993535,
+ -1.08460993535, -0.0324799276578, 600, 0, 1, 16, -1.13440062862,
+ -1.13440062862, -0.103147585846, 600, 0, 1, 17, -1.17958590034,
+ -1.17958590034, -0.179598855345, 600, 0, 1, 18, -1.21982186332,
+ -1.21982186332, -0.261251895832, 600, 0, 1, 19, -1.25480229757,
+ -1.25480229757, -0.347485278364, 600, 0, 1, 20, -1.28426098088,
+ -1.28426098088, -0.437642714831, 600, 0, 1, 21, -1.30797371487,
+ -1.30797371487, -0.531038052704, 600, 0, 1, 22, -1.32576003133,
+ -1.32576003133, -0.626960497068, 600, 0, 1, 23, -1.33748456564,
+ -1.33748456564, -0.724680020201};
double d(1.0e-06);
- for (auto i=0; i<168; i++){
- TS_ASSERT_DELTA(events[i], ref[i], d);
+ for (auto i = 0; i < 168; i++) {
+ TS_ASSERT_DELTA(events[i], ref[i], d);
}
AnalysisDataService::Instance().remove(normWSName);
@@ -446,8 +471,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("SaveHuberTo", tWSName));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
@@ -456,7 +483,8 @@ public:
// Retrieve the workspace from data service.
ITableWorkspace_sptr tws;
TS_ASSERT_THROWS_NOTHING(
- tws = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>(tWSName));
+ tws = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>(
+ tWSName));
TS_ASSERT(tws);
// check that workspace has 1 row and 1 column
@@ -477,13 +505,14 @@ public:
std::string tWSName1("LoadDNSSCDTest_Huber_load");
// create a test table workspace
- ITableWorkspace_sptr huberWS = WorkspaceFactory::Instance().createTable("TableWorkspace");
+ ITableWorkspace_sptr huberWS =
+ WorkspaceFactory::Instance().createTable("TableWorkspace");
huberWS->addColumn("double", "Huber(degrees)");
const std::vector<double> vals = {77.0, 92.0, 122.0};
auto n = vals.size();
- for (size_t i=0; i< n; i++) {
- huberWS->appendRow();
- huberWS->cell<double>(i, 0) = vals[i];
+ for (size_t i = 0; i < n; i++) {
+ huberWS->appendRow();
+ huberWS->cell<double>(i, 0) = vals[i];
}
AnalysisDataService::Instance().add(tWSName1, huberWS);
@@ -492,8 +521,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("LoadHuberFrom", tWSName1));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("SaveHuberTo", tWSName2));
@@ -509,12 +540,13 @@ public:
TS_ASSERT_EQUALS(iws->getNumDims(), 3);
// data should be replicated for each huber value
- TS_ASSERT_EQUALS(iws->getNPoints(), 24*n);
+ TS_ASSERT_EQUALS(iws->getNPoints(), 24 * n);
// Retrieve the table workspace from data service.
ITableWorkspace_sptr tws;
TS_ASSERT_THROWS_NOTHING(
- tws = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>(tWSName2));
+ tws = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>(
+ tWSName2));
TS_ASSERT(tws);
// check that workspace has 1 row and 1 column
@@ -524,8 +556,8 @@ public:
TS_ASSERT_EQUALS(tws->getColumnNames(), columnNames);
// test the values
- for (size_t i=0; i<n; i++)
- TS_ASSERT_DELTA(tws->cell<double>(i, 0), vals[i], 1.0e-06);
+ for (size_t i = 0; i < n; i++)
+ TS_ASSERT_DELTA(tws->cell<double>(i, 0), vals[i], 1.0e-06);
AnalysisDataService::Instance().remove(tWSName1);
AnalysisDataService::Instance().remove(tWSName2);
AnalysisDataService::Instance().remove(outWSName);
@@ -541,8 +573,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", m_fileName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("a", 6.84));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("b", 6.84));
@@ -578,16 +612,17 @@ public:
// 7*7 = 49
TS_ASSERT_EQUALS(events.size(), 49);
// reference vector
- const std::vector<coord_t> ref = {32369, 32369, 1, 3, -0.291194311172, -0.291194311172, 0.223000198347,
- 31851, 31851, 1, 4, -0.359968893923, -0.359968893923, 0.247807429194,
- 30221, 30221, 1, 5, -0.430031948245, -0.430031948245, 0.264160069153,
- 26267, 26267, 1, 6, -0.500850251989, -0.500850251989, 0.271933664761,
- 26788, 26788, 1, 7, -0.571884835101, -0.571884835101, 0.27106905426,
- 29729, 29729, 1, 8, -0.642595081514, -0.642595081514, 0.26157281786,
- 30188, 30188, 1, 9, -0.712442843555, -0.712442843555, 0.243517227652};
+ const std::vector<coord_t> ref = {
+ 32369, 32369, 1, 3, -0.291194311172, -0.291194311172, 0.223000198347,
+ 31851, 31851, 1, 4, -0.359968893923, -0.359968893923, 0.247807429194,
+ 30221, 30221, 1, 5, -0.430031948245, -0.430031948245, 0.264160069153,
+ 26267, 26267, 1, 6, -0.500850251989, -0.500850251989, 0.271933664761,
+ 26788, 26788, 1, 7, -0.571884835101, -0.571884835101, 0.27106905426,
+ 29729, 29729, 1, 8, -0.642595081514, -0.642595081514, 0.26157281786,
+ 30188, 30188, 1, 9, -0.712442843555, -0.712442843555, 0.243517227652};
double d(1.0e-06);
- for (auto i=0; i<49; i++){
- TS_ASSERT_DELTA(events[i], ref[i], d);
+ for (auto i = 0; i < 49; i++) {
+ TS_ASSERT_DELTA(events[i], ref[i], d);
}
AnalysisDataService::Instance().remove(outWSName);
@@ -616,8 +651,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", filenames));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
// algorithm should throw only if no valid files is provided
@@ -648,8 +685,10 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filenames", "dnstof.d_dat"));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", outWSName));
- TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("NormalizationWorkspace", normWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("OutputWorkspace", outWSName));
+ TS_ASSERT_THROWS_NOTHING(
+ alg.setPropertyValue("NormalizationWorkspace", normWSName));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("Normalization", "monitor"));
// algorithm should throw if no valid files is provided
@@ -661,5 +700,4 @@ private:
std::string m_fileName;
};
-
#endif /* MANTID_MDALGORITHMS_LOADDNSSCDEWEST_H_ */