LBE Class Reference

#include <LBE.hh>

Inheritance diagram for LBE:

Public Member Functions
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=nullptr)
void	BuildPhysicsTable ()
void	BuildPhysicsTable (G4ParticleDefinition *)
void	CheckParticleList ()
void	Construct ()
void	DisableCheckParticleList ()
void	DumpCutValuesTable (G4int flag=1)
void	DumpCutValuesTableIfRequested ()
void	DumpList () const
G4bool	GetApplyCuts (const G4String &name) const
G4double	GetCutValue (const G4String &pname) const
G4double	GetDefaultCutValue () const
G4int	GetInstanceID () const
const G4VPhysicsConstructor *	GetPhysics (const G4String &name) const
const G4VPhysicsConstructor *	GetPhysics (G4int index) const
const G4String &	GetPhysicsTableDirectory () const
const G4VPhysicsConstructor *	GetPhysicsWithType (G4int physics_type) const
G4int	GetVerboseLevel () const
virtual void	InitializeWorker ()
G4bool	IsPhysicsTableRetrieved () const
G4bool	IsStoredInAscii () const
	LBE (const LBE &)=delete
	LBE (G4int ver=1)
LBE &	operator= (const LBE &right)=delete
void	PreparePhysicsTable (G4ParticleDefinition *)
void	RegisterPhysics (G4VPhysicsConstructor *)
void	RemovePhysics (const G4String &name)
void	RemovePhysics (G4int type)
void	RemovePhysics (G4VPhysicsConstructor *)
void	RemoveProcessManager ()
void	RemoveTrackingManager ()
void	ReplacePhysics (G4VPhysicsConstructor *)
void	ResetPhysicsTableRetrieved ()
void	ResetStoredInAscii ()
void	SetApplyCuts (G4bool value, const G4String &name)
virtual void	SetCuts ()
void	SetCutsForRegion (G4double aCut, const G4String &rname)
void	SetCutsWithDefault ()
void	SetCutValue (G4double aCut, const G4String &pname)
void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)
void	SetDefaultCutValue (G4double newCutValue)
void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=nullptr)
void	SetParticleCuts (G4double cut, G4ParticleDefinition *particle, G4Region *region=nullptr)
void	SetPhysicsTableRetrieved (const G4String &directory="")
void	SetStoredInAscii ()
void	SetVerboseLevel (G4int value)
G4bool	StorePhysicsTable (const G4String &directory=".")
virtual void	TerminateWorker () override
void	UseCoupledTransportation (G4bool vl=true)
virtual	~LBE ()

Static Public Member Functions
static const G4VMPLManager &	GetSubInstanceManager ()

Protected Types
using	G4PhysConstVector = G4VMPLData::G4PhysConstVectorData

Protected Member Functions
virtual void	AddTransportation ()
void	BuildIntegralPhysicsTable (G4VProcess *, G4ParticleDefinition *)
virtual void	ConstructEM ()
virtual void	ConstructGeneral ()
virtual void	ConstructHad ()
virtual void	ConstructOp ()
virtual void	ConstructParticle ()
virtual void	ConstructProcess ()
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const
void	InitializeProcessManager ()
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
virtual void	RetrievePhysicsTable (G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)

Protected Attributes
G4double	defaultCutValue = 1.0
G4String	directoryPhysicsTable = "."
G4ProductionCutsTable *	fCutsTable = nullptr
G4bool	fDisableCheckParticleList = false
G4bool	fIsCheckedForRetrievePhysicsTable = false
G4bool	fIsRestoredCutValues = false
G4bool	fRetrievePhysicsTable = false
G4bool	fStoredInAscii = true
G4int	g4vmplInstanceID = 0
G4int	g4vuplInstanceID = 0
G4bool	isSetDefaultCutValue = false
G4ParticleTable *	theParticleTable = nullptr
G4int	verboseLevel = 0

Static Protected Attributes
static G4RUN_DLL G4VMPLManager	G4VMPLsubInstanceManager
static G4RUN_DLL G4VUPLManager	subInstanceManager

Private Types
enum	{ FixedStringLengthForStore = 32 }

Private Member Functions
void	ConstructMyBaryons ()
void	ConstructMyBosons ()
void	ConstructMyIons ()
void	ConstructMyLeptons ()
void	ConstructMyMesons ()
void	ConstructMyShortLiveds ()

Private Attributes
G4double	cutForElectron
G4double	cutForGamma
G4double	cutForPositron
G4int	OpVerbLevel
G4StoppingPhysics *	stoppingPhysics
G4int	VerboseLevel

Detailed Description

Definition at line 58 of file LBE.hh.

Member Typedef Documentation

G4PhysConstVector

using G4VModularPhysicsList::G4PhysConstVector = G4VMPLData::G4PhysConstVectorData

protectedinherited

Definition at line 139 of file G4VModularPhysicsList.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

privateinherited

Enumerator
FixedStringLengthForStore

Definition at line 311 of file G4VUserPhysicsList.hh.

    {
      FixedStringLengthForStore = 32
    };

Constructor & Destructor Documentation

LBE() [1/2]

LBE::LBE

(

G4int

ver = 1

)

Definition at line 77 of file LBE.cc.

{
  if(ver > 0) {
    G4cout << "You are using the simulation engine: LBE"<<G4endl;
    G4cout <<G4endl;
  }
  defaultCutValue     = 1.0*CLHEP::micrometer; //
  cutForGamma         = defaultCutValue;
  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);
}

References cutForElectron, cutForGamma, cutForPositron, G4VUserPhysicsList::defaultCutValue, G4cout, G4endl, CLHEP::micrometer, OpVerbLevel, G4VModularPhysicsList::SetVerboseLevel(), stoppingPhysics, and VerboseLevel.

~LBE()

LBE::~LBE ( )

virtual

Definition at line 102 of file LBE.cc.

{
  delete stoppingPhysics;
}

References stoppingPhysics.

LBE() [2/2]

LBE::LBE ( const LBE &  )

delete

Member Function Documentation

AddProcessManager()

void G4VUserPhysicsList::AddProcessManager ( G4ParticleDefinition *  newParticle, G4ProcessManager *  newManager = nullptr  )

inherited

Definition at line 207 of file G4VUserPhysicsList.cc.

{
  if(newParticle == nullptr)
    return;
  G4Exception("G4VUserPhysicsList::AddProcessManager", "Run0252",
              JustWarning, "This method is obsolete");
}

References G4Exception(), and JustWarning.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

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

References G4ProcessManager::AddDiscreteProcess(), G4VUserPhysicsList::AddTransportation(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), and G4ParticleTableIterator< K, V >::reset().

Referenced by ConstructProcess().

BuildIntegralPhysicsTable()

void G4VUserPhysicsList::BuildIntegralPhysicsTable ( G4VProcess *  process, G4ParticleDefinition *  particle  )

protectedinherited

Definition at line 864 of file G4VUserPhysicsList.cc.

{
  // TODO Should we change this function?
  //*******************************************************************
  // Temporary addition to make the integral schema of electromagnetic
  // processes work.
 
  if((process->GetProcessName() == "Imsc") ||
     (process->GetProcessName() == "IeIoni") ||
     (process->GetProcessName() == "IeBrems") ||
     (process->GetProcessName() == "Iannihil") ||
     (process->GetProcessName() == "IhIoni") ||
     (process->GetProcessName() == "IMuIoni") ||
     (process->GetProcessName() == "IMuBrems") ||
     (process->GetProcessName() == "IMuPairProd"))
  {
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildIntegralPhysicsTable  "
             << " BuildPhysicsTable is invoked for "
             << process->GetProcessName() << "(" << particle->GetParticleName()
             << ")" << G4endl;
    }
#endif
    process->BuildPhysicsTable(*particle);
  }
}

References G4VProcess::BuildPhysicsTable(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::RetrievePhysicsTable().

BuildPhysicsTable() [1/2]

void G4VUserPhysicsList::BuildPhysicsTable ( )

inherited

Definition at line 562 of file G4VUserPhysicsList.cc.

{
  // Prepare Physics table for all particles
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    PreparePhysicsTable(particle);
  }
 
  // ask processes to prepare physics table
  if(fRetrievePhysicsTable)
  {
    fIsRestoredCutValues =
      fCutsTable->RetrieveCutsTable(directoryPhysicsTable, fStoredInAscii);
    // check if retrieve Cut Table successfully
    if(!fIsRestoredCutValues)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
               << " Retrieve Cut Table failed !!" << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::BuildPhysicsTable", "Run0255",
                  RunMustBeAborted, "Fail to retrieve Production Cut Table");
    }
    else
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
               << "  Retrieve Cut Table successfully " << G4endl;
      }
