Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Private Attributes | List of all members
B03PhysicsList Class Reference
biasing » B03

#include <Doxymodules_biasing.h>

Inheritance diagram for B03PhysicsList:
G4VUserPhysicsList

Public Member Functions

 B03PhysicsList (G4String)
 
virtual ~B03PhysicsList ()
 
void AddParallelWorldName (G4String &pname)
 

Protected Member Functions

virtual void ConstructParticle ()
 
virtual void ConstructProcess ()
 
virtual void SetCuts ()
 
virtual void ConstructGeneral ()
 
virtual void ConstructEM ()
 
virtual void ConstructHad ()
 
virtual void ConstructLeptHad ()
 
void AddScoringProcess ()
 
void AddBiasingProcess ()
 
void ConstructAllBosons ()
 
void ConstructAllLeptons ()
 
void ConstructAllMesons ()
 
void ConstructAllBaryons ()
 
void ConstructAllIons ()
 
void ConstructAllShortLiveds ()
 

Private Attributes

std::vector< G4String > fParaWorldName
 
G4String fBiasWorldName
 

Detailed Description

Definition at line 52 of file Doxymodules_biasing.h.

Constructor & Destructor Documentation

◆ B03PhysicsList()

B03PhysicsList::B03PhysicsList ( G4String  parallelname)

Definition at line 56 of file B03PhysicsList.cc.

56 :
57G4VUserPhysicsList(),
58fBiasWorldName(parallelname)
59{
60 fParaWorldName.clear();
61 SetVerboseLevel(1);
62}
B03PhysicsList::fParaWorldName
std::vector< G4String > fParaWorldName
Definition B03PhysicsList.hh:81
B03PhysicsList::fBiasWorldName
G4String fBiasWorldName
Definition B03PhysicsList.hh:82

◆ ~B03PhysicsList()

B03PhysicsList::~B03PhysicsList ( )
virtual

Definition at line 66 of file B03PhysicsList.cc.

67{
68 fParaWorldName.clear();
69}

Member Function Documentation

◆ AddParallelWorldName()

void B03PhysicsList::AddParallelWorldName ( G4String &  pname)
inline

Definition at line 48 of file B03PhysicsList.hh.

49 {fParaWorldName.push_back(pname);}

◆ ConstructParticle()

void B03PhysicsList::ConstructParticle ( )
protectedvirtual

Definition at line 73 of file B03PhysicsList.cc.

74{
75 // In this method, static member functions should be called
76 // for all particles which you want to use.
77 // This ensures that objects of these particle types will be
78 // created in the program.
79
80 ConstructAllBosons();
81 ConstructAllLeptons();
82 ConstructAllMesons();
83 ConstructAllBaryons();
84 ConstructAllIons();
85 ConstructAllShortLiveds();
86}
B03PhysicsList::ConstructAllLeptons
void ConstructAllLeptons()
Definition B03PhysicsList.cc:99
B03PhysicsList::ConstructAllBosons
void ConstructAllBosons()
Definition B03PhysicsList.cc:90
B03PhysicsList::ConstructAllShortLiveds
void ConstructAllShortLiveds()
Definition B03PhysicsList.cc:135

◆ ConstructProcess()

void B03PhysicsList::ConstructProcess ( )
protectedvirtual

Definition at line 144 of file B03PhysicsList.cc.

145{
146 AddTransportation();
147 AddScoringProcess();
148 AddBiasingProcess();
149 ConstructEM();
150 ConstructLeptHad();
151 ConstructHad();
152 ConstructGeneral();
153}
B03PhysicsList::ConstructLeptHad
virtual void ConstructLeptHad()
Definition B03PhysicsList.cc:593
B03PhysicsList::ConstructGeneral
virtual void ConstructGeneral()
Definition B03PhysicsList.cc:599
B03PhysicsList::ConstructHad
virtual void ConstructHad()
Definition B03PhysicsList.cc:277
B03PhysicsList::ConstructEM
virtual void ConstructEM()
Definition B03PhysicsList.cc:175

◆ SetCuts()

void B03PhysicsList::SetCuts ( )
protectedvirtual

Definition at line 617 of file B03PhysicsList.cc.

