| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 /// \file optical/OpNovice2/include/RunAction. 26 /// \file optical/OpNovice2/include/RunAction.hh
27 /// \brief Definition of the RunAction class 27 /// \brief Definition of the RunAction class
28 // 28 //
29 //....oooOO0OOooo........oooOO0OOooo........oo 29 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
30 //....oooOO0OOooo........oooOO0OOooo........oo 30 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
31 31
32 #ifndef Run_h 32 #ifndef Run_h
33 #define Run_h 1 33 #define Run_h 1
34 34
35 #include "G4OpBoundaryProcess.hh" 35 #include "G4OpBoundaryProcess.hh"
36 #include "G4Run.hh" 36 #include "G4Run.hh"
37 37
38 class G4ParticleDefinition; 38 class G4ParticleDefinition;
39 39
40 //....oooOO0OOooo........oooOO0OOooo........oo 40 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
41 class Run : public G4Run 41 class Run : public G4Run
42 { 42 {
43 public: << 43 public:
44 Run(); << 44 Run();
45 ~Run() override = default; << 45 ~Run();
46 << 46
47 void SetPrimary(G4ParticleDefinition* part << 47 void SetPrimary(G4ParticleDefinition* particle, G4double energy,
48 G4double polarization); << 48 G4bool polarized, G4double polarization);
49 << 49
50 // particle energy << 50 // particle energy
51 void AddCerenkovEnergy(G4double en) { fCer << 51 void AddCerenkovEnergy(G4double en) { fCerenkovEnergy += en; }
52 void AddScintillationEnergy(G4double en) { << 52 void AddScintillationEnergy(G4double en) { fScintEnergy += en; }
53 void AddWLSAbsorptionEnergy(G4double en) { << 53 void AddWLSAbsorptionEnergy(G4double en) { fWLSAbsorptionEnergy += en; }
54 void AddWLSEmissionEnergy(G4double en) { f << 54 void AddWLSEmissionEnergy(G4double en) { fWLSEmissionEnergy += en; }
55 void AddWLS2AbsorptionEnergy(G4double en) << 55 void AddWLS2AbsorptionEnergy(G4double en) { fWLS2AbsorptionEnergy += en; }
56 void AddWLS2EmissionEnergy(G4double en) { << 56 void AddWLS2EmissionEnergy(G4double en) { fWLS2EmissionEnergy += en; }
57 << 57
58 // number of particles << 58 // number of particles
59 void AddCerenkov() { fCerenkovCount += 1; << 59 void AddCerenkov(void) { fCerenkovCount += 1; }
60 void AddScintillation() { fScintCount += 1 << 60 void AddScintillation(void) { fScintCount += 1; }
61 void AddRayleigh() { fRayleighCount += 1; << 61 void AddRayleigh(void) { fRayleighCount += 1; }
62 void AddWLSAbsorption() { fWLSAbsorptionCo << 62 void AddWLSAbsorption(void) { fWLSAbsorptionCount += 1; }
63 void AddWLSEmission() { fWLSEmissionCount << 63 void AddWLSEmission(void) { fWLSEmissionCount += 1; }
64 void AddWLS2Absorption() { fWLS2Absorption << 64 void AddWLS2Absorption(void) { fWLS2AbsorptionCount += 1; }
65 void AddWLS2Emission() { fWLS2EmissionCoun << 65 void AddWLS2Emission(void) { fWLS2EmissionCount += 1; }
66 << 66
67 void AddOpAbsorption() { fOpAbsorption += << 67 void AddOpAbsorption(void) { fOpAbsorption += 1; }
68 void AddOpAbsorptionPrior() { fOpAbsorptio << 68 void AddOpAbsorptionPrior(void) { fOpAbsorptionPrior += 1; }
69 << 69
70 void AddFresnelRefraction() { fBoundaryPro << 70 void AddFresnelRefraction(void) { fBoundaryProcs[FresnelRefraction] += 1; }
71 void AddFresnelReflection() { fBoundaryPro << 71 void AddFresnelReflection(void) { fBoundaryProcs[FresnelReflection] += 1; }
72 void AddTransmission() { fBoundaryProcs[Tr << 72 void AddTransmission(void) { fBoundaryProcs[Transmission] += 1; }
73 void AddTotalInternalReflection() { fBound << 73 void AddTotalInternalReflection(void)
74 void AddLambertianReflection() { fBoundary << 74 {
75 void AddLobeReflection() { fBoundaryProcs[ << 75 fBoundaryProcs[TotalInternalReflection] += 1;
76 void AddSpikeReflection() { fBoundaryProcs << 76 }
77 void AddBackScattering() { fBoundaryProcs[ << 77 void AddLambertianReflection(void)
78 void AddAbsorption() { fBoundaryProcs[Abso << 78 {
79 void AddDetection() { fBoundaryProcs[Detec << 79 fBoundaryProcs[LambertianReflection] += 1;
80 void AddNotAtBoundary() { fBoundaryProcs[N << 80 }
81 void AddSameMaterial() { fBoundaryProcs[Sa << 81 void AddLobeReflection(void) { fBoundaryProcs[LobeReflection] += 1; }
82 void AddStepTooSmall() { fBoundaryProcs[St << 82 void AddSpikeReflection(void) { fBoundaryProcs[SpikeReflection] += 1; }
83 void AddNoRINDEX() { fBoundaryProcs[NoRIND << 83 void AddBackScattering(void) { fBoundaryProcs[BackScattering] += 1; }
84 << 84 void AddAbsorption(void) { fBoundaryProcs[Absorption] += 1; }
85 void AddTotalSurface() { fTotalSurface += << 85 void AddDetection(void) { fBoundaryProcs[Detection] += 1; }
86 void AddPolishedLumirrorAirReflection() { << 86 void AddNotAtBoundary(void) { fBoundaryProcs[NotAtBoundary] += 1; }
87 void AddPolishedLumirrorGlueReflection() << 87 void AddSameMaterial(void) { fBoundaryProcs[SameMaterial] += 1; }
88 { << 88 void AddStepTooSmall(void) { fBoundaryProcs[StepTooSmall] += 1; }
89 fBoundaryProcs[PolishedLumirrorGlueRefle << 89 void AddNoRINDEX(void) { fBoundaryProcs[NoRINDEX] += 1; }
90 } << 90
91 void AddPolishedAirReflection() { fBoundar << 91 void AddTotalSurface(void) { fTotalSurface += 1; }
92 void AddPolishedTeflonAirReflection() { fB << 92 void AddPolishedLumirrorAirReflection(void)
93 void AddPolishedTiOAirReflection() { fBoun << 93 {
94 void AddPolishedTyvekAirReflection() { fBo << 94 fBoundaryProcs[PolishedLumirrorAirReflection] += 1;
95 void AddPolishedVM2000AirReflection() { fB << 95 }
96 void AddPolishedVM2000GlueReflection() { f << 96 void AddPolishedLumirrorGlueReflection(void)
97 << 97 {
98 void AddEtchedLumirrorAirReflection() { fB << 98 fBoundaryProcs[PolishedLumirrorGlueReflection] += 1;
99 void AddEtchedLumirrorGlueReflection() { f << 99 }
100 void AddEtchedAirReflection() { fBoundaryP << 100 void AddPolishedAirReflection(void)
101 void AddEtchedTeflonAirReflection() { fBou << 101 {
102 void AddEtchedTiOAirReflection() { fBounda << 102 fBoundaryProcs[PolishedAirReflection] += 1;
103 void AddEtchedTyvekAirReflection() { fBoun << 103 }
104 void AddEtchedVM2000AirReflection() { fBou << 104 void AddPolishedTeflonAirReflection(void)
105 void AddEtchedVM2000GlueReflection() { fBo << 105 {
106 << 106 fBoundaryProcs[PolishedTeflonAirReflection] += 1;
107 void AddGroundLumirrorAirReflection() { fB << 107 }
108 void AddGroundLumirrorGlueReflection() { f << 108 void AddPolishedTiOAirReflection(void)
109 void AddGroundAirReflection() { fBoundaryP << 109 {
110 void AddGroundTeflonAirReflection() { fBou << 110 fBoundaryProcs[PolishedTiOAirReflection] += 1;
111 void AddGroundTiOAirReflection() { fBounda << 111 }
112 void AddGroundTyvekAirReflection() { fBoun << 112 void AddPolishedTyvekAirReflection(void)
113 void AddGroundVM2000AirReflection() { fBou << 113 {
114 void AddGroundVM2000GlueReflection() { fBo << 114 fBoundaryProcs[PolishedTyvekAirReflection] += 1;
115 << 115 }
116 void AddDichroic() { fBoundaryProcs[Dichro << 116 void AddPolishedVM2000AirReflection(void)
117 void AddCoatedDielectricRefraction() { fBo << 117 {
118 void AddCoatedDielectricReflection() { fBo << 118 fBoundaryProcs[PolishedVM2000AirReflection] += 1;
119 void AddCoatedDielectricFrustratedTransmis << 119 }
120 { << 120 void AddPolishedVM2000GlueReflection(void)
121 fBoundaryProcs[CoatedDielectricFrustrate << 121 {
122 } << 122 fBoundaryProcs[PolishedVM2000GlueReflection] += 1;
123 << 123 }
124 void Merge(const G4Run*) override; << 124
125 << 125 void AddEtchedLumirrorAirReflection(void)
126 void EndOfRun(); << 126 {
127 << 127 fBoundaryProcs[EtchedLumirrorAirReflection] += 1;
128 private: << 128 }
129 // primary particle << 129 void AddEtchedLumirrorGlueReflection(void)
130 G4ParticleDefinition* fParticle = nullptr; << 130 {
131 G4double fEkin = -1.; << 131 fBoundaryProcs[EtchedLumirrorGlueReflection] += 1;
132 G4bool fPolarized = false; << 132 }
133 G4double fPolarization = 0.; << 133 void AddEtchedAirReflection(void)
134 << 134 {
135 G4double fCerenkovEnergy = 0.; << 135 fBoundaryProcs[EtchedAirReflection] += 1;
136 G4double fScintEnergy = 0.; << 136 }
137 G4double fWLSAbsorptionEnergy = 0.; << 137 void AddEtchedTeflonAirReflection(void)
138 G4double fWLSEmissionEnergy = 0.; << 138 {
139 G4double fWLS2AbsorptionEnergy = 0.; << 139 fBoundaryProcs[EtchedTeflonAirReflection] += 1;
140 G4double fWLS2EmissionEnergy = 0.; << 140 }
141 << 141 void AddEtchedTiOAirReflection(void)
142 // number of particles << 142 {
143 G4int fCerenkovCount = 0; << 143 fBoundaryProcs[EtchedTiOAirReflection] += 1;
144 G4int fScintCount = 0; << 144 }
145 G4int fWLSAbsorptionCount = 0; << 145 void AddEtchedTyvekAirReflection(void)
146 G4int fWLSEmissionCount = 0; << 146 {
147 G4int fWLS2AbsorptionCount = 0; << 147 fBoundaryProcs[EtchedTyvekAirReflection] += 1;
148 G4int fWLS2EmissionCount = 0; << 148 }
149 // number of events << 149 void AddEtchedVM2000AirReflection(void)
150 G4int fRayleighCount = 0; << 150 {
151 << 151 fBoundaryProcs[EtchedVM2000AirReflection] += 1;
152 // non-boundary processes << 152 }
153 G4int fOpAbsorption = 0; << 153 void AddEtchedVM2000GlueReflection(void)
>> 154 {
>> 155 fBoundaryProcs[EtchedVM2000GlueReflection] += 1;
>> 156 }
>> 157
>> 158 void AddGroundLumirrorAirReflection(void)
>> 159 {
>> 160 fBoundaryProcs[GroundLumirrorAirReflection] += 1;
>> 161 }
>> 162 void AddGroundLumirrorGlueReflection(void)
>> 163 {
>> 164 fBoundaryProcs[GroundLumirrorGlueReflection] += 1;
>> 165 }
>> 166 void AddGroundAirReflection(void)
>> 167 {
>> 168 fBoundaryProcs[GroundAirReflection] += 1;
>> 169 }
>> 170 void AddGroundTeflonAirReflection(void)
>> 171 {
>> 172 fBoundaryProcs[GroundTeflonAirReflection] += 1;
>> 173 }
>> 174 void AddGroundTiOAirReflection(void)
>> 175 {
>> 176 fBoundaryProcs[GroundTiOAirReflection] += 1;
>> 177 }
>> 178 void AddGroundTyvekAirReflection(void)
>> 179 {
>> 180 fBoundaryProcs[GroundTyvekAirReflection] += 1;
>> 181 }
>> 182 void AddGroundVM2000AirReflection(void)
>> 183 {
>> 184 fBoundaryProcs[GroundVM2000AirReflection] += 1;
>> 185 }
>> 186 void AddGroundVM2000GlueReflection(void)
>> 187 {
>> 188 fBoundaryProcs[GroundVM2000GlueReflection] += 1;
>> 189 }
>> 190
>> 191 void AddDichroic(void) { fBoundaryProcs[Dichroic] += 1; }
>> 192
>> 193 virtual void Merge(const G4Run*);
>> 194
>> 195 void EndOfRun();
>> 196
>> 197 private:
>> 198 // primary particle
>> 199 G4ParticleDefinition* fParticle;
>> 200 G4double fEkin;
>> 201 G4bool fPolarized;
>> 202 G4double fPolarization;
>> 203
>> 204 G4double fCerenkovEnergy;
>> 205 G4double fScintEnergy;
>> 206 G4double fWLSAbsorptionEnergy;
>> 207 G4double fWLSEmissionEnergy;
>> 208 G4double fWLS2AbsorptionEnergy;
>> 209 G4double fWLS2EmissionEnergy;
>> 210
>> 211 // number of particles
>> 212 G4int fCerenkovCount;
>> 213 G4int fScintCount;
>> 214 G4int fWLSAbsorptionCount;
>> 215 G4int fWLSEmissionCount;
>> 216 G4int fWLS2AbsorptionCount;
>> 217 G4int fWLS2EmissionCount;
>> 218 // number of events
>> 219 G4int fRayleighCount;
>> 220
>> 221 // non-boundary processes
>> 222 G4int fOpAbsorption;
154 223
155 // prior to boundary: << 224 // prior to boundary:
156 G4int fOpAbsorptionPrior = 0; << 225 G4int fOpAbsorptionPrior;
157 226
158 // boundary proc << 227 // boundary proc
159 std::vector<G4int> fBoundaryProcs; << 228 std::vector<G4int> fBoundaryProcs;
160 229
161 G4int fTotalSurface = 0; << 230 G4int fTotalSurface;
162 }; 231 };
163 232
164 #endif /* Run_h */ 233 #endif /* Run_h */
165 234