Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
LXeRun Class Reference

#include <LXeRun.hh>

Inheritance diagram for LXeRun:
G4Run

Public Member Functions

 LXeRun ()=default
 
 ~LXeRun () override=default
 
void IncPhotonCount_Scint (G4int count)
 
void IncPhotonCount_Ceren (G4int count)
 
void IncEDep (G4double dep)
 
void IncAbsorption (G4int count)
 
void IncBoundaryAbsorption (G4int count)
 
void IncHitCount (G4int count)
 
void IncHitsAboveThreshold (G4int count)
 
void Merge (const G4Run *run) override
 
void EndOfRun ()
 

Private Attributes

G4int fHitCount = 0
 
G4int fHitCount2 = 0
 
G4int fPhotonCount_Scint = 0
 
G4int fPhotonCount_Scint2 = 0
 
G4int fPhotonCount_Ceren = 0
 
G4int fPhotonCount_Ceren2 = 0
 
G4int fAbsorptionCount = 0
 
G4int fAbsorptionCount2 = 0
 
G4int fBoundaryAbsorptionCount = 0
 
G4int fBoundaryAbsorptionCount2 = 0
 
G4int fPMTsAboveThreshold = 0
 
G4int fPMTsAboveThreshold2 = 0
 
G4double fTotE = 0.
 
G4double fTotE2 = 0.
 

Detailed Description

Definition at line 41 of file LXeRun.hh.

Constructor & Destructor Documentation

◆ LXeRun()

LXeRun::LXeRun ( )
default

◆ ~LXeRun()

LXeRun::~LXeRun ( )
overridedefault

Member Function Documentation

◆ IncPhotonCount_Scint()

void LXeRun::IncPhotonCount_Scint ( G4int  count)
inline

Definition at line 47 of file LXeRun.hh.

48 {
49 fPhotonCount_Scint += count;
50 fPhotonCount_Scint2 += count * count;
51 }
G4int fPhotonCount_Scint
Definition LXeRun.hh:90
G4int fPhotonCount_Scint2
Definition LXeRun.hh:91

◆ IncPhotonCount_Ceren()

void LXeRun::IncPhotonCount_Ceren ( G4int  count)
inline

Definition at line 52 of file LXeRun.hh.

53 {
54 fPhotonCount_Ceren += count;
55 fPhotonCount_Ceren2 += count * count;
56 }
G4int fPhotonCount_Ceren
Definition LXeRun.hh:92
G4int fPhotonCount_Ceren2
Definition LXeRun.hh:93

◆ IncEDep()

void LXeRun::IncEDep ( G4double  dep)
inline

Definition at line 57 of file LXeRun.hh.

58 {
59 fTotE += dep;
60 fTotE2 += dep * dep;
61 }
G4double fTotE
Definition LXeRun.hh:101
G4double fTotE2
Definition LXeRun.hh:102

◆ IncAbsorption()

void LXeRun::IncAbsorption ( G4int  count)
inline

Definition at line 62 of file LXeRun.hh.

63 {
64 fAbsorptionCount += count;
65 fAbsorptionCount2 += count * count;
66 }
G4int fAbsorptionCount2
Definition LXeRun.hh:95
G4int fAbsorptionCount
Definition LXeRun.hh:94

◆ IncBoundaryAbsorption()

void LXeRun::IncBoundaryAbsorption ( G4int  count)
inline

Definition at line 67 of file LXeRun.hh.

68 {
70 fBoundaryAbsorptionCount2 += count * count;
71 }
G4int fBoundaryAbsorptionCount2
Definition LXeRun.hh:97
G4int fBoundaryAbsorptionCount
Definition LXeRun.hh:96

◆ IncHitCount()

void LXeRun::IncHitCount ( G4int  count)
inline

Definition at line 72 of file LXeRun.hh.

73 {
74 fHitCount += count;
75 fHitCount2 += count * count;
76 }
G4int fHitCount2
Definition LXeRun.hh:89
G4int fHitCount
Definition LXeRun.hh:88

◆ IncHitsAboveThreshold()

