BLCMDphysics Class Reference

Inheritance diagram for BLCMDphysics:

List of all members.

---

Detailed Description

class BLCMDphysics implements a command to select from the geant4 physics lists of physics processes.

Public Member Functions
	BLCMDphysics ()
	Default Constructor.
	~BLCMDphysics ()
	Destructor.
void	setDoStochastics (BLSetValue value, G4int warn=1)
	setDoStochastics() sets whether or not stochastic processes are to be enabled.
G4VUserPhysicsList *	getPhysicsList ()
	getPhysicsList() returns the G4PhysicsList.
G4String	commandName ()
	commandName() returns "physics".
int	command (BLArgumentVector &argv, BLArgumentMap &namedArgs)
	command() implements the command.
void	defineNamedArgs ()
	defineNamedArgs() defines the named arguments.
void	help (bool detailed)
	help() provides special help text for the physics command.
void	callback (int type)
	callback() is from BLCallback, and adds a StepLimiter to the physics list for every particle.
bool	isLocalPhysicsList (G4String name)
	isLocalPhysicsList() returns true if thsi is a local physics list.
G4VUserPhysicsList *	getLocalPhysicsList (G4String name)
	getLocalPhysicsList() returns a local physics list.
void	listPhysicsLists ()
	listPhysicsLists() will list all known physics lists, with synopsis.
void	printCase (G4String name, G4String description)
	printCase() prints the description of a physics list.
G4String	getSynopsis (G4String listName)
	getSynopsis() returns the synopsis for a physics list, by name.
Private Attributes
G4VUserPhysicsList *	physicsList
G4int	doStochastics
G4String	disable
G4int	list
G4int	synchrotronRadiation
G4int	synchrotronRadiationMuon
G4int	gammaToMuPair
std::vector< G4String >	disableList
G4PhysListFactory *	physListFactory

---

Constructor & Destructor Documentation

BLCMDphysics::BLCMDphysics

(

)

Default Constructor.

References BLCMDTYPE_PHYSICS, disable, doStochastics, gammaToMuPair, list, BLPhysics::minRangeCut, physicsList, physListFactory, BLCommand::registerCommand(), BLCommand::setDescription(), BLCommand::setSynopsis(), synchrotronRadiation, and synchrotronRadiationMuon.

                           : BLPhysics(), BLCommand(), disableList()
{
        registerCommand(BLCMDTYPE_PHYSICS);
        setSynopsis("Defines the physics processes and controls them.");
        setDescription("Exactly one physics command must be present.\n"
                "This command implements the geant4 physics lists\n"
                "of physics processes.\n"
                "The command is 'physics QGSP' for the QGSP set, and\n"
                "similarly for the other sets. With no argument it prints\n"
                "the available physics lists.\n"
                "Note that stochastic processes are always disabled while\n"
                "tracking the tune and reference particles.\n"
                "The only non-stochastic processes are Transportation and\n"
                "ionization energy loss (with fluctuations disabled).\n"
                "For muon beam studies you may want to disable the Decay "
                "process.\n\n"
                "NOTE: this command defines the particles used throughout "
                "the simulation, so this command must come before others "
                "that use particle names.\n\n"
                "NOTE: the rare decy mode for pi+/pi- to e nu is added.\n\n"
                "The default all-around physics list for HEP is called "
                "'QGSP_BERT'.");

        physicsList = 0;
        doStochastics = 1;
        list = 0;
        synchrotronRadiation = 0;
        synchrotronRadiationMuon = 0;
        gammaToMuPair = 0;
        disable = "";
        minRangeCut = 1.0 * mm;
        physListFactory = 0;
}

BLCMDphysics::~BLCMDphysics

(

)

[inline]

Destructor.

{ }

---

Member Function Documentation

void BLCMDphysics::setDoStochastics	(	BLSetValue	value,
		G4int	warn = 1
	)			[virtual]

setDoStochastics() sets whether or not stochastic processes are to be enabled.

Implements BLPhysics.

References disableList, doStochastics, FORCE_OFF, FORCE_ON, BLPhysics::isStochasticProcess(), list, BLPhysics::minRangeCut, NORMAL, and BLPhysics::stochasticsEnabled.