618{
619 if (verboseLevel >0)
620 {
621 G4cout << "B03PhysicsList::SetCuts:";
622 G4cout << "CutLength : " << defaultCutValue/mm << " (mm)" << G4endl;
623 }
624 // "G4VUserPhysicsList::SetCutsWithDefault" method sets
625 // the default cut value for all particle types
626 SetCutsWithDefault();
627}

◆ ConstructGeneral()

void B03PhysicsList::ConstructGeneral ( )
protectedvirtual

Definition at line 599 of file B03PhysicsList.cc.

600{
601 G4Decay* theDecayProcess = new G4Decay();
602 auto particleIterator=GetParticleIterator();
603 particleIterator->reset();
604 while( (*particleIterator)() ){
605 G4ParticleDefinition* particle = particleIterator->value();
606 G4ProcessManager* pmanager = particle->GetProcessManager();
607 if (theDecayProcess->IsApplicable(*particle)) {
608 pmanager ->AddProcess(theDecayProcess);
609 pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
610 pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
611 }
612 }
613}

◆ ConstructEM()

void B03PhysicsList::ConstructEM ( )
protectedvirtual

Definition at line 175 of file B03PhysicsList.cc.

176{
177 auto particleIterator=GetParticleIterator();
178 particleIterator->reset();
179 while( (*particleIterator)() ){
180 G4ParticleDefinition* particle = particleIterator->value();
181 G4ProcessManager* pmanager = particle->GetProcessManager();
182 G4String particleName = particle->GetParticleName();
183
184 if (particleName == "gamma") {
185 // gamma
186 // Construct processes for gamma
187 pmanager->AddDiscreteProcess(new G4GammaConversion());
188 pmanager->AddDiscreteProcess(new G4ComptonScattering());
189 pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
190
191 } else if (particleName == "e-") {
192 //electron
193 // Construct processes for electron
194 pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
195 pmanager->AddProcess(new G4eIonisation(),-1,2,2);
196 pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
197
198 } else if (particleName == "e+") {
199 //positron
200 // Construct processes for positron
201 pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
202
203 pmanager->AddProcess(new G4eIonisation(),-1,2,2);
204 pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
205 pmanager->AddProcess(new G4eplusAnnihilation(),0,-1,4);
206
207 } else if( particleName == "mu+" ||
208 particleName == "mu-" ) {
209 //muon
210 // Construct processes for muon+
211 pmanager->AddProcess(new G4MuMultipleScattering(),-1,1,1);
212 pmanager->AddProcess(new G4MuIonisation(),-1,2,2);
213 pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);
214 pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);
215
216 } else if( particleName == "GenericIon" ) {
217 pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
218 pmanager->AddProcess(new G4hIonisation(),-1,2,2);
219 } else {
220 if ((particle->GetPDGCharge() != 0.0) &&
221 (particle->GetParticleName() != "chargedgeantino")&&
222 (!particle->IsShortLived()) ) {
223 // all others charged particles except geantino
224 pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
225 pmanager->AddProcess(new G4hIonisation(),-1,2,2);
226 }
227 }
228 }
229}

◆ ConstructHad()

void B03PhysicsList::ConstructHad ( )
protectedvirtual

Definition at line 277 of file B03PhysicsList.cc.

