#include <DMXPhysicsList.hh>

Inheritance diagram for DMXPhysicsList:

Collaboration diagram for DMXPhysicsList:

Public Member Functions
	DMXPhysicsList ()

	~DMXPhysicsList ()

virtual void	SetCuts ()

Public Member Functions inherited from G4VUserPhysicsList
	G4VUserPhysicsList ()

virtual	~G4VUserPhysicsList ()

	G4VUserPhysicsList (const G4VUserPhysicsList &)

G4VUserPhysicsList &	operator= (const G4VUserPhysicsList &)

void	Construct ()

void	UseCoupledTransportation (G4bool vl=true)

void	SetDefaultCutValue (G4double newCutValue)

G4double	GetDefaultCutValue () const

void	BuildPhysicsTable ()

void	PreparePhysicsTable (G4ParticleDefinition *)

void	BuildPhysicsTable (G4ParticleDefinition *)

G4bool	StorePhysicsTable (const G4String &directory=".")

G4bool	IsPhysicsTableRetrieved () const

G4bool	IsStoredInAscii () const

const G4String &	GetPhysicsTableDirectory () const

void	SetPhysicsTableRetrieved (const G4String &directory="")

void	SetStoredInAscii ()

void	ResetPhysicsTableRetrieved ()

void	ResetStoredInAscii ()

void	DumpList () const

void	DumpCutValuesTable (G4int flag=1)

void	DumpCutValuesTableIfRequested ()

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

void	SetCutsWithDefault ()

void	SetCutValue (G4double aCut, const G4String &pname)

G4double	GetCutValue (const G4String &pname) const

void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)

void	SetParticleCuts (G4double cut, G4ParticleDefinition particle, G4Region region=0)

void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=0)

void	SetCutsForRegion (G4double aCut, const G4String &rname)

void	ResetCuts ()
	obsolete methods More...

void	SetApplyCuts (G4bool value, const G4String &name)

G4bool	GetApplyCuts (const G4String &name) const

void	RemoveProcessManager ()

void	AddProcessManager (G4ParticleDefinition newParticle, G4ProcessManager newManager=0)

void	CheckParticleList ()

void	DisableCheckParticleList ()

G4int	GetInstanceID () const

void	InitializeWorker ()

Protected Member Functions
virtual void	ConstructParticle ()

virtual void	ConstructProcess ()

virtual void	ConstructGeneral ()

virtual void	ConstructEM ()

virtual void	ConstructHad ()

virtual void	ConstructOp ()

virtual void	AddTransportation ()

Protected Member Functions inherited from G4VUserPhysicsList
void	AddTransportation ()

G4bool	RegisterProcess (G4VProcess process, G4ParticleDefinition particle)

void	BuildIntegralPhysicsTable (G4VProcess , G4ParticleDefinition )

virtual void	RetrievePhysicsTable (G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)

void	InitializeProcessManager ()

G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

Private Member Functions
void	ConstructMyBosons ()

void	ConstructMyLeptons ()

void	ConstructMyHadrons ()

void	ConstructMyShortLiveds ()

Private Attributes
G4int	VerboseLevel

G4int	OpVerbLevel

G4double	cutForGamma

G4double	cutForElectron

G4double	cutForPositron

Additional Inherited Members
Static Public Member Functions inherited from G4VUserPhysicsList
static const G4VUPLManager &	GetSubInstanceManager ()

Protected Attributes inherited from G4VUserPhysicsList
G4ParticleTable *	theParticleTable

G4int	verboseLevel

G4double	defaultCutValue

G4bool	isSetDefaultCutValue

G4ProductionCutsTable *	fCutsTable

G4bool	fRetrievePhysicsTable

G4bool	fStoredInAscii

G4bool	fIsCheckedForRetrievePhysicsTable

G4bool	fIsRestoredCutValues

G4String	directoryPhysicsTable

G4bool	fDisableCheckParticleList