{
        if(value == NORMAL) {
                if(doStochastics)
                        value = FORCE_ON;
                else
                        value = FORCE_OFF;
        }

        G4UImanager* UI = G4UImanager::GetUIpointer();
        G4String cmd;
        char rangeCmd[64];
        switch(value) {
        case FORCE_OFF:
                // turn off delta rays (and other particle production) by
                // setting production cut very high in energy by setting
                // the required range large.
                UI->ApplyCommand("/run/setCut 1 km");
                // Turn off enegry-loss straggling
                UI->ApplyCommand("/process/eLoss/fluct false");
                cmd = "/process/inactivate ";
                switch(warn) {
                case 0: break;
                case 1: printf("*** NOTE: All stochastic processes are disabled!\n");
                        break;
                case 2: G4Exception("physics",
                                "All stochastic processes disabled",
                                JustWarning,"");
                        break;
                }
                stochasticsEnabled = false;
                break;
        case FORCE_ON:
                // turn on delta rays (and other particle production)
                sprintf(rangeCmd,"/run/setCut %.6g mm",minRangeCut/mm);
                UI->ApplyCommand(rangeCmd);
                // Turn on enegry-loss straggling
                UI->ApplyCommand("/process/eLoss/fluct true");
                cmd = "/process/activate ";
                if(warn != 0) printf("Stochastic processes are enabled.\n");
                stochasticsEnabled = true;
                break;
        case NORMAL:
                return;
        }

        // run through list of processes, applying cmd to stochastic ones
        G4ProcessTable *pt = G4ProcessTable::GetProcessTable();
        G4ProcessTable::G4ProcNameVector *nv = pt->GetNameList();
        if(list) printf("List of physics processes:\n");
        for(unsigned int i=0; i<nv->size(); ++i) {
                G4String name = (*nv)[i];
                if(list) printf("\t%s\n",name.c_str());
                if(isStochasticProcess(name))
                        UI->ApplyCommand(cmd+name);
        }
        if(list) printf("\n");
        list = 0;       // print list only once

        // now disable all proceses in the disableList
        cmd = "/process/inactivate ";
        for(unsigned i=0; i<disableList.size(); ++i) {
                switch(warn) {
                case 0: break;
                case 1: printf("*** NOTE: Disabling physics process '%s'\n",
                                                disableList[i].c_str());
                        break;
                case 2: G4Exception("physics","Physics process disabled",
                                        JustWarning,disableList[i].c_str());
                        break;
                }
                UI->ApplyCommand(cmd+disableList[i]);
        }
}

G4VUserPhysicsList* BLCMDphysics::getPhysicsList

(

)

[inline, virtual]

getPhysicsList() returns the G4PhysicsList.

Implements BLPhysics.

References physicsList.

{ return physicsList; }

G4String BLCMDphysics::commandName

(

)

[inline, virtual]

commandName() returns "physics".

Implements BLCommand.

{ return "physics"; }

int BLCMDphysics::command	(	BLArgumentVector &	argv,
		BLArgumentMap &	namedArgs
	)			[virtual]

command() implements the command.

Implements BLCommand.

References disable, disableList, getLocalPhysicsList(), BLManager::getObject(), BLCommand::handleNamedArgs(), isLocalPhysicsList(), listPhysicsLists(), physicsList, physListFactory, BLCommand::print(), BLCommand::printError(), BLManager::registerCallback(), BLManager::registerPhysics(), and BLCommand::splitString().

{
        if(physicsList != 0 && argv.size() > 0) {
                printError("physics: Multiple physics commands not allowed!");
                return -1;
        }

        if(argv.size() == 0)
                return -1;

        // handle obsolete physics lists
        if(argv[0] == "QGSC") {
                argv[0] = "QGSC_BERT";
                printf("Physics list QGSC is obsolete, replaced by QGSC_BERT\n");
        }
        if(argv[0] == "QGSP") {
                argv[0] = "QGSP_BERT";
                printf("Physics list QGSP is obsolete, replaced by QGSP_BERT\n");
        }

        if(!physListFactory) physListFactory = new G4PhysListFactory();
        if(isLocalPhysicsList(argv[0]))
                physicsList = getLocalPhysicsList(argv[0]);
        if(!physicsList) {
                if(!physListFactory->IsReferencePhysList(argv[0])) {
                        printError("physics: Unknown physics list '%s'",
                                                        argv[0].c_str());
                        printError("The choices are:");
                        listPhysicsLists();
                        return -1;
                }
                physicsList = physListFactory->GetReferencePhysList(argv[0]);
        }

        handleNamedArgs(namedArgs);

        disableList = splitString(disable,',',true);

        BLManager::getObject()->registerPhysics(this);

        // now is too early to manage the physics processes; do it in a callback
        BLManager::getObject()->registerCallback(this,0);

        print(argv[0]);

        return 0;
}