278{
279 // this will be the model class for high energies
280 G4TheoFSGenerator* theTheoModel = new G4TheoFSGenerator;
281 G4TheoFSGenerator* antiBHighEnergyModel = new G4TheoFSGenerator;
282
283 // Evaporation logic
284 G4ExcitationHandler* theHandler = new G4ExcitationHandler;
285 theHandler->SetMinEForMultiFrag(3*MeV);
286
287 // Pre equilibrium stage
288 G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel(theHandler);
289
290 // a no-cascade generator-precompound interaface
291 G4GeneratorPrecompoundInterface* theCascade =
292 new G4GeneratorPrecompoundInterface;
293 theCascade->SetDeExcitation(thePreEquilib);
294
295 // Bertini cascade
296 G4CascadeInterface* bertini = new G4CascadeInterface;
297 bertini->SetMaxEnergy(22*MeV);
298
299 // here come the high energy parts
300 G4VPartonStringModel* theStringModel;
301 theStringModel = new G4FTFModel;
302 theTheoModel->SetTransport(theCascade);
303 theTheoModel->SetHighEnergyGenerator(theStringModel);
304 theTheoModel->SetMinEnergy(19*GeV);
305 theTheoModel->SetMaxEnergy( G4HadronicParameters::Instance()->GetMaxEnergy() );
306
307 G4VLongitudinalStringDecay* theFragmentation = new G4QGSMFragmentation;
308 G4ExcitedStringDecay* theStringDecay =
309 new G4ExcitedStringDecay(theFragmentation);
310 theStringModel->SetFragmentationModel(theStringDecay);
311
312 // high energy model for anti-baryons
313 antiBHighEnergyModel = new G4TheoFSGenerator("ANTI-FTFP");
314 G4FTFModel* antiBStringModel = new G4FTFModel;
315 G4ExcitedStringDecay* stringDecay =
316 new G4ExcitedStringDecay(new G4LundStringFragmentation);
317 antiBStringModel->SetFragmentationModel(stringDecay);
318
319 G4GeneratorPrecompoundInterface* antiBCascade =
320 new G4GeneratorPrecompoundInterface;
321 G4PreCompoundModel* preEquilib =
322 new G4PreCompoundModel(new G4ExcitationHandler);
323 antiBCascade->SetDeExcitation(preEquilib);
324
325 antiBHighEnergyModel->SetTransport(antiBCascade);
326 antiBHighEnergyModel->SetHighEnergyGenerator(antiBStringModel);
327 antiBHighEnergyModel->SetMinEnergy(0.0);
328 antiBHighEnergyModel->SetMaxEnergy(20*TeV);
329
330 // Light ion models
331 G4BinaryLightIonReaction* binaryCascade = new G4BinaryLightIonReaction;
332 binaryCascade->SetMinEnergy(0.0);
333 binaryCascade->SetMaxEnergy(110*MeV);
334
335 G4QMDReaction* qmd = new G4QMDReaction;
336 qmd->SetMinEnergy(100*MeV);
337 qmd->SetMaxEnergy(10*GeV);
338
339 G4VCrossSectionDataSet* ionXS = new G4CrossSectionInelastic( new G4ComponentGGNuclNuclXsc );
340
341 G4ComponentGGHadronNucleusXsc * ggHNXsec = new G4ComponentGGHadronNucleusXsc();
342 G4VCrossSectionDataSet * theGGHNEl = new G4CrossSectionElastic(ggHNXsec);
343 G4VCrossSectionDataSet * theGGHNInel = new G4CrossSectionInelastic(ggHNXsec);
344
345 // Elastic process
346 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
347 theElasticProcess->AddDataSet(theGGHNEl);
348 G4HadronElastic* theElasticModel = new G4HadronElastic;
349 theElasticProcess->RegisterMe(theElasticModel);
350
351 auto particleIterator=GetParticleIterator();
352 particleIterator->reset();
353 while ((*particleIterator)()) {
354 G4ParticleDefinition* particle = particleIterator->value();
355 G4ProcessManager* pmanager = particle->GetProcessManager();
356 G4String particleName = particle->GetParticleName();
357
358 if (particleName == "pi+") {
359 pmanager->AddDiscreteProcess(theElasticProcess);
360 G4HadronInelasticProcess* theInelasticProcess =
361 new G4HadronInelasticProcess( "inelastic", G4PionPlus::Definition() );
362 theInelasticProcess->AddDataSet(theGGHNInel);
363 theInelasticProcess->RegisterMe(bertini);
364 theInelasticProcess->RegisterMe(theTheoModel);
365 pmanager->AddDiscreteProcess(theInelasticProcess);
366 } else if (particleName == "pi-") {
367 pmanager->AddDiscreteProcess(theElasticProcess);
368 G4HadronInelasticProcess* theInelasticProcess =
369 new G4HadronInelasticProcess( "inelastic", G4PionMinus::Definition() );
370 theInelasticProcess->AddDataSet(theGGHNInel);
371 theInelasticProcess->RegisterMe(bertini);
372 theInelasticProcess->RegisterMe(theTheoModel);
373 pmanager->AddDiscreteProcess(theInelasticProcess);
374 } else if (particleName == "kaon+") {
375 pmanager->AddDiscreteProcess(theElasticProcess);
376 G4HadronInelasticProcess* theInelasticProcess =
377 new G4HadronInelasticProcess( "inelastic", G4KaonPlus::Definition() );
378 theInelasticProcess->AddDataSet(theGGHNInel);
379 theInelasticProcess->RegisterMe(bertini);
380 theInelasticProcess->RegisterMe(theTheoModel);
381 pmanager->AddDiscreteProcess(theInelasticProcess);
382 }
383 else if (particleName == "kaon0S") {
384 pmanager->AddDiscreteProcess(theElasticProcess);
385 G4HadronInelasticProcess* theInelasticProcess =
386 new G4HadronInelasticProcess( "inelastic", G4KaonZeroShort::Definition() );
387 theInelasticProcess->AddDataSet(theGGHNInel);
388 theInelasticProcess->RegisterMe(bertini);
389 theInelasticProcess->RegisterMe(theTheoModel);
390 pmanager->AddDiscreteProcess(theInelasticProcess);
391 }
392 else if (particleName == "kaon0L") {
393 pmanager->AddDiscreteProcess(theElasticProcess);
394 G4HadronInelasticProcess* theInelasticProcess =
395 new G4HadronInelasticProcess( "inelastic", G4KaonZeroLong::Definition() );
396 theInelasticProcess->AddDataSet(theGGHNInel);
397 theInelasticProcess->RegisterMe(bertini);
398 theInelasticProcess->RegisterMe(theTheoModel);
399 pmanager->AddDiscreteProcess(theInelasticProcess);
400 }
401 else if (particleName == "kaon-") {
402 pmanager->AddDiscreteProcess(theElasticProcess);
403 G4HadronInelasticProcess* theInelasticProcess =
404 new G4HadronInelasticProcess( "inelastic", G4KaonMinus::Definition() );
405 theInelasticProcess->AddDataSet(theGGHNInel);
406 theInelasticProcess->RegisterMe(bertini);
407 theInelasticProcess->RegisterMe(theTheoModel);
408 pmanager->AddDiscreteProcess(theInelasticProcess);
409 }
410 else if (particleName == "proton") {
411 pmanager->AddDiscreteProcess(theElasticProcess);
412 G4HadronInelasticProcess* theInelasticProcess =
413 new G4HadronInelasticProcess( "inelastic", G4Proton::Definition() );
414 theInelasticProcess->AddDataSet(theGGHNInel);
415 theInelasticProcess->RegisterMe(bertini);
416 theInelasticProcess->RegisterMe(theTheoModel);
417 pmanager->AddDiscreteProcess(theInelasticProcess);
418 }
419 else if (particleName == "anti_proton") {
420 pmanager->AddDiscreteProcess(theElasticProcess);
421 G4HadronInelasticProcess* theInelasticProcess =
422 new G4HadronInelasticProcess( "inelastic", G4AntiProton::Definition() );
423 theInelasticProcess->AddDataSet(theGGHNInel);
424 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
425 pmanager->AddDiscreteProcess(theInelasticProcess);
426
427 } else if (particleName == "neutron") {
428 // elastic scattering
429 pmanager->AddDiscreteProcess(theElasticProcess);
430
431 // inelastic scattering
432 G4HadronInelasticProcess* theInelasticProcess =
433 new G4HadronInelasticProcess( "inelastic", G4Neutron::Definition() );
434 theInelasticProcess->AddDataSet(new G4NeutronInelasticXS());
435 theInelasticProcess->RegisterMe(bertini);
436 theInelasticProcess->RegisterMe(theTheoModel);
437 pmanager->AddDiscreteProcess(theInelasticProcess);
438
439 // fission
440 G4NeutronFissionProcess* theFissionProcess = new G4NeutronFissionProcess;
441 G4LFission* theFissionModel = new G4LFission;
442 theFissionProcess->RegisterMe(theFissionModel);
443 pmanager->AddDiscreteProcess(theFissionProcess);
444
445 // capture
446 G4NeutronCaptureProcess* theCaptureProcess = new G4NeutronCaptureProcess;
447 G4NeutronRadCapture* theCaptureModel = new G4NeutronRadCapture;
448 theCaptureProcess->RegisterMe(theCaptureModel);
449 pmanager->AddDiscreteProcess(theCaptureProcess);
450
451 } else if (particleName == "anti_neutron") {
452 pmanager->AddDiscreteProcess(theElasticProcess);
453 G4HadronInelasticProcess* theInelasticProcess =
454 new G4HadronInelasticProcess( "inelastic", G4AntiNeutron::Definition() );
455 theInelasticProcess->AddDataSet(theGGHNInel);
456 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
457 pmanager->AddDiscreteProcess(theInelasticProcess);
458
459 } else if (particleName == "lambda") {
460 pmanager->AddDiscreteProcess(theElasticProcess);
461 G4HadronInelasticProcess* theInelasticProcess =
462 new G4HadronInelasticProcess( "inelastic", G4Lambda::Definition() );
463 theInelasticProcess->AddDataSet(theGGHNInel);
464 theInelasticProcess->RegisterMe(bertini);
465 theInelasticProcess->RegisterMe(theTheoModel);
466 pmanager->AddDiscreteProcess(theInelasticProcess);
467 }
468 else if (particleName == "anti_lambda") {
469 pmanager->AddDiscreteProcess(theElasticProcess);
470 G4HadronInelasticProcess* theInelasticProcess =
471 new G4HadronInelasticProcess( "inelastic", G4AntiLambda::Definition() );
472 theInelasticProcess->AddDataSet(theGGHNInel);
473 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
474 pmanager->AddDiscreteProcess(theInelasticProcess);
475 }
476 else if (particleName == "sigma+") {
477 pmanager->AddDiscreteProcess(theElasticProcess);
478 G4HadronInelasticProcess* theInelasticProcess =
479 new G4HadronInelasticProcess( "inelastic", G4SigmaPlus::Definition() );
480 theInelasticProcess->AddDataSet(theGGHNInel);
481 theInelasticProcess->RegisterMe(bertini);
482 theInelasticProcess->RegisterMe(theTheoModel);
483 pmanager->AddDiscreteProcess(theInelasticProcess);
484 }
485 else if (particleName == "sigma-") {
486 pmanager->AddDiscreteProcess(theElasticProcess);
487 G4HadronInelasticProcess* theInelasticProcess =
488 new G4HadronInelasticProcess( "inelastic", G4SigmaMinus::Definition() );
489 theInelasticProcess->AddDataSet(theGGHNInel);
490 theInelasticProcess->RegisterMe(bertini);
491 theInelasticProcess->RegisterMe(theTheoModel);
492 pmanager->AddDiscreteProcess(theInelasticProcess);
493 }
494 else if (particleName == "anti_sigma+") {
495 pmanager->AddDiscreteProcess(theElasticProcess);
496 G4HadronInelasticProcess* theInelasticProcess =
497 new G4HadronInelasticProcess( "inelastic", G4AntiSigmaPlus::Definition() );
498 theInelasticProcess->AddDataSet(theGGHNInel);
499 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
500 pmanager->AddDiscreteProcess(theInelasticProcess);
501 }
502 else if (particleName == "anti_sigma-") {
503 pmanager->AddDiscreteProcess(theElasticProcess);
504 G4HadronInelasticProcess* theInelasticProcess =
505 new G4HadronInelasticProcess( "inelastic", G4AntiSigmaMinus::Definition() );
506 theInelasticProcess->AddDataSet(theGGHNInel);
507 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
508 pmanager->AddDiscreteProcess(theInelasticProcess);
509 }
510 else if (particleName == "xi0") {
511 pmanager->AddDiscreteProcess(theElasticProcess);
512 G4HadronInelasticProcess* theInelasticProcess =
513 new G4HadronInelasticProcess( "inelastic", G4XiZero::Definition() );
514 theInelasticProcess->AddDataSet(theGGHNInel);
515 theInelasticProcess->RegisterMe(bertini);
516 theInelasticProcess->RegisterMe(theTheoModel);
517 pmanager->AddDiscreteProcess(theInelasticProcess);
518 }
519 else if (particleName == "xi-") {
520 pmanager->AddDiscreteProcess(theElasticProcess);
521 G4HadronInelasticProcess* theInelasticProcess =
522 new G4HadronInelasticProcess( "inelastic", G4XiMinus::Definition() );
523 theInelasticProcess->AddDataSet(theGGHNInel);
524 theInelasticProcess->RegisterMe(bertini);
525 theInelasticProcess->RegisterMe(theTheoModel);
526 pmanager->AddDiscreteProcess(theInelasticProcess);
527 }
528 else if (particleName == "anti_xi0") {
529 pmanager->AddDiscreteProcess(theElasticProcess);
530 G4HadronInelasticProcess* theInelasticProcess =
531 new G4HadronInelasticProcess( "inelastic", G4AntiXiZero::Definition() );
532 theInelasticProcess->AddDataSet(theGGHNInel);
533 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
534 pmanager->AddDiscreteProcess(theInelasticProcess);
535 }
536 else if (particleName == "anti_xi-") {
537 pmanager->AddDiscreteProcess(theElasticProcess);
538 G4HadronInelasticProcess* theInelasticProcess =
539 new G4HadronInelasticProcess( "inelastic", G4AntiXiMinus::Definition() );
540 theInelasticProcess->AddDataSet(theGGHNInel);
541 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
542 pmanager->AddDiscreteProcess(theInelasticProcess);
543 }
544 else if (particleName == "deuteron") {
545 pmanager->AddDiscreteProcess(theElasticProcess);
546 G4HadronInelasticProcess* theInelasticProcess =
547 new G4HadronInelasticProcess( "inelastic", G4Deuteron::Definition() );
548 theInelasticProcess->RegisterMe(binaryCascade);
549 theInelasticProcess->RegisterMe(qmd);
550 theInelasticProcess->AddDataSet(ionXS);
551 pmanager->AddDiscreteProcess(theInelasticProcess);
552 }
553 else if (particleName == "triton") {
554 pmanager->AddDiscreteProcess(theElasticProcess);
555 G4HadronInelasticProcess* theInelasticProcess =
556 new G4HadronInelasticProcess( "inelastic", G4Triton::Definition() );
557 theInelasticProcess->RegisterMe(binaryCascade);
558 theInelasticProcess->RegisterMe(qmd);
559 theInelasticProcess->AddDataSet(ionXS);
560 pmanager->AddDiscreteProcess(theInelasticProcess);
561 }
562 else if (particleName == "alpha") {
563 pmanager->AddDiscreteProcess(theElasticProcess);
564 G4HadronInelasticProcess* theInelasticProcess =
565 new G4HadronInelasticProcess( "inelastic", G4Alpha::Definition() );
566 theInelasticProcess->RegisterMe(binaryCascade);
567 theInelasticProcess->RegisterMe(qmd);
568 theInelasticProcess->AddDataSet(ionXS);
569 pmanager->AddDiscreteProcess(theInelasticProcess);
570
571 } else if (particleName == "omega-") {
572 pmanager->AddDiscreteProcess(theElasticProcess);
573 G4HadronInelasticProcess* theInelasticProcess =
574 new G4HadronInelasticProcess( "inelastic", G4OmegaMinus::Definition() );
575 theInelasticProcess->AddDataSet(theGGHNInel);
576 theInelasticProcess->RegisterMe(bertini);
577 theInelasticProcess->RegisterMe(theTheoModel);
578 pmanager->AddDiscreteProcess(theInelasticProcess);
579
580 } else if (particleName == "anti_omega-") {
581 pmanager->AddDiscreteProcess(theElasticProcess);
582 G4HadronInelasticProcess* theInelasticProcess =
583 new G4HadronInelasticProcess( "inelastic", G4AntiOmegaMinus::Definition() );
584 theInelasticProcess->AddDataSet(theGGHNInel);
585 theInelasticProcess->RegisterMe(antiBHighEnergyModel);
586 pmanager->AddDiscreteProcess(theInelasticProcess);
587 }
588 }
589}

