LMU/musrsim
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New Physics List. Deleted old Physics

Browse Source
This commit is contained in:
paraiso
2006-02-25 16:30:29 +00:00
parent efcc59f589
commit 505a247f60
4 changed files with 0 additions and 801 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
geant4/LEMuSR/src/LEMuSREMPhysics.cc
View File

@ -1,96 +0,0 @@
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//*
// LOW ENERGY MUON SPIN RELAXATION, ROTATION, RADIATION
//
// ID :LEMuSREMPhysics.cc , v 1.3
// AUTHOR: Taofiq PARAISO
// DATE : 2004-09-17 10:20
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//
// & &&&&&&&&&& &&&&&&& &&&&&&&&
// & & && && & &&
// & & & & & & &&
// & &&&&&&& & & &&&&&& &&&&&&&&
// & & & && & & &&
// & & && & & && && & &
// &&&&&&&&&& &&&&&&&&&& & &&&&& && &&&&&&& & &&
// &
// &
// &
// &
// ElectroMagnetic Physics List
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
#include "LEMuSREMPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
LEMuSREMPhysics::LEMuSREMPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
LEMuSREMPhysics::~LEMuSREMPhysics()
{
}
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoE.hh"
#include "G4UserSpecialCuts.hh"
void LEMuSREMPhysics::ConstructParticle()
{
// gamma
G4Gamma::GammaDefinition();
// electron
G4Electron::ElectronDefinition();
G4Positron::PositronDefinition();
G4NeutrinoE::NeutrinoEDefinition();
G4AntiNeutrinoE::AntiNeutrinoEDefinition();
}
#include "G4ProcessManager.hh"
void LEMuSREMPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
// Gamma Physics
pManager = G4Gamma::Gamma()->GetProcessManager();
pManager->AddDiscreteProcess(&thePhotoEffect);
pManager->AddDiscreteProcess(&theComptonEffect);
pManager->AddDiscreteProcess(&thePairProduction);
pManager->AddProcess(new G4UserSpecialCuts(),-1,-1,1);
// Electron Physics
pManager = G4Electron::Electron()->GetProcessManager();
pManager->AddProcess(&theElectronMultipleScattering, -1, 1, 1);
pManager->AddProcess(&theElectronIonisation, -1, 2, 2);
pManager->AddProcess(&theElectronBremsStrahlung, -1, 3, 3);
pManager->AddProcess(new G4UserSpecialCuts(),-1,-1,4);
//Positron Physics
pManager = G4Positron::Positron()->GetProcessManager();
pManager->AddProcess(&thePositronMultipleScattering, -1, 1, 1);
pManager->AddProcess(&thePositronIonisation, -1, 2, 2);
pManager->AddProcess(&thePositronBremsStrahlung, -1, 3, 3);
pManager->AddProcess(&theAnnihilation, 0,-1, 4);
pManager->AddProcess(new G4UserSpecialCuts(),-1,-1,5);
}

105
geant4/LEMuSR/src/LEMuSRGeneralPhysics.cc
View File

