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