G4VUserPhysicsList Class Reference

#include <G4VUserPhysicsList.hh>

Inheritance diagram for G4VUserPhysicsList:

G4ErrorPhysicsList G4VModularPhysicsList QBBC

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 ()
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::G4VUserPhysicsList (  ) 

Definition at line 74 of file G4VUserPhysicsList.cc.

References defaultCutValue, fCutsTable, G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4PhysicsListHelper::GetPhysicsListHelper(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::SetEnergyRange(), G4PhysicsListHelper::SetVerboseLevel(), theMessenger, theParticleIterator, theParticleTable, thePLHelper, and verboseLevel.

00075   :verboseLevel(1),
00076    defaultCutValue(1.0 * mm),
00077    isSetDefaultCutValue(false),
00078    fRetrievePhysicsTable(false),
00079    fStoredInAscii(true),
00080    fIsCheckedForRetrievePhysicsTable(false),
00081    fIsRestoredCutValues(false),
00082    directoryPhysicsTable("."),
00083    fDisplayThreshold(0),
00084    fIsPhysicsTableBuilt(false),
00085    fDisableCheckParticleList(false)
00086 {
00087   // default cut value  (1.0mm)
00088   defaultCutValue = 1.0*mm;
00089 
00090   // pointer to the particle table
00091   theParticleTable = G4ParticleTable::GetParticleTable();
00092   theParticleIterator = theParticleTable->GetIterator();
00093 
00094   // pointer to the cuts table
00095   fCutsTable =  G4ProductionCutsTable::GetProductionCutsTable();
00096 
00097   // set energy range for SetCut calcuration
00098   fCutsTable->SetEnergyRange(0.99*keV, 100*TeV);
00099 
00100   // UI Messenger
00101   theMessenger = new G4UserPhysicsListMessenger(this);
00102  
00103   // PhysicsListHelper
00104   thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
00105   thePLHelper->SetVerboseLevel(verboseLevel);
00106 
00107 }

G4VUserPhysicsList::~G4VUserPhysicsList (  )  [virtual]

Definition at line 110 of file G4VUserPhysicsList.cc.

References G4ParticleTable::DeleteAllParticles(), RemoveProcessManager(), theMessenger, and theParticleTable.

00111 {
00112   if (theMessenger != 0) {
00113     delete theMessenger;
00114     theMessenger = 0;
00115   }
00116   RemoveProcessManager();
00117 
00118   // invoke DeleteAllParticle
00119   theParticleTable->DeleteAllParticles();
00120 
00121 }

G4VUserPhysicsList::G4VUserPhysicsList ( const G4VUserPhysicsList &   ) 

Definition at line 124 of file G4VUserPhysicsList.cc.

References fCutsTable, G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), G4PhysicsListHelper::GetPhysicsListHelper(), G4ProductionCutsTable::GetProductionCutsTable(), G4PhysicsListHelper::SetVerboseLevel(), theMessenger, theParticleIterator, theParticleTable, thePLHelper, and verboseLevel.

00125   :verboseLevel(right.verboseLevel),
00126    defaultCutValue(right.defaultCutValue),
00127    isSetDefaultCutValue(right.isSetDefaultCutValue),
00128    fRetrievePhysicsTable(right.fRetrievePhysicsTable),
00129    fStoredInAscii(right.fStoredInAscii),
00130    fIsCheckedForRetrievePhysicsTable(right.fIsCheckedForRetrievePhysicsTable),
00131    fIsRestoredCutValues(right.fIsRestoredCutValues),
00132    directoryPhysicsTable(right.directoryPhysicsTable),
00133    fDisplayThreshold(right.fDisplayThreshold),
00134    fIsPhysicsTableBuilt(right.fIsPhysicsTableBuilt),
00135    fDisableCheckParticleList(right.fDisableCheckParticleList)
00136 {
00137   // pointer to the particle table
00138   theParticleTable = G4ParticleTable::GetParticleTable();
00139   theParticleIterator = theParticleTable->GetIterator();
00140 
00141   // pointer to the cuts table
00142   fCutsTable =  G4ProductionCutsTable::GetProductionCutsTable();
00143 
00144   // UI Messenger
00145   theMessenger = new G4UserPhysicsListMessenger(this);
00146  
00147   // PhysicsListHelper
00148   thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
00149   thePLHelper->SetVerboseLevel(verboseLevel);
00150 
00151 }

Member Function Documentation

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

Definition at line 174 of file G4VUserPhysicsList.cc.

