G4VUserPhysicsList Class Reference

#include <G4VUserPhysicsList.hh>

Inheritance diagram for G4VUserPhysicsList:

Public Member Functions
	G4VUserPhysicsList ()
virtual	~G4VUserPhysicsList ()
	G4VUserPhysicsList (const G4VUserPhysicsList &)
G4VUserPhysicsList &	operator= (const G4VUserPhysicsList &)
virtual void	ConstructParticle ()=0
void	Construct ()
virtual void	ConstructProcess ()=0
void	UseCoupledTransportation (G4bool vl=true)
virtual void	SetCuts ()
void	SetDefaultCutValue (G4double newCutValue)
G4double	GetDefaultCutValue () const
void	BuildPhysicsTable ()
void	PreparePhysicsTable (G4ParticleDefinition *)
void	BuildPhysicsTable (G4ParticleDefinition *)
G4bool	StorePhysicsTable (const G4String &directory=".")
G4bool	IsPhysicsTableRetrieved () const
G4bool	IsStoredInAscii () const
const G4String &	GetPhysicsTableDirectory () const
void	SetPhysicsTableRetrieved (const G4String &directory="")
void	SetStoredInAscii ()
void	ResetPhysicsTableRetrieved ()
void	ResetStoredInAscii ()
void	DumpList () const
void	DumpCutValuesTable (G4int flag=1)
void	DumpCutValuesTableIfRequested ()
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
void	SetCutsWithDefault ()
void	SetCutValue (G4double aCut, const G4String &pname)
G4double	GetCutValue (const G4String &pname) const
void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)
void	SetParticleCuts (G4double cut, G4ParticleDefinition *particle, G4Region *region=0)
void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=0)
void	SetCutsForRegion (G4double aCut, const G4String &rname)
void	ResetCuts ()
	obsolete methods
void	SetApplyCuts (G4bool value, const G4String &name)
G4bool	GetApplyCuts (const G4String &name) const
void	RemoveProcessManager ()
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=0)
void	CheckParticleList ()
void	DisableCheckParticleList ()

Protected Member Functions
void	AddTransportation ()
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
void	BuildIntegralPhysicsTable (G4VProcess *, G4ParticleDefinition *)
virtual void	RetrievePhysicsTable (G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)
void	InitializeProcessManager ()

Protected Attributes
G4ParticleTable *	theParticleTable
G4ParticleTable::G4PTblDicIterator *	theParticleIterator
G4UserPhysicsListMessenger *	theMessenger
G4int	verboseLevel
G4double	defaultCutValue
G4bool	isSetDefaultCutValue
G4ProductionCutsTable *	fCutsTable
G4bool	fRetrievePhysicsTable
G4bool	fStoredInAscii
G4bool	fIsCheckedForRetrievePhysicsTable
G4bool	fIsRestoredCutValues
G4String	directoryPhysicsTable
G4int	fDisplayThreshold
G4bool	fIsPhysicsTableBuilt
G4bool	fDisableCheckParticleList
G4PhysicsListHelper *	thePLHelper

Detailed Description

Definition at line 96 of file G4VUserPhysicsList.hh.

Constructor & Destructor Documentation

G4VUserPhysicsList() [1/2]

G4VUserPhysicsList::G4VUserPhysicsList

(

)

Definition at line 74 of file G4VUserPhysicsList.cc.

  :verboseLevel(1),
   defaultCutValue(1.0 * mm),
   isSetDefaultCutValue(false),
   fRetrievePhysicsTable(false),
   fStoredInAscii(true),
   fIsCheckedForRetrievePhysicsTable(false),
   fIsRestoredCutValues(false),
   directoryPhysicsTable("."),
   fDisplayThreshold(0),
   fIsPhysicsTableBuilt(false),
   fDisableCheckParticleList(false)
{
  // default cut value  (1.0mm)
  defaultCutValue = 1.0*mm;
 
  // pointer to the particle table
  theParticleTable = G4ParticleTable::GetParticleTable();
  theParticleIterator = theParticleTable->GetIterator();
 
  // pointer to the cuts table
  fCutsTable =  G4ProductionCutsTable::GetProductionCutsTable();
 
  // set energy range for SetCut calcuration
  fCutsTable->SetEnergyRange(0.99*keV, 100*TeV);
 
  // UI Messenger
  theMessenger = new G4UserPhysicsListMessenger(this);
 
  // PhysicsListHelper
  thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
  thePLHelper->SetVerboseLevel(verboseLevel);
 
}

