#include <LBE.hh>

Inheritance diagram for LBE:

Public Member Functions
	LBE (G4int ver=1)

virtual	~LBE ()

	LBE (const LBE &)=delete

LBE &	operator= (const LBE &right)=delete

virtual void	SetCuts ()

Public Member Functions inherited from G4VModularPhysicsList
	G4VModularPhysicsList ()

virtual	~G4VModularPhysicsList ()

virtual void	ConstructParticle () override

virtual void	ConstructProcess () override

void	RegisterPhysics (G4VPhysicsConstructor *)

const G4VPhysicsConstructor *	GetPhysics (G4int index) const

const G4VPhysicsConstructor *	GetPhysics (const G4String &name) const

const G4VPhysicsConstructor *	GetPhysicsWithType (G4int physics_type) const

void	ReplacePhysics (G4VPhysicsConstructor *)

void	RemovePhysics (G4VPhysicsConstructor *)

void	RemovePhysics (G4int type)

void	RemovePhysics (const G4String &name)

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

G4int	GetInstanceID () const

virtual void	TerminateWorker () override

Public Member Functions inherited from G4VUserPhysicsList
	G4VUserPhysicsList ()

virtual	~G4VUserPhysicsList ()

	G4VUserPhysicsList (const G4VUserPhysicsList &)

G4VUserPhysicsList &	operator= (const G4VUserPhysicsList &)

virtual void	ConstructParticle ()=0

void	Construct ()

virtual void	ConstructProcess ()=0

void	UseCoupledTransportation (G4bool vl=true)

virtual void	SetCuts ()

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

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

virtual void	InitializeWorker ()

virtual void	TerminateWorker ()

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 G4VModularPhysicsList
	G4VModularPhysicsList (const G4VModularPhysicsList &)

G4VModularPhysicsList &	operator= (const G4VModularPhysicsList &)

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 G4VModularPhysicsList
static const G4VMPLManager &	GetSubInstanceManager ()

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

Protected Types inherited from G4VModularPhysicsList
typedef G4VMPLData::G4PhysConstVectorData	G4PhysConstVector

Protected Attributes inherited from G4VModularPhysicsList
G4int	verboseLevel

G4int	g4vmplInstanceID

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 G4VModularPhysicsList
static G4RUN_DLL G4VMPLManager	G4VMPLsubInstanceManager

Static Protected Attributes inherited from G4VUserPhysicsList
static G4RUN_DLL G4VUPLManager	subInstanceManager

Detailed Description

Definition at line 58 of file LBE.hh.

Constructor & Destructor Documentation

◆ LBE() [1/2]

LBE::LBE ( G4int ver = 1 )

Definition at line 77 of file LBE.cc.

{
 
  G4cout << "You are using the simulation engine: LBE"<<G4endl;
  G4cout <<G4endl<<G4endl;
  defaultCutValue     = 1.0*CLHEP::micrometer; //
  cutForGamma         = defaultCutValue;
//  cutForElectron      = 1.0*CLHEP::nanometer;
  cutForElectron      = 1.0*CLHEP::micrometer;
  cutForPositron      = defaultCutValue;
  //not used:
  // cutForProton        = defaultCutValue;
  // cutForAlpha         = 1.0*CLHEP::nanometer;
  // cutForGenericIon    = 1.0*CLHEP::nanometer;
 
  stoppingPhysics = new G4StoppingPhysics;
 
  VerboseLevel = ver;
  OpVerbLevel = 0;
 
  SetVerboseLevel(VerboseLevel);
}

◆ ~LBE()

LBE::~LBE ( )

virtual

Definition at line 102 of file LBE.cc.

{
  delete stoppingPhysics;
}

◆ LBE() [2/2]

LBE::LBE ( const LBE & )

delete

Member Function Documentation

◆ AddTransportation()

void LBE::AddTransportation ( )

protectedvirtual