◆ ConstructLeptHad()

void B03PhysicsList::ConstructLeptHad ( )
protectedvirtual

Definition at line 593 of file B03PhysicsList.cc.

594{;}

◆ AddScoringProcess()

void B03PhysicsList::AddScoringProcess ( )
protected

Definition at line 632 of file B03PhysicsList.cc.

632 {
633
634 G4int npw = fParaWorldName.size();
635 for ( G4int i = 0; i < npw; i++){
636 G4String procName = "ParaWorldProc_"+fParaWorldName[i];
637 G4ParallelWorldProcess* theParallelWorldProcess
638 = new G4ParallelWorldProcess(procName);
639 theParallelWorldProcess->SetParallelWorld(fParaWorldName[i]);
640
641 auto particleIterator=GetParticleIterator();
642 particleIterator->reset();
643 while( (*particleIterator)() ){
644 G4ParticleDefinition* particle = particleIterator->value();
645 G4ProcessManager* pmanager = particle->GetProcessManager();
646 pmanager->AddProcess(theParallelWorldProcess);
647 if(theParallelWorldProcess->IsAtRestRequired(particle))
648 {pmanager->SetProcessOrdering(theParallelWorldProcess, idxAtRest, 9900);}
649 pmanager->SetProcessOrderingToSecond(theParallelWorldProcess, idxAlongStep);
650 pmanager->SetProcessOrdering(theParallelWorldProcess, idxPostStep, 9900);
651 }
652 }
653
654}

