// $Id$
// Category: physics
//
+// Author: I. Hrivnacova
+//
+// Class TG4PhysicsManager
+// -----------------------
// See the class description in the header file.
#include "TG4PhysicsManager.h"
-#include "TG4PhysicsList.h"
-#include "TG4CutVector.h"
-#include "TG4FlagVector.h"
-#include "TG4G3Defaults.h"
+#include "TG4ModularPhysicsList.h"
+#include "TG4ParticlesManager.h"
+#include "TG4G3PhysicsManager.h"
+#include "TG4PhysicsConstructorGeneral.h"
+#include "TG4PhysicsConstructorEM.h"
+#include "TG4PhysicsConstructorMuon.h"
+#include "TG4PhysicsConstructorHadron.h"
+#include "TG4PhysicsConstructorIon.h"
+#include "TG4PhysicsConstructorOptical.h"
+#include "TG4PhysicsConstructorSpecialCuts.h"
+#include "TG4PhysicsConstructorSpecialControls.h"
+#include "TG4GeometryServices.h"
+#include "TG4G3Cut.h"
+#include "TG4G3Control.h"
+#include "TG4G3Units.h"
+#include "TG4Limits.h"
+#include "AliDecayer.h"
#include <G4ParticleDefinition.hh>
+#include <G4OpBoundaryProcess.hh>
+#include <G4VProcess.hh>
+#include <G3MedTable.hh>
#include <TDatabasePDG.h>
TG4PhysicsManager* TG4PhysicsManager::fgInstance = 0;
-TG4PhysicsManager::TG4PhysicsManager()
- : fLock(false),
- fPhysicsList(0),
- fCutVector(0),
- fFlagVector(0)
+//_____________________________________________________________________________
+TG4PhysicsManager::TG4PhysicsManager(TG4ModularPhysicsList* physicsList)
+ : TG4Verbose("physicsManager"),
+ fMessenger(this),
+ fPhysicsList(physicsList),
+ fDecayer(0),
+ fSetEMPhysics(true),
+ fSetMuonPhysics(true),
+ fSetHadronPhysics(false),
+ fSetOpticalPhysics(false),
+ fSetSpecialCutsPhysics(false),
+ fSetSpecialControlsPhysics(false)
+
{
//
if (fgInstance) {
}
fgInstance = this;
+
+ // create particles manager
+ fParticlesManager = new TG4ParticlesManager();
- // initialize fIsCutVector
- fIsCutVector = new TG4boolVector;
- G4int i;
- //for (i=0; i<kNofParticlesWSP; i++) fIsCutVector->insert(false);
- for (i=0; i<kNofParticlesWSP; i++) fIsCutVector->push_back(false);
-
- // initialize fIsFlagVector
- fIsFlagVector = new TG4boolVector;
- //for (i=0; i<kNofParticlesWSP; i++) fIsFlagVector->insert(false);
- for (i=0; i<kNofParticlesWSP; i++) fIsFlagVector->push_back(false);
-
- // define fCutNameVector
- fG3CutNameVector.insert("CUTGAM");
- fG3CutNameVector.insert("CUTELE");
- fG3CutNameVector.insert("CUTNEU");
- fG3CutNameVector.insert("CUTHAD");
- fG3CutNameVector.insert("CUTMUO");
- fG3CutNameVector.insert("BCUTE");
- fG3CutNameVector.insert("BCUTM");
- fG3CutNameVector.insert("DCUTE");
- fG3CutNameVector.insert("DCUTM");
- fG3CutNameVector.insert("PPCUTM");
-
- // define fFlagNameVector
- fG3FlagNameVector.insert("PAIR");
- fG3FlagNameVector.insert("COMP");
- fG3FlagNameVector.insert("PHOT");
- fG3FlagNameVector.insert("PFIS");
- fG3FlagNameVector.insert("DRAY");
- fG3FlagNameVector.insert("ANNI");
- fG3FlagNameVector.insert("BREM");
- fG3FlagNameVector.insert("HADR");
- fG3FlagNameVector.insert("MUNU");
- fG3FlagNameVector.insert("DCAY");
- fG3FlagNameVector.insert("LOSS");
- fG3FlagNameVector.insert("MULS");
+ // create G3 physics manager
+ fG3PhysicsManager = new TG4G3PhysicsManager();
+
+ // fill process name map
+ // FillProcessMap();
}
-TG4PhysicsManager::TG4PhysicsManager(const TG4PhysicsManager& right) {
+//_____________________________________________________________________________
+TG4PhysicsManager::TG4PhysicsManager()
+ : TG4Verbose("physicsManager"),
+ fMessenger(this) {
+//
+}
+
+//_____________________________________________________________________________
+TG4PhysicsManager::TG4PhysicsManager(const TG4PhysicsManager& right)
+ : TG4Verbose("physicsManager"),
+ fMessenger(this) {
//
TG4Globals::Exception(
"Attempt to copy TG4PhysicsManager singleton.");
}
+//_____________________________________________________________________________
TG4PhysicsManager::~TG4PhysicsManager() {
//
- delete fIsCutVector;
- delete fIsFlagVector;
+ delete fDecayer;
+ delete fParticlesManager;
+ delete fG3PhysicsManager;
}
// operators
+//_____________________________________________________________________________
TG4PhysicsManager&
TG4PhysicsManager::operator=(const TG4PhysicsManager& right)
{
// private methods
-void TG4PhysicsManager::LockException() const
+//_____________________________________________________________________________
+void TG4PhysicsManager::FillProcessMap()
{
-// Gives exception in case of attempt to modified physics
-// setup after physics manager was locked.
+// Fills fProcessMCMap.
+// The default G4 process names are used in the map.
+// Not used - the map is filled in physics constructors
+// only with processes that are really built.
// ---
- G4String text = "TG4PhysicsManager: \n";
- text = text + " It is too late to change physics setup. \n";
- text = text + " PhysicsManager has been already locked.";
- TG4Globals::Exception(text);
-}
+ // multiple scattering
+ fProcessMCMap.Add("msc", kPMultipleScattering);
+ fProcessMCMap.Add("Imsc", kPMultipleScattering);
+
+ // continuous energy loss
+ // !! including delta rays
+ fProcessMCMap.Add("eIoni", kPEnergyLoss);
+ fProcessMCMap.Add("IeIoni", kPEnergyLoss);
+ fProcessMCMap.Add("LowEnergyIoni", kPEnergyLoss);
+ fProcessMCMap.Add("hIoni", kPEnergyLoss);
+ fProcessMCMap.Add("IhIoni", kPEnergyLoss);
+ fProcessMCMap.Add("hLowEIoni", kPEnergyLoss);
+ fProcessMCMap.Add("MuIoni", kPEnergyLoss);
+ fProcessMCMap.Add("IMuIonisation", kPEnergyLoss);
+ fProcessMCMap.Add("ionIoni", kPEnergyLoss);
+ fProcessMCMap.Add("ionLowEIoni", kPEnergyLoss);
+ fProcessMCMap.Add("PAIonisation", kPEnergyLoss);
+
+ // bending in mag. field
+ // kPMagneticFieldL
-G4int TG4PhysicsManager::GetPDGEncoding(G4ParticleDefinition* particle)
-{
-// Returns the PDG code of particle;
-// if standard PDG code is not defined the TDatabasePDG
-// is used.
-// ---
+ // particle decay
+ fProcessMCMap.Add("Decay", kPDecay);
+
+ // photon pair production or
+ // muon direct pair production
+ fProcessMCMap.Add("conv", kPPair);
+ fProcessMCMap.Add("LowEnConversion", kPPair);
+ fProcessMCMap.Add("MuPairProd", kPPair);
+ fProcessMCMap.Add("IMuPairProduction", kPPair);
+
+ // Compton scattering
+ fProcessMCMap.Add("compt", kPCompton);
+ fProcessMCMap.Add("LowEnCompton", kPCompton);
+ fProcessMCMap.Add("polarCompt", kPCompton);
+
+ // photoelectric effect
+ fProcessMCMap.Add("phot", kPPhotoelectric);
+ fProcessMCMap.Add("LowEnPhotoElec", kPPhotoelectric);
+
+ // bremsstrahlung
+ fProcessMCMap.Add("eBrem", kPBrem);
+ fProcessMCMap.Add("IeBrem", kPBrem);
+ fProcessMCMap.Add("MuBrems", kPBrem);
+ fProcessMCMap.Add("IMuBremsstrahlung", kPBrem);
+ fProcessMCMap.Add("LowEnBrem", kPBrem);
+
+ // delta-ray production
+ // kPDeltaRay
+ // has to be distinguished from kPEnergyLoss on flight
+
+ // positron annihilation
+ fProcessMCMap.Add("annihil", kPAnnihilation);
+ fProcessMCMap.Add("Iannihil", kPAnnihilation);
- // get PDG encoding from G4 particle definition
- G4int pdgEncoding = particle->GetPDGEncoding();
+ // hadronic interaction
+ // kPHadronic
- if (pdgEncoding == 0) {
- // get PDG encoding from TDatabasePDG
+ // nuclear evaporation
+ // kPEvaporation
- // get particle name from the name map
- G4String g4name = particle->GetParticleName();
- G4String tname = fParticleNameMap.GetSecond(g4name);
- if (tname == "Undefined") {
- G4String text = "TG4PhysicsManager::GetPDGEncoding: \n";
- text = text + " Particle " + g4name;
- text = text + " was not found in the name map.";
- TG4Globals::Exception(text);
- }
+ // nuclear fission
+ // kPNuclearFission
+
+ // nuclear absorption
+ fProcessMCMap.Add("PionMinusAbsorptionAtRest", kPNuclearAbsorption);
+ fProcessMCMap.Add("PiMinusAbsorptionAtRest", kPNuclearAbsorption);
+ fProcessMCMap.Add("KaonMinusAbsorption", kPNuclearAbsorption);
+ fProcessMCMap.Add("KaonMinusAbsorptionAtRest", kPNuclearAbsorption);
- // get particle from TDatabasePDG
- TDatabasePDG* pdgDB = TDatabasePDG::Instance();
- TParticlePDG* particle = pdgDB->GetParticle(tname);
- if (!particle) {
- G4String text = "TG4PhysicsManager::GetPDGEncoding: \n";
- text = text + " Particle " + tname;
- text = text + " was not found in TDatabasePDG.";
- TG4Globals::Exception(text);
- }
-
- // get PDG encoding
- pdgEncoding = particle->PdgCode();
- }
-
- return pdgEncoding;
+ // antiproton annihilation
+ fProcessMCMap.Add("AntiProtonAnnihilationAtRest", kPPbarAnnihilation);
+ // fProcessMCMap.Add("AntiNeutronAnnihilationAtRest", not defined);
+
+ // neutron capture
+ fProcessMCMap.Add("NeutronCaptureAtRest", kPNCapture);
+ // fProcessMCMap.Add("LCapture", hadron capture not defined);
+
+ // hadronic elastic incoherent scattering
+ fProcessMCMap.Add("LElastic", kPHElastic);
+
+ // hadronic inelastic scattering
+ fProcessMCMap.Add("inelastic", kPHInhelastic);
+
+ // muon nuclear interaction
+ fProcessMCMap.Add("MuNucl", kPMuonNuclear);
+
+ // exceeded time of flight cut
+ // kPTOFlimit
+
+ // nuclear photofission
+ // kPPhotoFission
+
+ // Rayleigh scattering
+ fProcessMCMap.Add("Rayleigh Scattering", kPRayleigh);
+
+ // no mechanism is active, usually at the entrance of a new volume
+ fProcessMCMap.Add("Transportation", kPNull);
+
+ // particle has fallen below energy threshold and tracking stops
+ // kPStop
+
+ // Cerenkov photon absorption
+ fProcessMCMap.Add("Absorption", kPLightAbsorption);
+
+ // Cerenkov photon reflection/refraction
+ // kPLightScattering, kPLightReflection, kPLightRefraction
+ // has to be inquired from the G4OpBoundary process
+
+ // synchrotron radiation
+ fProcessMCMap.Add("SynchrotronRadiation", kPSynchrotron);
}
-
-G4int TG4PhysicsManager::GetPDGEncoding(G4String particleName)
+
+//_____________________________________________________________________________
+void TG4PhysicsManager::GstparCut(G4int itmed, TG4G3Cut par, G4double parval)
{
-// Returns the PDG code of particle sepcified by name.
+// Sets special tracking medium parameter.
+// It is applied to all logical volumes that use the specified
+// tracking medium.
// ---
- G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
+ // get medium from table
+ G3MedTableEntry* medium = G3Med.get(itmed);
+ if (!medium) {
+ G4String text = "TG4PhysicsManager::GstparCut: \n";
+ text = text + " Medium not found.";
+ G4Exception(text);
+ }
- G4ParticleDefinition* particle = 0;
- particle = particleTable->FindParticle(particleName);
- if (!particle) {
- G4String text = "TG4PhysicsManager::GetPDGEncoding:\n";
- text = text + " G4ParticleTable::FindParticle() " + particleName;
- text = text + " failed.";
- TG4Globals::Exception(text);
- }
+ // get/create user limits
+ TG4Limits* limits
+ = TG4GeometryServices::Instance()->GetLimits(medium->GetLimits());
+
+ if (!limits) {
+ limits = new TG4Limits(*fG3PhysicsManager->GetCutVector(),
+ *fG3PhysicsManager->GetControlVector());
+ medium->SetLimits(limits);
+
+ if (VerboseLevel() > 1) {
+ G4cout << "TG4PhysicsManager::GstparCut: new TG4Limits() for medium "
+ << itmed << " has been created." << G4endl;
+ }
+ }
+
+ // add units
+ if (par == kTOFMAX) parval *= TG4G3Units::Time();
+ else parval *= TG4G3Units::Energy();
+
+ // set parameter
+ limits->SetG3Cut(par, parval);
+}
- return GetPDGEncoding(particle);
-}
+
+//_____________________________________________________________________________
+void TG4PhysicsManager::GstparControl(G4int itmed, TG4G3Control par,
+ TG4G3ControlValue parval)
+{
+// Sets special tracking medium parameter.
+// It is applied to all logical volumes that use the specified
+// tracking medium.
+// ---
+
+ // get medium from table
+ G3MedTableEntry* medium = G3Med.get(itmed);
+ if (!medium) {
+ G4String text = "TG4PhysicsManager::GstparControl: \n";
+ text = text + " Medium not found.";
+ G4Exception(text);
+ }
+
+ // get/create user limits
+ TG4Limits* limits
+ = TG4GeometryServices::Instance()->GetLimits(medium->GetLimits());
+
+ if (!limits) {
+ limits = new TG4Limits(*fG3PhysicsManager->GetCutVector(),
+ *fG3PhysicsManager->GetControlVector());
+ medium->SetLimits(limits);
+
+ if (VerboseLevel() > 1) {
+ G4cout << "TG4PhysicsManager::GstparControl: new TG4Limits() for medium"
+ << itmed << " has been created." << G4endl;
+ }
+ }
-void TG4PhysicsManager::SetCut(TG3Cut cut, G4double cutValue)
-{
-// Sets kinetic energy cut (in a G3-like way).
+ // set parameter
+ limits->SetG3Control(par, parval);
+}
+
+// public methods
+
+//_____________________________________________________________________________
+void TG4PhysicsManager::Gstpar(Int_t itmed, const char *param, Float_t parval)
+{
+// Passes the tracking medium parameter to TG4Limits.
+// The tracking medium parameter is set only in case
+// its value is different from the "global" physics setup.
+// (If: CheckCut/ControlWithG3Defaults is used checking
+// is performed with respect to G3 default values.)
+// When any cut/control parameter is set in limits
+// the physics manager is locked and the physics setup
+// cannot be changed.
+// Applying this TG4Limits to particles and physical
+// processes is still in development.
+//
+// Geant3 desription:
+// ==================
+// To change the value of cut or mechanism "CHPAR"
+// to a new value PARVAL for tracking medium ITMED
+// The data structure JTMED contains the standard tracking
+// parameters (CUTS and flags to control the physics processes) which
+// are used by default for all tracking media. It is possible to
+// redefine individually with GSTPAR any of these parameters for a
+// given tracking medium.
+// ITMED tracking medium number
+// CHPAR is a character string (variable name)
+// PARVAL must be given as a floating point.
// ---
- if (!fCutVector) {
- // create vector of kinetic energy cut values
- fCutVector = new TG4CutVector();
+ G4String name = TG4GeometryServices::Instance()->CutName(param);
+ TG4G3Cut cut;
+ if (fG3PhysicsManager->CheckCutWithTheVector(name, parval, cut)) {
+ GstparCut(itmed, cut, parval);
+ fG3PhysicsManager->Lock();
}
- fCutVector->SetG3Cut(cut, cutValue);
- SwitchIsCutVector(cut);
-}
+ else {
+ TG4G3Control control;
+ TG4G3ControlValue controlValue;
+ if (fG3PhysicsManager
+ ->CheckControlWithTheVector(name, parval, control, controlValue)) {
+ GstparControl(itmed, control, controlValue);
+ fG3PhysicsManager->Lock();
+ }
+ else if (cut==kNoG3Cuts && control==kNoG3Controls) {
+ G4String text = "TG4PhysicsManager::Gstpar:";
+ text = text + name;
+ text = text + " parameter is not yet implemented.";
+ TG4Globals::Warning(text);
+ }
+ }
+}
+
+//_____________________________________________________________________________
+void TG4PhysicsManager::CreatePhysicsConstructors()
+{
+// Creates the selected physics constructors
+// and registeres them in the modular physics list.
+// ---
-void TG4PhysicsManager::SetProcess(TG3Flag flag, G4int flagValue)
+ // general physics
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorGeneral(VerboseLevel()));
+
+ // electromagnetic physics
+ if (fSetEMPhysics)
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorEM(VerboseLevel()));
+
+ // muon physics
+ if (fSetMuonPhysics && fSetEMPhysics)
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorMuon(VerboseLevel()));
+
+ // hadron physics
+ if (fSetEMPhysics || fSetHadronPhysics) {
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorIon(
+ VerboseLevel(), fSetEMPhysics, fSetHadronPhysics));
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorHadron(
+ VerboseLevel(), fSetEMPhysics, fSetHadronPhysics));
+ }
+
+ // optical physics
+ if (fSetOpticalPhysics)
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorOptical(VerboseLevel()));
+
+ // special processes
+ if (fSetSpecialCutsPhysics)
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorSpecialCuts(VerboseLevel()));
+
+ if (fSetSpecialControlsPhysics)
+ fPhysicsList->RegisterPhysics(
+ new TG4PhysicsConstructorSpecialControls(VerboseLevel()));
+
+ // warn about not allowed combinations
+ if (fSetMuonPhysics && !fSetEMPhysics) {
+ G4String text = "TG4PhysicsManager::CreatePhysicsConstructors:\n";
+ text = text + " Muon physics cannot be constructed without EM physics.\n";
+ text = text + " SetMuon control was ignored.";
+ TG4Globals::Warning(text);
+ }
+
+ // all created physics constructors are deleted
+ // in the TG4ModularPhysicsList destructor
+}
+
+//_____________________________________________________________________________
+void TG4PhysicsManager::SetCut(const char* cutName, Float_t cutValue)
{
-// Sets control process flag (in a G3-like way).
+// Sets the specified cut.
// ---
- if (!fFlagVector) {
- // create vector of control process flag values
- fFlagVector = new TG4FlagVector;
+ fG3PhysicsManager->CheckLock();
+ TG4G3Cut g3Cut = TG4G3CutVector::GetCut(cutName);
+
+ if (g3Cut == kNoG3Cuts) {
+ G4String text = "TG4PhysicsManager::SetCut:\n";
+ text = text + " Parameter " + cutName;
+ text = text + " is not implemented.";
+ TG4Globals::Warning(text);
+ return;
}
- fFlagVector->SetG3Flag(flag, flagValue);
-}
+
+ // add units
+ if (g3Cut == kTOFMAX) cutValue *= TG4G3Units::Time();
+ else cutValue *= TG4G3Units::Energy();
+
+ fG3PhysicsManager->SetCut(g3Cut, cutValue);
+}
+
+//_____________________________________________________________________________
+void TG4PhysicsManager::SetProcess(const char* controlName, Int_t value)
+{
+// Sets the specified process control.
+// ---
+ fG3PhysicsManager->CheckLock();
+ TG4G3Control control = TG4G3ControlVector::GetControl(controlName);
+
+ if (control != kNoG3Controls) {
+ TG4G3ControlValue controlValue
+ = TG4G3ControlVector::GetControlValue(value, control);
+ fG3PhysicsManager->SetProcess(control, controlValue);
+ }
+ else {
+ G4String text = "TG4PhysicsManager::SetProcess:\n";
+ text = text + " Parameter " + controlName;
+ text = text + " is not implemented.";
+ TG4Globals::Warning(text);
+ }
+}
+//_____________________________________________________________________________
Float_t TG4PhysicsManager::Xsec(char* ch, Float_t p1, Int_t i1, Int_t i2)
{
// Not yet implemented -> gives exception.
return 0.;
}
+//_____________________________________________________________________________
Int_t TG4PhysicsManager::IdFromPDG(Int_t pdgID) const
{
// G4 does not use the integer particle identifiers
return pdgID;
}
+//_____________________________________________________________________________
Int_t TG4PhysicsManager::PDGFromId(Int_t mcID) const
{
// G4 does not use integer particle identifiers
return mcID;
}
+//_____________________________________________________________________________
void TG4PhysicsManager::DefineParticles()
{
// ======
// end of "common" implementation
// ======
- // map G4 particle names to TDatabasePDG names
- // (the map is built only for particles that have not
- // defined standard PDG encoding)
-
- fParticleNameMap.Add("deuteron","Deuteron");
- fParticleNameMap.Add("triton", "Triton");
- fParticleNameMap.Add("alpha", "Alpha");
- fParticleNameMap.Add("He3", "HE3");
- fParticleNameMap.Add("opticalphoton","Cherenkov");
- // fParticleNameMap.Add("???","FeedbackPhoton");
- fParticleNameMap.Add("geantino", "Rootino");
-
- // map G4 particle names to TDatabasePDG encodings
- fParticlePDGMap.Add("deuteron", GetPDGEncoding("deuteron"));
- fParticlePDGMap.Add("triton", GetPDGEncoding("triton"));
- fParticlePDGMap.Add("alpha", GetPDGEncoding("alpha"));
- fParticlePDGMap.Add("He3", GetPDGEncoding("He3") );
- fParticlePDGMap.Add("opticalphoton", GetPDGEncoding("opticalphoton"));
- // fParticlePDGMap.Add("???","FeedbackPhoton");
- fParticleNameMap.Add("geantino", GetPDGEncoding("geantino"));
-
- // add verbose
- G4cout << "Particle maps have been filled." << G4endl;
- //fParticleNameMap.PrintAll();
- //fParticlePDGMap.PrintAll();
-}
-
-void TG4PhysicsManager::SwitchIsCutVector(TG3Cut cut)
-{
-// Updates the vector of booleans (fIsCutVector) for the specified cut.
-// ---
-
- switch (cut) {
- case kCUTGAM:
- (*fIsCutVector)[kGamma] = true;
- break;
- case kBCUTE:
- (*fIsCutVector)[kGamma] = true;
- break;
- case kBCUTM:
- (*fIsCutVector)[kGamma] = true;
- break;
- case kCUTELE:
- (*fIsCutVector)[kElectron] = true;
- break;
- case kDCUTE:
- (*fIsCutVector)[kElectron] = true;
- break;
- case kDCUTM:
- (*fIsCutVector)[kElectron] = true;
- break;
- case kCUTNEU:
- (*fIsCutVector)[kNeutralHadron] = true;
- break;
- case kCUTHAD:
- (*fIsCutVector)[kChargedHadron] = true;
- break;
- case kCUTMUO:
- (*fIsCutVector)[kMuon] = true;
- break;
- default:
- break;
- }
-}
-
-void TG4PhysicsManager::SwitchIsFlagVector(TG3Flag flag)
-{
-// Updates the vector of booleans (fIsFlagVector) for the specified flag.
-// ---
-
- switch (flag) {
- case kPAIR:
- // gamma
- (*fIsFlagVector)[kGamma] = true;
- break;
- case kCOMP:
- // gamma
- (*fIsFlagVector)[kGamma] = true;
- break;
- case kPHOT:
- // gamma
- (*fIsFlagVector)[kGamma] = true;
- break;
- case kPFIS:
- // gamma
- (*fIsFlagVector)[kGamma] = true;
- break;
- case kDRAY:
- // all charged particles
- (*fIsFlagVector)[kElectron] = true;
- (*fIsFlagVector)[kEplus] = true;
- (*fIsFlagVector)[kChargedHadron] = true;
- (*fIsFlagVector)[kMuon] = true;
- break;
- case kANNI:
- // e+ only
- (*fIsFlagVector)[kEplus] = true;
- break;
- case kBREM:
- // e-/e+, muons
- (*fIsFlagVector)[kElectron] = true;
- (*fIsFlagVector)[kEplus] = true;
- (*fIsFlagVector)[kMuon] = true;
- break;
- case kHADR:
- // hadrons
- (*fIsFlagVector)[kNeutralHadron] = true;
- (*fIsFlagVector)[kChargedHadron] = true;
- break;
- case kMUNU:
- // muons
- (*fIsFlagVector)[kMuon] = true;
- break;
- case kDCAY:
- // any
- (*fIsFlagVector)[kAny] = true;
- break;
- case kLOSS:
- // all charged particles
- (*fIsFlagVector)[kElectron] = true;
- (*fIsFlagVector)[kEplus] = true;
- (*fIsFlagVector)[kChargedHadron] = true;
- (*fIsFlagVector)[kMuon] = true;
- break;
- case kMULS:
- // all charged particles
- (*fIsFlagVector)[kElectron] = true;
- (*fIsFlagVector)[kEplus] = true;
- (*fIsFlagVector)[kChargedHadron] = true;
- (*fIsFlagVector)[kMuon] = true;
- break;
- default:
- break;
- }
-}
-
-TG3Cut TG4PhysicsManager::GetG3Cut(G4String cutName)
-{
-// Retrieves corresponding TG3Cut constant from the cutName.
-// ---
-
- if (cutName == fG3CutNameVector[kCUTGAM]) return kCUTGAM;
- else if (cutName == fG3CutNameVector[kBCUTE]) return kBCUTE;
- else if (cutName == fG3CutNameVector[kBCUTM]) return kBCUTM;
- else if (cutName == fG3CutNameVector[kCUTELE]) return kCUTELE;
- else if (cutName == fG3CutNameVector[kDCUTE]) return kDCUTE;
- else if (cutName == fG3CutNameVector[kDCUTM]) return kDCUTM;
- else if (cutName == fG3CutNameVector[kCUTNEU]) return kCUTNEU;
- else if (cutName == fG3CutNameVector[kCUTHAD]) return kCUTHAD;
- else if (cutName == fG3CutNameVector[kCUTMUO]) return kCUTMUO;
- else return kNoG3Cuts;
-}
-
-TG3Flag TG4PhysicsManager::GetG3Flag(G4String flagName)
-{
-// Retrieves corresponding TG3Flag constant from the flagName.
-// ---
-
- if (flagName == fG3FlagNameVector[kPAIR]) return kPAIR;
- else if (flagName == fG3FlagNameVector[kCOMP]) return kCOMP;
- else if (flagName == fG3FlagNameVector[kPHOT]) return kPHOT;
- else if (flagName == fG3FlagNameVector[kPFIS]) return kPFIS;
- else if (flagName == fG3FlagNameVector[kDRAY]) return kDRAY;
- else if (flagName == fG3FlagNameVector[kANNI]) return kANNI;
- else if (flagName == fG3FlagNameVector[kBREM]) return kBREM;
- else if (flagName == fG3FlagNameVector[kHADR]) return kHADR;
- else if (flagName == fG3FlagNameVector[kMUNU]) return kMUNU;
- else if (flagName == fG3FlagNameVector[kDCAY]) return kDCAY;
- else if (flagName == fG3FlagNameVector[kLOSS]) return kLOSS;
- else if (flagName == fG3FlagNameVector[kMULS]) return kMULS;
- else return kNoG3Flags;
-}
-
-// public methods
-
-void TG4PhysicsManager::BuildPhysics()
-{
-// Empty function - not needed in G4.
-// (Physics is built within /run/initialize.)
-
- TG4Globals::Warning(
- "TG4PhysicsManager::BuildPhysics: is empty function in G4 MC.");
+ fParticlesManager->MapParticles();
}
-void TG4PhysicsManager::SetCut(const char* cutName, Float_t cutValue)
-{
-// Sets the specified cut.
-// ---
-
- if (fLock) LockException();
- TG3Cut g3Cut = GetG3Cut(cutName);
- if (g3Cut != kNoG3Cuts)
- SetCut(g3Cut, cutValue);
- else {
- G4String text = "TG4PhysicsManager::SetCut:\n";
- text = text + " Parameter " + cutName;
- text = text + " is not implemented.";
- TG4Globals::Warning(text);
- }
-}
-
-void TG4PhysicsManager::SetProcess(const char* flagName, Int_t flagValue)
-{
-// Sets the specified process control.
-// ---
-
- if (fLock) LockException();
- TG3Flag g3Flag = GetG3Flag(flagName);
- if (g3Flag != kNoG3Flags)
- SetProcess(g3Flag, flagValue);
- else {
- G4String text = "TG4PhysicsManager::SetProcess:\n";
- text = text + " Parameter " + flagName;
- text = text + " is not implemented.";
- TG4Globals::Warning(text);
- }
-}
-
+//_____________________________________________________________________________
void TG4PhysicsManager::SetProcessActivation()
{
// (In)Activates built processes according
-// to the setup in fFlagVector.
+// to the setup in TG4G3PhysicsManager::fControlVector.
// ---
- if (fPhysicsList) {
- // temporarily excluded
- // fPhysicsList->SetProcessActivation();
- }
- else {
- G4String text = "TG4PhysicsManager::SetProcessActivation:\n";
- text = text + " There is no physics list set.";
- TG4Globals::Exception(text);
- }
+ fPhysicsList->SetProcessActivation();
}
-G4int TG4PhysicsManager::GetPDGEncodingFast(G4ParticleDefinition* particle)
-{
-// Returns the PDG code of particle;
-// if standard PDG code is not defined the preregistred
-// fParticlePDGMap is used.
-// ---
-
- // get PDG encoding from G4 particle definition
- G4int pdgEncoding = particle->GetPDGEncoding();
-
- if (pdgEncoding == 0) {
- // use FParticlePDGMap if standard PDG code is not defined
- G4String name = particle->GetParticleName();
- pdgEncoding = fParticlePDGMap.GetSecond(name);
- }
-
- return pdgEncoding;
-}
-
-G4bool TG4PhysicsManager::CheckCutWithCutVector(G4String name,
- G4double value, TG3Cut& cut)
-{
-// Retrieves corresponding TG3Cut from the name and
-// in case the value is different from the value in cutVector
-// sets true the value of the fIsCutVector element
-// corresponding to this cut and returns true;
-// returns false otherwise.
-// ---
-
- // convert cut name -> TG3Cut
- cut = GetG3Cut(name);
-
- // set switch vector element only if the value
- // is different from the value in cutVector
- if (cut !=kNoG3Cuts) {
- // get tolerance from TG4G3Defaults in GeV
- G4double tolerance = TG4G3Defaults::CutTolerance()/GeV;
- if (!(fCutVector) || (abs(value - (*fCutVector)[cut]) > tolerance)) {
- SwitchIsCutVector(cut);
- return true;
- }
- else return false;
- }
- return false;
-}
-G4bool TG4PhysicsManager::CheckFlagWithFlagVector(G4String name,
- G4double value, TG3Flag& flag)
+//_____________________________________________________________________________
+AliMCProcess TG4PhysicsManager::GetMCProcess(const G4VProcess* process)
{
-// Retrieves corresponding TG3Flag from the name and
-// in case the value is different from the value in flagVector
-// sets true the value of the fIsFlagVector element
-// corresponding to this flag and returns true;
-// returns false otherwise.
+// Returns the AliMCProcess code of the specified G4 process.
// ---
+
+ if (!process) return kPNoProcess;
- // convert flag name -> TG3Flag
- flag = GetG3Flag(name);
-
- // set switch vector element only if the value
- // is different from the value in flagVector
- if (flag !=kNoG3Flags) {
- if (!(fFlagVector) || (abs(value - (*fFlagVector)[flag]) > 0.01)) {
- SwitchIsFlagVector(flag);
- return true;
- }
- else return false;
- }
- return false;
+ return fProcessMCMap.GetMCProcess(process);
}
-G4bool TG4PhysicsManager::CheckCutWithG3Defaults(G4String name,
- G4double value, TG3Cut& cut)
+//_____________________________________________________________________________
+AliMCProcess TG4PhysicsManager::GetOpBoundaryStatus(const G4VProcess* process)
{
-// Retrieves corresponding TG3Cut from the name and
-// in case the value is different from the G3 default value
-// sets true the value of the SwitchCutVector element
-// corresponding to this cut and returns true;
-// returns false otherwise.
+// Returns the AliMCProcess code according to the OpBoundary process
+// status.
// ---
+
+ if (!process) return kPNoProcess;
- // convert cut name -> TG3Cut
- cut = GetG3Cut(name);
-
- // set switch vector element only if the value
- // is different from G3 default
- if (cut !=kNoG3Cuts) {
- if (!TG4G3Defaults::IsDefaultCut(cut, value)) {
- SwitchIsCutVector(cut);
- return true;
- }
- else return false;
- }
- return false;
-}
-
-G4bool TG4PhysicsManager::CheckFlagWithG3Defaults(G4String name,
- G4double value, TG3Flag& flag)
-{
-// Retrieves corresponding TG3Flag from the name and
-// in case the value is different from the G3 default value
-// sets true the value of the SwitchFlagVector element
-// corresponding to this flag and returns true;
-// returns false otherwise.
-// ---
-
- // convert flag name -> TG3Flag
- flag = GetG3Flag(name);
-
- // set switch vector element only if the value
- // is different from G3 default
- if (flag !=kNoG3Flags) {
- if (!TG4G3Defaults::IsDefaultFlag(flag, value)) {
- SwitchIsFlagVector(flag);
- return true;
- }
- else return false;
- }
- return false;
-}
-
-void TG4PhysicsManager::SetG3DefaultCuts()
-{
-// Sets G3 default values of kinetic energy cuts.
-// ---
-
- if (fLock) LockException();
- if (!fCutVector) {
- // create vector of kinetic energy cut values
- fCutVector = new TG4CutVector();
- }
- fCutVector->SetG3Defaults();
-}
-
-void TG4PhysicsManager::SetG3DefaultProcesses()
-{
-// Sets G3 default values of control process flags.
-// ---
-
- if (fLock) LockException();
- if (!fFlagVector) {
- // create vector of control process flag values
- fFlagVector = new TG4FlagVector;
- }
- fFlagVector->SetG3Defaults();
-}
-
-G4bool TG4PhysicsManager::IsSpecialCuts() const
-{
-// Returns true if any special cut value is set.
-// ---
-
- for (G4int i=0; i<kNofParticlesWSP; i++)
- { if ((*fIsCutVector)[i]) return true; }
-
- return false;
-}
-
-G4bool TG4PhysicsManager::IsSpecialFlags() const
-{
-// Returns true if any special flag value is set.
-// ---
-
- for (G4int i=0; i<kNofParticlesWSP; i++)
- { if ((*fIsFlagVector)[i]) return true; }
-
- return false;
-}
-
-TG3ParticleWSP TG4PhysicsManager::GetG3ParticleWSP(
- G4ParticleDefinition* particle) const
-{
-// Returns TG3ParticleWSP constant for the specified particle.
-// (See TG3ParticleWSP.h, too.)
-// ---
-
- G4String name = particle->GetParticleName();
- G4String pType = particle->GetParticleType();
+#ifdef TGEANT4_DEBUG
+ G4OpBoundaryProcess* opBoundary
+ = dynamic_cast<G4OpBoundaryProcess*>(process);
- if (name == "gamma") {
- return kGamma;
- }
- else if (name == "e-") {
- return kElectron;
- }
- else if (name == "e+") {
- return kEplus;
- }
- else if (( pType == "baryon" || pType == "meson" || pType == "nucleus" )) {
- if (particle->GetPDGCharge() == 0) {
- return kNeutralHadron;
- }
- else
- return kChargedHadron;
- }
- else if ( name == "mu-" || name == "mu+" ) {
- return kMuon;
- }
- else {
- return kNofParticlesWSP;
- }
-}
-
-void TG4PhysicsManager::GetG3ParticleWSPName(G4int particleWSP,
- G4String& name) const
-{
-// Fills the passed name with the name/type of particle specified
-// by TG3ParticleWSP constant.
-// (See TG3ParticleWSP.h, too.)
-// ---
-
- switch (particleWSP) {
- case kGamma:
- name = "Gamma";
- break;
- case kElectron:
- name = "Electron";
- break;
- case kEplus:
- name = "Eplus";
- break;
- case kNeutralHadron:
- name = "NeutralHadron";
- break;
- case kChargedHadron:
- name = "ChargedHadron";
- break;
- case kMuon:
- name = "Muon";
- break;
- case kAny:
- name = "Any";
- break;
- case kNofParticlesWSP:
- name = "NoSP";
- break;
- default:
- G4String text = "TG4PhysicsList::GetG3ParticleWSPName:\n";
- text = text + " Wrong particleWSP.";
- TG4Globals::Exception(text);
- break;
+ if (!opBoundary)
+ TG4Globals::Exception(
+ "TG4PhysicsManager::GetOpBoundaryStatus: Wrong process type.");
+ return kPNoProcess;
}
-}
+
+ return opBoundary;
+#else
+ G4OpBoundaryProcess* opBoundary = (G4OpBoundaryProcess*)process;
+#endif
+
+ switch (opBoundary->GetStatus()) {
+ // reflection
+ case FresnelReflection:
+ case TotalInternalReflection:
+ case LambertianReflection:
+ case LobeReflection:
+ case SpikeReflection:
+ case BackScattering:
+ return kPLightReflection;
+ ;;
+
+ // refraction
+ case FresnelRefraction:
+ return kPLightReflection;
+ ;;
+
+ // absorption
+ case Absorption:
+ case Detection:
+ return kPLightAbsorption;
+ ;;
+ }
+
+ // should not happen
+ return kPNoProcess;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff