| 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 // G4ParticleGun class implementation <<
27 // 26 //
28 // Author: Makoto Asai, 1997 << 27 // $Id: G4ParticleGun.cc,v 1.14 2007/11/07 17:13:19 asaim Exp $
29 // ------------------------------------------- << 28 // GEANT4 tag $Name: geant4-09-01-patch-03 $
>> 29 //
30 30
>> 31 // G4ParticleGun
31 #include "G4ParticleGun.hh" 32 #include "G4ParticleGun.hh"
32 #include "G4SystemOfUnits.hh" <<
33 #include "G4PrimaryParticle.hh" 33 #include "G4PrimaryParticle.hh"
34 #include "G4ParticleGunMessenger.hh" 34 #include "G4ParticleGunMessenger.hh"
35 #include "G4Event.hh" 35 #include "G4Event.hh"
36 #include "G4ios.hh" 36 #include "G4ios.hh"
37 37
38 G4ParticleGun::G4ParticleGun() 38 G4ParticleGun::G4ParticleGun()
39 { 39 {
40 SetInitialValues(); 40 SetInitialValues();
41 } 41 }
42 42
43 G4ParticleGun::G4ParticleGun(G4int numberofpar 43 G4ParticleGun::G4ParticleGun(G4int numberofparticles)
44 { 44 {
45 SetInitialValues(); 45 SetInitialValues();
46 NumberOfParticlesToBeGenerated = numberofpar 46 NumberOfParticlesToBeGenerated = numberofparticles;
47 } 47 }
48 48
49 G4ParticleGun::G4ParticleGun(G4ParticleDefinit << 49 G4ParticleGun::G4ParticleGun
50 G4int numberofpar << 50 (G4ParticleDefinition * particleDef, G4int numberofparticles)
51 { 51 {
52 SetInitialValues(); 52 SetInitialValues();
53 NumberOfParticlesToBeGenerated = numberofpar 53 NumberOfParticlesToBeGenerated = numberofparticles;
54 SetParticleDefinition( particleDef ); 54 SetParticleDefinition( particleDef );
55 } 55 }
56 56
57 void G4ParticleGun::SetInitialValues() 57 void G4ParticleGun::SetInitialValues()
58 { 58 {
59 NumberOfParticlesToBeGenerated = 1; 59 NumberOfParticlesToBeGenerated = 1;
60 particle_definition = nullptr; << 60 particle_definition = 0;
61 G4ThreeVector zero; 61 G4ThreeVector zero;
62 particle_momentum_direction = (G4ParticleMom 62 particle_momentum_direction = (G4ParticleMomentum)zero;
63 particle_energy = 0.0; 63 particle_energy = 0.0;
64 particle_momentum = 0.0; 64 particle_momentum = 0.0;
65 particle_position = zero; 65 particle_position = zero;
66 particle_time = 0.0; 66 particle_time = 0.0;
67 particle_polarization = zero; 67 particle_polarization = zero;
68 particle_charge = 0.0; 68 particle_charge = 0.0;
69 theMessenger = new G4ParticleGunMessenger(th 69 theMessenger = new G4ParticleGunMessenger(this);
70 } 70 }
71 71
72 G4ParticleGun::~G4ParticleGun() 72 G4ParticleGun::~G4ParticleGun()
73 { 73 {
74 delete theMessenger; 74 delete theMessenger;
75 } 75 }
76 76
77 void G4ParticleGun:: << 77 G4ParticleGun::G4ParticleGun(const G4ParticleGun& /*right*/)
78 SetParticleDefinition(G4ParticleDefinition* aP << 78 :G4VPrimaryGenerator()
>> 79 { G4Exception("G4ParticleGun : Copy constructor should not be used."); }
>> 80
>> 81 const G4ParticleGun& G4ParticleGun::operator=(const G4ParticleGun& right)
>> 82 { G4Exception("G4ParticleGun : Equal operator should not be used."); return right; }
>> 83
>> 84 G4int G4ParticleGun::operator==(const G4ParticleGun& /*right*/) const
>> 85 { G4Exception("G4ParticleGun : == operator should not be used."); return true; }
>> 86
>> 87 G4int G4ParticleGun::operator!=(const G4ParticleGun& /*right*/) const
>> 88 { G4Exception("G4ParticleGun : == operator should not be used."); return false; }
>> 89
>> 90 void G4ParticleGun::SetParticleDefinition
>> 91 (G4ParticleDefinition * aParticleDefinition)
79 { 92 {
80 if(aParticleDefinition == nullptr) << 93 if(!aParticleDefinition)
81 { 94 {
82 G4Exception("G4ParticleGun::SetParticleDef << 95 G4Exception("G4ParticleGun::SetParticleDefinition()","Event00003",FatalException,
83 FatalException, "Null pointer << 96 "Null pointer is given.");
84 } 97 }
85 if(aParticleDefinition->IsShortLived()) 98 if(aParticleDefinition->IsShortLived())
86 { 99 {
87 if(aParticleDefinition->GetDecayTable() == << 100 if(!(aParticleDefinition->GetDecayTable()))
88 { 101 {
89 G4ExceptionDescription ED; << 102 G4cerr << "G4ParticleGun does not support shooting a short-lived particle without a valid decay table." << G4endl;
90 ED << "G4ParticleGun does not support sh << 103 G4cerr << "G4ParticleGun::SetParticleDefinition for "
91 << "particle without a valid decay ta << 104 << aParticleDefinition->GetParticleName() << " is ignored." << G4endl;
92 ED << "G4ParticleGun::SetParticleDefinit <<
93 << aParticleDefinition->GetParticleNa <<
94 G4Exception("G4ParticleGun::SetParticleD <<
95 JustWarning, ED); <<
96 return; 105 return;
97 } 106 }
98 } 107 }
99 particle_definition = aParticleDefinition; 108 particle_definition = aParticleDefinition;
100 particle_charge = particle_definition->GetPD 109 particle_charge = particle_definition->GetPDGCharge();
101 if(particle_momentum>0.0) 110 if(particle_momentum>0.0)
102 { 111 {
103 G4double mass = particle_definition->GetPD << 112 G4double mass = particle_definition->GetPDGMass();
104 particle_energy = 113 particle_energy =
105 std::sqrt(particle_momentum*particle_mom << 114 std::sqrt(particle_momentum*particle_momentum+mass*mass)-mass;
106 } 115 }
107 } 116 }
108 117
109 void G4ParticleGun::SetParticleEnergy(G4double 118 void G4ParticleGun::SetParticleEnergy(G4double aKineticEnergy)
110 { 119 {
111 particle_energy = aKineticEnergy; 120 particle_energy = aKineticEnergy;
112 if(particle_momentum>0.0) << 121 if(particle_momentum>0.0){
113 { << 122 if(particle_definition){
114 if(particle_definition != nullptr) <<
115 { <<
116 G4cout << "G4ParticleGun::" << particle_ 123 G4cout << "G4ParticleGun::" << particle_definition->GetParticleName()
117 << G4endl; 124 << G4endl;
118 } << 125 }else{
119 else <<
120 { <<
121 G4cout << "G4ParticleGun::" << " " << G4 126 G4cout << "G4ParticleGun::" << " " << G4endl;
122 } 127 }
123 G4cout << " was defined in terms of Moment 128 G4cout << " was defined in terms of Momentum: "
124 << particle_momentum/GeV << "GeV/c" 129 << particle_momentum/GeV << "GeV/c" << G4endl;
125 G4cout << " is now defined in terms of Kin 130 G4cout << " is now defined in terms of KineticEnergy: "
126 << particle_energy/GeV << "GeV" 131 << particle_energy/GeV << "GeV" << G4endl;
127 particle_momentum = 0.0; 132 particle_momentum = 0.0;
128 } 133 }
129 } 134 }
130 135
131 void G4ParticleGun::SetParticleMomentum(G4doub 136 void G4ParticleGun::SetParticleMomentum(G4double aMomentum)
132 { 137 {
133 if(particle_energy>0.0) << 138 if(particle_energy>0.0){
134 { << 139 if(particle_definition){
135 if(particle_definition != nullptr) <<
136 { <<
137 G4cout << "G4ParticleGun::" << particle_ 140 G4cout << "G4ParticleGun::" << particle_definition->GetParticleName()
138 << G4endl; 141 << G4endl;
139 } << 142 }else{
140 else <<
141 { <<
142 G4cout << "G4ParticleGun::" << " " << G4 143 G4cout << "G4ParticleGun::" << " " << G4endl;
143 } 144 }
144 G4cout << " was defined in terms of Kineti 145 G4cout << " was defined in terms of KineticEnergy: "
145 << particle_energy/GeV << "GeV" < 146 << particle_energy/GeV << "GeV" << G4endl;
146 G4cout << " is now defined in terms Moment 147 G4cout << " is now defined in terms Momentum: "
147 << aMomentum/GeV << "GeV/c" < 148 << aMomentum/GeV << "GeV/c" << G4endl;
148 } 149 }
149 if(particle_definition == nullptr) << 150 if(particle_definition==0)
150 { 151 {
151 G4cout << "Particle Definition not defined << 152 G4cout <<"Particle Definition not defined yet for G4ParticleGun"<< G4endl;
152 << G4endl; << 153 G4cout <<"Zero Mass is assumed"<<G4endl;
153 G4cout << "Zero Mass is assumed" << G4endl <<
154 particle_momentum = aMomentum; 154 particle_momentum = aMomentum;
155 particle_energy = aMomentum; 155 particle_energy = aMomentum;
156 } 156 }
157 else 157 else
158 { 158 {
159 G4double mass = particle_definition->GetPD << 159 G4double mass = particle_definition->GetPDGMass();
160 particle_momentum = aMomentum; 160 particle_momentum = aMomentum;
161 particle_energy = 161 particle_energy =
162 std::sqrt(particle_momentum*particle_mom << 162 std::sqrt(particle_momentum*particle_momentum+mass*mass)-mass;
163 } 163 }
164 } 164 }
165 165
166 void G4ParticleGun::SetParticleMomentum(G4Part 166 void G4ParticleGun::SetParticleMomentum(G4ParticleMomentum aMomentum)
167 { 167 {
168 if(particle_energy>0.0) << 168 if(particle_energy>0.0){
169 { << 169 if(particle_definition){
170 if(particle_definition != nullptr) <<
171 { <<
172 G4cout << "G4ParticleGun::" << particle_ 170 G4cout << "G4ParticleGun::" << particle_definition->GetParticleName()
173 << G4endl; 171 << G4endl;
174 } << 172 }else{
175 else <<
176 { <<
177 G4cout << "G4ParticleGun::" << " " << G4 173 G4cout << "G4ParticleGun::" << " " << G4endl;
178 } 174 }
179 G4cout << " was defined in terms of Kineti 175 G4cout << " was defined in terms of KineticEnergy: "
180 << particle_energy/GeV << "GeV" < 176 << particle_energy/GeV << "GeV" << G4endl;
181 G4cout << " is now defined in terms Moment 177 G4cout << " is now defined in terms Momentum: "
182 << aMomentum.mag()/GeV << "GeV/c" < 178 << aMomentum.mag()/GeV << "GeV/c" << G4endl;
183 } 179 }
184 if(particle_definition == nullptr) << 180 if(particle_definition==0)
185 { 181 {
186 G4cout << "Particle Definition not defined << 182 G4cout <<"Particle Definition not defined yet for G4ParticleGun"<< G4endl;
187 << G4endl; << 183 G4cout <<"Zero Mass is assumed"<<G4endl;
188 G4cout << "Zero Mass is assumed" << G4endl << 184 particle_momentum_direction = aMomentum.unit();
189 particle_momentum_direction = aMomentum.un <<
190 particle_momentum = aMomentum.mag(); 185 particle_momentum = aMomentum.mag();
191 particle_energy = aMomentum.mag(); 186 particle_energy = aMomentum.mag();
192 } 187 }
193 else 188 else
194 { 189 {
195 G4double mass = particle_definition->GetP 190 G4double mass = particle_definition->GetPDGMass();
196 particle_momentum = aMomentum.mag(); 191 particle_momentum = aMomentum.mag();
197 particle_momentum_direction = aMomentum.un << 192 particle_momentum_direction = aMomentum.unit();
198 particle_energy = 193 particle_energy =
199 std::sqrt(particle_momentum*particle_mom << 194 std::sqrt(particle_momentum*particle_momentum+mass*mass)-mass;
200 } 195 }
201 } 196 }
202 197
203 void G4ParticleGun::GeneratePrimaryVertex(G4Ev 198 void G4ParticleGun::GeneratePrimaryVertex(G4Event* evt)
204 { 199 {
205 if(particle_definition == nullptr) << 200 if(particle_definition==0) return;
206 { <<
207 G4ExceptionDescription ED; <<
208 ED << "Particle definition is not defined. <<
209 ED << "G4ParticleGun::SetParticleDefinitio <<
210 << G4endl; <<
211 G4Exception("G4ParticleGun::GeneratePrimar <<
212 FatalException, ED); <<
213 return; <<
214 } <<
215 201
216 // Create a new vertex << 202 // create a new vertex
217 // << 203 G4PrimaryVertex* vertex =
218 auto* vertex = <<
219 new G4PrimaryVertex(particle_position,part 204 new G4PrimaryVertex(particle_position,particle_time);
220 205
221 // Create new primaries and set them to the << 206 // create new primaries and set them to the vertex
222 // <<
223 G4double mass = particle_definition->GetPDG 207 G4double mass = particle_definition->GetPDGMass();
224 for( G4int i=0; i<NumberOfParticlesToBeGener << 208 G4double energy = particle_energy + mass;
>> 209 G4double pmom = std::sqrt(energy*energy-mass*mass);
>> 210 G4double px = pmom*particle_momentum_direction.x();
>> 211 G4double py = pmom*particle_momentum_direction.y();
>> 212 G4double pz = pmom*particle_momentum_direction.z();
>> 213 for( G4int i=0; i<NumberOfParticlesToBeGenerated; i++ )
225 { 214 {
226 auto* particle = << 215 G4PrimaryParticle* particle =
227 new G4PrimaryParticle(particle_definitio << 216 new G4PrimaryParticle(particle_definition,px,py,pz);
228 particle->SetKineticEnergy( particle_energ <<
229 particle->SetMass( mass ); 217 particle->SetMass( mass );
230 particle->SetMomentumDirection( particle_m <<
231 particle->SetCharge( particle_charge ); 218 particle->SetCharge( particle_charge );
232 particle->SetPolarization(particle_polariz 219 particle->SetPolarization(particle_polarization.x(),
233 particle_polariz << 220 particle_polarization.y(),
234 particle_polariz << 221 particle_polarization.z());
235 particle->SetWeight( particle_weight ); <<
236 vertex->SetPrimary( particle ); 222 vertex->SetPrimary( particle );
237 } 223 }
>> 224
238 evt->AddPrimaryVertex( vertex ); 225 evt->AddPrimaryVertex( vertex );
239 } 226 }
>> 227
>> 228
240 229