G4int	g4vuplInstanceID

Static Protected Attributes inherited from G4VUserPhysicsList
static G4RUN_DLL G4VUPLManager	subInstanceManager

Detailed Description

Definition at line 56 of file DMXPhysicsList.hh.

Constructor & Destructor Documentation

◆ DMXPhysicsList()

DMXPhysicsList::DMXPhysicsList ( )

Definition at line 72 of file DMXPhysicsList.cc.

                                : G4VUserPhysicsList() 
 {
 
   defaultCutValue     = 1.0*micrometer; //
   cutForGamma         = defaultCutValue;
   cutForElectron      = 1.0*nanometer;
   cutForPositron      = defaultCutValue;
 
   VerboseLevel = 1;
   OpVerbLevel = 0;
 
   SetVerboseLevel(VerboseLevel);
 }

Here is the call graph for this function:

◆ ~DMXPhysicsList()

DMXPhysicsList::~DMXPhysicsList ( )

Definition at line 88 of file DMXPhysicsList.cc.

89 {;}

Member Function Documentation

◆ AddTransportation()

void DMXPhysicsList::AddTransportation ( )

protectedvirtual

Definition at line 196 of file DMXPhysicsList.cc.

                                        {
   
   G4VUserPhysicsList::AddTransportation();
   
   auto particleIterator=GetParticleIterator();
   particleIterator->reset();
   while( (*particleIterator)() ){
     G4ParticleDefinition* particle = particleIterator->value();
     G4ProcessManager* pmanager = particle->GetProcessManager();
     G4String particleName = particle->GetParticleName();
     // time cuts for ONLY neutrons:
     if(particleName == "neutron") 
       pmanager->AddDiscreteProcess(new DMXMaxTimeCuts());
     // Energy cuts to kill charged (embedded in method) particles:
     pmanager->AddDiscreteProcess(new DMXMinEkineCuts());
 
     // Step limit applied to all particles:
     pmanager->AddProcess(new G4StepLimiter,       -1,-1,1);
 
   }           
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructEM()

void DMXPhysicsList::ConstructEM ( )

protectedvirtual

Definition at line 270 of file DMXPhysicsList.cc.

                                  {
   
   //set a finer grid of the physic tables in order to improve precision
   //former LowEnergy models have 200 bins up to 100 GeV
   G4EmProcessOptions opt;
   opt.SetMaxEnergy(100*GeV);
   opt.SetDEDXBinning(200);
   opt.SetLambdaBinning(200);
 
   auto particleIterator=GetParticleIterator();
   particleIterator->reset();
   while( (*particleIterator)() ){
     G4ParticleDefinition* particle = particleIterator->value();
     G4ProcessManager* pmanager = particle->GetProcessManager();
     G4String particleName = particle->GetParticleName();
     G4String particleType = particle->GetParticleType();
     G4double charge = particle->GetPDGCharge();
     
     if (particleName == "gamma") 
       {
     //gamma
     G4RayleighScattering* theRayleigh = new G4RayleighScattering();
     theRayleigh->SetEmModel(new G4LivermoreRayleighModel());  //not strictly necessary
     pmanager->AddDiscreteProcess(theRayleigh);
 
     G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
     thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
     pmanager->AddDiscreteProcess(thePhotoElectricEffect);
     
     G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
     theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
     pmanager->AddDiscreteProcess(theComptonScattering);
     
     G4GammaConversion* theGammaConversion = new G4GammaConversion();
     theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
     pmanager->AddDiscreteProcess(theGammaConversion);
 
       } 
     else if (particleName == "e-") 
       {
     //electron
     // process ordering: AddProcess(name, at rest, along step, post step)
     // Multiple scattering
     G4eMultipleScattering* msc = new G4eMultipleScattering();
     msc->SetStepLimitType(fUseDistanceToBoundary);
     pmanager->AddProcess(msc,-1, 1, 1);
 
     // Ionisation
     G4eIonisation* eIonisation = new G4eIonisation();
     eIonisation->SetEmModel(new G4LivermoreIonisationModel());
     eIonisation->SetStepFunction(0.2, 100*um); //improved precision in tracking  
     pmanager->AddProcess(eIonisation,-1, 2, 2);
     
     // Bremsstrahlung
     G4eBremsstrahlung* eBremsstrahlung = new G4eBremsstrahlung();
     eBremsstrahlung->SetEmModel(new G4LivermoreBremsstrahlungModel());
     pmanager->AddProcess(eBremsstrahlung, -1,-3, 3);
       } 
     else if (particleName == "e+") 
       {
     //positron  
     G4eMultipleScattering* msc = new G4eMultipleScattering();
     msc->SetStepLimitType(fUseDistanceToBoundary);
     pmanager->AddProcess(msc,-1, 1, 1);
     
     // Ionisation
     G4eIonisation* eIonisation = new G4eIonisation();
     eIonisation->SetStepFunction(0.2, 100*um); //     
     pmanager->AddProcess(eIonisation,                 -1, 2, 2);
 
     //Bremsstrahlung (use default, no low-energy available)
     pmanager->AddProcess(new G4eBremsstrahlung(), -1,-1, 3);
 
     //Annihilation
     pmanager->AddProcess(new G4eplusAnnihilation(),0,-1, 4);      
       } 
     else if( particleName == "mu+" || 
          particleName == "mu-"    ) 
       {
     //muon  
     pmanager->AddProcess(new G4eMultipleScattering,           -1, 1, 1);
     pmanager->AddProcess(new G4MuIonisation(),          -1, 2, 2);
     pmanager->AddProcess(new G4MuBremsstrahlung(),      -1,-1, 3);
     pmanager->AddProcess(new G4MuPairProduction(),      -1,-1, 4);
     if( particleName == "mu-" )
       pmanager->AddProcess(new G4MuonMinusCapture(), 0,-1,-1);
       } 
     else if (particleName == "proton" || 
          particleName == "pi+" || 
          particleName == "pi-")
       {
     //multiple scattering
     pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
       
     //ionisation
     G4hIonisation* hIonisation = new G4hIonisation();
     hIonisation->SetStepFunction(0.2, 50*um);
     pmanager->AddProcess(hIonisation,                     -1, 2, 2);      
     
     //bremmstrahlung
     pmanager->AddProcess(new G4hBremsstrahlung,     -1,-3, 3);
       }
     else if(particleName == "alpha"      ||
          particleName == "deuteron"   ||
          particleName == "triton"     ||
          particleName == "He3")
       {
     //multiple scattering
     pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
     
     //ionisation
     G4ionIonisation* ionIoni = new G4ionIonisation();
     ionIoni->SetStepFunction(0.1, 20*um);
     pmanager->AddProcess(ionIoni,                   -1, 2, 2);
       }
     else if (particleName == "GenericIon")
       {
     // OBJECT may be dynamically created as either a GenericIon or nucleus
     // G4Nucleus exists and therefore has particle type nucleus
     // genericIon:
     
     //multiple scattering
     pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
 
     //ionisation
     G4ionIonisation* ionIoni = new G4ionIonisation();
     ionIoni->SetEmModel(new G4IonParametrisedLossModel());
     ionIoni->SetStepFunction(0.1, 20*um);
     pmanager->AddProcess(ionIoni,                   -1, 2, 2);
       } 
 
     else if ((!particle->IsShortLived()) &&
          (charge != 0.0) && 
          (particle->GetParticleName() != "chargedgeantino")) 
       {
     //all others charged particles except geantino
         G4hMultipleScattering* aMultipleScattering = new G4hMultipleScattering();
         G4hIonisation* ahadronIon = new G4hIonisation();
     
     //multiple scattering
     pmanager->AddProcess(aMultipleScattering,-1,1,1);
 
     //ionisation
     pmanager->AddProcess(ahadronIon,       -1,2,2);      
       }
     
   }
 
   // turn off msc step-limitation - especially as electron cut 1nm
   opt.SetMscStepLimitation(fMinimal);
 
   // switch on fluorescence, PIXE and Auger:
   opt.SetFluo(true);
   opt.SetPIXE(true);
   opt.SetAuger(true);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructGeneral()

void DMXPhysicsList::ConstructGeneral ( )

protectedvirtual

Definition at line 877 of file DMXPhysicsList.cc.

                                       {
 
   // Add Decay Process
   G4Decay* theDecayProcess = new G4Decay();
   auto particleIterator=GetParticleIterator();
   particleIterator->reset();
   while( (*particleIterator)() )
     {
       G4ParticleDefinition* particle = particleIterator->value();
       G4ProcessManager* pmanager = particle->GetProcessManager();
       
       if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived()) 
     { 
       pmanager ->AddProcess(theDecayProcess);
       // set ordering for PostStepDoIt and AtRestDoIt
       pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
       pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
     }
     }
 
   // Declare radioactive decay to the GenericIon in the IonTable.
   const G4IonTable *theIonTable = 
     G4ParticleTable::GetParticleTable()->GetIonTable();
   G4RadioactiveDecay *theRadioactiveDecay = new G4RadioactiveDecay();
 
   for (G4int i=0; i<theIonTable->Entries(); i++) 
     {
       G4String particleName = theIonTable->GetParticle(i)->GetParticleName();
       G4String particleType = theIonTable->GetParticle(i)->GetParticleType();
       
       if (particleName == "GenericIon") 
     {
       G4ProcessManager* pmanager = 
         theIonTable->GetParticle(i)->GetProcessManager();
       pmanager->SetVerboseLevel(VerboseLevel);
       pmanager ->AddProcess(theRadioactiveDecay);
       pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep);
       pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest);
     } 
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructHad()

void DMXPhysicsList::ConstructHad ( )

protectedvirtual

Definition at line 570 of file DMXPhysicsList.cc.

 {
   //Elastic models
   const G4double elastic_elimitPi = 1.0*GeV;
 
   G4HadronElastic* elastic_lhep0 = new G4HadronElastic();
   G4HadronElastic* elastic_lhep1 = new G4HadronElastic();
   elastic_lhep1->SetMaxEnergy( elastic_elimitPi );
   G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();
   G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE(); 
   elastic_he->SetMinEnergy( elastic_elimitPi );
 
   
   // Inelastic scattering
   const G4double theFTFMin0 =    0.0*GeV;
   const G4double theFTFMin1 =    4.0*GeV;
   const G4double theFTFMax =   100.0*TeV;
   const G4double theBERTMin0 =   0.0*GeV;
   const G4double theBERTMin1 =  19.0*MeV;
   const G4double theBERTMax =    5.0*GeV;
   const G4double theHPMin =      0.0*GeV;
   const G4double theHPMax =     20.0*MeV;
 
   G4FTFModel * theStringModel = new G4FTFModel;
   G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
   theStringModel->SetFragmentationModel( theStringDecay );
   G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
   G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
 
   G4TheoFSGenerator * theFTFModel0 = new G4TheoFSGenerator( "FTFP" );
   theFTFModel0->SetHighEnergyGenerator( theStringModel );
   theFTFModel0->SetTransport( theCascade );
   theFTFModel0->SetMinEnergy( theFTFMin0 );
   theFTFModel0->SetMaxEnergy( theFTFMax );
 
   G4TheoFSGenerator * theFTFModel1 = new G4TheoFSGenerator( "FTFP" );
   theFTFModel1->SetHighEnergyGenerator( theStringModel );
   theFTFModel1->SetTransport( theCascade );
   theFTFModel1->SetMinEnergy( theFTFMin1 );
   theFTFModel1->SetMaxEnergy( theFTFMax );
 
   G4CascadeInterface * theBERTModel0 = new G4CascadeInterface;
   theBERTModel0->SetMinEnergy( theBERTMin0 );
   theBERTModel0->SetMaxEnergy( theBERTMax );
 
   G4CascadeInterface * theBERTModel1 = new G4CascadeInterface;
   theBERTModel1->SetMinEnergy( theBERTMin1 );
   theBERTModel1->SetMaxEnergy( theBERTMax );
 
   G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG( new G4PiNuclearCrossSection, 91*GeV );
   G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
   G4ComponentGGNuclNuclXsc * ggNuclNuclXsec = new G4ComponentGGNuclNuclXsc();
   G4VCrossSectionDataSet * theGGNuclNuclData = new G4CrossSectionInelastic(ggNuclNuclXsec);
 
   auto particleIterator=GetParticleIterator();
   particleIterator->reset();
   while ((*particleIterator)()) 
     {
       G4ParticleDefinition* particle = particleIterator->value();
       G4ProcessManager* pmanager = particle->GetProcessManager();
       G4String particleName = particle->GetParticleName();
 
       if (particleName == "pi+") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
           theElasticProcess->RegisterMe( elastic_lhep1 );
           theElasticProcess->RegisterMe( elastic_he );
       pmanager->AddDiscreteProcess( theElasticProcess );
       //Inelastic scattering
       G4PionPlusInelasticProcess* theInelasticProcess = 
         new G4PionPlusInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( thePiData );
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
     } 
 
       else if (particleName == "pi-") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
           theElasticProcess->RegisterMe( elastic_lhep1 );
           theElasticProcess->RegisterMe( elastic_he );
       pmanager->AddDiscreteProcess( theElasticProcess );
       //Inelastic scattering
       G4PionMinusInelasticProcess* theInelasticProcess = 
         new G4PionMinusInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( thePiData );
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );    
       //Absorption
       pmanager->AddRestProcess(new G4PiMinusAbsorptionBertini, ordDefault);
     }
       
       else if (particleName == "kaon+") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering   
       G4KaonPlusInelasticProcess* theInelasticProcess = 
         new G4KaonPlusInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                        GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
     }
       
       else if (particleName == "kaon0S") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering    
       G4KaonZeroSInelasticProcess* theInelasticProcess = 
         new G4KaonZeroSInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                        GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );    
     }
 
       else if (particleName == "kaon0L") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
       // Inelastic scattering
       G4KaonZeroLInelasticProcess* theInelasticProcess = 
         new G4KaonZeroLInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                        GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 ); 
       pmanager->AddDiscreteProcess( theInelasticProcess );    
     }
 
       else if (particleName == "kaon-") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
       G4KaonMinusInelasticProcess* theInelasticProcess = 
         new G4KaonMinusInelasticProcess("inelastic");   
           theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                        GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
       pmanager->AddRestProcess(new G4KaonMinusAbsorptionBertini, ordDefault);
     }
 
       else if (particleName == "proton") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->
                     GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));
           theElasticProcess->RegisterMe( elastic_chip );
       pmanager->AddDiscreteProcess( theElasticProcess );
       // Inelastic scattering
       G4ProtonInelasticProcess* theInelasticProcess = 
         new G4ProtonInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
     }
       else if (particleName == "anti_proton") 
     {
       // Elastic scattering
           const G4double elastic_elimitAntiNuc = 100.0*MeV;
           G4AntiNuclElastic* elastic_anuc = new G4AntiNuclElastic();
           elastic_anuc->SetMinEnergy( elastic_elimitAntiNuc );
           G4CrossSectionElastic* elastic_anucxs = new G4CrossSectionElastic( elastic_anuc->GetComponentCrossSection() );
           G4HadronElastic* elastic_lhep2 = new G4HadronElastic();
           elastic_lhep2->SetMaxEnergy( elastic_elimitAntiNuc );
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->AddDataSet( elastic_anucxs );
           theElasticProcess->RegisterMe( elastic_lhep2 );
           theElasticProcess->RegisterMe( elastic_anuc );
       pmanager->AddDiscreteProcess( theElasticProcess );
       // Inelastic scattering
       G4AntiProtonInelasticProcess* theInelasticProcess = 
         new G4AntiProtonInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( theAntiNucleonData );
       theInelasticProcess->RegisterMe( theFTFModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
       // Absorption
       pmanager->AddRestProcess(new G4AntiProtonAbsorptionFritiof, ordDefault);
     }
 
       else if (particleName == "neutron") {
     // elastic scattering
     G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
         theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsNeutronElasticXS::Default_Name()));
         G4HadronElastic* elastic_neutronChipsModel = new G4ChipsElasticModel();
     elastic_neutronChipsModel->SetMinEnergy( 19.0*MeV );
         theElasticProcess->RegisterMe( elastic_neutronChipsModel );
     G4ParticleHPElastic * theElasticNeutronHP = new G4ParticleHPElastic;
         theElasticNeutronHP->SetMinEnergy( theHPMin );
         theElasticNeutronHP->SetMaxEnergy( theHPMax );
     theElasticProcess->RegisterMe( theElasticNeutronHP );
     theElasticProcess->AddDataSet( new G4ParticleHPElasticData );
     pmanager->AddDiscreteProcess( theElasticProcess );
     // inelastic scattering     
     G4NeutronInelasticProcess* theInelasticProcess =
       new G4NeutronInelasticProcess("inelastic");
     theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ) );
     theInelasticProcess->RegisterMe( theFTFModel1 );
         theInelasticProcess->RegisterMe( theBERTModel1 );
     G4ParticleHPInelastic * theNeutronInelasticHPModel = new G4ParticleHPInelastic;
         theNeutronInelasticHPModel->SetMinEnergy( theHPMin );
         theNeutronInelasticHPModel->SetMaxEnergy( theHPMax );
     theInelasticProcess->RegisterMe( theNeutronInelasticHPModel );
     theInelasticProcess->AddDataSet( new G4ParticleHPInelasticData );
     pmanager->AddDiscreteProcess(theInelasticProcess);
     // capture
     G4HadronCaptureProcess* theCaptureProcess =
       new G4HadronCaptureProcess;
     G4ParticleHPCapture * theLENeutronCaptureModel = new G4ParticleHPCapture;
     theLENeutronCaptureModel->SetMinEnergy(theHPMin);
     theLENeutronCaptureModel->SetMaxEnergy(theHPMax);
     theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
     theCaptureProcess->AddDataSet( new G4ParticleHPCaptureData);
     pmanager->AddDiscreteProcess(theCaptureProcess);
 
       }
       else if (particleName == "anti_neutron") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering (include annihilation on-fly)
       G4AntiNeutronInelasticProcess* theInelasticProcess = 
         new G4AntiNeutronInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( theAntiNucleonData );
       theInelasticProcess->RegisterMe( theFTFModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );    
     }
 
       else if (particleName == "deuteron") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
       G4DeuteronInelasticProcess* theInelasticProcess = 
         new G4DeuteronInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( theGGNuclNuclData );
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
     }
       
       else if (particleName == "triton") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
       G4TritonInelasticProcess* theInelasticProcess = 
         new G4TritonInelasticProcess("inelastic");
       theInelasticProcess->AddDataSet( theGGNuclNuclData );
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
     }
       else if (particleName == "alpha") 
     {
       // Elastic scattering
           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
           theElasticProcess->RegisterMe( elastic_lhep0 );
       pmanager->AddDiscreteProcess( theElasticProcess );
           // Inelastic scattering
       G4AlphaInelasticProcess* theInelasticProcess = 
         new G4AlphaInelasticProcess("inelastic");    
           theInelasticProcess->AddDataSet( theGGNuclNuclData );
       theInelasticProcess->RegisterMe( theFTFModel1 );
           theInelasticProcess->RegisterMe( theBERTModel0 );
       pmanager->AddDiscreteProcess( theInelasticProcess );
     }
 
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructMyBosons()