Definition at line 217 of file LBE.cc.

                             {
  
  G4VUserPhysicsList::AddTransportation();
  
  auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
  myParticleIterator->reset();
  while( (*(myParticleIterator))() ){
    G4ParticleDefinition* particle = myParticleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    G4String particleName = particle->GetParticleName();
    // time cuts for ONLY neutrons:
    if(particleName == "neutron") 
    pmanager->AddDiscreteProcess(new G4MaxTimeCuts());
    // Energy cuts to kill charged (embedded in method) particles:
    pmanager->AddDiscreteProcess(new G4MinEkineCuts());
  }           
}

Referenced by ConstructProcess().

◆ ConstructEM()

void LBE::ConstructEM ( )

protectedvirtual

Definition at line 287 of file LBE.cc.

                       {
 
 // models & processes:
 // Use Livermore models up to 20 MeV, and standard 
 // models for higher energy
 G4double LivermoreHighEnergyLimit = 20*CLHEP::MeV;
 //
  auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
  myParticleIterator->reset();
  while( (*(myParticleIterator))() ){
    G4ParticleDefinition* particle = myParticleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    G4String particleName = particle->GetParticleName();
    G4String particleType = particle->GetParticleType();
    G4double charge = particle->GetPDGCharge();
    
    if (particleName == "gamma") 
      {
      G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
      G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel = 
    new G4LivermorePhotoElectricModel();
      theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
      thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
      pmanager->AddDiscreteProcess(thePhotoElectricEffect);
 
      G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
      G4LivermoreComptonModel* theLivermoreComptonModel = 
    new G4LivermoreComptonModel();
      theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
      theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
      pmanager->AddDiscreteProcess(theComptonScattering);
 
      G4GammaConversion* theGammaConversion = new G4GammaConversion();
      G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel = 
    new G4LivermoreGammaConversionModel();
      theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
      theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
      pmanager->AddDiscreteProcess(theGammaConversion);
 
      G4RayleighScattering* theRayleigh = new G4RayleighScattering();
      G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
      theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
      theRayleigh->AddEmModel(0, theRayleighModel);
      pmanager->AddDiscreteProcess(theRayleigh);
 
      } 
    else if (particleName == "e-") 
      {
       //electron
       // process ordering: AddProcess(name, at rest, along step, post step)
       // -1 = not implemented, then ordering
        G4eMultipleScattering* msc = new G4eMultipleScattering();     
        //msc->AddEmModel(0, new G4UrbanMscModel());
        msc->SetStepLimitType(fUseDistanceToBoundary);
        pmanager->AddProcess(msc,                   -1, 1, 1);
      
       // Ionisation
       G4eIonisation* eIoni = new G4eIonisation();
       G4LivermoreIonisationModel* theIoniLivermore = new
        G4LivermoreIonisationModel();
       theIoniLivermore->SetHighEnergyLimit(1*CLHEP::MeV); 
       eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
       eIoni->SetStepFunction(0.2, 100*CLHEP::um); //     
       pmanager->AddProcess(eIoni,                 -1, 2, 2);
      
       // Bremsstrahlung
       G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
       G4LivermoreBremsstrahlungModel* theBremLivermore = new
         G4LivermoreBremsstrahlungModel();
       theBremLivermore->SetHighEnergyLimit(LivermoreHighEnergyLimit);
       eBrem->AddEmModel(0, theBremLivermore);
       pmanager->AddProcess(eBrem, -1,-3, 3);   
      } 
    else if (particleName == "e+") 
      {
    //positron
      G4eMultipleScattering* msc = new G4eMultipleScattering();
      //msc->AddEmModel(0, new G4UrbanMscModel());      
      msc->SetStepLimitType(fUseDistanceToBoundary);
      pmanager->AddProcess(msc,                   -1, 1, 1);
      G4eIonisation* eIoni = new G4eIonisation();
      eIoni->SetStepFunction(0.2, 100*CLHEP::um);      
      pmanager->AddProcess(eIoni,                 -1, 2, 2);
      pmanager->AddProcess(new G4eBremsstrahlung, -1,-3, 3);      
      pmanager->AddProcess(new G4eplusAnnihilation,0,-1, 4);
      } 
    else if( particleName == "mu+" || 
         particleName == "mu-"    ) 
      {
    //muon  
        G4MuMultipleScattering* aMultipleScattering = new G4MuMultipleScattering();
    pmanager->AddProcess(aMultipleScattering,           -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 == "GenericIon")
    {
      pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
      G4ionIonisation* ionIoni = new G4ionIonisation();
      ionIoni->SetEmModel(new G4IonParametrisedLossModel());
      ionIoni->SetStepFunction(0.1, 10*CLHEP::um);
      pmanager->AddProcess(ionIoni,                   -1, 2, 2);
      pmanager->AddProcess(new G4NuclearStopping(),   -1, 3,-1);    
    }
    else if (particleName == "alpha" || particleName == "He3")
    {
      //MSC, ion-Ionisation, Nuclear Stopping
      pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
 
      G4ionIonisation* ionIoni = new G4ionIonisation();
      ionIoni->SetStepFunction(0.1, 20*CLHEP::um);
      pmanager->AddProcess(ionIoni,                   -1, 2, 2);
      pmanager->AddProcess(new G4NuclearStopping(),   -1, 3,-1);
    }
    else if (particleName == "proton"     ||      
         particleName == "deuteron"   ||
         particleName == "triton"     ||
             particleName == "pi+" ||
             particleName == "pi-" ||
         particleName == "kaon+" ||
             particleName == "kaon-") 
      {
       //MSC, h-ionisation, bremsstrahlung
       pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);      
       G4hIonisation* hIoni = new G4hIonisation();
       hIoni->SetStepFunction(0.2, 50*CLHEP::um);
       pmanager->AddProcess(hIoni,                     -1, 2, 2);      
       pmanager->AddProcess(new G4hBremsstrahlung,     -1,-3, 3);    
      } 
    else if ((!particle->IsShortLived()) &&
         (charge != 0.0) && 
         (particle->GetParticleName() != "chargedgeantino")) 
      {
    //all others charged particles except geantino
        pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
        pmanager->AddProcess(new G4hIonisation,         -1, 2, 2);
      }
    
  }
}

