/
LoadEventPreNexus2.h
234 lines (185 loc) · 7.68 KB
/
LoadEventPreNexus2.h
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
#ifndef LOADEVENTPRENEXUS_H_
#define LOADEVENTPRENEXUS_H_
#include <fstream>
#include <string>
#include <vector>
#include "MantidAPI/IFileLoader.h"
#include "MantidKernel/BinaryFile.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/Events.h"
namespace Mantid {
namespace DataHandling {
/** @class Mantid::DataHandling::LoadEventPreNexus2
A data loading routine for SNS pre-nexus event files
Copyright © 2010-11 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
National Laboratory & European Spallation Source
This file is part of Mantid.
Mantid is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
Mantid is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
File change history is stored at: <https://github.com/mantidproject/mantid>
*/
/// This define is used to quickly turn parallel code on or off.
#undef LOADEVENTPRENEXUS_ALLOW_PARALLEL
/// Make the code clearer by having this an explicit type
typedef int PixelType;
/// Type for the DAS time of flight (data file)
typedef int DasTofType;
/// Structure that matches the form in the binary event list.
#pragma pack(push, 4) // Make sure the structure is 8 bytes.
struct DasEvent {
/// Time of flight.
DasTofType tof;
/// Pixel identifier as published by the DAS/DAE/DAQ.
PixelType pid;
};
#pragma pack(pop)
/// Structure used as an intermediate for parallel processing of events
#pragma pack(push, 4) // Make sure the structure is 8 bytes.
struct IntermediateEvent {
/// Time of flight.
DasTofType tof;
/// Pixel identifier as published by the DAS/DAE/DAQ.
PixelType pid;
/// Frame index (pulse # of this event)
size_t frame_index;
/// Period of the event (not really used at this time)
uint32_t period;
};
#pragma pack(pop)
/// Structure that matches the form in the new pulseid files.
#pragma pack(push, 4) // Make sure the structure is 16 bytes.
struct Pulse {
/// The number of nanoseconds since the seconds field. This is not necessarily
/// less than one second.
uint32_t nanoseconds;
/// The number of seconds since January 1, 1990.
uint32_t seconds;
/// The index of the first event for this pulse.
uint64_t event_index;
/// The proton charge for the pulse.
double pCurrent;
};
#pragma pack(pop)
class DLLExport LoadEventPreNexus2
: public API::IFileLoader<Kernel::FileDescriptor> {
public:
/// Constructor
LoadEventPreNexus2();
/// Virtual destructor
~LoadEventPreNexus2() override;
/// Algorithm's name
const std::string name() const override { return "LoadEventPreNexus"; }
/// Algorithm's version
int version() const override { return (2); }
/// Algorithm's category for identification
const std::string category() const override {
return "DataHandling\\PreNexus";
}
/// Algorithm's aliases
const std::string alias() const override { return "LoadEventPreNeXus2"; }
/// Summary of algorithms purpose
const std::string summary() const override {
return "Loads SNS raw neutron event data format and stores it in a "
"workspace.";
}
/// Returns a confidence value that this algorithm can load a file
int confidence(Kernel::FileDescriptor &descriptor) const override;
private:
/// Initialisation code
void init() override;
/// Execution code
void exec() override;
Mantid::API::Progress *prog;
DataObjects::EventWorkspace_sptr localWorkspace; //< Output EventWorkspace
std::vector<int64_t> spectra_list; ///<the list of Spectra
/// The times for each pulse.
std::vector<Kernel::DateAndTime> pulsetimes;
/// The index of the first event in each pulse.
std::vector<uint64_t> event_indices;
/// The proton charge on a pulse by pulse basis.
std::vector<double> proton_charge;
/// The total proton charge for the run.
double proton_charge_tot;
/// The value of the vector is the workspace index. The index into it is the
/// pixel ID from DAS
std::vector<std::size_t> pixel_to_wkspindex;
/// Map between the DAS pixel IDs and our pixel IDs, used while loading.
std::vector<PixelType> pixelmap;
/// The maximum detector ID possible
Mantid::detid_t detid_max;
/// Handles loading from the event file
Mantid::Kernel::BinaryFile<DasEvent> *eventfile;
std::size_t num_events; ///< The number of events in the file
std::size_t num_pulses; ///<the number of pulses
uint32_t numpixel; ///<the number of pixels
std::size_t num_good_events; ///< The number of good events loaded
std::size_t num_error_events; ///< The number of error events encountered
std::size_t num_bad_events; ///<The number of bad events. Part of error events
std::size_t num_wrongdetid_events; ///<The number of events with wrong
/// detector IDs. Part of error events.
std::set<PixelType> wrongdetids; ///<set of all wrong detector IDs
std::map<PixelType, size_t> wrongdetidmap;
std::vector<std::vector<Kernel::DateAndTime>> wrongdetid_pulsetimes;
std::vector<std::vector<double>> wrongdetid_tofs;
/// the number of events that were ignored (not loaded) because, e.g. of only
/// loading some spectra.
std::size_t num_ignored_events;
std::size_t first_event; ///< The first event to load (count from zero)
std::size_t max_events; ///< Number of events to load
/// Set to true if a valid Mapping file was provided.
bool using_mapping_file;
/// For loading only some spectra
bool loadOnlySomeSpectra;
/// Handle to the loaded spectra map
std::map<int64_t, bool> spectraLoadMap;
/// Longest TOF limit
double longest_tof;
/// Shortest TOF limit
double shortest_tof;
/// Flag to allow for parallel loading
bool parallelProcessing;
/// Whether or not the pulse times are sorted in increasing order.
bool pulsetimesincreasing;
/// sample environment event
std::vector<detid_t> mSEids;
std::map<size_t, detid_t> mSEmap;
std::vector<std::vector<int64_t>> mSEpulseids;
std::vector<std::vector<double>> mSEtofs;
/// Investigation properties
bool m_dbOutput;
int m_dbOpBlockNumber;
size_t m_dbOpNumEvents;
size_t m_dbOpNumPulses;
void loadPixelMap(const std::string &filename);
void openEventFile(const std::string &filename);
void readPulseidFile(const std::string &filename, const bool throwError);
void runLoadInstrument(const std::string &eventfilename,
API::MatrixWorkspace_sptr localWorkspace);
inline void fixPixelId(PixelType &pixel, uint32_t &period) const;
void procEvents(DataObjects::EventWorkspace_sptr &workspace);
void procEventsLinear(DataObjects::EventWorkspace_sptr &workspace,
std::vector<DataObjects::TofEvent> **arrayOfVectors,
DasEvent *event_buffer,
size_t current_event_buffer_size, size_t fileOffset,
bool dbprint);
void setProtonCharge(DataObjects::EventWorkspace_sptr &workspace);
void addToWorkspaceLog(std::string logtitle, size_t mindex);
void processImbedLogs();
void debugOutput(bool doit, size_t mindex);
void unmaskVetoEventIndex();
API::MatrixWorkspace_sptr generateEventDistribtionWorkspace();
void createOutputWorkspace(const std::string event_filename);
/// Processing the input properties for purpose of investigation
void processInvestigationInputs();
};
}
}
#endif /*LOADEVENTPRENEXUS_H_*/