#endif
    }
  }
  else
  {
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
             << " does not retrieve Cut Table but calculate " << G4endl;
    }
#endif
  }
 
  // Sets a value to particle
  // set cut values for gamma at first and for e- and e+
  G4String particleName;
  G4ParticleDefinition* GammaP = theParticleTable->FindParticle("gamma");
  if(GammaP)
    BuildPhysicsTable(GammaP);
  G4ParticleDefinition* EMinusP = theParticleTable->FindParticle("e-");
  if(EMinusP)
    BuildPhysicsTable(EMinusP);
  G4ParticleDefinition* EPlusP = theParticleTable->FindParticle("e+");
  if(EPlusP)
    BuildPhysicsTable(EPlusP);
  G4ParticleDefinition* ProtonP = theParticleTable->FindParticle("proton");
  if(ProtonP)
    BuildPhysicsTable(ProtonP);
 
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    if(particle != GammaP && particle != EMinusP && particle != EPlusP &&
       particle != ProtonP)
    {
      BuildPhysicsTable(particle);
    }
  }
 
  // Set flag
  fIsPhysicsTableBuilt = true;
}

References G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::directoryPhysicsTable, G4VUserPhysicsList::fCutsTable, G4ParticleTable::FindParticle(), fIsPhysicsTableBuilt, G4VUserPhysicsList::fIsRestoredCutValues, G4VUserPhysicsList::fRetrievePhysicsTable, G4VUserPhysicsList::fStoredInAscii, G4cout, G4endl, G4Exception(), G4VUserPhysicsList::PreparePhysicsTable(), G4ProductionCutsTable::RetrieveCutsTable(), RunMustBeAborted, theParticleIterator, G4VUserPhysicsList::theParticleTable, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4RunManagerKernel::BuildPhysicsTables(), and G4UserPhysicsListMessenger::SetNewValue().

BuildPhysicsTable() [2/2]

void G4VUserPhysicsList::BuildPhysicsTable ( G4ParticleDefinition *  particle )

inherited

Definition at line 644 of file G4VUserPhysicsList.cc.

{
  if (auto *trackingManager = particle->GetTrackingManager())
  {
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
             << "Calculate Physics Table for " << particle->GetParticleName()
             << " via custom TrackingManager" << G4endl;
    }
#endif
    trackingManager->BuildPhysicsTable(*particle);
    return;
  }
 
  // Change in order to share physics tables for two kind of process.
 
  if(particle->GetMasterProcessManager() == nullptr)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    { G4cout
      << "#### G4VUserPhysicsList::BuildPhysicsTable() - BuildPhysicsTable("
      << particle->GetParticleName() << ") skipped..." << G4endl; }
#endif
    return;
  }
  if(fRetrievePhysicsTable)
  {
    if(!fIsRestoredCutValues)
    {
      // fail to retrieve cut tables
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
               << "Physics table can not be retrieved and will be calculated "
               << G4endl;
      }
#endif
      fRetrievePhysicsTable = false;
    }
    else
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
               << " Retrieve Physics Table for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      //  Retrieve PhysicsTable from files for proccesses
      RetrievePhysicsTable(particle, directoryPhysicsTable, fStoredInAscii);
    }
  }
 
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
           << "Calculate Physics Table for " << particle->GetParticleName()
           << G4endl;
  }
#endif
  // Rebuild the physics tables for every process for this particle type
  // if particle is not ShortLived
  if(!particle->IsShortLived())
  {
    G4ProcessManager* pManager = particle->GetProcessManager();
    if(pManager == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable "
               << " : No Process Manager for " << particle->GetParticleName()
               << G4endl;
        G4cout << particle->GetParticleName()
               << " should be created in your PhysicsList" << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::BuildPhysicsTable", "Run0271",
                  FatalException, "No process manager");
      return;
    }
 
    // Get processes from master thread;
    G4ProcessManager* pManagerShadow = particle->GetMasterProcessManager();
 
    G4ProcessVector* pVector = pManager->GetProcessList();
    if(pVector == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
               << " : No Process Vector for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::BuildPhysicsTable", "Run0272",
                  FatalException, "No process Vector");
      return;
    }
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildPhysicsTable %%%%%% "
             << particle->GetParticleName() << G4endl;
      G4cout << " ProcessManager : " << pManager
             << " ProcessManagerShadow : " << pManagerShadow << G4endl;
      for(std::size_t iv1 = 0; iv1 < pVector->size(); ++iv1)
      {
        G4cout << "  " << iv1 << " - " << (*pVector)[iv1]->GetProcessName()
               << G4endl;
      }
      G4cout << "--------------------------------------------------------------"
             << G4endl;
      G4ProcessVector* pVectorShadow = pManagerShadow->GetProcessList();
 
      for(std::size_t iv2 = 0; iv2 < pVectorShadow->size(); ++iv2)
      {
        G4cout << "  " << iv2 << " - "
               << (*pVectorShadow)[iv2]->GetProcessName() << G4endl;
      }
    }
#endif
    for(std::size_t j = 0; j < pVector->size(); ++j)
    {
      // Andrea July 16th 2013 : migration to new interface...
      // Infer if we are in a worker thread or master thread
      // Master thread is the one in which the process manager
      // and process manager shadow pointers are the same
      if(pManagerShadow == pManager)
      {
        (*pVector)[j]->BuildPhysicsTable(*particle);
      }
      else
      {
        (*pVector)[j]->BuildWorkerPhysicsTable(*particle);
      }
 
    }  // End loop on processes vector
  }    // End if short-lived
}

References G4VUserPhysicsList::directoryPhysicsTable, FatalException, G4VUserPhysicsList::fIsRestoredCutValues, G4VUserPhysicsList::fRetrievePhysicsTable, G4VUserPhysicsList::fStoredInAscii, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetMasterProcessManager(), G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::GetTrackingManager(), G4ParticleDefinition::IsShortLived(), G4VUserPhysicsList::RetrievePhysicsTable(), G4ProcessVector::size(), and G4VUserPhysicsList::verboseLevel.

CheckParticleList()

void G4VUserPhysicsList::CheckParticleList ( )

inherited

Definition at line 1060 of file G4VUserPhysicsList.cc.

{
  if(!fDisableCheckParticleList)
  {
    G4MT_thePLHelper->CheckParticleList();
  }
}

References G4VUserPhysicsList::fDisableCheckParticleList, and G4MT_thePLHelper.

Referenced by G4RunManagerKernel::InitializePhysics().

Construct()

void G4VUserPhysicsList::Construct ( )

inlineinherited

Definition at line 319 of file G4VUserPhysicsList.hh.

{
  #ifdef G4VERBOSE
    if(verboseLevel > 1)
      G4cout << "G4VUserPhysicsList::Construct()" << G4endl;
  #endif
 
  if ( G4Threading::IsMasterThread() ) G4PhysicsModelCatalog::Initialize();
  
  InitializeProcessManager();
 
  #ifdef G4VERBOSE
    if(verboseLevel > 1)
      G4cout << "Construct processes " << G4endl;
  #endif
  ConstructProcess();
}

References G4VUserPhysicsList::ConstructProcess(), G4cout, G4endl, G4PhysicsModelCatalog::Initialize(), G4VUserPhysicsList::InitializeProcessManager(), G4Threading::IsMasterThread(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4RunManagerKernel::InitializePhysics().

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

References G4ProcessManager::AddDiscreteProcess(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ProcessManager::AddProcess(), fUseDistanceToBoundary, G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::IsShortLived(), CLHEP::MeV, G4ParticleTableIterator< K, V >::reset(), G4VEnergyLossProcess::SetEmModel(), G4VEmModel::SetHighEnergyLimit(), G4VEnergyLossProcess::SetStepFunction(), G4VMultipleScattering::SetStepLimitType(), and CLHEP::um.

Referenced by ConstructProcess().

ConstructGeneral()

void LBE::ConstructGeneral ( )

protectedvirtual

Definition at line 886 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();
  G4RadioactiveDecay* theRadioactiveDecay = new G4RadioactiveDecay();
 
  //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;
}

References G4EmParameters::AddPhysics(), G4ProcessManager::AddProcess(), G4LossTableManager::AtomDeexcitation(), G4IonTable::Entries(), G4NuclideTable::GetInstance(), G4NuclearLevelData::GetInstance(), G4ParticleTable::GetIonTable(), G4ParticleTable::GetIterator(), G4NuclearLevelData::GetParameters(), G4IonTable::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetProcessManager(), idxAtRest, idxPostStep, G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), G4EmParameters::Instance(), G4LossTableManager::Instance(), G4Decay::IsApplicable(), G4ParticleDefinition::IsShortLived(), G4ParticleTableIterator< K, V >::reset(), G4LossTableManager::SetAtomDeexcitation(), G4EmParameters::SetAugerCascade(), G4DeexPrecoParameters::SetMaxLifeTime(), G4ProcessManager::SetProcessOrdering(), G4DeexPrecoParameters::SetStoreAllLevels(), G4ProcessManager::SetVerboseLevel(), and VerboseLevel.