void BLCMDphysics::defineNamedArgs

(

)

[virtual]

defineNamedArgs() defines the named arguments.

Reimplemented from BLCommand.

References BLCommand::argDouble(), BLCommand::argInt(), BLCommand::argString(), disable, doStochastics, gammaToMuPair, list, BLPhysics::minRangeCut, synchrotronRadiation, and synchrotronRadiationMuon.

{
        argString(disable,"disable","Comma-separated list of processes to disable (e.g. 'Decay,msc').");
        argString(disable,"inactivate","Synonym of disable.");
        argString(disable,"deactivate","Synonym of disable.");
        argInt(doStochastics,"doStochastics","Set to zero to disable all stochastic processes.");
        argDouble(minRangeCut,"minRangeCut","Minimum range cut for particle production (1 mm)");
        argInt(list,"list","Nonzero to list the processes (later in output).");
        argInt(gammaToMuPair,"gammaToMuPair","Nonzero to add gamma->mu+mu- (0).");
        argInt(synchrotronRadiation,"synchrotronRadiation","Nonzero to add synchrotron radiation to the physics list for e- and e+.");
        argInt(synchrotronRadiationMuon,"synchrotronRadiationMuon","Nonzero to add synchrotron radiation to the physics list for mu- and mu+ NOTE: This is experimental, and may not work correctly.");
}

void BLCMDphysics::help

(

bool

detailed

)

[virtual]

help() provides special help text for the physics command.

Reimplemented from BLCommand.

References BLCommand::help(), and listPhysicsLists().

{
        BLCommand::help(detailed);
        if(detailed) {
                printf("\n             ----- PHYSICS LISTS -----\n\n");
                printf("             Further guidance in selecting physics lists is available at:\n"
                "http://geant4.web.cern.ch/geant4/support/physicsLists/referencePL/index.shtml\n\n");
                printf("             The default all-around physics list for HEP is called 'QGSP_BERT'.\n\n");
                printf("             LHEP uses exclusively parameterized modeling.\n");
                printf("             FTF lists use the FRITIOF description of string excitation\n"
                       "                  and fragmentation.\n");
                printf("             QGSP lists use the quark gluon string model\n");
                printf("             QGSC are as QGSP except applying CHIPS modeling for the nuclear\n"
                       "                  de-excitation.\n");
                printf("             _BERT uses Geant4 Bertini cascade below ~ 10 GeV.\n");
                printf("             _BIC uses Geant4 Binary cascade below ~ 10 GeV.\n");
                printf("             _EMV suffix indicates a faster but less accurate EM modeling.\n");
                printf("             _EMX suffix indicates the low-energy EM processes.\n");
                printf("             _HP suffix uses the data driven high precision neutron package\n"
                       "                  (thermal to 20 MeV).\n");
                printf("             _NQE suffix indicates a list for comparison with earlier release.\n");
                printf("\n             List of available physics lists:\n");
                listPhysicsLists();
        }
}

void BLCMDphysics::callback

(

int

type

)

[virtual]

callback() is from BLCallback, and adds a StepLimiter to the physics list for every particle.

ensure only mu-nu is present

ensure only mu-nu is present

Reimplemented from BLCallback.

References BLAssert, gammaToMuPair, synchrotronRadiation, and synchrotronRadiationMuon.