~G4VUserPhysicsList()

G4VUserPhysicsList::~G4VUserPhysicsList ( )

virtual

Definition at line 110 of file G4VUserPhysicsList.cc.

{
  if (theMessenger != 0) {
    delete theMessenger;
    theMessenger = 0;
  }
  RemoveProcessManager();
 
  // invoke DeleteAllParticle
  theParticleTable->DeleteAllParticles();
 
}

G4VUserPhysicsList() [2/2]

G4VUserPhysicsList::G4VUserPhysicsList

(

const G4VUserPhysicsList &

right

)

Definition at line 124 of file G4VUserPhysicsList.cc.

  :verboseLevel(right.verboseLevel),
   defaultCutValue(right.defaultCutValue),
   isSetDefaultCutValue(right.isSetDefaultCutValue),
   fRetrievePhysicsTable(right.fRetrievePhysicsTable),
   fStoredInAscii(right.fStoredInAscii),
   fIsCheckedForRetrievePhysicsTable(right.fIsCheckedForRetrievePhysicsTable),
   fIsRestoredCutValues(right.fIsRestoredCutValues),
   directoryPhysicsTable(right.directoryPhysicsTable),
   fDisplayThreshold(right.fDisplayThreshold),
   fIsPhysicsTableBuilt(right.fIsPhysicsTableBuilt),
   fDisableCheckParticleList(right.fDisableCheckParticleList)
{
  // pointer to the particle table
  theParticleTable = G4ParticleTable::GetParticleTable();
  theParticleIterator = theParticleTable->GetIterator();
 
  // pointer to the cuts table
  fCutsTable =  G4ProductionCutsTable::GetProductionCutsTable();
 
  // UI Messenger
  theMessenger = new G4UserPhysicsListMessenger(this);
 
  // PhysicsListHelper
  thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
  thePLHelper->SetVerboseLevel(verboseLevel);
 
}

Member Function Documentation

AddProcessManager()

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

Definition at line 174 of file G4VUserPhysicsList.cc.

{
  if (newParticle == 0) return;
  if (newParticle->GetProcessManager() != 0) {
#ifdef G4VERBOSE
    if (verboseLevel >1){
      G4cout << "G4VUserPhysicsList::AddProcessManager: "
         << newParticle->GetParticleName()
         << " already has ProcessManager " << G4endl;
    }
#endif
    return;
  }
 
  // create new process manager if newManager  == 0
  if (newManager  == 0){
    // Add ProcessManager
    if (newParticle->GetParticleType() == "nucleus") {
      // Create a copy of the process manager of "GenericIon" in case of "nucleus"
      G4ParticleDefinition* genericIon =
       (G4ParticleTable::GetParticleTable())->FindParticle("GenericIon");
 
      if (genericIon != 0) {
    G4ProcessManager* ionMan = genericIon->GetProcessManager();
    if (ionMan != 0) {
      newManager = new G4ProcessManager(*ionMan);
    } else {
      // no process manager has been registered yet
      newManager = new G4ProcessManager(newParticle);
      G4Exception("G4VUserPhysicsList::AddProcessManager",
              "Run0251", RunMustBeAborted,
              "GenericIon has no ProcessMamanger");     
    }
      } else {
    // "GenericIon" does not exist
    newManager = new G4ProcessManager(newParticle);
    G4Exception("G4VUserPhysicsList::AddProcessManager",
            "Run0252", RunMustBeAborted,
            "GenericIon does not exist");   
      }
 
    } else {
      // create process manager for particles other than "nucleus"
      newManager = new G4ProcessManager(newParticle);
    }
  }
 
  // set particle type
  newManager->SetParticleType(newParticle);
 
  // add the process manager
  newParticle->SetProcessManager(newManager);
 
#ifdef G4VERBOSE
 if (verboseLevel >2){
    G4cout << "G4VUserPhysicsList::AddProcessManager: "
       << "adds ProcessManager to "
       << newParticle->GetParticleName() << G4endl;
    newManager->DumpInfo();
  }
#endif
  if ( fIsPhysicsTableBuilt
       && (newParticle->GetParticleType() == "nucleus")) {
    PreparePhysicsTable(newParticle);
    BuildPhysicsTable(newParticle);
  }
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

AddTransportation()

void G4VUserPhysicsList::AddTransportation ( )

protected

Definition at line 833 of file G4VUserPhysicsList.cc.

{   
  thePLHelper->AddTransportation();
}

Referenced by G4VModularPhysicsList::ConstructProcess().

BuildIntegralPhysicsTable()

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

protected

Definition at line 644 of file G4VUserPhysicsList.cc.

{
  //*********************************************************************
  // 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);
  }
}

