Import Geant4 3.1.0 source tree
This commit is contained in:
Gabriele Cosmo
@@ -0,0 +1,95 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
// and all its terms.
|
||||
//
|
||||
// $Id: ExN04EMPhysics.cc,v 1.1 2001/01/06 06:56:17 kurasige Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
|
||||
#include "ExN04EMPhysics.hh"
|
||||
|
||||
#include "globals.hh"
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
|
||||
|
||||
ExN04EMPhysics::ExN04EMPhysics(const G4String& name)
|
||||
: G4VPhysicsConstructor(name)
|
||||
{
|
||||
}
|
||||
|
||||
ExN04EMPhysics::~ExN04EMPhysics()
|
||||
{
|
||||
}
|
||||
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
|
||||
#include "G4Gamma.hh"
|
||||
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Positron.hh"
|
||||
|
||||
#include "G4NeutrinoE.hh"
|
||||
#include "G4AntiNeutrinoE.hh"
|
||||
|
||||
void ExN04EMPhysics::ConstructParticle()
|
||||
{
|
||||
// gamma
|
||||
G4Gamma::GammaDefinition();
|
||||
|
||||
// electron
|
||||
G4Electron::ElectronDefinition();
|
||||
G4Positron::PositronDefinition();
|
||||
G4NeutrinoE::NeutrinoEDefinition();
|
||||
G4AntiNeutrinoE::AntiNeutrinoEDefinition();
|
||||
}
|
||||
|
||||
|
||||
#include "G4ProcessManager.hh"
|
||||
|
||||
|
||||
void ExN04EMPhysics::ConstructProcess()
|
||||
{
|
||||
G4ProcessManager * pManager = 0;
|
||||
|
||||
// Gamma Physics
|
||||
pManager = G4Gamma::Gamma()->GetProcessManager();
|
||||
pManager->AddDiscreteProcess(&thePhotoEffect);
|
||||
pManager->AddDiscreteProcess(&theComptonEffect);
|
||||
pManager->AddDiscreteProcess(&thePairProduction);
|
||||
|
||||
// Electron Physics
|
||||
pManager = G4Electron::Electron()->GetProcessManager();
|
||||
// add processes
|
||||
pManager->AddDiscreteProcess(&theElectronBremsStrahlung);
|
||||
|
||||
pManager->AddProcess(&theElectronIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theElectronMultipleScattering);
|
||||
pManager->SetProcessOrdering(&theElectronMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theElectronMultipleScattering, idxPostStep, 1);
|
||||
|
||||
//Positron Physics
|
||||
pManager = G4Positron::Positron()->GetProcessManager();
|
||||
// add processes
|
||||
pManager->AddDiscreteProcess(&thePositronBremsStrahlung);
|
||||
|
||||
pManager->AddDiscreteProcess(&theAnnihilation);
|
||||
|
||||
pManager->AddRestProcess(&theAnnihilation);
|
||||
|
||||
pManager->AddProcess(&thePositronIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&thePositronMultipleScattering);
|
||||
pManager->SetProcessOrdering(&thePositronMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&thePositronMultipleScattering, idxPostStep, 1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
// and all its terms.
|
||||
//
|
||||
// $Id: ExN04GeneralPhysics.cc,v 1.1 2001/01/06 06:56:17 kurasige Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
|
||||
#include "ExN04GeneralPhysics.hh"
|
||||
|
||||
#include "globals.hh"
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
|
||||
ExN04GeneralPhysics::ExN04GeneralPhysics(const G4String& name)
|
||||
: G4VPhysicsConstructor(name)
|
||||
{
|
||||
}
|
||||
|
||||
ExN04GeneralPhysics::~ExN04GeneralPhysics()
|
||||
{
|
||||
}
|
||||
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ProcessManager.hh"
|
||||
// Bosons
|
||||
#include "G4ChargedGeantino.hh"
|
||||
#include "G4Geantino.hh"
|
||||
|
||||
void ExN04GeneralPhysics::ConstructParticle()
|
||||
{
|
||||
// pseudo-particles
|
||||
G4Geantino::GeantinoDefinition();
|
||||
G4ChargedGeantino::ChargedGeantinoDefinition();
|
||||
}
|
||||
|
||||
void ExN04GeneralPhysics::ConstructProcess()
|
||||
{
|
||||
// Add Decay Process
|
||||
theParticleIterator->reset();
|
||||
while( (*theParticleIterator)() ){
|
||||
G4ParticleDefinition* particle = theParticleIterator->value();
|
||||
G4ProcessManager* pmanager = particle->GetProcessManager();
|
||||
if (fDecayProcess.IsApplicable(*particle)) {
|
||||
pmanager ->AddProcess(&fDecayProcess);
|
||||
// set ordering for PostStepDoIt and AtRestDoIt
|
||||
pmanager ->SetProcessOrdering(&fDecayProcess, idxPostStep);
|
||||
pmanager ->SetProcessOrdering(&fDecayProcess, idxAtRest);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,412 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
// and all its terms.
|
||||
//
|
||||
// $Id: ExN04HadronPhysics.cc,v 1.1 2001/01/06 06:56:18 kurasige Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
|
||||
#include "ExN04HadronPhysics.hh"
|
||||
|
||||
#include "globals.hh"
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
|
||||
|
||||
ExN04HadronPhysics::ExN04HadronPhysics(const G4String& name)
|
||||
: G4VPhysicsConstructor(name)
|
||||
{
|
||||
}
|
||||
|
||||
ExN04HadronPhysics::~ExN04HadronPhysics()
|
||||
{
|
||||
}
|
||||
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
|
||||
// Nuclei
|
||||
#include "G4MesonConstructor.hh"
|
||||
#include "G4BaryonConstructor.hh"
|
||||
#include "G4ShortLivedConstructor.hh"
|
||||
|
||||
void ExN04HadronPhysics::ConstructParticle()
|
||||
{
|
||||
// Construct all mesons
|
||||
G4MesonConstructor pMesonConstructor;
|
||||
pMesonConstructor.ConstructParticle();
|
||||
|
||||
// Construct all barions
|
||||
G4BaryonConstructor pBaryonConstructor;
|
||||
pBaryonConstructor.ConstructParticle();
|
||||
|
||||
// Construct resonaces and quarks
|
||||
G4ShortLivedConstructor pShortLivedConstructor;
|
||||
pShortLivedConstructor.ConstructParticle();
|
||||
|
||||
}
|
||||
|
||||
|
||||
#include "G4ProcessManager.hh"
|
||||
|
||||
|
||||
void ExN04HadronPhysics::ConstructProcess()
|
||||
{
|
||||
G4ProcessManager * pManager = 0;
|
||||
|
||||
// Elastic Process
|
||||
theElasticModel = new G4LElastic();
|
||||
theElasticProcess.RegisterMe(theElasticModel);
|
||||
|
||||
// PionPlus
|
||||
pManager = G4PionPlus::PionPlus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEPionPlusModel = new G4LEPionPlusInelastic();
|
||||
theHEPionPlusModel = new G4HEPionPlusInelastic();
|
||||
thePionPlusInelastic.RegisterMe(theLEPionPlusModel);
|
||||
thePionPlusInelastic.RegisterMe(theHEPionPlusModel);
|
||||
pManager->AddDiscreteProcess(&thePionPlusInelastic);
|
||||
|
||||
pManager->AddProcess(&thePionPlusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&thePionPlusMult);
|
||||
pManager->SetProcessOrdering(&thePionPlusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&thePionPlusMult, idxPostStep, 1);
|
||||
|
||||
// PionMinus
|
||||
pManager = G4PionMinus::PionMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEPionMinusModel = new G4LEPionMinusInelastic();
|
||||
theHEPionMinusModel = new G4HEPionMinusInelastic();
|
||||
thePionMinusInelastic.RegisterMe(theLEPionMinusModel);
|
||||
thePionMinusInelastic.RegisterMe(theHEPionMinusModel);
|
||||
pManager->AddDiscreteProcess(&thePionMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&thePionMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&thePionMinusMult);
|
||||
pManager->SetProcessOrdering(&thePionMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&thePionMinusMult, idxPostStep, 1);
|
||||
|
||||
pManager->AddRestProcess(&thePionMinusAbsorption, ordDefault);
|
||||
|
||||
// KaonPlus
|
||||
pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEKaonPlusModel = new G4LEKaonPlusInelastic();
|
||||
theHEKaonPlusModel = new G4HEKaonPlusInelastic();
|
||||
theKaonPlusInelastic.RegisterMe(theLEKaonPlusModel);
|
||||
theKaonPlusInelastic.RegisterMe(theHEKaonPlusModel);
|
||||
pManager->AddDiscreteProcess(&theKaonPlusInelastic);
|
||||
|
||||
pManager->AddProcess(&theKaonPlusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theKaonPlusMult);
|
||||
pManager->SetProcessOrdering(&theKaonPlusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theKaonPlusMult, idxPostStep, 1);
|
||||
|
||||
// KaonMinus
|
||||
pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEKaonMinusModel = new G4LEKaonMinusInelastic();
|
||||
theHEKaonMinusModel = new G4HEKaonMinusInelastic();
|
||||
theKaonMinusInelastic.RegisterMe(theLEKaonMinusModel);
|
||||
theKaonMinusInelastic.RegisterMe(theHEKaonMinusModel);
|
||||
pManager->AddDiscreteProcess(&theKaonMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&theKaonMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theKaonMinusMult);
|
||||
pManager->SetProcessOrdering(&theKaonMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theKaonMinusMult, idxPostStep, 1);
|
||||
|
||||
pManager->AddRestProcess(&theKaonMinusAbsorption, ordDefault);
|
||||
|
||||
// KaonZeroL
|
||||
pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
|
||||
theHEKaonZeroLModel = new G4HEKaonZeroInelastic();
|
||||
theKaonZeroLInelastic.RegisterMe(theLEKaonZeroLModel);
|
||||
theKaonZeroLInelastic.RegisterMe(theHEKaonZeroLModel);
|
||||
pManager->AddDiscreteProcess(&theKaonZeroLInelastic);
|
||||
|
||||
// KaonZeroS
|
||||
pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
|
||||
theHEKaonZeroSModel = new G4HEKaonZeroInelastic();
|
||||
theKaonZeroSInelastic.RegisterMe(theLEKaonZeroSModel);
|
||||
theKaonZeroSInelastic.RegisterMe(theHEKaonZeroSModel);
|
||||
pManager->AddDiscreteProcess(&theKaonZeroSInelastic);
|
||||
|
||||
// Proton
|
||||
pManager = G4Proton::Proton()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEProtonModel = new G4LEProtonInelastic();
|
||||
theHEProtonModel = new G4HEProtonInelastic();
|
||||
theProtonInelastic.RegisterMe(theLEProtonModel);
|
||||
theProtonInelastic.RegisterMe(theHEProtonModel);
|
||||
pManager->AddDiscreteProcess(&theProtonInelastic);
|
||||
|
||||
pManager->AddProcess(&theProtonIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theProtonMult);
|
||||
pManager->SetProcessOrdering(&theProtonMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theProtonMult, idxPostStep, 1);
|
||||
|
||||
// anti-Proton
|
||||
pManager = G4AntiProton::AntiProton()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiProtonModel = new G4LEAntiProtonInelastic();
|
||||
theHEAntiProtonModel = new G4HEAntiProtonInelastic();
|
||||
theAntiProtonInelastic.RegisterMe(theLEAntiProtonModel);
|
||||
theAntiProtonInelastic.RegisterMe(theHEAntiProtonModel);
|
||||
pManager->AddDiscreteProcess(&theAntiProtonInelastic);
|
||||
|
||||
pManager->AddProcess(&theAntiProtonIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theAntiProtonMult);
|
||||
pManager->SetProcessOrdering(&theAntiProtonMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theAntiProtonMult, idxPostStep, 1);
|
||||
|
||||
pManager->AddRestProcess(&theAntiProtonAnnihilation);
|
||||
|
||||
// Neutron
|
||||
pManager = G4Neutron::Neutron()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLENeutronModel = new G4LENeutronInelastic();
|
||||
theHENeutronModel = new G4HENeutronInelastic();
|
||||
theNeutronInelastic.RegisterMe(theLENeutronModel);
|
||||
theNeutronInelastic.RegisterMe(theHENeutronModel);
|
||||
pManager->AddDiscreteProcess(&theNeutronInelastic);
|
||||
|
||||
//theNeutronFissionModel = new G4LFission();
|
||||
//theNeutronFission.RegisterMe(theNeutronFissionModel);
|
||||
//pManager->AddDiscreteProcess(&NeutronFission);
|
||||
|
||||
//theNeutronCaptureModel = new G4LCapture();
|
||||
//theNeutronCapture.RegisterMe(theNeutronCaptureModel);
|
||||
//pManager->AddDiscreteProcess(&theNeutronCapture);
|
||||
|
||||
// AntiNeutron
|
||||
pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
|
||||
theHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
|
||||
theAntiNeutronInelastic.RegisterMe(theLEAntiNeutronModel);
|
||||
theAntiNeutronInelastic.RegisterMe(theHEAntiNeutronModel);
|
||||
pManager->AddDiscreteProcess(&theAntiNeutronInelastic);
|
||||
|
||||
pManager->AddRestProcess(&theAntiNeutronAnnihilation);
|
||||
|
||||
// Lambda
|
||||
pManager = G4Lambda::Lambda()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLELambdaModel = new G4LELambdaInelastic();
|
||||
theHELambdaModel = new G4HELambdaInelastic();
|
||||
theLambdaInelastic.RegisterMe(theLELambdaModel);
|
||||
theLambdaInelastic.RegisterMe(theHELambdaModel);
|
||||
pManager->AddDiscreteProcess(&theLambdaInelastic);
|
||||
|
||||
// AntiLambda
|
||||
pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
|
||||
theHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
|
||||
theAntiLambdaInelastic.RegisterMe(theLEAntiLambdaModel);
|
||||
theAntiLambdaInelastic.RegisterMe(theHEAntiLambdaModel);
|
||||
pManager->AddDiscreteProcess(&theAntiLambdaInelastic);
|
||||
|
||||
// SigmaMinus
|
||||
pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLESigmaMinusModel = new G4LESigmaMinusInelastic();
|
||||
theHESigmaMinusModel = new G4HESigmaMinusInelastic();
|
||||
theSigmaMinusInelastic.RegisterMe(theLESigmaMinusModel);
|
||||
theSigmaMinusInelastic.RegisterMe(theHESigmaMinusModel);
|
||||
pManager->AddDiscreteProcess(&theSigmaMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&theSigmaMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theSigmaMinusMult);
|
||||
pManager->SetProcessOrdering(&theSigmaMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theSigmaMinusMult, idxPostStep, 1);
|
||||
|
||||
// anti-SigmaMinus
|
||||
pManager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
|
||||
theHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
|
||||
theAntiSigmaMinusInelastic.RegisterMe(theLEAntiSigmaMinusModel);
|
||||
theAntiSigmaMinusInelastic.RegisterMe(theHEAntiSigmaMinusModel);
|
||||
pManager->AddDiscreteProcess(&theAntiSigmaMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&theAntiSigmaMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theAntiSigmaMinusMult);
|
||||
pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxPostStep, 1);
|
||||
|
||||
// SigmaPlus
|
||||
pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLESigmaPlusModel = new G4LESigmaPlusInelastic();
|
||||
theHESigmaPlusModel = new G4HESigmaPlusInelastic();
|
||||
theSigmaPlusInelastic.RegisterMe(theLESigmaPlusModel);
|
||||
theSigmaPlusInelastic.RegisterMe(theHESigmaPlusModel);
|
||||
pManager->AddDiscreteProcess(&theSigmaPlusInelastic);
|
||||
|
||||
pManager->AddProcess(&theSigmaPlusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theSigmaPlusMult);
|
||||
pManager->SetProcessOrdering(&theSigmaPlusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theSigmaPlusMult, idxPostStep, 1);
|
||||
|
||||
// anti-SigmaPlus
|
||||
pManager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
|
||||
theHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
|
||||
theAntiSigmaPlusInelastic.RegisterMe(theLEAntiSigmaPlusModel);
|
||||
theAntiSigmaPlusInelastic.RegisterMe(theHEAntiSigmaPlusModel);
|
||||
pManager->AddDiscreteProcess(&theAntiSigmaPlusInelastic);
|
||||
|
||||
pManager->AddProcess(&theAntiSigmaPlusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theAntiSigmaPlusMult);
|
||||
pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxPostStep, 1);
|
||||
|
||||
// XiMinus
|
||||
pManager = G4XiMinus::XiMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEXiMinusModel = new G4LEXiMinusInelastic();
|
||||
theHEXiMinusModel = new G4HEXiMinusInelastic();
|
||||
theXiMinusInelastic.RegisterMe(theLEXiMinusModel);
|
||||
theXiMinusInelastic.RegisterMe(theHEXiMinusModel);
|
||||
pManager->AddDiscreteProcess(&theXiMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&theXiMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theXiMinusMult);
|
||||
pManager->SetProcessOrdering(&theXiMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theXiMinusMult, idxPostStep, 1);
|
||||
|
||||
// anti-XiMinus
|
||||
pManager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
|
||||
theHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
|
||||
theAntiXiMinusInelastic.RegisterMe(theLEAntiXiMinusModel);
|
||||
theAntiXiMinusInelastic.RegisterMe(theHEAntiXiMinusModel);
|
||||
pManager->AddDiscreteProcess(&theAntiXiMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&theAntiXiMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theAntiXiMinusMult);
|
||||
pManager->SetProcessOrdering(&theAntiXiMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theAntiXiMinusMult, idxPostStep, 1);
|
||||
|
||||
// XiZero
|
||||
pManager = G4XiZero::XiZero()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEXiZeroModel = new G4LEXiZeroInelastic();
|
||||
theHEXiZeroModel = new G4HEXiZeroInelastic();
|
||||
theXiZeroInelastic.RegisterMe(theLEXiZeroModel);
|
||||
theXiZeroInelastic.RegisterMe(theHEXiZeroModel);
|
||||
pManager->AddDiscreteProcess(&theXiZeroInelastic);
|
||||
|
||||
// anti-XiZero
|
||||
pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
|
||||
theHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
|
||||
theAntiXiZeroInelastic.RegisterMe(theLEAntiXiZeroModel);
|
||||
theAntiXiZeroInelastic.RegisterMe(theHEAntiXiZeroModel);
|
||||
pManager->AddDiscreteProcess(&theAntiXiZeroInelastic);
|
||||
|
||||
// OmegaMinus
|
||||
pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
|
||||
theHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
|
||||
theOmegaMinusInelastic.RegisterMe(theLEOmegaMinusModel);
|
||||
theOmegaMinusInelastic.RegisterMe(theHEOmegaMinusModel);
|
||||
pManager->AddDiscreteProcess(&theOmegaMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&theOmegaMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theOmegaMinusMult);
|
||||
pManager->SetProcessOrdering(&theOmegaMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theOmegaMinusMult, idxPostStep, 1);
|
||||
|
||||
// anti-OmegaMinus
|
||||
pManager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
theLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
|
||||
theHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
|
||||
theAntiOmegaMinusInelastic.RegisterMe(theLEAntiOmegaMinusModel);
|
||||
theAntiOmegaMinusInelastic.RegisterMe(theHEAntiOmegaMinusModel);
|
||||
pManager->AddDiscreteProcess(&theAntiOmegaMinusInelastic);
|
||||
|
||||
pManager->AddProcess(&theAntiOmegaMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&theAntiOmegaMinusMult);
|
||||
pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxPostStep, 1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
// and all its terms.
|
||||
//
|
||||
// $Id: ExN04IonPhysics.cc,v 1.1 2001/01/06 06:56:18 kurasige Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
|
||||
#include "ExN04IonPhysics.hh"
|
||||
|
||||
#include "globals.hh"
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
|
||||
|
||||
ExN04IonPhysics::ExN04IonPhysics(const G4String& name)
|
||||
: G4VPhysicsConstructor(name)
|
||||
{
|
||||
}
|
||||
|
||||
ExN04IonPhysics::~ExN04IonPhysics()
|
||||
{
|
||||
}
|
||||
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
|
||||
// Nuclei
|
||||
#include "G4IonConstructor.hh"
|
||||
|
||||
void ExN04IonPhysics::ConstructParticle()
|
||||
{
|
||||
// Construct light ions
|
||||
G4IonConstructor pConstructor;
|
||||
pConstructor.ConstructParticle();
|
||||
}
|
||||
|
||||
|
||||
#include "G4ProcessManager.hh"
|
||||
|
||||
|
||||
void ExN04IonPhysics::ConstructProcess()
|
||||
{
|
||||
G4ProcessManager * pManager = 0;
|
||||
|
||||
// Elastic Process
|
||||
theElasticModel = new G4LElastic();
|
||||
theElasticProcess.RegisterMe(theElasticModel);
|
||||
|
||||
// Generic Ion
|
||||
pManager = G4GenericIon::GenericIon()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
pManager->AddProcess(&fIonIonisation, ordInActive, 2, 2);
|
||||
|
||||
pManager->AddProcess(&fIonMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fIonMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fIonMultipleScattering, idxPostStep, 1);
|
||||
|
||||
// Deuteron
|
||||
pManager = G4Deuteron::Deuteron()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
fDeuteronModel = new G4LEDeuteronInelastic();
|
||||
fDeuteronProcess.RegisterMe(fDeuteronModel);
|
||||
pManager->AddDiscreteProcess(&fDeuteronProcess);
|
||||
|
||||
pManager->AddProcess(&fDeuteronIonisation, ordInActive, 2, 2);
|
||||
|
||||
pManager->AddProcess(&fDeuteronMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fDeuteronMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fDeuteronMultipleScattering, idxPostStep, 1);
|
||||
|
||||
// Triton
|
||||
pManager = G4Triton::Triton()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
fTritonModel = new G4LETritonInelastic();
|
||||
fTritonProcess.RegisterMe(fTritonModel);
|
||||
pManager->AddDiscreteProcess(&fTritonProcess);
|
||||
|
||||
pManager->AddProcess(&fTritonIonisation, ordInActive, 2, 2);
|
||||
|
||||
pManager->AddProcess(&fTritonMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fTritonMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fTritonMultipleScattering, idxPostStep, 1);
|
||||
|
||||
// Alpha
|
||||
pManager = G4Alpha::Alpha()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
fAlphaModel = new G4LEAlphaInelastic();
|
||||
fAlphaProcess.RegisterMe(fAlphaModel);
|
||||
pManager->AddDiscreteProcess(&fAlphaProcess);
|
||||
|
||||
pManager->AddProcess(&fAlphaIonisation, ordInActive, 2, 2);
|
||||
|
||||
pManager->AddProcess(&fAlphaMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fAlphaMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fAlphaMultipleScattering, idxPostStep, 1);
|
||||
|
||||
// He3
|
||||
pManager = G4He3::He3()->GetProcessManager();
|
||||
// add process
|
||||
pManager->AddDiscreteProcess(&theElasticProcess);
|
||||
|
||||
pManager->AddProcess(&fHe3Ionisation, ordInActive, 2, 2);
|
||||
|
||||
pManager->AddProcess(&fHe3MultipleScattering);
|
||||
pManager->SetProcessOrdering(&fHe3MultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fHe3MultipleScattering, idxPostStep, 1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,112 @@
|
||||
// This code implementation is the intellectual property of
|
||||
// the GEANT4 collaboration.
|
||||
//
|
||||
// By copying, distributing or modifying the Program (or any work
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
// and all its terms.
|
||||
//
|
||||
// $Id: ExN04MuonPhysics.cc,v 1.2 2001/03/06 10:11:21 kurasige Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
|
||||
#include "ExN04MuonPhysics.hh"
|
||||
|
||||
#include "globals.hh"
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
|
||||
|
||||
ExN04MuonPhysics::ExN04MuonPhysics(const G4String& name)
|
||||
: G4VPhysicsConstructor(name)
|
||||
{
|
||||
}
|
||||
|
||||
ExN04MuonPhysics::~ExN04MuonPhysics()
|
||||
{
|
||||
}
|
||||
|
||||
#include "G4ParticleDefinition.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
|
||||
#include "G4MuonPlus.hh"
|
||||
#include "G4MuonMinus.hh"
|
||||
#include "G4TauMinus.hh"
|
||||
#include "G4TauPlus.hh"
|
||||
#include "G4NeutrinoTau.hh"
|
||||
#include "G4AntiNeutrinoTau.hh"
|
||||
#include "G4NeutrinoMu.hh"
|
||||
#include "G4AntiNeutrinoMu.hh"
|
||||
|
||||
void ExN04MuonPhysics::ConstructParticle()
|
||||
{
|
||||
// Mu
|
||||
G4MuonPlus::MuonPlusDefinition();
|
||||
G4MuonMinus::MuonMinusDefinition();
|
||||
G4NeutrinoMu::NeutrinoMuDefinition();
|
||||
G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
|
||||
|
||||
// Tau
|
||||
G4TauMinus::TauMinusDefinition();
|
||||
G4TauPlus::TauPlusDefinition();
|
||||
G4NeutrinoTau::NeutrinoTauDefinition();
|
||||
G4AntiNeutrinoTau::AntiNeutrinoTauDefinition();
|
||||
|
||||
}
|
||||
|
||||
|
||||
#include "G4ProcessManager.hh"
|
||||
|
||||
void ExN04MuonPhysics::ConstructProcess()
|
||||
{
|
||||
G4ProcessManager * pManager = 0;
|
||||
|
||||
// Muon Plus Physics
|
||||
pManager = G4MuonPlus::MuonPlus()->GetProcessManager();
|
||||
// add processes
|
||||
pManager->AddProcess(&fMuPlusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddDiscreteProcess(&fMuPlusBremsstrahlung);
|
||||
|
||||
pManager->AddDiscreteProcess(&fMuPlusPairProduction);
|
||||
|
||||
pManager->AddProcess(&fMuPlusMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fMuPlusMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fMuPlusMultipleScattering, idxPostStep, 1);
|
||||
|
||||
// Muon Minus Physics
|
||||
pManager = G4MuonMinus::MuonMinus()->GetProcessManager();
|
||||
// add processes
|
||||
pManager->AddProcess(&fMuMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddDiscreteProcess(&fMuMinusBremsstrahlung);
|
||||
|
||||
pManager->AddDiscreteProcess(&fMuMinusPairProduction);
|
||||
|
||||
pManager->AddProcess(&fMuMinusMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fMuMinusMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fMuMinusMultipleScattering, idxPostStep, 1);
|
||||
pManager->AddRestProcess(&fMuMinusCaptureAtRest);
|
||||
|
||||
// Tau Plus Physics
|
||||
pManager = G4TauPlus::TauPlus()->GetProcessManager();
|
||||
// add processes
|
||||
pManager->AddProcess(&fTauPlusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&fTauPlusMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fTauPlusMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fTauPlusMultipleScattering, idxPostStep, 1);
|
||||
|
||||
// Tau Minus Physics
|
||||
pManager = G4TauMinus::TauMinus()->GetProcessManager();
|
||||
// add processes
|
||||
pManager->AddProcess(&fTauMinusIonisation, ordInActive,2, 2);
|
||||
|
||||
pManager->AddProcess(&fTauMinusMultipleScattering);
|
||||
pManager->SetProcessOrdering(&fTauMinusMultipleScattering, idxAlongStep, 1);
|
||||
pManager->SetProcessOrdering(&fTauMinusMultipleScattering, idxPostStep, 1);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -5,8 +5,8 @@
|
||||
// based on the Program) you indicate your acceptance of this statement,
|
||||
// and all its terms.
|
||||
//
|
||||
// $Id: ExN04PhysicsList.cc,v 1.8 2000/08/16 11:35:07 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-00 $
|
||||
// $Id: ExN04PhysicsList.cc,v 1.9 2001/01/06 06:56:18 kurasige Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
|
||||
@@ -19,627 +19,46 @@
|
||||
#include "G4ProcessVector.hh"
|
||||
#include "G4ParticleTypes.hh"
|
||||
#include "G4ParticleTable.hh"
|
||||
#include "G4BosonConstructor.hh"
|
||||
#include "G4LeptonConstructor.hh"
|
||||
#include "G4MesonConstructor.hh"
|
||||
#include "G4BaryonConstructor.hh"
|
||||
#include "G4IonConstructor.hh"
|
||||
#include "G4ShortLivedConstructor.hh"
|
||||
|
||||
#include "G4Material.hh"
|
||||
#include "G4MaterialTable.hh"
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
|
||||
#include "G4FastSimulationManagerProcess.hh"
|
||||
#include "ExN04GeneralPhysics.hh"
|
||||
#include "ExN04EMPhysics.hh"
|
||||
#include "ExN04MuonPhysics.hh"
|
||||
#include "ExN04HadronPhysics.hh"
|
||||
#include "ExN04IonPhysics.hh"
|
||||
|
||||
|
||||
ExN04PhysicsList::ExN04PhysicsList(): G4VUserPhysicsList()
|
||||
ExN04PhysicsList::ExN04PhysicsList(): G4VModularPhysicsList()
|
||||
{
|
||||
// default cut value (1.0mm)
|
||||
defaultCutValue = 1.0*mm;
|
||||
|
||||
SetVerboseLevel(1);
|
||||
|
||||
// General Physics
|
||||
RegisterPhysics( new ExN04GeneralPhysics("general") );
|
||||
|
||||
// EM Physics
|
||||
RegisterPhysics( new ExN04EMPhysics("standard EM"));
|
||||
|
||||
// Muon Physics
|
||||
RegisterPhysics( new ExN04MuonPhysics("muon"));
|
||||
|
||||
// Hadron Physics
|
||||
RegisterPhysics( new ExN04HadronPhysics("hadron"));
|
||||
|
||||
// Ion Physics
|
||||
RegisterPhysics( new ExN04IonPhysics("ion"));
|
||||
|
||||
|
||||
}
|
||||
|
||||
ExN04PhysicsList::~ExN04PhysicsList()
|
||||
{
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructParticle()
|
||||
{
|
||||
|
||||
// In this method, static member functions should be called
|
||||
// for all particles which you want to use.
|
||||
// This ensures that objects of these particle types will be
|
||||
// created in the program.
|
||||
|
||||
// create all particles
|
||||
ConstructAllBosons();
|
||||
ConstructAllLeptons();
|
||||
ConstructAllMesons();
|
||||
ConstructAllBaryons();
|
||||
ConstructAllIons();
|
||||
ConstructAllShortLiveds();
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructProcess()
|
||||
{
|
||||
AddTransportation();
|
||||
|
||||
ConstructEM();
|
||||
ConstructHad();
|
||||
ConstructGeneral();
|
||||
}
|
||||
|
||||
#include "G4ComptonScattering.hh"
|
||||
#include "G4GammaConversion.hh"
|
||||
#include "G4PhotoElectricEffect.hh"
|
||||
|
||||
#include "G4MultipleScattering.hh"
|
||||
|
||||
#include "G4eIonisation.hh"
|
||||
#include "G4eBremsstrahlung.hh"
|
||||
#include "G4eplusAnnihilation.hh"
|
||||
|
||||
#include "G4MuIonisation.hh"
|
||||
#include "G4MuBremsstrahlung.hh"
|
||||
#include "G4MuPairProduction.hh"
|
||||
|
||||
#include "G4hIonisation.hh"
|
||||
|
||||
void ExN04PhysicsList::ConstructEM()
|
||||
{
|
||||
theParticleIterator->reset();
|
||||
while( (*theParticleIterator)() ){
|
||||
G4ParticleDefinition* particle = theParticleIterator->value();
|
||||
G4ProcessManager* pmanager = particle->GetProcessManager();
|
||||
G4String particleName = particle->GetParticleName();
|
||||
|
||||
if (particleName == "gamma") {
|
||||
// gamma
|
||||
// Construct processes for gamma
|
||||
pmanager->AddDiscreteProcess(new G4GammaConversion());
|
||||
pmanager->AddDiscreteProcess(new G4ComptonScattering());
|
||||
pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
|
||||
|
||||
} else if (particleName == "e-") {
|
||||
//electron
|
||||
// Construct processes for electron
|
||||
G4VProcess* theeminusMultipleScattering = new G4MultipleScattering();
|
||||
G4VProcess* theeminusIonisation = new G4eIonisation();
|
||||
G4VProcess* theeminusBremsstrahlung = new G4eBremsstrahlung();
|
||||
// add processes
|
||||
pmanager->AddProcess(theeminusMultipleScattering);
|
||||
pmanager->AddProcess(theeminusIonisation);
|
||||
pmanager->AddProcess(theeminusBremsstrahlung);
|
||||
// set ordering for AlongStepDoIt
|
||||
pmanager->SetProcessOrdering(theeminusMultipleScattering, idxAlongStep, 1);
|
||||
pmanager->SetProcessOrdering(theeminusIonisation, idxAlongStep, 2);
|
||||
// set ordering for PostStepDoIt
|
||||
pmanager->SetProcessOrdering(theeminusMultipleScattering, idxPostStep, 1);
|
||||
pmanager->SetProcessOrdering(theeminusIonisation, idxPostStep, 2);
|
||||
pmanager->SetProcessOrdering(theeminusBremsstrahlung, idxPostStep, 3);
|
||||
|
||||
} else if (particleName == "e+") {
|
||||
//positron
|
||||
// Construct processes for positron
|
||||
G4VProcess* theeplusMultipleScattering = new G4MultipleScattering();
|
||||
G4VProcess* theeplusIonisation = new G4eIonisation();
|
||||
G4VProcess* theeplusBremsstrahlung = new G4eBremsstrahlung();
|
||||
G4VProcess* theeplusAnnihilation = new G4eplusAnnihilation();
|
||||
// add processes
|
||||
pmanager->AddProcess(theeplusMultipleScattering);
|
||||
pmanager->AddProcess(theeplusIonisation);
|
||||
pmanager->AddProcess(theeplusBremsstrahlung);
|
||||
pmanager->AddProcess(theeplusAnnihilation);
|
||||
// set ordering for AtRestDoIt
|
||||
pmanager->SetProcessOrderingToFirst(theeplusAnnihilation, idxAtRest);
|
||||
// set ordering for AlongStepDoIt
|
||||
pmanager->SetProcessOrdering(theeplusMultipleScattering, idxAlongStep, 1);
|
||||
pmanager->SetProcessOrdering(theeplusIonisation, idxAlongStep, 2);
|
||||
// set ordering for PostStepDoIt
|
||||
pmanager->SetProcessOrdering(theeplusMultipleScattering, idxPostStep, 1);
|
||||
pmanager->SetProcessOrdering(theeplusIonisation, idxPostStep, 2);
|
||||
pmanager->SetProcessOrdering(theeplusBremsstrahlung, idxPostStep, 3);
|
||||
pmanager->SetProcessOrdering(theeplusAnnihilation, idxPostStep, 4);
|
||||
|
||||
} else if( particleName == "mu+" ||
|
||||
particleName == "mu-" ) {
|
||||
//muon
|
||||
// Construct processes for muon+
|
||||
G4VProcess* aMultipleScattering = new G4MultipleScattering();
|
||||
G4VProcess* aBremsstrahlung = new G4MuBremsstrahlung();
|
||||
G4VProcess* aPairProduction = new G4MuPairProduction();
|
||||
G4VProcess* anIonisation = new G4MuIonisation();
|
||||
// add processes
|
||||
pmanager->AddProcess(anIonisation);
|
||||
pmanager->AddProcess(aMultipleScattering);
|
||||
pmanager->AddProcess(aBremsstrahlung);
|
||||
pmanager->AddProcess(aPairProduction);
|
||||
// set ordering for AlongStepDoIt
|
||||
pmanager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
|
||||
pmanager->SetProcessOrdering(anIonisation, idxAlongStep, 2);
|
||||
// set ordering for PostStepDoIt
|
||||
pmanager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
|
||||
pmanager->SetProcessOrdering(anIonisation, idxPostStep, 2);
|
||||
pmanager->SetProcessOrdering(aBremsstrahlung, idxPostStep, 3);
|
||||
pmanager->SetProcessOrdering(aPairProduction, idxPostStep, 4);
|
||||
|
||||
} else if( particleName == "GenericIon" ) {
|
||||
G4VProcess* aionIonization = new G4hIonisation;
|
||||
G4VProcess* aMultipleScattering = new G4MultipleScattering();
|
||||
pmanager->AddProcess(aionIonization);
|
||||
pmanager->AddProcess(aMultipleScattering);
|
||||
// set ordering for AlongStepDoIt
|
||||
pmanager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
|
||||
pmanager->SetProcessOrdering(aionIonization, idxAlongStep, 2);
|
||||
// set ordering for PostStepDoIt
|
||||
pmanager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
|
||||
pmanager->SetProcessOrdering(aionIonization, idxPostStep, 2);
|
||||
|
||||
} else if ((!particle->IsShortLived()) &&
|
||||
(particle->GetPDGCharge() != 0.0) &&
|
||||
(particle->GetParticleName() != "chargedgeantino")) {
|
||||
// all others charged particles except geantino
|
||||
G4VProcess* aMultipleScattering = new G4MultipleScattering();
|
||||
G4VProcess* anIonisation = new G4hIonisation();
|
||||
// add processes
|
||||
pmanager->AddProcess(anIonisation);
|
||||
pmanager->AddProcess(aMultipleScattering);
|
||||
// set ordering for AlongStepDoIt
|
||||
pmanager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
|
||||
pmanager->SetProcessOrdering(anIonisation, idxAlongStep, 2);
|
||||
// set ordering for PostStepDoIt
|
||||
pmanager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
|
||||
pmanager->SetProcessOrdering(anIonisation, idxPostStep, 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Hadron Processes
|
||||
|
||||
#include "G4HadronElasticProcess.hh"
|
||||
|
||||
#include "G4PionPlusInelasticProcess.hh"
|
||||
#include "G4PionMinusInelasticProcess.hh"
|
||||
#include "G4KaonPlusInelasticProcess.hh"
|
||||
#include "G4KaonZeroSInelasticProcess.hh"
|
||||
#include "G4KaonZeroLInelasticProcess.hh"
|
||||
#include "G4KaonMinusInelasticProcess.hh"
|
||||
#include "G4ProtonInelasticProcess.hh"
|
||||
#include "G4AntiProtonInelasticProcess.hh"
|
||||
#include "G4NeutronInelasticProcess.hh"
|
||||
#include "G4AntiNeutronInelasticProcess.hh"
|
||||
#include "G4LambdaInelasticProcess.hh"
|
||||
#include "G4AntiLambdaInelasticProcess.hh"
|
||||
#include "G4SigmaPlusInelasticProcess.hh"
|
||||
#include "G4SigmaMinusInelasticProcess.hh"
|
||||
#include "G4AntiSigmaPlusInelasticProcess.hh"
|
||||
#include "G4AntiSigmaMinusInelasticProcess.hh"
|
||||
#include "G4XiZeroInelasticProcess.hh"
|
||||
#include "G4XiMinusInelasticProcess.hh"
|
||||
#include "G4AntiXiZeroInelasticProcess.hh"
|
||||
#include "G4AntiXiMinusInelasticProcess.hh"
|
||||
#include "G4DeuteronInelasticProcess.hh"
|
||||
#include "G4TritonInelasticProcess.hh"
|
||||
#include "G4AlphaInelasticProcess.hh"
|
||||
#include "G4OmegaMinusInelasticProcess.hh"
|
||||
#include "G4AntiOmegaMinusInelasticProcess.hh"
|
||||
|
||||
// Low-energy Models
|
||||
|
||||
#include "G4LElastic.hh"
|
||||
|
||||
#include "G4LEPionPlusInelastic.hh"
|
||||
#include "G4LEPionMinusInelastic.hh"
|
||||
#include "G4LEKaonPlusInelastic.hh"
|
||||
#include "G4LEKaonZeroSInelastic.hh"
|
||||
#include "G4LEKaonZeroLInelastic.hh"
|
||||
#include "G4LEKaonMinusInelastic.hh"
|
||||
#include "G4LEProtonInelastic.hh"
|
||||
#include "G4LEAntiProtonInelastic.hh"
|
||||
#include "G4LENeutronInelastic.hh"
|
||||
#include "G4LEAntiNeutronInelastic.hh"
|
||||
#include "G4LELambdaInelastic.hh"
|
||||
#include "G4LEAntiLambdaInelastic.hh"
|
||||
#include "G4LESigmaPlusInelastic.hh"
|
||||
#include "G4LESigmaMinusInelastic.hh"
|
||||
#include "G4LEAntiSigmaPlusInelastic.hh"
|
||||
#include "G4LEAntiSigmaMinusInelastic.hh"
|
||||
#include "G4LEXiZeroInelastic.hh"
|
||||
#include "G4LEXiMinusInelastic.hh"
|
||||
#include "G4LEAntiXiZeroInelastic.hh"
|
||||
#include "G4LEAntiXiMinusInelastic.hh"
|
||||
#include "G4LEDeuteronInelastic.hh"
|
||||
#include "G4LETritonInelastic.hh"
|
||||
#include "G4LEAlphaInelastic.hh"
|
||||
#include "G4LEOmegaMinusInelastic.hh"
|
||||
#include "G4LEAntiOmegaMinusInelastic.hh"
|
||||
|
||||
// High-energy Models
|
||||
|
||||
#include "G4HEPionPlusInelastic.hh"
|
||||
#include "G4HEPionMinusInelastic.hh"
|
||||
#include "G4HEKaonPlusInelastic.hh"
|
||||
#include "G4HEKaonZeroInelastic.hh"
|
||||
#include "G4HEKaonZeroInelastic.hh"
|
||||
#include "G4HEKaonMinusInelastic.hh"
|
||||
#include "G4HEProtonInelastic.hh"
|
||||
#include "G4HEAntiProtonInelastic.hh"
|
||||
#include "G4HENeutronInelastic.hh"
|
||||
#include "G4HEAntiNeutronInelastic.hh"
|
||||
#include "G4HELambdaInelastic.hh"
|
||||
#include "G4HEAntiLambdaInelastic.hh"
|
||||
#include "G4HESigmaPlusInelastic.hh"
|
||||
#include "G4HESigmaMinusInelastic.hh"
|
||||
#include "G4HEAntiSigmaPlusInelastic.hh"
|
||||
#include "G4HEAntiSigmaMinusInelastic.hh"
|
||||
#include "G4HEXiZeroInelastic.hh"
|
||||
#include "G4HEXiMinusInelastic.hh"
|
||||
#include "G4HEAntiXiZeroInelastic.hh"
|
||||
#include "G4HEAntiXiMinusInelastic.hh"
|
||||
#include "G4HEOmegaMinusInelastic.hh"
|
||||
#include "G4HEAntiOmegaMinusInelastic.hh"
|
||||
|
||||
// Stopping processes
|
||||
|
||||
#ifdef TRIUMF_STOP_PIMINUS
|
||||
#include "G4PionMinusAbsorptionAtRest.hh"
|
||||
#else
|
||||
#include "G4PiMinusAbsorptionAtRest.hh"
|
||||
#endif
|
||||
#ifdef TRIUMF_STOP_KMINUS
|
||||
#include "G4KaonMinusAbsorption.hh"
|
||||
#else
|
||||
#include "G4KaonMinusAbsorptionAtRest.hh"
|
||||
#endif
|
||||
|
||||
//
|
||||
// ConstructHad()
|
||||
//
|
||||
// Makes discrete physics processes for the hadrons, at present limited
|
||||
// to those particles with GHEISHA interactions (INTRC > 0).
|
||||
// The processes are: Elastic scattering and Inelastic scattering.
|
||||
//
|
||||
// F.W.Jones 09-JUL-1998
|
||||
//
|
||||
|
||||
void ExN04PhysicsList::ConstructHad()
|
||||
{
|
||||
G4HadronElasticProcess* theElasticProcess =
|
||||
new G4HadronElasticProcess;
|
||||
G4LElastic* theElasticModel = new G4LElastic;
|
||||
theElasticProcess->RegisterMe(theElasticModel);
|
||||
|
||||
theParticleIterator->reset();
|
||||
while ((*theParticleIterator)()) {
|
||||
G4ParticleDefinition* particle = theParticleIterator->value();
|
||||
G4ProcessManager* pmanager = particle->GetProcessManager();
|
||||
G4String particleName = particle->GetParticleName();
|
||||
|
||||
if (particleName == "pi+") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4PionPlusInelasticProcess* theInelasticProcess =
|
||||
new G4PionPlusInelasticProcess("inelastic");
|
||||
G4LEPionPlusInelastic* theLEInelasticModel =
|
||||
new G4LEPionPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEPionPlusInelastic* theHEInelasticModel =
|
||||
new G4HEPionPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "pi-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4PionMinusInelasticProcess* theInelasticProcess =
|
||||
new G4PionMinusInelasticProcess("inelastic");
|
||||
G4LEPionMinusInelastic* theLEInelasticModel =
|
||||
new G4LEPionMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEPionMinusInelastic* theHEInelasticModel =
|
||||
new G4HEPionMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
#ifdef TRIUMF_STOP_PIMINUS
|
||||
pmanager->AddRestProcess(new G4PionMinusAbsorptionAtRest, ordDefault);
|
||||
#else
|
||||
G4String prcNam;
|
||||
pmanager->AddRestProcess(
|
||||
new G4PiMinusAbsorptionAtRest(
|
||||
prcNam="PiMinusAbsorptionAtRest"), ordDefault);
|
||||
#endif
|
||||
}
|
||||
else if (particleName == "kaon+") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4KaonPlusInelasticProcess* theInelasticProcess =
|
||||
new G4KaonPlusInelasticProcess("inelastic");
|
||||
G4LEKaonPlusInelastic* theLEInelasticModel =
|
||||
new G4LEKaonPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEKaonPlusInelastic* theHEInelasticModel =
|
||||
new G4HEKaonPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "kaon0S") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4KaonZeroSInelasticProcess* theInelasticProcess =
|
||||
new G4KaonZeroSInelasticProcess("inelastic");
|
||||
G4LEKaonZeroSInelastic* theLEInelasticModel =
|
||||
new G4LEKaonZeroSInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEKaonZeroInelastic* theHEInelasticModel =
|
||||
new G4HEKaonZeroInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "kaon0L") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4KaonZeroLInelasticProcess* theInelasticProcess =
|
||||
new G4KaonZeroLInelasticProcess("inelastic");
|
||||
G4LEKaonZeroLInelastic* theLEInelasticModel =
|
||||
new G4LEKaonZeroLInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEKaonZeroInelastic* theHEInelasticModel =
|
||||
new G4HEKaonZeroInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "kaon-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4KaonMinusInelasticProcess* theInelasticProcess =
|
||||
new G4KaonMinusInelasticProcess("inelastic");
|
||||
G4LEKaonMinusInelastic* theLEInelasticModel =
|
||||
new G4LEKaonMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEKaonMinusInelastic* theHEInelasticModel =
|
||||
new G4HEKaonMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
#ifdef TRIUMF_STOP_KMINUS
|
||||
pmanager->AddRestProcess(new G4KaonMinusAbsorption, ordDefault);
|
||||
#else
|
||||
pmanager->AddRestProcess(new G4KaonMinusAbsorptionAtRest, ordDefault);
|
||||
#endif
|
||||
}
|
||||
else if (particleName == "proton") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4ProtonInelasticProcess* theInelasticProcess =
|
||||
new G4ProtonInelasticProcess("inelastic");
|
||||
G4LEProtonInelastic* theLEInelasticModel = new G4LEProtonInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEProtonInelastic* theHEInelasticModel = new G4HEProtonInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_proton") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiProtonInelasticProcess* theInelasticProcess =
|
||||
new G4AntiProtonInelasticProcess("inelastic");
|
||||
G4LEAntiProtonInelastic* theLEInelasticModel =
|
||||
new G4LEAntiProtonInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiProtonInelastic* theHEInelasticModel =
|
||||
new G4HEAntiProtonInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "neutron") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4NeutronInelasticProcess* theInelasticProcess =
|
||||
new G4NeutronInelasticProcess("inelastic");
|
||||
G4LENeutronInelastic* theLEInelasticModel =
|
||||
new G4LENeutronInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HENeutronInelastic* theHEInelasticModel =
|
||||
new G4HENeutronInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_neutron") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiNeutronInelasticProcess* theInelasticProcess =
|
||||
new G4AntiNeutronInelasticProcess("inelastic");
|
||||
G4LEAntiNeutronInelastic* theLEInelasticModel =
|
||||
new G4LEAntiNeutronInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiNeutronInelastic* theHEInelasticModel =
|
||||
new G4HEAntiNeutronInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "lambda") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4LambdaInelasticProcess* theInelasticProcess =
|
||||
new G4LambdaInelasticProcess("inelastic");
|
||||
G4LELambdaInelastic* theLEInelasticModel = new G4LELambdaInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HELambdaInelastic* theHEInelasticModel = new G4HELambdaInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_lambda") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiLambdaInelasticProcess* theInelasticProcess =
|
||||
new G4AntiLambdaInelasticProcess("inelastic");
|
||||
G4LEAntiLambdaInelastic* theLEInelasticModel =
|
||||
new G4LEAntiLambdaInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiLambdaInelastic* theHEInelasticModel =
|
||||
new G4HEAntiLambdaInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "sigma+") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4SigmaPlusInelasticProcess* theInelasticProcess =
|
||||
new G4SigmaPlusInelasticProcess("inelastic");
|
||||
G4LESigmaPlusInelastic* theLEInelasticModel =
|
||||
new G4LESigmaPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HESigmaPlusInelastic* theHEInelasticModel =
|
||||
new G4HESigmaPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "sigma-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4SigmaMinusInelasticProcess* theInelasticProcess =
|
||||
new G4SigmaMinusInelasticProcess("inelastic");
|
||||
G4LESigmaMinusInelastic* theLEInelasticModel =
|
||||
new G4LESigmaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HESigmaMinusInelastic* theHEInelasticModel =
|
||||
new G4HESigmaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_sigma+") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiSigmaPlusInelasticProcess* theInelasticProcess =
|
||||
new G4AntiSigmaPlusInelasticProcess("inelastic");
|
||||
G4LEAntiSigmaPlusInelastic* theLEInelasticModel =
|
||||
new G4LEAntiSigmaPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiSigmaPlusInelastic* theHEInelasticModel =
|
||||
new G4HEAntiSigmaPlusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_sigma-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiSigmaMinusInelasticProcess* theInelasticProcess =
|
||||
new G4AntiSigmaMinusInelasticProcess("inelastic");
|
||||
G4LEAntiSigmaMinusInelastic* theLEInelasticModel =
|
||||
new G4LEAntiSigmaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiSigmaMinusInelastic* theHEInelasticModel =
|
||||
new G4HEAntiSigmaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "xi0") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4XiZeroInelasticProcess* theInelasticProcess =
|
||||
new G4XiZeroInelasticProcess("inelastic");
|
||||
G4LEXiZeroInelastic* theLEInelasticModel =
|
||||
new G4LEXiZeroInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEXiZeroInelastic* theHEInelasticModel =
|
||||
new G4HEXiZeroInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "xi-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4XiMinusInelasticProcess* theInelasticProcess =
|
||||
new G4XiMinusInelasticProcess("inelastic");
|
||||
G4LEXiMinusInelastic* theLEInelasticModel =
|
||||
new G4LEXiMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEXiMinusInelastic* theHEInelasticModel =
|
||||
new G4HEXiMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_xi0") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiXiZeroInelasticProcess* theInelasticProcess =
|
||||
new G4AntiXiZeroInelasticProcess("inelastic");
|
||||
G4LEAntiXiZeroInelastic* theLEInelasticModel =
|
||||
new G4LEAntiXiZeroInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiXiZeroInelastic* theHEInelasticModel =
|
||||
new G4HEAntiXiZeroInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_xi-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiXiMinusInelasticProcess* theInelasticProcess =
|
||||
new G4AntiXiMinusInelasticProcess("inelastic");
|
||||
G4LEAntiXiMinusInelastic* theLEInelasticModel =
|
||||
new G4LEAntiXiMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiXiMinusInelastic* theHEInelasticModel =
|
||||
new G4HEAntiXiMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "deuteron") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4DeuteronInelasticProcess* theInelasticProcess =
|
||||
new G4DeuteronInelasticProcess("inelastic");
|
||||
G4LEDeuteronInelastic* theLEInelasticModel =
|
||||
new G4LEDeuteronInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "triton") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4TritonInelasticProcess* theInelasticProcess =
|
||||
new G4TritonInelasticProcess("inelastic");
|
||||
G4LETritonInelastic* theLEInelasticModel =
|
||||
new G4LETritonInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "alpha") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AlphaInelasticProcess* theInelasticProcess =
|
||||
new G4AlphaInelasticProcess("inelastic");
|
||||
G4LEAlphaInelastic* theLEInelasticModel =
|
||||
new G4LEAlphaInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "omega-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4OmegaMinusInelasticProcess* theInelasticProcess =
|
||||
new G4OmegaMinusInelasticProcess("inelastic");
|
||||
G4LEOmegaMinusInelastic* theLEInelasticModel =
|
||||
new G4LEOmegaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEOmegaMinusInelastic* theHEInelasticModel =
|
||||
new G4HEOmegaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
else if (particleName == "anti_omega-") {
|
||||
pmanager->AddDiscreteProcess(theElasticProcess);
|
||||
G4AntiOmegaMinusInelasticProcess* theInelasticProcess =
|
||||
new G4AntiOmegaMinusInelasticProcess("inelastic");
|
||||
G4LEAntiOmegaMinusInelastic* theLEInelasticModel =
|
||||
new G4LEAntiOmegaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theLEInelasticModel);
|
||||
G4HEAntiOmegaMinusInelastic* theHEInelasticModel =
|
||||
new G4HEAntiOmegaMinusInelastic;
|
||||
theInelasticProcess->RegisterMe(theHEInelasticModel);
|
||||
pmanager->AddDiscreteProcess(theInelasticProcess);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#include "G4Decay.hh"
|
||||
void ExN04PhysicsList::ConstructGeneral()
|
||||
{
|
||||
// Add Decay Process
|
||||
G4Decay* theDecayProcess = new G4Decay();
|
||||
theParticleIterator->reset();
|
||||
while( (*theParticleIterator)() ){
|
||||
G4ParticleDefinition* particle = theParticleIterator->value();
|
||||
G4ProcessManager* pmanager = particle->GetProcessManager();
|
||||
if (theDecayProcess->IsApplicable(*particle)) {
|
||||
pmanager ->AddProcess(theDecayProcess);
|
||||
// set ordering for PostStepDoIt and AtRestDoIt
|
||||
pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
|
||||
pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::SetCuts()
|
||||
{
|
||||
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
|
||||
@@ -647,45 +66,5 @@ void ExN04PhysicsList::SetCuts()
|
||||
SetCutsWithDefault();
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructAllBosons()
|
||||
{
|
||||
// Construct all bosons
|
||||
G4BosonConstructor pConstructor;
|
||||
pConstructor.ConstructParticle();
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructAllLeptons()
|
||||
{
|
||||
// Construct all leptons
|
||||
G4LeptonConstructor pConstructor;
|
||||
pConstructor.ConstructParticle();
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructAllMesons()
|
||||
{
|
||||
// Construct all mesons
|
||||
G4MesonConstructor pConstructor;
|
||||
pConstructor.ConstructParticle();
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructAllBaryons()
|
||||
{
|
||||
// Construct all barions
|
||||
G4BaryonConstructor pConstructor;
|
||||
pConstructor.ConstructParticle();
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructAllIons()
|
||||
{
|
||||
// Construct light ions
|
||||
G4IonConstructor pConstructor;
|
||||
pConstructor.ConstructParticle();
|
||||
}
|
||||
|
||||
void ExN04PhysicsList::ConstructAllShortLiveds()
|
||||
{
|
||||
// Construct resonaces and quarks
|
||||
G4ShortLivedConstructor pConstructor;
|
||||
pConstructor.ConstructParticle();
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user