{
        G4ParticleTable::G4PTblDicIterator *theParticleIterator =
                        G4ParticleTable::GetParticleTable()->GetIterator();
        theParticleIterator -> reset();
        while( (*theParticleIterator)() ) {
                G4ParticleDefinition* particle = theParticleIterator->value();
                G4ProcessManager* pmanager = particle -> GetProcessManager();
                if(!pmanager) {
                        printf("BLCMDphysics: particle '%s' has no ProcessManager!\n",
                                particle->GetParticleName().c_str());
                        continue;
                }
                pmanager -> AddProcess(new G4StepLimiter(),-1,-1,ordDefault);
        }

        // add pi+/pi- decay to e nu
        double br=1.230e-4;
        G4ParticleTable *table = G4ParticleTable::GetParticleTable();
        { G4ParticleDefinition *pi=table->FindParticle("pi+");
          G4DecayTable* table = pi->GetDecayTable();
          BLAssert(table->entries() == 1); /// ensure only mu-nu is present
          G4VDecayChannel *munu = table->GetDecayChannel(0);
          munu->SetBR(1.0-br);  
          table->Insert(new G4PhaseSpaceDecayChannel("pi+",br,2,"e+","nu_e"));
        }
        { G4ParticleDefinition *pi=table->FindParticle("pi-");
          G4DecayTable* table = pi->GetDecayTable();
          BLAssert(table->entries() == 1); /// ensure only mu-nu is present
          G4VDecayChannel *munu = table->GetDecayChannel(0);
          munu->SetBR(1.0-br);  
          table->Insert(new G4PhaseSpaceDecayChannel("pi-",br,2,"e-","anti_nu_e"));
        }

        if(synchrotronRadiation) {
                table->FindParticle("e-")->GetProcessManager()->
                        AddDiscreteProcess(new G4SynchrotronRadiation);
                table->FindParticle("e+")->GetProcessManager()->
                        AddDiscreteProcess(new G4SynchrotronRadiation);
        }

        if(synchrotronRadiationMuon) {
                table->FindParticle("mu-")->GetProcessManager()->
                        AddDiscreteProcess(new G4SynchrotronRadiation);
                table->FindParticle("mu+")->GetProcessManager()->
                        AddDiscreteProcess(new G4SynchrotronRadiation);
        }

        if(gammaToMuPair) {
                table->FindParticle("gamma")->GetProcessManager()->
                        AddDiscreteProcess(new G4GammaConversionToMuons);
        }
}

bool BLCMDphysics::isLocalPhysicsList

(

G4String

name

)

isLocalPhysicsList() returns true if thsi is a local physics list.

Referenced by command().

{
        return false;
}

G4VUserPhysicsList * BLCMDphysics::getLocalPhysicsList

(

G4String

name

)

getLocalPhysicsList() returns a local physics list.

Referenced by command().

{
        return 0;
}

void BLCMDphysics::listPhysicsLists

(

)

listPhysicsLists() will list all known physics lists, with synopsis.

References getSynopsis(), physListFactory, and printCase().

Referenced by command(), and help().

{
        if(!physListFactory) physListFactory = new G4PhysListFactory();
        const std::vector<G4String> v = physListFactory->AvailablePhysLists();
        for(unsigned i=0; i<v.size(); ++i) {
                G4String n = v[i];
                G4String s = getSynopsis(n);
                printCase(n,s);
        }
}

void BLCMDphysics::printCase	(	G4String	name,
		G4String	description
	)

printCase() prints the description of a physics list.

References BLCommand::wrapWords().

Referenced by listPhysicsLists().

{
        G4String indent1("             "), indent("       ");
        indent += indent1;
        indent1 += name;
        do { indent1 += " "; } while(indent1.size() < indent.size());
        printf("%s",wrapWords(description,indent1,indent).c_str());
}

G4String BLCMDphysics::getSynopsis

(

G4String

listName

)

getSynopsis() returns the synopsis for a physics list, by name.

References CASE.

Referenced by listPhysicsLists().

