Project
Loading...
Searching...
No Matches
VisualisationEventROOTSerializer.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
16
18#include <fairlogger/Logger.h>
19#include <iostream>
20
21#include <TFile.h>
22#include <TTree.h>
23#include <TKey.h>
24#include <TParameter.h>
25#include <TNtuple.h>
26
27namespace o2
28{
29namespace event_visualisation
30{
31constexpr int ROOT_FILE_VERSION = 1;
32
33void VisualisationEventROOTSerializer::save(const char* name, const std::string& value)
34{
35 TNamed obj(name, value);
36 obj.Write();
37}
38
39std::string VisualisationEventROOTSerializer::readString(TFile& f, const char* name)
40{
41 auto* v = (TNamed*)f.Get(name);
42 if (v == nullptr) {
43 return "";
44 }
45 std::string result = v->GetTitle();
46 free(v);
47 return result;
48}
49
50void VisualisationEventROOTSerializer::saveInt(const char* name, int value)
51{
52 TParameter<int> obj;
53 obj.SetVal(value);
54 obj.Write(name);
55}
56
57void VisualisationEventROOTSerializer::saveUInt64(const char* name, uint64_t value)
58{
59 TParameter<long> obj;
60 obj.SetVal((long)value);
61 obj.Write(name);
62}
63
64int VisualisationEventROOTSerializer::readInt(TFile& f, const char* name)
65{
66 auto v = (TParameter<int>*)f.Get(name);
67 if (v == nullptr) {
68 return 0;
69 }
70 int result = v->GetVal();
71 free(v);
72 return result;
73}
74
75uint64_t VisualisationEventROOTSerializer::readUInt64(TFile& f, const char* name)
76{
77 auto v = (TParameter<uint64_t>*)f.Get(name);
78 if (v == nullptr) {
79 return 0;
80 }
81 uint64_t result = v->GetVal();
82 free(v);
83 return result;
84}
85
86bool VisualisationEventROOTSerializer::existUInt64(TFile& f, const char* name)
87{
88 auto v = (TParameter<uint64_t>*)f.Get(name);
89 if (v == nullptr) {
90 return false;
91 }
92 free(v);
93 return true;
94}
95
97{
98 std::string fileName = location.fileName();
99 TFile f(fileName.c_str(), "recreate");
100
101 saveInt("runNumber", event.mRunNumber);
102 saveInt("runType", event.mRunType);
103 saveInt("clMask", event.mClMask);
104 saveInt("trkMask", event.mTrkMask);
105 saveInt("tfCounter", event.mTfCounter);
106 saveInt("firstTForbit", event.mFirstTForbit);
107 saveInt("primaryVertex", event.mPrimaryVertex);
108 saveUInt64("creationTime", event.mCreationTime);
109 std::string version = std::to_string(event.mEveVersion / 100.0);
110 save("eveVersion", version); // obsolete
111 saveInt("version", event.mEveVersion);
112 // save("workflowParameters", event.mWorkflowParameters);
113
114 // clusters
115 TNtuple xyz("xyz", "xyz", "x:y:z");
116 long xyzPos = 0L;
117
118 TTree clusters("clusters", "Clusters");
119 long cluster_xyz;
120 unsigned cluster_bgid;
121 float cluster_time;
122 clusters.Branch("BGID", &cluster_bgid);
123 clusters.Branch("time", &cluster_time);
124 clusters.Branch("xyz", &cluster_xyz);
125 for (auto cluster : event.getClustersSpan()) {
126 cluster_time = cluster.Time();
127 cluster_bgid = serialize(cluster.mBGID);
128 cluster_xyz = xyzPos;
129 xyz.Fill(cluster.X(), cluster.Y(), cluster.Z());
130 xyzPos++;
131 clusters.Fill();
132 }
133
134 // Tracks
135 long track_xyz; // first track point
136 int track_points; // number of track points
137 int track_clusters; // number of track clusters
138 unsigned track_BGID; // binary GID
139 float track_time;
140 int track_charge;
141 float track_theta;
142 float track_phi;
143 float track_eta;
144 int track_PID;
145
146 TTree tracks("tracks", "Tracks");
147 tracks.Branch("xyz", &track_xyz);
148 tracks.Branch("time", &track_time);
149 tracks.Branch("charge", &track_charge);
150 tracks.Branch("theta", &track_theta);
151 tracks.Branch("phi", &track_phi);
152 tracks.Branch("eta", &track_eta);
153 tracks.Branch("PID", &track_PID);
154 tracks.Branch("BGID", &track_BGID);
155 tracks.Branch("points", &track_points);
156 tracks.Branch("clusters", &track_clusters);
157
158 for (auto track : event.getTracksSpan()) {
159 track_xyz = xyzPos;
160 track_time = std::isnan(track.mTime) ? 0 : track.mTime;
161 track_charge = track.mCharge;
162 track_theta = std::isnan(track.mTheta) ? 0 : track.mTheta;
163 track_phi = std::isnan(track.mPhi) ? 0 : track.mPhi;
164 track_eta = std::isnan(track.mEta) ? 0 : track.mEta;
165 track_PID = track.mPID;
166 track_BGID = serialize(track.mBGID);
167
168 xyz.Fill(track.mStartCoordinates[0], track.mStartCoordinates[1], track.mStartCoordinates[2]);
169 xyzPos++;
170 track_points = track.getPointCount();
171
172 for (size_t i = 0; i < track.getPointCount(); i++) {
173 xyz.Fill(track.mPolyX[i], track.mPolyY[i], track.mPolyZ[i]);
174 xyzPos++;
175 }
176 track_clusters = track.getClusterCount();
177 for (auto cluster : track.getClustersSpan()) {
178 xyz.Fill(cluster.X(), cluster.Y(), cluster.Z());
179 xyzPos++;
180 }
181 tracks.Fill();
182 }
183
184 clusters.Write();
185
186 // calorimeters
187 TTree calo("calo", "Calorimeters");
188 float calo_time;
189 float calo_energy;
190 float calo_eta;
191 float calo_phi;
192 int calo_PID;
193 unsigned calo_BGID;
194
195 calo.Branch("time", &calo_time);
196 calo.Branch("energy", &calo_energy);
197 calo.Branch("eta", &calo_eta);
198 calo.Branch("phi", &calo_phi);
199 calo.Branch("BGID", &calo_BGID);
200 calo.Branch("PID", &calo_PID);
201
202 for (const auto& calorimeter : event.getCalorimetersSpan()) {
203 calo_time = calorimeter.getTime();
204 calo_energy = calorimeter.getEnergy();
205 calo_eta = calorimeter.getEta();
206 calo_phi = calorimeter.getPhi();
207 calo_BGID = serialize(calorimeter.mBGID);
208 calo_PID = calorimeter.getPID();
209 calo.Fill();
210 }
211 calo.Write();
212
213 tracks.Write();
214
215 xyz.Write();
216}
217
219{
220 // LOGF(info, "VisualisationEventROOTSerializer <- %s ", fileName);
221 event.mTracks.clear();
222 event.mClusters.clear();
223 event.mCalo.clear();
224
225 TFile f(fileName.c_str());
226
227 event.setRunNumber(readInt(f, "runNumber"));
228 event.setRunType(static_cast<parameters::GRPECS::RunType>(readInt(f, "runType")));
229 event.setClMask(readInt(f, "clMask"));
230 event.setTrkMask(readInt(f, "trkMask"));
231 event.setTfCounter(readInt(f, "tfCounter"));
232 event.setFirstTForbit(readInt(f, "firstTForbit"));
233 event.mPrimaryVertex = readInt(f, "primaryVertex");
234
235 if (existUInt64(f, "creationTime")) {
236 event.setCreationTime(readInt(f, "creationTime"));
237 } else {
238 auto collisionTime = readString(f, "collisionTime");
239 event.mCreationTime = parseDateTime(collisionTime.c_str());
240 }
241
242 event.mEveVersion = 0;
243 if (f.Get("version") != nullptr) {
244 event.mEveVersion = readInt(f, "version");
245 } else {
246 std::string version = readString(f, "eveVersion");
247 event.mEveVersion = (int)(100 * std::stof(version));
248 }
249
250 // xyz
251 auto* xyz = (TNtuple*)f.Get("xyz");
252 if (xyz == nullptr) {
253 return false;
254 }
255
256 // tracks
257 auto* tracks = (TTree*)f.Get("tracks");
258 if (tracks == nullptr) {
259 delete xyz;
260 return false;
261 }
262
263 long track_xyz; // first track point
264 int track_points; // number of track points
265 int track_clusters; // number of track clusters
266 int track_source; // obsolete
267 std::string* track_GID = nullptr;
268 unsigned track_BGID;
269 float track_time;
270 int track_charge;
271 float track_theta;
272 float track_phi;
273 float track_eta;
274 int track_PID;
275
276 tracks->SetBranchAddress("xyz", &track_xyz);
277 tracks->SetBranchAddress("time", &track_time);
278 tracks->SetBranchAddress("charge", &track_charge);
279 tracks->SetBranchAddress("theta", &track_theta);
280 tracks->SetBranchAddress("phi", &track_phi);
281 tracks->SetBranchAddress("eta", &track_eta);
282 tracks->SetBranchAddress("PID", &track_PID);
283 auto gid = tracks->GetBranch("GID"); // obsolete
284 if (gid != nullptr) {
285 tracks->SetBranchAddress("GID", &track_GID);
286 }
287 auto bgid = tracks->GetBranch("BGID");
288 if (bgid != nullptr) {
289 tracks->SetBranchAddress("BGID", &track_BGID);
290 }
291 auto source = tracks->GetBranch("source"); // obsolete
292 if (source != nullptr) {
293 tracks->SetBranchAddress("source", &track_source);
294 }
295 tracks->SetBranchAddress("points", &track_points);
296 tracks->SetBranchAddress("clusters", &track_clusters);
297
298 auto tracksNoOfEntries = (Int_t)tracks->GetEntries();
299 for (Int_t i = 0; i < tracksNoOfEntries; i++) {
300 tracks->GetEntry(i);
301 VisualisationTrack track;
302 track.mTime = track_time;
303 track.mCharge = track_charge;
304 track.mTheta = track_theta;
305 track.mPhi = track_phi;
306 track.mEta = track_eta;
307 track.mPID = track_PID;
308 if (bgid) {
309 track.mBGID = deserialize(track_BGID);
310 } else {
311 track.mBGID = gidFromString(*track_GID);
312 }
313 xyz->GetEntry(track_xyz);
314 track.addStartCoordinates(xyz->GetArgs());
315 for (int p = 0; p < track_points; p++) {
316 xyz->GetEntry(track_xyz + 1 + p);
317 track.addPolyPoint(xyz->GetArgs());
318 }
319 for (size_t it = 0; it < track_clusters; it++) {
320 xyz->GetEntry(track_xyz + 1 + track_points + it);
321 VisualisationCluster cluster(xyz->GetArgs(), track.mTime, track.mBGID);
322 track.mClusters.emplace_back(cluster);
323 }
324 event.mTracks.emplace_back(track);
325 }
326
327 if (gid != nullptr) {
328 delete track_GID;
329 track_GID = nullptr;
330 }
331
332 if (!readClusters(event, f, xyz)) {
333 delete xyz;
334 delete tracks;
335 return false;
336 }
337
338 if (!readCalo(event, f)) {
339 delete xyz;
340 delete tracks;
341 return false;
342 }
343
344 delete tracks;
345 delete xyz;
346
347 event.afterLoading();
348 return true;
349}
350
351bool VisualisationEventROOTSerializer::readClusters(VisualisationEvent& event, TFile& f, TNtuple* xyz)
352{
353 auto* clusters = (TTree*)f.Get("clusters");
354 if (clusters == nullptr) {
355 return false;
356 }
357
358 long cluster_xyz;
359 int cluster_source;
360 unsigned cluster_BGID;
361
362 float cluster_time;
363 auto source = clusters->GetBranch("source"); // obsolete
364 if (source != nullptr) {
365 clusters->SetBranchAddress("source", &cluster_source);
366 }
367
368 auto bgid = clusters->GetBranch("BGID");
369 if (bgid != nullptr) {
370 clusters->SetBranchAddress("BGID", &cluster_BGID);
371 }
372
373 clusters->SetBranchAddress("time", &cluster_time);
374 clusters->SetBranchAddress("xyz", &cluster_xyz);
375 auto clustersNoOfEntries = (Int_t)clusters->GetEntries();
376 for (Int_t i = 0; i < clustersNoOfEntries; i++) {
377 clusters->GetEntry(i);
378 xyz->GetEntry(cluster_xyz);
379 dataformats::GlobalTrackID gid = 0;
380 if (bgid) {
381 gid = deserialize(cluster_BGID);
382 } else if (source) {
383 gid = deserialize(cluster_source, 0, 0);
384 }
385 VisualisationCluster cluster(xyz->GetArgs(), cluster_time, gid);
386 event.mClusters.emplace_back(cluster);
387 }
388 delete clusters;
389 return true;
390}
391
392bool VisualisationEventROOTSerializer::readCalo(VisualisationEvent& event, TFile& f)
393{
394 auto* calo = (TTree*)f.Get("calo");
395 if (calo == nullptr) {
396 return false;
397 }
398
399 int calo_source;
400 float calo_time;
401 float calo_energy;
402 float calo_eta;
403 float calo_phi;
404 unsigned calo_BGID;
405 int calo_PID;
406
407 auto source = calo->GetBranch("source");
408 if (source != nullptr) {
409 calo->SetBranchAddress("source", &calo_source);
410 }
411 auto bgid = calo->GetBranch("BGID");
412 if (bgid != nullptr) {
413 calo->SetBranchAddress("BGID", &calo_BGID);
414 }
415
416 calo->SetBranchAddress("time", &calo_time);
417 calo->SetBranchAddress("energy", &calo_energy);
418 calo->SetBranchAddress("eta", &calo_eta);
419 calo->SetBranchAddress("phi", &calo_phi);
420 calo->SetBranchAddress("PID", &calo_PID);
421
422 auto nentries = (Int_t)calo->GetEntries();
423 for (Int_t i = 0; i < nentries; i++) {
424 calo->GetEntry(i);
425 VisualisationCalo calorimeter;
426 calorimeter.mTime = calo_time;
427 calorimeter.mEnergy = calo_energy;
428 calorimeter.mEta = calo_eta;
429 calorimeter.mPhi = calo_phi;
430 if (bgid) {
431 calorimeter.mBGID = deserialize(calo_BGID);
432 } else {
433 calorimeter.mBGID = deserialize(calo_source, 0, 0);
434 }
435 calorimeter.mPID = calo_PID;
436 event.mCalo.emplace_back(calorimeter);
437 }
438 delete calo;
439 return true;
440}
441
442} // namespace event_visualisation
443} // namespace o2
int32_t i
bool fromFile(VisualisationEvent &event, std::string fileName) override
void toFile(const VisualisationEvent &event, Location &location) override
static unsigned serialize(o2::dataformats::GlobalTrackID gidValue)
static o2::dataformats::GlobalTrackID deserialize(unsigned seralizedValue)
static o2::dataformats::GlobalTrackID gidFromString(const std::string &gid)
void addPolyPoint(float x, float y, float z)
struct _cl_event * event
Definition glcorearb.h:2982
GLuint64EXT * result
Definition glcorearb.h:5662
const GLdouble * v
Definition glcorearb.h:832
GLuint const GLchar * name
Definition glcorearb.h:781
GLdouble f
Definition glcorearb.h:310
GLsizei GLsizei GLchar * source
Definition glcorearb.h:798
GLsizei const GLfloat * value
Definition glcorearb.h:819
a couple of static helper functions to create timestamp values for CCDB queries or override obsolete ...
std::string to_string(gsl::span< T, Size > span)
Definition common.h:52
std::vector< Cluster > clusters