GammaLib  1.7.0.dev
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
GCOMEventList.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * GCOMEventList.cpp - COMPTEL event list class *
3  * ----------------------------------------------------------------------- *
4  * copyright (C) 2017-2019 by Juergen Knoedlseder *
5  * ----------------------------------------------------------------------- *
6  * *
7  * This program is free software: you can redistribute it and/or modify *
8  * it under the terms of the GNU General Public License as published by *
9  * the Free Software Foundation, either version 3 of the License, or *
10  * (at your option) any later version. *
11  * *
12  * This program is distributed in the hope that it will be useful, *
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15  * GNU General Public License for more details. *
16  * *
17  * You should have received a copy of the GNU General Public License *
18  * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19  * *
20  ***************************************************************************/
21 /**
22  * @file GCOMEventList.hpp
23  * @brief COMPTEL event list class implementation
24  * @author Juergen Knoedlseder
25  */
26 
27 /* __ Includes ___________________________________________________________ */
28 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31 #include <typeinfo>
32 #include "GMath.hpp"
33 #include "GFits.hpp"
34 #include "GException.hpp"
35 #include "GCOMSupport.hpp"
36 #include "GCOMEventList.hpp"
37 
38 /* __ Method name definitions ____________________________________________ */
39 #define G_OPERATOR "GCOMEventList::operator[](int&)"
40 #define G_ROI "GCOMEventList::roi(GRoi&)"
41 
42 /* __ Macros _____________________________________________________________ */
43 
44 /* __ Coding definitions _________________________________________________ */
45 
46 /* __ Debug definitions __________________________________________________ */
47 
48 
49 /*==========================================================================
50  = =
51  = Constructors/destructors =
52  = =
53  ==========================================================================*/
54 
55 /***********************************************************************//**
56  * @brief Void constructor
57  *
58  * Creates an empty COMPTEL event list.
59  ***************************************************************************/
61 {
62  // Initialise class members for clean destruction
63  init_members();
64 
65  // Return
66  return;
67 }
68 
69 
70 /***********************************************************************//**
71  * @brief File name constructor
72  *
73  * @param[in] filename COMPTEL event list filename.
74  *
75  * Construct COMPTEL event list object by loading the events from a
76  * FITS file.
77  ***************************************************************************/
79 {
80  // Initialise members
81  init_members();
82 
83  // Load event list
84  load(filename);
85 
86  // Return
87  return;
88 }
89 
90 
91 /***********************************************************************//**
92  * @brief Copy constructor
93  *
94  * @param[in] list COMPTEL event list.
95  ***************************************************************************/
97 {
98  // Initialise members
99  init_members();
100 
101  // Copy members
102  copy_members(list);
103 
104  // Return
105  return;
106 }
107 
108 
109 /***********************************************************************//**
110  * @brief Destructor
111  ***************************************************************************/
113 {
114  // Free members
115  free_members();
116 
117  // Return
118  return;
119 }
120 
121 
122 /*==========================================================================
123  = =
124  = Operators =
125  = =
126  ==========================================================================*/
127 
128 /***********************************************************************//**
129  * @brief Assignment operator
130  *
131  * @param[in] list COMPTEL event list.
132  * @return COMPTEL event list.
133  ***************************************************************************/
135 {
136  // Execute only if object is not identical
137  if (this != &list) {
138 
139  // Copy base class members
140  this->GEventList::operator=(list);
141 
142  // Free members
143  free_members();
144 
145  // Initialise members
146  init_members();
147 
148  // Copy members
149  copy_members(list);
150 
151  } // endif: object was not identical
152 
153  // Return this object
154  return *this;
155 }
156 
157 
158 /***********************************************************************//**
159  * @brief COMPTEL event atom access operator
160  *
161  * @param[in] index Event index [0,...,size()-1].
162  * @return Pointer to COMPTEL event atom.
163  *
164  * @exception GException::out_of_range
165  * Event index outside valid range.
166  *
167  * Returns pointer to a COMPTEL event atom.
168  ***************************************************************************/
170 {
171  // Optionally check if the index is valid
172  #if defined(G_RANGE_CHECK)
173  if (index < 0 || index >= size()) {
174  throw GException::out_of_range(G_OPERATOR, "Event index", index, size());
175  }
176  #endif
177 
178  // Return pointer
179  return (&(m_events[index]));
180 }
181 
182 
183 /***********************************************************************//**
184  * @brief COMPTEL event atom access operator
185  *
186  * @param[in] index Event index [0,...,size()-1].
187  * @return Pointer to COMPTEL event atom.
188  *
189  * @exception GException::out_of_range
190  * Event index outside valid range.
191  *
192  * Returns pointer to a COMPTEL event atom.
193  ***************************************************************************/
194 const GCOMEventAtom* GCOMEventList::operator[](const int& index) const
195 {
196  // Optionally check if the index is valid
197  #if defined(G_RANGE_CHECK)
198  if (index < 0 || index >= size()) {
199  throw GException::out_of_range(G_OPERATOR, "Event index", index, size());
200  }
201  #endif
202 
203  // Return pointer
204  return (&(m_events[index]));
205 }
206 
207 
208 /*==========================================================================
209  = =
210  = Public methods =
211  = =
212  ==========================================================================*/
213 
214 /***********************************************************************//**
215  * @brief Clear COMPTEL event list
216  *
217  * Clears COMPTEL event list by resetting all class members to an
218  * initial state. Any information that was present before will be lost.
219  ***************************************************************************/
221 {
222  // Free class members (base and derived classes, derived class first)
223  free_members();
224  this->GEventList::free_members();
225  this->GEvents::free_members();
226 
227  // Initialise members
228  this->GEvents::init_members();
229  this->GEventList::init_members();
230  init_members();
231 
232  // Return
233  return;
234 }
235 
236 
237 /***********************************************************************//**
238  * @brief Clone event list
239  *
240  * @return Pointer to deep copy of COMPTEL event list.
241  ***************************************************************************/
243 {
244  return new GCOMEventList(*this);
245 }
246 
247 
248 /***********************************************************************//**
249  * @brief Load COMPTEL events from FITS file
250  *
251  * @param[in] filename COMPTEL event list FITS file name.
252  *
253  * Loads COMPTEL events from a FITS file into the event list.
254  ***************************************************************************/
255 void GCOMEventList::load(const GFilename& filename)
256 {
257  // Open FITS file
258  GFits fits(filename);
259 
260  // Read event list from FITS file
261  read(fits);
262 
263  // Close FITS file
264  fits.close();
265 
266  // Return
267  return;
268 }
269 
270 
271 /***********************************************************************//**
272  * @brief Save COMPTEL events
273  *
274  * @param[in] filename COMPTEL event list FITS file name.
275  * @param[in] clobber Overwrite existing FITS file?
276  *
277  * Save COMPTEL events from a FITS file into the event list.
278  ***************************************************************************/
279 void GCOMEventList::save(const GFilename& filename,
280  const bool& clobber) const
281 {
282  // Open FITS file
283  GFits fits;
284 
285  // Write events
286  write(fits);
287 
288  // Save events
289  fits.saveto(filename, clobber);
290 
291  // Close FITS file
292  fits.close();
293 
294  // Return
295  return;
296 }
297 
298 
299 /***********************************************************************//**
300  * @brief Read COMPTEL events from FITS file.
301  *
302  * @param[in] file FITS file.
303  *
304  * Read the COMPTEL event list from a FITS file object.
305  ***************************************************************************/
306 void GCOMEventList::read(const GFits& file)
307 {
308  // Clear object
309  clear();
310 
311  // Get HDU (pointer is always valid)
312  const GFitsTable& hdu = *file.table(1);
313 
314  // Read event data
315  read_events(hdu);
316 
317  // If there are events then get start and stop time from the first
318  // and last event and append them as single time interval to the GTI
319  if (size() > 0) {
320  GTime start = m_events[0].time();
321  GTime stop = m_events[size()-1].time();
322  m_gti.append(start, stop);
323  }
324 
325  // Return
326  return;
327 }
328 
329 
330 /***********************************************************************//**
331  * @brief Write COMPTEL event list into FITS file.
332  *
333  * @param[in] file FITS file.
334  *
335  * Write the COMPTEL event list into FITS file.
336  *
337  * @todo Implement method.
338  ***************************************************************************/
339 void GCOMEventList::write(GFits& file) const
340 {
341  // TODO: You need to implement an interface to the FITS file that so
342  // that you can save your events.
343 
344  // Return
345  return;
346 }
347 
348 
349 /***********************************************************************//**
350  * @brief Set region of interest
351  *
352  * @param[in] roi Region of interest.
353  *
354  * @exception GException::invalid_argument
355  * Specified RoI is not a COMPTEL RoI.
356  *
357  * Sets the region of interest for the observation.
358  ***************************************************************************/
359 void GCOMEventList::roi(const GRoi& roi)
360 {
361  // Get pointer on COMPTEL region of interest
362  const GCOMRoi* comroi = dynamic_cast<const GCOMRoi*>(&roi);
363  if (comroi == NULL) {
364  std::string cls = std::string(typeid(&roi).name());
365  std::string msg = "Region of interest of type \""+cls+"\" is "
366  "not a COMPTEL RoI. Please specify a "
367  "COMPTEL RoI as argument.";
369  }
370 
371  // Set RoI
372  m_roi = *comroi;
373 
374  // Return
375  return;
376 }
377 
378 
379 /***********************************************************************//**
380  * @brief Append event to event list
381  *
382  * @param[in] event Event.
383  *
384  * Appends an event to the end of the event list.
385  ***************************************************************************/
387 {
388  // Append event
389  m_events.push_back(event);
390 
391  // Return
392  return;
393 }
394 
395 
396 /***********************************************************************//**
397  * @brief Remove events from event list
398  *
399  * @param[in] index Index from which on events should be removed.
400  * @param[in] number Number of event to remove (default: 1).
401  *
402  * Removes events from the event list. This method does nothing if @p index
403  * points beyond the event list. The method does also gently accept
404  * @p number arguments where @p index + @p number reach beyond the event
405  * list. In that case, all events from event @p index on will be removed.
406  ***************************************************************************/
407 void GCOMEventList::remove(const int& index, const int& number)
408 {
409  // Continue only if index is valid
410  if (index < size()) {
411 
412  // Determine number of elements to remove
413  int n_remove = (index + number > size()) ? size() - index : number;
414 
415  // Remove events
416  m_events.erase(m_events.begin() + index,
417  m_events.begin() + index + n_remove);
418 
419  } // endif: index was valid
420 
421  // Return
422  return;
423 }
424 
425 
426 /***********************************************************************//**
427  * @brief Print COMPTEL event list information
428  *
429  * @param[in] chatter Chattiness.
430  * @return String containing COMPTEL event list information.
431  ***************************************************************************/
432 std::string GCOMEventList::print(const GChatter& chatter) const
433 {
434  // Initialise result string
435  std::string result;
436 
437  // Continue only if chatter is not silent
438  if (chatter != SILENT) {
439 
440  // Append header
441  result.append("=== GCOMEventList ===");
442 
443  // Append information
444  result.append("\n"+gammalib::parformat("Number of events") +
445  gammalib::str(number()));
446 
447  // Append time information
448  if (gti().size() > 0) {
449  result.append("\n"+gammalib::parformat("TJD interval"));
450  result.append(gammalib::str(gammalib::com_tjd(tstart()))+":");
451  result.append(gammalib::str(gammalib::com_tics(tstart()))+" - ");
452  result.append(gammalib::str(gammalib::com_tjd(tstop()))+":");
453  result.append(gammalib::str(gammalib::com_tics(tstop())));
454  result.append("\n"+gammalib::parformat("MJD interval"));
455  result.append(gammalib::str(tstart().mjd())+" - ");
456  result.append(gammalib::str(tstop().mjd())+" days");
457  result.append("\n"+gammalib::parformat("UTC interval"));
458  result.append(tstart().utc()+" - ");
459  result.append(tstop().utc());
460  }
461  else {
462  result.append("\n"+gammalib::parformat("MJD interval"));
463  result.append("not defined");
464  }
465 
466  // Append energy information
467  result.append("\n"+gammalib::parformat("Energy interval"));
468  if (ebounds().size() > 0) {
469  result.append(gammalib::str(ebounds().emin().MeV()));
470  result.append(" - ");
471  result.append(gammalib::str(ebounds().emax().MeV())+" MeV");
472  }
473  else {
474  result.append("not defined");
475  }
476 
477  } // endif: chatter was not silent
478 
479  // Return result
480  return result;
481 }
482 
483 
484 /*==========================================================================
485  = =
486  = Private methods =
487  = =
488  ==========================================================================*/
489 
490 /***********************************************************************//**
491  * @brief Initialise class members
492  ***************************************************************************/
494 {
495  // Initialise members
496  m_roi.clear();
497  m_events.clear();
498 
499  // Return
500  return;
501 }
502 
503 
504 /***********************************************************************//**
505  * @brief Copy class members
506  *
507  * @param[in] list COMPTEL event list.
508  ***************************************************************************/
510 {
511  // Copy members
512  m_roi = list.m_roi;
513  m_events = list.m_events;
514 
515  // Return
516  return;
517 }
518 
519 
520 /***********************************************************************//**
521  * @brief Delete class members
522  ***************************************************************************/
524 {
525  // Return
526  return;
527 }
528 
529 
530 /***********************************************************************//**
531  * @brief Read COMPTEL events from FITS table
532  *
533  * @param[in] table FITS table.
534  *
535  * Reads COMPTEL events from a FITS table. The method expects the data in the
536  * format that is provided by the HEASARC archive.
537  *
538  * The method also sets the energy boundaries and Region of Interest of the
539  * data set as this information is not provided in the FITS table header.
540  * For that purpose it scans all data and determines the range that is
541  * covered by the data.
542  *
543  * The method assumes that no events exist so far.
544  ***************************************************************************/
546 {
547  // Extract number of events in FITS file
548  int num = table.nrows();
549 
550  // If there are events then load them
551  if (num > 0) {
552 
553  // Use pointing direction as roi centre
554  GSkyDir centre;
555  centre.lb_deg(table.real("GLON_SCZ"), table.real("GLAT_SCZ"));
556 
557  // Initialise boundaries
558  double radius_max = 0.0;
559  double phibar_min = 0.0;
560  double phibar_max = 0.0;
561 
562  // Reserve data
563  m_events.reserve(num);
564 
565  // Get column pointers
566  const GFitsTableCol* ptr_tjd = table["TJD"]; // days
567  const GFitsTableCol* ptr_tics = table["TICS"]; // ticks
568  const GFitsTableCol* ptr_glon_scat = table["GLON_SCAT"]; // rad
569  const GFitsTableCol* ptr_glat_scat = table["GLAT_SCAT"]; // rad
570  const GFitsTableCol* ptr_phi_scat = table["AZIMUTH_SCAT"]; // rad
571  const GFitsTableCol* ptr_theta_scat = table["ZENITH_SCAT"]; // rad
572  const GFitsTableCol* ptr_phibar = table["PHIBAR"]; // rad
573  const GFitsTableCol* ptr_eha = table["EARTH_HORIZON"]; // rad
574  const GFitsTableCol* ptr_e1 = table["E_D1"]; // keV
575  const GFitsTableCol* ptr_e2 = table["E_D2"]; // keV
576  const GFitsTableCol* ptr_psd = table["PSD"]; // channel
577  const GFitsTableCol* ptr_tof = table["TOF"]; // channel
578  const GFitsTableCol* ptr_modcom = table["MODCOM"]; // id
579  const GFitsTableCol* ptr_reflag = table["RC_REFLAG"]; //
580  const GFitsTableCol* ptr_veto = table["RC_VETO"]; //
581 
582  // Disable scaling of TOF and PSD values so that the original channel
583  // values are recovered. The values are divided by 128.0 below. This
584  // emulates the behaviour of the evpdal13.pevpsr.f function.
585  ptr_psd->scale(1.0, 0.0);
586  ptr_tof->scale(1.0, 0.0);
587 
588  // Initialise boundaries
589  GEnergy emin;
590  GEnergy emax;
591 
592  // Copy data from columns into GCOMEventAtom objects
593  for (int i = 0; i < num; ++i) {
594 
595  // Allocate event
596  GCOMEventAtom event;
597 
598  // Set instrument direction. Note that contrary to what is
599  // specified in the FITS file, angles are provided in radians.
600  // Also, GLON and GLAT are inverted.
601  GCOMInstDir inst_dir;
602  GSkyDir sky_dir;
603  sky_dir.lb(ptr_glat_scat->real(i), ptr_glon_scat->real(i));
604  inst_dir.dir(sky_dir);
605  inst_dir.phibar(ptr_phibar->real(i) * gammalib::rad2deg);
606 
607  // Set total energy
608  GEnergy etot;
609  etot.keV(ptr_e1->real(i) + ptr_e2->real(i));
610 
611  // Set phibar value (deg)
612  double phibar = ptr_phibar->real(i) * gammalib::rad2deg;
613 
614  // Set event information
615  event.time(ptr_tjd->integer(i), ptr_tics->integer(i));
616  event.energy(etot);
617  event.dir(inst_dir);
618  event.phi(ptr_phi_scat->real(i) * gammalib::rad2deg); // rad -> deg
619  event.theta(ptr_theta_scat->real(i) * gammalib::rad2deg); // rad -> deg
620  event.phibar(phibar); // rad -> deg
621  event.eha(ptr_eha->real(i) * gammalib::rad2deg); // rad -> deg
622  event.e1(ptr_e1->real(i) * 1.0e-3); // keV -> MeV
623  event.e2(ptr_e2->real(i) * 1.0e-3); // keV -> MeV
624  event.psd(ptr_psd->integer(i)/128.0);
625  event.tof(ptr_tof->integer(i)/128.0);
626  event.modcom(ptr_modcom->integer(i));
627  event.reflag(ptr_reflag->integer(i));
628  event.veto(ptr_veto->integer(i));
629 
630  // Append event
631  m_events.push_back(event);
632 
633  // Compute distance from pointing direction
634  double radius = centre.dist_deg(sky_dir);
635 
636  // Update boundaries
637  if (i == 0) {
638  emin = etot;
639  emax = etot;
640  phibar_min = phibar;
641  phibar_max = phibar;
642  radius_max = radius;
643  }
644  else {
645  if (etot < emin) {
646  emin = etot;
647  }
648  if (etot > emax) {
649  emax = etot;
650  }
651  if (phibar < phibar_min) {
652  phibar_min = phibar;
653  }
654  if (phibar > phibar_max) {
655  phibar_max = phibar;
656  }
657  if (radius > radius_max) {
658  radius_max = radius;
659  }
660  }
661 
662  } // endfor: looped over all events
663 
664  // Set region of interest
665  double phibar = 0.5 * (phibar_min + phibar_max);
666  m_roi = GCOMRoi(GCOMInstDir(centre, phibar), radius_max,
667  phibar_min, phibar_max);
668 
669  // Set energy boundaries
670  m_ebounds = GEbounds(emin, emax);
671 
672  } // endif: there were events
673 
674  // Return
675  return;
676 }
void phibar(const double &phibar)
Set event Compton scatter angle.
#define G_OPERATOR
void free_members(void)
Delete class members.
#define G_ROI
const GGti & gti(void) const
Return Good Time Intervals.
Definition: GEvents.hpp:134
double dist_deg(const GSkyDir &dir) const
Compute angular distance between sky directions in degrees.
Definition: GSkyDir.hpp:284
GFitsTable * table(const int &extno)
Get pointer to table HDU.
Definition: GFits.cpp:472
std::string number(const std::string &noun, const int &number)
Convert singular noun into number noun.
Definition: GTools.cpp:1057
void scale(const double &tscale, const double &tzero) const
Set table column scale value.
virtual const GCOMRoi & roi(void) const
Return Region of Interest.
void lb(const double &l, const double &b)
Set galactic sky direction (radians)
Definition: GSkyDir.cpp:251
void init_members(void)
Initialise class members.
Definition: GEvents.cpp:176
Abstract event atom container class.
Definition: GEventList.hpp:49
COMPTEL event list class definition.
void init_members(void)
Initialise class members.
Definition: GEventList.cpp:143
const GTime & tstop(void) const
Return stop time.
Definition: GEvents.hpp:158
GEbounds m_ebounds
Energy boundaries covered by events.
Definition: GEvents.hpp:111
void read_events(const GFitsTable &table)
Read COMPTEL events from FITS table.
Time class.
Definition: GTime.hpp:54
FITS file class.
Definition: GFits.hpp:63
FITS file class interface definition.
void append(const GTime &tstart, const GTime &tstop)
Append Good Time Interval.
Definition: GGti.cpp:269
Implementation of support function used by COMPTEL classes.
std::string centre(const std::string &s, const int &n, const char &c= ' ')
Centre string to achieve a length of n characters.
Definition: GTools.cpp:1008
virtual GCOMEventList & operator=(const GCOMEventList &list)
Assignment operator.
GCOMRoi m_roi
Region of interest.
virtual GCOMEventList * clone(void) const
Clone event list.
void saveto(const GFilename &filename, const bool &clobber=false)
Saves to specified FITS file.
Definition: GFits.cpp:1267
double real(const std::string &keyname) const
Return card value as double precision.
Definition: GFitsHDU.hpp:423
virtual void load(const GFilename &filename)
Load COMPTEL events from FITS file.
virtual int size(void) const
Return number of events in list.
Energy boundaries container class.
Definition: GEbounds.hpp:60
void dir(const GSkyDir &dir)
Set event scatter direction.
Filename class.
Definition: GFilename.hpp:62
void free_members(void)
Delete class members.
Definition: GEvents.cpp:206
Abstract interface for FITS table column.
virtual void save(const GFilename &filename, const bool &clobber=false) const
Save COMPTEL events.
int com_tjd(const GTime &time)
Convert GTime in COMPTEL TJD.
void remove(const int &index, const int &number=1)
Remove events from event list.
virtual GEventList & operator=(const GEventList &list)
Assignment operator.
Definition: GEventList.cpp:104
virtual void clear(void)
Clear region of interest.
Definition: GCOMRoi.cpp:165
Abstract interface for FITS table.
Definition: GFitsTable.hpp:44
GGti m_gti
Good time intervals covered by events.
Definition: GEvents.hpp:112
GChatter
Definition: GTypemaps.hpp:33
void append(const GCOMEventAtom &event)
Append event to event list.
virtual std::string print(const GChatter &chatter=NORMAL) const
Print COMPTEL event list information.
void copy_members(const GCOMEventList &list)
Copy class members.
COMPTEL region of interest class.
Definition: GCOMRoi.hpp:44
const int & nrows(void) const
Return number of rows in table.
Definition: GFitsTable.hpp:119
virtual void write(GFits &file) const
Write COMPTEL event list into FITS file.
void free_members(void)
Delete class members.
Definition: GEventList.cpp:165
virtual GCOMEventAtom * operator[](const int &index)
COMPTEL event atom access operator.
int com_tics(const GTime &time)
Convert GTime in COMPTEL tics.
virtual int integer(const int &row, const int &inx=0) const =0
virtual void clear(void)
Clear COMPTEL event list.
virtual double real(const int &row, const int &inx=0) const =0
const GEnergy & emin(void) const
Return minimum energy.
Definition: GEvents.hpp:170
std::vector< GCOMEventAtom > m_events
Events.
double keV(void) const
Return energy in keV.
Definition: GEnergy.cpp:306
GCOMEventList(void)
Void constructor.
void lb_deg(const double &l, const double &b)
Set galactic sky direction (degrees)
Definition: GSkyDir.cpp:278
virtual int number(void) const
Return number of events in list.
Exception handler interface definition.
COMPTEL event list class.
const GEbounds & ebounds(void) const
Return energy boundaries.
Definition: GEvents.hpp:122
virtual void read(const GFits &file)
Read COMPTEL events from FITS file.
Interface for the region of interest classes.
Definition: GRoi.hpp:48
const double rad2deg
Definition: GMath.hpp:44
std::string parformat(const std::string &s, const int &indent=0)
Convert string in parameter format.
Definition: GTools.cpp:1033
const GTime & tstart(void) const
Return start time.
Definition: GEvents.hpp:146
Sky direction class.
Definition: GSkyDir.hpp:62
void close(void)
Close FITS file.
Definition: GFits.cpp:1314
const GEnergy & emax(void) const
Return maximum energy.
Definition: GEvents.hpp:182
void init_members(void)
Initialise class members.
Interface for the COMPTEL instrument direction class.
Definition: GCOMInstDir.hpp:45
Mathematical function definitions.
virtual ~GCOMEventList(void)
Destructor.
Class that handles energies in a unit independent way.
Definition: GEnergy.hpp:48
COMPTEL event atom class.
std::string str(const unsigned short int &value)
Convert unsigned short integer value into string.
Definition: GTools.cpp:415