lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 7.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 11:11:55 +02:00
parent e083ffb441
commit 516dbf1a58
5914 changed files with 202605 additions and 71141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/novice/N04/src/ExN04DetectorConstruction.cc
+2 -2
View File
@@ -205,8 +205,8 @@ G4VPhysicalVolume* ExN04DetectorConstruction::Construct()
{
G4double phi, x, y, z;
phi = 360.*deg/nomucounter*i;
x = muBox_radius*sin(phi);
y = muBox_radius*cos(phi);
x = muBox_radius*std::sin(phi);
y = muBox_radius*std::cos(phi);
z = 0.*cm;
G4RotationMatrix rm;
rm.rotateZ(phi);
examples/novice/N04/src/ExN04EMPhysics.cc
-101
View File
@@ -1,101 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * 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.6 2003/10/24 12:36:14 maire Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
//
//
#include "ExN04EMPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <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();
pManager->AddProcess(&theElectronMultipleScattering, -1, 1, 1);
pManager->AddProcess(&theElectronIonisation, -1, 2, 2);
pManager->AddProcess(&theElectronBremsStrahlung, -1, 3, 3);
//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);
}
examples/novice/N04/src/ExN04Field.cc
+1 -1
View File
@@ -37,7 +37,7 @@ void ExN04Field::GetFieldValue(const double Point[3],double *Bfield) const
{
Bfield[0] = 0.;
Bfield[1] = 0.;
if(abs(Point[2])<zmax && (sqr(Point[0])+sqr(Point[1]))<rmax_sq)
if(std::abs(Point[2])<zmax && (sqr(Point[0])+sqr(Point[1]))<rmax_sq)
{ Bfield[2] = Bz; }
else
{ Bfield[2] = 0.; }
examples/novice/N04/src/ExN04GeneralPhysics.cc
-73
View File
@@ -1,73 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * 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.6 2003/11/19 19:09:06 asaim Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
//
//
#include "ExN04GeneralPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <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);
}
}
}
examples/novice/N04/src/ExN04HadronPhysics.cc
-438
View File
@@ -1,438 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * 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.10 2003/06/16 16:49:54 gunter Exp $
// GEANT4 tag $Name: geant4-05-02-patch-01 $
//
#include "ExN04HadronPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
ExN04HadronPhysics::ExN04HadronPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
ExN04HadronPhysics::~ExN04HadronPhysics()
{
delete theStringDecay;
}
#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;
G4cout << "" << G4endl;
G4cout << "You are using the ExN04HadronPhysics" << 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);
}
examples/novice/N04/src/ExN04IonPhysics.cc
-126
View File
@@ -1,126 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * 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.5 2003/09/27 13:27:31 vnivanch Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
//
//
#include "ExN04IonPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <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(&fIonMultipleScattering, -1, 1, 1);
pManager->AddProcess(&fIonIonisation, -1, 2, 2);
// Deuteron
pManager = G4Deuteron::Deuteron()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
fDeuteronModel = new G4LEDeuteronInelastic();
fDeuteronProcess.RegisterMe(fDeuteronModel);
pManager->AddDiscreteProcess(&fDeuteronProcess);
pManager->AddProcess(&fDeuteronMultipleScattering, -1, 1, 1);
pManager->AddProcess(&fDeuteronIonisation, -1, 2, 2);
// Triton
pManager = G4Triton::Triton()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
fTritonModel = new G4LETritonInelastic();
fTritonProcess.RegisterMe(fTritonModel);
pManager->AddDiscreteProcess(&fTritonProcess);
pManager->AddProcess(&fTritonMultipleScattering, -1, 1, 1);
pManager->AddProcess(&fTritonIonisation, -1, 2, 2);
// Alpha
pManager = G4Alpha::Alpha()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
fAlphaModel = new G4LEAlphaInelastic();
fAlphaProcess.RegisterMe(fAlphaModel);
pManager->AddDiscreteProcess(&fAlphaProcess);
pManager->AddProcess(&fAlphaMultipleScattering, -1, 1, 1);
pManager->AddProcess(&fAlphaIonisation, -1, 2, 2);
// He3
pManager = G4He3::He3()->GetProcessManager();
// add process
pManager->AddDiscreteProcess(&theElasticProcess);
pManager->AddProcess(&fHe3MultipleScattering, -1, 1, 1);
pManager->AddProcess(&fHe3Ionisation, -1, 2, 2);
}
examples/novice/N04/src/ExN04MuonPhysics.cc
-114
View File
@@ -1,114 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * 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.8 2003/11/19 09:26:02 vnivanch Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
//
//
#include "ExN04MuonPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <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();
pManager->AddProcess(&fMuPlusMultipleScattering,-1, 1, 1);
pManager->AddProcess(&fMuPlusIonisation, -1, 2, 2);
pManager->AddProcess(&fMuPlusBremsstrahlung, -1, 3, 3);
pManager->AddProcess(&fMuPlusPairProduction, -1, 4, 4);
// 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);
// 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);
}
examples/novice/N04/src/ExN04PhysicsList.cc
-85
View File
@@ -1,85 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * 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: ExN04PhysicsList.cc,v 1.15 2003/11/19 09:26:02 vnivanch Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
//
//
#include "ExN04PhysicsList.hh"
#include "globals.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4ios.hh"
#include <iomanip>
#include "ExN04GeneralPhysics.hh"
#include "ExN04EMPhysics.hh"
#include "ExN04MuonPhysics.hh"
#include "ExN04HadronPhysics.hh"
#include "ExN04IonPhysics.hh"
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::SetCuts()
{
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
SetCutsWithDefault();
}
examples/novice/N04/src/ExN04RunAction.cc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: ExN04RunAction.cc,v 1.1 2002/05/02 14:18:51 maire Exp $
// GEANT4 tag $Name: geant4-05-02-patch-01 $
// GEANT4 tag $Name: geant4-07-00-cand-01 $
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/novice/N04/src/ExN04SteppingVerbose.cc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: ExN04SteppingVerbose.cc,v 1.3 2003/06/16 16:49:58 gunter Exp $
// GEANT4 tag $Name: geant4-05-02-patch-01 $
// GEANT4 tag $Name: geant4-07-00-cand-01 $
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/novice/N04/src/ExN04VisManager.cc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: ExN04VisManager.cc,v 1.3 2003/11/10 14:28:58 gcosmo Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
// GEANT4 tag $Name: geant4-07-00-cand-01 $
//
//
// John Allison 24th January 1998.