References BuildPhysicsTable(), G4ProcessManager::DumpInfo(), fIsPhysicsTableBuilt, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetProcessManager(), PreparePhysicsTable(), RunMustBeAborted, G4ProcessManager::SetParticleType(), G4ParticleDefinition::SetProcessManager(), and verboseLevel.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00176 {
00177   if (newParticle == 0) return;
00178   if (newParticle->GetProcessManager() != 0) {
00179 #ifdef G4VERBOSE
00180     if (verboseLevel >1){
00181       G4cout << "G4VUserPhysicsList::AddProcessManager: "
00182              << newParticle->GetParticleName()
00183              << " already has ProcessManager " << G4endl;
00184     }
00185 #endif
00186     return;
00187   }
00188 
00189   // create new process manager if newManager  == 0
00190   if (newManager  == 0){
00191     // Add ProcessManager
00192     if (newParticle->GetParticleType() == "nucleus") {
00193       // Create a copy of the process manager of "GenericIon" in case of "nucleus"
00194       G4ParticleDefinition* genericIon =
00195            (G4ParticleTable::GetParticleTable())->FindParticle("GenericIon");
00196 
00197       if (genericIon != 0) {
00198         G4ProcessManager* ionMan = genericIon->GetProcessManager();
00199         if (ionMan != 0) {
00200           newManager = new G4ProcessManager(*ionMan);
00201         } else {
00202           // no process manager has been registered yet
00203           newManager = new G4ProcessManager(newParticle);
00204           G4Exception("G4VUserPhysicsList::AddProcessManager",
00205                       "Run0251", RunMustBeAborted,
00206                       "GenericIon has no ProcessMamanger");     
00207         }
00208       } else {
00209         // "GenericIon" does not exist
00210         newManager = new G4ProcessManager(newParticle);
00211         G4Exception("G4VUserPhysicsList::AddProcessManager",
00212                     "Run0252", RunMustBeAborted,
00213                     "GenericIon does not exist");       
00214       }
00215 
00216     } else {
00217       // create process manager for particles other than "nucleus"
00218       newManager = new G4ProcessManager(newParticle);
00219     }
00220   }
00221 
00222   // set particle type
00223   newManager->SetParticleType(newParticle);
00224 
00225   // add the process manager
00226   newParticle->SetProcessManager(newManager);
00227 
00228 #ifdef G4VERBOSE
00229  if (verboseLevel >2){
00230     G4cout << "G4VUserPhysicsList::AddProcessManager: "
00231            << "adds ProcessManager to "
00232            << newParticle->GetParticleName() << G4endl;
00233     newManager->DumpInfo();
00234   }
00235 #endif
00236   if ( fIsPhysicsTableBuilt
00237        && (newParticle->GetParticleType() == "nucleus")) {
00238     PreparePhysicsTable(newParticle);
00239     BuildPhysicsTable(newParticle);
00240   }
00241 }

void G4VUserPhysicsList::AddTransportation (  )  [protected]

Definition at line 833 of file G4VUserPhysicsList.cc.

References G4PhysicsListHelper::AddTransportation(), and thePLHelper.

Referenced by TLBE< T >::AddTransportation(), and G4VModularPhysicsList::ConstructProcess().

00834 {   
00835   thePLHelper->AddTransportation();
00836 }

void G4VUserPhysicsList::BuildIntegralPhysicsTable ( G4VProcess *  ,
G4ParticleDefinition *   
) [protected]

Definition at line 644 of file G4VUserPhysicsList.cc.

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

Referenced by RetrievePhysicsTable().

00646 {
00647   //*********************************************************************
00648   // temporary addition to make the integral schema of electromagnetic
00649   // processes work.
00650   //
00651 
00652   if ( (process->GetProcessName() == "Imsc") ||
00653        (process->GetProcessName() == "IeIoni") ||
00654        (process->GetProcessName() == "IeBrems") ||
00655        (process->GetProcessName() == "Iannihil") ||
00656        (process->GetProcessName() == "IhIoni") ||
00657        (process->GetProcessName() == "IMuIoni") ||
00658        (process->GetProcessName() == "IMuBrems") ||
00659        (process->GetProcessName() == "IMuPairProd")  ) {
00660 #ifdef G4VERBOSE
00661     if (verboseLevel>2){
00662       G4cout << "G4VUserPhysicsList::BuildIntegralPhysicsTable  "
00663              << " BuildPhysicsTable is invoked for "
00664              << process->GetProcessName()
00665              << "(" << particle->GetParticleName() << ")" << G4endl;
00666     }
00667 #endif
00668     process->BuildPhysicsTable(*particle);
00669   }
00670 }

void G4VUserPhysicsList::BuildPhysicsTable ( G4ParticleDefinition *   ) 

Definition at line 527 of file G4VUserPhysicsList.cc.

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

00528 {
00529   if (fRetrievePhysicsTable) {
00530     if ( !fIsRestoredCutValues){
00531       // fail to retreive cut tables
00532 #ifdef G4VERBOSE
00533       if (verboseLevel>0){
00534         G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
00535                << "Physics table can not be retreived and will be calculated "
00536                << G4endl;
00537       }
00538 #endif
00539       fRetrievePhysicsTable = false; 
00540 
00541     } else {
00542 #ifdef G4VERBOSE
00543       if (verboseLevel>2){
00544         G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
00545                << " Retrieve Physics Table for "
00546                << particle->GetParticleName() << G4endl;
00547       }
00548 #endif
00549       //  Retrieve PhysicsTable from files for proccesses
00550       RetrievePhysicsTable(particle, directoryPhysicsTable, fStoredInAscii);
00551     }
00552   }
00553 
00554 #ifdef G4VERBOSE
00555   if (verboseLevel>2){
00556     G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
00557            << "Calculate Physics Table for " 
00558            << particle->GetParticleName() << G4endl;
00559   }
00560 #endif
00561   // Rebuild the physics tables for every process for this particle type
00562   // if particle is not ShortLived
00563   if(!particle->IsShortLived()) {
00564     G4ProcessManager* pManager =  particle->GetProcessManager();
00565     if (!pManager) {
00566 #ifdef G4VERBOSE
00567       if (verboseLevel>0){
00568         G4cout << "G4VUserPhysicsList::BuildPhysicsTable "
00569                <<" : No Process Manager for "
00570                << particle->GetParticleName() << G4endl;
00571         G4cout << particle->GetParticleName() 
00572                << " should be created in your PhysicsList" <<G4endl;
00573       }
00574 #endif
00575       G4Exception("G4VUserPhysicsList::BuildPhysicsTable",
00576                   "Run0271", FatalException,  
00577                   "No process manager");
00578       return;
00579     }
00580     G4ProcessVector* pVector = pManager->GetProcessList();
00581     if (!pVector) {
00582 #ifdef G4VERBOSE
00583       if (verboseLevel>0){      
00584         G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
00585                <<" : No Process Vector for " 
00586                << particle->GetParticleName() <<G4endl;
00587       }
00588 #endif
00589       G4Exception("G4VUserPhysicsList::BuildPhysicsTable",
00590                   "Run0272", FatalException,
00591                   "No process Vector");
00592       return;
00593     }
00594     for (G4int j=0; j < pVector->size(); ++j) {
00595       (*pVector)[j]->BuildPhysicsTable(*particle);
00596     }
00597   }
00598 }