◆ AddBiasingProcess()

void B03PhysicsList::AddBiasingProcess ( )
protected

Definition at line 660 of file B03PhysicsList.cc.

660 {
661
662 G4cout << " Preparing Importance Sampling with GhostWorld "
663 << fBiasWorldName << G4endl;
664
665 G4IStore* iStore = G4IStore::GetInstance(fBiasWorldName);
666 G4GeometrySampler fGeomSampler(fBiasWorldName,"neutron");
667 fGeomSampler.SetParallel(true); // parallelworld
668 // fGeomSampler.SetWorld(iStore->GetParallelWorldVolumePointer());
669 // fGeomSampler->PrepareImportanceSampling(G4IStore::
670 // GetInstance(fBiasWorldName), 0);
671 static G4bool first = true;
672 if(first) {
673 fGeomSampler.PrepareImportanceSampling(iStore, 0);
674
675 fGeomSampler.Configure();
676 G4cout << " GeomSampler Configured!!! " << G4endl;
677 first = false;
678 }
679
680#ifdef G4MULTITHREADED
681 if(!G4Threading::IsMasterThread()) fGeomSampler.AddProcess();
682#else
683 G4cout << " Running in singlethreaded mode!!! " << G4endl;
684#endif
685
686}

◆ ConstructAllBosons()

