G4VUserPhysicsList Class Reference

#include <G4VUserPhysicsList.hh>

Inheritance diagram for G4VUserPhysicsList:

Collaboration 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 More...
void	SetApplyCuts (G4bool value, const G4String &name)
G4bool	GetApplyCuts (const G4String &name) const
void	RemoveProcessManager ()
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=0)
void	CheckParticleList ()
void	DisableCheckParticleList ()
G4int	GetInstanceID () const
void	InitializeWorker ()

Static Public Member Functions
static const G4VUPLManager &	GetSubInstanceManager ()

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 ()
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

Protected Attributes
G4ParticleTable *	theParticleTable
G4int	verboseLevel
G4double	defaultCutValue
G4bool	isSetDefaultCutValue
G4ProductionCutsTable *	fCutsTable
G4bool	fRetrievePhysicsTable
G4bool	fStoredInAscii
G4bool	fIsCheckedForRetrievePhysicsTable
G4bool	fIsRestoredCutValues
G4String	directoryPhysicsTable
G4bool	fDisableCheckParticleList
G4int	g4vuplInstanceID

Static Protected Attributes
static G4RUN_DLL G4VUPLManager	subInstanceManager

Detailed Description

Definition at line 155 of file G4VUserPhysicsList.hh.

Constructor & Destructor Documentation

G4VUserPhysicsList::G4VUserPhysicsList

(

)

Definition at line 104 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)
{
    g4vuplInstanceID = subInstanceManager.CreateSubInstance(); //AND
  // 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);
    G4MT_theMessenger = new G4UserPhysicsListMessenger(this); //AND
 
  // PhysicsListHelper
  //thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
  //thePLHelper->SetVerboseLevel(verboseLevel);
    //G4MT_thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper(); //AND
    G4MT_thePLHelper->SetVerboseLevel(verboseLevel); //AND

    fIsPhysicsTableBuilt = false;
    fDisplayThreshold = 0;

}

Here is the call graph for this function:

G4VUserPhysicsList::~G4VUserPhysicsList ( )

virtual

Definition at line 154 of file G4VUserPhysicsList.cc.

{
  if (G4MT_theMessenger != 0) {
    delete G4MT_theMessenger;
    G4MT_theMessenger = 0;
  }
  RemoveProcessManager();

  // invoke DeleteAllParticle
  theParticleTable->DeleteAllParticles();

}

Here is the call graph for this function:

G4VUserPhysicsList::G4VUserPhysicsList

(

const G4VUserPhysicsList &

right

)

Definition at line 168 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)
{
  g4vuplInstanceID = subInstanceManager.CreateSubInstance(); //AND
  // 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);
  G4MT_theMessenger = new G4UserPhysicsListMessenger(this); //AND
 
  // PhysicsListHelper
  //thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
  //thePLHelper->SetVerboseLevel(verboseLevel);
    G4MT_thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper(); //AND
    G4MT_thePLHelper->SetVerboseLevel(verboseLevel); //AND
    
    fIsPhysicsTableBuilt = right.GetSubInstanceManager().offset[right.GetInstanceID()]._fIsPhysicsTableBuilt;
    fDisplayThreshold = right.GetSubInstanceManager().offset[right.GetInstanceID()]._fDisplayThreshold;
}

Here is the call graph for this function:

Member Function Documentation

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

Definition at line 225 of file G4VUserPhysicsList.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::AddTransportation ( )

protected

Definition at line 953 of file G4VUserPhysicsList.cc.

{   
  G4MT_thePLHelper->AddTransportation();
}

Here is the caller graph for this function:

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

protected

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::BuildPhysicsTable

(

)

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

}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::BuildPhysicsTable

(

G4ParticleDefinition *

particle

)

Definition at line 590 of file G4VUserPhysicsList.cc.