@ -1,105 +0,0 @@
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//*
// LOW ENERGY MUON SPIN RELAXATION, ROTATION, RADIATION
//
// ID : LEMuSRGeneralPhysics.cc , v 1.1
// AUTHOR: Taofiq PARAISO
// DATE : 2004-08-24 16:33
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//
// & &&&&&&&&&& &&&&&&& &&&&&&&&
// & & && && & &&
// & & & & & & &&
// & &&&&&&& & & &&&&&& &&&&&&&&
// & & & && & & &&
// & & && & & && && & &
// &&&&&&&&&& &&&&&&&&&& & &&&&& && &&&&&&& & &&
// &
// &
// &
// &
// GENERAL PHYSICS
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
#include "LEMuSRGeneralPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
#include "G4StepLimiter.hh"
LEMuSRGeneralPhysics::LEMuSRGeneralPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
LEMuSRGeneralPhysics::~LEMuSRGeneralPhysics()
{
}
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
// Bosons
#include "G4ChargedGeantino.hh"
#include "G4Geantino.hh"
#include "G4UserSpecialCuts.hh"
#include "G4Neutron.hh"
void LEMuSRGeneralPhysics::ConstructParticle()
{
// pseudo-particles
G4Neutron::Neutron();
G4Geantino::GeantinoDefinition();
G4ChargedGeantino::ChargedGeantinoDefinition();
}
void LEMuSRGeneralPhysics::ConstructProcess()
{
// Add Decay Process
theParticleIterator->reset();
while( (*theParticleIterator)() )
{
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
if (fDecayProcess.IsApplicable(*particle)&&particle->GetParticleName()!="mu+"&&particle->GetParticleName()!="Mu")
{
pmanager ->AddProcess(&fDecayProcess);
// set ordering for PostStepDoIt and AtRestDoIt
pmanager ->SetProcessOrdering(&fDecayProcess, idxPostStep);
pmanager ->SetProcessOrdering(&fDecayProcess, idxAtRest);
}
if (particle->GetParticleName()!="mu+"&&particle->GetParticleName()!="Mu")
{
pmanager->AddProcess(new G4UserSpecialCuts(),-1,-1,1);
}
//#if defined LEMU_TEST_FIELD
if (particle->GetParticleName()=="mu+"||particle->GetParticleName()=="Mu")
{
pmanager->AddProcess(&fStepLimiter,-1,-1,1); //
pmanager->AddProcess(new G4UserSpecialCuts(),-1,-1,1);
}
//#endif
}
G4ProcessManager* Gpmanager;
Gpmanager = G4Geantino::Geantino()->GetProcessManager();
Gpmanager->AddProcess(new G4UserSpecialCuts(),-1,-1,1); //
Gpmanager->AddProcess(&fStepLimiter,-1,-1,1); //
G4ProcessManager* Npmanager;
Npmanager = G4Neutron::Neutron()->GetProcessManager();
Npmanager->AddProcess(new G4UserSpecialCuts(),-1,-1,1); //
Npmanager->AddProcess(new G4UserSpecialCuts(),-1,-1,1); //
}

415
geant4/LEMuSR/src/LEMuSRHadronPhysics.cc
View File

@ -1,415 +0,0 @@
// $Id$
// From GEANT4 examples.
//
#include "LEMuSRHadronPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
LEMuSRHadronPhysics::LEMuSRHadronPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
LEMuSRHadronPhysics::~LEMuSRHadronPhysics()
{
delete theStringDecay;
}
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
// Nuclei
#include "G4MesonConstructor.hh"
#include "G4BaryonConstructor.hh"
#include "G4ShortLivedConstructor.hh"
void LEMuSRHadronPhysics::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 LEMuSRHadronPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
G4cout << "" << G4endl;
G4cout << "You are using the ExoN04HadronPhysics" << G4endl;
G4cout << " - Note that this hadronic physics list is not optimized for any particular usage" << G4endl;
G4cout << " - If you wish to have a starting point tailored for a particular area of work," << G4endl;
G4cout << " please use one of the available physics lists by use-case." << G4endl;
G4cout << " More information can also be found from the Geant4 HyperNews." << G4endl;
G4cout << "" << G4endl;
// Elastic Process
theElasticModel = new G4LElastic();
theElasticProcess.RegisterMe(theElasticModel);
// pi+ and pi-
thePreEquilib = new G4PreCompoundModel(&theHandler);
theCascade.SetDeExcitation(thePreEquilib);
theTheoModel.SetTransport(&theCascade);
theTheoModel.SetHighEnergyGenerator(&theStringModel);
theStringDecay = new G4ExcitedStringDecay(&theFragmentation);
theStringModel.SetFragmentationModel(theStringDecay);
theTheoModel.SetMinEnergy(15*GeV);
theTheoModel.SetMaxEnergy(100*TeV);
// PionPlus
pManager = G4PionPlus::PionPlus()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
theLEPionPlusModel = new G4LEPionPlusInelastic();
thePionPlusInelastic.RegisterMe(theLEPionPlusModel);
thePionPlusInelastic.RegisterMe(&theTheoModel);
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();
thePionMinusInelastic.RegisterMe(theLEPionMinusModel);
thePionMinusInelastic.RegisterMe(&theTheoModel);
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(&theTheoModel);
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(&theTheoModel);
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(&theTheoModel);
pManager->AddDiscreteProcess(&theNeutronInelastic);
theNeutronFissionModel = new G4LFission();
theNeutronFission.RegisterMe(theNeutronFissionModel);
pManager->AddDiscreteProcess(&theNeutronFission);
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);
}