Referenced by ConstructProcess().

ConstructHad()

void LBE::ConstructHad ( )

protectedvirtual

Definition at line 579 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
          G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4PionPlus::Definition() );
          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
          G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4PionMinus::Definition() );     
          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
          G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4KaonPlus::Definition() );
      
          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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4KaonZeroShort::Definition() );
          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");
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4KaonZeroLong::Definition() );
          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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4KaonMinus::Definition() );
          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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4Proton::Definition() );
          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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4AntiProton::Definition() );
          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
    G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4Neutron::Definition() );
        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
    G4NeutronCaptureProcess* theCaptureProcess = new G4NeutronCaptureProcess;
    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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4AntiNeutron::Definition() );
          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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4Deuteron::Definition() );      
          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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4Triton::Definition() );    
          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
      G4HadronInelasticProcess* theInelasticProcess = new G4HadronInelasticProcess( "inelastic", G4Alpha::Definition() );     
          theInelasticProcess->AddDataSet( theGGNuclNuclData );
      theInelasticProcess->RegisterMe( theFTFModel1 );
      theInelasticProcess->RegisterMe( theIonBC );
      pmanager->AddDiscreteProcess( theInelasticProcess );
    }
    }   // while ((*(myParticleIterator))()) 
 
  // Add stopping processes with builder
  stoppingPhysics->ConstructProcess();
}

References G4HadronicProcess::AddDataSet(), G4ProcessManager::AddDiscreteProcess(), G4StoppingPhysics::ConstructProcess(), G4ChipsKaonMinusElasticXS::Default_Name(), G4ChipsKaonMinusInelasticXS::Default_Name(), G4ChipsKaonPlusElasticXS::Default_Name(), G4ChipsKaonPlusInelasticXS::Default_Name(), G4ChipsKaonZeroElasticXS::Default_Name(), G4ChipsKaonZeroInelasticXS::Default_Name(), G4ChipsNeutronElasticXS::Default_Name(), G4ChipsProtonElasticXS::Default_Name(), G4NeutronCaptureXS::Default_Name(), G4AntiNeutron::Definition(), G4AntiProton::Definition(), G4Neutron::Definition(), G4Proton::Definition(), G4Alpha::Definition(), G4Deuteron::Definition(), G4Triton::Definition(), G4KaonMinus::Definition(), G4KaonPlus::Definition(), G4KaonZeroLong::Definition(), G4KaonZeroShort::Definition(), G4PionMinus::Definition(), G4PionPlus::Definition(), G4AntiNuclElastic::GetComponentCrossSection(), G4ParticleTable::GetIterator(), G4HadronicParameters::GetMaxEnergy(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), CLHEP::GeV, G4CrossSectionDataSetRegistry::Instance(), G4HadronicParameters::Instance(), CLHEP::MeV, G4Neutron::Neutron(), G4Proton::Proton(), G4HadronicProcess::RegisterMe(), G4ParticleTableIterator< K, V >::reset(), G4VPartonStringModel::SetFragmentationModel(), G4TheoFSGenerator::SetHighEnergyGenerator(), G4HadronicInteraction::SetMaxEnergy(), G4HadronicInteraction::SetMinEnergy(), G4TheoFSGenerator::SetTransport(), and stoppingPhysics.

Referenced by ConstructProcess().

ConstructMyBaryons()

void LBE::ConstructMyBaryons ( )

private

Definition at line 173 of file LBE.cc.

{
 //  baryons
  G4BaryonConstructor bConstructor;
  bConstructor.ConstructParticle();
 
}

References G4BaryonConstructor::ConstructParticle().

Referenced by ConstructParticle().

ConstructMyBosons()

void LBE::ConstructMyBosons ( )

private

Definition at line 128 of file LBE.cc.

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

References G4ChargedGeantino::ChargedGeantinoDefinition(), G4Gamma::GammaDefinition(), G4Geantino::GeantinoDefinition(), and G4OpticalPhoton::OpticalPhotonDefinition().

Referenced by ConstructParticle().

ConstructMyIons()

void LBE::ConstructMyIons ( )

private

Definition at line 183 of file LBE.cc.

{
 //  ions
  G4IonConstructor iConstructor;
  iConstructor.ConstructParticle();
 
}

References G4IonConstructor::ConstructParticle().

Referenced by ConstructParticle().

ConstructMyLeptons()

void LBE::ConstructMyLeptons ( )

private

Definition at line 143 of file LBE.cc.

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

References G4AntiNeutrinoE::AntiNeutrinoEDefinition(), G4AntiNeutrinoMu::AntiNeutrinoMuDefinition(), G4Electron::ElectronDefinition(), G4MuonMinus::MuonMinusDefinition(), G4MuonPlus::MuonPlusDefinition(), G4NeutrinoE::NeutrinoEDefinition(), G4NeutrinoMu::NeutrinoMuDefinition(), and G4Positron::PositronDefinition().

Referenced by ConstructParticle().

ConstructMyMesons()

void LBE::ConstructMyMesons ( )

private

Definition at line 163 of file LBE.cc.

{
 //  mesons
  G4MesonConstructor mConstructor;
  mConstructor.ConstructParticle();
 
}

References G4MesonConstructor::ConstructParticle().

Referenced by ConstructParticle().

ConstructMyShortLiveds()

void LBE::ConstructMyShortLiveds ( )

private

Definition at line 192 of file LBE.cc.

{
  // ShortLiveds
  G4ShortLivedConstructor pShortLivedConstructor;
  pShortLivedConstructor.ConstructParticle();
}

References G4ShortLivedConstructor::ConstructParticle().

Referenced by ConstructParticle().

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->SetVerboseLevel(OpVerbLevel);
 
  // scintillation process for alpha:
  G4bool theScintProcessAlphaNeverUsed = true;
  G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
  // theScintProcessNuc->DumpPhysicsTable();
  theScintProcessAlpha->SetTrackSecondariesFirst(true);
  theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
 
  // scintillation process for heavy nuclei
  G4bool theScintProcessNucNeverUsed = true;  
  G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
  // theScintProcessNuc->DumpPhysicsTable();
  theScintProcessNuc->SetTrackSecondariesFirst(true);
  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;
}

References G4ProcessManager::AddDiscreteProcess(), G4ProcessManager::AddProcess(), G4ParticleTable::GetIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), idxAtRest, idxPostStep, G4Scintillation::IsApplicable(), OpVerbLevel, G4ParticleTableIterator< K, V >::reset(), G4ProcessManager::SetProcessOrderingToLast(), G4Scintillation::SetTrackSecondariesFirst(), G4Scintillation::SetVerboseLevel(), G4OpAbsorption::SetVerboseLevel(), and G4OpBoundaryProcess::SetVerboseLevel().

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
}

References ConstructMyBaryons(), ConstructMyBosons(), ConstructMyIons(), ConstructMyLeptons(), ConstructMyMesons(), ConstructMyShortLiveds(), G4StoppingPhysics::ConstructParticle(), and stoppingPhysics.

ConstructProcess()

void LBE::ConstructProcess ( )

protectedvirtual

Reimplemented from G4VModularPhysicsList.

Definition at line 203 of file LBE.cc.

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

References AddTransportation(), ConstructEM(), ConstructGeneral(), ConstructHad(), and ConstructOp().

DisableCheckParticleList()

void G4VUserPhysicsList::DisableCheckParticleList ( )

inlineinherited

Definition at line 379 of file G4VUserPhysicsList.hh.

{
  fDisableCheckParticleList = true;
}

References G4VUserPhysicsList::fDisableCheckParticleList.

DumpCutValuesTable()

void G4VUserPhysicsList::DumpCutValuesTable ( G4int  flag = 1 )

inherited

Definition at line 916 of file G4VUserPhysicsList.cc.

{
  fDisplayThreshold = flag;
}

References fDisplayThreshold.

Referenced by G4RunManagerKernel::BuildPhysicsTables(), export_G4VUserPhysicsList(), PhysicsList::SetCuts(), SetCuts(), G4VUserPhysicsList::SetCuts(), and G4UserPhysicsListMessenger::SetNewValue().

DumpCutValuesTableIfRequested()

void G4VUserPhysicsList::DumpCutValuesTableIfRequested ( )

inherited

Definition at line 922 of file G4VUserPhysicsList.cc.

{
  if(fDisplayThreshold == 0)
    return;
  G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples();
  fDisplayThreshold = 0;
}

References G4ProductionCutsTable::DumpCouples(), fDisplayThreshold, and G4ProductionCutsTable::GetProductionCutsTable().

Referenced by G4RunManagerKernel::BuildPhysicsTables(), and export_G4VUserPhysicsList().

DumpList()

void G4VUserPhysicsList::DumpList ( ) const

inherited

Definition at line 895 of file G4VUserPhysicsList.cc.

{
  theParticleIterator->reset();
  G4int idx = 0;
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    G4cout << particle->GetParticleName();
    if((idx++ % 4) == 3)
    {
      G4cout << G4endl;
    }
    else
    {
      G4cout << ", ";
    }
  }
  G4cout << G4endl;
}

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), and theParticleIterator.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

GetApplyCuts()

G4bool G4VUserPhysicsList::GetApplyCuts ( const G4String &  name ) const

inherited

Definition at line 1054 of file G4VUserPhysicsList.cc.

{
  return theParticleTable->FindParticle(name)->GetApplyCutsFlag();
}

References G4ParticleTable::FindParticle(), G4ParticleDefinition::GetApplyCutsFlag(), G4InuclParticleNames::name(), and G4VUserPhysicsList::theParticleTable.

Referenced by export_G4VUserPhysicsList().

GetCutValue()

G4double G4VUserPhysicsList::GetCutValue ( const G4String &  pname ) const

inherited

Definition at line 421 of file G4VUserPhysicsList.cc.

{
  std::size_t nReg = (G4RegionStore::GetInstance())->size();
  if(nReg == 0)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::GetCutValue "
             << " : No Default Region " << G4endl;
    }
#endif
    G4Exception("G4VUserPhysicsList::GetCutValue", "Run0253", FatalException,
                "No Default Region");
    return -1. * mm;
  }
  G4Region* region =
    G4RegionStore::GetInstance()->GetRegion("DefaultRegionForTheWorld", false);
  return region->GetProductionCuts()->GetProductionCut(name);
}

References FatalException, G4cout, G4endl, G4Exception(), G4RegionStore::GetInstance(), G4ProductionCuts::GetProductionCut(), G4Region::GetProductionCuts(), G4RegionStore::GetRegion(), mm, G4InuclParticleNames::name(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::SetCuts(), and G4UserPhysicsListMessenger::SetNewValue().

GetDefaultCutValue()

G4double G4VUserPhysicsList::GetDefaultCutValue ( ) const

inlineinherited

Definition at line 337 of file G4VUserPhysicsList.hh.

{
  return defaultCutValue;
}

References G4VUserPhysicsList::defaultCutValue.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

GetInstanceID()

G4int G4VModularPhysicsList::GetInstanceID ( ) const

inlineinherited

Definition at line 153 of file G4VModularPhysicsList.hh.

{
  return g4vmplInstanceID;
}

References G4VModularPhysicsList::g4vmplInstanceID.

Referenced by G4VModularPhysicsList::operator=().

GetParticleIterator()

G4ParticleTable::G4PTblDicIterator * G4VUserPhysicsList::GetParticleIterator ( ) const

protectedinherited

Definition at line 1089 of file G4VUserPhysicsList.cc.

{
  return (subInstanceManager.offset[g4vuplInstanceID])._theParticleIterator;
}

References G4VUserPhysicsList::g4vuplInstanceID, G4VUPLSplitter< T >::offset, and G4VUserPhysicsList::subInstanceManager.

Referenced by G4ErrorPhysicsList::ConstructEM(), and G4ErrorPhysicsList::ConstructProcess().

GetPhysics() [1/2]

const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysics ( const G4String &  name ) const

inherited

Definition at line 390 of file G4VModularPhysicsList.cc.

{
  auto itr = G4MT_physicsVector->cbegin();
  for(; itr != G4MT_physicsVector->cend(); ++itr)
  {
    if(name == (*itr)->GetPhysicsName())
      break;
  }
  if(itr != G4MT_physicsVector->cend())
    return (*itr);
  else
    return nullptr;
}

References G4MT_physicsVector, and G4InuclParticleNames::name().

GetPhysics() [2/2]

const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysics ( G4int  index ) const

inherited

Definition at line 378 of file G4VModularPhysicsList.cc.

{
  auto itr = G4MT_physicsVector->cbegin();
  for(G4int i = 0; i < idx && itr != G4MT_physicsVector->cend(); ++i)
    ++itr;
  if(itr != G4MT_physicsVector->cend())
    return (*itr);
  else
    return nullptr;
}

References G4MT_physicsVector.

GetPhysicsTableDirectory()

const G4String & G4VUserPhysicsList::GetPhysicsTableDirectory ( ) const

inlineinherited

Definition at line 357 of file G4VUserPhysicsList.hh.

{
  return directoryPhysicsTable;
}

References G4VUserPhysicsList::directoryPhysicsTable.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

GetPhysicsWithType()

const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysicsWithType ( G4int  physics_type ) const

inherited

Definition at line 406 of file G4VModularPhysicsList.cc.

{
  auto itr = G4MT_physicsVector->cbegin();
  for(; itr != G4MT_physicsVector->cend(); ++itr)
  {
    if(pType == (*itr)->GetPhysicsType())
      break;
  }
  if(itr != G4MT_physicsVector->cend())
    return (*itr);
  else
    return nullptr;
}

References G4MT_physicsVector.

GetSubInstanceManager()

const G4VMPLManager & G4VModularPhysicsList::GetSubInstanceManager ( )

inlinestaticinherited

Definition at line 158 of file G4VModularPhysicsList.hh.

{
  return G4VMPLsubInstanceManager;
}

References G4VModularPhysicsList::G4VMPLsubInstanceManager.

Referenced by G4PhysicsListWorkspace::G4PhysicsListWorkspace().

GetVerboseLevel()

G4int G4VModularPhysicsList::GetVerboseLevel ( ) const

inlineinherited

Definition at line 148 of file G4VModularPhysicsList.hh.

{
  return verboseLevel;
}

References G4VModularPhysicsList::verboseLevel.

Referenced by G4PhysListRegistry::GetModularPhysicsList(), and G4PhysListFactoryMessenger::SetNewValue().

InitializeProcessManager()

void G4VUserPhysicsList::InitializeProcessManager ( )

protectedinherited

Definition at line 217 of file G4VUserPhysicsList.cc.

{
  // Request lock for particle table access. Some changes are inside
  // this critical region.
#ifdef G4MULTITHREADED
  G4MUTEXLOCK(&G4ParticleTable::particleTableMutex());
  G4ParticleTable::lockCount()++;
#endif
  G4ParticleDefinition* gion =
    G4ParticleTable::GetParticleTable()->GetGenericIon();
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    G4ProcessManager* pmanager     = particle->GetProcessManager();
 
    if(pmanager == nullptr)
    {
      // create process manager if the particle does not have its own.
      pmanager = new G4ProcessManager(particle);
      particle->SetProcessManager(pmanager);
      if(particle->GetMasterProcessManager() == nullptr)
        particle->SetMasterProcessManager(pmanager);
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::InitializeProcessManager: creating "
                  "ProcessManager to "
               << particle->GetParticleName() << G4endl;
      }
#endif
    }
  }
 
  if(gion != nullptr)
  {
    G4ProcessManager* gionPM = gion->GetProcessManager();
    // loop over all particles once again (this time, with all general ions)
    theParticleIterator->reset(false);
    while((*theParticleIterator)())
    {
      G4ParticleDefinition* particle = theParticleIterator->value();
      if(particle->IsGeneralIon())
      {
        particle->SetProcessManager(gionPM);
#ifdef G4VERBOSE
        if(verboseLevel > 2)
        {
          G4cout << "G4VUserPhysicsList::InitializeProcessManager: copying "
                    "ProcessManager to "
                 << particle->GetParticleName() << G4endl;
        }
#endif
      }
    }
  }
 
  // release lock for particle table access
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex());
#endif
}

