LoadILLSANSTest.h 15.2 KB
Newer Older
1
2
3
// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
4
5
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
6
// SPDX - License - Identifier: GPL - 3.0 +
7
#pragma once
8
9
10

#include <cxxtest/TestSuite.h>

11
#include "MantidAPI/AnalysisDataService.h"
LamarMoore's avatar
LamarMoore committed
12
#include "MantidAPI/Axis.h"
13
#include "MantidAPI/MatrixWorkspace.h"
14
#include "MantidDataHandling/LoadILLSANS.h"
15
16
17
18
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidKernel/ConfigService.h"
19
#include "MantidKernel/Unit.h"
20
#include "MantidTypes/Core/DateAndTimeHelpers.h"
21

LamarMoore's avatar
LamarMoore committed
22
using Mantid::API::AnalysisDataService;
23
using Mantid::API::Axis;
24
using Mantid::API::MatrixWorkspace_const_sptr;
LamarMoore's avatar
LamarMoore committed
25
using Mantid::DataHandling::LoadILLSANS;
26
using Mantid::Geometry::IComponent_const_sptr;
27
using Mantid::Geometry::IDetector_const_sptr;
28
using Mantid::Geometry::Instrument;
LamarMoore's avatar
LamarMoore committed
29
30
31
using Mantid::Kernel::ConfigService;
using Mantid::Kernel::Unit;
using Mantid::Kernel::V3D;
32
using detid2det_map = std::map<Mantid::detid_t, IDetector_const_sptr>;
33

