| 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
32 #ifndef Run_h 33 #ifndef Run_h
33 #define Run_h 1 34 #define Run_h 1
34 35
35 #include "G4OpBoundaryProcess.hh" 36 #include "G4OpBoundaryProcess.hh"
36 #include "G4Run.hh" 37 #include "G4Run.hh"
37 38
38 class G4ParticleDefinition; 39 class G4ParticleDefinition;
39 40
40 //....oooOO0OOooo........oooOO0OOooo........oo 41 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
41 class Run : public G4Run 42 class Run : public G4Run
42 { 43 {
43 public: 44 public:
44 Run(); 45 Run();
45 ~Run() override = default; << 46 ~Run();
46 47
47 void SetPrimary(G4ParticleDefinition* part << 48 void SetPrimary(G4ParticleDefinition* particle, G4double energy);
48 G4double polarization); <<
49 49
50 // particle energy << 50 // spectrum of Cerenkov radiation
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
54 void AddWLSEmissionEnergy(G4double en) { f << 54 void AddCerenkov(void) {fCerenkovCount += 1;}
55 void AddWLS2AbsorptionEnergy(G4double en) << 55 void AddScintillation(void) {fScintCount += 1;}
56 void AddWLS2EmissionEnergy(G4double en) { << 56 void AddRayleigh(void) {fRayleighCount += 1;}
>> 57
>> 58 void AddOpAbsorption(void) {fOpAbsorption += 1;}
>> 59 void AddOpAbsorptionPrior(void) {fOpAbsorptionPrior += 1;}
57 60
58 // number of particles << 61 void AddFresnelRefraction(void) {
59 void AddCerenkov() { fCerenkovCount += 1; << 62 fBoundaryProcs[FresnelRefraction] += 1;
60 void AddScintillation() { fScintCount += 1 <<
61 void AddRayleigh() { fRayleighCount += 1; <<
62 void AddWLSAbsorption() { fWLSAbsorptionCo <<
63 void AddWLSEmission() { fWLSEmissionCount <<
64 void AddWLS2Absorption() { fWLS2Absorption <<
65 void AddWLS2Emission() { fWLS2EmissionCoun <<
66 <<
67 void AddOpAbsorption() { fOpAbsorption += <<
68 void AddOpAbsorptionPrior() { fOpAbsorptio <<
69 <<
70 void AddFresnelRefraction() { fBoundaryPro <<
71 void AddFresnelReflection() { fBoundaryPro <<
72 void AddTransmission() { fBoundaryProcs[Tr <<
73 void AddTotalInternalReflection() { fBound <<
74 void AddLambertianReflection() { fBoundary <<
75 void AddLobeReflection() { fBoundaryProcs[ <<
76 void AddSpikeReflection() { fBoundaryProcs <<
77 void AddBackScattering() { fBoundaryProcs[ <<
78 void AddAbsorption() { fBoundaryProcs[Abso <<
79 void AddDetection() { fBoundaryProcs[Detec <<
80 void AddNotAtBoundary() { fBoundaryProcs[N <<
81 void AddSameMaterial() { fBoundaryProcs[Sa <<
82 void AddStepTooSmall() { fBoundaryProcs[St <<
83 void AddNoRINDEX() { fBoundaryProcs[NoRIND <<
84 <<
85 void AddTotalSurface() { fTotalSurface += <<
86 void AddPolishedLumirrorAirReflection() { <<
87 void AddPolishedLumirrorGlueReflection() <<
88 { <<
89 fBoundaryProcs[PolishedLumirrorGlueRefle <<
90 } 63 }
91 void AddPolishedAirReflection() { fBoundar << 64 void AddFresnelReflection(void) {
92 void AddPolishedTeflonAirReflection() { fB << 65 fBoundaryProcs[FresnelReflection] += 1;
93 void AddPolishedTiOAirReflection() { fBoun <<
94 void AddPolishedTyvekAirReflection() { fBo <<
95 void AddPolishedVM2000AirReflection() { fB <<
96 void AddPolishedVM2000GlueReflection() { f <<
97 <<
98 void AddEtchedLumirrorAirReflection() { fB <<
99 void AddEtchedLumirrorGlueReflection() { f <<
100 void AddEtchedAirReflection() { fBoundaryP <<
101 void AddEtchedTeflonAirReflection() { fBou <<
102 void AddEtchedTiOAirReflection() { fBounda <<
103 void AddEtchedTyvekAirReflection() { fBoun <<
104 void AddEtchedVM2000AirReflection() { fBou <<
105 void AddEtchedVM2000GlueReflection() { fBo <<
106 <<
107 void AddGroundLumirrorAirReflection() { fB <<
108 void AddGroundLumirrorGlueReflection() { f <<
109 void AddGroundAirReflection() { fBoundaryP <<
110 void AddGroundTeflonAirReflection() { fBou <<
111 void AddGroundTiOAirReflection() { fBounda <<
112 void AddGroundTyvekAirReflection() { fBoun <<
113 void AddGroundVM2000AirReflection() { fBou <<
114 void AddGroundVM2000GlueReflection() { fBo <<
115 <<
116 void AddDichroic() { fBoundaryProcs[Dichro <<
117 void AddCoatedDielectricRefraction() { fBo <<
118 void AddCoatedDielectricReflection() { fBo <<
119 void AddCoatedDielectricFrustratedTransmis <<
120 { <<
121 fBoundaryProcs[CoatedDielectricFrustrate <<
122 } 66 }
>> 67 void AddTransmission(void) {fBoundaryProcs[Transmission] += 1;}
>> 68 void AddTotalInternalReflection(void)
>> 69 {fBoundaryProcs[TotalInternalReflection] += 1;}
>> 70 void AddLambertianReflection(void)
>> 71 {fBoundaryProcs[LambertianReflection] += 1;}
>> 72 void AddLobeReflection(void) {fBoundaryProcs[LobeReflection] += 1;}
>> 73 void AddSpikeReflection(void) {fBoundaryProcs[SpikeReflection] += 1;}
>> 74 void AddBackScattering(void) {fBoundaryProcs[BackScattering] += 1;}
>> 75 void AddAbsorption(void) {fBoundaryProcs[Absorption] += 1;}
>> 76 void AddDetection(void) {fBoundaryProcs[Detection] += 1;}
>> 77 void AddNotAtBoundary(void) {fBoundaryProcs[NotAtBoundary] += 1;}
>> 78 void AddSameMaterial(void) {fBoundaryProcs[SameMaterial] += 1;}
>> 79 void AddStepTooSmall(void) {fBoundaryProcs[StepTooSmall] += 1;}
>> 80 void AddNoRINDEX(void) {fBoundaryProcs[NoRINDEX] += 1;}
>> 81
>> 82 void AddTotalSurface(void) {fTotalSurface += 1;}
>> 83 void AddPolishedLumirrorAirReflection(void)
>> 84 {fBoundaryProcs[PolishedLumirrorAirReflection] += 1;}
>> 85 void AddPolishedLumirrorGlueReflection(void)
>> 86 {fBoundaryProcs[PolishedLumirrorGlueReflection] += 1;}
>> 87 void AddPolishedAirReflection(void)
>> 88 {fBoundaryProcs[PolishedAirReflection] += 1;}
>> 89 void AddPolishedTeflonAirReflection(void)
>> 90 {fBoundaryProcs[PolishedTeflonAirReflection] += 1;}
>> 91 void AddPolishedTiOAirReflection(void)
>> 92 {fBoundaryProcs[PolishedTiOAirReflection] += 1;}
>> 93 void AddPolishedTyvekAirReflection(void)
>> 94 {fBoundaryProcs[PolishedTyvekAirReflection] += 1;}
>> 95 void AddPolishedVM2000AirReflection(void)
>> 96 {fBoundaryProcs[PolishedVM2000AirReflection] += 1;}
>> 97 void AddPolishedVM2000GlueReflection(void)
>> 98 {fBoundaryProcs[PolishedVM2000GlueReflection] += 1;}
>> 99
>> 100 void AddEtchedLumirrorAirReflection(void)
>> 101 {fBoundaryProcs[EtchedLumirrorAirReflection] += 1;}
>> 102 void AddEtchedLumirrorGlueReflection(void)
>> 103 {fBoundaryProcs[EtchedLumirrorGlueReflection] += 1;}
>> 104 void AddEtchedAirReflection(void)
>> 105 {fBoundaryProcs[EtchedAirReflection] += 1;}
>> 106 void AddEtchedTeflonAirReflection(void)
>> 107 {fBoundaryProcs[EtchedTeflonAirReflection] += 1;}
>> 108 void AddEtchedTiOAirReflection(void)
>> 109 {fBoundaryProcs[EtchedTiOAirReflection] += 1;}
>> 110 void AddEtchedTyvekAirReflection(void)
>> 111 {fBoundaryProcs[EtchedTyvekAirReflection] += 1;}
>> 112 void AddEtchedVM2000AirReflection(void)
>> 113 {fBoundaryProcs[EtchedVM2000AirReflection] += 1;}
>> 114 void AddEtchedVM2000GlueReflection(void)
>> 115 {fBoundaryProcs[EtchedVM2000GlueReflection] += 1;}
>> 116
>> 117 void AddGroundLumirrorAirReflection(void)
>> 118 {fBoundaryProcs[GroundLumirrorAirReflection] += 1;}
>> 119 void AddGroundLumirrorGlueReflection(void)
>> 120 {fBoundaryProcs[GroundLumirrorGlueReflection] += 1;}
>> 121 void AddGroundAirReflection(void)
>> 122 {fBoundaryProcs[GroundAirReflection] += 1;}
>> 123 void AddGroundTeflonAirReflection(void)
>> 124 {fBoundaryProcs[GroundTeflonAirReflection] += 1;}
>> 125 void AddGroundTiOAirReflection(void)
>> 126 {fBoundaryProcs[GroundTiOAirReflection] += 1;}
>> 127 void AddGroundTyvekAirReflection(void)
>> 128 {fBoundaryProcs[GroundTyvekAirReflection] += 1;}
>> 129 void AddGroundVM2000AirReflection(void)
>> 130 {fBoundaryProcs[GroundVM2000AirReflection] += 1;}
>> 131 void AddGroundVM2000GlueReflection(void)
>> 132 {fBoundaryProcs[GroundVM2000GlueReflection] += 1;}
123 133
124 void Merge(const G4Run*) override; << 134 void AddDichroic(void) {fBoundaryProcs[Dichroic] += 1;}
>> 135
>> 136 virtual void Merge(const G4Run*);
125 137
126 void EndOfRun(); 138 void EndOfRun();
127 139
128 private: 140 private:
129 // primary particle 141 // primary particle
130 G4ParticleDefinition* fParticle = nullptr; << 142 G4ParticleDefinition* fParticle;
131 G4double fEkin = -1.; << 143 G4double fEkin;
132 G4bool fPolarized = false; << 144
133 G4double fPolarization = 0.; << 145 G4double fCerenkovEnergy;
134 << 146 G4double fScintEnergy;
135 G4double fCerenkovEnergy = 0.; <<
136 G4double fScintEnergy = 0.; <<
137 G4double fWLSAbsorptionEnergy = 0.; <<
138 G4double fWLSEmissionEnergy = 0.; <<
139 G4double fWLS2AbsorptionEnergy = 0.; <<
140 G4double fWLS2EmissionEnergy = 0.; <<
141 147
142 // number of particles 148 // number of particles
143 G4int fCerenkovCount = 0; << 149 G4int fCerenkovCount;
144 G4int fScintCount = 0; << 150 G4int fScintCount;
145 G4int fWLSAbsorptionCount = 0; <<
146 G4int fWLSEmissionCount = 0; <<
147 G4int fWLS2AbsorptionCount = 0; <<
148 G4int fWLS2EmissionCount = 0; <<
149 // number of events 151 // number of events
150 G4int fRayleighCount = 0; << 152 G4int fRayleighCount;
151 << 153
152 // non-boundary processes 154 // non-boundary processes
153 G4int fOpAbsorption = 0; << 155 G4int fOpAbsorption;
154 156
155 // prior to boundary: 157 // prior to boundary:
156 G4int fOpAbsorptionPrior = 0; << 158 G4int fOpAbsorptionPrior;
157 159
158 // boundary proc 160 // boundary proc
159 std::vector<G4int> fBoundaryProcs; 161 std::vector<G4int> fBoundaryProcs;
160 162
161 G4int fTotalSurface = 0; << 163 G4int fTotalSurface;
>> 164
162 }; 165 };
>> 166
163 167
164 #endif /* Run_h */ 168 #endif /* Run_h */
165 169