{
#define CASE(NAME,SYNOPSIS)                             \
        if(listName == #NAME) return SYNOPSIS;

        CASE(CHIPS,"No synopsis available.");
        CASE(FTFP_BERT,"For calorimetry. The FTF model is based on the FRITIOF description of string excitation and fragmentation. Uses Geant4 Bertini cascade for primary protons, neutrons, pions and Kaons below ~10GeV.");
        CASE(FTFP_BERT_EMV,"Like FTFP_BERT but with faster EM modeling.");
        CASE(FTFP_BERT_EMX,"Like FTFP_BERT but with low-energy EM modeling.");
        CASE(FTFP_BERT_TRV,"A variant of QGSP_BERT where the Geant4 Bertini cascade is only used for particles below ~5.5 GeV.");
        CASE(FTFP_BIC,"For calorimetry. The FTF model is based on the FRITIOF description of string excitation and fragmentation. Uses Geant4 binary cascade for primary protons, neutrons, pions and Kaons below ~10GeV.");
        CASE(LBE,"For low background experiments (e.g. underground)");
        CASE(LHEP,"For calorimetry -- is the fastest, when it comes to CPU. It uses the LEP and HEP parametrized models for inelastic scattering. The modeling parametrizes the final states individual inelastic reactions, so you will not see resonances, and the detailed secondary angular distributions for O(100MeV) reactions may not be described perfectly. The average quantities will be well described.");
        CASE(LHEP_BERT,"For 'typical' HEP collider detectors and low-energy penetration shielding (< 5 GeV) -- is as LHEP for energies above 3GeV. Below 3 GeV the Bertini cascade is used for nucleon and pion induced reactions. The price to pay is reduced CPU performance. It does not include gamma and electro nuclear physics.");
        CASE(LHEP_EMV,"Like LHEP but with faster EM modeling.");
        CASE(QBBC,"No synopsis available.");
        CASE(QGSC,"For calorimetry and high energy physics trackers -- is as QGSP for the initial reaction, but uses chiral invariant phase-space decay (multi-quasmon fragmentation) to model the behavior of the system's fragmentation.");
        CASE(QGSC_BERT,"For calorimetry and high energy physics trackers -- is as QGSP for the initial reaction, but uses chiral invariant phase-space decay (multi-quasmon fragmentation) to model the behavior of the system's fragmentation. Uses Geant4 Bertini cascade for nucleon and pion induced reactions.");
        CASE(QGSP,"For calorimetry and high energy physics trackers and high-energy and medium-energy production targets -- uses theory driven modeling for the reactions of energetic pions, kaons, and nucleons. It employs quark gluon string model for the 'punch-through' interactions of the projectile with a nucleus, the string excitation cross-sections being calculated in quasi-eikonal approximation. A pre-equilibrium decay model with an extensive evaporation phase to model the behavior of the nucleus 'after the punch'. It uses current best pion cross-section.");
        CASE(QGSP_BERT,"Like QGSP, but using Geant4 Bertini cascade for primary protons, neutrons, pions and Kaons below ~10GeV. In comparison to experimental data we find improved agreement to data compared to QGSP which uses the low energy parameterised (LEP) model for all particles at these energies. The Bertini model produces more secondary neutrons and protons than the LEP model, yielding a better agreement to experimental data.");
        CASE(QGSP_BERT_EMV,"Like QGSP_BERT but with faster EM modeling.");
        CASE(QGSP_BERT_EMX,"Like QGSP_BERT but with low-energy EM modeling.");
        CASE(QGSP_BERT_HP,"Like QGSP_BERT but with _HP modeling for neutrons.");
        CASE(QGSP_BIC,"Like QGSP, but using Geant4 Binary cascade for primary protons and neutrons with energies below ~10GeV, thus replacing the use of the LEP model for protons and neutrons In comparison to teh LEP model, Binary cascade better describes production of secondary particles produced in interactions of protons and neutrons with nuclei.");
        CASE(QGSP_BIC_EMX,"Like QGSP_BIC but with low-energy EM modeling.");
        CASE(QGSP_BIC_HP,"Like QGSP_BIC but with _HP modeling for neutrons.");

        return "No synopsis available.";
}

---

Member Data Documentation

G4VUserPhysicsList* BLCMDphysics::physicsList [private]

Referenced by BLCMDphysics(), command(), and getPhysicsList().

G4int BLCMDphysics::doStochastics [private]

Referenced by BLCMDphysics(), defineNamedArgs(), and setDoStochastics().

G4String BLCMDphysics::disable [private]

Referenced by BLCMDphysics(), command(), and defineNamedArgs().

G4int BLCMDphysics::list [private]

Referenced by BLCMDphysics(), defineNamedArgs(), and setDoStochastics().

G4int BLCMDphysics::synchrotronRadiation [private]

Referenced by BLCMDphysics(), callback(), and defineNamedArgs().

G4int BLCMDphysics::synchrotronRadiationMuon [private]

Referenced by BLCMDphysics(), callback(), and defineNamedArgs().

G4int BLCMDphysics::gammaToMuPair [private]

Referenced by BLCMDphysics(), callback(), and defineNamedArgs().

std::vector<G4String> BLCMDphysics::disableList [private]

Referenced by command(), and setDoStochastics().

G4PhysListFactory* BLCMDphysics::physListFactory [private]

Referenced by BLCMDphysics(), command(), and listPhysicsLists().

---

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

• BLCMDphysics.cc