34
class LoadILLSANSTest : public CxxTest::TestSuite {
35
public:
36
37
38
39
40
  // This pair of boilerplate methods prevent the suite being created statically
  // This means the constructor isn't called when running other tests
  static LoadILLSANSTest *createSuite() { return new LoadILLSANSTest(); }
  static void destroySuite(LoadILLSANSTest *suite) { delete suite; }

41
42
  LoadILLSANSTest() {
    ConfigService::Instance().appendDataSearchSubDir("ILL/D11/");
43
    ConfigService::Instance().appendDataSearchSubDir("ILL/D11B/");
44
    ConfigService::Instance().appendDataSearchSubDir("ILL/D22/");
45
    ConfigService::Instance().appendDataSearchSubDir("ILL/D22B/");
46
47
48
49
    ConfigService::Instance().appendDataSearchSubDir("ILL/D33/");
    ConfigService::Instance().appendDataSearchSubDir("ILL/D16/");
    ConfigService::Instance().setFacility("ILL");
  }
50

Gagik Vardanyan's avatar
Gagik Vardanyan committed
51
  void tearDown() override { AnalysisDataService::Instance().clear(); }
52

53
  void test_name() {
54
55
56
57
    LoadILLSANS alg;
    TS_ASSERT_EQUALS(alg.name(), "LoadILLSANS");
  }

58
  void test_version() {
59
60
61
62
    LoadILLSANS alg;
    TS_ASSERT_EQUALS(alg.version(), 1);
  }

63
  void test_init() {
64
65
66
67
68
    LoadILLSANS alg;
    TS_ASSERT_THROWS_NOTHING(alg.initialize())
    TS_ASSERT(alg.isInitialized())
  }

69
  void test_D11() {
70
71
72
73
74
75
76
77
78
79
    LoadILLSANS alg;
    alg.setChild(true);
    alg.initialize();
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filename", "010560.nxs"))
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", "__unused_for_child"))
    TS_ASSERT_THROWS_NOTHING(alg.execute())
    TS_ASSERT(alg.isExecuted())
    MatrixWorkspace_const_sptr outputWS = alg.getProperty("OutputWorkspace");
    TS_ASSERT(outputWS)
80
    TS_ASSERT_EQUALS(outputWS->getNumberHistograms(), 128 * 128 + 2)
81
    TS_ASSERT_EQUALS(outputWS->blocksize(), 1)
82
83
    TS_ASSERT(outputWS->detectorInfo().isMonitor(128 * 128))
    TS_ASSERT(outputWS->detectorInfo().isMonitor(128 * 128 + 1))
84
85
86
    TS_ASSERT(outputWS->isHistogramData())
    TS_ASSERT(!outputWS->isDistribution())
    const auto &instrument = outputWS->getInstrument();
87
88
    IComponent_const_sptr component =
        instrument->getComponentByName("detector");
89
90
    V3D pos = component->getPos();
    TS_ASSERT_DELTA(pos.Z(), 20.007, 1E-3)
91
92
93
    const auto &xAxis = outputWS->x(0).rawData();
    const auto &spec6 = outputWS->y(6).rawData();
    const auto &err6 = outputWS->e(6).rawData();
94
    TS_ASSERT_EQUALS(xAxis.size(), 2)
95
96
    TS_ASSERT_DELTA(xAxis[0], 5.73, 1E-5)
    TS_ASSERT_DELTA(xAxis[1], 6.27, 1E-5)
97
    TS_ASSERT_EQUALS(spec6[0], 20)
98
99
100
    TS_ASSERT_DELTA(err6[0], sqrt(20), 1E-5)
    const auto unit = outputWS->getAxis(0)->unit()->unitID();
    TS_ASSERT_EQUALS(unit, "Wavelength");
101
    checkTimeFormat(outputWS);
102
  }
103

104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
  void test_D11B() {
    LoadILLSANS alg;
    alg.setChild(true);
    alg.initialize();
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filename", "027194.nxs"))
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", "__unused_for_child"))
    TS_ASSERT_THROWS_NOTHING(alg.execute())
    TS_ASSERT(alg.isExecuted())
    MatrixWorkspace_const_sptr outputWS = alg.getProperty("OutputWorkspace");
    TS_ASSERT(outputWS)
    TS_ASSERT_EQUALS(outputWS->getNumberHistograms(),
                     192 * 256 + 2 * 32 * 256 + 2)
    TS_ASSERT_EQUALS(outputWS->blocksize(), 1)
    TS_ASSERT(outputWS->detectorInfo().isMonitor(192 * 256 + 2 * 32 * 256))
    TS_ASSERT(outputWS->detectorInfo().isMonitor(192 * 256 + 2 * 32 * 256 + 1))
    TS_ASSERT(outputWS->isHistogramData())
    TS_ASSERT(!outputWS->isDistribution())
    const auto &instrument = outputWS->getInstrument();

    IComponent_const_sptr component =
125
        instrument->getComponentByName("detector_center");
126
    V3D pos = component->getPos();
127
    TS_ASSERT_DELTA(pos.Z(), 8.9274824298, 1E-3)
128
129
130

    component = instrument->getComponentByName("detector_left");
    pos = component->getPos();
131
    TS_ASSERT_DELTA(pos.Z(), 8.82248, 1E-5)
132
133
134

    component = instrument->getComponentByName("detector_right");
    pos = component->getPos();
135
    TS_ASSERT_DELTA(pos.Z(), 8.82248, 1E-5)
136
137
138
139
140
141
142
143
144
145
146
147
148
149

    const auto &xAxis = outputWS->x(0).rawData();
    const auto &spec = outputWS->y(3630).rawData();
    const auto &err = outputWS->e(3630).rawData();
    TS_ASSERT_EQUALS(xAxis.size(), 2)
    TS_ASSERT_DELTA(xAxis[0], 6.685, 1E-5)
    TS_ASSERT_DELTA(xAxis[1], 7.315, 1E-5)
    TS_ASSERT_EQUALS(spec[0], 246)
    TS_ASSERT_DELTA(err[0], sqrt(246), 1E-5)
    const auto unit = outputWS->getAxis(0)->unit()->unitID();
    TS_ASSERT_EQUALS(unit, "Wavelength");
    checkTimeFormat(outputWS);
  }

150
  void test_D22() {
151
152
153
154
155
156
157
158
159
160
    LoadILLSANS alg;
    alg.setChild(true);
    alg.initialize();
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filename", "192068.nxs"))
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", "__unused_for_child"))
    TS_ASSERT_THROWS_NOTHING(alg.execute())
    TS_ASSERT(alg.isExecuted())
    MatrixWorkspace_const_sptr outputWS = alg.getProperty("OutputWorkspace");
    TS_ASSERT(outputWS)
161
    TS_ASSERT_EQUALS(outputWS->getNumberHistograms(), 128 * 256 + 2)
162
    TS_ASSERT_EQUALS(outputWS->blocksize(), 1)
163
164
    TS_ASSERT(outputWS->detectorInfo().isMonitor(128 * 256))
    TS_ASSERT(outputWS->detectorInfo().isMonitor(128 * 256 + 1))
165
166
167
    TS_ASSERT(outputWS->isHistogramData())
    TS_ASSERT(!outputWS->isDistribution())
    const auto &instrument = outputWS->getInstrument();
168
169
    IComponent_const_sptr component =
        instrument->getComponentByName("detector");
170
171
    V3D pos = component->getPos();
    TS_ASSERT_DELTA(pos.Z(), 8, 0.01)
172
    TS_ASSERT_DELTA(pos.X(), -0.35, 0.01)
173
174
175
    const auto &xAxis = outputWS->x(0).rawData();
    const auto &spec6 = outputWS->y(6).rawData();
    const auto &err6 = outputWS->e(6).rawData();
176
    TS_ASSERT_EQUALS(xAxis.size(), 2)
177
178
    TS_ASSERT_DELTA(xAxis[0], 4.75, 1E-5)
    TS_ASSERT_DELTA(xAxis[1], 5.25, 1E-5)
179
    TS_ASSERT_EQUALS(spec6[0], 45)
180
181
182
    TS_ASSERT_DELTA(err6[0], sqrt(45), 1E-5)
    const auto unit = outputWS->getAxis(0)->unit()->unitID();
    TS_ASSERT_EQUALS(unit, "Wavelength");
183
    checkTimeFormat(outputWS);
184
  }
185

Gagik Vardanyan's avatar
Gagik Vardanyan committed
186
  void trest_d22B() {
187
188
189
    LoadILLSANS alg;
    alg.setChild(true);
    alg.initialize();
Gagik Vardanyan's avatar
Gagik Vardanyan committed
190
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filename", "000180.nxs"))
191
192
193
194
195
196
197
198
199
200
201
202
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", "__unused_for_child"))
    TS_ASSERT_THROWS_NOTHING(alg.execute())
    TS_ASSERT(alg.isExecuted())
    MatrixWorkspace_const_sptr outputWS = alg.getProperty("OutputWorkspace");
    TS_ASSERT(outputWS)
    TS_ASSERT_EQUALS(outputWS->getNumberHistograms(), 128 * 256 + 96 * 256 + 2)
    TS_ASSERT_EQUALS(outputWS->blocksize(), 1)
    TS_ASSERT(outputWS->detectorInfo().isMonitor(128 * 256 + 96 * 256))
    TS_ASSERT(outputWS->detectorInfo().isMonitor(128 * 256 + 96 * 256 + 1))
    TS_ASSERT(outputWS->isHistogramData())
    TS_ASSERT(!outputWS->isDistribution())
Gagik Vardanyan's avatar
Gagik Vardanyan committed
203
    TS_ASSERT_EQUALS(outputWS->getAxis(0)->unit()->unitID(), "Wavelength");
204
    const auto &instrument = outputWS->getInstrument();
Gagik Vardanyan's avatar
Gagik Vardanyan committed
205
    const auto &run = outputWS->run();
206
207
208

    IComponent_const_sptr comp = instrument->getComponentByName("detector");
    V3D pos = comp->getPos();
Gagik Vardanyan's avatar
Gagik Vardanyan committed
209
210
211
212
213
214
215
216
217
    TS_ASSERT(run.hasProperty("Detector 2.det2_calc"))
    double det2_calc = run.getLogAsSingleValue("Detector 2.det2_calc");
    TS_ASSERT(run.hasProperty("Detector_2.dtr2_actual"))
    double dtr2_act = run.getLogAsSingleValue("Detector_2.dtr2_actual");
    TS_ASSERT_DELTA(pos.Z(), det2_calc, 1E-6)
    TS_ASSERT_DELTA(pos.X(), -dtr2_act / 1000., 1E-6)
    TS_ASSERT(run.hasProperty("L2"))
    double l2 = run.getLogAsSingleValue("L2");
    TS_ASSERT_DELTA(l2, det2_calc, 1E-6)
218
219
220

    comp = instrument->getComponentByName("detector_right");
    pos = comp->getPos();
Gagik Vardanyan's avatar
Gagik Vardanyan committed
221
222
223
224
225
226
    TS_ASSERT(run.hasProperty("Detector 1.det1_calc"))
    double det1_calc = run.getLogAsSingleValue("Detector 1.det1_calc");
    TS_ASSERT(run.hasProperty("Detector_1.dtr1_actual"))
    double dtr1_act = run.getLogAsSingleValue("Detector_1.dtr1_actual");
    TS_ASSERT_DELTA(pos.Z(), det1_calc, 1E-6)
    TS_ASSERT_DELTA(pos.X(), -dtr1_act / 1000., 1E-6)
227
228
229
230

    checkTimeFormat(outputWS);
  }

231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
  void test_D16() {
    LoadILLSANS alg;
    alg.setChild(true);
    alg.initialize();
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filename", "218356.nxs"));
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", "__unused_for_child"));
    TS_ASSERT_THROWS_NOTHING(alg.execute());
    TS_ASSERT(alg.isExecuted());
    MatrixWorkspace_const_sptr outputWS = alg.getProperty("OutputWorkspace");
    TS_ASSERT(outputWS);

    TS_ASSERT(outputWS->detectorInfo().isMonitor(320 * 320));
    TS_ASSERT(outputWS->detectorInfo().isMonitor(320 * 320 + 1));

    const auto &instrument = outputWS->getInstrument();
    IComponent_const_sptr component =
        instrument->getComponentByName("detector");
    V3D pos = component->getPos();
    V3D origin(0, 0, 0);
    TS_ASSERT_DELTA(pos.distance(origin), 1, 1E-5);
252
253
    TS_ASSERT_DELTA(pos.X(), -0.17365, 1E-5); // sin(10)
    TS_ASSERT_DELTA(pos.Z(), 0.98481, 1E-5);  // cos(10)
254
255
256
257
258
259
260

    Mantid::detid_t bl_id, tr_id;
    instrument->getMinMaxDetectorIDs(bl_id, tr_id);

    detid2det_map det_map;
    instrument->getDetectors(det_map);

261
262
    IDetector_const_sptr bottom_right_pixel = det_map[bl_id];
    IDetector_const_sptr top_left_pixel = det_map[320 * 320 - 1];
263

264
265
    V3D br_pos = bottom_right_pixel->getPos();
    V3D tl_pos = top_left_pixel->getPos();
266
267

    // check the detector has 10 degrees angle
268
269
    TS_ASSERT_DELTA(br_pos.distance(origin), 1.02512, 1E-5);
    TS_ASSERT_DELTA(tl_pos.distance(origin), 1.02512, 1E-5);
270

271
272
273
274
    TS_ASSERT_DELTA(tl_pos.X(), -0.33073, 1E-5);
    TS_ASSERT_DELTA(tl_pos.Z(), 0.95711, 1E-5);
    TS_ASSERT_DELTA(br_pos.X(), -0.01657, 1E-5);
    TS_ASSERT_DELTA(br_pos.Z(), 1.01250, 1E-5);
275
276
277
278
279

    const auto &xAxis = outputWS->x(0).rawData();
    const auto &spec = outputWS->y(51972).rawData();
    const auto &err = outputWS->e(51972).rawData();
    TS_ASSERT_EQUALS(xAxis.size(), 2)
280
281
    TS_ASSERT_DELTA(xAxis[0], 6.965, 1E-3)
    TS_ASSERT_DELTA(xAxis[1], 7.035, 1E-3)
282
283
    TS_ASSERT_EQUALS(spec[0], 17)
    TS_ASSERT_DELTA(err[0], sqrt(17), 1E-5)
284
    checkTimeFormat(outputWS);
285
286
  }

287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
  void test_D33() {
    LoadILLSANS alg;
    alg.setChild(true);
    alg.initialize();
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filename", "002294.nxs"))
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", "__unused_for_child"))
    TS_ASSERT_THROWS_NOTHING(alg.execute())
    TS_ASSERT(alg.isExecuted())
    MatrixWorkspace_const_sptr outputWS = alg.getProperty("OutputWorkspace");
    TS_ASSERT(outputWS)
    TS_ASSERT_EQUALS(outputWS->getNumberHistograms(), 256 * 256 + 2)
    TS_ASSERT_EQUALS(outputWS->blocksize(), 1)
    TS_ASSERT(outputWS->detectorInfo().isMonitor(256 * 256))
    TS_ASSERT(outputWS->detectorInfo().isMonitor(256 * 256 + 1))
    TS_ASSERT(outputWS->isHistogramData())
    TS_ASSERT(!outputWS->isDistribution())
    const auto &xAxis = outputWS->x(0).rawData();
    const auto &spec = outputWS->y(15947).rawData();
    const auto &err = outputWS->e(15947).rawData();
    TS_ASSERT_EQUALS(xAxis.size(), 2)
    TS_ASSERT_DELTA(xAxis[0], 9.5, 1E-3)
    TS_ASSERT_DELTA(xAxis[1], 10.5, 1E-3)
    TS_ASSERT_EQUALS(spec[0], 220)
    TS_ASSERT_DELTA(err[0], sqrt(220), 1E-5)
    const auto &instrument = outputWS->getInstrument();
    IComponent_const_sptr back =
        instrument->getComponentByName("back_detector");
    TS_ASSERT_EQUALS(back->getPos(), V3D(0, 0, 10.1128));
    IComponent_const_sptr right =
        instrument->getComponentByName("front_detector_right");
    TS_ASSERT_EQUALS(right->getPos(), V3D(-0.41, 0, 1.4968));
    IComponent_const_sptr left =
        instrument->getComponentByName("front_detector_left");
    TS_ASSERT_EQUALS(left->getPos(), V3D(0.41, 0, 1.4968));
    IComponent_const_sptr top =
        instrument->getComponentByName("front_detector_top");
    TS_ASSERT_EQUALS(top->getPos(), V3D(0, 0.41, 1.3118));
    IComponent_const_sptr bottom =
        instrument->getComponentByName("front_detector_bottom");
    TS_ASSERT_EQUALS(bottom->getPos(), V3D(0, -0.41, 1.3118));
    const auto unit = outputWS->getAxis(0)->unit()->unitID();
    TS_ASSERT_EQUALS(unit, "Wavelength");
330
    checkTimeFormat(outputWS);
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
  }