References G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, G4ParticleTable::GetGenericIon(), G4ParticleDefinition::GetMasterProcessManager(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::IsGeneralIon(), G4ParticleDefinition::SetMasterProcessManager(), G4ParticleDefinition::SetProcessManager(), theParticleIterator, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::Construct().

InitializeWorker()

void G4VUserPhysicsList::InitializeWorker ( )

virtualinherited

Definition at line 117 of file G4VUserPhysicsList.cc.

{
  // Remember messengers are per-thread, so this needs to be done by each
  // worker and due to the presence of "this" cannot be done in
  // G4VUPLData::initialize()
  G4MT_theMessenger = new G4UserPhysicsListMessenger(this);
}

References G4MT_theMessenger.

Referenced by G4WorkerRunManager::SetUserInitialization().

IsPhysicsTableRetrieved()

G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved ( ) const

inlineinherited

Definition at line 347 of file G4VUserPhysicsList.hh.

{
  return fRetrievePhysicsTable;
}

References G4VUserPhysicsList::fRetrievePhysicsTable.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

IsStoredInAscii()

G4bool G4VUserPhysicsList::IsStoredInAscii ( ) const

inlineinherited

Definition at line 352 of file G4VUserPhysicsList.hh.

{
  return fStoredInAscii;
}

References G4VUserPhysicsList::fStoredInAscii.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

operator=()

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

delete

PreparePhysicsTable()

void G4VUserPhysicsList::PreparePhysicsTable ( G4ParticleDefinition *  particle )

inherited

Definition at line 793 of file G4VUserPhysicsList.cc.

{
  if (auto *trackingManager = particle->GetTrackingManager())
  {
    trackingManager->PreparePhysicsTable(*particle);
    return;
  }
 
  if(!(particle->GetMasterProcessManager()))
  {
    return;
  }
  // Prepare the physics tables for every process for this particle type
  // if particle is not ShortLived
  if(!particle->IsShortLived())
  {
    G4ProcessManager* pManager = particle->GetProcessManager();
    if(pManager == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::PreparePhysicsTable  "
               << ": No Process Manager for " << particle->GetParticleName()
               << G4endl;
        G4cout << particle->GetParticleName()
               << " should be created in your PhysicsList" << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::PreparePhysicsTable", "Run0273",
                  FatalException, "No process manager");
      return;
    }
 
    // Get processes from master thread
    G4ProcessManager* pManagerShadow = particle->GetMasterProcessManager();
 
    G4ProcessVector* pVector = pManager->GetProcessList();
    if(pVector == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::PreparePhysicsTable  "
               << ": No Process Vector for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::PreparePhysicsTable", "Run0274",
                  FatalException, "No process Vector");
      return;
    }
    for(std::size_t j = 0; j < pVector->size(); ++j)
    {
      // Andrea July 16th 2013 : migration to new interface...
      // Infer if we are in a worker thread or master thread
      // Master thread is the one in which the process manager
      // and process manager shadow pointers are the same
      if(pManagerShadow == pManager)
      {
        (*pVector)[j]->PreparePhysicsTable(*particle);
      }
      else
      {
        (*pVector)[j]->PrepareWorkerPhysicsTable(*particle);
      }
    }  // End loop on processes vector
  }    // End if pn ShortLived
}

References FatalException, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetMasterProcessManager(), G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::GetTrackingManager(), G4ParticleDefinition::IsShortLived(), G4ProcessVector::size(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), and G4UserPhysicsListMessenger::SetNewValue().

RegisterPhysics()

void G4VModularPhysicsList::RegisterPhysics ( G4VPhysicsConstructor *  fPhysics )

inherited

Definition at line 150 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RegisterPhysics", "Run0201",
                JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  G4String pName = fPhysics->GetPhysicsName();
  G4int pType    = fPhysics->GetPhysicsType();
  // If physics_type is equal to 0,
  // following duplication check is omitted
  // This is TEMPORAL treatment.
  if(pType == 0)
  {
    G4MT_physicsVector->push_back(fPhysics);
#ifdef G4VERBOSE
    if(verboseLevel > 1)
    {
      G4cout << "G4VModularPhysicsList::RegisterPhysics: " << pName
             << " with type : " << pType << " is added" << G4endl;
    }
#endif
    return;
  }
 
  // Check if physics with the physics_type same as one of given physics
  auto itr = G4MT_physicsVector->cbegin();
  for(; itr != G4MT_physicsVector->cend(); ++itr)
  {
    if(pType == (*itr)->GetPhysicsType())
      break;
  }
  if(itr != G4MT_physicsVector->cend())
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VModularPhysicsList::RegisterPhysics: "
             << "a physics with given type already exists " << G4endl;
      G4cout << " Type = " << pType << " : "
             << "  existing physics is " << (*itr)->GetPhysicsName() << G4endl;
      G4cout << " New " << pName << " can not be registered " << G4endl;
    }
#endif
    G4String comment = "Duplicate type for ";
    comment += pName;
    G4Exception("G4VModularPhysicsList::RegisterPhysics", "Run0202",
                JustWarning, comment);
    return;
  }
 
  // register
  G4MT_physicsVector->push_back(fPhysics);
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4VPhysicsConstructor::GetPhysicsName(), G4VPhysicsConstructor::GetPhysicsType(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

Referenced by export_G4VModularPhysicsList(), FTF_BIC::FTF_BIC(), FTFP_BERT::FTFP_BERT(), FTFP_BERT_ATL::FTFP_BERT_ATL(), FTFP_BERT_HP::FTFP_BERT_HP(), FTFP_BERT_TRV::FTFP_BERT_TRV(), FTFQGSP_BERT::FTFQGSP_BERT(), G4PhysListRegistry::GetModularPhysicsList(), NuBeam::NuBeam(), QBBC::QBBC(), QGS_BIC::QGS_BIC(), QGSP_BERT::QGSP_BERT(), QGSP_BERT_HP::QGSP_BERT_HP(), QGSP_BIC::QGSP_BIC(), QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), QGSP_FTFP_BERT::QGSP_FTFP_BERT(), QPhysicsList::QPhysicsList(), G4PhysListFactoryMessenger::SetNewValue(), and Shielding::Shielding().

RegisterProcess()

G4bool G4VUserPhysicsList::RegisterProcess ( G4VProcess *  process, G4ParticleDefinition *  particle  )

protectedinherited

Definition at line 1081 of file G4VUserPhysicsList.cc.

{
  return G4MT_thePLHelper->RegisterProcess(process, particle);
}

References G4MT_thePLHelper.

RemovePhysics() [1/3]

void G4VModularPhysicsList::RemovePhysics ( const G4String &  name )

inherited

Definition at line 343 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0206", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend();)
  {
    G4String pName = (*itr)->GetPhysicsName();
    if(name == pName)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName
               << " is removed" << G4endl;
      }
#endif
      G4MT_physicsVector->erase(itr);
      break;
    }
    else
    {
      ++itr;
    }
  }
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), JustWarning, G4InuclParticleNames::name(), and G4VModularPhysicsList::verboseLevel.

RemovePhysics() [2/3]

void G4VModularPhysicsList::RemovePhysics ( G4int  type )

inherited

Definition at line 273 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0204", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend();)
  {
    if(pType == (*itr)->GetPhysicsType())
    {
      G4String pName = (*itr)->GetPhysicsName();
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName
               << " is removed" << G4endl;
      }
#endif
      G4MT_physicsVector->erase(itr);
      break;
    }
    else
    {
      ++itr;
    }
  }
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

RemovePhysics() [3/3]

void G4VModularPhysicsList::RemovePhysics ( G4VPhysicsConstructor *  fPhysics )

inherited

Definition at line 308 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0205", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend();)
  {
    if(fPhysics == (*itr))
    {
      G4String pName = (*itr)->GetPhysicsName();
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName
               << " is removed" << G4endl;
      }
#endif
      G4MT_physicsVector->erase(itr);
      break;
    }
    else
    {
      ++itr;
    }
  }
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

RemoveProcessManager()

void G4VUserPhysicsList::RemoveProcessManager ( )

inherited

Definition at line 283 of file G4VUserPhysicsList.cc.