void G4VUserPhysicsList::BuildPhysicsTable (  ) 

Definition at line 458 of file G4VUserPhysicsList.cc.

References directoryPhysicsTable, fCutsTable, G4ParticleTable::FindParticle(), fIsPhysicsTableBuilt, fIsRestoredCutValues, fRetrievePhysicsTable, fStoredInAscii, G4cout, G4endl, G4Exception(), PreparePhysicsTable(), G4ParticleTableIterator< K, V >::reset(), G4ProductionCutsTable::RetrieveCutsTable(), RunMustBeAborted, theParticleIterator, theParticleTable, G4ParticleTableIterator< K, V >::value(), and verboseLevel.

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

00459 {
00460   //Prepare Physics table for all particles 
00461   theParticleIterator->reset();
00462   while( (*theParticleIterator)() ){
00463     G4ParticleDefinition* particle = theParticleIterator->value();
00464     PreparePhysicsTable(particle); 
00465   }
00466 
00467   // ask processes to prepare physics table 
00468   if (fRetrievePhysicsTable) {
00469     fIsRestoredCutValues = fCutsTable->RetrieveCutsTable(directoryPhysicsTable, fStoredInAscii);
00470     // check if retrieve Cut Table successfully
00471     if (!fIsRestoredCutValues) {
00472 #ifdef G4VERBOSE
00473       if (verboseLevel>0){
00474         G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
00475                << " Retrieve Cut Table failed !!" << G4endl;
00476       }
00477 #endif  
00478       G4Exception("G4VUserPhysicsList::BuildPhysicsTable",
00479                   "Run0255", RunMustBeAborted,
00480                   "Fail to retrieve Production Cut Table");
00481     } else {
00482 #ifdef G4VERBOSE
00483       if (verboseLevel>2){
00484         G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
00485                << "  Retrieve Cut Table successfully " << G4endl;
00486       }
00487 #endif 
00488     }     
00489   } else {
00490 #ifdef G4VERBOSE
00491     if (verboseLevel>2){
00492       G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
00493              << " does not retrieve Cut Table but calculate " << G4endl;
00494     } 
00495 #endif      
00496   }
00497 
00498   // Sets a value to particle
00499   // set cut values for gamma at first and for e- and e+
00500   G4String particleName;
00501   G4ParticleDefinition* GammaP = theParticleTable->FindParticle("gamma");
00502   if(GammaP) BuildPhysicsTable(GammaP);
00503   G4ParticleDefinition* EMinusP = theParticleTable->FindParticle("e-");
00504   if(EMinusP) BuildPhysicsTable(EMinusP);
00505   G4ParticleDefinition* EPlusP = theParticleTable->FindParticle("e+");
00506   if(EPlusP) BuildPhysicsTable(EPlusP);
00507   G4ParticleDefinition* ProtonP = theParticleTable->FindParticle("proton");
00508   if(ProtonP) BuildPhysicsTable(ProtonP);
00509 
00510 
00511   theParticleIterator->reset();
00512   while( (*theParticleIterator)() ){
00513     G4ParticleDefinition* particle = theParticleIterator->value();
00514     if( particle!=GammaP && 
00515         particle!=EMinusP && 
00516         particle!=EPlusP && 
00517         particle!=ProtonP   ){
00518       BuildPhysicsTable(particle); 
00519     }
00520   }
00521 
00522   // Set flag
00523   fIsPhysicsTableBuilt = true;
00524 
00525 }

void G4VUserPhysicsList::CheckParticleList (  ) 

Definition at line 825 of file G4VUserPhysicsList.cc.

References G4PhysicsListHelper::CheckParticleList(), fDisableCheckParticleList, and thePLHelper.

Referenced by G4RunManagerKernel::InitializePhysics().

00826 {
00827   if (! fDisableCheckParticleList ){
00828     thePLHelper->CheckParticleList();
00829   }
00830 }

void G4VUserPhysicsList::Construct (  )  [inline]

Definition at line 333 of file G4VUserPhysicsList.hh.