void B03PhysicsList::ConstructAllBosons ( )
protected

Definition at line 90 of file B03PhysicsList.cc.

91{
92 // Construct all bosons
93 G4BosonConstructor pConstructor;
94 pConstructor.ConstructParticle();
95}

◆ ConstructAllLeptons()

void B03PhysicsList::ConstructAllLeptons ( )
protected

Definition at line 99 of file B03PhysicsList.cc.

100{
101 // Construct all leptons
102 G4LeptonConstructor pConstructor;
103 pConstructor.ConstructParticle();
104}

◆ ConstructAllMesons()

void B03PhysicsList::ConstructAllMesons ( )
protected

Definition at line 108 of file B03PhysicsList.cc.

109{
110 // Construct all mesons
111 G4MesonConstructor pConstructor;
112 pConstructor.ConstructParticle();
113}

◆ ConstructAllBaryons()

void B03PhysicsList::ConstructAllBaryons ( )
protected

Definition at line 117 of file B03PhysicsList.cc.

118{
119 // Construct all barions
120 G4BaryonConstructor pConstructor;
121 pConstructor.ConstructParticle();
122}

◆ ConstructAllIons()

void B03PhysicsList::ConstructAllIons ( )
protected

Definition at line 126 of file B03PhysicsList.cc.

127{
128 // Construct light ions
129 G4IonConstructor pConstructor;
130 pConstructor.ConstructParticle();
131}

◆ ConstructAllShortLiveds()

void B03PhysicsList::ConstructAllShortLiveds ( )
protected

Definition at line 135 of file B03PhysicsList.cc.

136{
137 // Construct resonaces and quarks
138 G4ShortLivedConstructor pConstructor;
139 pConstructor.ConstructParticle();
140}

Member Data Documentation

◆ fParaWorldName

std::vector<G4String> B03PhysicsList::fParaWorldName
private

Definition at line 81 of file B03PhysicsList.hh.

◆ fBiasWorldName

G4String B03PhysicsList::fBiasWorldName
private

Definition at line 82 of file B03PhysicsList.hh.

The documentation for this class was generated from the following files:
Generated on Tue Jan 30 2024 12:18:46 for Geant4 examples by   doxygen 1.9.8
Applications | User Support | Publications | Collaboration