Referenced by ConstructProcess().

◆ ConstructGeneral()

void LBE::ConstructGeneral ( )

protectedvirtual

Definition at line 902 of file LBE.cc.

                            {
 
  // Add Decay Process
  G4Decay* theDecayProcess = new G4Decay();
  G4bool theDecayProcessNeverUsed = true; //Check if theDecayProcess will be used
  auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
  myParticleIterator->reset();
  while( (*(myParticleIterator))() )
    {
      G4ParticleDefinition* particle = myParticleIterator->value();
      G4ProcessManager* pmanager = particle->GetProcessManager();
      
      if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived()) 
    { 
      theDecayProcessNeverUsed = false;
      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();
  G4RadioactiveDecayBase* theRadioactiveDecay = new G4RadioactiveDecayBase();
 
  //Fix for activation of RadioactiveDecay, based on G4RadioactiveDecayPhysics 
  G4EmParameters* param = G4EmParameters::Instance();
  param->SetAugerCascade(true);
  param->AddPhysics("world","G4RadioactiveDecay");
 
  G4DeexPrecoParameters* deex = G4NuclearLevelData::GetInstance()->GetParameters();
  deex->SetStoreAllLevels(true);
  deex->SetMaxLifeTime(G4NuclideTable::GetInstance()->GetThresholdOfHalfLife()
                       /std::log(2.));
 
  G4LossTableManager* man = G4LossTableManager::Instance();
  G4VAtomDeexcitation* ad = man->AtomDeexcitation();
  if(!ad) {
    ad = new G4UAtomicDeexcitation();
    man->SetAtomDeexcitation(ad);
    ad->InitialiseAtomicDeexcitation();
  }
 
  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);
    } 
    }
    //If we actually never used the process, delete it
    //From Coverity report
    if ( theDecayProcessNeverUsed ) delete theDecayProcess;
}

