DMXPhysicsList Class Reference

#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

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

(

)

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

(

)

Definition at line 88 of file DMXPhysicsList.cc.

{;}

Member Function Documentation

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:

void DMXPhysicsList::ConstructEM ( )

protectedvirtual

Definition at line 273 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
  G4EmParameters* param = G4EmParameters::Instance();
  param->SetMaxEnergy(100*GeV);
  param->SetNumberOfBinsPerDecade(20);
  param->SetMscStepLimitType(fMinimal);
  param->SetFluo(true);
  param->SetPixe(true);
  param->SetAuger(true);
  G4LossTableManager* man = G4LossTableManager::Instance();
  G4VAtomDeexcitation* ad = man->AtomDeexcitation();
  if(!ad) {
    man->SetAtomDeexcitation(new G4UAtomicDeexcitation());
  }

  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();
    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);      
      }
    
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void DMXPhysicsList::ConstructGeneral ( )

protectedvirtual

Definition at line 878 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:

void DMXPhysicsList::ConstructHad ( )

protectedvirtual

Definition at line 571 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:

void DMXPhysicsList::ConstructOp ( )

protectedvirtual

Definition at line 436 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:

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();

}

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:

void DMXPhysicsList::SetCuts ( )

virtual

Reimplemented from G4VUserPhysicsList.

Definition at line 921 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:

---

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

• source/geant4.10.03.p03/examples/advanced/underground_physics/include/DMXPhysicsList.hh
• source/geant4.10.03.p03/examples/advanced/underground_physics/src/DMXPhysicsList.cc