References ConstructProcess(), G4cout, G4endl, InitializeProcessManager(), and verboseLevel.

Referenced by G4RunManagerKernel::InitializePhysics().

00334 {
00335 #ifdef G4VERBOSE  
00336   if (verboseLevel >1) G4cout << "G4VUserPhysicsList::Construct()" << G4endl;  
00337 #endif
00338 
00339   InitializeProcessManager();
00340 
00341 #ifdef G4VERBOSE  
00342   if (verboseLevel >1) G4cout << "Construct processes " << G4endl;  
00343 #endif
00344   ConstructProcess();
00345 
00346 }

virtual void G4VUserPhysicsList::ConstructParticle (  )  [pure virtual]

Implemented in G4ErrorPhysicsList, and G4VModularPhysicsList.

Referenced by G4RunManagerKernel::SetPhysics().

virtual void G4VUserPhysicsList::ConstructProcess (  )  [pure virtual]

Implemented in G4ErrorPhysicsList, and G4VModularPhysicsList.

Referenced by Construct().

void G4VUserPhysicsList::DisableCheckParticleList (  )  [inline]

Definition at line 400 of file G4VUserPhysicsList.hh.

References fDisableCheckParticleList.

00401 {
00402   fDisableCheckParticleList = true;
00403 }

void G4VUserPhysicsList::DumpCutValuesTable ( G4int  flag = 1  ) 

Definition at line 691 of file G4VUserPhysicsList.cc.

References fDisplayThreshold.

Referenced by TLHEP_EMV< T >::SetCuts(), SetCuts(), and G4UserPhysicsListMessenger::SetNewValue().

00692 { 
00693   fDisplayThreshold = flag; 
00694 }

void G4VUserPhysicsList::DumpCutValuesTableIfRequested (  ) 

Definition at line 697 of file G4VUserPhysicsList.cc.

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

00698 {
00699   if(fDisplayThreshold==0) return;
00700   G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples();
00701   fDisplayThreshold = 0;
00702 }

void G4VUserPhysicsList::DumpList (  )  const

Definition at line 673 of file G4VUserPhysicsList.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleTableIterator< K, V >::reset(), theParticleIterator, and G4ParticleTableIterator< K, V >::value().

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00674 {
00675   theParticleIterator->reset();
00676   G4int idx = 0;
00677   while( (*theParticleIterator)() ){
00678     G4ParticleDefinition* particle = theParticleIterator->value();
00679     G4cout << particle->GetParticleName();
00680     if ((idx++ % 4) == 3) {
00681       G4cout << G4endl;
00682     } else {
00683       G4cout << ", ";
00684     }      
00685   }
00686   G4cout << G4endl;
00687 }

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

Definition at line 818 of file G4VUserPhysicsList.cc.

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

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

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

Definition at line 342 of file G4VUserPhysicsList.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4RegionStore::GetInstance(), G4ProductionCuts::GetProductionCut(), G4Region::GetProductionCuts(), and verboseLevel.

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

00343 {
00344   size_t nReg = (G4RegionStore::GetInstance())->size();
00345   if (nReg==0) {
00346 #ifdef G4VERBOSE
00347     if (verboseLevel>0){      
00348       G4cout << "G4VUserPhysicsList::GetCutValue "
00349              <<" : No Default Region " <<G4endl;
00350     }
00351 #endif
00352     G4Exception("G4VUserPhysicsList::GetCutValue",
00353                 "Run0253", FatalException,
00354                 "No Default Region");
00355     return -1.*mm;
00356   }
00357   G4Region* region = (*(G4RegionStore::GetInstance()))[0];
00358   return region->GetProductionCuts()->GetProductionCut(name);
00359 }

G4double G4VUserPhysicsList::GetDefaultCutValue (  )  const [inline]

Definition at line 348 of file G4VUserPhysicsList.hh.

References defaultCutValue.

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

00349 {
00350   return defaultCutValue;
00351 }

const G4String & G4VUserPhysicsList::GetPhysicsTableDirectory (  )  const [inline]

Definition at line 372 of file G4VUserPhysicsList.hh.

References directoryPhysicsTable.

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

00373 {
00374   return directoryPhysicsTable;  
00375 }

G4int G4VUserPhysicsList::GetVerboseLevel (  )  const [inline]

Reimplemented in G4VModularPhysicsList.

Definition at line 354 of file G4VUserPhysicsList.hh.

References verboseLevel.

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

00355 {
00356   return  verboseLevel;
00357 }

void G4VUserPhysicsList::InitializeProcessManager (  )  [protected]

Definition at line 245 of file G4VUserPhysicsList.cc.

References G4ParticleDefinition::GetProcessManager(), G4ParticleTableIterator< K, V >::reset(), G4ParticleDefinition::SetProcessManager(), theParticleIterator, and G4ParticleTableIterator< K, V >::value().

Referenced by Construct().

00246 {
00247   // loop over all particles in G4ParticleTable
00248   theParticleIterator->reset();
00249   while( (*theParticleIterator)() ){
00250     G4ParticleDefinition* particle = theParticleIterator->value();
00251     G4ProcessManager* pmanager = particle->GetProcessManager();
00252     if  (pmanager==0) {
00253       // create process manager if the particle has no its one
00254       pmanager = new G4ProcessManager(particle);
00255       particle->SetProcessManager(pmanager);
00256     }
00257   }
00258 }

G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved (  )  const [inline]

Definition at line 360 of file G4VUserPhysicsList.hh.

References fRetrievePhysicsTable.

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

00361 {
00362   return fRetrievePhysicsTable;  
00363 }

G4bool G4VUserPhysicsList::IsStoredInAscii (  )  const [inline]

Definition at line 366 of file G4VUserPhysicsList.hh.

References fStoredInAscii.

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

00367 {
00368   return fStoredInAscii;
00369 }

G4VUserPhysicsList & G4VUserPhysicsList::operator= ( const G4VUserPhysicsList &   ) 

Definition at line 155 of file G4VUserPhysicsList.cc.

References defaultCutValue, directoryPhysicsTable, fDisableCheckParticleList, fDisplayThreshold, fIsCheckedForRetrievePhysicsTable, fIsPhysicsTableBuilt, fIsRestoredCutValues, fRetrievePhysicsTable, fStoredInAscii, isSetDefaultCutValue, and verboseLevel.

00156 {
00157   if (this != &right) {
00158     verboseLevel   = right.verboseLevel;
00159     defaultCutValue = right.defaultCutValue;
00160     isSetDefaultCutValue = right.isSetDefaultCutValue;
00161     fRetrievePhysicsTable = right.fRetrievePhysicsTable;
00162     fStoredInAscii = right.fStoredInAscii;
00163     fIsCheckedForRetrievePhysicsTable = right.fIsCheckedForRetrievePhysicsTable;
00164     fIsRestoredCutValues = right.fIsRestoredCutValues;
00165     directoryPhysicsTable = right.directoryPhysicsTable;
00166     fDisplayThreshold = right.fDisplayThreshold;
00167     fIsPhysicsTableBuilt = right.fIsPhysicsTableBuilt;
00168     fDisableCheckParticleList = right.fDisableCheckParticleList;
00169   }
00170   return *this;
00171 }

void G4VUserPhysicsList::PreparePhysicsTable ( G4ParticleDefinition *   ) 

Definition at line 601 of file G4VUserPhysicsList.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::IsShortLived(), G4ProcessVector::size(), and verboseLevel.

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

00602 {
00603   // Prepare the physics tables for every process for this particle type
00604   // if particle is not ShortLived
00605   if(!particle->IsShortLived()) {
00606     G4ProcessManager* pManager =  particle->GetProcessManager();
00607     if (!pManager) {
00608 #ifdef G4VERBOSE
00609       if (verboseLevel>0) {
00610         G4cout<< "G4VUserPhysicsList::PreparePhysicsTable  "
00611               << ": No Process Manager for " 
00612               << particle->GetParticleName() <<G4endl;
00613         G4cout << particle->GetParticleName() 
00614                << " should be created in your PhysicsList" <<G4endl;
00615       }
00616 #endif
00617       G4Exception("G4VUserPhysicsList::PreparePhysicsTable",
00618                   "Run0273", FatalException, 
00619                   "No process manager");
00620       return;
00621     }
00622     
00623     G4ProcessVector* pVector = pManager->GetProcessList();
00624     if (!pVector) {
00625 #ifdef G4VERBOSE
00626       if (verboseLevel>0) {
00627         G4cout << "G4VUserPhysicsList::PreparePhysicsTable  "
00628                << ": No Process Vector for " 
00629                << particle->GetParticleName() <<G4endl;
00630       }
00631 #endif
00632       G4Exception("G4VUserPhysicsList::PreparePhysicsTable",
00633                   "Run0274", FatalException,
00634                   "No process Vector");
00635       return;
00636     }
00637     for (G4int j=0; j < pVector->size(); ++j) {
00638       (*pVector)[j]->PreparePhysicsTable(*particle);
00639     }
00640   }
00641 }

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

Definition at line 845 of file G4VUserPhysicsList.cc.

References G4PhysicsListHelper::RegisterProcess(), and thePLHelper.

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

void G4VUserPhysicsList::RemoveProcessManager (  ) 

Definition at line 261 of file G4VUserPhysicsList.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), G4ParticleTableIterator< K, V >::reset(), G4ParticleDefinition::SetProcessManager(), theParticleIterator, G4ParticleTableIterator< K, V >::value(), and verboseLevel.

Referenced by ~G4VUserPhysicsList().

00262 {
00263   // loop over all particles in G4ParticleTable
00264   theParticleIterator->reset();
00265   while( (*theParticleIterator)() ){
00266     G4ParticleDefinition* particle = theParticleIterator->value();
00267     G4ProcessManager* pmanager = particle->GetProcessManager();
00268     if  (pmanager!=0) delete pmanager;
00269     particle->SetProcessManager(0);
00270 #ifdef G4VERBOSE
00271     if (verboseLevel >2){
00272       G4cout << "G4VUserPhysicsList::RemoveProcessManager: "
00273              << "remove ProcessManager from "
00274              << particle->GetParticleName() << G4endl;
00275     }
00276 #endif
00277   }
00278 }

void G4VUserPhysicsList::ResetCuts (  ) 

obsolete methods

Definition at line 873 of file G4VUserPhysicsList.cc.

References G4cout, G4endl, and verboseLevel.

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