Referenced by ConstructProcess().

◆ ConstructHad()

void LBE::ConstructHad ( )

protectedvirtual

Definition at line 597 of file LBE.cc.

{
  // Elastic scattering
  G4HadronElastic* elastic_lhep0 = new G4HadronElastic();
  G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();
  G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE(); 
 
  const G4double elastic_elimitAntiNuc = 100.0*CLHEP::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 );
 
  // Inelastic scattering
  const G4double theFTFMin0 =    0.0*CLHEP::GeV;
  const G4double theFTFMin1 =    4.0*CLHEP::GeV;
  const G4double theFTFMax = G4HadronicParameters::Instance()->GetMaxEnergy();
  const G4double theBERTMin0 =   0.0*CLHEP::GeV;
  const G4double theBERTMin1 =  19.0*CLHEP::MeV;
  const G4double theBERTMax =    5.0*CLHEP::GeV;
  const G4double theHPMin =      0.0*CLHEP::GeV;
  const G4double theHPMax =     20.0*CLHEP::MeV;
  const G4double theIonBCMin =   0.0*CLHEP::GeV;
  const G4double theIonBCMax =   5.0*CLHEP::GeV;
 
 
  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 );
 
  // Binary Cascade
  G4BinaryLightIonReaction * theIonBC = new G4BinaryLightIonReaction( thePreEquilib );
  theIonBC->SetMinEnergy( theIonBCMin );
  theIonBC->SetMaxEnergy( theIonBCMax );
 
  G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
  G4ComponentGGNuclNuclXsc * ggNuclNuclXsec = new G4ComponentGGNuclNuclXsc();
  G4VCrossSectionDataSet * theGGNuclNuclData = new G4CrossSectionInelastic(ggNuclNuclXsec);
 
  auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
  myParticleIterator->reset();
  while ((*(myParticleIterator))()) 
    {
      G4ParticleDefinition* particle = myParticleIterator->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_he );
      pmanager->AddDiscreteProcess( theElasticProcess );
          // Inelastic scattering
      G4PionPlusInelasticProcess* theInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
          theInelasticProcess->AddDataSet( new G4BGGPionInelasticXS( G4PionPlus::Definition() ) );
      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_he );
      pmanager->AddDiscreteProcess( theElasticProcess );
          // Inelastic scattering
      G4PionMinusInelasticProcess* theInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
          theInelasticProcess->AddDataSet( new G4BGGPionInelasticXS( G4PionMinus::Definition() ) );
      theInelasticProcess->RegisterMe( theFTFModel1 );
          theInelasticProcess->RegisterMe( theBERTModel0 );
      pmanager->AddDiscreteProcess( theInelasticProcess );
    }
      
      else if (particleName == "kaon+") 
    {
          // Elastic scattering
          G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
          theElasticProcess->RegisterMe( elastic_lhep0 );
          theElasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonPlusElasticXS::Default_Name()));
      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 );
          theElasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonZeroElasticXS::Default_Name()));
      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 );
          theElasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonZeroElasticXS::Default_Name()));
      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 );
          theElasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsKaonMinusElasticXS::Default_Name()));
      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 );
    }
 
      else if (particleName == "proton") 
    {
          // Elastic scattering
          G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
          theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));
          theElasticProcess->AddDataSet( new G4BGGNucleonElasticXS( G4Proton::Proton() ) );
          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
          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 );
    }
 
      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*CLHEP::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 * theNeutronCaptureHPModel = new G4ParticleHPCapture;
        theNeutronCaptureHPModel->SetMinEnergy( theHPMin );
        theNeutronCaptureHPModel->SetMaxEnergy( theHPMax );
    G4NeutronRadCapture* theNeutronRadCapture = new G4NeutronRadCapture(); 
    theNeutronRadCapture->SetMinEnergy(theHPMax*0.99); 
    theCaptureProcess->RegisterMe( theNeutronCaptureHPModel );
    theCaptureProcess->RegisterMe( theNeutronRadCapture);
    theCaptureProcess->AddDataSet( new G4ParticleHPCaptureData );
    theCaptureProcess->AddDataSet((G4NeutronCaptureXS*)G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4NeutronCaptureXS::Default_Name()));
    pmanager->AddDiscreteProcess(theCaptureProcess);
      }
      else if (particleName == "anti_neutron") 
    {
          // Elastic scattering
          G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
          theElasticProcess->AddDataSet( elastic_anucxs );
          theElasticProcess->RegisterMe( elastic_lhep2 );
          theElasticProcess->RegisterMe( elastic_anuc );
      pmanager->AddDiscreteProcess( theElasticProcess );
          // Inelastic scattering
      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 );
          theElasticProcess->AddDataSet( theGGNuclNuclData );
      pmanager->AddDiscreteProcess( theElasticProcess );
          // Inelastic scattering
      G4DeuteronInelasticProcess* theInelasticProcess = new G4DeuteronInelasticProcess("inelastic");
          theInelasticProcess->AddDataSet( theGGNuclNuclData );
      theInelasticProcess->RegisterMe( theFTFModel1 );
      theInelasticProcess->RegisterMe( theIonBC );
      pmanager->AddDiscreteProcess( theInelasticProcess );
    }
      
      else if (particleName == "triton") 
    {
          // Elastic scattering
          G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
          theElasticProcess->RegisterMe( elastic_lhep0 );
          theElasticProcess->AddDataSet( theGGNuclNuclData );
      pmanager->AddDiscreteProcess( theElasticProcess );
          // Inelastic scattering
      G4TritonInelasticProcess* theInelasticProcess = new G4TritonInelasticProcess("inelastic");
          theInelasticProcess->AddDataSet( theGGNuclNuclData );
      theInelasticProcess->RegisterMe( theFTFModel1 );
      theInelasticProcess->RegisterMe( theIonBC );
      pmanager->AddDiscreteProcess( theInelasticProcess );
    }
 
      else if (particleName == "alpha") 
    {
          // Elastic scattering
          G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
          theElasticProcess->RegisterMe( elastic_lhep0 );
          theElasticProcess->AddDataSet( theGGNuclNuclData );
      pmanager->AddDiscreteProcess( theElasticProcess );
          // Inelastic scattering
      G4AlphaInelasticProcess* theInelasticProcess = new G4AlphaInelasticProcess("inelastic");
          theInelasticProcess->AddDataSet( theGGNuclNuclData );
      theInelasticProcess->RegisterMe( theFTFModel1 );
      theInelasticProcess->RegisterMe( theIonBC );
      pmanager->AddDiscreteProcess( theInelasticProcess );
    }
    }   // while ((*(myParticleIterator))()) 
 
  // Add stopping processes with builder
  stoppingPhysics->ConstructProcess();
}