{
  // Request lock for particle table access. Some changes are inside
  // this critical region.
#ifdef G4MULTITHREADED
  G4MUTEXLOCK(&G4ParticleTable::particleTableMutex());
  G4ParticleTable::lockCount()++;
#endif
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    if(particle->GetInstanceID() <
       G4ParticleDefinitionSubInstanceManager::slavetotalspace())
    {
      if(particle->GetParticleSubType() != "generic" ||
         particle->GetParticleName() == "GenericIon")
      {
        G4ProcessManager* pmanager = particle->GetProcessManager();
        if(pmanager != nullptr)
          delete pmanager;
#ifdef G4VERBOSE
        if(verboseLevel > 2)
        {
          G4cout << "G4VUserPhysicsList::RemoveProcessManager: ";
          G4cout << "remove ProcessManager from ";
          G4cout << particle->GetParticleName() << G4endl;
        }
#endif
      }
      particle->SetProcessManager(nullptr);
    }
  }
 
  // release lock for particle table access
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex());
#endif
}

References G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, G4ParticleDefinition::GetInstanceID(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::SetProcessManager(), G4PDefManager::slavetotalspace(), theParticleIterator, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::TerminateWorker(), and G4VUserPhysicsList::~G4VUserPhysicsList().

RemoveTrackingManager()

void G4VUserPhysicsList::RemoveTrackingManager ( )

inherited

Definition at line 326 of file G4VUserPhysicsList.cc.

{
  // One tracking manager may be registered for multiple particles, make sure
  // to delete every object only once.
  std::unordered_set<G4VTrackingManager *> trackingManagers;
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    if (auto *trackingManager = particle->GetTrackingManager())
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::RemoveTrackingManager: ";
        G4cout << "remove TrackingManager from ";
        G4cout << particle->GetParticleName() << G4endl;
      }
#endif
      trackingManagers.insert(trackingManager);
      particle->SetTrackingManager(nullptr);
    }
  }
 
  for (G4VTrackingManager *tm : trackingManagers)
  {
    delete tm;
  }
}

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetTrackingManager(), G4ParticleDefinition::SetTrackingManager(), theParticleIterator, G4InuclParticleNames::tm, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::TerminateWorker(), and G4VUserPhysicsList::~G4VUserPhysicsList().

ReplacePhysics()

void G4VModularPhysicsList::ReplacePhysics ( G4VPhysicsConstructor *  fPhysics )

inherited

Definition at line 211 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::ReplacePhysics", "Run0203", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  G4String pName = fPhysics->GetPhysicsName();
  G4int pType    = fPhysics->GetPhysicsType();
  // If physics_type is equal to 0,
  // duplication check is omitted and just added.
  // This is TEMPORAL treatment.
  if(pType == 0)
  {
    // register
    G4MT_physicsVector->push_back(fPhysics);
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VModularPhysicsList::ReplacePhysics: " << pName
             << " with type : " << pType << " is added" << G4endl;
    }
#endif
    return;
  }
 
  // Check if physics with the physics_type same as one of given physics
  auto itr = G4MT_physicsVector->begin();
  for(; itr != G4MT_physicsVector->end(); ++itr)
  {
    if(pType == (*itr)->GetPhysicsType())
      break;
  }
  if(itr == G4MT_physicsVector->end())
  {
    // register
    G4MT_physicsVector->push_back(fPhysics);
  }
  else
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VModularPhysicsList::ReplacePhysics: "
             << (*itr)->GetPhysicsName() << " with type : " << pType
             << " is replaced with " << pName << G4endl;
    }
#endif
 
    //  delete exsiting one
    delete(*itr);
    // replace with given one
    (*itr) = fPhysics;
  }
  return;
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4VPhysicsConstructor::GetPhysicsName(), G4VPhysicsConstructor::GetPhysicsType(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

Referenced by G4PhysListRegistry::GetModularPhysicsList(), and G4PhysListFactory::GetReferencePhysList().

ResetPhysicsTableRetrieved()

void G4VUserPhysicsList::ResetPhysicsTableRetrieved ( )

inlineinherited

Definition at line 367 of file G4VUserPhysicsList.hh.

{
  fRetrievePhysicsTable             = false;
  fIsRestoredCutValues              = false;
  fIsCheckedForRetrievePhysicsTable = false;
}

References G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable, G4VUserPhysicsList::fIsRestoredCutValues, and G4VUserPhysicsList::fRetrievePhysicsTable.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

ResetStoredInAscii()

void G4VUserPhysicsList::ResetStoredInAscii ( )

inlineinherited

Definition at line 374 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = false;
}

References G4VUserPhysicsList::fStoredInAscii.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

RetrievePhysicsTable()

void G4VUserPhysicsList::RetrievePhysicsTable ( G4ParticleDefinition *  particle, const G4String &  directory, G4bool  ascii = false  )

protectedvirtualinherited

Definition at line 996 of file G4VUserPhysicsList.cc.

{
  G4bool success[100];
  // Retrieve physics tables for every process for this particle type
  G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
  for(std::size_t j = 0; j < pVector->size(); ++j)
  {
    success[j] =
      (*pVector)[j]->RetrievePhysicsTable(particle, directory, ascii);
 
    if(!success[j])
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::RetrievePhysicsTable   "
               << " Fail to retrieve Physics Table for "
               << (*pVector)[j]->GetProcessName() << G4endl;
        G4cout << "Calculate Physics Table for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      (*pVector)[j]->BuildPhysicsTable(*particle);
    }
  }
  for(std::size_t j = 0; j < pVector->size(); ++j)
  {
    // temporary addition to make the integral schema
    if(!success[j])
      BuildIntegralPhysicsTable((*pVector)[j], particle);
  }
}

References G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), G4ProcessVector::size(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::BuildPhysicsTable().

SetApplyCuts()

void G4VUserPhysicsList::SetApplyCuts ( G4bool  value, const G4String &  name  )

inherited

Definition at line 1032 of file G4VUserPhysicsList.cc.

{
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::SetApplyCuts for " << name << G4endl;
  }
#endif
  if(name == "all")
  {
    theParticleTable->FindParticle("gamma")->SetApplyCutsFlag(value);
    theParticleTable->FindParticle("e-")->SetApplyCutsFlag(value);
    theParticleTable->FindParticle("e+")->SetApplyCutsFlag(value);
    theParticleTable->FindParticle("proton")->SetApplyCutsFlag(value);
  }
  else
  {
    theParticleTable->FindParticle(name)->SetApplyCutsFlag(value);
  }
}

References G4ParticleTable::FindParticle(), G4cout, G4endl, G4InuclParticleNames::name(), G4ParticleDefinition::SetApplyCutsFlag(), G4VUserPhysicsList::theParticleTable, and G4VUserPhysicsList::verboseLevel.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetCuts()

void LBE::SetCuts ( )

virtual

Reimplemented from G4VUserPhysicsList.

Definition at line 952 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();
}

References cutForElectron, cutForGamma, cutForPositron, G4VUserPhysicsList::defaultCutValue, G4VUserPhysicsList::DumpCutValuesTable(), CLHEP::eV, G4BestUnit, G4cout, G4endl, G4ProductionCutsTable::GetProductionCutsTable(), CLHEP::GeV, G4VUserPhysicsList::SetCutValue(), G4ProductionCutsTable::SetEnergyRange(), and G4VModularPhysicsList::verboseLevel.

SetCutsForRegion()

void G4VUserPhysicsList::SetCutsForRegion ( G4double  aCut, const G4String &  rname  )

inherited

Definition at line 478 of file G4VUserPhysicsList.cc.

{
  // set cut values for gamma at first and for e- and e+
  SetCutValue(aCut, "gamma", rname);
  SetCutValue(aCut, "e-", rname);
  SetCutValue(aCut, "e+", rname);
  SetCutValue(aCut, "proton", rname);
}

References G4VUserPhysicsList::SetCutValue().

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

SetCutsWithDefault()

void G4VUserPhysicsList::SetCutsWithDefault ( )

inherited

Definition at line 471 of file G4VUserPhysicsList.cc.

{
  SetDefaultCutValue(defaultCutValue);
  G4VUserPhysicsList::SetCuts();
}

References G4VUserPhysicsList::defaultCutValue, G4VUserPhysicsList::SetCuts(), and G4VUserPhysicsList::SetDefaultCutValue().

Referenced by export_G4VUserPhysicsList(), PhysicsListEMstd::SetCuts(), ExN01PhysicsList::SetCuts(), QPhysicsList::SetCuts(), G4ErrorPhysicsList::SetCuts(), FTFP_BERT_HP::SetCuts(), and QGSP_BERT_HP::SetCuts().

SetCutValue() [1/2]

void G4VUserPhysicsList::SetCutValue ( G4double  aCut, const G4String &  pname  )

inherited

Definition at line 443 of file G4VUserPhysicsList.cc.

