GammaLib 2.1.0.dev
Loading...
Searching...
No Matches
GEnergy.cpp
Go to the documentation of this file.
1/***************************************************************************
2 * GEnergy.cpp - Energy class *
3 * ----------------------------------------------------------------------- *
4 * copyright (C) 2010-2024 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 GEnergy.cpp
23 * @brief Energy value class implementation
24 * @author Juergen Knoedlseder
25 */
26
27/* __ Includes ___________________________________________________________ */
28#ifdef HAVE_CONFIG_H
29#include <config.h>
30#endif
31#include <cfloat>
32#include <cmath>
33#include "GEnergy.hpp"
34#include "GTools.hpp"
35#include "GException.hpp"
36
37/* __ Constants __________________________________________________________ */
38
39/* __ Method name definitions ____________________________________________ */
40#define G_CONSTRUCT "GEnergy::GEnergy(double&, std::string&)"
41#define G_OPERATOR1 "GEnergy::operator()(double&, std::string&)"
42#define G_OPERATOR2 "GEnergy::operator()(std::string&)"
43#define G_ANGSTROM_GET "GEnergy::Angstrom()"
44#define G_ANGSTROM_SET "GEnergy::Angstrom(double&)"
45#define G_LOG10_GET "GEnergy::log10(std::string&)"
46#define G_LOG10_SET "GEnergy::log10(double&, std::string&)"
47
48/* __ Macros _____________________________________________________________ */
49
50/* __ Coding definitions _________________________________________________ */
51
52/* __ Debug definitions __________________________________________________ */
53
54
55/*==========================================================================
56 = =
57 = Constructors/destructors =
58 = =
59 ==========================================================================*/
60
61/***********************************************************************//**
62 * @brief Void constructor
63 ***************************************************************************/
65{
66 // Initialise private members
68
69 // Return
70 return;
71}
72
73
74/***********************************************************************//**
75 * @brief Copy constructor
76 *
77 * @param[in] eng Energy.
78 ***************************************************************************/
80{
81 // Initialise private members
83
84 // Copy members
85 copy_members(eng);
86
87 // Return
88 return;
89}
90
91
92/***********************************************************************//**
93 * @brief Energy constructor
94 *
95 * @param[in] eng Energy.
96 * @param[in] unit Energy unit (one of erg(s), keV, MeV, GeV, TeV).
97 *
98 * Construct energy from an energy value and unit. The constructor interprets
99 * the unit string and performs automatic conversion of the energy value.
100 ***************************************************************************/
101GEnergy::GEnergy(const double& eng, const std::string& unit)
102{
103 // Initialise private members
104 init_members();
105
106 // Set energy according to unit string
107 this->operator()(eng, unit);
108
109 // Return
110 return;
111}
112
113
114/***********************************************************************//**
115 * @brief Destructor
116 ***************************************************************************/
118{
119 // Free members
120 free_members();
121
122 // Return
123 return;
124}
125
126
127/*==========================================================================
128 = =
129 = Operators =
130 = =
131 ==========================================================================*/
132
133/***********************************************************************//**
134 * @brief Assignment operator
135 *
136 * @param[in] eng Energy.
137 * @return Energy.
138 ***************************************************************************/
140{
141 // Execute only if object is not identical
142 if (this != &eng) {
143
144 // Free members
145 free_members();
146
147 // Initialise private members for clean destruction
148 init_members();
149
150 // Copy members
151 copy_members(eng);
152
153 } // endif: object was not identical
154
155 // Return
156 return *this;
157}
158
159
160/***********************************************************************//**
161 * @brief Unit set operator
162 *
163 * @param[in] eng Energy.
164 * @param[in] unit Energy unit (one of erg(s), eV, keV, MeV, GeV, TeV, Angstrom).
165 *
166 * @exception GException::invalid_argument
167 * Invalid energy unit specified.
168 *
169 * Construct energy from an energy value and unit. The constructor interprets
170 * the unit string and performs automatic conversion of the energy value.
171 ***************************************************************************/
172void GEnergy::operator()(const double& eng, const std::string& unit)
173{
174 // Set energy according to unit string
175 std::string eunit = gammalib::strip_whitespace(gammalib::tolower(unit));
176 if (eunit == "erg" || eunit == "ergs") {
177 this->erg(eng);
178 }
179 else if (eunit == "ev") {
180 this->eV(eng);
181 }
182 else if (eunit == "kev") {
183 this->keV(eng);
184 }
185 else if (eunit == "mev") {
186 this->MeV(eng);
187 }
188 else if (eunit == "gev") {
189 this->GeV(eng);
190 }
191 else if (eunit == "tev") {
192 this->TeV(eng);
193 }
194 else if (eunit == "angstrom") {
195 this->Angstrom(eng);
196 }
197 else {
199 "Valid energy units are \"erg(s)\", \"eV\", \"keV\", \"MeV\","
200 " \"GeV\", \"TeV\", or \"Angstrom\" (case insensitive).");
201 }
202
203 // Return
204 return;
205}
206
207
208/***********************************************************************//**
209 * @brief Unit access operator
210 *
211 * @param[in] unit Energy unit (one of erg(s), eV, keV, MeV, GeV, TeV, Angstrom).
212 * @return Energy in requested units.
213 *
214 * @exception GException::invalid_argument
215 * Invalid energy unit specified.
216 *
217 * Returns the energy in the requested units.
218 ***************************************************************************/
219double GEnergy::operator()(const std::string& unit) const
220{
221 // Initialise energy
222 double energy = 0.0;
223
224 // Set energy according to unit string
225 std::string eunit = gammalib::tolower(unit);
226 if (eunit == "erg" || eunit == "ergs") {
227 energy = this->erg();
228 }
229 else if (eunit == "ev") {
230 energy = this->eV();
231 }
232 else if (eunit == "kev") {
233 energy = this->keV();
234 }
235 else if (eunit == "mev") {
236 energy = this->MeV();
237 }
238 else if (eunit == "gev") {
239 energy = this->GeV();
240 }
241 else if (eunit == "tev") {
242 energy = this->TeV();
243 }
244 else if (eunit == "angstrom") {
245 energy = this->Angstrom();
246 }
247 else {
249 "Valid energy units are \"erg(s)\", \"eV\", \"keV\", \"MeV\","
250 " \"GeV\", \"TeV\", or \"Angstrom\" (case insensitive).");
251 }
252
253 // Return energy
254 return energy;
255}
256
257
258/*==========================================================================
259 = =
260 = Public methods =
261 = =
262 ==========================================================================*/
263
264/***********************************************************************//**
265 * @brief Clear instance
266 ***************************************************************************/
268{
269 // Free members
270 free_members();
271
272 // Initialise private members
273 init_members();
274
275 // Return
276 return;
277}
278
279
280/***********************************************************************//**
281 * @brief Clone object
282 *
283 * @return Pointer to deep copy of energy.
284 ***************************************************************************/
286{
287 // Clone this image
288 return new GEnergy(*this);
289}
290
291
292/***********************************************************************//**
293 * @brief Return energy in erg
294 *
295 * @return Energy in erg.
296 ***************************************************************************/
297double GEnergy::erg(void) const
298{
299 // Compute energy
300 double energy = m_energy * gammalib::MeV2erg;
301
302 // Return energy
303 return energy;
304}
305
306
307/***********************************************************************//**
308 * @brief Return energy in eV
309 *
310 * @return Energy in eV.
311 ***************************************************************************/
312double GEnergy::eV(void) const
313{
314 // Compute energy
315 double energy = m_energy * 1.0e+6;
316
317 // Return energy
318 return energy;
319}
320
321
322/***********************************************************************//**
323 * @brief Return energy in keV
324 *
325 * @return Energy in keV.
326 ***************************************************************************/
327double GEnergy::keV(void) const
328{
329 // Compute energy
330 double energy = m_energy * 1.0e+3;
331
332 // Return energy
333 return energy;
334}
335
336
337/***********************************************************************//**
338 * @brief Return energy in MeV
339 *
340 * @return Energy in MeV.
341 ***************************************************************************/
342double GEnergy::MeV(void) const
343{
344 // Return energy
345 return m_energy;
346}
347
348
349/***********************************************************************//**
350 * @brief Return energy in GeV
351 *
352 * @return Energy in GeV.
353 ***************************************************************************/
354double GEnergy::GeV(void) const
355{
356 // Compute energy
357 double energy = m_energy * 1.0e-3;
358
359 // Return energy
360 return energy;
361}
362
363
364/***********************************************************************//**
365 * @brief Return energy in TeV
366 *
367 * @return Energy in TeV.
368 ***************************************************************************/
369double GEnergy::TeV(void) const
370{
371 // Compute energy
372 double energy = m_energy * 1.0e-6;
373
374 // Return energy
375 return energy;
376}
377
378
379/***********************************************************************//**
380 * @brief Return energy as wavelength in Angstrom
381 *
382 * @return Energy as wavelength in Angstrom (1e-10 metres).
383 *
384 * @exception GException::invalid_value
385 * Cannot convert zero energy into a wavelength.
386 ***************************************************************************/
387double GEnergy::Angstrom(void) const
388{
389 // Throw exception if energy is zero
390 if (m_energy == 0) {
392 "Cannot convert energy of 0 MeV into Angstrom.");
393 }
394
395 // Compute wavelength
396 double wavelength = gammalib::MeV2Angstrom/m_energy;
397
398 // Return wavelength in Angstrom
399 return wavelength;
400}
401
402
403/***********************************************************************//**
404 * @brief Return log10 of energy in erg
405 *
406 * @return Energy in log10 erg.
407 *
408 * Returns the log10 of the energy in erg.
409 ***************************************************************************/
410double GEnergy::log10erg(void) const
411{
412 // Set offset
413 const double offset = std::log10(gammalib::MeV2erg);
414
415 // Return log10 energy
416 return (log10MeV()+offset);
417}
418
419
420/***********************************************************************//**
421 * @brief Return log10 of energy in eV
422 *
423 * @return Energy in log10 eV.
424 *
425 * Returns the log10 of the energy in eV.
426 ***************************************************************************/
427double GEnergy::log10eV(void) const
428{
429 // Return log10 energy
430 return (log10MeV()+6.0);
431}
432
433
434/***********************************************************************//**
435 * @brief Return log10 of energy in keV
436 *
437 * @return Energy in log10 keV.
438 *
439 * Returns the log10 of the energy in keV.
440 ***************************************************************************/
441double GEnergy::log10keV(void) const
442{
443 // Return log10 energy
444 return (log10MeV()+3.0);
445}
446
447
448/***********************************************************************//**
449 * @brief Return log10 of energy in MeV
450 *
451 * @return Energy in log10 MeV.
452 *
453 * Returns the log10 of the energy in MeV. The result is stored internally
454 * and not recomputed when the method is called again with the same energy
455 * value. This speeds up computation. In case that the energy is not positive
456 * the method returns DBL_MIN.
457 ***************************************************************************/
458double GEnergy::log10MeV(void) const
459{
460 // If required compute log10 of energy.
461 if (!m_has_log10) {
462 m_elog10 = (m_energy > 0.0) ? std::log10(m_energy) : DBL_MIN;
463 m_has_log10 = true;
464 }
465
466 // Return log10 energy
467 return m_elog10;
468}
469
470
471/***********************************************************************//**
472 * @brief Return log10 of energy in GeV
473 *
474 * @return Energy in log10 GeV.
475 *
476 * Returns the log10 of the energy in GeV.
477 ***************************************************************************/
478double GEnergy::log10GeV(void) const
479{
480 // Return log10 energy
481 return (log10MeV()-3.0);
482}
483
484
485/***********************************************************************//**
486 * @brief Return log10 of energy in TeV
487 *
488 * @return Energy in log10 TeV.
489 *
490 * Returns the log10 of the energy in TeV.
491 ***************************************************************************/
492double GEnergy::log10TeV(void) const
493{
494 // Return log10 energy
495 return (log10MeV()-6.0);
496}
497
498
499/***********************************************************************//**
500 * @brief Set log10 of energy with unit specification
501 *
502 * @param[in] unit Unit of log10 of energy (one of erg(s), eV, keV, MeV, GeV, TeV).
503 * @return eng log10 of energy.
504 *
505 * @exception GException::invalid_argument
506 * Unit argument is not valid.
507 ***************************************************************************/
508double GEnergy::log10(const std::string& unit) const
509{
510 // Initialise result
511 double logE = 0.0;
512
513 // Set energy according to unit string
514 std::string eunit = gammalib::tolower(unit);
515 if (eunit == "erg" || eunit == "ergs") {
516 logE = this->log10erg();
517 }
518 else if (eunit == "ev") {
519 logE = this->log10eV();
520 }
521 else if (eunit == "kev") {
522 logE = this->log10keV();
523 }
524 else if (eunit == "mev") {
525 logE = this->log10MeV();
526 }
527 else if (eunit == "gev") {
528 logE = this->log10GeV();
529 }
530 else if (eunit == "tev") {
531 logE = this->log10TeV();
532 }
533 else {
535 "Valid energy units are \"erg(s)\", \"eV\", \"keV\", \"MeV\","
536 " \"GeV\", or \"TeV\" (case insensitive).");
537 }
538
539 // Return
540 return logE;
541}
542
543
544/***********************************************************************//**
545 * @brief Set energy in erg
546 *
547 * @param[in] eng Energy in erg.
548 ***************************************************************************/
549void GEnergy::erg(const double& eng)
550{
551 // Set energy
553
554 // Signals that log10 of energy is not valid
555 m_has_log10 = false;
556
557 // Return
558 return;
559}
560
561
562/***********************************************************************//**
563 * @brief Set energy in eV
564 *
565 * @param[in] eng Energy in eV.
566 ***************************************************************************/
567void GEnergy::eV(const double& eng)
568{
569 // Set energy
570 m_energy = eng * 1.0e-6;
571
572 // Signals that log10 of energy is not valid
573 m_has_log10 = false;
574
575 // Return
576 return;
577}
578
579
580/***********************************************************************//**
581 * @brief Set energy in keV
582 *
583 * @param[in] eng Energy in keV.
584 ***************************************************************************/
585void GEnergy::keV(const double& eng)
586{
587 // Set energy
588 m_energy = eng * 1.0e-3;
589
590 // Signals that log10 of energy is not valid
591 m_has_log10 = false;
592
593 // Return
594 return;
595}
596
597
598/***********************************************************************//**
599 * @brief Set energy in MeV
600 *
601 * @param[in] eng Energy in MeV.
602 ***************************************************************************/
603void GEnergy::MeV(const double& eng)
604{
605 // Set energy
606 m_energy = eng;
607
608 // Signals that log10 of energy is not valid
609 m_has_log10 = false;
610
611 // Return
612 return;
613}
614
615
616/***********************************************************************//**
617 * @brief Set energy in GeV
618 *
619 * @param[in] eng Energy in GeV.
620 ***************************************************************************/
621void GEnergy::GeV(const double& eng)
622{
623 // Set energy
624 m_energy = eng * 1.0e+3;
625
626 // Signals that log10 of energy is not valid
627 m_has_log10 = false;
628
629 // Return
630 return;
631}
632
633
634/***********************************************************************//**
635 * @brief Set energy in TeV
636 *
637 * @param[in] eng Energy in TeV.
638 ***************************************************************************/
639void GEnergy::TeV(const double& eng)
640{
641 // Set energy
642 m_energy = eng * 1.0e+6;
643
644 // Signals that log10 of energy is not valid
645 m_has_log10 = false;
646
647 // Return
648 return;
649}
650
651
652/***********************************************************************//**
653 * @brief Set energy from wavelength in Angstrom
654 *
655 * @param[in] wavelength Wavelength in Angstrom.
656 *
657 * @exception GException::invalid_argument
658 * Cannot set energy from zero wavelength.
659 ***************************************************************************/
660void GEnergy::Angstrom(const double& wavelength)
661{
662 // Throw exception if wavelength is zero
663 if (wavelength == 0) {
665 "Cannot set energy from a wavelength that is zero.");
666 }
667
668 // Set energy
669 m_energy = gammalib::MeV2Angstrom / wavelength;
670
671 // Signals that log10 of energy is not valid
672 m_has_log10 = false;
673
674 // Return
675 return;
676}
677
678
679/***********************************************************************//**
680 * @brief Set log10 of energy in erg
681 *
682 * @param[in] eng log10 of energy in erg.
683 ***************************************************************************/
684void GEnergy::log10erg(const double& eng)
685{
686 // Set offset
687 const double offset = std::log10(gammalib::MeV2erg);
688
689 // Set energy
690 log10MeV(eng-offset);
691
692 // Return
693 return;
694}
695
696
697/***********************************************************************//**
698 * @brief Set log10 of energy in eV
699 *
700 * @param[in] eng log10 of energy in eV.
701 ***************************************************************************/
702void GEnergy::log10eV(const double& eng)
703{
704 // Set energy
705 log10MeV(eng-6.0);
706
707 // Return
708 return;
709}
710
711
712/***********************************************************************//**
713 * @brief Set log10 of energy in keV
714 *
715 * @param[in] eng log10 of energy in keV.
716 ***************************************************************************/
717void GEnergy::log10keV(const double& eng)
718{
719 // Set energy
720 log10MeV(eng-3.0);
721
722 // Return
723 return;
724}
725
726
727/***********************************************************************//**
728 * @brief Set log10 of energy in MeV
729 *
730 * @param[in] eng log10 of energy in MeV.
731 ***************************************************************************/
732void GEnergy::log10MeV(const double& eng)
733{
734 // Set energy
735 m_elog10 = eng;
736 m_energy = std::pow(10.0, eng);
737 m_has_log10 = true;
738
739 // Return
740 return;
741}
742
743
744/***********************************************************************//**
745 * @brief Set log10 of energy in GeV
746 *
747 * @param[in] eng log10 of energy in GeV.
748 ***************************************************************************/
749void GEnergy::log10GeV(const double& eng)
750{
751 // Set energy
752 log10MeV(eng+3.0);
753
754 // Return
755 return;
756}
757
758
759/***********************************************************************//**
760 * @brief Set log10 of energy in TeV
761 *
762 * @param[in] eng log10 of energy in TeV.
763 ***************************************************************************/
764void GEnergy::log10TeV(const double& eng)
765{
766 // Set energy
767 log10MeV(eng+6.0);
768
769 // Return
770 return;
771}
772
773
774/***********************************************************************//**
775 * @brief Set log10 of energy with unit specification
776 *
777 * @param[in] eng log10 of energy.
778 * @param[in] unit Unit of log10 of energy (one of erg(s), eV, keV, MeV, GeV, TeV).
779 *
780 * @exception GException::invalid_argument
781 * Unit argument is not valid.
782 ***************************************************************************/
783void GEnergy::log10(const double& eng, const std::string& unit)
784{
785 // Set energy according to unit string
786 std::string eunit = gammalib::tolower(unit);
787 if (eunit == "erg" || eunit == "ergs") {
788 this->log10erg(eng);
789 }
790 else if (eunit == "ev") {
791 this->log10eV(eng);
792 }
793 else if (eunit == "kev") {
794 this->log10keV(eng);
795 }
796 else if (eunit == "mev") {
797 this->log10MeV(eng);
798 }
799 else if (eunit == "gev") {
800 this->log10GeV(eng);
801 }
802 else if (eunit == "tev") {
803 this->log10TeV(eng);
804 }
805 else {
807 "Valid energy units are \"erg(s)\", \"eV\", \"keV\", \"MeV\","
808 " \"GeV\", or \"TeV\" (case insensitive).");
809 }
810
811 // Return
812 return;
813}
814
815
816/***********************************************************************//**
817 * @brief Print energy
818 *
819 * @param[in] chatter Chattiness.
820 * @return String containing energy information.
821 ***************************************************************************/
822std::string GEnergy::print(const GChatter& chatter) const
823{
824 // Initialise result string
825 std::string result;
826
827 // Continue only if chatter is not silent
828 if (chatter != SILENT) {
829
830 // Append energy
831 if (TeV() >= 1000.0) {
832 result.append(gammalib::str(TeV()/1000.0)+" PeV");
833 }
834 else if (GeV() >= 1000.0) {
835 result.append(gammalib::str(TeV())+" TeV");
836 }
837 else if (MeV() >= 1000.0) {
838 result.append(gammalib::str(GeV())+" GeV");
839 }
840 else if (keV() >= 1000.0) {
841 result.append(gammalib::str(MeV())+" MeV");
842 }
843 else if (eV() >= 1000.0) {
844 result.append(gammalib::str(keV())+" keV");
845 }
846 else {
847 result.append(gammalib::str(eV())+" eV");
848 }
849
850 // VERBOSE: append energy and log10 energy
851 if (chatter == VERBOSE) {
852 result.append(" (E="+gammalib::str(m_energy));
853 if (m_has_log10) {
854 result.append(", log10(E)="+gammalib::str(m_elog10)+")");
855 }
856 else {
857 result.append(", no log10(E) value)");
858 }
859 }
860
861 } // endif: chatter was not silent
862
863 // Return
864 return result;
865}
866
867
868/*==========================================================================
869 = =
870 = Private methods =
871 = =
872 ==========================================================================*/
873
874/***********************************************************************//**
875 * @brief Initialise class members
876 ***************************************************************************/
878{
879 // Initialise members
880 m_energy = 0.0;
881 m_elog10 = DBL_MIN;
882 m_has_log10 = false;
883
884 // Return
885 return;
886}
887
888
889/***********************************************************************//**
890 * @brief Copy class members
891 *
892 * @param[in] eng Energy.
893 ***************************************************************************/
895{
896 // Copy time
897 m_energy = eng.m_energy;
898 m_elog10 = eng.m_elog10;
900
901 // Return
902 return;
903}
904
905
906/***********************************************************************//**
907 * @brief Delete class members
908 ***************************************************************************/
910{
911 // Return
912 return;
913}
#define G_ANGSTROM_GET
Definition GEnergy.cpp:43
#define G_OPERATOR1
Definition GEnergy.cpp:41
#define G_LOG10_SET
Definition GEnergy.cpp:46
#define G_OPERATOR2
Definition GEnergy.cpp:42
#define G_LOG10_GET
Definition GEnergy.cpp:45
#define G_ANGSTROM_SET
Definition GEnergy.cpp:44
Energy value class definition.
Exception handler interface definition.
Gammalib tools definition.
GChatter
Definition GTypemaps.hpp:33
@ SILENT
Definition GTypemaps.hpp:34
@ VERBOSE
Definition GTypemaps.hpp:38
Class that handles energies in a unit independent way.
Definition GEnergy.hpp:48
double log10(const std::string &unit) const
Set log10 of energy with unit specification.
Definition GEnergy.cpp:508
double GeV(void) const
Return energy in GeV.
Definition GEnergy.cpp:354
double Angstrom(void) const
Return energy as wavelength in Angstrom.
Definition GEnergy.cpp:387
double m_energy
Energy in MeV.
Definition GEnergy.hpp:121
double keV(void) const
Return energy in keV.
Definition GEnergy.cpp:327
void operator()(const double &eng, const std::string &unit)
Unit set operator.
Definition GEnergy.cpp:172
double log10TeV(void) const
Return log10 of energy in TeV.
Definition GEnergy.cpp:492
double log10GeV(void) const
Return log10 of energy in GeV.
Definition GEnergy.cpp:478
double MeV(void) const
Return energy in MeV.
Definition GEnergy.cpp:342
double log10MeV(void) const
Return log10 of energy in MeV.
Definition GEnergy.cpp:458
void free_members(void)
Delete class members.
Definition GEnergy.cpp:909
GEnergy(void)
Void constructor.
Definition GEnergy.cpp:64
void copy_members(const GEnergy &eng)
Copy class members.
Definition GEnergy.cpp:894
std::string print(const GChatter &chatter=NORMAL) const
Print energy.
Definition GEnergy.cpp:822
double log10keV(void) const
Return log10 of energy in keV.
Definition GEnergy.cpp:441
GEnergy & operator=(const GEnergy &eng)
Assignment operator.
Definition GEnergy.cpp:139
void clear(void)
Clear instance.
Definition GEnergy.cpp:267
double TeV(void) const
Return energy in TeV.
Definition GEnergy.cpp:369
double erg(void) const
Return energy in erg.
Definition GEnergy.cpp:297
double log10erg(void) const
Return log10 of energy in erg.
Definition GEnergy.cpp:410
void init_members(void)
Initialise class members.
Definition GEnergy.cpp:877
virtual ~GEnergy(void)
Destructor.
Definition GEnergy.cpp:117
double log10eV(void) const
Return log10 of energy in eV.
Definition GEnergy.cpp:427
bool m_has_log10
log10 of energy is valid
Definition GEnergy.hpp:123
GEnergy * clone(void) const
Clone object.
Definition GEnergy.cpp:285
double m_elog10
log10 of energy in MeV
Definition GEnergy.hpp:122
double eV(void) const
Return energy in eV.
Definition GEnergy.cpp:312
const double erg2MeV
Definition GTools.hpp:46
std::string str(const unsigned short int &value)
Convert unsigned short integer value into string.
Definition GTools.cpp:508
std::string tolower(const std::string &s)
Convert string to lower case.
Definition GTools.cpp:974
std::string strip_whitespace(const std::string &arg)
Strip leading and trailing whitespace from string.
Definition GTools.cpp:99
const double MeV2Angstrom
Definition GTools.hpp:47
const double MeV2erg
Definition GTools.hpp:45