Referenced by ConstructProcess().

◆ ConstructOp()

void LBE::ConstructOp ( )

protectedvirtual

Definition at line 438 of file LBE.cc.

{
  // default scintillation process
  //Coverity report: check that the process is actually used, if not must delete
  G4bool theScintProcessDefNeverUsed = true;
  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:
  G4bool theScintProcessAlphaNeverUsed = true;
  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
  G4bool theScintProcessNucNeverUsed = true;  
  G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
  // theScintProcessNuc->DumpPhysicsTable();
  theScintProcessNuc->SetTrackSecondariesFirst(true);
  theScintProcessNuc->SetScintillationYieldFactor(0.2);
  theScintProcessNuc->SetScintillationExcitationRatio(1.0);
  theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
 
  // optical processes
  G4bool theAbsorptionProcessNeverUsed = true;
  G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
  //  G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
  G4bool theBoundaryProcessNeverUsed = true;
  G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
  //  theAbsorptionProcess->DumpPhysicsTable();
  //  theRayleighScatteringProcess->DumpPhysicsTable();
  theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
  // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
  theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
 
  auto myParticleIterator=G4ParticleTable::GetParticleTable()->GetIterator();
  myParticleIterator->reset();
  while( (*(myParticleIterator))() )
    {
      G4ParticleDefinition* particle = myParticleIterator->value();
      G4ProcessManager* pmanager = particle->GetProcessManager();
      G4String particleName = particle->GetParticleName();
      if (theScintProcessDef->IsApplicable(*particle)) {
    //      if(particle->GetPDGMass() > 5.0*CLHEP::GeV) 
    if(particle->GetParticleName() == "GenericIon") {
      pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
      pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
      pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
      theScintProcessNucNeverUsed = false;
    }     
    else if(particle->GetParticleName() == "alpha") {
      pmanager->AddProcess(theScintProcessAlpha);
      pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
      pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
      theScintProcessAlphaNeverUsed = false;
    }
    else {
      pmanager->AddProcess(theScintProcessDef);
      pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
      pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
      theScintProcessDefNeverUsed = false;
    }     
      }
      
      if (particleName == "opticalphoton") {
    pmanager->AddDiscreteProcess(theAbsorptionProcess);
    theAbsorptionProcessNeverUsed = false;
    //  pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
    theBoundaryProcessNeverUsed = false;
    pmanager->AddDiscreteProcess(theBoundaryProcess);
      }
    }
    if ( theScintProcessDefNeverUsed ) delete theScintProcessDef;
    if ( theScintProcessAlphaNeverUsed ) delete theScintProcessAlpha;
    if ( theScintProcessNucNeverUsed ) delete theScintProcessNuc;
    if ( theBoundaryProcessNeverUsed ) delete theBoundaryProcess;
    if ( theAbsorptionProcessNeverUsed ) delete theAbsorptionProcess;
}

