Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include "MantidDataHandling/ScanningWorkspaceBuilder.h"
#include "MantidAPI/DetectorInfo.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidGeometry/Instrument.h"
using namespace Mantid::API;
namespace Mantid {
namespace DataHandling {
ScanningWorkspaceBuilder::ScanningWorkspaceBuilder(size_t nDetectors,
size_t nTimeIndexes,
size_t nBins)
: m_nDetectors(nDetectors), m_nTimeIndexes(nTimeIndexes), m_nBins(nBins) {}
void ScanningWorkspaceBuilder::setInstrument(
boost::shared_ptr<const Geometry::Instrument> instrument) {
m_instrument = instrument;
}
void ScanningWorkspaceBuilder::setTimeRanges(const std::vector<
std::pair<Kernel::DateAndTime, Kernel::DateAndTime>> &timeRanges) {
verifyTimeIndexSize(timeRanges.size(), "start time, end time pairs");
m_timeRanges = timeRanges;
}
void ScanningWorkspaceBuilder::setTimeRanges(
const Kernel::DateAndTime &startTime,
const std::vector<double> &durations) {
verifyTimeIndexSize(durations.size(), "time durations");
std::vector<std::pair<Kernel::DateAndTime, Kernel::DateAndTime>> timeRanges =
{std::pair<Kernel::DateAndTime, Kernel::DateAndTime>(
startTime, startTime + durations[0])};
for (size_t i = 1; i < m_nTimeIndexes; ++i) {
const auto newStartTime = timeRanges[i - 1].second;
const auto endTime = newStartTime + durations[i];
timeRanges.push_back(std::pair<Kernel::DateAndTime, Kernel::DateAndTime>(
newStartTime, endTime));
}
setTimeRanges(timeRanges);
}
void ScanningWorkspaceBuilder::setPositions(
std::vector<std::vector<Kernel::V3D>>) {
throw std::runtime_error("Not implemented yet!");
}
void ScanningWorkspaceBuilder::setRotations(
std::vector<std::vector<Kernel::Quat>>) {
throw std::runtime_error("Not implemented yet!");
}
MatrixWorkspace_sptr ScanningWorkspaceBuilder::buildWorkspace() {
validateInputs();
auto outputWorkspace = WorkspaceFactory::Instance().create(
"Workspace2D", m_nDetectors * m_nTimeIndexes, m_nBins + 1, m_nBins);
outputWorkspace->setInstrument(m_instrument);
MatrixWorkspace_const_sptr parentWorkspace = outputWorkspace->clone();
auto &outputDetectorInfo = outputWorkspace->mutableDetectorInfo();
outputDetectorInfo.setScanInterval(0, m_timeRanges[0]);
for (size_t i = 1; i < m_nTimeIndexes; ++i) {
auto mergeWorkspace =
WorkspaceFactory::Instance().create(parentWorkspace, m_nDetectors);
auto &mergeDetectorInfo = mergeWorkspace->mutableDetectorInfo();
for (size_t j = 0; j < m_nDetectors; ++j) {
mergeDetectorInfo.setScanInterval(j, m_timeRanges[i]);
}
outputDetectorInfo.merge(mergeDetectorInfo);
}
return outputWorkspace;
}
void ScanningWorkspaceBuilder::verifyTimeIndexSize(
size_t inputSize, const std::string &description) {
if (inputSize != m_nTimeIndexes) {
throw std::logic_error(
"Number of " + description +
" supplied does not match the number of time indexes being requested.");
}
}
void ScanningWorkspaceBuilder::validateInputs() {
if (!m_instrument)
throw std::logic_error("Can not build workspace - instrument has not been "
"set. Please call setInstrument() before building.");
if (m_timeRanges.empty())
throw std::logic_error("Can not build workspace - time ranges have not "
"been set. Please call setTimeRanges() before "
"building.");
}
} // namespace DataHandling
} // namespace Mantid