Pandora
Pandora source code navigator
Loading...
Searching...
No Matches
BinaryFileReader.cc
Go to the documentation of this file.
1
9#include "Api/PandoraApi.h"
10
11#include "Objects/CaloHit.h"
12#include "Objects/Track.h"
13
14#include "Persistency/BinaryFileReader.h"
15
16namespace pandora
17{
18
19BinaryFileReader::BinaryFileReader(const pandora::Pandora &pandora, const std::string &fileName) :
20 FileReader(pandora, fileName),
21 m_containerPosition(0),
22 m_containerSize(0)
23{
24 m_fileType = BINARY;
25 m_fileStream.open(fileName.c_str(), std::ios::in | std::ios::binary);
26
27 if (!m_fileStream.is_open() || !m_fileStream.good())
28 throw StatusCodeException(STATUS_CODE_FAILURE);
29}
30
31//------------------------------------------------------------------------------------------------------------------------------------------
32
37
38//------------------------------------------------------------------------------------------------------------------------------------------
39
40StatusCode BinaryFileReader::ReadHeader()
41{
42 std::string fileHash;
43 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(fileHash));
44
45 if (PANDORA_FILE_HASH != fileHash)
46 return STATUS_CODE_FAILURE;
47
48 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(m_containerId));
49
50 if ((EVENT_CONTAINER != m_containerId) && (GEOMETRY_CONTAINER != m_containerId))
51 return STATUS_CODE_FAILURE;
52
53 m_containerPosition = m_fileStream.tellg();
54 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(m_containerSize));
55
56 if (0 == m_containerSize)
57 return STATUS_CODE_FAILURE;
58
59 return STATUS_CODE_SUCCESS;
60}
61
62//------------------------------------------------------------------------------------------------------------------------------------------
63
64StatusCode BinaryFileReader::GoToNextContainer()
65{
66 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadHeader());
67 m_fileStream.seekg(m_containerPosition + m_containerSize, std::ios::beg);
68
69 if (!m_fileStream.good())
70 return STATUS_CODE_FAILURE;
71
72 return STATUS_CODE_SUCCESS;
73}
74
75//------------------------------------------------------------------------------------------------------------------------------------------
76
77ContainerId BinaryFileReader::GetNextContainerId()
78{
79 const std::ifstream::pos_type initialPosition(m_fileStream.tellg());
80
81 std::string fileHash;
82 const StatusCode fileHashStatusCode(this->ReadVariable(fileHash));
83
84 if (STATUS_CODE_SUCCESS != fileHashStatusCode)
85 throw StatusCodeException(fileHashStatusCode);
86
87 if (PANDORA_FILE_HASH != fileHash)
88 throw StatusCodeException(STATUS_CODE_FAILURE);
89
90 ContainerId containerId(UNKNOWN_CONTAINER);
91 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(containerId));
92
93 m_fileStream.seekg(initialPosition, std::ios::beg);
94
95 if (!m_fileStream.good())
96 throw StatusCodeException(STATUS_CODE_FAILURE);
97
98 return containerId;
99}
100
101//------------------------------------------------------------------------------------------------------------------------------------------
102
103StatusCode BinaryFileReader::GoToGeometry(const unsigned int geometryNumber)
104{
105 int nGeometriesRead(0);
106 m_fileStream.seekg(0, std::ios::beg);
107
108 if (!m_fileStream.good())
109 return STATUS_CODE_FAILURE;
110
111 if (GEOMETRY_CONTAINER != this->GetNextContainerId())
112 --nGeometriesRead;
113
114 while (nGeometriesRead < static_cast<int>(geometryNumber))
115 {
116 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GoToNextGeometry());
117 ++nGeometriesRead;
118 }
119
120 return STATUS_CODE_SUCCESS;
121}
122
123//------------------------------------------------------------------------------------------------------------------------------------------
124
125StatusCode BinaryFileReader::GoToEvent(const unsigned int eventNumber)
126{
127 int nEventsRead(0);
128 m_fileStream.seekg(0, std::ios::beg);
129
130 if (!m_fileStream.good())
131 return STATUS_CODE_FAILURE;
132
133 if (EVENT_CONTAINER != this->GetNextContainerId())
134 --nEventsRead;
135
136 while (nEventsRead < static_cast<int>(eventNumber))
137 {
138 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->GoToNextEvent());
139 ++nEventsRead;
140 }
141
142 return STATUS_CODE_SUCCESS;
143}
144
145//------------------------------------------------------------------------------------------------------------------------------------------
146
147StatusCode BinaryFileReader::ReadNextGeometryComponent()
148{
149 ComponentId componentId(UNKNOWN_COMPONENT);
150 const StatusCode statusCode(this->ReadVariable(componentId));
151
152 if (STATUS_CODE_SUCCESS != statusCode)
153 {
154 if (STATUS_CODE_NOT_FOUND != statusCode)
155 throw StatusCodeException(statusCode);
156
157 return STATUS_CODE_NOT_FOUND;
158 }
159
160 switch (componentId)
161 {
162 case SUB_DETECTOR_COMPONENT:
163 return this->ReadSubDetector(false);
164 case LAR_TPC_COMPONENT:
165 return this->ReadLArTPC(false);
166 case LINE_GAP_COMPONENT:
167 return this->ReadLineGap(false);
168 case BOX_GAP_COMPONENT:
169 return this->ReadBoxGap(false);
170 case CONCENTRIC_GAP_COMPONENT:
171 return this->ReadConcentricGap(false);
172 case GEOMETRY_END_COMPONENT:
173 m_containerId = UNKNOWN_CONTAINER;
174 return STATUS_CODE_NOT_FOUND;
175 default:
176 throw StatusCodeException(STATUS_CODE_FAILURE);
177 }
178}
179
180//------------------------------------------------------------------------------------------------------------------------------------------
181
182StatusCode BinaryFileReader::ReadNextEventComponent()
183{
184 ComponentId componentId(UNKNOWN_COMPONENT);
185 const StatusCode statusCode(this->ReadVariable(componentId));
186
187 if (STATUS_CODE_SUCCESS != statusCode)
188 {
189 if (STATUS_CODE_NOT_FOUND != statusCode)
190 throw StatusCodeException(statusCode);
191
192 return STATUS_CODE_NOT_FOUND;
193 }
194
195 switch (componentId)
196 {
197 case CALO_HIT_COMPONENT:
198 return this->ReadCaloHit(false);
199 case TRACK_COMPONENT:
200 return this->ReadTrack(false);
201 case MC_PARTICLE_COMPONENT:
202 return this->ReadMCParticle(false);
203 case RELATIONSHIP_COMPONENT:
204 return this->ReadRelationship(false);
205 case EVENT_END_COMPONENT:
206 m_containerId = UNKNOWN_CONTAINER;
207 return STATUS_CODE_NOT_FOUND;
208 default:
209 throw StatusCodeException(STATUS_CODE_FAILURE);
210 }
211}
212
213//------------------------------------------------------------------------------------------------------------------------------------------
214
215StatusCode BinaryFileReader::ReadSubDetector(bool checkComponentId)
216{
217 if (GEOMETRY_CONTAINER != m_containerId)
218 return STATUS_CODE_FAILURE;
219
220 if (checkComponentId)
221 {
222 ComponentId componentId(UNKNOWN_COMPONENT);
223 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
224
225 if (SUB_DETECTOR_COMPONENT != componentId)
226 return STATUS_CODE_FAILURE;
227 }
228
229 PandoraApi::Geometry::SubDetector::Parameters *pParameters = m_pSubDetectorFactory->NewParameters();
230
231 try
232 {
233 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pSubDetectorFactory->Read(*pParameters, *this));
234
235 std::string subDetectorName;
236 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(subDetectorName));
237 SubDetectorType subDetectorType(SUB_DETECTOR_OTHER);
238 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(subDetectorType));
239 float innerRCoordinate(0.f);
240 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(innerRCoordinate));
241 float innerZCoordinate(0.f);
242 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(innerZCoordinate));
243 float innerPhiCoordinate(0.f);
244 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(innerPhiCoordinate));
245 unsigned int innerSymmetryOrder(0);
246 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(innerSymmetryOrder));
247 float outerRCoordinate(0.f);
248 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(outerRCoordinate));
249 float outerZCoordinate(0.f);
250 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(outerZCoordinate));
251 float outerPhiCoordinate(0.f);
252 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(outerPhiCoordinate));
253 unsigned int outerSymmetryOrder(0);
254 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(outerSymmetryOrder));
255 bool isMirroredInZ(false);
256 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(isMirroredInZ));
257 unsigned int nLayers(0);
258 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(nLayers));
259
260 pParameters->m_subDetectorName = subDetectorName;
261 pParameters->m_subDetectorType = subDetectorType;
262 pParameters->m_innerRCoordinate = innerRCoordinate;
263 pParameters->m_innerZCoordinate = innerZCoordinate;
264 pParameters->m_innerPhiCoordinate = innerPhiCoordinate;
265 pParameters->m_innerSymmetryOrder = innerSymmetryOrder;
266 pParameters->m_outerRCoordinate = outerRCoordinate;
267 pParameters->m_outerZCoordinate = outerZCoordinate;
268 pParameters->m_outerPhiCoordinate = outerPhiCoordinate;
269 pParameters->m_outerSymmetryOrder = outerSymmetryOrder;
270 pParameters->m_isMirroredInZ = isMirroredInZ;
271 pParameters->m_nLayers = nLayers;
272
273 for (unsigned int iLayer = 0; iLayer < nLayers; ++iLayer)
274 {
275 float closestDistanceToIp(0.f);
276 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(closestDistanceToIp));
277 float nRadiationLengths(0.f);
278 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(nRadiationLengths));
279 float nInteractionLengths(0.f);
280 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(nInteractionLengths));
281
282 PandoraApi::Geometry::LayerParameters layerParameters;
283 layerParameters.m_closestDistanceToIp = closestDistanceToIp;
284 layerParameters.m_nRadiationLengths = nRadiationLengths;
285 layerParameters.m_nInteractionLengths = nInteractionLengths;
286 pParameters->m_layerParametersVector.push_back(layerParameters);
287 }
288
289 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::SubDetector::Create(*m_pPandora, *pParameters, *m_pSubDetectorFactory));
290 delete pParameters;
291 }
292 catch (StatusCodeException &statusCodeException)
293 {
294 delete pParameters;
295 return statusCodeException.GetStatusCode();
296 }
297
298 return STATUS_CODE_SUCCESS;
299}
300
301//------------------------------------------------------------------------------------------------------------------------------------------
302
303StatusCode BinaryFileReader::ReadLArTPC(bool checkComponentId)
304{
305 if (GEOMETRY_CONTAINER != m_containerId)
306 return STATUS_CODE_FAILURE;
307
308 if (checkComponentId)
309 {
310 ComponentId componentId(UNKNOWN_COMPONENT);
311 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
312
313 if (LAR_TPC_COMPONENT != componentId)
314 return STATUS_CODE_FAILURE;
315 }
316
317 PandoraApi::Geometry::LArTPC::Parameters *pParameters = m_pLArTPCFactory->NewParameters();
318
319 try
320 {
321 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pLArTPCFactory->Read(*pParameters, *this));
322
323 unsigned int larTPCVolumeId;
324 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(larTPCVolumeId));
325 float centerX(0.f);
326 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(centerX));
327 float centerY(0.f);
328 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(centerY));
329 float centerZ(0.f);
330 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(centerZ));
331 float widthX(0.f);
332 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(widthX));
333 float widthY(0.f);
334 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(widthY));
335 float widthZ(0.f);
336 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(widthZ));
337 float wirePitchU(0.f);
338 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(wirePitchU));
339 float wirePitchV(0.f);
340 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(wirePitchV));
341 float wirePitchW(0.f);
342 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(wirePitchW));
343 float wireAngleU(0.f);
344 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(wireAngleU));
345 float wireAngleV(0.f);
346 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(wireAngleV));
347 float wireAngleW(0.f);
348 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(wireAngleW));
349 float sigmaUVW(0.f);
350 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(sigmaUVW));
351 bool isDriftInPositiveX(false);
352 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(isDriftInPositiveX));
353
354 pParameters->m_larTPCVolumeId = larTPCVolumeId;
355 pParameters->m_centerX = centerX;
356 pParameters->m_centerY = centerY;
357 pParameters->m_centerZ = centerZ;
358 pParameters->m_widthX = widthX;
359 pParameters->m_widthY = widthY;
360 pParameters->m_widthZ = widthZ;
361 pParameters->m_wirePitchU = wirePitchU;
362 pParameters->m_wirePitchV = wirePitchV;
363 pParameters->m_wirePitchW = wirePitchW;
364 pParameters->m_wireAngleU = wireAngleU;
365 pParameters->m_wireAngleV = wireAngleV;
366 pParameters->m_wireAngleW = wireAngleW;
367 pParameters->m_sigmaUVW = sigmaUVW;
368 pParameters->m_isDriftInPositiveX = isDriftInPositiveX;
369
370 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::LArTPC::Create(*m_pPandora, *pParameters, *m_pLArTPCFactory));
371 delete pParameters;
372 }
373 catch (StatusCodeException &statusCodeException)
374 {
375 delete pParameters;
376 return statusCodeException.GetStatusCode();
377 }
378
379 return STATUS_CODE_SUCCESS;
380}
381
382//------------------------------------------------------------------------------------------------------------------------------------------
383
384StatusCode BinaryFileReader::ReadLineGap(bool checkComponentId)
385{
386 if (GEOMETRY_CONTAINER != m_containerId)
387 return STATUS_CODE_FAILURE;
388
389 if (checkComponentId)
390 {
391 ComponentId componentId(UNKNOWN_COMPONENT);
392 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
393
394 if (LINE_GAP_COMPONENT != componentId)
395 return STATUS_CODE_FAILURE;
396 }
397
398 PandoraApi::Geometry::LineGap::Parameters *pParameters = m_pLineGapFactory->NewParameters();
399
400 try
401 {
402 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pLineGapFactory->Read(*pParameters, *this));
403
404 LineGapType lineGapType(TPC_WIRE_GAP_VIEW_U);
405 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(lineGapType));
406 float lineStartX(0.f);
407 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(lineStartX));
408 float lineEndX(0.f);
409 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(lineEndX));
410 float lineStartZ(0.f);
411 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(lineStartZ));
412 float lineEndZ(0.f);
413 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(lineEndZ));
414
415 pParameters->m_lineGapType = lineGapType;
416 pParameters->m_lineStartX = lineStartX;
417 pParameters->m_lineEndX = lineEndX;
418 pParameters->m_lineStartZ = lineStartZ;
419 pParameters->m_lineEndZ = lineEndZ;
420 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::LineGap::Create(*m_pPandora, *pParameters, *m_pLineGapFactory));
421 delete pParameters;
422 }
423 catch (StatusCodeException &statusCodeException)
424 {
425 delete pParameters;
426 return statusCodeException.GetStatusCode();
427 }
428
429 return STATUS_CODE_SUCCESS;
430}
431
432//------------------------------------------------------------------------------------------------------------------------------------------
433
434StatusCode BinaryFileReader::ReadBoxGap(bool checkComponentId)
435{
436 if (GEOMETRY_CONTAINER != m_containerId)
437 return STATUS_CODE_FAILURE;
438
439 if (checkComponentId)
440 {
441 ComponentId componentId(UNKNOWN_COMPONENT);
442 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
443
444 if (BOX_GAP_COMPONENT != componentId)
445 return STATUS_CODE_FAILURE;
446 }
447
448 PandoraApi::Geometry::BoxGap::Parameters *pParameters = m_pBoxGapFactory->NewParameters();
449
450 try
451 {
452 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pBoxGapFactory->Read(*pParameters, *this));
453
454 CartesianVector vertex(0.f, 0.f, 0.f);
455 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(vertex));
456 CartesianVector side1(0.f, 0.f, 0.f);
457 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(side1));
458 CartesianVector side2(0.f, 0.f, 0.f);
459 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(side2));
460 CartesianVector side3(0.f, 0.f, 0.f);
461 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(side3));
462
463 pParameters->m_vertex = vertex;
464 pParameters->m_side1 = side1;
465 pParameters->m_side2 = side2;
466 pParameters->m_side3 = side3;
467 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::BoxGap::Create(*m_pPandora, *pParameters, *m_pBoxGapFactory));
468 delete pParameters;
469 }
470 catch (StatusCodeException &statusCodeException)
471 {
472 delete pParameters;
473 return statusCodeException.GetStatusCode();
474 }
475
476 return STATUS_CODE_SUCCESS;
477}
478
479//------------------------------------------------------------------------------------------------------------------------------------------
480
481StatusCode BinaryFileReader::ReadConcentricGap(bool checkComponentId)
482{
483 if (GEOMETRY_CONTAINER != m_containerId)
484 return STATUS_CODE_FAILURE;
485
486 if (checkComponentId)
487 {
488 ComponentId componentId(UNKNOWN_COMPONENT);
489 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
490
491 if (CONCENTRIC_GAP_COMPONENT != componentId)
492 return STATUS_CODE_FAILURE;
493 }
494
495 PandoraApi::Geometry::ConcentricGap::Parameters *pParameters = m_pConcentricGapFactory->NewParameters();
496
497 try
498 {
499 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pConcentricGapFactory->Read(*pParameters, *this));
500
501 float minZCoordinate(0.f);
502 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(minZCoordinate));
503 float maxZCoordinate(0.f);
504 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(maxZCoordinate));
505 float innerRCoordinate(0.f);
506 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(innerRCoordinate));
507 float innerPhiCoordinate(0.f);
508 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(innerPhiCoordinate));
509 unsigned int innerSymmetryOrder(0);
510 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(innerSymmetryOrder));
511 float outerRCoordinate(0.f);
512 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(outerRCoordinate));
513 float outerPhiCoordinate(0.f);
514 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(outerPhiCoordinate));
515 unsigned int outerSymmetryOrder(0);
516 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(outerSymmetryOrder));
517
518 pParameters->m_minZCoordinate = minZCoordinate;
519 pParameters->m_maxZCoordinate = maxZCoordinate;
520 pParameters->m_innerRCoordinate = innerRCoordinate;
521 pParameters->m_innerPhiCoordinate = innerPhiCoordinate;
522 pParameters->m_innerSymmetryOrder = innerSymmetryOrder;
523 pParameters->m_outerRCoordinate = outerRCoordinate;
524 pParameters->m_outerPhiCoordinate = outerPhiCoordinate;
525 pParameters->m_outerSymmetryOrder = outerSymmetryOrder;
526 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Geometry::ConcentricGap::Create(*m_pPandora, *pParameters, *m_pConcentricGapFactory));
527 delete pParameters;
528 }
529 catch (StatusCodeException &statusCodeException)
530 {
531 delete pParameters;
532 return statusCodeException.GetStatusCode();
533 }
534
535 return STATUS_CODE_SUCCESS;
536}
537
538//------------------------------------------------------------------------------------------------------------------------------------------
539
540StatusCode BinaryFileReader::ReadCaloHit(bool checkComponentId)
541{
542 if (EVENT_CONTAINER != m_containerId)
543 return STATUS_CODE_FAILURE;
544
545 if (checkComponentId)
546 {
547 ComponentId componentId(UNKNOWN_COMPONENT);
548 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
549
550 if (CALO_HIT_COMPONENT != componentId)
551 return STATUS_CODE_FAILURE;
552 }
553
554 PandoraApi::CaloHit::Parameters *pParameters = m_pCaloHitFactory->NewParameters();
555
556 try
557 {
558 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pCaloHitFactory->Read(*pParameters, *this));
559
560 CellGeometry cellGeometry(RECTANGULAR);
561 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(cellGeometry));
562 CartesianVector positionVector(0.f, 0.f, 0.f);
563 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(positionVector));
564 CartesianVector expectedDirection(0.f, 0.f, 0.f);
565 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(expectedDirection));
566 CartesianVector cellNormalVector(0.f, 0.f, 0.f);
567 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(cellNormalVector));
568 float cellThickness(0.f);
569 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(cellThickness));
570 float nCellRadiationLengths(0.f);
571 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(nCellRadiationLengths));
572 float nCellInteractionLengths(0.f);
573 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(nCellInteractionLengths));
574 float time(0.f);
575 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(time));
576 float inputEnergy(0.f);
577 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(inputEnergy));
578 float mipEquivalentEnergy(0.f);
579 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(mipEquivalentEnergy));
580 float electromagneticEnergy(0.f);
581 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(electromagneticEnergy));
582 float hadronicEnergy(0.f);
583 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(hadronicEnergy));
584 bool isDigital(false);
585 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(isDigital));
586 HitType hitType(ECAL);
587 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(hitType));
588 HitRegion hitRegion(BARREL);
589 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(hitRegion));
590 unsigned int layer(0);
591 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(layer));
592 bool isInOuterSamplingLayer(false);
593 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(isInOuterSamplingLayer));
594 const void *pParentAddress(nullptr);
595 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(pParentAddress));
596 float cellSize0(0.f);
597 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(cellSize0));
598 float cellSize1(0.f);
599 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(cellSize1));
600
601 pParameters->m_positionVector = positionVector;
602 pParameters->m_expectedDirection = expectedDirection;
603 pParameters->m_cellNormalVector = cellNormalVector;
604 pParameters->m_cellGeometry = cellGeometry;
605 pParameters->m_cellSize0 = cellSize0;
606 pParameters->m_cellSize1 = cellSize1;
607 pParameters->m_cellThickness = cellThickness;
608 pParameters->m_nCellRadiationLengths = nCellRadiationLengths;
609 pParameters->m_nCellInteractionLengths = nCellInteractionLengths;
610 pParameters->m_time = time;
611 pParameters->m_inputEnergy = inputEnergy;
612 pParameters->m_mipEquivalentEnergy = mipEquivalentEnergy;
613 pParameters->m_electromagneticEnergy = electromagneticEnergy;
614 pParameters->m_hadronicEnergy = hadronicEnergy;
615 pParameters->m_isDigital = isDigital;
616 pParameters->m_hitType = hitType;
617 pParameters->m_hitRegion = hitRegion;
618 pParameters->m_layer = layer;
619 pParameters->m_isInOuterSamplingLayer = isInOuterSamplingLayer;
620 pParameters->m_pParentAddress = pParentAddress;
621 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::CaloHit::Create(*m_pPandora, *pParameters, *m_pCaloHitFactory));
622 delete pParameters;
623 }
624 catch (StatusCodeException &statusCodeException)
625 {
626 delete pParameters;
627 return statusCodeException.GetStatusCode();
628 }
629
630 return STATUS_CODE_SUCCESS;
631}
632
633//------------------------------------------------------------------------------------------------------------------------------------------
634
635StatusCode BinaryFileReader::ReadTrack(bool checkComponentId)
636{
637 if (EVENT_CONTAINER != m_containerId)
638 return STATUS_CODE_FAILURE;
639
640 if (checkComponentId)
641 {
642 ComponentId componentId(UNKNOWN_COMPONENT);
643 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
644
645 if (TRACK_COMPONENT != componentId)
646 return STATUS_CODE_FAILURE;
647 }
648
649 PandoraApi::Track::Parameters *pParameters = m_pTrackFactory->NewParameters();
650
651 try
652 {
653 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pTrackFactory->Read(*pParameters, *this));
654
655 float d0(0.f);
656 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(d0));
657 float z0(0.f);
658 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(z0));
659 int particleId(0);
660 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(particleId));
661 int charge(0);
662 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(charge));
663 float mass(0.f);
664 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(mass));
665 CartesianVector momentumAtDca(0.f, 0.f, 0.f);
666 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(momentumAtDca));
667 TrackState trackStateAtStart(0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
668 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(trackStateAtStart));
669 TrackState trackStateAtEnd(0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
670 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(trackStateAtEnd));
671 TrackState trackStateAtCalorimeter(0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
672 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(trackStateAtCalorimeter));
673 float timeAtCalorimeter(0.f);
674 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(timeAtCalorimeter));
675 bool reachesCalorimeter(false);
676 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(reachesCalorimeter));
677 bool isProjectedToEndCap(false);
678 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(isProjectedToEndCap));
679 bool canFormPfo(false);
680 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(canFormPfo));
681 bool canFormClusterlessPfo(false);
682 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(canFormClusterlessPfo));
683 const void *pParentAddress(nullptr);
684 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(pParentAddress));
685
686 pParameters->m_d0 = d0;
687 pParameters->m_z0 = z0;
688 pParameters->m_particleId = particleId;
689 pParameters->m_charge = charge;
690 pParameters->m_mass = mass;
691 pParameters->m_momentumAtDca = momentumAtDca;
692 pParameters->m_trackStateAtStart = trackStateAtStart;
693 pParameters->m_trackStateAtEnd = trackStateAtEnd;
694 pParameters->m_trackStateAtCalorimeter = trackStateAtCalorimeter;
695 pParameters->m_timeAtCalorimeter = timeAtCalorimeter;
696 pParameters->m_reachesCalorimeter = reachesCalorimeter;
697 pParameters->m_isProjectedToEndCap = isProjectedToEndCap;
698 pParameters->m_canFormPfo = canFormPfo;
699 pParameters->m_canFormClusterlessPfo = canFormClusterlessPfo;
700 pParameters->m_pParentAddress = pParentAddress;
701 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::Track::Create(*m_pPandora, *pParameters, *m_pTrackFactory));
702 delete pParameters;
703 }
704 catch (StatusCodeException &statusCodeException)
705 {
706 delete pParameters;
707 return statusCodeException.GetStatusCode();
708 }
709
710 return STATUS_CODE_SUCCESS;
711}
712
713//------------------------------------------------------------------------------------------------------------------------------------------
714
715StatusCode BinaryFileReader::ReadMCParticle(bool checkComponentId)
716{
717 if (EVENT_CONTAINER != m_containerId)
718 return STATUS_CODE_FAILURE;
719
720 if (checkComponentId)
721 {
722 ComponentId componentId(UNKNOWN_COMPONENT);
723 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
724
725 if (MC_PARTICLE_COMPONENT != componentId)
726 return STATUS_CODE_FAILURE;
727 }
728
729 PandoraApi::MCParticle::Parameters *pParameters = m_pMCParticleFactory->NewParameters();
730
731 try
732 {
733 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_pMCParticleFactory->Read(*pParameters, *this));
734
735 float energy(0.f);
736 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(energy));
737 CartesianVector momentum(0.f, 0.f, 0.f);
738 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(momentum));
739 CartesianVector vertex(0.f, 0.f, 0.f);
740 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(vertex));
741 CartesianVector endpoint(0.f, 0.f, 0.f);
742 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(endpoint));
743 int particleId(-std::numeric_limits<int>::max());
744 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(particleId));
745 MCParticleType mcParticleType(MC_3D);
746 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(mcParticleType));
747 const void *pParentAddress(nullptr);
748 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(pParentAddress));
749
750 pParameters->m_energy = energy;
751 pParameters->m_momentum = momentum;
752 pParameters->m_vertex = vertex;
753 pParameters->m_endpoint = endpoint;
754 pParameters->m_particleId = particleId;
755 pParameters->m_mcParticleType = mcParticleType;
756 pParameters->m_pParentAddress = pParentAddress;
757 PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraApi::MCParticle::Create(*m_pPandora, *pParameters, *m_pMCParticleFactory));
758 delete pParameters;
759 }
760 catch (StatusCodeException &statusCodeException)
761 {
762 delete pParameters;
763 return statusCodeException.GetStatusCode();
764 }
765
766 return STATUS_CODE_SUCCESS;
767}
768
769//------------------------------------------------------------------------------------------------------------------------------------------
770
771StatusCode BinaryFileReader::ReadRelationship(bool checkComponentId)
772{
773 if (EVENT_CONTAINER != m_containerId)
774 return STATUS_CODE_FAILURE;
775
776 if (checkComponentId)
777 {
778 ComponentId componentId(UNKNOWN_COMPONENT);
779 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(componentId));
780
781 if (RELATIONSHIP_COMPONENT != componentId)
782 return STATUS_CODE_FAILURE;
783 }
784
785 RelationshipId relationshipId(UNKNOWN_RELATIONSHIP);
786 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(relationshipId));
787 const void *address1(nullptr);
788 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(address1));
789 const void *address2(nullptr);
790 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(address2));
791 float weight(1.f);
792 PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, this->ReadVariable(weight));
793
794 switch (relationshipId)
795 {
796 case CALO_HIT_TO_MC_RELATIONSHIP:
797 return PandoraApi::SetCaloHitToMCParticleRelationship(*m_pPandora, address1, address2, weight);
798 case TRACK_TO_MC_RELATIONSHIP:
799 return PandoraApi::SetTrackToMCParticleRelationship(*m_pPandora, address1, address2, weight);
800 case MC_PARENT_DAUGHTER_RELATIONSHIP:
801 return PandoraApi::SetMCParentDaughterRelationship(*m_pPandora, address1, address2);
802 case TRACK_PARENT_DAUGHTER_RELATIONSHIP:
803 return PandoraApi::SetTrackParentDaughterRelationship(*m_pPandora, address1, address2);
804 case TRACK_SIBLING_RELATIONSHIP:
805 return PandoraApi::SetTrackSiblingRelationship(*m_pPandora, address1, address2);
806 default:
807 return STATUS_CODE_FAILURE;
808 }
809
810 return STATUS_CODE_SUCCESS;
811}
812
813} // namespace pandora
BinaryFileReader.h
Header file for the binary file reader class.
CaloHit.h
Header file for the calo hit class.
PandoraApi.h
Header file for the pandora api class.
PANDORA_THROW_RESULT_IF
#define PANDORA_THROW_RESULT_IF(StatusCode1, Operator, Command)
Definition StatusCodes.h:43
PANDORA_RETURN_RESULT_IF
#define PANDORA_RETURN_RESULT_IF(StatusCode1, Operator, Command)
Definition StatusCodes.h:19
Track.h
Header file for the track class.
PandoraApi::SetTrackToMCParticleRelationship
static pandora::StatusCode SetTrackToMCParticleRelationship(const pandora::Pandora &pandora, const void *const pTrackParentAddress, const void *const pMCParticleParentAddress, const float mcParticleWeight=1)
Set track to mc particle relationship.
Definition PandoraApi.cc:76
PandoraApi::SetMCParentDaughterRelationship
static pandora::StatusCode SetMCParentDaughterRelationship(const pandora::Pandora &pandora, const void *const pParentAddress, const void *const pDaughterAddress)
Set parent-daughter mc particle relationship.
Definition PandoraApi.cc:44
PandoraApi::SetCaloHitToMCParticleRelationship
static pandora::StatusCode SetCaloHitToMCParticleRelationship(const pandora::Pandora &pandora, const void *const pCaloHitParentAddress, const void *const pMCParticleParentAddress, const float mcParticleWeight=1)
Set calo hit to mc particle relationship.
Definition PandoraApi.cc:68
PandoraApi::SetTrackSiblingRelationship
static pandora::StatusCode SetTrackSiblingRelationship(const pandora::Pandora &pandora, const void *const pFirstSiblingAddress, const void *const pSecondSiblingAddress)
Set sibling track relationship.
Definition PandoraApi.cc:60
PandoraApi::SetTrackParentDaughterRelationship
static pandora::StatusCode SetTrackParentDaughterRelationship(const pandora::Pandora &pandora, const void *const pParentAddress, const void *const pDaughterAddress)
Set parent-daughter track relationship.
Definition PandoraApi.cc:52
object_creation::Geometry::LayerParameters
LayerParameters class.
Definition ObjectCreation.h:202
object_creation::Geometry::LayerParameters::m_closestDistanceToIp
pandora::InputFloat m_closestDistanceToIp
Closest distance of the layer from the interaction point, units mm.
Definition ObjectCreation.h:204
object_creation::Geometry::LayerParameters::m_nRadiationLengths
pandora::InputFloat m_nRadiationLengths
Absorber material in front of layer, units radiation lengths.
Definition ObjectCreation.h:205
object_creation::Geometry::LayerParameters::m_nInteractionLengths
pandora::InputFloat m_nInteractionLengths
Absorber material in front of layer, units interaction lengths.
Definition ObjectCreation.h:206
object_creation::ObjectCreationHelper::Create
static pandora::StatusCode Create(const pandora::Pandora &pandora, const Parameters &parameters, const pandora::ObjectFactory< Parameters, Object > &factory=pandora::PandoraObjectFactory< Parameters, Object >())
Create a new object from a user factory.
object_creation::ObjectCreationHelper::Parameters
PARAMETERS Parameters
Definition ObjectCreation.h:38
pandora::BinaryFileReader::ReadTrack
StatusCode ReadTrack(bool checkComponentId=true)
Read a track from the current position in the file, recreating the stored object.
Definition BinaryFileReader.cc:635
pandora::BinaryFileReader::ReadCaloHit
StatusCode ReadCaloHit(bool checkComponentId=true)
Read a calo hit from the current position in the file, recreating the stored object.
Definition BinaryFileReader.cc:540
pandora::BinaryFileReader::m_containerSize
std::ifstream::pos_type m_containerSize
Size of the current event/geometry container object in the file.
Definition BinaryFileReader.h:121
pandora::BinaryFileReader::ReadHeader
StatusCode ReadHeader()
Read the container header from the current position in the file, checking for properly written contai...
Definition BinaryFileReader.cc:40
pandora::BinaryFileReader::ReadSubDetector
StatusCode ReadSubDetector(bool checkComponentId=true)
Read a sub detector from the current position in the file.
Definition BinaryFileReader.cc:215
pandora::BinaryFileReader::GoToNextContainer
StatusCode GoToNextContainer()
Skip to next container in the file.
Definition BinaryFileReader.cc:64
pandora::BinaryFileReader::ReadLineGap
StatusCode ReadLineGap(bool checkComponentId=true)
Read a line gap from the current position in the file.
Definition BinaryFileReader.cc:384
pandora::BinaryFileReader::ReadConcentricGap
StatusCode ReadConcentricGap(bool checkComponentId=true)
Read a concentric gap from the current position in the file.
Definition BinaryFileReader.cc:481
pandora::BinaryFileReader::ReadVariable
StatusCode ReadVariable(T &t)
Read a variable from the file.
Definition BinaryFileReader.h:128
pandora::BinaryFileReader::GoToGeometry
StatusCode GoToGeometry(const unsigned int geometryNumber)
Skip to a specified geometry number in the file.
Definition BinaryFileReader.cc:103
pandora::BinaryFileReader::ReadRelationship
StatusCode ReadRelationship(bool checkComponentId=true)
Read a relationship from the current position in the file, recreating the stored relationship.
Definition BinaryFileReader.cc:771
pandora::BinaryFileReader::BinaryFileReader
BinaryFileReader(const pandora::Pandora &pandora, const std::string &fileName)
Constructor.
Definition BinaryFileReader.cc:19
pandora::BinaryFileReader::ReadLArTPC
StatusCode ReadLArTPC(bool checkComponentId=true)
Read a lar tpc from the current position in the file.
Definition BinaryFileReader.cc:303
pandora::BinaryFileReader::GetNextContainerId
ContainerId GetNextContainerId()
Get the id of the next container in the file without changing the current position in the file.
Definition BinaryFileReader.cc:77
pandora::BinaryFileReader::ReadNextEventComponent
StatusCode ReadNextEventComponent()
Read the next pandora event component from the current position in the file, recreating the stored co...
Definition BinaryFileReader.cc:182
pandora::BinaryFileReader::ReadNextGeometryComponent
StatusCode ReadNextGeometryComponent()
Read the next pandora geometry component from the current position in the file, recreating the stored...
Definition BinaryFileReader.cc:147
pandora::BinaryFileReader::ReadBoxGap
StatusCode ReadBoxGap(bool checkComponentId=true)
Read a box gap from the current position in the file.
Definition BinaryFileReader.cc:434
pandora::BinaryFileReader::m_fileStream
std::ifstream m_fileStream
The stream class to read from the file.
Definition BinaryFileReader.h:122
pandora::BinaryFileReader::m_containerPosition
std::ifstream::pos_type m_containerPosition
Position of start of the current event/geometry container object in file.
Definition BinaryFileReader.h:120
pandora::BinaryFileReader::ReadMCParticle
StatusCode ReadMCParticle(bool checkComponentId=true)
Read a mc particle from the current position in the file, recreating the stored object.
Definition BinaryFileReader.cc:715
pandora::BinaryFileReader::GoToEvent
StatusCode GoToEvent(const unsigned int eventNumber)
Skip to a specified event number in the file.
Definition BinaryFileReader.cc:125
pandora::CartesianVector
CartesianVector class.
Definition CartesianVector.h:24
pandora::FileReader
FileReader class.
Definition FileReader.h:29
pandora::FileReader::GoToNextGeometry
StatusCode GoToNextGeometry()
Skip to next geometry container in the file.
Definition FileReader.cc:84
pandora::FileReader::GoToNextEvent
StatusCode GoToNextEvent()
Skip to next event container in the file.
Definition FileReader.cc:97
pandora::ObjectFactory::NewParameters
virtual Parameters * NewParameters() const =0
Create new parameters instance on the heap (memory-management to be controlled by user)
pandora::ObjectFactory::Read
virtual StatusCode Read(Parameters &parameters, FileReader &fileReader) const =0
Read any additional (derived class only) object parameters from file using the specified file reader.
pandora::Pandora
Pandora class.
Definition Pandora.h:40
pandora::Persistency::m_pBoxGapFactory
ObjectFactory< object_creation::Geometry::BoxGap::Parameters, object_creation::Geometry::BoxGap::Object > * m_pBoxGapFactory
Address of the box gap factory.
Definition Persistency.h:84
pandora::Persistency::m_containerId
ContainerId m_containerId
The type of container currently being written to file.
Definition Persistency.h:76
pandora::Persistency::m_pPandora
const Pandora *const m_pPandora
Address of pandora instance to be used alongside the file writer.
Definition Persistency.h:73
pandora::Persistency::m_pMCParticleFactory
ObjectFactory< object_creation::MCParticle::Parameters, object_creation::MCParticle::Object > * m_pMCParticleFactory
Address of the mc particle factory.
Definition Persistency.h:80
pandora::Persistency::m_pLArTPCFactory
ObjectFactory< object_creation::Geometry::LArTPC::Parameters, object_creation::Geometry::LArTPC::Object > * m_pLArTPCFactory
Address of the lar tpc factory.
Definition Persistency.h:82
pandora::Persistency::m_pTrackFactory
ObjectFactory< object_creation::Track::Parameters, object_creation::Track::Object > * m_pTrackFactory
Address of the track factory.
Definition Persistency.h:79
pandora::Persistency::m_pCaloHitFactory
ObjectFactory< object_creation::CaloHit::Parameters, object_creation::CaloHit::Object > * m_pCaloHitFactory
Address of the calo hit factory.
Definition Persistency.h:78
pandora::Persistency::m_pLineGapFactory
ObjectFactory< object_creation::Geometry::LineGap::Parameters, object_creation::Geometry::LineGap::Object > * m_pLineGapFactory
Address of the line gap factory.
Definition Persistency.h:83
pandora::Persistency::m_pConcentricGapFactory
ObjectFactory< object_creation::Geometry::ConcentricGap::Parameters, object_creation::Geometry::ConcentricGap::Object > * m_pConcentricGapFactory
Address of the concentric gap factory.
Definition Persistency.h:85
pandora::Persistency::m_pSubDetectorFactory
ObjectFactory< object_creation::Geometry::SubDetector::Parameters, object_creation::Geometry::SubDetector::Object > * m_pSubDetectorFactory
Address of the sub detector factory.
Definition Persistency.h:81
pandora::Persistency::m_fileType
FileType m_fileType
The file type.
Definition Persistency.h:75
pandora::StatusCodeException
StatusCodeException class.
Definition StatusCodes.h:119
pandora::StatusCodeException::GetStatusCode
StatusCode GetStatusCode() const
Get status code.
Definition StatusCodes.h:191
pandora::TrackState
TrackState class.
Definition TrackState.h:22
pandora::HitType
HitType
Calorimeter hit type enum.
Definition PandoraEnumeratedTypes.h:65
pandora::HitRegion
HitRegion
Calorimeter hit region enum.
Definition PandoraEnumeratedTypes.h:53
pandora::ComponentId
ComponentId
The component identification enum.
Definition PandoraIO.h:36
pandora::GEOMETRY_END_COMPONENT
@ GEOMETRY_END_COMPONENT
Definition PandoraIO.h:46
pandora::LINE_GAP_COMPONENT
@ LINE_GAP_COMPONENT
Definition PandoraIO.h:43
pandora::TRACK_COMPONENT
@ TRACK_COMPONENT
Definition PandoraIO.h:38
pandora::UNKNOWN_COMPONENT
@ UNKNOWN_COMPONENT
Definition PandoraIO.h:48
pandora::BOX_GAP_COMPONENT
@ BOX_GAP_COMPONENT
Definition PandoraIO.h:44
pandora::CONCENTRIC_GAP_COMPONENT
@ CONCENTRIC_GAP_COMPONENT
Definition PandoraIO.h:45
pandora::SUB_DETECTOR_COMPONENT
@ SUB_DETECTOR_COMPONENT
Definition PandoraIO.h:42
pandora::MC_PARTICLE_COMPONENT
@ MC_PARTICLE_COMPONENT
Definition PandoraIO.h:39
pandora::EVENT_END_COMPONENT
@ EVENT_END_COMPONENT
Definition PandoraIO.h:41
pandora::LAR_TPC_COMPONENT
@ LAR_TPC_COMPONENT
Definition PandoraIO.h:47
pandora::RELATIONSHIP_COMPONENT
@ RELATIONSHIP_COMPONENT
Definition PandoraIO.h:40
pandora::CALO_HIT_COMPONENT
@ CALO_HIT_COMPONENT
Definition PandoraIO.h:37
pandora::RelationshipId
RelationshipId
The relationship identification enum.
Definition PandoraIO.h:57
pandora::TRACK_TO_MC_RELATIONSHIP
@ TRACK_TO_MC_RELATIONSHIP
Definition PandoraIO.h:59
pandora::CALO_HIT_TO_MC_RELATIONSHIP
@ CALO_HIT_TO_MC_RELATIONSHIP
Definition PandoraIO.h:58
pandora::TRACK_SIBLING_RELATIONSHIP
@ TRACK_SIBLING_RELATIONSHIP
Definition PandoraIO.h:62
pandora::TRACK_PARENT_DAUGHTER_RELATIONSHIP
@ TRACK_PARENT_DAUGHTER_RELATIONSHIP
Definition PandoraIO.h:61
pandora::UNKNOWN_RELATIONSHIP
@ UNKNOWN_RELATIONSHIP
Definition PandoraIO.h:63
pandora::MC_PARENT_DAUGHTER_RELATIONSHIP
@ MC_PARENT_DAUGHTER_RELATIONSHIP
Definition PandoraIO.h:60
pandora::CellGeometry
CellGeometry
Cell geometry enum.
Definition PandoraEnumeratedTypes.h:18
pandora::ContainerId
ContainerId
The container identification enum.
Definition PandoraIO.h:24
pandora::EVENT_CONTAINER
@ EVENT_CONTAINER
Definition PandoraIO.h:25
pandora::UNKNOWN_CONTAINER
@ UNKNOWN_CONTAINER
Definition PandoraIO.h:27
pandora::GEOMETRY_CONTAINER
@ GEOMETRY_CONTAINER
Definition PandoraIO.h:26
pandora::MCParticleType
MCParticleType
MC particle type enum.
Definition PandoraEnumeratedTypes.h:96
pandora::StatusCode
StatusCode
The StatusCode enum.
Definition StatusCodes.h:100
pandora::SubDetectorType
SubDetectorType
Subdetector type enum.
Definition PandoraEnumeratedTypes.h:110
pandora::PANDORA_FILE_HASH
const std::string PANDORA_FILE_HASH("pandora")
Look for hash each event to check integrity.
pandora::LineGapType
LineGapType
Line gap type.
Definition PandoraEnumeratedTypes.h:83