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

Import Geant4 10.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 11:51:14 +02:00
parent e2d2f9810a
commit 286caacf06
12421 changed files with 730077 additions and 502383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/extended/runAndEvent/RE02/src/RE02ActionInitialization.cc
+59
View File
@@ -0,0 +1,59 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: RE02ActionInitialization.cc 66522 2012-12-19 12:26:04Z ihrivnac $
//
/// \file src/RE02ActionInitialization.cc
/// \brief Implementation of the RE02ActionInitialization class
//
#include "RE02ActionInitialization.hh"
#include "RE02PrimaryGeneratorAction.hh"
#include "RE02RunAction.hh"
#include "RE02EventAction.hh"
RE02ActionInitialization::RE02ActionInitialization()
{;}
RE02ActionInitialization::~RE02ActionInitialization()
{;}
void RE02ActionInitialization::Build() const
{
//
SetUserAction(new RE02PrimaryGeneratorAction);
//
SetUserAction(new RE02RunAction);
//
SetUserAction(new RE02EventAction);
}
void RE02ActionInitialization::BuildForMaster() const
{
//
G4UserRunAction* run_action = new RE02RunAction;
SetUserAction(run_action);
}
examples/extended/runAndEvent/RE02/src/RE02DetectorConstruction.cc
+129 -125
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02DetectorConstruction class
//
//
// $Id$
// $Id: RE02DetectorConstruction.cc 75682 2013-11-05 09:11:19Z gcosmo $
//
#include "RE02DetectorConstruction.hh"
@@ -104,6 +104,7 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02DetectorConstruction::RE02DetectorConstruction()
: G4VUserDetectorConstruction()
{
// Default size of water phantom,and segmentation.
fPhantomSize.setX(200.*mm);
@@ -241,7 +242,7 @@ RE02DetectorConstruction::~RE02DetectorConstruction()
G4String zVoxName("phantomSens");
G4VSolid* solVoxel =
new G4Box(zVoxName,sensSize.x()/2.,sensSize.y()/2.,sensSize.z()/2.);
G4LogicalVolume* logicPhantomSens = new G4LogicalVolume(solVoxel,water,zVoxName);
fLVPhantomSens = new G4LogicalVolume(solVoxel,water,zVoxName);
//
//
std::vector<G4Material*> phantomMat(2,water);
@@ -254,7 +255,7 @@ RE02DetectorConstruction::~RE02DetectorConstruction()
= new RE02NestedPhantomParameterisation(sensSize/2.,nzCells,phantomMat);
//G4VPhysicalVolume * physiPhantomSens =
new G4PVParameterised("PhantomSens", // their name
logicPhantomSens, // their logical volume
fLVPhantomSens, // their logical volume
logXRep, // Mother logical volume
kUndefined, // Are placed along this axis
nzCells, // Number of cells
@@ -263,130 +264,11 @@ RE02DetectorConstruction::~RE02DetectorConstruction()
// kUndefined, kXAxis, kYAxis, kZAxis.
//
//================================================
// Sensitive detectors : MultiFunctionalDetector
//================================================
//
// Sensitive Detector Manager.
G4SDManager* pSDman = G4SDManager::GetSDMpointer();
//
// Sensitive Detector Name
G4String phantomSDname = "PhantomSD";
//------------------------
// MultiFunctionalDetector
//------------------------
//
// Define MultiFunctionalDetector with name.
G4MultiFunctionalDetector* mFDet
= new G4MultiFunctionalDetector(phantomSDname);
pSDman->AddNewDetector( mFDet ); // Register SD to SDManager.
logicPhantomSens->SetSensitiveDetector(mFDet); // Assign SD to the logical volume.
//---------------------------------------
// SDFilter : Sensitive Detector Filters
//---------------------------------------
//
// Particle Filter for Primitive Scorer with filter name(fltName)
// and particle name(particleName),
// or particle names are given by add("particle name"); method.
//
G4String fltName,particleName;
//
//-- proton filter
G4SDParticleFilter* protonFilter =
new G4SDParticleFilter(fltName="protonFilter", particleName="proton");
//
//-- electron filter
G4SDParticleFilter* electronFilter =
new G4SDParticleFilter(fltName="electronFilter");
electronFilter->add(particleName="e+"); // accept electrons.
electronFilter->add(particleName="e-"); // accept positorons.
//
//-- charged particle filter
G4SDChargedFilter* chargedFilter =
new G4SDChargedFilter(fltName="chargedFilter");
//------------------------
// PS : Primitive Scorers
//------------------------
// Primitive Scorers are used with SDFilters according to your purpose.
//
//
//-- Primitive Scorer for Energy Deposit.
// Total, by protons, by electrons.
G4String psName;
G4PSEnergyDeposit3D * scorer0 = new G4PSEnergyDeposit3D(psName="totalEDep",
fNx,fNy,fNz);
G4PSEnergyDeposit3D * scorer1 = new G4PSEnergyDeposit3D(psName="protonEDep",
fNx,fNy,fNz);
scorer1->SetFilter(protonFilter);
//
//-- Number of Steps for protons
G4PSNofStep3D * scorer2 =
new G4PSNofStep3D(psName="protonNStep",fNx,fNy,fNz);
scorer2->SetFilter(protonFilter);
//
//-- CellFlux for charged particles
G4PSPassageCellFlux3D * scorer3 =
new G4PSPassageCellFlux3D(psName="chargedPassCellFlux", fNx,fNy,fNz);
G4PSCellFlux3D * scorer4 =
new G4PSCellFlux3D(psName="chargedCellFlux", fNx,fNy,fNz);
G4PSFlatSurfaceFlux3D * scorer5 =
new G4PSFlatSurfaceFlux3D(psName="chargedSurfFlux", fFlux_InOut,fNx,fNy,fNz);
scorer3->SetFilter(chargedFilter);
scorer4->SetFilter(chargedFilter);
scorer5->SetFilter(chargedFilter);
//
//------------------------------------------------------------
// Register primitive scorers to MultiFunctionalDetector
//------------------------------------------------------------
mFDet->RegisterPrimitive(scorer0);
mFDet->RegisterPrimitive(scorer1);
mFDet->RegisterPrimitive(scorer2);
mFDet->RegisterPrimitive(scorer3);
mFDet->RegisterPrimitive(scorer4);
mFDet->RegisterPrimitive(scorer5);
//========================
// More additional Primitive Scoreres
//========================
//
//--- Surface Current for gamma with energy bin.
// This example creates four primitive scorers.
// 4 bins with energy --- Primitive Scorer Name
// 1. to 10 KeV, gammaSurfCurr000
// 10 keV to 100 KeV, gammaSurfCurr001
// 100 keV to 1 MeV, gammaSurfCurr002
// 1 MeV to 10 MeV. gammaSurfCurr003
//
char name[17];
for ( G4int i = 0; i < 4; i++){
std::sprintf(name,"gammaSurfCurr%03d",i);
G4String psgName(name);
G4double kmin = std::pow(10.,(G4double)i)*keV;
G4double kmax = std::pow(10.,(G4double)(i+1))*keV;
//-- Particle with kinetic energy filter.
G4SDParticleWithEnergyFilter* pkinEFilter =
new G4SDParticleWithEnergyFilter(fltName="gammaE filter",kmin,kmax);
pkinEFilter->add("gamma"); // Accept only gamma.
pkinEFilter->show(); // Show accepting condition to stdout.
//-- Surface Current Scorer which scores number of tracks in unit area.
G4PSFlatSurfaceCurrent3D * scorer =
new G4PSFlatSurfaceCurrent3D(psgName,fCurrent_InOut,fNx,fNy,fNz);
scorer->SetFilter(pkinEFilter); // Assign filter.
mFDet->RegisterPrimitive(scorer); // Register it to MultiFunctionalDetector.
}
//
//===============================
// Visualization attributes
// Visualization attributes
//===============================
G4VisAttributes* boxVisAtt= new G4VisAttributes(G4Colour(1.0,1.0,1.0));
G4VisAttributes* boxVisAtt = new G4VisAttributes(G4Colour(1.0,1.0,1.0));
logicWorld ->SetVisAttributes(boxVisAtt);
//logicWorld->SetVisAttributes(G4VisAttributes::Invisible);
@@ -401,9 +283,131 @@ RE02DetectorConstruction::~RE02DetectorConstruction()
logXRep->SetVisAttributes(xRepVisAtt);
// Skip the visualization for those voxels.
logicPhantomSens->SetVisAttributes(G4VisAttributes::Invisible);
fLVPhantomSens->SetVisAttributes(G4VisAttributes::Invisible);
return physiWorld;
}
void RE02DetectorConstruction::ConstructSDandField() {
//================================================
// Sensitive detectors : MultiFunctionalDetector
//================================================
//
// Sensitive Detector Manager.
G4SDManager* pSDman = G4SDManager::GetSDMpointer();
//
// Sensitive Detector Name
G4String phantomSDname = "PhantomSD";
//------------------------
// MultiFunctionalDetector
//------------------------
//
// Define MultiFunctionalDetector with name.
G4MultiFunctionalDetector* mFDet
= new G4MultiFunctionalDetector(phantomSDname);
pSDman->AddNewDetector( mFDet ); // Register SD to SDManager.
fLVPhantomSens->SetSensitiveDetector(mFDet); // Assign SD to the logical volume.
//---------------------------------------
// SDFilter : Sensitive Detector Filters
//---------------------------------------
//
// Particle Filter for Primitive Scorer with filter name(fltName)
// and particle name(particleName),
// or particle names are given by add("particle name"); method.
//
G4String fltName,particleName;
//
//-- proton filter
G4SDParticleFilter* protonFilter =
new G4SDParticleFilter(fltName="protonFilter", particleName="proton");
//
//-- electron filter
G4SDParticleFilter* electronFilter =
new G4SDParticleFilter(fltName="electronFilter");
electronFilter->add(particleName="e+"); // accept electrons.
electronFilter->add(particleName="e-"); // accept positorons.
//
//-- charged particle filter
G4SDChargedFilter* chargedFilter =
new G4SDChargedFilter(fltName="chargedFilter");
//------------------------
// PS : Primitive Scorers
//------------------------
// Primitive Scorers are used with SDFilters according to your purpose.
//
//
//-- Primitive Scorer for Energy Deposit.
// Total, by protons, by electrons.
G4String psName;
G4PSEnergyDeposit3D * scorer0 = new G4PSEnergyDeposit3D(psName="totalEDep",
fNx,fNy,fNz);
G4PSEnergyDeposit3D * scorer1 = new G4PSEnergyDeposit3D(psName="protonEDep",
fNx,fNy,fNz);
scorer1->SetFilter(protonFilter);
//
//-- Number of Steps for protons
G4PSNofStep3D * scorer2 =
new G4PSNofStep3D(psName="protonNStep",fNx,fNy,fNz);
scorer2->SetFilter(protonFilter);
//
//-- CellFlux for charged particles
G4PSPassageCellFlux3D * scorer3 =
new G4PSPassageCellFlux3D(psName="chargedPassCellFlux", fNx,fNy,fNz);
G4PSCellFlux3D * scorer4 =
new G4PSCellFlux3D(psName="chargedCellFlux", fNx,fNy,fNz);
G4PSFlatSurfaceFlux3D * scorer5 =
new G4PSFlatSurfaceFlux3D(psName="chargedSurfFlux", fFlux_InOut,fNx,fNy,fNz);
scorer3->SetFilter(chargedFilter);
scorer4->SetFilter(chargedFilter);
scorer5->SetFilter(chargedFilter);
//
//------------------------------------------------------------
// Register primitive scorers to MultiFunctionalDetector
//------------------------------------------------------------
mFDet->RegisterPrimitive(scorer0);
mFDet->RegisterPrimitive(scorer1);
mFDet->RegisterPrimitive(scorer2);
mFDet->RegisterPrimitive(scorer3);
mFDet->RegisterPrimitive(scorer4);
mFDet->RegisterPrimitive(scorer5);
//========================
// More additional Primitive Scoreres
//========================
//
//--- Surface Current for gamma with energy bin.
// This example creates four primitive scorers.
// 4 bins with energy --- Primitive Scorer Name
// 1. to 10 KeV, gammaSurfCurr000
// 10 keV to 100 KeV, gammaSurfCurr001
// 100 keV to 1 MeV, gammaSurfCurr002
// 1 MeV to 10 MeV. gammaSurfCurr003
//
char name[17];
for ( G4int i = 0; i < 4; i++){
std::sprintf(name,"gammaSurfCurr%03d",i);
G4String psgName(name);
G4double kmin = std::pow(10.,(G4double)i)*keV;
G4double kmax = std::pow(10.,(G4double)(i+1))*keV;
//-- Particle with kinetic energy filter.
G4SDParticleWithEnergyFilter* pkinEFilter =
new G4SDParticleWithEnergyFilter(fltName="gammaE filter",kmin,kmax);
pkinEFilter->add("gamma"); // Accept only gamma.
pkinEFilter->show(); // Show accepting condition to stdout.
//-- Surface Current Scorer which scores number of tracks in unit area.
G4PSFlatSurfaceCurrent3D * scorer =
new G4PSFlatSurfaceCurrent3D(psgName,fCurrent_InOut,fNx,fNy,fNz);
scorer->SetFilter(pkinEFilter); // Assign filter.
mFDet->RegisterPrimitive(scorer); // Register it to MultiFunctionalDetector.
}
}
examples/extended/runAndEvent/RE02/src/RE02EMPhysics.cc
-124
View File
@@ -1,124 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
/// \file runAndEvent/RE02/src/RE02EMPhysics.cc
/// \brief Implementation of the RE02EMPhysics class
//
// $Id$
// --------------------------------------------------------------
//
//
// 09-Oct-2003 Change gamma, electron, positorn process T. Koi
// 10-Jan-2004 Add Brems. of AlongStepDoIt for e+- T. Koi
#include "RE02EMPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02EMPhysics::RE02EMPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02EMPhysics::~RE02EMPhysics()
{
}
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoE.hh"
#include "G4ProcessManager.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02EMPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
//Gamma
pManager = G4Gamma::Gamma()->GetProcessManager();
pManager->AddDiscreteProcess(new G4GammaConversion());
pManager->AddDiscreteProcess(new G4ComptonScattering());
pManager->AddDiscreteProcess(new G4PhotoElectricEffect());
//Electorn
pManager = G4Electron::Electron()->GetProcessManager();
G4VProcess* theeminusMultipleScattering = new G4eMultipleScattering();
G4VProcess* theeminusIonisation = new G4eIonisation();
G4VProcess* theeminusBremsstrahlung = new G4eBremsstrahlung();
//
// add process
pManager->AddProcess(theeminusMultipleScattering);
pManager->AddProcess(theeminusIonisation);
pManager->AddProcess(theeminusBremsstrahlung);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theeminusMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theeminusIonisation, idxAlongStep,2);
pManager->SetProcessOrdering(theeminusBremsstrahlung, idxAlongStep,3);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theeminusMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theeminusIonisation, idxPostStep,2);
pManager->SetProcessOrdering(theeminusBremsstrahlung, idxPostStep,3);
//Positron
pManager = G4Positron::Positron()->GetProcessManager();
G4VProcess* theeplusMultipleScattering = new G4eMultipleScattering();
G4VProcess* theeplusIonisation = new G4eIonisation();
G4VProcess* theeplusBremsstrahlung = new G4eBremsstrahlung();
G4VProcess* theeplusAnnihilation = new G4eplusAnnihilation();
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);
pManager->SetProcessOrdering(theeplusBremsstrahlung, idxAlongStep,3);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theeplusMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theeplusIonisation, idxPostStep,2);
pManager->SetProcessOrdering(theeplusBremsstrahlung, idxPostStep,3);
pManager->SetProcessOrdering(theeplusAnnihilation, idxPostStep,4);
}
examples/extended/runAndEvent/RE02/src/RE02EventAction.cc
+2 -1
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02EventAction class
//
//
// $Id$
// $Id: RE02EventAction.cc 68026 2013-03-13 13:45:22Z gcosmo $
//
#include "RE02EventAction.hh"
@@ -39,6 +39,7 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02EventAction::RE02EventAction()
: G4UserEventAction()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/runAndEvent/RE02/src/RE02GeneralPhysics.cc
-118
View File
@@ -1,118 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
/// \file runAndEvent/RE02/src/RE02GeneralPhysics.cc
/// \brief Implementation of the RE02GeneralPhysics class
//
// $Id$
// --------------------------------------------------------------
//
// 22-Nov-2004 Construct ALL Particles by T. Koi
#include "RE02GeneralPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02GeneralPhysics::RE02GeneralPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02GeneralPhysics::~RE02GeneralPhysics()
{
}
#include "G4BaryonConstructor.hh"
#include "G4BosonConstructor.hh"
#include "G4IonConstructor.hh"
#include "G4LeptonConstructor.hh"
#include "G4MesonConstructor.hh"
#include "G4ShortLivedConstructor.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02GeneralPhysics::ConstructParticle()
{
// In Alphabetical Order
// Construct all barions
G4BaryonConstructor* baryonConstructor = new G4BaryonConstructor();
baryonConstructor -> ConstructParticle();
delete baryonConstructor;
// Construct all bosons (including geantinos)
G4BosonConstructor* bosonConstructor = new G4BosonConstructor();
bosonConstructor -> ConstructParticle();
delete bosonConstructor;
// Construct all ions
G4IonConstructor* ionConstructor = new G4IonConstructor();
ionConstructor -> ConstructParticle();
delete ionConstructor;
// Construct all leptons
G4LeptonConstructor* leptonConstructor = new G4LeptonConstructor();
leptonConstructor -> ConstructParticle();
delete leptonConstructor;
// Construct all mesons
G4MesonConstructor* mesonConstructor = new G4MesonConstructor();
mesonConstructor -> ConstructParticle();
delete mesonConstructor;
// Construct resonaces and quarks
G4ShortLivedConstructor* shortLivedConstructor =
new G4ShortLivedConstructor();
shortLivedConstructor -> ConstructParticle();
delete shortLivedConstructor;
}
#include "G4Decay.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02GeneralPhysics::ConstructProcess()
{
// 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);
}
}
}
examples/extended/runAndEvent/RE02/src/RE02HadronPhysics.cc
-703
View File
@@ -1,703 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
/// \file runAndEvent/RE02/src/RE02HadronPhysics.cc
/// \brief Implementation of the RE02HadronPhysics class
//
// $Id$
// --------------------------------------------------------------
//
// 09-Oct-2003 Hadron Physics List with Parameterization Model by T. Koi
// 12-Oct-2003 Bug Fixed (KaonMinus) by T. Koi
// 16-Nov-2005 Binary Cascade for Protons. by T. Aso
// Proton : BinaryCascade < 6 GeV, 4 GeV < LE Model,
// Neutron: BinaryCascade < 6 GeV, 4 GeV < LE Model,
//
#include "RE02HadronPhysics.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "G4ios.hh"
#include <iomanip>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02HadronPhysics::RE02HadronPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02HadronPhysics::~RE02HadronPhysics()
{
}
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02HadronPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
// Pi+ Physics
pManager = G4PionPlus::PionPlus()->GetProcessManager();
// add processes
G4HadronElasticProcess* theppElasticProcess = new G4HadronElasticProcess();
G4LElastic* theppElasticModel = new G4LElastic();
theppElasticProcess->RegisterMe(theppElasticModel);
pManager->AddDiscreteProcess(theppElasticProcess);
G4PionPlusInelasticProcess* thePionPlusInelasticProcess =
new G4PionPlusInelasticProcess();
G4LEPionPlusInelastic* thePionPlusLEPModel = new G4LEPionPlusInelastic();
G4HEPionPlusInelastic* thePionPlusHEPModel = new G4HEPionPlusInelastic();
thePionPlusInelasticProcess->RegisterMe(thePionPlusLEPModel);
thePionPlusInelasticProcess->RegisterMe(thePionPlusHEPModel);
pManager->AddDiscreteProcess(thePionPlusInelasticProcess);
G4VProcess* theppMultipleScattering = new G4hMultipleScattering();
G4VProcess* theppIonisation = new G4hIonisation();
//
pManager->AddProcess(theppIonisation);
pManager->AddProcess(theppMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theppMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theppIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theppMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theppIonisation, idxPostStep,2);
// Pi- Physics
pManager = G4PionMinus::PionMinus()->GetProcessManager();
G4HadronElasticProcess* thepmElasticProcess = new G4HadronElasticProcess();
G4LElastic* thepmElasticModel = new G4LElastic();
thepmElasticProcess->RegisterMe(thepmElasticModel);
pManager->AddDiscreteProcess(thepmElasticProcess);
G4PionMinusInelasticProcess* thePionMinusInelasticProcess =
new G4PionMinusInelasticProcess();
G4LEPionMinusInelastic* thePionMinusLEPModel = new G4LEPionMinusInelastic();
G4HEPionMinusInelastic* thePionMinusHEPModel = new G4HEPionMinusInelastic();
thePionMinusInelasticProcess->RegisterMe(thePionMinusLEPModel);
thePionMinusInelasticProcess->RegisterMe(thePionMinusHEPModel);
pManager->AddDiscreteProcess(thePionMinusInelasticProcess);
G4VProcess* thepmMultipleScattering = new G4hMultipleScattering();
G4VProcess* thepmIonisation = new G4hIonisation();
//
// add processes
pManager->AddProcess(thepmIonisation);
pManager->AddProcess(thepmMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thepmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thepmIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thepmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thepmIonisation, idxPostStep,2);
// K+ Physics
pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
G4HadronElasticProcess* thekpElasticProcess = new G4HadronElasticProcess();
G4LElastic* thekpElasticModel = new G4LElastic();
thekpElasticProcess->RegisterMe(thekpElasticModel);
pManager->AddDiscreteProcess(thekpElasticProcess);
G4KaonPlusInelasticProcess* theKaonPlusInelasticProcess =
new G4KaonPlusInelasticProcess();
G4LEKaonPlusInelastic* theKaonPlusLEPModel = new G4LEKaonPlusInelastic();
G4HEKaonPlusInelastic* theKaonPlusHEPModel = new G4HEKaonPlusInelastic();
theKaonPlusInelasticProcess->RegisterMe(theKaonPlusLEPModel);
theKaonPlusInelasticProcess->RegisterMe(theKaonPlusHEPModel);
pManager->AddDiscreteProcess(theKaonPlusInelasticProcess);
G4VProcess* thekpMultipleScattering = new G4hMultipleScattering();
G4VProcess* thekpIonisation = new G4hIonisation();
//
// add processes
pManager->AddProcess(thekpIonisation);
pManager->AddProcess(thekpMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thekpMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thekpIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thekpMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thekpIonisation, idxPostStep,2);
// K- Physics
pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
// add processes
G4HadronElasticProcess* thekmElasticProcess = new G4HadronElasticProcess();
G4LElastic* thekmElasticModel = new G4LElastic();
thekmElasticProcess->RegisterMe(thekmElasticModel);
pManager->AddDiscreteProcess(thekmElasticProcess);
G4KaonMinusInelasticProcess* theKaonMinusInelasticProcess =
new G4KaonMinusInelasticProcess();
G4LEKaonMinusInelastic* theKaonMinusLEPModel = new G4LEKaonMinusInelastic();
G4HEKaonMinusInelastic* theKaonMinusHEPModel = new G4HEKaonMinusInelastic();
theKaonMinusInelasticProcess->RegisterMe(theKaonMinusLEPModel);
theKaonMinusInelasticProcess->RegisterMe(theKaonMinusHEPModel);
pManager->AddDiscreteProcess(theKaonMinusInelasticProcess);
G4VProcess* thekmMultipleScattering = new G4hMultipleScattering();
G4VProcess* thekmIonisation = new G4hIonisation();
pManager->AddProcess(thekmIonisation);
pManager->AddProcess(thekmMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thekmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thekmIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thekmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thekmIonisation, idxPostStep,2);
// Kaon0L Physics
pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
G4HadronElasticProcess* thek0lElasticProcess = new G4HadronElasticProcess();
G4LElastic* thek0lElasticModel = new G4LElastic();
thek0lElasticProcess->RegisterMe(thek0lElasticModel);
pManager->AddDiscreteProcess(thek0lElasticProcess);
G4KaonZeroLInelasticProcess* theKaonZeroLInelasticProcess =
new G4KaonZeroLInelasticProcess();
G4LEKaonZeroLInelastic* theKaonZeroLLEPModel = new G4LEKaonZeroLInelastic();
G4HEKaonZeroInelastic* theKaonZerolHEPModel = new G4HEKaonZeroInelastic();
theKaonZeroLInelasticProcess->RegisterMe(theKaonZeroLLEPModel);
theKaonZeroLInelasticProcess->RegisterMe(theKaonZerolHEPModel);
pManager->AddDiscreteProcess(theKaonZeroLInelasticProcess);
// Kaon0S Physics
pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
G4HadronElasticProcess* thek0sElasticProcess = new G4HadronElasticProcess();
G4LElastic* thek0sElasticModel = new G4LElastic();
thek0sElasticProcess->RegisterMe(thek0sElasticModel);
pManager->AddDiscreteProcess(thek0sElasticProcess);
G4KaonZeroSInelasticProcess* theKaonZeroSInelasticProcess =
new G4KaonZeroSInelasticProcess();
G4LEKaonZeroSInelastic* theKaonZeroSLEPModel = new G4LEKaonZeroSInelastic();
G4HEKaonZeroInelastic* theKaonZerosHEPModel = new G4HEKaonZeroInelastic();
theKaonZeroSInelasticProcess->RegisterMe(theKaonZeroSLEPModel);
theKaonZeroSInelasticProcess->RegisterMe(theKaonZerosHEPModel);
pManager->AddDiscreteProcess(theKaonZeroSInelasticProcess);
// Proton Physics
pManager = G4Proton::Proton()->GetProcessManager();
// add process
G4HadronElasticProcess* thepElasticProcess = new G4HadronElasticProcess();
G4LElastic* thepElasticModel = new G4LElastic();
thepElasticProcess->RegisterMe(thepElasticModel);
pManager->AddDiscreteProcess(thepElasticProcess);
G4ProtonInelasticProcess* theProtonInelasticProcess =
new G4ProtonInelasticProcess();
G4BinaryCascade* theProtonBCModel = new G4BinaryCascade();
theProtonBCModel->SetMaxEnergy(6.*GeV);
G4LEProtonInelastic* theProtonLEPModel = new G4LEProtonInelastic();
theProtonLEPModel->SetMinEnergy(4.*GeV);
G4HEProtonInelastic* theProtonHEPModel = new G4HEProtonInelastic();
theProtonInelasticProcess->RegisterMe(theProtonBCModel);
theProtonInelasticProcess->RegisterMe(theProtonLEPModel);
theProtonInelasticProcess->RegisterMe(theProtonHEPModel);
pManager->AddDiscreteProcess(theProtonInelasticProcess);
G4VProcess* thepMultipleScattering = new G4hMultipleScattering();
G4VProcess* thepIonisation = new G4hIonisation();
pManager->AddProcess(thepIonisation);
pManager->AddProcess(thepMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thepMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thepIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thepMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thepIonisation, idxPostStep,2);
// anti-proton Physics
pManager = G4AntiProton::AntiProton()->GetProcessManager();
// add process
G4HadronElasticProcess* theapElasticProcess = new G4HadronElasticProcess();
G4LElastic* theapElasticModel = new G4LElastic();
theapElasticProcess->RegisterMe(theapElasticModel);
pManager->AddDiscreteProcess(theapElasticProcess);
G4AntiProtonInelasticProcess* theAntiProtonInelasticProcess =
new G4AntiProtonInelasticProcess();
G4LEAntiProtonInelastic* theAntiProtonLEPModel =
new G4LEAntiProtonInelastic();
G4HEAntiProtonInelastic* theAntiProtonHEPModel =
new G4HEAntiProtonInelastic();
theAntiProtonInelasticProcess->RegisterMe(theAntiProtonLEPModel);
theAntiProtonInelasticProcess->RegisterMe(theAntiProtonHEPModel);
pManager->AddDiscreteProcess(theAntiProtonInelasticProcess);
G4AntiProtonAnnihilationAtRest* theAntiProtonAnnihilation =
new G4AntiProtonAnnihilationAtRest();
pManager->AddRestProcess(theAntiProtonAnnihilation);
G4VProcess* theapMultipleScattering = new G4hMultipleScattering();
G4VProcess* theapIonisation = new G4hIonisation();
pManager->AddProcess(theapIonisation);
pManager->AddProcess(theapMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theapMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theapIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theapMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theapIonisation, idxPostStep,2);
// neutron Physics
pManager = G4Neutron::Neutron()->GetProcessManager();
// add process
G4HadronElasticProcess* thenElasticProcess = new G4HadronElasticProcess();
G4LElastic* thenElasticModel = new G4LElastic();
thenElasticProcess->RegisterMe(thenElasticModel);
pManager->AddDiscreteProcess(thenElasticProcess);
G4NeutronInelasticProcess* theNeutronInelasticProcess =
new G4NeutronInelasticProcess();
G4BinaryCascade* theNeutronBCModel = new G4BinaryCascade();
theNeutronBCModel->SetMaxEnergy(6.*GeV);
G4LENeutronInelastic* theNeutronLEPModel = new G4LENeutronInelastic();
theNeutronLEPModel->SetMinEnergy(4.*GeV);
G4HENeutronInelastic* theNeutronHEPModel = new G4HENeutronInelastic();
theNeutronInelasticProcess->RegisterMe(theNeutronBCModel);
theNeutronInelasticProcess->RegisterMe(theNeutronLEPModel);
theNeutronInelasticProcess->RegisterMe(theNeutronHEPModel);
pManager->AddDiscreteProcess(theNeutronInelasticProcess);
G4HadronFissionProcess* thenFission = new G4HadronFissionProcess();
G4LFission* thenFissionModel = new G4LFission();
thenFission->RegisterMe(thenFissionModel);
pManager->AddDiscreteProcess(thenFission);
G4HadronCaptureProcess* thenCapture = new G4HadronCaptureProcess();
G4LCapture* thenCaptureModel = new G4LCapture();
thenCapture->RegisterMe(thenCaptureModel);
pManager->AddDiscreteProcess(thenCapture);
// anti-neutron Physics
pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
// add process
G4HadronElasticProcess* theanElasticProcess = new G4HadronElasticProcess();
G4LElastic* theanElasticModel = new G4LElastic();
theanElasticProcess->RegisterMe(theanElasticModel);
pManager->AddDiscreteProcess(theanElasticProcess);
G4AntiNeutronInelasticProcess* theAntiNeutronInelasticProcess =
new G4AntiNeutronInelasticProcess();
G4LEAntiNeutronInelastic* theAntiNeutronLEPModel =
new G4LEAntiNeutronInelastic();
G4HEAntiNeutronInelastic* theAntiNeutronHEPModel =
new G4HEAntiNeutronInelastic();
theAntiNeutronInelasticProcess->RegisterMe(theAntiNeutronLEPModel);
theAntiNeutronInelasticProcess->RegisterMe(theAntiNeutronHEPModel);
pManager->AddDiscreteProcess(theAntiNeutronInelasticProcess);
G4AntiNeutronAnnihilationAtRest* theAntiNeutronAnnihilation =
new G4AntiNeutronAnnihilationAtRest();
pManager->AddRestProcess(theAntiNeutronAnnihilation);
// Lambda Physics
pManager = G4Lambda::Lambda()->GetProcessManager();
// add process
G4HadronElasticProcess* thel0ElasticProcess = new G4HadronElasticProcess();
G4LElastic* thel0ElasticModel = new G4LElastic();
thel0ElasticProcess->RegisterMe(thel0ElasticModel);
pManager->AddDiscreteProcess(thel0ElasticProcess);
G4LambdaInelasticProcess* theLambdaInelasticProcess =
new G4LambdaInelasticProcess();
G4LELambdaInelastic* theLambdaLEPModel = new G4LELambdaInelastic();
G4HELambdaInelastic* theLambdaHEPModel = new G4HELambdaInelastic();
theLambdaInelasticProcess->RegisterMe(theLambdaLEPModel);
theLambdaInelasticProcess->RegisterMe(theLambdaHEPModel);
pManager->AddDiscreteProcess(theLambdaInelasticProcess);
// Anti-Labda Physics
pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
// add process
G4HadronElasticProcess* theal0ElasticProcess = new G4HadronElasticProcess();
G4LElastic* theal0ElasticModel = new G4LElastic();
theal0ElasticProcess->RegisterMe(theal0ElasticModel);
pManager->AddDiscreteProcess(theal0ElasticProcess);
G4AntiLambdaInelasticProcess* theAntiLambdaInelasticProcess =
new G4AntiLambdaInelasticProcess();
G4LEAntiLambdaInelastic* theAntiLambdaLEPModel =
new G4LEAntiLambdaInelastic();
G4HEAntiLambdaInelastic* theAntiLambdaHEPModel =
new G4HEAntiLambdaInelastic();
theAntiLambdaInelasticProcess->RegisterMe(theAntiLambdaLEPModel);
theAntiLambdaInelasticProcess->RegisterMe(theAntiLambdaHEPModel);
pManager->AddDiscreteProcess(theAntiLambdaInelasticProcess);
// Sigma+ Physics
pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
// add process
G4HadronElasticProcess* thespElasticProcess = new G4HadronElasticProcess();
G4LElastic* thespElasticModel = new G4LElastic();
thespElasticProcess->RegisterMe(thespElasticModel);
pManager->AddDiscreteProcess(thespElasticProcess);
G4SigmaPlusInelasticProcess* theSigmaPlusInelasticProcess =
new G4SigmaPlusInelasticProcess();
G4LESigmaPlusInelastic* theSigmaPlusLEPModel = new G4LESigmaPlusInelastic();
G4HESigmaPlusInelastic* theSigmaPlusHEPModel = new G4HESigmaPlusInelastic();
theSigmaPlusInelasticProcess->RegisterMe(theSigmaPlusLEPModel);
theSigmaPlusInelasticProcess->RegisterMe(theSigmaPlusHEPModel);
pManager->AddDiscreteProcess(theSigmaPlusInelasticProcess);
G4VProcess* thespMultipleScattering = new G4hMultipleScattering();
G4VProcess* thespIonisation = new G4hIonisation();
pManager->AddProcess(thespIonisation);
pManager->AddProcess(thespMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thespMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thespIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thespMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thespIonisation, idxPostStep,2);
// anti-Sigma+ Physics
pManager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
// add process
G4HadronElasticProcess* theaspElasticProcess = new G4HadronElasticProcess();
G4LElastic* theaspElasticModel = new G4LElastic();
theaspElasticProcess->RegisterMe(theaspElasticModel);
pManager->AddDiscreteProcess(theaspElasticProcess);
G4AntiSigmaPlusInelasticProcess* theAntiSigmaPlusInelasticProcess =
new G4AntiSigmaPlusInelasticProcess();
G4LEAntiSigmaPlusInelastic* theAntiSigmaPlusLEPModel =
new G4LEAntiSigmaPlusInelastic();
G4HEAntiSigmaPlusInelastic* theAntiSigmaPlusHEPModel =
new G4HEAntiSigmaPlusInelastic();
theAntiSigmaPlusInelasticProcess->RegisterMe(theAntiSigmaPlusLEPModel);
theAntiSigmaPlusInelasticProcess->RegisterMe(theAntiSigmaPlusHEPModel);
pManager->AddDiscreteProcess(theAntiSigmaPlusInelasticProcess);
G4VProcess* theaspMultipleScattering = new G4hMultipleScattering();
G4VProcess* theaspIonisation = new G4hIonisation();
pManager->AddProcess(theaspIonisation);
pManager->AddProcess(theaspMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theaspMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theaspIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theaspMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theaspIonisation, idxPostStep,2);
// Sigma- Physics
pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
// add process
G4HadronElasticProcess* thesmElasticProcess = new G4HadronElasticProcess();
G4LElastic* thesmElasticModel = new G4LElastic();
thesmElasticProcess->RegisterMe(thesmElasticModel);
pManager->AddDiscreteProcess(thesmElasticProcess);
G4SigmaMinusInelasticProcess* theSigmaMinusInelasticProcess =
new G4SigmaMinusInelasticProcess();
G4LESigmaMinusInelastic* theSigmaMinusLEPModel =
new G4LESigmaMinusInelastic();
G4HESigmaMinusInelastic* theSigmaMinusHEPModel =
new G4HESigmaMinusInelastic();
theSigmaMinusInelasticProcess->RegisterMe(theSigmaMinusLEPModel);
theSigmaMinusInelasticProcess->RegisterMe(theSigmaMinusHEPModel);
pManager->AddDiscreteProcess(theSigmaMinusInelasticProcess);
G4VProcess* thesmMultipleScattering = new G4hMultipleScattering();
G4VProcess* thesmIonisation = new G4hIonisation();
pManager->AddProcess(thesmIonisation);
pManager->AddProcess(thesmMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thesmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thesmIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thesmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thesmIonisation, idxPostStep,2);
// anti-Sigma- Physics
pManager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
// add process
G4HadronElasticProcess* theasmElasticProcess = new G4HadronElasticProcess();
G4LElastic* theasmElasticModel = new G4LElastic();
theasmElasticProcess->RegisterMe(theasmElasticModel);
pManager->AddDiscreteProcess(theasmElasticProcess);
G4AntiSigmaMinusInelasticProcess* theAntiSigmaMinusInelasticProcess =
new G4AntiSigmaMinusInelasticProcess();
G4LEAntiSigmaMinusInelastic* theAntiSigmaMinusLEPModel =
new G4LEAntiSigmaMinusInelastic();
G4HEAntiSigmaMinusInelastic* theAntiSigmaMinusHEPModel =
new G4HEAntiSigmaMinusInelastic();
theAntiSigmaMinusInelasticProcess->RegisterMe(theAntiSigmaMinusLEPModel);
theAntiSigmaMinusInelasticProcess->RegisterMe(theAntiSigmaMinusHEPModel);
pManager->AddDiscreteProcess(theAntiSigmaMinusInelasticProcess);
G4VProcess* theasmMultipleScattering = new G4hMultipleScattering();
G4VProcess* theasmIonisation = new G4hIonisation();
pManager->AddProcess(theasmIonisation);
pManager->AddProcess(theasmMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theasmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theasmIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theasmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theasmIonisation, idxPostStep,2);
// Xi0 Physics
pManager = G4XiZero::XiZero()->GetProcessManager();
// add process
G4HadronElasticProcess* thex0ElasticProcess = new G4HadronElasticProcess();
G4LElastic* thex0ElasticModel = new G4LElastic();
thex0ElasticProcess->RegisterMe(thex0ElasticModel);
pManager->AddDiscreteProcess(thex0ElasticProcess);
G4XiZeroInelasticProcess* theXiZeroInelasticProcess =
new G4XiZeroInelasticProcess();
G4LEXiZeroInelastic* theXiZeroLEPModel = new G4LEXiZeroInelastic();
G4HEXiZeroInelastic* theXiZeroHEPModel = new G4HEXiZeroInelastic();
theXiZeroInelasticProcess->RegisterMe(theXiZeroLEPModel);
theXiZeroInelasticProcess->RegisterMe(theXiZeroHEPModel);
pManager->AddDiscreteProcess(theXiZeroInelasticProcess);
// Anti-Xi0 Physics
pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
// add process
G4HadronElasticProcess* theax0ElasticProcess = new G4HadronElasticProcess();
G4LElastic* theax0ElasticModel = new G4LElastic();
theax0ElasticProcess->RegisterMe(theax0ElasticModel);
pManager->AddDiscreteProcess(theax0ElasticProcess);
G4AntiXiZeroInelasticProcess* theAntiXiZeroInelasticProcess =
new G4AntiXiZeroInelasticProcess();
G4LEAntiXiZeroInelastic* theAntiXiZeroLEPModel =
new G4LEAntiXiZeroInelastic();
G4HEAntiXiZeroInelastic* theAntiXiZeroHEPModel =
new G4HEAntiXiZeroInelastic();
theAntiXiZeroInelasticProcess->RegisterMe(theAntiXiZeroLEPModel);
theAntiXiZeroInelasticProcess->RegisterMe(theAntiXiZeroHEPModel);
pManager->AddDiscreteProcess(theAntiXiZeroInelasticProcess);
// Xi- Physics
pManager = G4XiMinus::XiMinus()->GetProcessManager();
// add process
G4HadronElasticProcess* thexmElasticProcess = new G4HadronElasticProcess();
G4LElastic* thexmElasticModel = new G4LElastic();
thexmElasticProcess->RegisterMe(thexmElasticModel);
pManager->AddDiscreteProcess(thexmElasticProcess);
G4XiMinusInelasticProcess* theXiMinusInelasticProcess =
new G4XiMinusInelasticProcess();
G4LEXiMinusInelastic* theXiMinusLEPModel = new G4LEXiMinusInelastic();
G4HEXiMinusInelastic* theXiMinusHEPModel = new G4HEXiMinusInelastic();
theXiMinusInelasticProcess->RegisterMe(theXiMinusLEPModel);
theXiMinusInelasticProcess->RegisterMe(theXiMinusHEPModel);
pManager->AddDiscreteProcess(theXiMinusInelasticProcess);
G4VProcess* thexmMultipleScattering = new G4hMultipleScattering();
G4VProcess* thexmIonisation = new G4hIonisation();
pManager->AddProcess(thexmIonisation);
pManager->AddProcess(thexmMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thexmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thexmIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thexmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thexmIonisation, idxPostStep,2);
// anti-Xi- Physics
pManager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
// add process
G4HadronElasticProcess* theaxmElasticProcess = new G4HadronElasticProcess();
G4LElastic* theaxmElasticModel = new G4LElastic();
theaxmElasticProcess->RegisterMe(theaxmElasticModel);
pManager->AddDiscreteProcess(theaxmElasticProcess);
G4AntiXiMinusInelasticProcess* theAntiXiMinusInelasticProcess =
new G4AntiXiMinusInelasticProcess();
G4LEAntiXiMinusInelastic* theAntiXiMinusLEPModel =
new G4LEAntiXiMinusInelastic();
G4HEAntiXiMinusInelastic* theAntiXiMinusHEPModel =
new G4HEAntiXiMinusInelastic();
theAntiXiMinusInelasticProcess->RegisterMe(theAntiXiMinusLEPModel);
theAntiXiMinusInelasticProcess->RegisterMe(theAntiXiMinusHEPModel);
pManager->AddDiscreteProcess(theAntiXiMinusInelasticProcess);
G4VProcess* theaxmMultipleScattering = new G4hMultipleScattering();
G4VProcess* theaxmIonisation = new G4hIonisation();
pManager->AddProcess(theaxmIonisation);
pManager->AddProcess(theaxmMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theaxmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theaxmIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theaxmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theaxmIonisation, idxPostStep,2);
// Omega- Physics
pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
// add process
G4HadronElasticProcess* theomElasticProcess = new G4HadronElasticProcess();
G4LElastic* theomElasticModel = new G4LElastic();
theomElasticProcess->RegisterMe(theomElasticModel);
pManager->AddDiscreteProcess(theomElasticProcess);
G4OmegaMinusInelasticProcess* theOmegaMinusInelasticProcess =
new G4OmegaMinusInelasticProcess();
G4LEOmegaMinusInelastic* theOmegaMinusLEPModel =
new G4LEOmegaMinusInelastic();
G4HEOmegaMinusInelastic* theOmegaMinusHEPModel =
new G4HEOmegaMinusInelastic();
theOmegaMinusInelasticProcess->RegisterMe(theOmegaMinusLEPModel);
theOmegaMinusInelasticProcess->RegisterMe(theOmegaMinusHEPModel);
pManager->AddDiscreteProcess(theOmegaMinusInelasticProcess);
G4VProcess* theomMultipleScattering = new G4hMultipleScattering();
G4VProcess* theomIonisation = new G4hIonisation();
pManager->AddProcess(theomIonisation);
pManager->AddProcess(theomMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theomMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theomIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theomMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theomIonisation, idxPostStep,2);
// anti-Omega- Physics
pManager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
// add process
G4HadronElasticProcess* theaomElasticProcess = new G4HadronElasticProcess();
G4LElastic* theaomElasticModel = new G4LElastic();
theaomElasticProcess->RegisterMe(theaomElasticModel);
pManager->AddDiscreteProcess(theaomElasticProcess);
G4AntiOmegaMinusInelasticProcess* theAntiOmegaMinusInelasticProcess =
new G4AntiOmegaMinusInelasticProcess();
G4LEAntiOmegaMinusInelastic* theAntiOmegaMinusLEPModel =
new G4LEAntiOmegaMinusInelastic();
G4HEAntiOmegaMinusInelastic* theAntiOmegaMinusHEPModel =
new G4HEAntiOmegaMinusInelastic();
theAntiOmegaMinusInelasticProcess->RegisterMe(theAntiOmegaMinusLEPModel);
theAntiOmegaMinusInelasticProcess->RegisterMe(theAntiOmegaMinusHEPModel);
pManager->AddDiscreteProcess(theAntiOmegaMinusInelasticProcess);
G4VProcess* theaomMultipleScattering = new G4hMultipleScattering();
G4VProcess* theaomIonisation = new G4hIonisation();
pManager->AddProcess(theaomIonisation);
pManager->AddProcess(theaomMultipleScattering);
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(theaomMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(theaomIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(theaomMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(theaomIonisation, idxPostStep,2);
}
examples/extended/runAndEvent/RE02/src/RE02IonPhysics.cc
-208
View File
@@ -1,208 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
/// \file runAndEvent/RE02/src/RE02IonPhysics.cc
/// \brief Implementation of the RE02IonPhysics class
//
// $Id$
// --------------------------------------------------------------
//
// 13-Oct-2003 Add Comment for Ionisation of Generic Ion by T. Koi
// 05-Jan-2004 Change G. Ion Ionisation from G4hIonisation
// to G4ionIonisation T. Koi
// 18-Nov-2005 Add Inelastic process with G4BinaryLightIonReaction.
// T. Aso
#include "RE02IonPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02IonPhysics::RE02IonPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02IonPhysics::~RE02IonPhysics()
{
}
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4HadronElastic.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02IonPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
// Generic Ion
pManager = G4GenericIon::GenericIon()->GetProcessManager();
// add process
G4VProcess* thegionMultipleScattering = new G4hMultipleScattering();
//
// G4hIonization may be not able to use for Geanric Ion in future
// Please take care using this physics list after v5.2.p02
// G4VProcess* thegionIonisation = new G4hIonisation();
//
// From V6.0 hIonisation does not work for GenericIon
G4VProcess* thegionIonisation = new G4ionIonisation();
// Inelastic process
G4HadronInelasticProcess* thegionInelastic =
new G4HadronInelasticProcess("IonInelastic",G4GenericIon::GenericIon());
thegionInelastic->AddDataSet(new G4TripathiCrossSection);
thegionInelastic->AddDataSet(new G4IonsShenCrossSection);
G4BinaryLightIonReaction* thegionBCModel = new G4BinaryLightIonReaction;
thegionInelastic->RegisterMe(thegionBCModel);
//
pManager->AddProcess(thegionIonisation);
pManager->AddProcess(thegionMultipleScattering);
pManager->AddDiscreteProcess(thegionInelastic);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thegionMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thegionIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thegionMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thegionIonisation, idxPostStep,2);
// Deuteron
pManager = G4Deuteron::Deuteron()->GetProcessManager();
// add process
G4HadronElasticProcess* thedueElasticProcess = new G4HadronElasticProcess();
thedueElasticProcess->RegisterMe(new G4HadronElastic());
pManager->AddDiscreteProcess(thedueElasticProcess);
G4DeuteronInelasticProcess* theDeuteronInelasticProcess =
new G4DeuteronInelasticProcess();
G4LEDeuteronInelastic* theDeuteronLEPModel = new G4LEDeuteronInelastic();
theDeuteronInelasticProcess->RegisterMe(theDeuteronLEPModel);
pManager->AddDiscreteProcess(theDeuteronInelasticProcess);
G4VProcess* thedueMultipleScattering = new G4hMultipleScattering();
G4VProcess* thedueIonisation = new G4hIonisation();
//
pManager->AddProcess(thedueIonisation);
pManager->AddProcess(thedueMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thedueMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thedueIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thedueMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thedueIonisation, idxPostStep,2);
// Triton
pManager = G4Triton::Triton()->GetProcessManager();
// add process
G4HadronElasticProcess* thetriElasticProcess = new G4HadronElasticProcess();
thetriElasticProcess->RegisterMe(new G4HadronElastic());
pManager->AddDiscreteProcess(thetriElasticProcess);
G4TritonInelasticProcess* theTritonInelasticProcess =
new G4TritonInelasticProcess();
G4LETritonInelastic* theTritonLEPModel = new G4LETritonInelastic();
theTritonInelasticProcess->RegisterMe(theTritonLEPModel);
pManager->AddDiscreteProcess(theTritonInelasticProcess);
G4VProcess* thetriMultipleScattering = new G4hMultipleScattering();
G4VProcess* thetriIonisation = new G4hIonisation();
//
pManager->AddProcess(thetriIonisation);
pManager->AddProcess(thetriMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thetriMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thetriIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thetriMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thetriIonisation, idxPostStep,2);
// Alpha
pManager = G4Alpha::Alpha()->GetProcessManager();
// add processes
G4HadronElasticProcess* thealElasticProcess = new G4HadronElasticProcess();
thealElasticProcess->RegisterMe(new G4HadronElastic());
pManager->AddDiscreteProcess(thealElasticProcess);
G4AlphaInelasticProcess* theAlphaInelasticProcess =
new G4AlphaInelasticProcess();
G4LEAlphaInelastic* theAlphaLEPModel = new G4LEAlphaInelastic();
theAlphaInelasticProcess->RegisterMe(theAlphaLEPModel);
pManager->AddDiscreteProcess(theAlphaInelasticProcess);
G4VProcess* thealpMultipleScattering = new G4hMultipleScattering();
G4VProcess* thealpIonisation = new G4hIonisation();
//
pManager->AddProcess(thealpIonisation);
pManager->AddProcess(thealpMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thealpMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thealpIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thealpMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thealpIonisation, idxPostStep,2);
// He3
pManager = G4He3::He3()->GetProcessManager();
// add processes
G4VProcess* thehe3MultipleScattering = new G4hMultipleScattering();
G4VProcess* thehe3Ionisation = new G4hIonisation();
//
pManager->AddProcess(thehe3Ionisation);
pManager->AddProcess(thehe3MultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thehe3MultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thehe3Ionisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thehe3MultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thehe3Ionisation, idxPostStep,2);
}
examples/extended/runAndEvent/RE02/src/RE02MuonPhysics.cc
-150
View File
@@ -1,150 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
/// \file runAndEvent/RE02/src/RE02MuonPhysics.cc
/// \brief Implementation of the RE02MuonPhysics class
//
// $Id$
// --------------------------------------------------------------
//
// 09-Oct-2003 mu+- tau+- processes are changed by T. Koi
// 05-Jan-2004 Add Brem. and PairProd. of AlongStepDoit for mu+- by T. Koi
#include "RE02MuonPhysics.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02MuonPhysics::RE02MuonPhysics(const G4String& name)
: G4VPhysicsConstructor(name)
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02MuonPhysics::~RE02MuonPhysics()
{
}
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4TauMinus.hh"
#include "G4TauPlus.hh"
#include "G4ProcessManager.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02MuonPhysics::ConstructProcess()
{
G4ProcessManager * pManager = 0;
//Muon+
pManager = G4MuonPlus::MuonPlus()->GetProcessManager();
G4VProcess* thempMultipleScattering = new G4MuMultipleScattering();
G4VProcess* thempBremsstrahlung = new G4MuBremsstrahlung();
G4VProcess* thempPairProduction = new G4MuPairProduction();
G4VProcess* thempIonisation = new G4MuIonisation();
//
// add processes
pManager->AddProcess(thempIonisation);
pManager->AddProcess(thempMultipleScattering);
pManager->AddProcess(thempBremsstrahlung);
pManager->AddProcess(thempPairProduction);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thempMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thempIonisation, idxAlongStep,2);
pManager->SetProcessOrdering(thempBremsstrahlung, idxAlongStep,3);
pManager->SetProcessOrdering(thempPairProduction, idxAlongStep,4);
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thempMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thempIonisation, idxPostStep,2);
pManager->SetProcessOrdering(thempBremsstrahlung, idxPostStep,3);
pManager->SetProcessOrdering(thempPairProduction, idxPostStep,4);
//Muon-
pManager = G4MuonMinus::MuonMinus()->GetProcessManager();
G4VProcess* themmMultipleScattering = new G4MuMultipleScattering();
G4VProcess* themmBremsstrahlung = new G4MuBremsstrahlung();
G4VProcess* themmPairProduction = new G4MuPairProduction();
G4VProcess* themmIonisation = new G4MuIonisation();
//
// add processes
pManager->AddProcess(themmIonisation);
pManager->AddProcess(themmMultipleScattering);
pManager->AddProcess(themmBremsstrahlung);
pManager->AddProcess(themmPairProduction);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(themmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(themmIonisation, idxAlongStep,2);
pManager->SetProcessOrdering(themmBremsstrahlung, idxAlongStep,3);
pManager->SetProcessOrdering(themmPairProduction, idxAlongStep,4);
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(themmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(themmIonisation, idxPostStep,2);
pManager->SetProcessOrdering(themmBremsstrahlung, idxPostStep,3);
pManager->SetProcessOrdering(themmPairProduction, idxPostStep,4);
// Tau+ Physics
pManager = G4TauPlus::TauPlus()->GetProcessManager();
G4VProcess* thetpMultipleScattering = new G4hMultipleScattering();
G4VProcess* thetpIonisation = new G4hIonisation();
//
// add processes
pManager->AddProcess(thetpIonisation);
pManager->AddProcess(thetpMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thetpMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thetpIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thetpMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thetpIonisation, idxPostStep,2);
// Tau- Physics
pManager = G4TauMinus::TauMinus()->GetProcessManager();
G4VProcess* thetmMultipleScattering = new G4hMultipleScattering();
G4VProcess* thetmIonisation = new G4hIonisation();
//
// add processes
pManager->AddProcess(thetmIonisation);
pManager->AddProcess(thetmMultipleScattering);
//
// set ordering for AlongStepDoIt
pManager->SetProcessOrdering(thetmMultipleScattering, idxAlongStep,1);
pManager->SetProcessOrdering(thetmIonisation, idxAlongStep,2);
//
// set ordering for PostStepDoIt
pManager->SetProcessOrdering(thetmMultipleScattering, idxPostStep,1);
pManager->SetProcessOrdering(thetmIonisation, idxPostStep,2);
}
examples/extended/runAndEvent/RE02/src/RE02PSCellFlux.cc
+5 -3
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02PSCellFlux class
//
//
// $Id$
// $Id: RE02PSCellFlux.cc 72957 2013-08-14 14:27:23Z gcosmo $
//
// RE02PSCellFlux
#include "RE02PSCellFlux.hh"
@@ -73,6 +73,8 @@ G4int RE02PSCellFlux::GetIndex(G4Step* aStep)
G4int ix = touchable->GetReplicaNumber(1);
G4int iy = touchable->GetReplicaNumber(2);
G4int iz = touchable->GetReplicaNumber(0);
return iy*fNx*fNz+ix*fNz+iz;
G4int tmp = fNy;
if (tmp) return iy*fNx*fNz+ix*fNz+iz;
else return iy*fNx*fNz+ix*fNz+iz;
}
examples/extended/runAndEvent/RE02/src/RE02PSEnergyDeposit.cc
+5 -2
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02PSEnergyDeposit class
//
//
// $Id$
// $Id: RE02PSEnergyDeposit.cc 72957 2013-08-14 14:27:23Z gcosmo $
//
// RE02PSEnergyDeposit
#include "RE02PSEnergyDeposit.hh"
@@ -74,5 +74,8 @@ G4int RE02PSEnergyDeposit::GetIndex(G4Step* aStep)
G4int ix = touchable->GetReplicaNumber(1);
G4int iy = touchable->GetReplicaNumber(2);
G4int iz = touchable->GetReplicaNumber(0);
return iy*fNx*fNz+ix*fNz+iz;
G4int tmp = fNy;
if (tmp) return iy*fNx*fNz+ix*fNz+iz;
else return iy*fNx*fNz+ix*fNz+iz;
}
examples/extended/runAndEvent/RE02/src/RE02PSFlatSurfaceCurrent.cc
+5 -3
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02PSFlatSurfaceCurrent class
//
//
// $Id$
// $Id: RE02PSFlatSurfaceCurrent.cc 72957 2013-08-14 14:27:23Z gcosmo $
//
// RE02PSFlatSurfaceCurrent
#include "RE02PSFlatSurfaceCurrent.hh"
@@ -75,6 +75,8 @@ G4int RE02PSFlatSurfaceCurrent::GetIndex(G4Step* aStep)
G4int ix = touchable->GetReplicaNumber(1);
G4int iy = touchable->GetReplicaNumber(2);
G4int iz = touchable->GetReplicaNumber(0);
return iy*fNx*fNz+ix*fNz+iz;
G4int tmp = fNy;
if (tmp) return iy*fNx*fNz+ix*fNz+iz;
else return iy*fNx*fNz+ix*fNz+iz;
}
examples/extended/runAndEvent/RE02/src/RE02PSFlatSurfaceFlux.cc
+5 -3
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02PSFlatSurfaceFlux class
//
//
// $Id$
// $Id: RE02PSFlatSurfaceFlux.cc 72957 2013-08-14 14:27:23Z gcosmo $
//
// RE02PSFlatSurfaceFlux
#include "RE02PSFlatSurfaceFlux.hh"
@@ -74,6 +74,8 @@ G4int RE02PSFlatSurfaceFlux::GetIndex(G4Step* aStep)
G4int ix = touchable->GetReplicaNumber(1);
G4int iy = touchable->GetReplicaNumber(2);
G4int iz = touchable->GetReplicaNumber(0);
return iy*fNx*fNz+ix*fNz+iz;
G4int tmp = fNy;
if (tmp) return iy*fNx*fNz+ix*fNz+iz;
else return iy*fNx*fNz+ix*fNz+iz;
}
examples/extended/runAndEvent/RE02/src/RE02PSNofStep.cc
+5 -3
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02PSNofStep class
//
//
// $Id$
// $Id: RE02PSNofStep.cc 72957 2013-08-14 14:27:23Z gcosmo $
//
// RE02PSNofStep
#include "RE02PSNofStep.hh"
@@ -73,6 +73,8 @@ G4int RE02PSNofStep::GetIndex(G4Step* aStep)
G4int ix = touchable->GetReplicaNumber(1);
G4int iy = touchable->GetReplicaNumber(2);
G4int iz = touchable->GetReplicaNumber(0);
return iy*fNx*fNz+ix*fNz+iz;
G4int tmp = fNy;
if (tmp) return iy*fNx*fNz+ix*fNz+iz;
else return iy*fNx*fNz+ix*fNz+iz;
}
examples/extended/runAndEvent/RE02/src/RE02PSPassageCellFlux.cc
+5 -3
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02PSPassageCellFlux class
//
//
// $Id$
// $Id: RE02PSPassageCellFlux.cc 72957 2013-08-14 14:27:23Z gcosmo $
//
// RE02PSPassageCellFlux
#include "RE02PSPassageCellFlux.hh"
@@ -74,6 +74,8 @@ G4int RE02PSPassageCellFlux::GetIndex(G4Step* aStep)
G4int ix = touchable->GetReplicaNumber(1);
G4int iy = touchable->GetReplicaNumber(2);
G4int iz = touchable->GetReplicaNumber(0);
return iy*fNx*fNz+ix*fNz+iz;
G4int tmp = fNy;
if (tmp) return iy*fNx*fNz+ix*fNz+iz;
else return iy*fNx*fNz+ix*fNz+iz;
}
examples/extended/runAndEvent/RE02/src/RE02PhysicsList.cc
-123
View File
@@ -1,123 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
/// \file runAndEvent/RE02/src/RE02PhysicsList.cc
/// \brief Implementation of the RE02PhysicsList class
//
// $Id$
// --------------------------------------------------------------
//
// 28-Jan-04 Add QGSP_BERT and QGSP_BIC for hadronic lists. T. Koi
// 22-Nov-04 Comment out QGSP_BERT and QGSP_BIC
// Output Notificaiton message
// All Particles are created in GeneralPhysics
#include "RE02PhysicsList.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleWithCuts.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 "RE02GeneralPhysics.hh"
#include "RE02EMPhysics.hh"
#include "RE02MuonPhysics.hh"
#include "RE02HadronPhysics.hh"
#include "RE02IonPhysics.hh"
//#include "HadronPhysicsQGSP_BERT.hh"
//#include "HadronPhysicsQGSP_BIC.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02PhysicsList::RE02PhysicsList() : G4VModularPhysicsList()
{
G4cout
<< "You are using the RE02PhysicsList\n"
<< "This PhysicsList originally comes from example/extended/analysis/A01,\n"
<< "and is modified in Hadron Physics in order to involve Binary Cascade\n"
<< "at low energy region and inelastic process for generic ions.\n"
<< "Full set of particles (barions bosons and mesons) will be created and\n"
<< "Standard EM Physics and Low & High Energy parameterized models will be "
<< "applied.\n"
<< "RE02PhysicsList is optimized for robustness and not for any particular "
<< "usage.\n"
<< "For the hadronic physics, educated guesses of physics list are "
<< "prepared\n"
<< "for various use cases.\n"
<< "When you will start REAL calculations for your own interest, please\n"
<< "consider the usage of hadronic_lists instead of RE02PhysicsLists.\n"
<< "More information can also be found from the Geant4 HyperNews.\n"
<< "http://geant4-hn.slac.stanford.edu:5090/Geant4-HyperNews/index\n"
<< G4endl;
// default cut value (1.0mm)
defaultCutValue = 1.0*mm;
SetVerboseLevel(1);
// General Physics ( Create ALL Particle and apply Decay )
RegisterPhysics( new RE02GeneralPhysics("general") );
// EM Physics ( Apply related Processes to gamma and e-/+)
RegisterPhysics( new RE02EMPhysics("standard EM"));
// Muon Physics ( Apply related processes to mu and tau
RegisterPhysics( new RE02MuonPhysics("muon"));
// Hadron Physics ( Apply related processes to hadrons )
RegisterPhysics( new RE02HadronPhysics("hadron"));
// We do not use hadronic lists since v7.
//RegisterPhysics( new HadronPhysicsQGSP_BERT("hadron"));
//RegisterPhysics( new HadronPhysicsQGSP_BIC("hadron"));
// Ion Physics ( Apply related processes to ions )
RegisterPhysics( new RE02IonPhysics("ion"));
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RE02PhysicsList::~RE02PhysicsList()
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02PhysicsList::SetCuts()
{
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
SetCutsWithDefault();
}
examples/extended/runAndEvent/RE02/src/RE02PrimaryGeneratorAction.cc
+3 -1
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02PrimaryGeneratorAction class
//
//
// $Id$
// $Id: RE02PrimaryGeneratorAction.cc 68026 2013-03-13 13:45:22Z gcosmo $
//
#include "RE02PrimaryGeneratorAction.hh"
@@ -43,6 +43,8 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//
RE02PrimaryGeneratorAction::RE02PrimaryGeneratorAction()
: G4VUserPrimaryGeneratorAction(),
fParticleGun(0)
{
G4int n_particle = 1;
fParticleGun = new G4ParticleGun(n_particle);
examples/extended/runAndEvent/RE02/src/RE02Run.cc
+21 -2
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02Run class
//
//
// $Id$
// $Id: RE02Run.cc 76292 2013-11-08 13:10:20Z gcosmo $
//
//=====================================================================
@@ -95,7 +95,8 @@ RE02Run::RE02Run(const std::vector<G4String> mfdName) : G4Run()
G4int collectionID = pSDman->GetCollectionID(fullCollectionName);
//
if ( collectionID >= 0 ){
G4cout << "++ "<<fullCollectionName<< " id " << collectionID << G4endl;
G4cout << "++ "<<fullCollectionName<< " id " << collectionID
<< G4endl;
// Store obtained HitsCollection information into data members.
// And, creates new G4THitsMap for accumulating quantities during RUN.
fCollName.push_back(fullCollectionName);
@@ -160,6 +161,24 @@ void RE02Run::RecordEvent(const G4Event* aEvent)
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RE02Run::Merge(const G4Run * aRun) {
const RE02Run * localRun = static_cast<const RE02Run *>(aRun);
//=======================================================
// Merge HitsMap of working threads
//=======================================================
G4int nCol = localRun->fCollID.size();
for ( G4int i = 0; i < nCol ; i++ ){ // Loop over HitsCollection
if ( localRun->fCollID[i] >= 0 ){
*fRunMap[i] += *localRun->fRunMap[i];
}
}
G4Run::Merge(aRun);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//
// Access method for HitsMap of the RUN
examples/extended/runAndEvent/RE02/src/RE02RunAction.cc
+5 -2
View File
@@ -27,7 +27,7 @@
/// \brief Implementation of the RE02RunAction class
//
//
// $Id$
// $Id: RE02RunAction.cc 75682 2013-11-05 09:11:19Z gcosmo $
//
#include "RE02RunAction.hh"
#include "RE02Run.hh"
@@ -51,7 +51,8 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// Constructor
RE02RunAction::RE02RunAction()
: fNx(0), fNy(0), fNz(0)
: G4UserRunAction(),
fNx(0), fNy(0), fNz(0)
{
// - Prepare data member for RE02Run.
// vector represents a list of MultiFunctionalDetector names.
@@ -86,6 +87,8 @@ void RE02RunAction::BeginOfRunAction(const G4Run* aRun)
//==
void RE02RunAction::EndOfRunAction(const G4Run* aRun)
{
if(!IsMaster()) return;
//- RE02Run object.
RE02Run* re02Run = (RE02Run*)aRun;
//--- Dump all socred quantities involved in RE02Run.