void G4VUserPhysicsList::ResetPhysicsTableRetrieved (  )  [inline]

Definition at line 385 of file G4VUserPhysicsList.hh.

References fIsCheckedForRetrievePhysicsTable, fIsRestoredCutValues, and fRetrievePhysicsTable.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00386 {
00387   fRetrievePhysicsTable = false;
00388   fIsRestoredCutValues = false;
00389   fIsCheckedForRetrievePhysicsTable=false;
00390 }

void G4VUserPhysicsList::ResetStoredInAscii (  )  [inline]

Definition at line 394 of file G4VUserPhysicsList.hh.

References fStoredInAscii.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00395 {
00396   fStoredInAscii = false;
00397 }

void G4VUserPhysicsList::RetrievePhysicsTable ( G4ParticleDefinition *  ,
const G4String &  directory,
G4bool  ascii = false 
) [protected, virtual]

Definition at line 767 of file G4VUserPhysicsList.cc.

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

Referenced by BuildPhysicsTable().

00770 {
00771   G4int  j;
00772   G4bool success[100];  
00773   // Retrieve physics tables for every process for this particle type
00774   G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
00775   for ( j=0; j < pVector->size(); ++j) {
00776     success[j] = 
00777        (*pVector)[j]->RetrievePhysicsTable(particle,directory,ascii);
00778 
00779     if (!success[j]) {
00780 #ifdef G4VERBOSE  
00781       if (verboseLevel>2){
00782         G4cout << "G4VUserPhysicsList::RetrievePhysicsTable   "
00783                << " Fail to retrieve Physics Table for "
00784                << (*pVector)[j]->GetProcessName() << G4endl;
00785         G4cout << "Calculate Physics Table for " 
00786                << particle->GetParticleName() << G4endl;
00787       }
00788 #endif
00789       (*pVector)[j]->BuildPhysicsTable(*particle);
00790     }
00791   }
00792   for ( j=0; j < pVector->size(); ++j) {
00793     // temporary addition to make the integral schema
00794     if (!success[j]) BuildIntegralPhysicsTable((*pVector)[j], particle); 
00795   }
00796 }

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

Definition at line 800 of file G4VUserPhysicsList.cc.

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00801 {
00802 #ifdef G4VERBOSE  
00803   if (verboseLevel>2){
00804     G4cout << "G4VUserPhysicsList::SetApplyCuts for " << name << G4endl;
00805   }
00806 #endif
00807   if(name=="all") {
00808     theParticleTable->FindParticle("gamma")->SetApplyCutsFlag(value);
00809     theParticleTable->FindParticle("e-")->SetApplyCutsFlag(value);
00810     theParticleTable->FindParticle("e+")->SetApplyCutsFlag(value);
00811     theParticleTable->FindParticle("proton")->SetApplyCutsFlag(value);
00812   } else {
00813     theParticleTable->FindParticle(name)->SetApplyCutsFlag(value);
00814   }
00815 }

void G4VUserPhysicsList::SetCuts (  )  [virtual]

Reimplemented in G4ErrorPhysicsList, and QBBC.

Definition at line 282 of file G4VUserPhysicsList.cc.

References defaultCutValue, DumpCutValuesTable(), G4cout, G4endl, GetCutValue(), isSetDefaultCutValue, SetDefaultCutValue(), and verboseLevel.

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

00283 {
00284   if ( !isSetDefaultCutValue ){
00285     SetDefaultCutValue(defaultCutValue);
00286   }
00287 
00288 #ifdef G4VERBOSE
00289   if (verboseLevel >1){
00290     G4cout << "G4VUserPhysicsList::SetCuts:   " << G4endl;
00291     G4cout << "Cut for gamma: " << GetCutValue("gamma")/mm  
00292            << "[mm]" << G4endl;
00293     G4cout << "Cut  for e-: " << GetCutValue("e-")/mm  
00294            << "[mm]" << G4endl;
00295     G4cout << "Cut  for e+: " << GetCutValue("e+")/mm 
00296            << "[mm]" << G4endl;
00297     G4cout << "Cut  for proton: " << GetCutValue("proton")/mm  
00298            << "[mm]" << G4endl;
00299   }
00300 #endif
00301 
00302   // dump Cut values if verboseLevel==3
00303   if (verboseLevel>2) {
00304     DumpCutValuesTable();
00305   }
00306 }

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

Definition at line 394 of file G4VUserPhysicsList.cc.

References SetCutValue().

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00395 {
00396   // set cut values for gamma at first and for e- and e+
00397   SetCutValue(aCut, "gamma", rname);
00398   SetCutValue(aCut, "e-", rname);
00399   SetCutValue(aCut, "e+", rname);
00400   SetCutValue(aCut, "proton", rname);
00401 }

void G4VUserPhysicsList::SetCutsWithDefault (  ) 

Definition at line 387 of file G4VUserPhysicsList.cc.

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

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

00388 {
00389   SetDefaultCutValue(defaultCutValue);
00390   G4VUserPhysicsList::SetCuts();
00391 }

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

Definition at line 369 of file G4VUserPhysicsList.cc.

References G4cout, G4endl, G4RegionStore::GetInstance(), and G4RegionStore::GetRegion().

