GTestEventBin.hpp
5.62 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
/***************************************************************************
* GTestEventBin.hpp - Test event bin class *
* ----------------------------------------------------------------------- *
* copyright (C) 2012 by Jean-Baptiste Cayrou *
* ----------------------------------------------------------------------- *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
***************************************************************************/
#ifndef GTESTEVENTBIN_HPP
#define GTESTEVENTBIN_HPP
/* __ Includes ___________________________________________________________ */
#include <string>
#include "GEventBin.hpp"
#include "GEnergy.hpp"
#include "GTime.hpp"
#include "GTestInstDir.hpp"
class GTestEventBin : public GEventBin {
// Friend classes
friend class GTestEventCube;
public:
// Constructors and destructors
GTestEventBin(void) : GEventBin(){
init_members();
return;
}
GTestEventBin(const GTestEventBin& bin) : GEventBin(bin){
init_members();
copy_members(bin);
return;
}
virtual ~GTestEventBin(void){
free_members();
return;
}
// Operators
virtual GTestEventBin& operator= (const GTestEventBin& bin){
// Execute only if object is not identical
if (this != &bin) {
// Copy base class members
this->GEventBin::operator=(bin);
// Free members
free_members();
// Initialise private members for clean destruction
init_members();
// Copy members
copy_members(bin);
} // endif: object was not identical
// Return this object
return *this;
}
// Implemented pure virtual base class methods
virtual void clear(void){
// Free class members (base and derived classes, derived class first)
free_members();
this->GEventBin::free_members();
this->GEvent::free_members();
// Initialise members
this->GEvent::init_members();
this->GEventBin::init_members();
init_members();
// Return
return;
}
virtual GTestEventBin* clone(void) const{ return new GTestEventBin(*this); }
virtual std::string classname(void) const { return "GTestEventBin"; }
virtual double size(void) const{
// Compute bin size
double size = ewidth().MeV() * ontime();
// Return bin size
return size;
}
virtual const GTestInstDir& dir(void) const { return m_dir; }
virtual const GEnergy& energy(void) const { return m_energy; }
virtual const GTime& time(void) const { return m_time; }
virtual double counts(void) const { return m_counts; }
virtual double error(void) const{
// Compute uncertainty
double error = sqrt(counts()+1.0e-50);
// Return error
return error;
}
virtual void counts(const double& counts) { m_counts=counts; }
virtual std::string print(const GChatter& chatter = NORMAL) const{
// Initialise result string
std::string result;
// Append number of counts
result.append(gammalib::str(counts()));
// Return result
return result;
}
// Other methods
const GEnergy ewidth(void) const { return m_ewidth; }
const double& ontime(void) const { return m_ontime; }
void energy(GEnergy energy){ m_energy=energy;}
void dir(GTestInstDir dir){ m_dir=dir;}
void time(GTime time){ m_time=time;}
void ewidth(GEnergy ewidth){ m_ewidth=ewidth;}
void ontime(double ontime){ m_ontime=ontime;}
protected:
// Protected methods
void init_members(void){
// Initialise members
m_counts=0;
m_ontime=0;
// Return
return;
}
void copy_members(const GTestEventBin& bin){
// Copy members
m_energy = bin.m_energy;
m_dir = bin.m_dir;
m_time = bin.m_time;
m_counts = bin.m_counts;
m_ewidth = bin.m_ewidth;
m_ontime = bin.m_ontime;
// Return
return;
}
void free_members(void){ return; }
// Protected members
GEnergy m_energy; //!< Pointer to bin energy
GTestInstDir m_dir; //!< Pointer to bin direction
GTime m_time; //!< Pointer to bin time
double m_counts; //!< Pointer to number of counts
GEnergy m_ewidth; //!< Pointer to energy width of bin
double m_ontime; //!< Pointer to ontime of bin (seconds)
};
#endif /* GTestEVENTBIN_HPP */