Referenced by RetrievePhysicsTable().

BuildPhysicsTable() [1/2]

void G4VUserPhysicsList::BuildPhysicsTable

(

)

Definition at line 458 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;
 
}

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

BuildPhysicsTable() [2/2]

void G4VUserPhysicsList::BuildPhysicsTable

(

G4ParticleDefinition *

particle

)

Definition at line 527 of file G4VUserPhysicsList.cc.

{
  if (fRetrievePhysicsTable) {
    if ( !fIsRestoredCutValues){
      // fail to retreive cut tables
#ifdef G4VERBOSE
      if (verboseLevel>0){
    G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
           << "Physics table can not be retreived 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) {
#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;
    }
    G4ProcessVector* pVector = pManager->GetProcessList();
    if (!pVector) {
#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;
    }
    for (G4int j=0; j < pVector->size(); ++j) {
      (*pVector)[j]->BuildPhysicsTable(*particle);
    }
  }
}

CheckParticleList()

void G4VUserPhysicsList::CheckParticleList

(

)

Definition at line 825 of file G4VUserPhysicsList.cc.

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

Referenced by G4RunManagerKernel::InitializePhysics().

Construct()

void G4VUserPhysicsList::Construct ( )

inline

Definition at line 333 of file G4VUserPhysicsList.hh.

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

Referenced by G4RunManagerKernel::InitializePhysics().

ConstructParticle()

virtual void G4VUserPhysicsList::ConstructParticle ( )

pure virtual

Implemented in G4ErrorPhysicsList, and G4VModularPhysicsList.

Referenced by G4RunManagerKernel::SetPhysics().

ConstructProcess()

virtual void G4VUserPhysicsList::ConstructProcess ( )

pure virtual

Implemented in G4ErrorPhysicsList, and G4VModularPhysicsList.

Referenced by Construct().

DisableCheckParticleList()

void G4VUserPhysicsList::DisableCheckParticleList ( )

inline

Definition at line 400 of file G4VUserPhysicsList.hh.

{
  fDisableCheckParticleList = true;
}

DumpCutValuesTable()

void G4VUserPhysicsList::DumpCutValuesTable

(

G4int

flag = 1

)

Definition at line 691 of file G4VUserPhysicsList.cc.

{ 
  fDisplayThreshold = flag; 
}

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

DumpCutValuesTableIfRequested()

void G4VUserPhysicsList::DumpCutValuesTableIfRequested

(

)

Definition at line 697 of file G4VUserPhysicsList.cc.

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

DumpList()

void G4VUserPhysicsList::DumpList

(

)

const

Definition at line 673 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;
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

GetApplyCuts()

G4bool G4VUserPhysicsList::GetApplyCuts

(

const G4String &

name

)

const

Definition at line 818 of file G4VUserPhysicsList.cc.

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

GetCutValue()

G4double G4VUserPhysicsList::GetCutValue

(

const G4String &

pname

)

const

Definition at line 342 of file G4VUserPhysicsList.cc.

{
  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()))[0];
  return region->GetProductionCuts()->GetProductionCut(name);
}

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

GetDefaultCutValue()

G4double G4VUserPhysicsList::GetDefaultCutValue ( ) const

inline

Definition at line 348 of file G4VUserPhysicsList.hh.