void LXeRun::IncHitsAboveThreshold ( G4int  count)
inline

Definition at line 77 of file LXeRun.hh.

78 {
79 fPMTsAboveThreshold += count;
80 fPMTsAboveThreshold2 += count * count;
81 }
G4int fPMTsAboveThreshold2
Definition LXeRun.hh:99
G4int fPMTsAboveThreshold
Definition LXeRun.hh:98

◆ Merge()

void LXeRun::Merge ( const G4Run run)
override

Definition at line 39 of file LXeRun.cc.

40{
41 const auto localRun = static_cast<const LXeRun*>(run);
42
43 fHitCount += localRun->fHitCount;
44 fHitCount2 += localRun->fHitCount2;
45 fPMTsAboveThreshold += localRun->fPMTsAboveThreshold;
46 fPMTsAboveThreshold2 += localRun->fPMTsAboveThreshold2;
47 fPhotonCount_Scint += localRun->fPhotonCount_Scint;
48 fPhotonCount_Scint2 += localRun->fPhotonCount_Scint2;
49 fPhotonCount_Ceren += localRun->fPhotonCount_Ceren;
50 fPhotonCount_Ceren2 += localRun->fPhotonCount_Ceren2;
51 fAbsorptionCount += localRun->fAbsorptionCount;
52 fAbsorptionCount2 += localRun->fAbsorptionCount2;
53 fBoundaryAbsorptionCount += localRun->fBoundaryAbsorptionCount;
54 fBoundaryAbsorptionCount2 += localRun->fBoundaryAbsorptionCount2;
55 fTotE += localRun->fTotE;
56 fTotE2 += localRun->fTotE2;
57
58 G4Run::Merge(run);
59}

◆ EndOfRun()

void LXeRun::EndOfRun ( )

Definition at line 63 of file LXeRun.cc.

64{
65 G4cout << "\n ======================== run summary ======================\n";
66
67 G4int prec = G4cout.precision();
68
69 auto n_evt = (G4double) numberOfEvent;
70 G4cout << "The run was " << numberOfEvent << " events." << G4endl;
71
72 G4cout.precision(4);
73 G4double hits = G4double(fHitCount) / n_evt;
74 G4double hits2 = G4double(fHitCount2) / n_evt;
75 G4double rms_hits = hits2 - hits * hits;
76 if(rms_hits > 0.)
77 rms_hits = std::sqrt(rms_hits / n_evt);
78 else
79 rms_hits = 0.;
80 G4cout << "Number of hits per event:\t " << hits << " +- " << rms_hits
81 << G4endl;
82
83 G4double hitsAbove = G4double(fPMTsAboveThreshold) / n_evt;
84 G4double hitsAbove2 = G4double(fPMTsAboveThreshold2) / n_evt;
85 G4double rms_hitsAbove = hitsAbove2 - hitsAbove * hitsAbove;
86 if(rms_hitsAbove > 0.)
87 rms_hitsAbove = std::sqrt(rms_hitsAbove / n_evt);
88 else
89 rms_hitsAbove = 0.;
90
91 G4cout << "Number of hits per event above threshold:\t " << hitsAbove
92 << " +- " << rms_hitsAbove << G4endl;
93
94 G4double scint = G4double(fPhotonCount_Scint) / n_evt;
95 G4double scint2 = G4double(fPhotonCount_Scint2) / n_evt;
96 G4double rms_scint = scint2 - scint * scint;
97 if(rms_scint > 0.)
98 rms_scint = std::sqrt(rms_scint / n_evt);
99 else
100 rms_scint = 0.;
101
102 G4cout << "Number of scintillation photons per event :\t " << scint << " +- "
103 << rms_scint << G4endl;
104
105 G4double ceren = G4double(fPhotonCount_Ceren) / n_evt;
106 G4double ceren2 = G4double(fPhotonCount_Ceren2) / n_evt;
107 G4double rms_ceren = ceren2 - ceren * ceren;
108 if(rms_ceren > 0.)
109 rms_ceren = std::sqrt(rms_ceren / n_evt);
110 else
111 rms_ceren = 0.;
112
113 G4cout << "Number of Cerenkov photons per event:\t " << ceren << " +- "
114 << rms_ceren << G4endl;
115
116 G4double absorb = G4double(fAbsorptionCount) / n_evt;
117 G4double absorb2 = G4double(fAbsorptionCount2) / n_evt;
118 G4double rms_absorb = absorb2 - absorb * absorb;
119 if(rms_absorb > 0.)
120 rms_absorb = std::sqrt(rms_absorb / n_evt);
121 else
122 rms_absorb = 0.;
123
124 G4cout << "Number of absorbed photons per event :\t " << absorb << " +- "
125 << rms_absorb << G4endl;
126
127 G4double bdry = G4double(fBoundaryAbsorptionCount) / n_evt;
128 G4double bdry2 = G4double(fBoundaryAbsorptionCount2) / n_evt;
129 G4double rms_bdry = bdry2 - bdry * bdry;
130 if(rms_bdry > 0.)
131 rms_bdry = std::sqrt(rms_bdry / n_evt);
132 else
133 rms_bdry = 0.;
134
135 G4cout << "Number of photons absorbed at boundary per event:\t " << bdry
136 << " +- " << rms_bdry << G4endl;
137
138 G4double en = fTotE / n_evt;
139 G4double en2 = fTotE2 / n_evt;
140 G4double rms_en = en2 - en * en;
141 if(rms_en > 0.)
142 rms_en = std::sqrt(rms_en / n_evt);
143 else
144 rms_en = 0.;
145
146 G4cout << "Total energy deposition in scintillator per event:\t " << en / keV
147 << " +- " << rms_en / keV << " keV." << G4endl;
148
149 G4cout << G4endl;
150 G4cout.precision(prec);
151}