{
  if(!(particle->GetMasterProcessManager())) {
    G4cout << "#### G4VUserPhysicsList::BuildPhysicsTable() - BuildPhysicsTable(" 
           << particle->GetParticleName() << ") skipped..." << G4endl;
    return;
  }
  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;
    }

    //Get processes from master thread;
    G4ProcessManager* pManagerShadow = particle->GetMasterProcessManager();

    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;
    }
#ifdef G4VERBOSE
    if (verboseLevel>2){
      G4cout << "G4VUserPhysicsList::BuildPhysicsTable %%%%%% " << particle->GetParticleName() << G4endl;
      G4cout << " ProcessManager : " << pManager << " ProcessManagerShadow : " << pManagerShadow << G4endl;
      for(G4int iv1=0;iv1<pVector->size();iv1++)
      { G4cout << "  " << iv1 << " - " << (*pVector)[iv1]->GetProcessName() << G4endl; }
      G4cout << "--------------------------------------------------------------" << G4endl;
      G4ProcessVector* pVectorShadow = pManagerShadow->GetProcessList();

      for(G4int iv2=0;iv2<pVectorShadow->size();iv2++)
      { G4cout << "  " << iv2 << " - " << (*pVectorShadow)[iv2]->GetProcessName() << G4endl; }
    }
#endif
    for (G4int 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
}

Here is the call graph for this function:

void G4VUserPhysicsList::CheckParticleList

(

)

Definition at line 945 of file G4VUserPhysicsList.cc.

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

Here is the caller graph for this function:

void G4VUserPhysicsList::Construct ( )

inline

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

}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void G4VUserPhysicsList::ConstructParticle ( )

pure virtual

Implemented in G4VModularPhysicsList, and G4ErrorPhysicsList.

Here is the caller graph for this function:

virtual void G4VUserPhysicsList::ConstructProcess ( )

pure virtual

Implemented in G4VModularPhysicsList, and G4ErrorPhysicsList.

Here is the caller graph for this function:

void G4VUserPhysicsList::DisableCheckParticleList ( )

inline

Definition at line 470 of file G4VUserPhysicsList.hh.

{
  fDisableCheckParticleList = true;
}

void G4VUserPhysicsList::DumpCutValuesTable

(

G4int

flag = 1

)

Definition at line 811 of file G4VUserPhysicsList.cc.

{ 
  fDisplayThreshold = flag; 
}

Here is the caller graph for this function:

void G4VUserPhysicsList::DumpCutValuesTableIfRequested

(

)

Definition at line 817 of file G4VUserPhysicsList.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::DumpList