void DMXPhysicsList::ConstructMyBosons ( )

private

Definition at line 110 of file DMXPhysicsList.cc.

 {
   // pseudo-particles
   G4Geantino::GeantinoDefinition();
   G4ChargedGeantino::ChargedGeantinoDefinition();
   
   // gamma
   G4Gamma::GammaDefinition();
 
   //OpticalPhotons
   G4OpticalPhoton::OpticalPhotonDefinition();
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructMyHadrons()

void DMXPhysicsList::ConstructMyHadrons ( )

private

Definition at line 146 of file DMXPhysicsList.cc.

 {
  //  mesons
   G4MesonConstructor mConstructor;
   mConstructor.ConstructParticle();
 
  //  baryons
   G4BaryonConstructor bConstructor;
   bConstructor.ConstructParticle();
 
  //  ions
   G4IonConstructor iConstructor;
   iConstructor.ConstructParticle();
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructMyLeptons()

void DMXPhysicsList::ConstructMyLeptons ( )

private

Definition at line 126 of file DMXPhysicsList.cc.

 {
   // leptons
   G4Electron::ElectronDefinition();
   G4Positron::PositronDefinition();
   G4MuonPlus::MuonPlusDefinition();
   G4MuonMinus::MuonMinusDefinition();
 
   G4NeutrinoE::NeutrinoEDefinition();
   G4AntiNeutrinoE::AntiNeutrinoEDefinition();
   G4NeutrinoMu::NeutrinoMuDefinition();
   G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructMyShortLiveds()

void DMXPhysicsList::ConstructMyShortLiveds ( )

private

Definition at line 165 of file DMXPhysicsList.cc.

 {
   G4ShortLivedConstructor slConstructor;
   slConstructor.ConstructParticle();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructOp()

void DMXPhysicsList::ConstructOp ( )

protectedvirtual

Definition at line 435 of file DMXPhysicsList.cc.

 {
   // default scintillation process
   G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");
   // theScintProcessDef->DumpPhysicsTable();
   theScintProcessDef->SetTrackSecondariesFirst(true);
   theScintProcessDef->SetScintillationYieldFactor(1.0); //
   theScintProcessDef->SetScintillationExcitationRatio(0.0); //
   theScintProcessDef->SetVerboseLevel(OpVerbLevel);
 
   // scintillation process for alpha:
   G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
   // theScintProcessNuc->DumpPhysicsTable();
   theScintProcessAlpha->SetTrackSecondariesFirst(true);
   theScintProcessAlpha->SetScintillationYieldFactor(1.1);
   theScintProcessAlpha->SetScintillationExcitationRatio(1.0);
   theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
 
   // scintillation process for heavy nuclei
   G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
   // theScintProcessNuc->DumpPhysicsTable();
   theScintProcessNuc->SetTrackSecondariesFirst(true);
   theScintProcessNuc->SetScintillationYieldFactor(0.2);
   theScintProcessNuc->SetScintillationExcitationRatio(1.0);
   theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
 
   // optical processes
   G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
   //  G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
   G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
   //  theAbsorptionProcess->DumpPhysicsTable();
   //  theRayleighScatteringProcess->DumpPhysicsTable();
   theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
   // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
   theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
 
   auto particleIterator=GetParticleIterator();
   particleIterator->reset();
   while( (*particleIterator)() )
     {
       G4ParticleDefinition* particle = particleIterator->value();
       G4ProcessManager* pmanager = particle->GetProcessManager();
       G4String particleName = particle->GetParticleName();
       if (theScintProcessDef->IsApplicable(*particle)) {
     //      if(particle->GetPDGMass() > 5.0*GeV) 
     if(particle->GetParticleName() == "GenericIon") {
       pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
       pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
       pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
     }     
     else if(particle->GetParticleName() == "alpha") {
       pmanager->AddProcess(theScintProcessAlpha);
       pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
       pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
     }
     else {
       pmanager->AddProcess(theScintProcessDef);
       pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
       pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
     }     
       }
       
       if (particleName == "opticalphoton") {
     pmanager->AddDiscreteProcess(theAbsorptionProcess);
     //  pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
     pmanager->AddDiscreteProcess(theBoundaryProcess);
       }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructParticle()

void DMXPhysicsList::ConstructParticle ( void )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 93 of file DMXPhysicsList.cc.

 {
 
   // In this method, static member functions should be called
   // for all particles which you want to use.
   // This ensures that objects of these particle types will be
   // created in the program. 
 
   ConstructMyBosons();
   ConstructMyLeptons();
   ConstructMyHadrons();
   ConstructMyShortLiveds();
 
 }

Here is the call graph for this function:

◆ ConstructProcess()

void DMXPhysicsList::ConstructProcess ( void )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 175 of file DMXPhysicsList.cc.

 {
 
   AddTransportation();
 
   ConstructEM();
 
   ConstructOp();
 
   ConstructHad();
 
   ConstructGeneral();
 
 }

Here is the call graph for this function:

◆ SetCuts()

void DMXPhysicsList::SetCuts ( )

virtual

Reimplemented from G4VUserPhysicsList.

Definition at line 920 of file DMXPhysicsList.cc.

 {
   
   if (verboseLevel >1)
     G4cout << "DMXPhysicsList::SetCuts:";
   
   if (verboseLevel>0){
     G4cout << "DMXPhysicsList::SetCuts:";
     G4cout << "CutLength : " 
        << G4BestUnit(defaultCutValue,"Length") << G4endl;
   }
 
   //special for low energy physics
   G4double lowlimit=250*eV;  
   G4ProductionCutsTable::GetProductionCutsTable()->SetEnergyRange(lowlimit,100.*GeV);
 
   // set cut values for gamma at first and for e- second and next for e+,
   // because some processes for e+/e- need cut values for gamma 
   SetCutValue(cutForGamma, "gamma");
   SetCutValue(cutForElectron, "e-");
   SetCutValue(cutForPositron, "e+");
   
   if (verboseLevel>0) DumpCutValuesTable();
 }

Here is the call graph for this function:

Member Data Documentation

◆ cutForElectron

G4double DMXPhysicsList::cutForElectron

private

Definition at line 85 of file DMXPhysicsList.hh.

◆ cutForGamma

G4double DMXPhysicsList::cutForGamma

private

Definition at line 84 of file DMXPhysicsList.hh.

◆ cutForPositron

G4double DMXPhysicsList::cutForPositron

private

Definition at line 86 of file DMXPhysicsList.hh.

◆ OpVerbLevel

G4int DMXPhysicsList::OpVerbLevel

private

Definition at line 82 of file DMXPhysicsList.hh.

◆ VerboseLevel

G4int DMXPhysicsList::VerboseLevel

private

Definition at line 81 of file DMXPhysicsList.hh.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DMXPhysicsList()

◆ ~DMXPhysicsList()

Member Function Documentation

◆ AddTransportation()

◆ ConstructEM()

◆ ConstructGeneral()

◆ ConstructHad()

◆ ConstructMyBosons()

◆ ConstructMyHadrons()

◆ ConstructMyLeptons()

◆ ConstructMyShortLiveds()

◆ ConstructOp()

◆ ConstructParticle()

◆ ConstructProcess()

◆ SetCuts()

Member Data Documentation

◆ cutForElectron

◆ cutForGamma

◆ cutForPositron

◆ OpVerbLevel

◆ VerboseLevel