00370 {
00371   G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
00372   if (region != 0){
00373     //set cut value
00374     SetParticleCuts( aCut ,pname, region );
00375   } else {
00376 #ifdef G4VERBOSE
00377     if (verboseLevel>0){      
00378       G4cout << "G4VUserPhysicsList::SetCutValue "
00379              <<" : No Region of " << rname << G4endl;
00380     }
00381 #endif
00382   }
00383 }

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

Definition at line 362 of file G4VUserPhysicsList.cc.

References SetParticleCuts().

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

00363 {
00364   SetParticleCuts( aCut ,name );
00365 }

void G4VUserPhysicsList::SetDefaultCutValue ( G4double  newCutValue  ) 

Definition at line 310 of file G4VUserPhysicsList.cc.

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

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

00311 {
00312   if (value<0.0) {
00313 #ifdef G4VERBOSE
00314     if (verboseLevel >0){
00315       G4cout << "G4VUserPhysicsList::SetDefaultCutValue: negative cut values"
00316              << "  :" << value/mm << "[mm]" << G4endl;
00317     }
00318 #endif
00319     return;
00320   }
00321 
00322   defaultCutValue = value;
00323   isSetDefaultCutValue = true;
00324   
00325   // set cut values for gamma at first and for e- and e+
00326   SetCutValue(defaultCutValue, "gamma");
00327   SetCutValue(defaultCutValue, "e-");
00328   SetCutValue(defaultCutValue, "e+");
00329   SetCutValue(defaultCutValue, "proton");    
00330 
00331 #ifdef G4VERBOSE
00332   if (verboseLevel >1){
00333     G4cout << "G4VUserPhysicsList::SetDefaultCutValue:"
00334            << "default cut value is changed to   :" 
00335            << defaultCutValue/mm << "[mm]" << G4endl;
00336   }
00337 #endif
00338  }

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

Definition at line 412 of file G4VUserPhysicsList.cc.

References defaultCutValue, FatalException, G4cout, G4endl, G4Exception(), G4RegionStore::GetInstance(), G4Region::GetProductionCuts(), isSetDefaultCutValue, SetDefaultCutValue(), G4ProductionCuts::SetProductionCut(), and verboseLevel.

00413 {
00414   if (cut<0.0) {
00415 #ifdef G4VERBOSE
00416     if (verboseLevel >0){
00417       G4cout << "G4VUserPhysicsList::SetParticleCuts: negative cut values"
00418              << "  :" << cut/mm << "[mm]" 
00419              << " for "<< particleName << G4endl;
00420     }
00421 #endif
00422     return;
00423   }
00424 
00425   if(!region){
00426     size_t nReg = (G4RegionStore::GetInstance())->size();
00427     if (nReg==0) {
00428 #ifdef G4VERBOSE
00429       if (verboseLevel>0){      
00430         G4cout << "G4VUserPhysicsList::SetParticleCuts "
00431                <<" : No Default Region " <<G4endl;
00432       }
00433 #endif
00434       G4Exception("G4VUserPhysicsList::SetParticleCuts ",
00435                   "Run0254", FatalException,
00436                 "No Default Region");
00437       return;
00438     }
00439     region = (*(G4RegionStore::GetInstance()))[0];
00440   }
00441 
00442   if ( !isSetDefaultCutValue ){
00443     SetDefaultCutValue(defaultCutValue);
00444   }
00445 
00446   G4ProductionCuts* pcuts = region->GetProductionCuts();
00447   pcuts->SetProductionCut(cut,particleName);
00448 #ifdef G4VERBOSE
00449   if (verboseLevel>2){      
00450     G4cout << "G4VUserPhysicsList::SetParticleCuts: "
00451            << "  :" << cut/mm << "[mm]" 
00452            << " for "<< particleName << G4endl;
00453   }
00454 #endif
00455 }

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

Definition at line 406 of file G4VUserPhysicsList.cc.

References G4ParticleDefinition::GetParticleName().

Referenced by SetCutValue().

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

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

Definition at line 756 of file G4VUserPhysicsList.cc.

References directoryPhysicsTable, fIsCheckedForRetrievePhysicsTable, fIsRestoredCutValues, fRetrievePhysicsTable, and G4String::isNull().

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00757 {
00758   fRetrievePhysicsTable = true;
00759   if(!directory.isNull()) {
00760     directoryPhysicsTable = directory;
00761   }
00762   fIsCheckedForRetrievePhysicsTable=false;
00763   fIsRestoredCutValues = false;
00764 }

void G4VUserPhysicsList::SetStoredInAscii (  )  [inline]

Definition at line 378 of file G4VUserPhysicsList.hh.

References fStoredInAscii.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00379 {
00380   fStoredInAscii = true;
00381 }

void G4VUserPhysicsList::SetVerboseLevel ( G4int  value  ) 

Reimplemented in G4VModularPhysicsList.

Definition at line 852 of file G4VUserPhysicsList.cc.

References fCutsTable, G4cout, G4endl, G4PhysicsListHelper::SetVerboseLevel(), G4ProductionCutsTable::SetVerboseLevel(), thePLHelper, and verboseLevel.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00853 {
00854   verboseLevel = value;
00855   // set verboseLevel for G4ProductionCutsTable same as one for G4VUserPhysicsList: 
00856   fCutsTable->SetVerboseLevel(verboseLevel);
00857 
00858   thePLHelper->SetVerboseLevel(verboseLevel);
00859 
00860 #ifdef G4VERBOSE
00861   if (verboseLevel >1){
00862     G4cout << "G4VUserPhysicsList::SetVerboseLevel  :"
00863            << " Verbose level is set to " << verboseLevel << G4endl;
00864   }
00865 #endif
00866 }

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

