Gabriele Cosmo
389 lines
14 KiB
C++
389 lines
14 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
// $Id: G4VUserPhysicsList.hh,v 1.35 2007/05/30 10:16:27 ahoward Exp $
|
|
// GEANT4 tag $Name: geant4-09-01 $
|
|
//
|
|
//
|
|
// ------------------------------------------------------------
|
|
// GEANT 4 class header file
|
|
// Class Description:
|
|
// This class is an abstruct class for
|
|
// constructing particles and processes.
|
|
// User must implement following four virtual methods
|
|
// in his own concrete class derived from this class.
|
|
// G4VUserPhysicsList::ConstructParticle()
|
|
// Construct particles
|
|
// G4VUserPhysicsList::constructPhysics()
|
|
// Construct procesess and register them to particles
|
|
// G4VUserPhysicsList::SetCuts()
|
|
// set cut values in range to all particles
|
|
// (and rebuilding physics table will be invoked )
|
|
//
|
|
// -------------------------------------------
|
|
// History
|
|
// first version 09 Jan. 1998 by H.Kurashige
|
|
// modified 24 Jan. 1998 by H.Kurashige
|
|
// rename DumpCutValues/DumpCutValuesTable
|
|
// change SetCuts method
|
|
// add SetCutsWithDefault method
|
|
// modified 06 June 1998 by H.Kurashige
|
|
// add AddProcessManager
|
|
// add BuildPhysicsTable
|
|
// modified 29 June 1998 by H.Kurashige
|
|
// add AddProcessManager
|
|
// modified 05 Dec. 1998 by H.Kurashige
|
|
// add ConstructAllParticles()
|
|
// modified 14, Apr 1999 by H.Kurashige
|
|
// change BuildPhysicsTable as public
|
|
// removed ConstructAllParticles() and related methods
|
|
// changed SetCuts method argument
|
|
// modified 08, Nov 2000 by H.Kurashige
|
|
// added Retrieve/StorePhysicsTable and related methods
|
|
// modified 08, Mar 2001 by H.Kurashige
|
|
// added binary mode for Retrieve/StorePhysicsTable
|
|
// added RetrieveCutValues and related
|
|
// added Set/ResetStoredInAscii() to switch on ascii mode
|
|
// for Retrieve/StorePhysicsTable
|
|
// modified for CUTS per REGION 10, Oct 2002 by H.Kurashige
|
|
// removed following methods
|
|
// void ReCalcCutValue()
|
|
// void SetCutValueForOthers()
|
|
// void SetCutValueForOtherThan()
|
|
// void ReCalcCutValueForOthers()
|
|
// virtual G4bool StoreMaterialInfo()
|
|
// virtual G4bool StoreCutValues()
|
|
// virtual G4bool RetrieveCutValues()
|
|
// virtual G4bool CheckForRetrievePhysicsTable()
|
|
// virtual G4bool CheckMaterialInfo()
|
|
// added void BuildPhysicsTable()
|
|
// ------------------------------------------------------------
|
|
#ifndef G4VUserPhysicsList_h
|
|
#define G4VUserPhysicsList_h 1
|
|
#include "globals.hh"
|
|
#include "G4ios.hh"
|
|
|
|
#include "G4ParticleTable.hh"
|
|
#include "G4ParticleDefinition.hh"
|
|
#include "G4ProductionCutsTable.hh"
|
|
|
|
class G4UserPhysicsListMessenger;
|
|
class G4VProcess;
|
|
|
|
class G4VUserPhysicsList
|
|
{
|
|
public:
|
|
G4VUserPhysicsList();
|
|
virtual ~G4VUserPhysicsList();
|
|
|
|
public: // with description
|
|
// Each particle type will be instantiated
|
|
// This method is invoked by the RunManger
|
|
virtual void ConstructParticle() = 0;
|
|
|
|
// By calling the "Construct" method,
|
|
// process manager and processes are created.
|
|
void Construct();
|
|
|
|
// Each physics process will be instantiated and
|
|
// registered to the process manager of each particle type
|
|
// This method is invoked in Construct" method
|
|
virtual void ConstructProcess() = 0;
|
|
|
|
protected: // with description
|
|
// User must invoke this method in his ConstructProcess()
|
|
// implementation in order to insures particle transportation.
|
|
// !! Caution: this class must not be overriden !!
|
|
void AddTransportation();
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
public: // with description
|
|
// "SetCuts" method sets a cut value for all particle types
|
|
// in the particle table
|
|
virtual void SetCuts() = 0;
|
|
|
|
public: // with description
|
|
// set/get the default cut value
|
|
// Calling SetDefaultCutValue causes re-calcuration of cut values
|
|
// and physics tables just before the next event loop
|
|
void SetDefaultCutValue(G4double newCutValue);
|
|
G4double GetDefaultCutValue() const;
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
public: // with description
|
|
// Invoke BuildPhysicsTable for all processes for all particles
|
|
// In case of "Retrieve" flag is ON, PhysicsTable will be
|
|
// retrieved from files
|
|
void BuildPhysicsTable();
|
|
|
|
// do PreparePhysicsTable for specified particle type
|
|
void PreparePhysicsTable(G4ParticleDefinition* );
|
|
|
|
// do BuildPhysicsTable for specified particle type
|
|
void BuildPhysicsTable(G4ParticleDefinition* );
|
|
|
|
// Store PhysicsTable together with both material and cut value
|
|
// information in files under the specified directory.
|
|
// (return true if files are sucessfully created)
|
|
G4bool StorePhysicsTable(const G4String& directory = ".");
|
|
|
|
// Return true if "Retrieve" flag is ON.
|
|
// (i.e. PhysicsTable will be retrieved from files)
|
|
G4bool IsPhysicsTableRetrieved() const;
|
|
G4bool IsStoredInAscii() const;
|
|
|
|
// Get directory path for physics table files.
|
|
const G4String& GetPhysicsTableDirectory() const;
|
|
|
|
// Set "Retrieve" flag
|
|
// Directory path can be set together.
|
|
// Null string (default) means directory is not changed
|
|
// from the current value
|
|
void SetPhysicsTableRetrieved(const G4String& directory = "");
|
|
void SetStoredInAscii();
|
|
|
|
// Reset "Retrieve" flag
|
|
void ResetPhysicsTableRetrieved();
|
|
void ResetStoredInAscii();
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
public: // with description
|
|
// Print out the List of registered particles types
|
|
void DumpList() const;
|
|
|
|
public: // with description
|
|
// Request to print out information of cut values
|
|
// Printing will be performed when all tables are made
|
|
void DumpCutValuesTable(G4int nParticles=3);
|
|
|
|
// The following method actually trigger the print-out requested
|
|
// by the above method. This method must be invoked by RunManager
|
|
// at the proper moment.
|
|
void DumpCutValuesTableIfRequested();
|
|
|
|
void DumpCutValues(const G4String &particle_name = "ALL");
|
|
void DumpCutValues(G4ParticleDefinition* );
|
|
|
|
public: // with description
|
|
void SetVerboseLevel(G4int value);
|
|
G4int GetVerboseLevel() const;
|
|
// set/get controle flag for output message
|
|
// 0: Silent
|
|
// 1: Warning message
|
|
// 2: More
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
public: // with description
|
|
// "SetCutsWithDefault" method sets the default cut value
|
|
// for all particles for the default region.
|
|
void SetCutsWithDefault();
|
|
|
|
// Following are utility methods for SetCuts
|
|
|
|
// SetCutValue sets a cut value for a particle type for the default region
|
|
void SetCutValue(G4double aCut, const G4String& pname);
|
|
|
|
// SetCutValue sets a cut value for a particle type for a region
|
|
void SetCutValue(G4double aCut, const G4String& pname, const G4String& rname);
|
|
|
|
// Invoke SetCuts for specified particle for a region
|
|
// If the pointer to the region is NULL, the default region is used
|
|
// In case of "Retrieve" flag is ON,
|
|
// Cut values will be retrieved from files
|
|
void SetParticleCuts(G4double cut,G4ParticleDefinition* particle,G4Region* region=0);
|
|
|
|
// Invoke SetCuts for all particles in a region
|
|
void SetCutsForRegion(G4double aCut, const G4String& rname);
|
|
|
|
// Following are utility methods are obsolete
|
|
void ResetCuts();
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
public:
|
|
// Get/SetApplyCuts gets/sets the flag for ApplyCuts
|
|
void SetApplyCuts(G4bool value, const G4String& name);
|
|
G4bool GetApplyCuts(const G4String& name) const;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
protected:
|
|
// do BuildPhysicsTable for make the integral schema
|
|
void BuildIntegralPhysicsTable(G4VProcess* ,G4ParticleDefinition* );
|
|
|
|
|
|
protected:
|
|
// Retrieve PhysicsTable from files for proccess belongng the particle.
|
|
// Normal BuildPhysics procedure of processes will be invoked,
|
|
// if it fails (in case of Process's RetrievePhysicsTable returns false)
|
|
virtual void RetrievePhysicsTable(G4ParticleDefinition* ,
|
|
const G4String& directory,
|
|
G4bool ascii = false);
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
protected:
|
|
// adds new ProcessManager to all particles in the Particle Table
|
|
// this routine is used in Construct()
|
|
void InitializeProcessManager();
|
|
|
|
public: // with description
|
|
// remove and delete ProcessManagers for all particles in tha Particle Table
|
|
// this routine is invoked from RunManager
|
|
void RemoveProcessManager();
|
|
|
|
public: // with description
|
|
// add process manager for particles created on-the-fly
|
|
void AddProcessManager(G4ParticleDefinition* newParticle,
|
|
G4ProcessManager* newManager = 0 );
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
protected:
|
|
// the particle table has the complete List of existing particle types
|
|
G4ParticleTable* theParticleTable;
|
|
G4ParticleTable::G4PTblDicIterator* theParticleIterator;
|
|
|
|
protected:
|
|
// pointer to G4UserPhysicsListMessenger
|
|
G4UserPhysicsListMessenger* theMessenger;
|
|
|
|
protected:
|
|
G4int verboseLevel;
|
|
|
|
protected:
|
|
// this is the default cut value for all particles
|
|
G4double defaultCutValue;
|
|
|
|
protected:
|
|
// pointer to ProductionCutsTable
|
|
G4ProductionCutsTable* fCutsTable;
|
|
|
|
// flag to determine physics table will be build from file or not
|
|
G4bool fRetrievePhysicsTable;
|
|
G4bool fStoredInAscii;
|
|
|
|
G4bool fIsCheckedForRetrievePhysicsTable;
|
|
G4bool fIsRestoredCutValues;
|
|
|
|
// directory name for physics table files
|
|
G4String directoryPhysicsTable;
|
|
|
|
// flag for displaying the range cuts & energy thresholds
|
|
G4int fDisplayThreshold;
|
|
|
|
private:
|
|
enum { FixedStringLengthForStore = 32 };
|
|
|
|
|
|
private:
|
|
G4bool useCoupledTransportation;
|
|
|
|
public:
|
|
inline void UseCoupledTransportation(G4bool vl=true)
|
|
{ useCoupledTransportation = vl; }
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Following method is for backward compatibility and removed soon
|
|
////////////////////////////////////////////////////////////////////////////
|
|
protected:
|
|
void SetCutValueForOthers(G4double) const;
|
|
|
|
};
|
|
|
|
inline
|
|
void G4VUserPhysicsList::SetCutValueForOthers(G4double) const
|
|
{
|
|
G4cerr << "WARNING !" << G4endl;
|
|
G4cerr << " SetCutValueForOthers became obsolete." << G4endl;
|
|
G4cerr << " It is harmless to remove this invokation without any side effects." << G4endl;
|
|
G4cerr << " This dummy method implementation will be removed soon." << G4endl;
|
|
}
|
|
|
|
inline void G4VUserPhysicsList::Construct()
|
|
{
|
|
#ifdef G4VERBOSE
|
|
if (verboseLevel >1) G4cout << "G4VUserPhysicsList::Construct()" << G4endl;
|
|
#endif
|
|
|
|
InitializeProcessManager();
|
|
|
|
#ifdef G4VERBOSE
|
|
if (verboseLevel >1) G4cout << "Construct processes " << G4endl;
|
|
#endif
|
|
ConstructProcess();
|
|
}
|
|
|
|
inline G4double G4VUserPhysicsList::GetDefaultCutValue() const
|
|
{
|
|
return defaultCutValue;
|
|
}
|
|
|
|
|
|
inline G4int G4VUserPhysicsList::GetVerboseLevel() const
|
|
{
|
|
return verboseLevel;
|
|
}
|
|
|
|
inline
|
|
G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved() const
|
|
{
|
|
return fRetrievePhysicsTable;
|
|
}
|
|
|
|
inline
|
|
G4bool G4VUserPhysicsList::IsStoredInAscii() const
|
|
{
|
|
return fStoredInAscii;
|
|
}
|
|
|
|
inline
|
|
const G4String& G4VUserPhysicsList::GetPhysicsTableDirectory() const
|
|
{
|
|
return directoryPhysicsTable;
|
|
}
|
|
|
|
inline
|
|
void G4VUserPhysicsList::SetStoredInAscii()
|
|
{
|
|
fStoredInAscii = true;
|
|
}
|
|
|
|
|
|
inline
|
|
void G4VUserPhysicsList::ResetPhysicsTableRetrieved()
|
|
{
|
|
fRetrievePhysicsTable = false;
|
|
fIsRestoredCutValues = false;
|
|
fIsCheckedForRetrievePhysicsTable=false;
|
|
}
|
|
|
|
|
|
inline
|
|
void G4VUserPhysicsList::ResetStoredInAscii()
|
|
{
|
|
fStoredInAscii = false;
|
|
}
|
|
#endif
|
|
|