Referenced by ConstructProcess().

◆ ConstructParticle()

void LBE::ConstructParticle ( )

protectedvirtual

Reimplemented from G4VModularPhysicsList.

Definition at line 109 of file LBE.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();
  ConstructMyMesons();
  ConstructMyBaryons();
  ConstructMyIons();
  ConstructMyShortLiveds();
  stoppingPhysics->ConstructParticle(); // Anything not included above
}

◆ ConstructProcess()

void LBE::ConstructProcess ( )

protectedvirtual

Reimplemented from G4VModularPhysicsList.

Definition at line 203 of file LBE.cc.

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

◆ operator=()

LBE & LBE::operator= ( const LBE & right )

delete

◆ SetCuts()

void LBE::SetCuts ( )

virtual

Reimplemented from G4VUserPhysicsList.

Definition at line 968 of file LBE.cc.

{
  
  if (verboseLevel >1)
    G4cout << "LBE::SetCuts:";
  
  if (verboseLevel>0){
    G4cout << "LBE::SetCuts:";
    G4cout << "CutLength : " 
       << G4BestUnit(defaultCutValue,"Length") << G4endl;
  }
 
  //special for low energy physics
  G4double lowlimit=250*CLHEP::eV;  
  G4ProductionCutsTable * aPCTable = G4ProductionCutsTable::GetProductionCutsTable();
  aPCTable->SetEnergyRange(lowlimit,100*CLHEP::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+");
  
  //  SetCutValue(cutForProton, "proton");
  //  SetCutValue(cutForProton, "anti_proton");
  //  SetCutValue(cutForAlpha,  "alpha");
  //  SetCutValue(cutForGenericIon,  "GenericIon");
  
  //  SetCutValueForOthers(defaultCutValue);
  
  if (verboseLevel>0) DumpCutValuesTable();
}

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LBE() [1/2]

◆ ~LBE()

◆ LBE() [2/2]

Member Function Documentation

◆ AddTransportation()

◆ ConstructEM()

◆ ConstructGeneral()

◆ ConstructHad()

◆ ConstructOp()

◆ ConstructParticle()

◆ ConstructProcess()

◆ operator=()

◆ SetCuts()