{
  SetParticleCuts(aCut, name);
}

References G4InuclParticleNames::name(), and G4VUserPhysicsList::SetParticleCuts().

Referenced by QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), PhysicsList::SetCuts(), FTFP_BERT_HP::SetCuts(), SetCuts(), QGSP_BERT_HP::SetCuts(), G4VUserPhysicsList::SetCutsForRegion(), G4VUserPhysicsList::SetDefaultCutValue(), G4UserPhysicsListMessenger::SetNewValue(), and Shielding::Shielding().

SetCutValue() [2/2]

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

inherited

Definition at line 449 of file G4VUserPhysicsList.cc.

{
  G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
  if(region != nullptr)
  {
    // set cut value
    SetParticleCuts(aCut, pname, region);
  }
  else
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::SetCutValue "
             << " : No Region of " << rname << G4endl;
    }
#endif
  }
}

References G4cout, G4endl, G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), eplot::pname, G4VUserPhysicsList::SetParticleCuts(), and G4VUserPhysicsList::verboseLevel.

SetDefaultCutValue()

void G4VUserPhysicsList::SetDefaultCutValue ( G4double  newCutValue )

inherited

Definition at line 387 of file G4VUserPhysicsList.cc.

{
  if(value < 0.0)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::SetDefaultCutValue: negative cut values"
             << "  :" << value / mm << "[mm]" << G4endl;
    }
#endif
    return;
  }
 
  defaultCutValue      = value;
  isSetDefaultCutValue = true;
 
  // set cut values for gamma at first and for e- and e+
  SetCutValue(defaultCutValue, "gamma");
  SetCutValue(defaultCutValue, "e-");
  SetCutValue(defaultCutValue, "e+");
  SetCutValue(defaultCutValue, "proton");
 
#ifdef G4VERBOSE
  if(verboseLevel > 1)
  {
    G4cout << "G4VUserPhysicsList::SetDefaultCutValue:"
           << "default cut value is changed to   :" << defaultCutValue / mm
           << "[mm]" << G4endl;
  }
#endif
}

References G4VUserPhysicsList::defaultCutValue, G4cout, G4endl, G4VUserPhysicsList::isSetDefaultCutValue, mm, G4VUserPhysicsList::SetCutValue(), and G4VUserPhysicsList::verboseLevel.

Referenced by export_G4VUserPhysicsList(), G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetCutsWithDefault(), G4UserPhysicsListMessenger::SetNewValue(), and G4VUserPhysicsList::SetParticleCuts().

SetParticleCuts() [1/2]

void G4VUserPhysicsList::SetParticleCuts ( G4double  cut, const G4String &  particleName, G4Region *  region = nullptr  )

inherited

Definition at line 496 of file G4VUserPhysicsList.cc.

{
  if(cut < 0.0)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::SetParticleCuts: negative cut values"
             << "  :" << cut / mm << "[mm]"
             << " for " << particleName << G4endl;
    }
#endif
    return;
  }
 
  G4Region* world_region =
    G4RegionStore::GetInstance()->GetRegion("DefaultRegionForTheWorld", false);
  if(region == nullptr)
  {
    std::size_t nReg = G4RegionStore::GetInstance()->size();
    if(nReg == 0)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::SetParticleCuts "
               << " : No Default Region " << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::SetParticleCuts ", "Run0254",
                  FatalException, "No Default Region");
      return;
    }
    region = world_region;
  }
 
  if(!isSetDefaultCutValue)
  {
    SetDefaultCutValue(defaultCutValue);
  }
 
  G4ProductionCuts* pcuts = region->GetProductionCuts();
  if(region != world_region &&
     pcuts == G4ProductionCutsTable::GetProductionCutsTable()
                ->GetDefaultProductionCuts())
  {  // This region had no unique cuts yet but shares the default cuts.
     // Need to create a new object before setting the value.
    pcuts =
      new G4ProductionCuts(*(G4ProductionCutsTable::GetProductionCutsTable()
                               ->GetDefaultProductionCuts()));
    region->SetProductionCuts(pcuts);
  }
  pcuts->SetProductionCut(cut, particleName);
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::SetParticleCuts: "
           << "  :" << cut / mm << "[mm]"
           << " for " << particleName << G4endl;
  }
#endif
}

References G4VUserPhysicsList::defaultCutValue, FatalException, G4cout, G4endl, G4Exception(), G4RegionStore::GetInstance(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4RegionStore::GetRegion(), G4VUserPhysicsList::isSetDefaultCutValue, mm, G4VUserPhysicsList::SetDefaultCutValue(), G4ProductionCuts::SetProductionCut(), G4Region::SetProductionCuts(), and G4VUserPhysicsList::verboseLevel.

SetParticleCuts() [2/2]

void G4VUserPhysicsList::SetParticleCuts ( G4double  cut, G4ParticleDefinition *  particle, G4Region *  region = nullptr  )

inherited

Definition at line 488 of file G4VUserPhysicsList.cc.

{
  SetParticleCuts(cut, particle->GetParticleName(), region);
}

References G4ParticleDefinition::GetParticleName(), and G4VUserPhysicsList::SetParticleCuts().

Referenced by PhysicsList::SetCutForElectron(), PhysicsList::SetCutForGamma(), PhysicsList::SetCutForPositron(), G4VUserPhysicsList::SetCutValue(), and G4VUserPhysicsList::SetParticleCuts().

SetPhysicsTableRetrieved()

void G4VUserPhysicsList::SetPhysicsTableRetrieved ( const G4String &  directory = "" )

inherited

Definition at line 984 of file G4VUserPhysicsList.cc.

{
  fRetrievePhysicsTable = true;
  if(!directory.empty())
  {
    directoryPhysicsTable = directory;
  }
  fIsCheckedForRetrievePhysicsTable = false;
  fIsRestoredCutValues              = false;
}

References G4VUserPhysicsList::directoryPhysicsTable, G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable, G4VUserPhysicsList::fIsRestoredCutValues, and G4VUserPhysicsList::fRetrievePhysicsTable.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetStoredInAscii()

void G4VUserPhysicsList::SetStoredInAscii ( )

inlineinherited

Definition at line 362 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = true;
}

References G4VUserPhysicsList::fStoredInAscii.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

SetVerboseLevel()

void G4VModularPhysicsList::SetVerboseLevel ( G4int  value )

inherited

Definition at line 422 of file G4VModularPhysicsList.cc.

{
  verboseLevel = value;
  // Loop over constructors
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend(); ++itr)
  {
    (*itr)->SetVerboseLevel(verboseLevel);
  }
}

References G4MT_physicsVector, and G4VModularPhysicsList::verboseLevel.

Referenced by FTF_BIC::FTF_BIC(), FTFP_BERT::FTFP_BERT(), FTFP_BERT_ATL::FTFP_BERT_ATL(), FTFP_BERT_HP::FTFP_BERT_HP(), FTFP_BERT_TRV::FTFP_BERT_TRV(), FTFQGSP_BERT::FTFQGSP_BERT(), G4PhysListRegistry::GetModularPhysicsList(), LBE(), NuBeam::NuBeam(), PhysicsList::PhysicsList(), QBBC::QBBC(), QGS_BIC::QGS_BIC(), QGSP_BERT::QGSP_BERT(), QGSP_BERT_HP::QGSP_BERT_HP(), QGSP_BIC::QGSP_BIC(), QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), QGSP_FTFP_BERT::QGSP_FTFP_BERT(), QPhysicsList::QPhysicsList(), and Shielding::Shielding().

StorePhysicsTable()

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

inherited

Definition at line 931 of file G4VUserPhysicsList.cc.

{
  G4bool ascii = fStoredInAscii;
  G4String dir = directory;
  if(dir.empty())
    dir = directoryPhysicsTable;
  else
    directoryPhysicsTable = dir;
 
  // store CutsTable info
  if(!fCutsTable->StoreCutsTable(dir, ascii))
  {
    G4Exception("G4VUserPhysicsList::StorePhysicsTable", "Run0281", JustWarning,
                "Fail to store Cut Table");
    return false;
  }
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::StorePhysicsTable   "
           << " Store material and cut values successfully" << G4endl;
  }
#endif
 
  G4bool success = true;
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    // Store physics tables for every process for this particle type
    G4ProcessVector* pVector =
      (particle->GetProcessManager())->GetProcessList();
    for(std::size_t j = 0; j < pVector->size(); ++j)
    {
      if(!(*pVector)[j]->StorePhysicsTable(particle, dir, ascii))
      {
        G4String comment = "Fail to store physics table for ";
        comment += (*pVector)[j]->GetProcessName();
        comment += "(" + particle->GetParticleName() + ")";
        G4Exception("G4VUserPhysicsList::StorePhysicsTable", "Run0282",
                    JustWarning, comment);
        success = false;
      }
    }
    // end loop over processes
  }
  // end loop over particles
  return success;
}