(

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4VUserPhysicsList::GetApplyCuts

(

const G4String &

name

)

const

Definition at line 938 of file G4VUserPhysicsList.cc.

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

Here is the call graph for this function:

G4double G4VUserPhysicsList::GetCutValue

(

const G4String &

pname

)

const

Definition at line 396 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()->GetRegion("DefaultRegionForTheWorld", false);
  return region->GetProductionCuts()->GetProductionCut(name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VUserPhysicsList::GetDefaultCutValue ( ) const

inline

Definition at line 418 of file G4VUserPhysicsList.hh.

{
  return defaultCutValue;
}

Here is the caller graph for this function:

G4int G4VUserPhysicsList::GetInstanceID ( ) const

inline

Definition at line 476 of file G4VUserPhysicsList.hh.

{
    return g4vuplInstanceID;
}

Here is the caller graph for this function:

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

protected

Definition at line 972 of file G4VUserPhysicsList.cc.

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

Here is the caller graph for this function:

const G4String & G4VUserPhysicsList::GetPhysicsTableDirectory ( ) const

inline

Definition at line 442 of file G4VUserPhysicsList.hh.

{
  return directoryPhysicsTable;  
}

Here is the caller graph for this function:

const G4VUPLManager & G4VUserPhysicsList::GetSubInstanceManager ( )

inlinestatic

Definition at line 482 of file G4VUserPhysicsList.hh.

{
    return subInstanceManager;
}

Here is the caller graph for this function:

G4int G4VUserPhysicsList::GetVerboseLevel ( ) const

inline

Definition at line 424 of file G4VUserPhysicsList.hh.

{
  return  verboseLevel;
}

Here is the caller graph for this function:

void G4VUserPhysicsList::InitializeProcessManager ( )

protected

Definition at line 236 of file G4VUserPhysicsList.cc.

{
  //Request lock for particle table accesses. 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==0) {
      // create process manager if the particle does not have its own.
      pmanager = new G4ProcessManager(particle);
      particle->SetProcessManager(pmanager);
      if( particle->GetMasterProcessManager() == 0 ) particle->SetMasterProcessManager(pmanager);
#ifdef G4VERBOSE
      if (verboseLevel >2){
        G4cout << "G4VUserPhysicsList::InitializeProcessManager: creating ProcessManager to "
          << particle->GetParticleName() << G4endl;
      }
#endif
    }
  }

  if(gion)
  {
    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 accesses.
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex);
#endif
//  G4cout << "Particle table is released by G4VUserPhysicsList::InitializeProcessManager" << G4endl;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::InitializeWorker

(

)

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

Here is the caller graph for this function:

G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved ( ) const

inline

Definition at line 430 of file G4VUserPhysicsList.hh.

{
  return fRetrievePhysicsTable;  
}

Here is the caller graph for this function:

G4bool G4VUserPhysicsList::IsStoredInAscii ( ) const

inline

Definition at line 436 of file G4VUserPhysicsList.hh.

{
  return fStoredInAscii;
}

Here is the caller graph for this function:

G4VUserPhysicsList & G4VUserPhysicsList::operator=

(

const G4VUserPhysicsList &

right

)

Definition at line 204 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.GetSubInstanceManager().offset[right.GetInstanceID()]._fIsPhysicsTableBuilt;
      fDisplayThreshold = right.GetSubInstanceManager().offset[right.GetInstanceID()]._fDisplayThreshold;
      //fIsPhysicsTableBuilt = right.fIsPhysicsTableBuilt;
    fDisableCheckParticleList = right.fDisableCheckParticleList;
  }
  return *this;
}

Here is the call graph for this function:

void G4VUserPhysicsList::PreparePhysicsTable

(

G4ParticleDefinition *

particle

)

Definition at line 698 of file G4VUserPhysicsList.cc.

{
  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) {
#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();
    //Andrea Dotti 15 Jan 2013: Change of interface of MSC
    //G4ProcessVector* pVectorShadow = pManagerShadow->GetProcessList();

    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) {

        //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
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Definition at line 965 of file G4VUserPhysicsList.cc.

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

void G4VUserPhysicsList::RemoveProcessManager

(

)

Definition at line 295 of file G4VUserPhysicsList.cc.

{
  //Request lock for particle table accesses. Some changes are inside
  //this critical region.
#ifdef G4MULTITHREADED
  G4MUTEXLOCK(&G4ParticleTable::particleTableMutex);
  G4ParticleTable::lockCount++;
#endif
//  G4cout << "Particle table is held by G4VUserPhysicsList::InitializeProcessManager" << G4endl;

  // 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!=0) delete pmanager;
#ifdef G4VERBOSE
        if (verboseLevel >2){
          G4cout << "G4VUserPhysicsList::RemoveProcessManager: ";
          G4cout  << "remove ProcessManager from ";
          G4cout  << particle->GetParticleName() << G4endl;
        }
#endif
      }
      particle->SetProcessManager(0);
    }
  }

  //release lock for particle table accesses.
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex);
#endif
//  G4cout << "Particle table is released by G4VUserPhysicsList::InitializeProcessManager" << G4endl;

}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::ResetCuts

(

)

obsolete methods

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

void G4VUserPhysicsList::ResetPhysicsTableRetrieved ( )

inline

Definition at line 455 of file G4VUserPhysicsList.hh.

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

Here is the caller graph for this function:

void G4VUserPhysicsList::ResetStoredInAscii ( )

inline

Definition at line 464 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = false;
}

Here is the caller graph for this function:

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

protectedvirtual

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::SetCuts ( )

virtual

Reimplemented in G4ErrorPhysicsList, and QBBC.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::SetCutsWithDefault

(

)

Definition at line 441 of file G4VUserPhysicsList.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 416 of file G4VUserPhysicsList.cc.

{
  SetParticleCuts( aCut ,name );
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

void G4VUserPhysicsList::SetDefaultCutValue

(

G4double

newCutValue

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 460 of file G4VUserPhysicsList.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 466 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){
    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
}

Here is the call graph for this function:

void G4VUserPhysicsList::SetPhysicsTableRetrieved

(

const G4String &

directory = ""

)

Definition at line 876 of file G4VUserPhysicsList.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::SetStoredInAscii ( )

inline

Definition at line 448 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = true;
}

Here is the caller graph for this function:

void G4VUserPhysicsList::SetVerboseLevel

(

G4int

value

)

Definition at line 978 of file G4VUserPhysicsList.cc.

{
  verboseLevel = value;
  // set verboseLevel for G4ProductionCutsTable same as one for G4VUserPhysicsList: 
  fCutsTable->SetVerboseLevel(verboseLevel);

  G4MT_thePLHelper->SetVerboseLevel(verboseLevel);

#ifdef G4VERBOSE
  if (verboseLevel >1){
    G4cout << "G4VUserPhysicsList::SetVerboseLevel  :"
       << " Verbose level is set to " << verboseLevel << G4endl;
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4VUserPhysicsList::StorePhysicsTable

(

const G4String &

directory = "."

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VUserPhysicsList::UseCoupledTransportation

(

G4bool

vl = true

)

Definition at line 959 of file G4VUserPhysicsList.cc.

{ 
  G4MT_thePLHelper->UseCoupledTransportation(vl);
}

Here is the caller graph for this function:

Member Data Documentation

G4double G4VUserPhysicsList::defaultCutValue

protected

Definition at line 358 of file G4VUserPhysicsList.hh.

G4String G4VUserPhysicsList::directoryPhysicsTable

protected

Definition at line 373 of file G4VUserPhysicsList.hh.

G4ProductionCutsTable* G4VUserPhysicsList::fCutsTable

protected

Definition at line 363 of file G4VUserPhysicsList.hh.

G4bool G4VUserPhysicsList::fDisableCheckParticleList

protected

Definition at line 382 of file G4VUserPhysicsList.hh.

G4bool G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable

protected

Definition at line 369 of file G4VUserPhysicsList.hh.

G4bool G4VUserPhysicsList::fIsRestoredCutValues

protected

Definition at line 370 of file G4VUserPhysicsList.hh.

G4bool G4VUserPhysicsList::fRetrievePhysicsTable

protected

Definition at line 366 of file G4VUserPhysicsList.hh.

G4bool G4VUserPhysicsList::fStoredInAscii

protected

Definition at line 367 of file G4VUserPhysicsList.hh.

G4int G4VUserPhysicsList::g4vuplInstanceID

protected

Definition at line 392 of file G4VUserPhysicsList.hh.

G4bool G4VUserPhysicsList::isSetDefaultCutValue

protected

Definition at line 359 of file G4VUserPhysicsList.hh.

G4VUPLManager G4VUserPhysicsList::subInstanceManager

staticprotected

Definition at line 393 of file G4VUserPhysicsList.hh.

G4ParticleTable* G4VUserPhysicsList::theParticleTable

protected

Definition at line 346 of file G4VUserPhysicsList.hh.

G4int G4VUserPhysicsList::verboseLevel

protected

Definition at line 354 of file G4VUserPhysicsList.hh.

---

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

• geant4.10.03.p01/source/run/include/G4VUserPhysicsList.hh
• geant4.10.03.p01/source/run/src/G4VUserPhysicsList.cc