Definition at line 706 of file G4VUserPhysicsList.cc.

References directoryPhysicsTable, fCutsTable, fStoredInAscii, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), G4String::isNull(), JustWarning, G4ParticleTableIterator< K, V >::reset(), G4ProcessVector::size(), G4ProductionCutsTable::StoreCutsTable(), theParticleIterator, G4ParticleTableIterator< K, V >::value(), and verboseLevel.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

00707 {
00708   G4bool   ascii = fStoredInAscii;
00709   G4String dir   = directory;
00710   if (dir.isNull()) dir = directoryPhysicsTable; 
00711   else directoryPhysicsTable = dir; 
00712 
00713   // store CutsTable info
00714   if (!fCutsTable->StoreCutsTable(dir, ascii)) {
00715     G4Exception("G4VUserPhysicsList::StorePhysicsTable",
00716                 "Run0281", JustWarning,
00717                 "Fail to store Cut Table");     
00718     return false;
00719   }
00720 #ifdef G4VERBOSE  
00721   if (verboseLevel>2){
00722     G4cout << "G4VUserPhysicsList::StorePhysicsTable   "
00723            << " Store material and cut values successfully" << G4endl;
00724   }
00725 #endif
00726 
00727   G4bool success= true;
00728 
00729   // loop over all particles in G4ParticleTable 
00730   theParticleIterator->reset();
00731   while( (*theParticleIterator)() ){
00732     G4ParticleDefinition* particle = theParticleIterator->value();
00733     // Store physics tables for every process for this particle type
00734     G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
00735     G4int  j;
00736     for ( j=0; j < pVector->size(); ++j) {
00737       if (!(*pVector)[j]->StorePhysicsTable(particle,dir,ascii)){   
00738         G4String comment =  "Fail to store physics table for "; 
00739         comment += (*pVector)[j]->GetProcessName();
00740         comment += "(" + particle->GetParticleName()  + ")";
00741         G4Exception("G4VUserPhysicsList::StorePhysicsTable",
00742                     "Run0282", JustWarning,
00743                     comment);   
00744         success = false;
00745       }
00746     }
00747     // end loop over processes
00748   }
00749   // end loop over particles
00750   return success;
00751 }

void G4VUserPhysicsList::UseCoupledTransportation ( G4bool  vl = true  ) 

Definition at line 839 of file G4VUserPhysicsList.cc.

References thePLHelper, and G4PhysicsListHelper::UseCoupledTransportation().

Referenced by G4RunManagerKernel::InitializePhysics().

00840 { 
00841   thePLHelper->UseCoupledTransportation(vl);
00842 }

Field Documentation

G4double G4VUserPhysicsList::defaultCutValue [protected]

Definition at line 298 of file G4VUserPhysicsList.hh.

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

G4String G4VUserPhysicsList::directoryPhysicsTable [protected]

Definition at line 313 of file G4VUserPhysicsList.hh.

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

G4ProductionCutsTable* G4VUserPhysicsList::fCutsTable [protected]

Definition at line 303 of file G4VUserPhysicsList.hh.

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

G4bool G4VUserPhysicsList::fDisableCheckParticleList [protected]

Definition at line 322 of file G4VUserPhysicsList.hh.

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

G4int G4VUserPhysicsList::fDisplayThreshold [protected]

Definition at line 316 of file G4VUserPhysicsList.hh.

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

G4bool G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable [protected]

Definition at line 309 of file G4VUserPhysicsList.hh.

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

G4bool G4VUserPhysicsList::fIsPhysicsTableBuilt [protected]

Definition at line 319 of file G4VUserPhysicsList.hh.

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

G4bool G4VUserPhysicsList::fIsRestoredCutValues [protected]

Definition at line 310 of file G4VUserPhysicsList.hh.

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

G4bool G4VUserPhysicsList::fRetrievePhysicsTable [protected]

Definition at line 306 of file G4VUserPhysicsList.hh.

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

G4bool G4VUserPhysicsList::fStoredInAscii [protected]

Definition at line 307 of file G4VUserPhysicsList.hh.

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

G4bool G4VUserPhysicsList::isSetDefaultCutValue [protected]

Definition at line 299 of file G4VUserPhysicsList.hh.

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

G4UserPhysicsListMessenger* G4VUserPhysicsList::theMessenger [protected]

Definition at line 291 of file G4VUserPhysicsList.hh.

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

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

G4ParticleTable* G4VUserPhysicsList::theParticleTable [protected]

Definition at line 286 of file G4VUserPhysicsList.hh.

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

G4PhysicsListHelper* G4VUserPhysicsList::thePLHelper [protected]

Definition at line 325 of file G4VUserPhysicsList.hh.

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

G4int G4VUserPhysicsList::verboseLevel [protected]

Reimplemented in G4VModularPhysicsList.

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(), SetDefaultCutValue(), SetParticleCuts(), SetVerboseLevel(), and StorePhysicsTable().

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:53:57 2013 for Geant4 by  doxygen 1.4.7