185
geant4/LEMuSR/src/LEMuSRMuonPhysics.cc
View File

@ -1,185 +0,0 @@
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
// LOW ENERGY MUON SPIN RELAXATION, ROTATION, RADIATION
//
// ID : LEMuSRMuonPhysics.cc , v 1.3
// AUTHOR: Taofiq PARAISO
// DATE : 2006-01-19 16:15
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
//
// & &&&&&&&&&& &&&&&&& &&&&&&&&
// & & && && & &&
// & & & & & & &&
// & &&&&&&& & & &&&&&& &&&&&&&&
// & & & && & & &&
// & & && & & && && & &
// &&&&&&&&&& &&&&&&&&&& & &&&&& && &&&&&&& & &&
// &
// &
// &
// &
// MuonPhysics
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
#include "LEMuSRMuonPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
LEMuSRMuonPhysics::LEMuSRMuonPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
LEMuSRMuonPhysics::~LEMuSRMuonPhysics()
{
}
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4MuonPlus.hh"
#include "G4Muonium.hh"
#include "G4MuonMinus.hh"
#include "G4TauMinus.hh"
#include "G4TauPlus.hh"
#include "G4NeutrinoTau.hh"
#include "G4AntiNeutrinoTau.hh"
#include "G4NeutrinoMu.hh"
#include "G4AntiNeutrinoMu.hh"
#include "LEMuSRMuonDecayChannel.hh"
#include "G4UserSpecialCuts.hh"
#include "G4DecayTable.hh"
#include "G4MuonDecayChannelWithSpin.hh"
void LEMuSRMuonPhysics::ConstructParticle()
{
//! Muon
G4MuonPlus::MuonPlusDefinition();
G4Muonium::MuoniumDefinition();
G4MuonMinus::MuonMinusDefinition();
G4NeutrinoMu::NeutrinoMuDefinition();
G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
//! Tau
G4TauMinus::TauMinusDefinition();
G4TauPlus::TauPlusDefinition();
G4NeutrinoTau::NeutrinoTauDefinition();
G4AntiNeutrinoTau::AntiNeutrinoTauDefinition();
//! The decay process
/*!
* Although the asymmetric decay process is a feature of new Geant4 versions,
* it is recommended to use the original \lemu implementation.
*/
#ifdef ASYM_USE_LEMU
G4DecayTable* MuonPlusDecayTable = new G4DecayTable();
MuonPlusDecayTable -> Insert(new LEMuSRMuonDecayChannel("mu+",1.00));
G4MuonPlus::MuonPlusDefinition() -> SetDecayTable(MuonPlusDecayTable);
/*!
Half of the muonium have a completely isotropic decay.
*/
G4DecayTable* MuoniumDecayTable = new G4DecayTable();
MuoniumDecayTable -> Insert(new LEMuSRMuonDecayChannel("Mu",0.5));
MuoniumDecayTable -> Insert(new G4MuonDecayChannel("Mu",0.5));
G4Muonium::MuoniumDefinition() -> SetDecayTable(MuoniumDecayTable);
G4DecayTable* MuonMinusDecayTable = new G4DecayTable();
MuonMinusDecayTable -> Insert(new LEMuSRMuonDecayChannel("mu-",1.00));
G4MuonMinus::MuonMinusDefinition() -> SetDecayTable(MuonMinusDecayTable);
G4cout<<"ASYM_USE_LEMU\n";
#else
G4DecayTable* MuonPlusDecayTable = new G4DecayTable();
MuonPlusDecayTable -> Insert(new G4MuonDecayChannel("mu+",1.00));
G4MuonPlus::MuonPlusDefinition() -> SetDecayTable(MuonPlusDecayTable);
G4DecayTable* MuoniumDecayTable = new G4DecayTable();
MuoniumDecayTable -> Insert(new G4MuonDecayChannel("Mu",1.));
G4Muonium::MuoniumDefinition() -> SetDecayTable(MuoniumDecayTable);
G4DecayTable* MuonMinusDecayTable = new G4DecayTable();
MuonMinusDecayTable -> Insert(new G4MuonDecayChannelWithSpin("mu-",1.00));
G4MuonMinus::MuonMinusDefinition() -> SetDecayTable(MuonMinusDecayTable);
G4cout<<"ASYM_USE_G4\n";
#endif
}
#include "G4ProcessManager.hh"
void LEMuSRMuonPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
// Muon Plus Physics
pManager = G4MuonPlus::MuonPlus()->GetProcessManager();
//! Syntax: pManager->AddProcess(&fprocess, atrest, prestep, poststep). -1 means that the process is not executed under correspondant condition.
pManager->AddProcess(&fMuAtRestSpinRotation, 1, -1, -1);
pManager->AddProcess(&fMuFormation,-1, -1, 1);
pManager->AddProcess(&fMuPlusMultipleScattering,-1, 1, -1);// may crash when enabled as post step process
pManager->AddProcess(&fMuPlusIonisation, -1, 2, 2);
pManager->AddProcess(&fMuPlusBremsstrahlung, -1, 3, 3);
pManager->AddProcess(&fMuPlusPairProduction, -1, 4, 4);
pManager->AddProcess(new G4UserSpecialCuts(),-1,-1,6);
// pManager ->SetProcessOrderingToLast(&fDepolarization, idxAtRest);
// pManager ->SetProcessOrdering(&fDepolarization, idxPostStep);
//! the last process: decay
pManager->AddProcess(&fDecayProcess);
pManager ->SetProcessOrderingToLast(&fDecayProcess, idxAtRest);
pManager ->SetProcessOrdering(&fDecayProcess, idxPostStep);
//! Muonium Physics is the same as muon plus physics
pManager = G4Muonium::Muonium()->GetProcessManager();
pManager->AddProcess(&fMuAtRestSpinRotation, 1, -1, -1);
pManager->AddProcess(&fMuPlusIonisation, -1, 2, 2);
pManager->AddProcess(&fMuoniumScatt, -1, -1, 3);
pManager->AddProcess(&fMuPlusBremsstrahlung, -1, 4, 4);
pManager->AddProcess(&fMuPlusPairProduction, -1, 5, 5);
pManager->AddProcess(new G4UserSpecialCuts(),-1,-1,6);
// the last process: decay
pManager->AddProcess(&fDecayProcess);
pManager->SetProcessOrderingToLast(&fDecayProcess, idxAtRest);
pManager->SetProcessOrdering(&fDecayProcess, idxPostStep);
//! Muon Minus Physics
pManager = G4MuonMinus::MuonMinus()->GetProcessManager();
pManager->AddProcess(&fMuMinusMultipleScattering,-1, 1, 1);
pManager->AddProcess(&fMuMinusIonisation, -1, 2, 2);
pManager->AddProcess(&fMuMinusBremsstrahlung, -1, 3, 3);
pManager->AddProcess(&fMuMinusPairProduction, -1, 4, 4);
pManager->AddRestProcess(&fMuMinusCaptureAtRest);
pManager->AddProcess(&fDecayProcess);
pManager->SetProcessOrderingToLast(&fDecayProcess, idxAtRest);
pManager->SetProcessOrdering(&fDecayProcess, idxPostStep);
//! Tau Plus Physics
pManager = G4TauPlus::TauPlus()->GetProcessManager();
pManager->AddProcess(&fTauPlusMultipleScattering, -1, 1, 1);
pManager->AddProcess(&fTauPlusIonisation, -1, 2, 2);
//! Tau Minus Physics
pManager = G4TauMinus::TauMinus()->GetProcessManager();
pManager->AddProcess(&fTauMinusMultipleScattering, -1, 1, 1);
pManager->AddProcess(&fTauMinusIonisation, -1, 2, 2);
}