source: trunk/examples/extended/biasing/B01/src/B01PhysicsList.cc@ 1345

Last change on this file since 1345 was 1337, checked in by garnier, 15 years ago

tag geant4.9.4 beta 1 + modifs locales
File size: 27.3 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: B01PhysicsList.cc,v 1.9 2010/03/24 21:04:23 gcosmo Exp $
28// GEANT4 tag $Name: geant4-09-04-beta-01 $
29//
30
31#include "globals.hh"
32#include <iomanip>
33
34#include "B01PhysicsList.hh"
35
36#include "G4ParticleDefinition.hh"
37#include "G4ParticleWithCuts.hh"
38#include "G4ProcessManager.hh"
39#include "G4ProcessVector.hh"
40#include "G4ParticleTypes.hh"
41#include "G4ParticleTable.hh"
42#include "G4BosonConstructor.hh"
43#include "G4LeptonConstructor.hh"
44#include "G4MesonConstructor.hh"
45#include "G4BaryonConstructor.hh"
46#include "G4IonConstructor.hh"
47#include "G4ShortLivedConstructor.hh"
48#include "G4Material.hh"
49#include "G4MaterialTable.hh"
50
51B01PhysicsList::B01PhysicsList(): G4VUserPhysicsList()
52{
53 paraWorldName.clear();
54 SetVerboseLevel(1);
55
56}
57
58B01PhysicsList::~B01PhysicsList()
59{
60 paraWorldName.clear();
61}
62
63void B01PhysicsList::ConstructParticle()
64{
65 // In this method, static member functions should be called
66 // for all particles which you want to use.
67 // This ensures that objects of these particle types will be
68 // created in the program.
69
70 ConstructAllBosons();
71 ConstructAllLeptons();
72 ConstructAllMesons();
73 ConstructAllBaryons();
74 ConstructAllIons();
75 ConstructAllShortLiveds();
76}
77
78void B01PhysicsList::ConstructAllBosons()
79{
80 // Construct all bosons
81 G4BosonConstructor pConstructor;
82 pConstructor.ConstructParticle();
83}
84
85void B01PhysicsList::ConstructAllLeptons()
86{
87 // Construct all leptons
88 G4LeptonConstructor pConstructor;
89 pConstructor.ConstructParticle();
90}
91
92void B01PhysicsList::ConstructAllMesons()
93{
94 // Construct all mesons
95 G4MesonConstructor pConstructor;
96 pConstructor.ConstructParticle();
97}
98
99void B01PhysicsList::ConstructAllBaryons()
100{
101 // Construct all barions
102 G4BaryonConstructor pConstructor;
103 pConstructor.ConstructParticle();
104}
105
106void B01PhysicsList::ConstructAllIons()
107{
108 // Construct light ions
109 G4IonConstructor pConstructor;
110 pConstructor.ConstructParticle();
111}
112
113void B01PhysicsList::ConstructAllShortLiveds()
114{
115 // Construct resonaces and quarks
116 G4ShortLivedConstructor pConstructor;
117 pConstructor.ConstructParticle();
118}
119
120void B01PhysicsList::ConstructProcess()
121{
122 AddTransportation();
123 AddScoringProcess();
124 ConstructEM();
125 ConstructLeptHad();
126 ConstructHad();
127 ConstructGeneral();
128}
129
130#include "G4ComptonScattering.hh"
131#include "G4GammaConversion.hh"
132#include "G4PhotoElectricEffect.hh"
133
134#include "G4eMultipleScattering.hh"
135#include "G4MuMultipleScattering.hh"
136#include "G4hMultipleScattering.hh"
137
138#include "G4eIonisation.hh"
139#include "G4eBremsstrahlung.hh"
140#include "G4eplusAnnihilation.hh"
141
142#include "G4MuIonisation.hh"
143#include "G4MuBremsstrahlung.hh"
144#include "G4MuPairProduction.hh"
145
146#include "G4hIonisation.hh"
147
148void B01PhysicsList::ConstructEM()
149{
150 theParticleIterator->reset();
151 while( (*theParticleIterator)() ){
152 G4ParticleDefinition* particle = theParticleIterator->value();
153 G4ProcessManager* pmanager = particle->GetProcessManager();
154 G4String particleName = particle->GetParticleName();
155
156 if (particleName == "gamma") {
157 // gamma
158 // Construct processes for gamma
159 pmanager->AddDiscreteProcess(new G4GammaConversion());
160 pmanager->AddDiscreteProcess(new G4ComptonScattering());
161 pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
162
163 } else if (particleName == "e-") {
164 //electron
165 // Construct processes for electron
166 pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
167 pmanager->AddProcess(new G4eIonisation(),-1,2,2);
168 pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
169
170 } else if (particleName == "e+") {
171 //positron
172 // Construct processes for positron
173 pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
174
175 pmanager->AddProcess(new G4eIonisation(),-1,2,2);
176 pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
177 pmanager->AddProcess(new G4eplusAnnihilation(),0,-1,4);
178
179 } else if( particleName == "mu+" ||
180 particleName == "mu-" ) {
181 //muon
182 // Construct processes for muon+
183 pmanager->AddProcess(new G4MuMultipleScattering(),-1,1,1);
184 pmanager->AddProcess(new G4MuIonisation(),-1,2,2);
185 pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);
186 pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);
187
188 } else if( particleName == "GenericIon" ) {
189 pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
190 pmanager->AddProcess(new G4hIonisation(),-1,2,2);
191 } else {
192 if ((particle->GetPDGCharge() != 0.0) &&
193 (particle->GetParticleName() != "chargedgeantino")&&
194 (!particle->IsShortLived()) ) {
195 // all others charged particles except geantino
196 pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
197 pmanager->AddProcess(new G4hIonisation(),-1,2,2);
198 }
199 }
200 }
201}
202
203// Hadron Processes
204
205#include "G4HadronElasticProcess.hh"
206#include "G4HadronFissionProcess.hh"
207#include "G4HadronCaptureProcess.hh"
208
209#include "G4PionPlusInelasticProcess.hh"
210#include "G4PionMinusInelasticProcess.hh"
211#include "G4KaonPlusInelasticProcess.hh"
212#include "G4KaonZeroSInelasticProcess.hh"
213#include "G4KaonZeroLInelasticProcess.hh"
214#include "G4KaonMinusInelasticProcess.hh"
215#include "G4ProtonInelasticProcess.hh"
216#include "G4AntiProtonInelasticProcess.hh"
217#include "G4NeutronInelasticProcess.hh"
218#include "G4AntiNeutronInelasticProcess.hh"
219#include "G4LambdaInelasticProcess.hh"
220#include "G4AntiLambdaInelasticProcess.hh"
221#include "G4SigmaPlusInelasticProcess.hh"
222#include "G4SigmaMinusInelasticProcess.hh"
223#include "G4AntiSigmaPlusInelasticProcess.hh"
224#include "G4AntiSigmaMinusInelasticProcess.hh"
225#include "G4XiZeroInelasticProcess.hh"
226#include "G4XiMinusInelasticProcess.hh"
227#include "G4AntiXiZeroInelasticProcess.hh"
228#include "G4AntiXiMinusInelasticProcess.hh"
229#include "G4DeuteronInelasticProcess.hh"
230#include "G4TritonInelasticProcess.hh"
231#include "G4AlphaInelasticProcess.hh"
232#include "G4OmegaMinusInelasticProcess.hh"
233#include "G4AntiOmegaMinusInelasticProcess.hh"
234
235// Low-energy Models
236
237#include "G4LElastic.hh"
238#include "G4LFission.hh"
239#include "G4LCapture.hh"
240
241#include "G4LEPionPlusInelastic.hh"
242#include "G4LEPionMinusInelastic.hh"
243#include "G4LEKaonPlusInelastic.hh"
244#include "G4LEKaonZeroSInelastic.hh"
245#include "G4LEKaonZeroLInelastic.hh"
246#include "G4LEKaonMinusInelastic.hh"
247#include "G4LEProtonInelastic.hh"
248#include "G4LEAntiProtonInelastic.hh"
249#include "G4LENeutronInelastic.hh"
250#include "G4LEAntiNeutronInelastic.hh"
251#include "G4LELambdaInelastic.hh"
252#include "G4LEAntiLambdaInelastic.hh"
253#include "G4LESigmaPlusInelastic.hh"
254#include "G4LESigmaMinusInelastic.hh"
255#include "G4LEAntiSigmaPlusInelastic.hh"
256#include "G4LEAntiSigmaMinusInelastic.hh"
257#include "G4LEXiZeroInelastic.hh"
258#include "G4LEXiMinusInelastic.hh"
259#include "G4LEAntiXiZeroInelastic.hh"
260#include "G4LEAntiXiMinusInelastic.hh"
261#include "G4LEDeuteronInelastic.hh"
262#include "G4LETritonInelastic.hh"
263#include "G4LEAlphaInelastic.hh"
264#include "G4LEOmegaMinusInelastic.hh"
265#include "G4LEAntiOmegaMinusInelastic.hh"
266
267// -- generator models
268#include "G4TheoFSGenerator.hh"
269#include "G4ExcitationHandler.hh"
270#include "G4Evaporation.hh"
271#include "G4CompetitiveFission.hh"
272#include "G4FermiBreakUp.hh"
273#include "G4StatMF.hh"
274#include "G4GeneratorPrecompoundInterface.hh"
275#include "G4Fancy3DNucleus.hh"
276#include "G4LEProtonInelastic.hh"
277#include "G4StringModel.hh"
278#include "G4PreCompoundModel.hh"
279#include "G4FTFModel.hh"
280#include "G4QGSMFragmentation.hh"
281#include "G4ExcitedStringDecay.hh"
282
283//
284// ConstructHad()
285//
286// Makes discrete physics processes for the hadrons, at present limited
287// to those particles with GHEISHA interactions (INTRC > 0).
288// The processes are: Elastic scattering, Inelastic scattering,
289// Fission (for neutron only), and Capture (neutron).
290//
291// F.W.Jones 06-JUL-1998
292//
293
294void B01PhysicsList::ConstructHad()
295{
296 // this will be the model class for high energies
297 G4TheoFSGenerator * theTheoModel = new G4TheoFSGenerator;
298
299 // all models for treatment of thermal nucleus
300 G4Evaporation * theEvaporation = new G4Evaporation;
301 G4FermiBreakUp * theFermiBreakUp = new G4FermiBreakUp;
302 G4StatMF * theMF = new G4StatMF;
303
304 // Evaporation logic
305 G4ExcitationHandler * theHandler = new G4ExcitationHandler;
306 theHandler->SetEvaporation(theEvaporation);
307 theHandler->SetFermiModel(theFermiBreakUp);
308 theHandler->SetMultiFragmentation(theMF);
309 theHandler->SetMaxAandZForFermiBreakUp(12, 6);
310 theHandler->SetMinEForMultiFrag(3*MeV);
311
312 // Pre equilibrium stage
313 G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel(theHandler);
314
315
316 // a no-cascade generator-precompound interaface
317 G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface;
318 theCascade->SetDeExcitation(thePreEquilib);
319
320 // here come the high energy parts
321 // the string model; still not quite according to design - Explicite use of the forseen interfaces
322 // will be tested and documented in this program by beta-02 at latest.
323 G4VPartonStringModel * theStringModel;
324 theStringModel = new G4FTFModel;
325 theTheoModel->SetTransport(theCascade);
326 theTheoModel->SetHighEnergyGenerator(theStringModel);
327 theTheoModel->SetMinEnergy(19*GeV);
328 theTheoModel->SetMaxEnergy(100*TeV);
329
330 G4VLongitudinalStringDecay * theFragmentation = new G4QGSMFragmentation;
331 G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay(theFragmentation);
332 theStringModel->SetFragmentationModel(theStringDecay);
333
334// done with the generator model (most of the above is also available as default)
335 G4HadronElasticProcess* theElasticProcess =
336 new G4HadronElasticProcess;
337 G4LElastic* theElasticModel = new G4LElastic;
338 theElasticProcess->RegisterMe(theElasticModel);
339 G4HadronElasticProcess* theElasticProcess1 =
340 new G4HadronElasticProcess;
341 theParticleIterator->reset();
342 while ((*theParticleIterator)()) {
343 G4ParticleDefinition* particle = theParticleIterator->value();
344 G4ProcessManager* pmanager = particle->GetProcessManager();
345 G4String particleName = particle->GetParticleName();
346
347 if (particleName == "pi+") {
348 pmanager->AddDiscreteProcess(theElasticProcess);
349 G4PionPlusInelasticProcess* theInelasticProcess =
350 new G4PionPlusInelasticProcess("inelastic");
351 G4LEPionPlusInelastic* theInelasticModel =
352 new G4LEPionPlusInelastic;
353 theInelasticProcess->RegisterMe(theInelasticModel);
354 theInelasticProcess->RegisterMe(theTheoModel);
355 pmanager->AddDiscreteProcess(theInelasticProcess);
356 }
357 else if (particleName == "pi-") {
358 pmanager->AddDiscreteProcess(theElasticProcess);
359 G4PionMinusInelasticProcess* theInelasticProcess =
360 new G4PionMinusInelasticProcess("inelastic");
361 G4LEPionMinusInelastic* theInelasticModel =
362 new G4LEPionMinusInelastic;
363 theInelasticProcess->RegisterMe(theInelasticModel);
364 theInelasticProcess->RegisterMe(theTheoModel);
365 pmanager->AddDiscreteProcess(theInelasticProcess);
366 }
367 else if (particleName == "kaon+") {
368 pmanager->AddDiscreteProcess(theElasticProcess);
369 G4KaonPlusInelasticProcess* theInelasticProcess =
370 new G4KaonPlusInelasticProcess("inelastic");
371 G4LEKaonPlusInelastic* theInelasticModel = new G4LEKaonPlusInelastic;
372 theInelasticProcess->RegisterMe(theInelasticModel);
373 theInelasticProcess->RegisterMe(theTheoModel);
374 pmanager->AddDiscreteProcess(theInelasticProcess);
375 }
376 else if (particleName == "kaon0S") {
377 pmanager->AddDiscreteProcess(theElasticProcess);
378 G4KaonZeroSInelasticProcess* theInelasticProcess =
379 new G4KaonZeroSInelasticProcess("inelastic");
380 G4LEKaonZeroSInelastic* theInelasticModel =
381 new G4LEKaonZeroSInelastic;
382 theInelasticProcess->RegisterMe(theInelasticModel);
383 theInelasticProcess->RegisterMe(theTheoModel);
384 pmanager->AddDiscreteProcess(theInelasticProcess);
385 }
386 else if (particleName == "kaon0L") {
387 pmanager->AddDiscreteProcess(theElasticProcess);
388 G4KaonZeroLInelasticProcess* theInelasticProcess =
389 new G4KaonZeroLInelasticProcess("inelastic");
390 G4LEKaonZeroLInelastic* theInelasticModel =
391 new G4LEKaonZeroLInelastic;
392 theInelasticProcess->RegisterMe(theInelasticModel);
393 theInelasticProcess->RegisterMe(theTheoModel);
394 pmanager->AddDiscreteProcess(theInelasticProcess);
395 }
396 else if (particleName == "kaon-") {
397 pmanager->AddDiscreteProcess(theElasticProcess);
398 G4KaonMinusInelasticProcess* theInelasticProcess =
399 new G4KaonMinusInelasticProcess("inelastic");
400 G4LEKaonMinusInelastic* theInelasticModel =
401 new G4LEKaonMinusInelastic;
402 theInelasticProcess->RegisterMe(theInelasticModel);
403 theInelasticProcess->RegisterMe(theTheoModel);
404 pmanager->AddDiscreteProcess(theInelasticProcess);
405 }
406 else if (particleName == "proton") {
407 pmanager->AddDiscreteProcess(theElasticProcess);
408 G4ProtonInelasticProcess* theInelasticProcess =
409 new G4ProtonInelasticProcess("inelastic");
410 G4LEProtonInelastic* theInelasticModel = new G4LEProtonInelastic;
411 theInelasticProcess->RegisterMe(theInelasticModel);
412 theInelasticProcess->RegisterMe(theTheoModel);
413 pmanager->AddDiscreteProcess(theInelasticProcess);
414 }
415 else if (particleName == "anti_proton") {
416 pmanager->AddDiscreteProcess(theElasticProcess);
417 G4AntiProtonInelasticProcess* theInelasticProcess =
418 new G4AntiProtonInelasticProcess("inelastic");
419 G4LEAntiProtonInelastic* theInelasticModel =
420 new G4LEAntiProtonInelastic;
421 theInelasticProcess->RegisterMe(theInelasticModel);
422 theInelasticProcess->RegisterMe(theTheoModel);
423 pmanager->AddDiscreteProcess(theInelasticProcess);
424 }
425 else if (particleName == "neutron") {
426
427 // elastic scattering
428 G4LElastic* theElasticModel1 = new G4LElastic;
429 theElasticProcess1->RegisterMe(theElasticModel1);
430 pmanager->AddDiscreteProcess(theElasticProcess1);
431 // inelastic scattering
432 G4NeutronInelasticProcess* theInelasticProcess =
433 new G4NeutronInelasticProcess("inelastic");
434 G4LENeutronInelastic* theInelasticModel = new G4LENeutronInelastic;
435 theInelasticProcess->RegisterMe(theInelasticModel);
436 theInelasticProcess->RegisterMe(theTheoModel);
437 pmanager->AddDiscreteProcess(theInelasticProcess);
438 // fission
439 G4HadronFissionProcess* theFissionProcess =
440 new G4HadronFissionProcess;
441 G4LFission* theFissionModel = new G4LFission;
442 theFissionProcess->RegisterMe(theFissionModel);
443 pmanager->AddDiscreteProcess(theFissionProcess);
444 // capture
445 G4HadronCaptureProcess* theCaptureProcess =
446 new G4HadronCaptureProcess;
447 G4LCapture* theCaptureModel = new G4LCapture;
448 theCaptureProcess->RegisterMe(theCaptureModel);
449 pmanager->AddDiscreteProcess(theCaptureProcess);
450 }
451 else if (particleName == "anti_neutron") {
452 pmanager->AddDiscreteProcess(theElasticProcess);
453 G4AntiNeutronInelasticProcess* theInelasticProcess =
454 new G4AntiNeutronInelasticProcess("inelastic");
455 G4LEAntiNeutronInelastic* theInelasticModel =
456 new G4LEAntiNeutronInelastic;
457 theInelasticProcess->RegisterMe(theInelasticModel);
458 theInelasticProcess->RegisterMe(theTheoModel);
459 pmanager->AddDiscreteProcess(theInelasticProcess);
460 }
461 else if (particleName == "lambda") {
462 pmanager->AddDiscreteProcess(theElasticProcess);
463 G4LambdaInelasticProcess* theInelasticProcess =
464 new G4LambdaInelasticProcess("inelastic");
465 G4LELambdaInelastic* theInelasticModel = new G4LELambdaInelastic;
466 theInelasticProcess->RegisterMe(theInelasticModel);
467 theInelasticProcess->RegisterMe(theTheoModel);
468 pmanager->AddDiscreteProcess(theInelasticProcess);
469 }
470 else if (particleName == "anti_lambda") {
471 pmanager->AddDiscreteProcess(theElasticProcess);
472 G4AntiLambdaInelasticProcess* theInelasticProcess =
473 new G4AntiLambdaInelasticProcess("inelastic");
474 G4LEAntiLambdaInelastic* theInelasticModel =
475 new G4LEAntiLambdaInelastic;
476 theInelasticProcess->RegisterMe(theInelasticModel);
477 theInelasticProcess->RegisterMe(theTheoModel);
478 pmanager->AddDiscreteProcess(theInelasticProcess);
479 }
480 else if (particleName == "sigma+") {
481 pmanager->AddDiscreteProcess(theElasticProcess);
482 G4SigmaPlusInelasticProcess* theInelasticProcess =
483 new G4SigmaPlusInelasticProcess("inelastic");
484 G4LESigmaPlusInelastic* theInelasticModel =
485 new G4LESigmaPlusInelastic;
486 theInelasticProcess->RegisterMe(theInelasticModel);
487 theInelasticProcess->RegisterMe(theTheoModel);
488 pmanager->AddDiscreteProcess(theInelasticProcess);
489 }
490 else if (particleName == "sigma-") {
491 pmanager->AddDiscreteProcess(theElasticProcess);
492 G4SigmaMinusInelasticProcess* theInelasticProcess =
493 new G4SigmaMinusInelasticProcess("inelastic");
494 G4LESigmaMinusInelastic* theInelasticModel =
495 new G4LESigmaMinusInelastic;
496 theInelasticProcess->RegisterMe(theInelasticModel);
497 theInelasticProcess->RegisterMe(theTheoModel);
498 pmanager->AddDiscreteProcess(theInelasticProcess);
499 }
500 else if (particleName == "anti_sigma+") {
501 pmanager->AddDiscreteProcess(theElasticProcess);
502 G4AntiSigmaPlusInelasticProcess* theInelasticProcess =
503 new G4AntiSigmaPlusInelasticProcess("inelastic");
504 G4LEAntiSigmaPlusInelastic* theInelasticModel =
505 new G4LEAntiSigmaPlusInelastic;
506 theInelasticProcess->RegisterMe(theInelasticModel);
507 theInelasticProcess->RegisterMe(theTheoModel);
508 pmanager->AddDiscreteProcess(theInelasticProcess);
509 }
510 else if (particleName == "anti_sigma-") {
511 pmanager->AddDiscreteProcess(theElasticProcess);
512 G4AntiSigmaMinusInelasticProcess* theInelasticProcess =
513 new G4AntiSigmaMinusInelasticProcess("inelastic");
514 G4LEAntiSigmaMinusInelastic* theInelasticModel =
515 new G4LEAntiSigmaMinusInelastic;
516 theInelasticProcess->RegisterMe(theInelasticModel);
517 theInelasticProcess->RegisterMe(theTheoModel);
518 pmanager->AddDiscreteProcess(theInelasticProcess);
519 }
520 else if (particleName == "xi0") {
521 pmanager->AddDiscreteProcess(theElasticProcess);
522 G4XiZeroInelasticProcess* theInelasticProcess =
523 new G4XiZeroInelasticProcess("inelastic");
524 G4LEXiZeroInelastic* theInelasticModel =
525 new G4LEXiZeroInelastic;
526 theInelasticProcess->RegisterMe(theInelasticModel);
527 theInelasticProcess->RegisterMe(theTheoModel);
528 pmanager->AddDiscreteProcess(theInelasticProcess);
529 }
530 else if (particleName == "xi-") {
531 pmanager->AddDiscreteProcess(theElasticProcess);
532 G4XiMinusInelasticProcess* theInelasticProcess =
533 new G4XiMinusInelasticProcess("inelastic");
534 G4LEXiMinusInelastic* theInelasticModel =
535 new G4LEXiMinusInelastic;
536 theInelasticProcess->RegisterMe(theInelasticModel);
537 theInelasticProcess->RegisterMe(theTheoModel);
538 pmanager->AddDiscreteProcess(theInelasticProcess);
539 }
540 else if (particleName == "anti_xi0") {
541 pmanager->AddDiscreteProcess(theElasticProcess);
542 G4AntiXiZeroInelasticProcess* theInelasticProcess =
543 new G4AntiXiZeroInelasticProcess("inelastic");
544 G4LEAntiXiZeroInelastic* theInelasticModel =
545 new G4LEAntiXiZeroInelastic;
546 theInelasticProcess->RegisterMe(theInelasticModel);
547 theInelasticProcess->RegisterMe(theTheoModel);
548 pmanager->AddDiscreteProcess(theInelasticProcess);
549 }
550 else if (particleName == "anti_xi-") {
551 pmanager->AddDiscreteProcess(theElasticProcess);
552 G4AntiXiMinusInelasticProcess* theInelasticProcess =
553 new G4AntiXiMinusInelasticProcess("inelastic");
554 G4LEAntiXiMinusInelastic* theInelasticModel =
555 new G4LEAntiXiMinusInelastic;
556 theInelasticProcess->RegisterMe(theInelasticModel);
557 theInelasticProcess->RegisterMe(theTheoModel);
558 pmanager->AddDiscreteProcess(theInelasticProcess);
559 }
560 else if (particleName == "deuteron") {
561 pmanager->AddDiscreteProcess(theElasticProcess);
562 G4DeuteronInelasticProcess* theInelasticProcess =
563 new G4DeuteronInelasticProcess("inelastic");
564 G4LEDeuteronInelastic* theInelasticModel =
565 new G4LEDeuteronInelastic;
566 theInelasticProcess->RegisterMe(theInelasticModel);
567 theInelasticProcess->RegisterMe(theTheoModel);
568 pmanager->AddDiscreteProcess(theInelasticProcess);
569 }
570 else if (particleName == "triton") {
571 pmanager->AddDiscreteProcess(theElasticProcess);
572 G4TritonInelasticProcess* theInelasticProcess =
573 new G4TritonInelasticProcess("inelastic");
574 G4LETritonInelastic* theInelasticModel =
575 new G4LETritonInelastic;
576 theInelasticProcess->RegisterMe(theInelasticModel);
577 theInelasticProcess->RegisterMe(theTheoModel);
578 pmanager->AddDiscreteProcess(theInelasticProcess);
579 }
580 else if (particleName == "alpha") {
581 pmanager->AddDiscreteProcess(theElasticProcess);
582 G4AlphaInelasticProcess* theInelasticProcess =
583 new G4AlphaInelasticProcess("inelastic");
584 G4LEAlphaInelastic* theInelasticModel =
585 new G4LEAlphaInelastic;
586 theInelasticProcess->RegisterMe(theInelasticModel);
587 theInelasticProcess->RegisterMe(theTheoModel);
588 pmanager->AddDiscreteProcess(theInelasticProcess);
589 }
590 else if (particleName == "omega-") {
591 pmanager->AddDiscreteProcess(theElasticProcess);
592 G4OmegaMinusInelasticProcess* theInelasticProcess =
593 new G4OmegaMinusInelasticProcess("inelastic");
594 G4LEOmegaMinusInelastic* theInelasticModel =
595 new G4LEOmegaMinusInelastic;
596 theInelasticProcess->RegisterMe(theInelasticModel);
597 theInelasticProcess->RegisterMe(theTheoModel);
598 pmanager->AddDiscreteProcess(theInelasticProcess);
599 }
600 else if (particleName == "anti_omega-") {
601 pmanager->AddDiscreteProcess(theElasticProcess);
602 G4AntiOmegaMinusInelasticProcess* theInelasticProcess =
603 new G4AntiOmegaMinusInelasticProcess("inelastic");
604 G4LEAntiOmegaMinusInelastic* theInelasticModel =
605 new G4LEAntiOmegaMinusInelastic;
606 theInelasticProcess->RegisterMe(theInelasticModel);
607 theInelasticProcess->RegisterMe(theTheoModel);
608 pmanager->AddDiscreteProcess(theInelasticProcess);
609 }
610 }
611}
612
613void B01PhysicsList::ConstructLeptHad()
614{;}
615
616#include "G4Decay.hh"
617void B01PhysicsList::ConstructGeneral()
618{
619 G4Decay* theDecayProcess = new G4Decay();
620 theParticleIterator->reset();
621 while( (*theParticleIterator)() ){
622 G4ParticleDefinition* particle = theParticleIterator->value();
623 G4ProcessManager* pmanager = particle->GetProcessManager();
624 if (theDecayProcess->IsApplicable(*particle)) {
625 pmanager ->AddProcess(theDecayProcess);
626 pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
627 pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
628 }
629 }
630}
631
632void B01PhysicsList::SetCuts()
633{
634 if (verboseLevel >0)
635 {
636 G4cout << "B01PhysicsList::SetCuts:";
637 G4cout << "CutLength : " << defaultCutValue/mm << " (mm)" << G4endl;
638 }
639 // "G4VUserPhysicsList::SetCutsWithDefault" method sets
640 // the default cut value for all particle types
641 SetCutsWithDefault();
642}
643
644#include "G4ParallelWorldScoringProcess.hh"
645void B01PhysicsList::AddScoringProcess(){
646
647 G4int npw = paraWorldName.size();
648 for ( G4int i = 0; i < npw; i++){
649 G4ParallelWorldScoringProcess* theParallelWorldScoringProcess
650 = new G4ParallelWorldScoringProcess("ParaWorldScoringProc");
651 theParallelWorldScoringProcess->SetParallelWorld(paraWorldName[i]);
652
653 theParticleIterator->reset();
654 while( (*theParticleIterator)() ){
655 G4ParticleDefinition* particle = theParticleIterator->value();
656 if ( !particle->IsShortLived() ){
657 G4ProcessManager* pmanager = particle->GetProcessManager();
658 pmanager->AddProcess(theParallelWorldScoringProcess);
659 pmanager->SetProcessOrderingToLast(theParallelWorldScoringProcess,idxAtRest);
660 pmanager->SetProcessOrdering(theParallelWorldScoringProcess,idxAlongStep,1);
661 pmanager->SetProcessOrderingToLast(theParallelWorldScoringProcess,idxPostStep);
662 }
663 }
664 }
665
666}
Note: See TracBrowser for help on using the repository browser.