  void test_D33_TOF() {
    LoadILLSANS alg;
    alg.setChild(true);
    alg.initialize();
    TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("Filename", "042610.nxs"))
    TS_ASSERT_THROWS_NOTHING(
        alg.setPropertyValue("OutputWorkspace", "__unused_for_child"))
    TS_ASSERT_THROWS_NOTHING(alg.execute())
    TS_ASSERT(alg.isExecuted())
    MatrixWorkspace_const_sptr outputWS = alg.getProperty("OutputWorkspace");
    TS_ASSERT(outputWS)
    TS_ASSERT_EQUALS(outputWS->getNumberHistograms(), 256 * 256 + 2)
    TS_ASSERT_EQUALS(outputWS->blocksize(), 200)
    TS_ASSERT(outputWS->detectorInfo().isMonitor(256 * 256))
    TS_ASSERT(outputWS->detectorInfo().isMonitor(256 * 256 + 1))
    TS_ASSERT(outputWS->isHistogramData())
    TS_ASSERT(!outputWS->isDistribution())
    const auto &x = outputWS->x(0).rawData();
    TS_ASSERT_DELTA(x[0], 0.04969, 1E-5)
    TS_ASSERT_DELTA(x[1], 0.14873, 1E-5)
    TS_ASSERT_DELTA(x[200], 19.85713, 1E-5)
    const auto &run = outputWS->run();
    TS_ASSERT(run.hasProperty("tof_mode"))
    const auto tof = run.getLogData("tof_mode");
    TS_ASSERT_EQUALS(tof->value(), "TOF");
    const auto unit = outputWS->getAxis(0)->unit()->unitID();
    TS_ASSERT_EQUALS(unit, "Wavelength");
360
361
362
363
    checkTimeFormat(outputWS);
  }

  void checkTimeFormat(MatrixWorkspace_const_sptr outputWS) {
364
    TS_ASSERT(outputWS->run().hasProperty("start_time"));
365
    TS_ASSERT(Mantid::Types::Core::DateAndTimeHelpers::stringIsISO8601(
366
        outputWS->run().getProperty("start_time")->value()));
367
  }
368
369
};

370
371
372
class LoadILLSANSTestPerformance : public CxxTest::TestSuite {
public:
  void setUp() override {
373
374
375
376
    m_alg.initialize();
    m_alg.setChild(true);
    m_alg.setPropertyValue("Filename", "ILL/D33/042610.nxs");
    m_alg.setPropertyValue("OutputWorkspace", "__unused_for_child");
377
378
  }
  void testLoadILLSANSPerformance() {
379
380
    for (int i = 0; i < 10; ++i) {
      TS_ASSERT_THROWS_NOTHING(m_alg.execute());
381
382
    }
  }
383
  void tearDown() override { AnalysisDataService::Instance().clear(); }
384
385

private:
386
  LoadILLSANS m_alg;
387
};