{
  return defaultCutValue;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

GetPhysicsTableDirectory()

const G4String & G4VUserPhysicsList::GetPhysicsTableDirectory ( ) const

inline

Definition at line 372 of file G4VUserPhysicsList.hh.

{
  return directoryPhysicsTable;  
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

GetVerboseLevel()

G4int G4VUserPhysicsList::GetVerboseLevel ( ) const

inline

Definition at line 354 of file G4VUserPhysicsList.hh.

{
  return  verboseLevel;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

InitializeProcessManager()

void G4VUserPhysicsList::InitializeProcessManager ( )

protected

Definition at line 245 of file G4VUserPhysicsList.cc.

{
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while( (*theParticleIterator)() ){
    G4ParticleDefinition* particle = theParticleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    if  (pmanager==0) {
      // create process manager if the particle has no its one
      pmanager = new G4ProcessManager(particle);
      particle->SetProcessManager(pmanager);
    }
  }
}

Referenced by Construct().

IsPhysicsTableRetrieved()

G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved ( ) const

inline

Definition at line 360 of file G4VUserPhysicsList.hh.

{
  return fRetrievePhysicsTable;  
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

IsStoredInAscii()

G4bool G4VUserPhysicsList::IsStoredInAscii ( ) const

inline

Definition at line 366 of file G4VUserPhysicsList.hh.

{
  return fStoredInAscii;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

operator=()

G4VUserPhysicsList & G4VUserPhysicsList::operator=

(

const G4VUserPhysicsList &

right

)

Definition at line 155 of file G4VUserPhysicsList.cc.

{
  if (this != &right) {
    verboseLevel   = right.verboseLevel;
    defaultCutValue = right.defaultCutValue;
    isSetDefaultCutValue = right.isSetDefaultCutValue;
    fRetrievePhysicsTable = right.fRetrievePhysicsTable;
    fStoredInAscii = right.fStoredInAscii;
    fIsCheckedForRetrievePhysicsTable = right.fIsCheckedForRetrievePhysicsTable;
    fIsRestoredCutValues = right.fIsRestoredCutValues;
    directoryPhysicsTable = right.directoryPhysicsTable;
    fDisplayThreshold = right.fDisplayThreshold;
    fIsPhysicsTableBuilt = right.fIsPhysicsTableBuilt;
    fDisableCheckParticleList = right.fDisableCheckParticleList;
  }
  return *this;
}

PreparePhysicsTable()

void G4VUserPhysicsList::PreparePhysicsTable

(

G4ParticleDefinition *

particle

)

Definition at line 601 of file G4VUserPhysicsList.cc.

{
  // 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) {
#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;
    }
    
    G4ProcessVector* pVector = pManager->GetProcessList();
    if (!pVector) {
#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 (G4int j=0; j < pVector->size(); ++j) {
      (*pVector)[j]->PreparePhysicsTable(*particle);
    }
  }
}

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

RegisterProcess()

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

protected

Definition at line 845 of file G4VUserPhysicsList.cc.

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

RemoveProcessManager()

void G4VUserPhysicsList::RemoveProcessManager

(

)

Definition at line 261 of file G4VUserPhysicsList.cc.

{
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while( (*theParticleIterator)() ){
    G4ParticleDefinition* particle = theParticleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    if  (pmanager!=0) delete pmanager;
    particle->SetProcessManager(0);
#ifdef G4VERBOSE
    if (verboseLevel >2){
      G4cout << "G4VUserPhysicsList::RemoveProcessManager: "
         << "remove ProcessManager from "
         << particle->GetParticleName() << G4endl;
    }
#endif
  }
}

Referenced by ~G4VUserPhysicsList().

ResetCuts()

void G4VUserPhysicsList::ResetCuts

(

)

obsolete methods

Definition at line 873 of file G4VUserPhysicsList.cc.

{
#ifdef G4VERBOSE  
  if (verboseLevel>0){
    G4cout << "G4VUserPhysicsList::ResetCuts() is obsolete."
       << " This method gives no effect and you can remove it. "<< G4endl;
  }
#endif
}

ResetPhysicsTableRetrieved()

void G4VUserPhysicsList::ResetPhysicsTableRetrieved ( )

inline

Definition at line 385 of file G4VUserPhysicsList.hh.

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

ResetStoredInAscii()

void G4VUserPhysicsList::ResetStoredInAscii ( )

inline

Definition at line 394 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = false;
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

RetrievePhysicsTable()

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

protectedvirtual

Definition at line 767 of file G4VUserPhysicsList.cc.

{
  G4int  j;
  G4bool success[100];  
  // Retrieve physics tables for every process for this particle type
  G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
  for ( 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 ( j=0; j < pVector->size(); ++j) {
    // temporary addition to make the integral schema
    if (!success[j]) BuildIntegralPhysicsTable((*pVector)[j], particle); 
  }
}

Referenced by BuildPhysicsTable().

SetApplyCuts()

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

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetCuts()

void G4VUserPhysicsList::SetCuts ( )

virtual

Reimplemented in G4ErrorPhysicsList, and QBBC.

Definition at line 282 of file G4VUserPhysicsList.cc.

{
  if ( !isSetDefaultCutValue ){
    SetDefaultCutValue(defaultCutValue);
  }
 
#ifdef G4VERBOSE
  if (verboseLevel >1){
    G4cout << "G4VUserPhysicsList::SetCuts:   " << G4endl;
    G4cout << "Cut for gamma: " << GetCutValue("gamma")/mm  
       << "[mm]" << G4endl;
    G4cout << "Cut  for e-: " << GetCutValue("e-")/mm  
       << "[mm]" << G4endl;
    G4cout << "Cut  for e+: " << GetCutValue("e+")/mm 
       << "[mm]" << G4endl;
    G4cout << "Cut  for proton: " << GetCutValue("proton")/mm  
       << "[mm]" << G4endl;
  }
#endif
 
  // dump Cut values if verboseLevel==3
  if (verboseLevel>2) {
    DumpCutValuesTable();
  }
}

Referenced by G4RunManagerKernel::InitializePhysics(), SetCutsWithDefault(), and G4UserPhysicsListMessenger::SetNewValue().

SetCutsForRegion()

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

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetCutsWithDefault()

void G4VUserPhysicsList::SetCutsWithDefault

(

)

Definition at line 387 of file G4VUserPhysicsList.cc.

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

Referenced by G4ErrorPhysicsList::SetCuts(), and QBBC::SetCuts().

SetCutValue() [1/2]

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

Definition at line 362 of file G4VUserPhysicsList.cc.

{
  SetParticleCuts( aCut ,name );
}

Referenced by SetCutsForRegion(), SetDefaultCutValue(), and G4UserPhysicsListMessenger::SetNewValue().

SetCutValue() [2/2]

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

Definition at line 368 of file G4VUserPhysicsList.cc.

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

SetDefaultCutValue()

void G4VUserPhysicsList::SetDefaultCutValue

(

G4double

newCutValue

)

Definition at line 310 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
 }

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

SetParticleCuts() [1/2]

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

Definition at line 412 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;
  }
 
  if(!region){
    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 = (*(G4RegionStore::GetInstance()))[0];
  }
 
  if ( !isSetDefaultCutValue ){
    SetDefaultCutValue(defaultCutValue);
  }
 
  G4ProductionCuts* pcuts = region->GetProductionCuts();
  pcuts->SetProductionCut(cut,particleName);
#ifdef G4VERBOSE
  if (verboseLevel>2){      
    G4cout << "G4VUserPhysicsList::SetParticleCuts: "
       << "  :" << cut/mm << "[mm]" 
       << " for "<< particleName << G4endl;
  }
#endif
}

SetParticleCuts() [2/2]

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

Definition at line 406 of file G4VUserPhysicsList.cc.

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

Referenced by SetCutValue(), and SetParticleCuts().

SetPhysicsTableRetrieved()

void G4VUserPhysicsList::SetPhysicsTableRetrieved

(

const G4String &

directory = ""

)

Definition at line 756 of file G4VUserPhysicsList.cc.

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetStoredInAscii()

void G4VUserPhysicsList::SetStoredInAscii ( )

inline

Definition at line 378 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = true;
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetVerboseLevel()

void G4VUserPhysicsList::SetVerboseLevel

(

G4int

value

)

Definition at line 852 of file G4VUserPhysicsList.cc.

{
  verboseLevel = value;
  // set verboseLevel for G4ProductionCutsTable same as one for G4VUserPhysicsList: 
  fCutsTable->SetVerboseLevel(verboseLevel);
 
  thePLHelper->SetVerboseLevel(verboseLevel);
 
#ifdef G4VERBOSE
  if (verboseLevel >1){
    G4cout << "G4VUserPhysicsList::SetVerboseLevel  :"
       << " Verbose level is set to " << verboseLevel << G4endl;
  }
#endif
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

StorePhysicsTable()

G4bool G4VUserPhysicsList::StorePhysicsTable

(

const G4String &

directory = "."

)

Definition at line 706 of file G4VUserPhysicsList.cc.

{
  G4bool   ascii = fStoredInAscii;
  G4String dir   = directory;
  if (dir.isNull()) 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();
    G4int  j;
    for ( 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;
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

UseCoupledTransportation()

void G4VUserPhysicsList::UseCoupledTransportation

(

G4bool

vl = true

)

Definition at line 839 of file G4VUserPhysicsList.cc.

{ 
  thePLHelper->UseCoupledTransportation(vl);
}

Referenced by G4RunManagerKernel::InitializePhysics().

Member Data Documentation

defaultCutValue

G4double G4VUserPhysicsList::defaultCutValue

protected

Definition at line 298 of file G4VUserPhysicsList.hh.

Referenced by G4ErrorPhysicsList::G4ErrorPhysicsList(), G4VUserPhysicsList(), GetDefaultCutValue(), G4VModularPhysicsList::operator=(), operator=(), QBBC::QBBC(), SetCuts(), SetCutsWithDefault(), SetDefaultCutValue(), and SetParticleCuts().

directoryPhysicsTable

G4String G4VUserPhysicsList::directoryPhysicsTable

protected

Definition at line 313 of file G4VUserPhysicsList.hh.

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

fCutsTable

G4ProductionCutsTable* G4VUserPhysicsList::fCutsTable

protected

Definition at line 303 of file G4VUserPhysicsList.hh.

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

fDisableCheckParticleList

G4bool G4VUserPhysicsList::fDisableCheckParticleList

protected

Definition at line 322 of file G4VUserPhysicsList.hh.

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

fDisplayThreshold

G4int G4VUserPhysicsList::fDisplayThreshold

protected

Definition at line 316 of file G4VUserPhysicsList.hh.

Referenced by DumpCutValuesTable(), DumpCutValuesTableIfRequested(), G4VModularPhysicsList::operator=(), and operator=().

fIsCheckedForRetrievePhysicsTable

G4bool G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable

protected

Definition at line 309 of file G4VUserPhysicsList.hh.

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

fIsPhysicsTableBuilt

G4bool G4VUserPhysicsList::fIsPhysicsTableBuilt

protected

Definition at line 319 of file G4VUserPhysicsList.hh.

Referenced by AddProcessManager(), BuildPhysicsTable(), G4VModularPhysicsList::operator=(), and operator=().

fIsRestoredCutValues

G4bool G4VUserPhysicsList::fIsRestoredCutValues

protected

Definition at line 310 of file G4VUserPhysicsList.hh.

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

fRetrievePhysicsTable

G4bool G4VUserPhysicsList::fRetrievePhysicsTable

protected

Definition at line 306 of file G4VUserPhysicsList.hh.

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

fStoredInAscii

G4bool G4VUserPhysicsList::fStoredInAscii

protected

Definition at line 307 of file G4VUserPhysicsList.hh.

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

isSetDefaultCutValue

G4bool G4VUserPhysicsList::isSetDefaultCutValue

protected

Definition at line 299 of file G4VUserPhysicsList.hh.

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

theMessenger

G4UserPhysicsListMessenger* G4VUserPhysicsList::theMessenger

protected

Definition at line 291 of file G4VUserPhysicsList.hh.

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

theParticleIterator

G4ParticleTable::G4PTblDicIterator* G4VUserPhysicsList::theParticleIterator

protected

Definition at line 287 of file G4VUserPhysicsList.hh.

Referenced by BuildPhysicsTable(), G4ErrorPhysicsList::ConstructEM(), G4ErrorPhysicsList::ConstructProcess(), DumpList(), G4VUserPhysicsList(), InitializeProcessManager(), RemoveProcessManager(), and StorePhysicsTable().

theParticleTable

G4ParticleTable* G4VUserPhysicsList::theParticleTable

protected

Definition at line 286 of file G4VUserPhysicsList.hh.

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

thePLHelper

G4PhysicsListHelper* G4VUserPhysicsList::thePLHelper

protected

Definition at line 325 of file G4VUserPhysicsList.hh.

Referenced by AddTransportation(), CheckParticleList(), G4VUserPhysicsList(), RegisterProcess(), SetVerboseLevel(), and UseCoupledTransportation().

verboseLevel

G4int G4VUserPhysicsList::verboseLevel

protected

Definition at line 294 of file G4VUserPhysicsList.hh.

Referenced by AddProcessManager(), BuildIntegralPhysicsTable(), BuildPhysicsTable(), Construct(), G4ErrorPhysicsList::ConstructProcess(), G4VUserPhysicsList(), GetCutValue(), GetVerboseLevel(), operator=(), PreparePhysicsTable(), RemoveProcessManager(), ResetCuts(), RetrievePhysicsTable(), SetApplyCuts(), SetCuts(), SetCutValue(), SetDefaultCutValue(), SetParticleCuts(), SetVerboseLevel(), and StorePhysicsTable().

---

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

• G4VUserPhysicsList.hh
• G4VUserPhysicsList.cc