References G4VUserPhysicsList::directoryPhysicsTable, G4VUserPhysicsList::fCutsTable, G4VUserPhysicsList::fStoredInAscii, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), JustWarning, G4ProcessVector::size(), G4ProductionCutsTable::StoreCutsTable(), theParticleIterator, and G4VUserPhysicsList::verboseLevel.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

TerminateWorker()

void G4VModularPhysicsList::TerminateWorker ( )

overridevirtualinherited

Reimplemented from G4VUserPhysicsList.

Definition at line 434 of file G4VModularPhysicsList.cc.

{
  // See https://jira-geant4.kek.jp/browse/DEV-284
  std::for_each(
    G4MT_physicsVector->cbegin(), G4MT_physicsVector->cend(),
    [](G4PhysConstVector::value_type el) { el->TerminateWorker(); });
  G4VUserPhysicsList::TerminateWorker();
}

References G4MT_physicsVector, and G4VUserPhysicsList::TerminateWorker().

UseCoupledTransportation()

void G4VUserPhysicsList::UseCoupledTransportation ( G4bool  vl = true )

inherited

Definition at line 1075 of file G4VUserPhysicsList.cc.

{
  G4MT_thePLHelper->UseCoupledTransportation(vl);
}

References G4MT_thePLHelper.

Referenced by G4RunManagerKernel::InitializePhysics().

Field Documentation

cutForElectron

G4double LBE::cutForElectron

private

Definition at line 101 of file LBE.hh.

Referenced by LBE(), and SetCuts().

cutForGamma

G4double LBE::cutForGamma

private

Definition at line 100 of file LBE.hh.

Referenced by LBE(), and SetCuts().

cutForPositron

G4double LBE::cutForPositron

private

Definition at line 102 of file LBE.hh.

Referenced by LBE(), and SetCuts().

defaultCutValue

G4double G4VUserPhysicsList::defaultCutValue = 1.0

protectedinherited

Definition at line 285 of file G4VUserPhysicsList.hh.

Referenced by FTF_BIC::FTF_BIC(), FTFP_BERT::FTFP_BERT(), FTFP_BERT_ATL::FTFP_BERT_ATL(), FTFP_BERT_HP::FTFP_BERT_HP(), FTFP_BERT_TRV::FTFP_BERT_TRV(), FTFQGSP_BERT::FTFQGSP_BERT(), G4ErrorPhysicsList::G4ErrorPhysicsList(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetDefaultCutValue(), LBE(), NuBeam::NuBeam(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), PhysicsListEMstd::PhysicsListEMstd(), QBBC::QBBC(), QGS_BIC::QGS_BIC(), QGSP_BERT::QGSP_BERT(), QGSP_BERT_HP::QGSP_BERT_HP(), QGSP_BIC::QGSP_BIC(), QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), QGSP_FTFP_BERT::QGSP_FTFP_BERT(), QPhysicsList::QPhysicsList(), SetCuts(), G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetCutsWithDefault(), G4VUserPhysicsList::SetDefaultCutValue(), G4VUserPhysicsList::SetParticleCuts(), and Shielding::Shielding().

directoryPhysicsTable

G4String G4VUserPhysicsList::directoryPhysicsTable = "."

protectedinherited

Definition at line 299 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::GetPhysicsTableDirectory(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::SetPhysicsTableRetrieved(), and G4VUserPhysicsList::StorePhysicsTable().

fCutsTable

G4ProductionCutsTable* G4VUserPhysicsList::fCutsTable = nullptr

protectedinherited

Definition at line 289 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::SetVerboseLevel(), and G4VUserPhysicsList::StorePhysicsTable().

fDisableCheckParticleList

G4bool G4VUserPhysicsList::fDisableCheckParticleList = false

protectedinherited

Definition at line 302 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::CheckParticleList(), G4VUserPhysicsList::DisableCheckParticleList(), G4VModularPhysicsList::operator=(), and G4VUserPhysicsList::operator=().

fIsCheckedForRetrievePhysicsTable

G4bool G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable = false

protectedinherited

Definition at line 296 of file G4VUserPhysicsList.hh.

Referenced by G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetPhysicsTableRetrieved(), and G4VUserPhysicsList::SetPhysicsTableRetrieved().

fIsRestoredCutValues

G4bool G4VUserPhysicsList::fIsRestoredCutValues = false

protectedinherited

Definition at line 297 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetPhysicsTableRetrieved(), and G4VUserPhysicsList::SetPhysicsTableRetrieved().

fRetrievePhysicsTable

G4bool G4VUserPhysicsList::fRetrievePhysicsTable = false

protectedinherited

Definition at line 292 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::IsPhysicsTableRetrieved(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetPhysicsTableRetrieved(), and G4VUserPhysicsList::SetPhysicsTableRetrieved().

fStoredInAscii

G4bool G4VUserPhysicsList::fStoredInAscii = true

protectedinherited

Definition at line 294 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::IsStoredInAscii(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetStoredInAscii(), G4VUserPhysicsList::SetStoredInAscii(), and G4VUserPhysicsList::StorePhysicsTable().

g4vmplInstanceID

G4int G4VModularPhysicsList::g4vmplInstanceID = 0

protectedinherited

Definition at line 142 of file G4VModularPhysicsList.hh.

Referenced by G4VModularPhysicsList::G4VModularPhysicsList(), G4VModularPhysicsList::GetInstanceID(), and G4VModularPhysicsList::operator=().

G4VMPLsubInstanceManager

G4VMPLManager G4VModularPhysicsList::G4VMPLsubInstanceManager

staticprotectedinherited

Definition at line 143 of file G4VModularPhysicsList.hh.

Referenced by G4VModularPhysicsList::G4VModularPhysicsList(), G4VModularPhysicsList::GetSubInstanceManager(), and G4VModularPhysicsList::operator=().

g4vuplInstanceID

G4int G4VUserPhysicsList::g4vuplInstanceID = 0

protectedinherited

Definition at line 305 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetInstanceID(), G4VUserPhysicsList::GetParticleIterator(), and G4VModularPhysicsList::operator=().

isSetDefaultCutValue

G4bool G4VUserPhysicsList::isSetDefaultCutValue = false

protectedinherited

Definition at line 287 of file G4VUserPhysicsList.hh.

Referenced by G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetDefaultCutValue(), and G4VUserPhysicsList::SetParticleCuts().

OpVerbLevel

G4int LBE::OpVerbLevel

private

Definition at line 98 of file LBE.hh.

Referenced by ConstructOp(), and LBE().

stoppingPhysics

G4StoppingPhysics* LBE::stoppingPhysics

private

Definition at line 108 of file LBE.hh.

Referenced by ConstructHad(), ConstructParticle(), LBE(), and ~LBE().

subInstanceManager

G4VUPLManager G4VUserPhysicsList::subInstanceManager

staticprotectedinherited

Definition at line 306 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetParticleIterator(), G4VUserPhysicsList::GetSubInstanceManager(), and G4VModularPhysicsList::operator=().

theParticleTable

G4ParticleTable* G4VUserPhysicsList::theParticleTable = nullptr

protectedinherited

Definition at line 280 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetApplyCuts(), G4VUserPhysicsList::SetApplyCuts(), and G4VUserPhysicsList::~G4VUserPhysicsList().

VerboseLevel

G4int LBE::VerboseLevel

private

Definition at line 97 of file LBE.hh.

Referenced by ConstructGeneral(), and LBE().

verboseLevel

G4int G4VModularPhysicsList::verboseLevel = 0

protectedinherited

Definition at line 141 of file G4VModularPhysicsList.hh.

Referenced by PhysicsList::AddPhysicsList(), G4VModularPhysicsList::GetVerboseLevel(), G4VModularPhysicsList::operator=(), G4VModularPhysicsList::RegisterPhysics(), G4VModularPhysicsList::RemovePhysics(), G4VModularPhysicsList::ReplacePhysics(), FTFP_BERT_HP::SetCuts(), SetCuts(), QGSP_BERT_HP::SetCuts(), and G4VModularPhysicsList::SetVerboseLevel().

---

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

• source/physics_lists/lists/include/LBE.hh
• source/physics_lists/lists/src/LBE.cc