Member Data Documentation

◆ fHitCount

G4int LXeRun::fHitCount = 0
private

Definition at line 88 of file LXeRun.hh.

◆ fHitCount2

G4int LXeRun::fHitCount2 = 0
private

Definition at line 89 of file LXeRun.hh.

◆ fPhotonCount_Scint

G4int LXeRun::fPhotonCount_Scint = 0
private

Definition at line 90 of file LXeRun.hh.

◆ fPhotonCount_Scint2

G4int LXeRun::fPhotonCount_Scint2 = 0
private

Definition at line 91 of file LXeRun.hh.

◆ fPhotonCount_Ceren

G4int LXeRun::fPhotonCount_Ceren = 0
private

Definition at line 92 of file LXeRun.hh.

◆ fPhotonCount_Ceren2

G4int LXeRun::fPhotonCount_Ceren2 = 0
private

Definition at line 93 of file LXeRun.hh.

◆ fAbsorptionCount

G4int LXeRun::fAbsorptionCount = 0
private

Definition at line 94 of file LXeRun.hh.

◆ fAbsorptionCount2

G4int LXeRun::fAbsorptionCount2 = 0
private

Definition at line 95 of file LXeRun.hh.

◆ fBoundaryAbsorptionCount

G4int LXeRun::fBoundaryAbsorptionCount = 0
private

Definition at line 96 of file LXeRun.hh.

◆ fBoundaryAbsorptionCount2

G4int LXeRun::fBoundaryAbsorptionCount2 = 0
private

Definition at line 97 of file LXeRun.hh.

◆ fPMTsAboveThreshold

G4int LXeRun::fPMTsAboveThreshold = 0
private

Definition at line 98 of file LXeRun.hh.

◆ fPMTsAboveThreshold2

G4int LXeRun::fPMTsAboveThreshold2 = 0
private

Definition at line 99 of file LXeRun.hh.

◆ fTotE

G4double LXeRun::fTotE = 0.
private

Definition at line 101 of file LXeRun.hh.

◆ fTotE2

G4double LXeRun::fTotE2 = 0.
private

Definition at line 102 of file LXeRun.hh.


The documentation for this class was generated from the following files:

Applications | User Support | Publications | Collaboration