| 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 ////////////////////////////////////////////// 26 ///////////////////////////////////////////////////////////////////////////////
27 // File: CCalPrimaryGeneratorAction.cc 27 // File: CCalPrimaryGeneratorAction.cc
28 // Description: CCalPrimaryGeneratorAction Set 28 // Description: CCalPrimaryGeneratorAction Sets up particle beam
29 ////////////////////////////////////////////// 29 ///////////////////////////////////////////////////////////////////////////////
30 30
31 #include <CLHEP/Random/RandFlat.h> 31 #include <CLHEP/Random/RandFlat.h>
32 32
33 #include "CCalPrimaryGeneratorAction.hh" 33 #include "CCalPrimaryGeneratorAction.hh"
34 #include "CCalPrimaryGeneratorMessenger.hh" 34 #include "CCalPrimaryGeneratorMessenger.hh"
35 #include "G4HEPEvtInterface.hh" 35 #include "G4HEPEvtInterface.hh"
36 36
37 #include "G4Exp.hh" 37 #include "G4Exp.hh"
38 #include "G4PhysicalConstants.hh" 38 #include "G4PhysicalConstants.hh"
39 #include "G4SystemOfUnits.hh" 39 #include "G4SystemOfUnits.hh"
40 #include "G4Event.hh" 40 #include "G4Event.hh"
41 #include "G4ParticleGun.hh" 41 #include "G4ParticleGun.hh"
42 #include "G4ParticleTable.hh" 42 #include "G4ParticleTable.hh"
43 #include "G4ParticleDefinition.hh" 43 #include "G4ParticleDefinition.hh"
44 #include "G4HEPEvtInterface.hh" 44 #include "G4HEPEvtInterface.hh"
45 #include "G4RunManager.hh" 45 #include "G4RunManager.hh"
46 46
47 //#define debug << 47 #define debug
48 48
49 CCalPrimaryGeneratorAction::CCalPrimaryGenerat 49 CCalPrimaryGeneratorAction::CCalPrimaryGeneratorAction(): particleGun(0),
50 generatorInput(singleFixed), verboseLevel(0 50 generatorInput(singleFixed), verboseLevel(0), n_particle(1),
51 particleName("pi-"), particleEnergy(100*GeV) 51 particleName("pi-"), particleEnergy(100*GeV), particlePosition(0.,0.,0.),
52 particleDir(1.,1.,0.1), isInitialized(0), sc 52 particleDir(1.,1.,0.1), isInitialized(0), scanSteps(0) {
53 53
54 //Initialise the messenger 54 //Initialise the messenger
55 gunMessenger = new CCalPrimaryGeneratorMesse 55 gunMessenger = new CCalPrimaryGeneratorMessenger(this);
56 56
57 //Default settings: 57 //Default settings:
58 SetMinimumEnergy(1.*GeV); 58 SetMinimumEnergy(1.*GeV);
59 SetMaximumEnergy(1.*TeV); 59 SetMaximumEnergy(1.*TeV);
60 SetMinimumEta(0.); 60 SetMinimumEta(0.);
61 SetMaximumEta(3.5); 61 SetMaximumEta(3.5);
62 SetMinimumPhi(0.*degree); 62 SetMinimumPhi(0.*degree);
63 SetMaximumPhi(360.*degree); 63 SetMaximumPhi(360.*degree);
64 SetStepsPhi(1); 64 SetStepsPhi(1);
65 SetStepsEta(1); 65 SetStepsEta(1);
66 66
67 // Number of particles per gun 67 // Number of particles per gun
68 particleGun = new G4ParticleGun(n_particle); 68 particleGun = new G4ParticleGun(n_particle);
69 69
70 // Getting particle definition 70 // Getting particle definition
71 G4ParticleTable* particleTable = G4ParticleT 71 G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
72 G4ParticleDefinition* particle = particleTab 72 G4ParticleDefinition* particle = particleTable->FindParticle(particleName);
73 particleGun->SetParticleDefinition(particle) 73 particleGun->SetParticleDefinition(particle);
74 74
75 // Setting particle properties 75 // Setting particle properties
76 particleGun->SetParticleEnergy(particleEnerg 76 particleGun->SetParticleEnergy(particleEnergy);
77 particleGun->SetParticleMomentumDirection(pa 77 particleGun->SetParticleMomentumDirection(particleDir);
78 particleGun->SetParticlePosition(particlePos 78 particleGun->SetParticlePosition(particlePosition);
79 print(0); 79 print(0);
80 } 80 }
81 81
82 CCalPrimaryGeneratorAction::~CCalPrimaryGenera 82 CCalPrimaryGeneratorAction::~CCalPrimaryGeneratorAction() {
83 if (gunMessenger) 83 if (gunMessenger)
84 delete gunMessenger; 84 delete gunMessenger;
85 if (particleGun) 85 if (particleGun)
86 delete particleGun; 86 delete particleGun;
87 } 87 }
88 88
89 void CCalPrimaryGeneratorAction::GeneratePrima 89 void CCalPrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent) {
90 90
91 if (isInitialized == 0) initialize(); 91 if (isInitialized == 0) initialize();
92 92
93 if (generatorInput == singleRandom) { 93 if (generatorInput == singleRandom) {
94 particleEnergy = CLHEP::RandFlat::shoot(en 94 particleEnergy = CLHEP::RandFlat::shoot(energyMin,energyMax);
95 particleGun->SetParticleEnergy(particleEne 95 particleGun->SetParticleEnergy(particleEnergy);
96 96
97 G4double eta = CLHEP::RandFlat::shoot(etaM 97 G4double eta = CLHEP::RandFlat::shoot(etaMin,etaMax);
98 G4double phi = CLHEP::RandFlat::shoot(phiM 98 G4double phi = CLHEP::RandFlat::shoot(phiMin,phiMax);
99 G4double theta = std::atan(G4Exp(-eta))*2. 99 G4double theta = std::atan(G4Exp(-eta))*2.;
100 G4double randomX = std::sin(theta)*std::co 100 G4double randomX = std::sin(theta)*std::cos(phi);
101 G4double randomY = std::sin(theta)*std::si 101 G4double randomY = std::sin(theta)*std::sin(phi);
102 G4double randomZ = std::cos(theta); 102 G4double randomZ = std::cos(theta);
103 103
104 particleDir = G4ThreeVector(randomX,random 104 particleDir = G4ThreeVector(randomX,randomY,randomZ);
105 particleGun->SetParticleMomentumDirection( 105 particleGun->SetParticleMomentumDirection(particleDir);
>> 106 #ifdef debug
106 if (verboseLevel >= 2 ) { 107 if (verboseLevel >= 2 ) {
107 G4cout << "Energy " << particleEnergy/Ge 108 G4cout << "Energy " << particleEnergy/GeV << " GeV; Theta "
108 << theta/deg << " degree; Phi " < << 109 << theta/deg << " degree; Phi " << phi/deg << " degree" << G4endl;
109 G4cout << "Shooting in " << particleDir 110 G4cout << "Shooting in " << particleDir << " direction "<< G4endl;
110 } 111 }
>> 112 #endif
111 } else if (generatorInput == singleScan) { 113 } else if (generatorInput == singleScan) {
112 G4double scanEtaStep, scanPhiStep; 114 G4double scanEtaStep, scanPhiStep;
113 if (scanSteps == 0) { 115 if (scanSteps == 0) {
114 scanPhiStep = (phiMax - phiMin) / phiSte 116 scanPhiStep = (phiMax - phiMin) / phiSteps;
115 phiValue = phiMin - scanPhiStep; //first 117 phiValue = phiMin - scanPhiStep; //first step is going to change scanCurrentPhiValue
116 etaValue = etaMin; 118 etaValue = etaMin;
117 } 119 }
118 120
119 scanEtaStep = (etaMax - etaMin) / etaSteps 121 scanEtaStep = (etaMax - etaMin) / etaSteps;
120 scanPhiStep = (phiMax - phiMin) / phiSteps 122 scanPhiStep = (phiMax - phiMin) / phiSteps;
121 #ifdef debug 123 #ifdef debug
122 if (verboseLevel > 2 ) { 124 if (verboseLevel > 2 ) {
123 G4cout << " scanEtaStep " << scanEtaStep 125 G4cout << " scanEtaStep " << scanEtaStep << " # of Steps " << etaSteps
124 << G4endl; << 126 << G4endl;
125 G4cout << " scanPhiStep " << scanPhiStep 127 G4cout << " scanPhiStep " << scanPhiStep << " # of Steps " << phiSteps
126 << G4endl; << 128 << G4endl;
127 } 129 }
128 #endif 130 #endif
129 131
130 //----- First scan in phi, then in eta 132 //----- First scan in phi, then in eta
131 if (phiMax - phiValue < 1.E-6 * scanPhiSte 133 if (phiMax - phiValue < 1.E-6 * scanPhiStep) { // !only <= 1.E6 steps allowed
132 if (etaMax - etaValue < 1.E-6 * scanEtaS 134 if (etaMax - etaValue < 1.E-6 * scanEtaStep) { // !only <= 1.E6 steps allowed
133 G4cout << " Scan completed!" << G4endl << 135 G4cout << " Scan completed!" << G4endl;
134 return; << 136 return;
135 } else { 137 } else {
136 etaValue += scanEtaStep; << 138 etaValue += scanEtaStep;
137 phiValue = phiMin; << 139 phiValue = phiMin;
138 } 140 }
139 } else { 141 } else {
140 phiValue += scanPhiStep; 142 phiValue += scanPhiStep;
141 } 143 }
142 G4double theta = std::atan(G4Exp(-etaValue 144 G4double theta = std::atan(G4Exp(-etaValue))*2.;
143 145
144 G4double scanX = std::sin(theta)*std::cos( 146 G4double scanX = std::sin(theta)*std::cos(phiValue);
145 G4double scanY = std::sin(theta)*std::sin( 147 G4double scanY = std::sin(theta)*std::sin(phiValue);
146 G4double scanZ = std::cos(theta); 148 G4double scanZ = std::cos(theta);
147 if (verboseLevel >= 2 ) { 149 if (verboseLevel >= 2 ) {
148 G4cout << "Scan eta " << etaValue << " P 150 G4cout << "Scan eta " << etaValue << " Phi " << phiValue/deg
149 << " theta " << theta/deg << G4en << 151 << " theta " << theta/deg << G4endl;
150 } 152 }
151 particleDir = G4ThreeVector(scanX,scanY,sc 153 particleDir = G4ThreeVector(scanX,scanY,scanZ);
152 particleGun->SetParticleMomentumDirection( 154 particleGun->SetParticleMomentumDirection(particleDir);
153 #ifdef debug 155 #ifdef debug
154 if (verboseLevel > 2 ) { 156 if (verboseLevel > 2 ) {
155 G4cout << "Shooting in " << particleDir 157 G4cout << "Shooting in " << particleDir << " direction "<< G4endl;
156 } 158 }
157 #endif 159 #endif
158 scanSteps++; 160 scanSteps++;
159 } 161 }
160 162
161 // Generate GEANT4 primary vertex 163 // Generate GEANT4 primary vertex
162 particleGun->GeneratePrimaryVertex(anEvent); 164 particleGun->GeneratePrimaryVertex(anEvent);
163 } 165 }
164 166
165 167
166 void CCalPrimaryGeneratorAction::SetVerboseLev 168 void CCalPrimaryGeneratorAction::SetVerboseLevel(G4int val){
167 verboseLevel = val; 169 verboseLevel = val;
168 } 170 }
169 171
170 172
171 void CCalPrimaryGeneratorAction::SetRandom(G4S 173 void CCalPrimaryGeneratorAction::SetRandom(G4String val) {
172 174
173 if (val=="on") { 175 if (val=="on") {
174 generatorInput = singleRandom; 176 generatorInput = singleRandom;
175 print (1); 177 print (1);
176 } else { 178 } else {
177 generatorInput = singleFixed; 179 generatorInput = singleFixed;
178 print (1); 180 print (1);
179 } 181 }
180 } 182 }
181 183
182 184
183 void CCalPrimaryGeneratorAction::SetScan(G4Str 185 void CCalPrimaryGeneratorAction::SetScan(G4String val) {
184 186
185 if (val=="on") { 187 if (val=="on") {
186 generatorInput = singleScan; 188 generatorInput = singleScan;
187 scanSteps = 0; 189 scanSteps = 0;
188 print (1); 190 print (1);
189 } else { 191 } else {
190 generatorInput = singleFixed; 192 generatorInput = singleFixed;
191 print (1); 193 print (1);
192 } 194 }
193 } 195 }
194 196
195 197
196 void CCalPrimaryGeneratorAction::SetMinimumEne 198 void CCalPrimaryGeneratorAction::SetMinimumEnergy(G4double p){
197 199
198 if (p <= 0.) { 200 if (p <= 0.) {
199 G4cerr << "CCalPrimaryGeneratorAction::Set 201 G4cerr << "CCalPrimaryGeneratorAction::SetMinimumEnergy: value " << p/GeV
200 << "GeV is out of bounds, it will n << 202 << "GeV is out of bounds, it will not be used" << G4endl;
201 G4cerr << " Should be >0. Please check" 203 G4cerr << " Should be >0. Please check" << G4endl;
202 } else { 204 } else {
203 energyMin = p; 205 energyMin = p;
204 #ifdef debug 206 #ifdef debug
205 if (verboseLevel >= 1 ) { 207 if (verboseLevel >= 1 ) {
206 G4cout << " CCalPrimaryGeneratorAction: 208 G4cout << " CCalPrimaryGeneratorAction: setting min. value of energy to "
207 << energyMin/GeV << " GeV " << G4 << 209 << energyMin/GeV << " GeV " << G4endl;
208 } 210 }
209 #endif 211 #endif
210 } 212 }
211 } 213 }
212 214
213 215
214 void CCalPrimaryGeneratorAction::SetMaximumEne 216 void CCalPrimaryGeneratorAction::SetMaximumEnergy(G4double p){
215 217
216 if (p <= 0.) { 218 if (p <= 0.) {
217 G4cerr << "CCalPrimaryGeneratorAction::Set 219 G4cerr << "CCalPrimaryGeneratorAction::SetMaximumEnergy: value " << p/GeV
218 << "GeV is out of bounds, it will n << 220 << "GeV is out of bounds, it will not be used" << G4endl;
219 G4cerr << " Should be >0. Please check" 221 G4cerr << " Should be >0. Please check" << G4endl;
220 } else { 222 } else {
221 energyMax = p; 223 energyMax = p;
222 #ifdef debug 224 #ifdef debug
223 if (verboseLevel >= 1 ) { 225 if (verboseLevel >= 1 ) {
224 G4cout << " CCalPrimaryGeneratorAction: 226 G4cout << " CCalPrimaryGeneratorAction: setting max. value of energy to "
225 << energyMax/GeV << " GeV " << G4 << 227 << energyMax/GeV << " GeV " << G4endl;
226 } 228 }
227 #endif 229 #endif
228 } 230 }
229 } 231 }
230 232
231 233
232 void CCalPrimaryGeneratorAction::SetMinimumPhi 234 void CCalPrimaryGeneratorAction::SetMinimumPhi(G4double p){
233 235
234 if (std::fabs(p)>2.*pi) { 236 if (std::fabs(p)>2.*pi) {
235 G4cerr << "CCalPrimaryGeneratorAction::Set 237 G4cerr << "CCalPrimaryGeneratorAction::SetMinimumPhi: setting value quite "
236 << "large" << G4endl; << 238 << "large" << G4endl;
237 G4cerr << " Should be given in radians - P 239 G4cerr << " Should be given in radians - Please check" << G4endl;
238 } else { 240 } else {
239 phiMin = std::fabs(p); 241 phiMin = std::fabs(p);
240 #ifdef debug 242 #ifdef debug
241 if (verboseLevel >= 1 ) { 243 if (verboseLevel >= 1 ) {
242 G4cout << " CCalPrimaryGeneratorAction: 244 G4cout << " CCalPrimaryGeneratorAction: setting min. value of phi to "
243 << phiMin << G4endl; << 245 << phiMin << G4endl;
244 } 246 }
245 #endif 247 #endif
246 } 248 }
247 } 249 }
248 250
249 251
250 void CCalPrimaryGeneratorAction::SetMaximumPhi 252 void CCalPrimaryGeneratorAction::SetMaximumPhi(G4double p){
251 253
252 if (std::fabs(p)>2.*pi) { 254 if (std::fabs(p)>2.*pi) {
253 G4cerr << "CCalPrimaryGeneratorAction::Set 255 G4cerr << "CCalPrimaryGeneratorAction::SetMaximumPhi: setting value quite "
254 << "large" << G4endl; << 256 << "large" << G4endl;
255 G4cerr << " Should be given in radians - P 257 G4cerr << " Should be given in radians - Please check" << G4endl;
256 } else { 258 } else {
257 phiMax = std::fabs(p); 259 phiMax = std::fabs(p);
258 #ifdef debug 260 #ifdef debug
259 if (verboseLevel >= 1 ) { 261 if (verboseLevel >= 1 ) {
260 G4cout << " CCalPrimaryGeneratorAction: 262 G4cout << " CCalPrimaryGeneratorAction: setting max. value of phi to "
261 << phiMax << G4endl; << 263 << phiMax << G4endl;
262 } 264 }
263 #endif 265 #endif
264 } 266 }
265 } 267 }
266 268
267 269
268 void CCalPrimaryGeneratorAction::SetStepsPhi(G 270 void CCalPrimaryGeneratorAction::SetStepsPhi(G4int val){
269 271
270 if (val <= 0) { 272 if (val <= 0) {
271 G4cerr << "CCalPrimaryGeneratorAction::Set 273 G4cerr << "CCalPrimaryGeneratorAction::SetStepsPhi: value " << val
272 << " is out of bounds, it will not << 274 << " is out of bounds, it will not be used" << G4endl;
273 G4cerr << " Should be > 0 Please check" 275 G4cerr << " Should be > 0 Please check" << G4endl;
274 } else { 276 } else {
275 phiSteps = val; 277 phiSteps = val;
276 #ifdef debug 278 #ifdef debug
277 if (verboseLevel >= 1 ) { 279 if (verboseLevel >= 1 ) {
278 G4cout << " CCalPrimaryGeneratorAction: 280 G4cout << " CCalPrimaryGeneratorAction: setting no. of steps in phi to "
279 << phiSteps << G4endl; << 281 << phiSteps << G4endl;
280 } 282 }
281 #endif 283 #endif
282 } 284 }
283 } 285 }
284 286
285 287
286 void CCalPrimaryGeneratorAction::SetMinimumEta 288 void CCalPrimaryGeneratorAction::SetMinimumEta(G4double p){
287 289
288 etaMin = p; 290 etaMin = p;
289 #ifdef debug 291 #ifdef debug
290 if (verboseLevel >= 1 ) { 292 if (verboseLevel >= 1 ) {
291 G4cout << " CCalPrimaryGeneratorAction: se 293 G4cout << " CCalPrimaryGeneratorAction: setting min. value of eta to "
292 << etaMin << G4endl; << 294 << etaMin << G4endl;
293 } 295 }
294 #endif 296 #endif
295 } 297 }
296 298
297 299
298 void CCalPrimaryGeneratorAction::SetMaximumEta 300 void CCalPrimaryGeneratorAction::SetMaximumEta(G4double p){
299 301
300 etaMax = p; 302 etaMax = p;
301 #ifdef debug 303 #ifdef debug
302 if (verboseLevel >= 1 ) { 304 if (verboseLevel >= 1 ) {
303 G4cout << " CCalPrimaryGeneratorAction: se 305 G4cout << " CCalPrimaryGeneratorAction: setting max. value of eta to "
304 << etaMax << G4endl; << 306 << etaMax << G4endl;
305 } 307 }
306 #endif 308 #endif
307 } 309 }
308 310
309 311
310 void CCalPrimaryGeneratorAction::SetStepsEta(G 312 void CCalPrimaryGeneratorAction::SetStepsEta(G4int val){
311 313
312 if (val <= 0) { 314 if (val <= 0) {
313 G4cerr<<"CCalPrimaryGeneratorAction::SetSt 315 G4cerr<<"CCalPrimaryGeneratorAction::SetStepsEta: value " << val << " is out of bounds, it will not be used"<<G4endl;
314 G4cerr<<" Should be > 0 Please check"<<G 316 G4cerr<<" Should be > 0 Please check"<<G4endl;
315 } else { 317 } else {
316 etaSteps = val; 318 etaSteps = val;
317 #ifdef debug 319 #ifdef debug
318 if (verboseLevel >= 1 ) { 320 if (verboseLevel >= 1 ) {
319 G4cout << " CCalPrimaryGeneratorAction: 321 G4cout << " CCalPrimaryGeneratorAction: setting no. of steps in eta to "
320 << etaSteps << G4endl; << 322 << etaSteps << G4endl;
321 } 323 }
322 #endif 324 #endif
323 } 325 }
324 } 326 }
325 327
326 void CCalPrimaryGeneratorAction::SetGunPositio 328 void CCalPrimaryGeneratorAction::SetGunPosition(const G4ThreeVector & pos) const {
327 329
328 particleGun->SetParticlePosition(pos); 330 particleGun->SetParticlePosition(pos);
329 } 331 }
330 332
331 void CCalPrimaryGeneratorAction::SetRunNo(G4in 333 void CCalPrimaryGeneratorAction::SetRunNo(G4int val){
332 G4RunManager::GetRunManager()->SetRunIDCount 334 G4RunManager::GetRunManager()->SetRunIDCounter( val );
333 } 335 }
334 336
335 void CCalPrimaryGeneratorAction::initialize(){ 337 void CCalPrimaryGeneratorAction::initialize(){
336 338
337 isInitialized = 1; 339 isInitialized = 1;
338 340
339 print (1); 341 print (1);
340 } 342 }
341 343
342 344
343 void CCalPrimaryGeneratorAction::print(G4int v 345 void CCalPrimaryGeneratorAction::print(G4int val){
344 346
>> 347 #ifdef debug
345 if (verboseLevel >= val) { 348 if (verboseLevel >= val) {
346 349
347 if (generatorInput == singleRandom) { 350 if (generatorInput == singleRandom) {
348 G4cout << G4endl 351 G4cout << G4endl
349 << "***************************** << 352 << "**********************************************************************" << G4endl
350 << "* << 353 << "* *" << G4endl
351 << "* CCalPrimaryGeneratorAction << 354 << "* CCalPrimaryGeneratorAction DEFAULT Random Energy/Direction setting:*" << G4endl
352 << "* << 355 << "* *" << G4endl
353 << "* << 356 << "* *" << G4endl
354 << "* Energy in [ "<< energy << 357 << "* Energy in [ "<< energyMin/GeV << " - " << energyMax/GeV << "] (GeV) "<< G4endl
355 << "* Phi angle in [ "<< phiMin << 358 << "* Phi angle in [ "<< phiMin << " - " << phiMax << "] (rad) "<< G4endl
356 << "* [ "<< phiMin << 359 << "* [ "<< phiMin/degree << " - " << phiMax/degree << "] (deg) "<< G4endl
357 << "* Eta in [ "<< etaMin << 360 << "* Eta in [ "<< etaMin << " - " << etaMax << "] "<< G4endl
358 << "* << 361 << "* *" << G4endl
359 << "* << 362 << "* *" << G4endl
360 << "*********************** << 363 << "**********************************************************************" << G4endl;
361 } else if (generatorInput == singleScan) { 364 } else if (generatorInput == singleScan) {
362 G4cout << G4endl 365 G4cout << G4endl
363 << "***************************** << 366 << "**********************************************************************" << G4endl
364 << "* << 367 << "* *" << G4endl
365 << "* CCalPrimaryGeneratorAction << 368 << "* CCalPrimaryGeneratorAction DEFAULT Scan Direction settings : *" << G4endl
366 << "* << 369 << "* *" << G4endl
367 << "* << 370 << "* *" << G4endl
368 << "* Phi angle in [ " << phiMi << 371 << "* Phi angle in [ " << phiMin/degree << " - " << phiMax/degree << "] (deg) " << G4endl
369 << "* Eta in [ " << etaMi << 372 << "* Eta in [ " << etaMin << " - " << etaMax << "] " << G4endl
370 << "* Steps along eta " << etaS << 373 << "* Steps along eta " << etaSteps << " and along phi " << phiSteps << G4endl
371 << "* << 374 << "* *" << G4endl
372 << "* << 375 << "* *" << G4endl
373 << "*********************** << 376 << "**********************************************************************" << G4endl;
374 } else if (generatorInput == singleFixed) 377 } else if (generatorInput == singleFixed) {
375 G4cout << G4endl 378 G4cout << G4endl
376 << "***************************** << 379 << "*******************************************************************" << G4endl
377 << "* << 380 << "* *" << G4endl
378 << "* CCalPrimaryGeneratorAction: << 381 << "* CCalPrimaryGeneratorAction: Current settings : *" << G4endl
379 << "* << 382 << "* *" << G4endl
380 << "* " << particleGun->GetNumber << 383 << "* " << particleGun->GetNumberOfParticles()
381 << " " << particleGun->GetPartic << 384 << " " << particleGun->GetParticleDefinition()->GetParticleName()
382 << " of " << particleGun->GetPart << 385 << " of " << particleGun->GetParticleEnergy()/GeV << " GeV" << G4endl
383 << "* will be shot from " << part << 386 << "* will be shot from " << particleGun->GetParticlePosition() << G4endl;
384 G4cout << "* in direction " << particleG 387 G4cout << "* in direction " << particleGun->GetParticleMomentumDirection() << G4endl;
385 G4cout << "* << 388 G4cout << "* *" << G4endl
386 << "* << 389 << "* *" << G4endl
387 << "***************************** << 390 << "*******************************************************************" << G4endl;
388 } 391 }
389 } << 392 }
>> 393 #endif
>> 394
390 } 395 }
>> 396
391 397