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
#include "MantidDataHandling/ParallelEventLoader.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidParallel/IO/EventLoader.h"
#include "MantidTypes/Event/TofEvent.h"
namespace Mantid {
namespace DataHandling {
std::vector<int32_t> bankOffsets(const API::ExperimentInfo &ws,
const std::vector<std::string> &bankNames) {
const auto instrument = ws.getInstrument();
const auto &compInfo = ws.componentInfo();
const auto &detInfo = ws.detectorInfo();
const auto &detIDs = detInfo.detectorIDs();
const auto monitors = instrument->getMonitors();
int32_t monitorOffset = static_cast<int32_t>(monitors.size());
std::vector<int32_t> bankOffsets;
for (const auto &bankName : bankNames) {
// Removing "_events" from bankName
auto bank =
instrument->getComponentByName(bankName.substr(0, bankName.size() - 7));
if (bank) {
const auto &detectors =
compInfo.detectorsInSubtree(compInfo.indexOf(bank->getComponentID()));
const size_t detIndex = detectors.front();
bankOffsets.push_back(detIDs[detIndex] - static_cast<int32_t>(detIndex) +
monitorOffset);
printf("%s %d %d %lu offset %d\n", bankName.c_str(),
detIDs[detectors.front()], detIDs[detectors.back()],
detectors.size(), bankOffsets.back());
if ((detIDs[detectors.back()] - detIDs[detectors.front()]) !=
static_cast<int32_t>(detectors.size()) - 1)
throw std::runtime_error("Detector ID range in bank is not contiguous. "
"Cannot use ParallelEventLoader.");
} else {
printf("bank %s not found\n", bankName.c_str());
throw std::runtime_error("");
}
}
return bankOffsets;
}
void ParallelEventLoader::load(DataObjects::EventWorkspace &ws,
const std::string &filename,
const std::string &groupName,
const std::vector<std::string> &bankNames) {
const size_t size = ws.getNumberHistograms();
std::vector<std::vector<Types::Event::TofEvent> *> eventLists(size, nullptr);
for (size_t i = 0; i < size; ++i)
DataObjects::getEventsFrom(ws.getSpectrum(i), eventLists[i]);
fprintf(stderr, "loading into %lu event lists\n", size);
Parallel::IO::EventLoader::load(filename, groupName, bankNames,
bankOffsets(ws, bankNames),
std::move(eventLists));
//for (size_t i = 0; i < size; ++i)
// fprintf(stderr, "total %lu\n", ws.getSpectrum(i).getNumberEvents());
fprintf(stderr, "loading done\n");
}
/*
for chunk in myfile:
if currently_processed_buffer_start == buffer_index:
consumer.wait()
# ring buffer, loader is taking small steps
loader.load(chunk, buffer_index)
buffer_index = (buffer_index + 1)%buffer_count
if buffer_index * chunk.size <= consumer.optimal_buffer_size:
# consumer taking large steps (better for MPI), chasing the loader in the ring buffer
consumer.start_processing(buffer_index_start, buffer_index)
currently_processed_buffer_start = buffer_index_start
buffer_index_start = buffer_index
consumer.finalize()
*/
} // namespace DataHandling
} // namespace Mantid