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

Import Geant4 11.3.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2024-06-28 13:08:51 +02:00
parent f7b23877ed
commit e58e650b32
5232 changed files with 239416 additions and 244360 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/extended/hadronic/ParticleFluence/Layer/src/ActionInitialization.cc
+14 -11
View File
@@ -32,35 +32,38 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "ActionInitialization.hh"
#include "PrimaryGeneratorAction.hh"
#include "Run.hh"
#include "RunAction.hh"
#include "SteppingAction.hh"
#include "TrackingAction.hh"
#include "Run.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
ActionInitialization::ActionInitialization( const DetectorConstruction*
inputDetectorConstruction ) :
G4VUserActionInitialization(), fPtrDetectorConstruction( inputDetectorConstruction ) {}
ActionInitialization::ActionInitialization(const DetectorConstruction* inputDetectorConstruction)
: G4VUserActionInitialization(), fPtrDetectorConstruction(inputDetectorConstruction)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void ActionInitialization::BuildForMaster() const {
void ActionInitialization::BuildForMaster() const
{
// This is NOT called in SEQ-mode, while in the MT-mode is called only for the Master thread.
SetUserAction( new RunAction );
SetUserAction(new RunAction);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void ActionInitialization::Build() const {
void ActionInitialization::Build() const
{
// This is called in the SEQ-mode and in the MT-mode only for Worker threads.
SetUserAction( new PrimaryGeneratorAction( fPtrDetectorConstruction ) );
SetUserAction(new PrimaryGeneratorAction(fPtrDetectorConstruction));
SteppingAction* steppingAction = new SteppingAction;
SetUserAction( steppingAction );
SetUserAction(steppingAction);
TrackingAction* trackingAction = new TrackingAction;
SetUserAction( trackingAction );
SetUserAction( new RunAction( steppingAction, trackingAction ) );
SetUserAction(trackingAction);
SetUserAction(new RunAction(steppingAction, trackingAction));
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Layer/src/DetectorConstruction.cc
+152 -145
View File
@@ -32,55 +32,66 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "DetectorConstruction.hh"
#include "DetectorMessenger.hh"
#include "PrimaryGeneratorAction.hh"
#include "G4Box.hh"
#include "G4GeometryManager.hh"
#include "G4LogicalVolume.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4Material.hh"
#include "G4NistManager.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4LogicalVolume.hh"
#include "G4ThreeVector.hh"
#include "G4PVPlacement.hh"
#include "globals.hh"
#include "G4GeometryManager.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4SolidStore.hh"
#include "G4RunManager.hh"
#include "G4SystemOfUnits.hh"
#include "G4PhysicalConstants.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4RunManager.hh"
#include "G4SolidStore.hh"
#include "G4SystemOfUnits.hh"
#include "G4ThreeVector.hh"
#include "G4Tubs.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorConstruction::DetectorConstruction() :
fMaterial( nullptr ), fExperimentalHall_log( nullptr ), fExperimentalHall_phys( nullptr ),
fLogicLayer( nullptr ), fPhysiLayer( nullptr ),
fLogicScoringUpDown( nullptr ), fPhysiScoringUpstream( nullptr ),
fPhysiScoringDownstream( nullptr ),
fLogicScoringSide( nullptr ), fPhysiScoringSide( nullptr ),
fDetectorMessenger( nullptr ),
fThickness( 2.0*CLHEP::m ), fDiameter( 2.0*CLHEP::m ) //***LOOKHERE*** Default values
DetectorConstruction::DetectorConstruction()
: fMaterial(nullptr),
fExperimentalHall_log(nullptr),
fExperimentalHall_phys(nullptr),
fLogicLayer(nullptr),
fPhysiLayer(nullptr),
fLogicScoringUpDown(nullptr),
fPhysiScoringUpstream(nullptr),
fPhysiScoringDownstream(nullptr),
fLogicScoringSide(nullptr),
fPhysiScoringSide(nullptr),
fDetectorMessenger(nullptr),
fThickness(2.0 * CLHEP::m),
fDiameter(2.0 * CLHEP::m) //***LOOKHERE*** Default values
{
fMaterial = G4NistManager::Instance()->FindOrBuildMaterial( "G4_Fe" ); //***LOOKHERE***
// Default material
fDetectorMessenger = new DetectorMessenger( this );
fMaterial = G4NistManager::Instance()->FindOrBuildMaterial("G4_Fe"); //***LOOKHERE***
// Default material
fDetectorMessenger = new DetectorMessenger(this);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorConstruction::~DetectorConstruction() {
DetectorConstruction::~DetectorConstruction()
{
delete fDetectorMessenger;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4VPhysicalVolume* DetectorConstruction::Construct() {
G4VPhysicalVolume* DetectorConstruction::Construct()
{
return ConstructLayer();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4VPhysicalVolume* DetectorConstruction::ConstructLayer() {
G4VPhysicalVolume* DetectorConstruction::ConstructLayer()
{
// Clean old geometry, if any.
G4GeometryManager::GetInstance()->OpenGeometry();
G4PhysicalVolumeStore::GetInstance()->Clean();
@@ -92,156 +103,152 @@ G4VPhysicalVolume* DetectorConstruction::ConstructLayer() {
// The world volume (experimental hall) is a box 20% bigger than the target layer,
// and it is filled of "G4_Galactic" material.
G4double expHall_x = 0.6*fDiameter; // half dimension along x : 20% bigger than the radius
// of the target layer
G4double expHall_y = 0.6*fDiameter; // half dimension along y : 20% bigger than the radius
// of the target layer
G4double expHall_z = 0.6*fThickness; // half dimension along z : 20% bigger than the half
// thickness of the target layer
G4double expHall_x = 0.6 * fDiameter; // half dimension along x : 20% bigger than the radius
// of the target layer
G4double expHall_y = 0.6 * fDiameter; // half dimension along y : 20% bigger than the radius
// of the target layer
G4double expHall_z = 0.6 * fThickness; // half dimension along z : 20% bigger than the half
// thickness of the target layer
G4Material* vacuum = G4NistManager::Instance()->FindOrBuildMaterial( "G4_Galactic" );
G4Material* vacuum = G4NistManager::Instance()->FindOrBuildMaterial("G4_Galactic");
// Experimental hall
G4Box* experimentalHall_box = new G4Box( "expHall_box", expHall_x, expHall_y, expHall_z );
fExperimentalHall_log = new G4LogicalVolume( experimentalHall_box, // solid
vacuum, // material
"expHall_log", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
fExperimentalHall_phys = new G4PVPlacement( 0, // rotation
G4ThreeVector(), // translation
"expHall", // name
fExperimentalHall_log, // logical volume
0, // mother physical volume
false, // boolean operation
0 ); // copy number
G4Box* experimentalHall_box = new G4Box("expHall_box", expHall_x, expHall_y, expHall_z);
fExperimentalHall_log = new G4LogicalVolume(experimentalHall_box, // solid
vacuum, // material
"expHall_log", // name
0, // field manager
0, // sensitive detector
0); // user limits
fExperimentalHall_phys = new G4PVPlacement(0, // rotation
G4ThreeVector(), // translation
"expHall", // name
fExperimentalHall_log, // logical volume
0, // mother physical volume
false, // boolean operation
0); // copy number
// Target
G4Tubs* solidLayer = new G4Tubs( "solidLayer", // name
0.0, // inner radius
0.5*fDiameter, // outer radius
0.5*fThickness, // half cylinder length in z
0.0, // starting phi angle in rad
2.0*pi ); // final phi angle in rad
fLogicLayer = new G4LogicalVolume( solidLayer, // solid
fMaterial, // material
"logicLayer", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
fPhysiLayer = new G4PVPlacement( 0, // rotation
G4ThreeVector(), // translation
"physiLayer", // name
fLogicLayer, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0 ); // copy number
G4Tubs* solidLayer = new G4Tubs("solidLayer", // name
0.0, // inner radius
0.5 * fDiameter, // outer radius
0.5 * fThickness, // half cylinder length in z
0.0, // starting phi angle in rad
2.0 * pi); // final phi angle in rad
fLogicLayer = new G4LogicalVolume(solidLayer, // solid
fMaterial, // material
"logicLayer", // name
0, // field manager
0, // sensitive detector
0); // user limits
fPhysiLayer = new G4PVPlacement(0, // rotation
G4ThreeVector(), // translation
"physiLayer", // name
fLogicLayer, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0); // copy number
// Three scoring volumes: one thin layer downstream of the target ("down")
// one thin layer surrounding (lateral) of the target ("side")
// one thin layer upstream of the target ("up")
G4Tubs* solidScoringUpDown = new G4Tubs( "solidScoringUpDown", // name
0.0, // inner radius
0.5*fDiameter, // outer radius
0.5*fScoringThickness, // half cylinder length in z
0.0, // starting phi angle in rad
2.0*pi ); // final phi angle in rad
fLogicScoringUpDown = new G4LogicalVolume( solidScoringUpDown, // solid
vacuum, // material
"logicScoringUpDown", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
G4double zScoringUpDown = 0.5*(fThickness + fScoringThickness);
fPhysiScoringUpstream = new G4PVPlacement( 0, // rotation
G4ThreeVector( 0.0, 0.0, -zScoringUpDown ),
// translation
"physiScoringUpstream", // name
fLogicScoringUpDown, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0 ); // copy number
fPhysiScoringDownstream = new G4PVPlacement( 0, // rotation
G4ThreeVector( 0.0, 0.0, zScoringUpDown ),
// translation
"physiScoringDownstream", // name
fLogicScoringUpDown, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0 ); // copy number
G4Tubs* solidScoringUpDown = new G4Tubs("solidScoringUpDown", // name
0.0, // inner radius
0.5 * fDiameter, // outer radius
0.5 * fScoringThickness, // half cylinder length in z
0.0, // starting phi angle in rad
2.0 * pi); // final phi angle in rad
fLogicScoringUpDown = new G4LogicalVolume(solidScoringUpDown, // solid
vacuum, // material
"logicScoringUpDown", // name
0, // field manager
0, // sensitive detector
0); // user limits
G4double zScoringUpDown = 0.5 * (fThickness + fScoringThickness);
fPhysiScoringUpstream = new G4PVPlacement(0, // rotation
G4ThreeVector(0.0, 0.0, -zScoringUpDown),
// translation
"physiScoringUpstream", // name
fLogicScoringUpDown, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0); // copy number
fPhysiScoringDownstream = new G4PVPlacement(0, // rotation
G4ThreeVector(0.0, 0.0, zScoringUpDown),
// translation
"physiScoringDownstream", // name
fLogicScoringUpDown, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0); // copy number
G4Tubs* solidScoringSide = new G4Tubs( "solidScoringSide", // name
0.5*fDiameter, // inner radius
0.5*fDiameter + fScoringThickness, // outer radius
0.5*fThickness, // half cylinder length in z
0.0, // starting phi angle in rad
2.0*pi ); // final phi angle in rad
fLogicScoringSide = new G4LogicalVolume( solidScoringSide, // solid
vacuum, // material
"logicScoringSide", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
fPhysiScoringSide = new G4PVPlacement( 0, // rotation
G4ThreeVector( 0.0, 0.0, 0.0 ), // translation
"physiScoringSide", // name
fLogicScoringSide, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0 ); // copy number
G4Tubs* solidScoringSide = new G4Tubs("solidScoringSide", // name
0.5 * fDiameter, // inner radius
0.5 * fDiameter + fScoringThickness, // outer radius
0.5 * fThickness, // half cylinder length in z
0.0, // starting phi angle in rad
2.0 * pi); // final phi angle in rad
fLogicScoringSide = new G4LogicalVolume(solidScoringSide, // solid
vacuum, // material
"logicScoringSide", // name
0, // field manager
0, // sensitive detector
0); // user limits
fPhysiScoringSide = new G4PVPlacement(0, // rotation
G4ThreeVector(0.0, 0.0, 0.0), // translation
"physiScoringSide", // name
fLogicScoringSide, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
0); // copy number
G4cout << G4endl
<< "DetectorConstruction::ConstructLayer() : " << G4endl
<< "\t World (box) size: " << G4endl
<< "\t \t x : -/+ " << expHall_x << " mm ;"
<< "\t y : -/+ " << expHall_y << " mm ;"
<< "\t z : -/+ " << expHall_z << " mm ;" << G4endl
<< "\t Target layer (cylinder) size: " << G4endl
<< "\t \t x : -/+ " << 0.5*fDiameter << " mm ;"
<< "\t y : -/+ " << 0.5*fDiameter << " mm ;"
<< "\t z : -/+ " << 0.5*fThickness << " mm ;" << G4endl
<< G4endl << G4endl;
G4cout << G4endl << "DetectorConstruction::ConstructLayer() : " << G4endl
<< "\t World (box) size: " << G4endl << "\t \t x : -/+ " << expHall_x << " mm ;"
<< "\t y : -/+ " << expHall_y << " mm ;"
<< "\t z : -/+ " << expHall_z << " mm ;" << G4endl
<< "\t Target layer (cylinder) size: " << G4endl << "\t \t x : -/+ " << 0.5 * fDiameter
<< " mm ;"
<< "\t y : -/+ " << 0.5 * fDiameter << " mm ;"
<< "\t z : -/+ " << 0.5 * fThickness << " mm ;" << G4endl << G4endl << G4endl;
return fExperimentalHall_phys;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::SetMaterial( const G4String name ) {
fMaterial = G4NistManager::Instance()->FindOrBuildMaterial( name );
if ( ! fMaterial ) {
G4cout << G4endl << G4endl
<< "WARNING: the name of the material has not been recognized!" << G4endl
<< " ===> the default * G4_Fe * will be used."
<< G4endl << G4endl;
fMaterial = G4NistManager::Instance()->FindOrBuildMaterial( "G4_Fe" );
void DetectorConstruction::SetMaterial(const G4String name)
{
fMaterial = G4NistManager::Instance()->FindOrBuildMaterial(name);
if (!fMaterial) {
G4cout << G4endl << G4endl << "WARNING: the name of the material has not been recognized!"
<< G4endl << " ===> the default * G4_Fe * will be used." << G4endl << G4endl;
fMaterial = G4NistManager::Instance()->FindOrBuildMaterial("G4_Fe");
}
if ( fLogicLayer ) fLogicLayer->SetMaterial( fMaterial );
if (fLogicLayer) fLogicLayer->SetMaterial(fMaterial);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::UpdateGeometry() {
void DetectorConstruction::UpdateGeometry()
{
G4RunManager::GetRunManager()->ReinitializeGeometry();
PrintParameters();
// Update also the position of the gun
const PrimaryGeneratorAction* pPrimaryAction = dynamic_cast< const PrimaryGeneratorAction* >(
G4RunManager::GetRunManager()->GetUserPrimaryGeneratorAction() );
if ( pPrimaryAction ) pPrimaryAction->SetGunPosition();
const PrimaryGeneratorAction* pPrimaryAction = dynamic_cast<const PrimaryGeneratorAction*>(
G4RunManager::GetRunManager()->GetUserPrimaryGeneratorAction());
if (pPrimaryAction) pPrimaryAction->SetGunPosition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::PrintParameters() {
G4cout << G4endl << G4endl
<< " ------ DetectorConstruction::PrintParameters() ------ " << G4endl
void DetectorConstruction::PrintParameters()
{
G4cout << G4endl << G4endl << " ------ DetectorConstruction::PrintParameters() ------ " << G4endl
<< " Material = " << fMaterial->GetName() << G4endl
<< " Thickness = " << fThickness << " mm" << G4endl
<< " Diameter = " << fDiameter << " mm" << G4endl
<< " ScoringThickness = " << fScoringThickness << " mm" << G4endl
<< " ------------------------------------------------------ "
<< G4endl << G4endl;
<< " Diameter = " << fDiameter << " mm" << G4endl
<< " ScoringThickness = " << fScoringThickness << " mm" << G4endl
<< " ------------------------------------------------------ " << G4endl << G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Layer/src/DetectorMessenger.cc
+40 -35
View File
@@ -32,48 +32,52 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "DetectorMessenger.hh"
#include "DetectorConstruction.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithoutParameter.hh"
#include "G4UIdirectory.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorMessenger::DetectorMessenger( DetectorConstruction* myDet ) : fDetector( myDet ) {
fDetectorDir = new G4UIdirectory( "/mydet/" );
fDetectorDir->SetGuidance( "Detector control." );
DetectorMessenger::DetectorMessenger(DetectorConstruction* myDet) : fDetector(myDet)
{
fDetectorDir = new G4UIdirectory("/mydet/");
fDetectorDir->SetGuidance("Detector control.");
fMaterial = new G4UIcmdWithAString( "/mydet/material", this );
fMaterial->SetGuidance( "Choice of the material:" );
fMaterial->SetGuidance( " a Geant4 NIST material, e.g. G4_Fe " );
fMaterial->SetParameterName( "choiceMaterial", true );
fMaterial->SetDefaultValue( "G4_Fe" );
fMaterial->AvailableForStates( G4State_PreInit, G4State_Idle );
fThickness = new G4UIcmdWithADoubleAndUnit( "/mydet/thickness", this );
fThickness->SetParameterName( "choiceThickness", true );
fThickness->SetGuidance( "Target thickness" );
fThickness->SetDefaultValue( 1000.0 ); // default: 1 meter.
fThickness->AvailableForStates( G4State_PreInit, G4State_Idle );
fMaterial = new G4UIcmdWithAString("/mydet/material", this);
fMaterial->SetGuidance("Choice of the material:");
fMaterial->SetGuidance(" a Geant4 NIST material, e.g. G4_Fe ");
fMaterial->SetParameterName("choiceMaterial", true);
fMaterial->SetDefaultValue("G4_Fe");
fMaterial->AvailableForStates(G4State_PreInit, G4State_Idle);
fDiameter = new G4UIcmdWithADoubleAndUnit( "/mydet/diameter", this );
fDiameter->SetParameterName( "choiceDiameter", true );
fDiameter->SetGuidance( "Target diameter" );
fDiameter->SetDefaultValue( 1000.0 ); // default: 1 meter.
fDiameter->AvailableForStates( G4State_PreInit, G4State_Idle );
fThickness = new G4UIcmdWithADoubleAndUnit("/mydet/thickness", this);
fThickness->SetParameterName("choiceThickness", true);
fThickness->SetGuidance("Target thickness");
fThickness->SetDefaultValue(1000.0); // default: 1 meter.
fThickness->AvailableForStates(G4State_PreInit, G4State_Idle);
fUpdateCommand = new G4UIcmdWithoutParameter( "/mydet/update", this);
fUpdateCommand->SetGuidance( "Update calorimeter geometry." );
fUpdateCommand->SetGuidance( "This command MUST be applied before \"beamOn\" " );
fUpdateCommand->SetGuidance( "if you changed geometrical value(s)." );
fUpdateCommand->AvailableForStates( G4State_Idle );
fDiameter = new G4UIcmdWithADoubleAndUnit("/mydet/diameter", this);
fDiameter->SetParameterName("choiceDiameter", true);
fDiameter->SetGuidance("Target diameter");
fDiameter->SetDefaultValue(1000.0); // default: 1 meter.
fDiameter->AvailableForStates(G4State_PreInit, G4State_Idle);
fUpdateCommand = new G4UIcmdWithoutParameter("/mydet/update", this);
fUpdateCommand->SetGuidance("Update calorimeter geometry.");
fUpdateCommand->SetGuidance("This command MUST be applied before \"beamOn\" ");
fUpdateCommand->SetGuidance("if you changed geometrical value(s).");
fUpdateCommand->AvailableForStates(G4State_Idle);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorMessenger::~DetectorMessenger() {
DetectorMessenger::~DetectorMessenger()
{
delete fDetectorDir;
delete fMaterial;
delete fThickness;
@@ -83,17 +87,18 @@ DetectorMessenger::~DetectorMessenger() {
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorMessenger::SetNewValue( G4UIcommand* command, G4String newValue ) {
if ( command == fMaterial ) {
fDetector->SetMaterial( newValue );
void DetectorMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
{
if (command == fMaterial) {
fDetector->SetMaterial(newValue);
}
if ( command == fThickness ) {
fDetector->SetThickness( fThickness->GetNewDoubleValue( newValue ) );
if (command == fThickness) {
fDetector->SetThickness(fThickness->GetNewDoubleValue(newValue));
}
if ( command == fDiameter ) {
fDetector->SetDiameter( fDiameter->GetNewDoubleValue(newValue) );
if (command == fDiameter) {
fDetector->SetDiameter(fDiameter->GetNewDoubleValue(newValue));
}
if ( command == fUpdateCommand ) {
if (command == fUpdateCommand) {
fDetector->UpdateGeometry();
}
}
examples/extended/hadronic/ParticleFluence/Layer/src/PrimaryGeneratorAction.cc
+25 -20
View File
@@ -32,54 +32,59 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "PrimaryGeneratorAction.hh"
#include "DetectorConstruction.hh"
#include "G4Event.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleGun.hh"
#include "G4ParticleTable.hh"
#include "G4ParticleDefinition.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PrimaryGeneratorAction::
PrimaryGeneratorAction( const DetectorConstruction* pDetector ) :
fPointerDetectorConstruction( pDetector )
PrimaryGeneratorAction::PrimaryGeneratorAction(const DetectorConstruction* pDetector)
: fPointerDetectorConstruction(pDetector)
{
G4int n_particle = 1;
fParticleGun = new G4ParticleGun( n_particle );
fParticleGun = new G4ParticleGun(n_particle);
G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
//***LOOKHERE*** Default particle and energy
fParticleGun->SetParticleDefinition( particleTable->FindParticle( "geantino" ) );
fParticleGun->SetParticleEnergy( 10.0*GeV );
fParticleGun->SetParticleDefinition(particleTable->FindParticle("geantino"));
fParticleGun->SetParticleEnergy(10.0 * GeV);
SetGunPosition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PrimaryGeneratorAction::~PrimaryGeneratorAction() {
PrimaryGeneratorAction::~PrimaryGeneratorAction()
{
delete fParticleGun;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PrimaryGeneratorAction::SetGunPosition() const {
void PrimaryGeneratorAction::SetGunPosition() const
{
// Shoot the particle in the middle between the world and the target layer
G4double targetThickness =
( fPointerDetectorConstruction ? fPointerDetectorConstruction->GetThickness() : 0.0 );
G4double gunPosition = -0.55*targetThickness; //***LOOKHERE*** default gun position
// along the z-axis
G4cout << G4endl << "PrimaryGenerationAction::SetGunPosition() : gun position along z = "
<< gunPosition << " mm " << G4endl << G4endl;
fParticleGun->SetParticlePosition( G4ThreeVector( 0.0, 0.0, gunPosition ) );
(fPointerDetectorConstruction ? fPointerDetectorConstruction->GetThickness() : 0.0);
G4double gunPosition = -0.55 * targetThickness; //***LOOKHERE*** default gun position
// along the z-axis
G4cout << G4endl
<< "PrimaryGenerationAction::SetGunPosition() : gun position along z = " << gunPosition
<< " mm " << G4endl << G4endl;
fParticleGun->SetParticlePosition(G4ThreeVector(0.0, 0.0, gunPosition));
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PrimaryGeneratorAction::GeneratePrimaries( G4Event* anEvent ) {
G4ThreeVector v( 0.0, 0.0, 1.0 ); //***LOOKHERE*** default shoot along the z-axis
fParticleGun->SetParticleMomentumDirection( v );
fParticleGun->GeneratePrimaryVertex( anEvent );
void PrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent)
{
G4ThreeVector v(0.0, 0.0, 1.0); //***LOOKHERE*** default shoot along the z-axis
fParticleGun->SetParticleMomentumDirection(v);
fParticleGun->GeneratePrimaryVertex(anEvent);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Layer/src/Run.cc
+69 -63
View File
@@ -32,39 +32,46 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "Run.hh"
#include "G4SystemOfUnits.hh"
#include "G4Run.hh"
#include "G4RunManager.hh"
#include "G4SystemOfUnits.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
Run::Run() : G4Run(), fNumEvents( 0 ),
fPrimaryParticleId( 0 ), fPrimaryParticleEnergy( 0.0 ),
fPrimaryParticleDirection( G4ThreeVector( 0.0, 0.0, 0.0 ) ),
fTargetMaterialName( "" ),
fCubicVolumeScoringUpDown( 1.0 ), fCubicVolumeScoringSide( 1.0 )
Run::Run()
: G4Run(),
fNumEvents(0),
fPrimaryParticleId(0),
fPrimaryParticleEnergy(0.0),
fPrimaryParticleDirection(G4ThreeVector(0.0, 0.0, 0.0)),
fTargetMaterialName(""),
fCubicVolumeScoringUpDown(1.0),
fCubicVolumeScoringSide(1.0)
{
fSteppingArray.fill( 0.0 );
fTrackingArray1.fill( 0 );
fTrackingArray2.fill( 0.0 );
fSteppingArray.fill(0.0);
fTrackingArray1.fill(0);
fTrackingArray2.fill(0.0);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void Run::RecordEvent( const G4Event* anEvent ) {
void Run::RecordEvent(const G4Event* anEvent)
{
// This method is called automatically by the Geant4 kernel (not by the user!) at the end
// of each event : in MT-mode, it is called only for the working thread that handled the event.
G4int nEvt = anEvent->GetEventID();
if ( nEvt % 10 == 0 ) G4cout << " Event#=" << nEvt << G4endl;
G4Run::RecordEvent( anEvent );
if (nEvt % 10 == 0) G4cout << " Event#=" << nEvt << G4endl;
G4Run::RecordEvent(anEvent);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void Run::Merge( const G4Run* aRun ) {
void Run::Merge(const G4Run* aRun)
{
// This method is called automatically by the Geant4 kernel (not by the user!) only in the case
// of multithreaded mode and only for working threads.
const Run* localRun = static_cast< const Run* >( aRun );
const Run* localRun = static_cast<const Run*>(aRun);
fPrimaryParticleId = localRun->GetPrimaryParticleId();
fPrimaryParticleEnergy = localRun->GetPrimaryParticleEnergy();
fPrimaryParticleDirection = localRun->GetPrimaryParticleDirection();
@@ -72,54 +79,52 @@ void Run::Merge( const G4Run* aRun ) {
fCubicVolumeScoringUpDown = localRun->GetCubicVolumeScoringUpDown();
fCubicVolumeScoringSide = localRun->GetCubicVolumeScoringSide();
fNumEvents += localRun->GetNumberOfEvent();
for ( G4int i = 0; i < SteppingAction::fkNumberCombinations; ++i ) {
for (G4int i = 0; i < SteppingAction::fkNumberCombinations; ++i) {
fSteppingArray[i] += localRun->GetSteppingArray()[i];
}
for ( G4int i = 0; i < TrackingAction::fkNumberCombinations; ++i ) {
for (G4int i = 0; i < TrackingAction::fkNumberCombinations; ++i) {
fTrackingArray1[i] += localRun->GetTrackingArray1()[i];
fTrackingArray2[i] += localRun->GetTrackingArray2()[i];
}
G4Run::Merge( aRun );
G4Run::Merge(aRun);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void Run::PrintInfo() const {
void Run::PrintInfo() const
{
// This method is called by RunAction::EndOfRunAction. In MT-mode, only the master thread
// calls it.
const G4double floatingNumberOfEvents =
std::max( 1.0, fNumEvents > 0 ? fNumEvents*1.0 : GetNumberOfEvent()*1.0 );
std::max(1.0, fNumEvents > 0 ? fNumEvents * 1.0 : GetNumberOfEvent() * 1.0);
// The fluence in the scoring volume is defined as sum of step lengths in that volume
// divided by the volume of that scoring volume.
const G4double conversionFactor = CLHEP::cm * CLHEP::cm; // From mm^-2 to cm^-2
const G4double factorUpDown =
conversionFactor / ( fCubicVolumeScoringUpDown*floatingNumberOfEvents );
const G4double factorSide =
conversionFactor / ( fCubicVolumeScoringSide*floatingNumberOfEvents );
conversionFactor / (fCubicVolumeScoringUpDown * floatingNumberOfEvents);
const G4double factorSide = conversionFactor / (fCubicVolumeScoringSide * floatingNumberOfEvents);
G4cout << std::setprecision(6) << G4endl << G4endl
<< " =============== Run::PrintInfo() =============== \t RunID = " << GetRunID()
<< G4endl
<< " Primary particle PDG code = " << fPrimaryParticleId << G4endl
<< " Primary particle kinetic energy = " << fPrimaryParticleEnergy / CLHEP::GeV
<< " GeV" << G4endl
<< " Primary particle direction = " << fPrimaryParticleDirection << G4endl
<< G4endl << " Primary particle PDG code = " << fPrimaryParticleId << G4endl
<< " Primary particle kinetic energy = " << fPrimaryParticleEnergy / CLHEP::GeV << " GeV"
<< G4endl << " Primary particle direction = " << fPrimaryParticleDirection << G4endl
<< " Target material = " << fTargetMaterialName << G4endl
<< " Cubic-volume scoring up-down = " << fCubicVolumeScoringUpDown << " mm^3" << G4endl
<< " Cubic-volume scoring side = " << fCubicVolumeScoringSide << " mm^3" << G4endl
<< " Cubic-volume scoring side = " << fCubicVolumeScoringSide << " mm^3" << G4endl
<< " Number of events = " << floatingNumberOfEvents << G4endl
<< " Conversion factor: fluence from mm^-2 to cm^-2 = " << conversionFactor << G4endl
<< " Particle fluence in unit of cm^-2 :" << G4endl;
for ( G4int i = 0; i < SteppingAction::fkNumberScoringVolumes; ++i ) {
G4double factor = ( i == 1 ? factorSide : factorUpDown );
for ( G4int j = 0; j < SteppingAction::fkNumberKinematicRegions; ++j ) {
for ( G4int k = 0; k < SteppingAction::fkNumberParticleTypes; ++k ) {
G4int index = SteppingAction::GetIndex( i, j, k );
//G4cout << "(i, j, k)=(" << i << ", " << j << ", " << k << ") ->" << index;
G4cout << " case=" << std::setw(3) << index
<< " " << std::setw(12) << SteppingAction::fkArrayScoringVolumeNames[i]
<< " " << std::setw(12) << SteppingAction::fkArrayKinematicRegionNames[j]
<< " " << std::setw(12) << SteppingAction::fkArrayParticleTypeNames[k]
<< " " << std::setw( 8) << factor*fSteppingArray[index] << G4endl;
for (G4int i = 0; i < SteppingAction::fkNumberScoringVolumes; ++i) {
G4double factor = (i == 1 ? factorSide : factorUpDown);
for (G4int j = 0; j < SteppingAction::fkNumberKinematicRegions; ++j) {
for (G4int k = 0; k < SteppingAction::fkNumberParticleTypes; ++k) {
G4int index = SteppingAction::GetIndex(i, j, k);
// G4cout << "(i, j, k)=(" << i << ", " << j << ", " << k << ") ->" << index;
G4cout << " case=" << std::setw(3) << index << " " << std::setw(12)
<< SteppingAction::fkArrayScoringVolumeNames[i] << " " << std::setw(12)
<< SteppingAction::fkArrayKinematicRegionNames[j] << " " << std::setw(12)
<< SteppingAction::fkArrayParticleTypeNames[k] << " " << std::setw(8)
<< factor * fSteppingArray[index] << G4endl;
}
}
}
@@ -127,21 +132,19 @@ void Run::PrintInfo() const {
<< " Extra information: particle production \t \t <N> <E_kin> <Sum_Ekin> [MeV]"
<< G4endl;
const G4double normalization = 1.0 / floatingNumberOfEvents;
for ( G4int i = 0; i < TrackingAction::fkNumberScoringVolumes; ++i ) {
for ( G4int j = 0; j < TrackingAction::fkNumberKinematicRegions; ++j ) {
for ( G4int k = 0; k < TrackingAction::fkNumberParticleTypes; ++k ) {
G4int index = TrackingAction::GetIndex( i, j, k );
//G4cout << "(i, j, k)=(" << i << ", " << j << ", " << k << ") ->" << index;
G4cout << " case=" << std::setw(3) << index
<< " " << std::setw(12) << TrackingAction::fkArrayScoringVolumeNames[i]
<< " " << std::setw(12) << TrackingAction::fkArrayKinematicRegionNames[j]
<< " " << std::setw(12) << TrackingAction::fkArrayParticleTypeNames[k]
<< " " << std::setw( 8) << normalization * fTrackingArray1[index]
<< " " << std::setw( 8) << ( fTrackingArray1[index] > 0 ?
fTrackingArray2[index] / fTrackingArray1[index] :
0.0 )
<< " " << std::setw( 8) << normalization * fTrackingArray2[index]
<< G4endl;
for (G4int i = 0; i < TrackingAction::fkNumberScoringVolumes; ++i) {
for (G4int j = 0; j < TrackingAction::fkNumberKinematicRegions; ++j) {
for (G4int k = 0; k < TrackingAction::fkNumberParticleTypes; ++k) {
G4int index = TrackingAction::GetIndex(i, j, k);
// G4cout << "(i, j, k)=(" << i << ", " << j << ", " << k << ") ->" << index;
G4cout << " case=" << std::setw(3) << index << " " << std::setw(12)
<< TrackingAction::fkArrayScoringVolumeNames[i] << " " << std::setw(12)
<< TrackingAction::fkArrayKinematicRegionNames[j] << " " << std::setw(12)
<< TrackingAction::fkArrayParticleTypeNames[k] << " " << std::setw(8)
<< normalization * fTrackingArray1[index] << " " << std::setw(8)
<< (fTrackingArray1[index] > 0 ? fTrackingArray2[index] / fTrackingArray1[index]
: 0.0)
<< " " << std::setw(8) << normalization * fTrackingArray2[index] << G4endl;
}
}
}
@@ -150,27 +153,30 @@ void Run::PrintInfo() const {
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void Run::SetSteppingArray( const std::array< G4double,
SteppingAction::fkNumberCombinations >& inputArray ) {
for ( G4int i = 0; i < SteppingAction::fkNumberCombinations; ++i ) {
void Run::SetSteppingArray(
const std::array<G4double, SteppingAction::fkNumberCombinations>& inputArray)
{
for (G4int i = 0; i < SteppingAction::fkNumberCombinations; ++i) {
fSteppingArray[i] = inputArray[i];
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void Run::SetTrackingArray1( const std::array< G4long,
TrackingAction::fkNumberCombinations >& inputArray ) {
for ( G4int i = 0; i < TrackingAction::fkNumberCombinations; ++i ) {
void Run::SetTrackingArray1(
const std::array<G4long, TrackingAction::fkNumberCombinations>& inputArray)
{
for (G4int i = 0; i < TrackingAction::fkNumberCombinations; ++i) {
fTrackingArray1[i] = inputArray[i];
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void Run::SetTrackingArray2( const std::array< G4double,
TrackingAction::fkNumberCombinations >& inputArray ) {
for ( G4int i = 0; i < TrackingAction::fkNumberCombinations; ++i ) {
void Run::SetTrackingArray2(
const std::array<G4double, TrackingAction::fkNumberCombinations>& inputArray)
{
for (G4int i = 0; i < TrackingAction::fkNumberCombinations; ++i) {
fTrackingArray2[i] = inputArray[i];
}
}
examples/extended/hadronic/ParticleFluence/Layer/src/RunAction.cc
+22 -16
View File
@@ -32,46 +32,52 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "RunAction.hh"
#include "globals.hh"
#include "G4Run.hh"
#include "Run.hh"
#include "SteppingAction.hh"
#include "TrackingAction.hh"
#include "G4Run.hh"
#include "G4RunManager.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::RunAction( SteppingAction* steppingAction, TrackingAction* trackingAction ) :
G4UserRunAction(), fSteppingAction( steppingAction ), fTrackingAction( trackingAction ) {}
RunAction::RunAction(SteppingAction* steppingAction, TrackingAction* trackingAction)
: G4UserRunAction(), fSteppingAction(steppingAction), fTrackingAction(trackingAction)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4Run* RunAction::GenerateRun() {
G4Run* RunAction::GenerateRun()
{
return new Run;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::BeginOfRunAction( const G4Run* aRun ) {
void RunAction::BeginOfRunAction(const G4Run* aRun)
{
G4cout << "### Run " << aRun->GetRunID() << " starts." << G4endl;
Run* run = const_cast< Run* >( static_cast< const Run* >( aRun ) );
if ( run == nullptr ) return;
if ( fSteppingAction != nullptr ) {
Run* run = const_cast<Run*>(static_cast<const Run*>(aRun));
if (run == nullptr) return;
if (fSteppingAction != nullptr) {
fSteppingAction->Initialize();
fSteppingAction->SetRunPointer( run );
fSteppingAction->SetRunPointer(run);
}
if ( fTrackingAction != nullptr ) {
if (fTrackingAction != nullptr) {
fTrackingAction->Initialize();
fTrackingAction->SetRunPointer( run );
fTrackingAction->SetRunPointer(run);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::EndOfRunAction( const G4Run* aRun ) {
const Run* run = static_cast< const Run* >( aRun );
if ( run == nullptr || run->GetNumberOfEvent() == 0 ) return;
if ( IsMaster() ) run->PrintInfo();
void RunAction::EndOfRunAction(const G4Run* aRun)
{
const Run* run = static_cast<const Run*>(aRun);
if (run == nullptr || run->GetNumberOfEvent() == 0) return;
if (IsMaster()) run->PrintInfo();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Layer/src/SteppingAction.cc
+114 -94
View File
@@ -32,44 +32,47 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "SteppingAction.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTypes.hh"
#include "G4IonTable.hh"
#include "G4StepPoint.hh"
#include "G4VPhysicalVolume.hh"
#include "G4VTouchable.hh"
#include "G4TouchableHistory.hh"
#include "G4VSolid.hh"
#include "G4LossTableManager.hh"
#include "G4SystemOfUnits.hh"
#include "Run.hh"
const std::array< G4String, SteppingAction::fkNumberScoringVolumes >
SteppingAction::fkArrayScoringVolumeNames = { "downstream", "side", "upstream" };
#include "G4IonTable.hh"
#include "G4LossTableManager.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTypes.hh"
#include "G4Step.hh"
#include "G4StepPoint.hh"
#include "G4SystemOfUnits.hh"
#include "G4TouchableHistory.hh"
#include "G4Track.hh"
#include "G4VPhysicalVolume.hh"
#include "G4VSolid.hh"
#include "G4VTouchable.hh"
const std::array< G4String, SteppingAction::fkNumberKinematicRegions >
SteppingAction::fkArrayKinematicRegionNames = { "", "below 20 MeV", "above 20 MeV" };
const std::array<G4String, SteppingAction::fkNumberScoringVolumes>
SteppingAction::fkArrayScoringVolumeNames = {"downstream", "side", "upstream"};
const std::array< G4String, SteppingAction::fkNumberParticleTypes >
SteppingAction::fkArrayParticleTypeNames = { "all", "electron", "gamma", "muon", "neutrino",
"pion", "neutron", "proton", "ion", "otherMeson",
"otherBaryon" };
const std::array<G4String, SteppingAction::fkNumberKinematicRegions>
SteppingAction::fkArrayKinematicRegionNames = {"", "below 20 MeV", "above 20 MeV"};
const std::array<G4String, SteppingAction::fkNumberParticleTypes>
SteppingAction::fkArrayParticleTypeNames = {"all", "electron", "gamma", "muon",
"neutrino", "pion", "neutron", "proton",
"ion", "otherMeson", "otherBaryon"};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4int SteppingAction::GetIndex( const G4int iScoringVolume, const G4int iKinematicRegion,
const G4int iParticleType ) {
G4int SteppingAction::GetIndex(const G4int iScoringVolume, const G4int iKinematicRegion,
const G4int iParticleType)
{
G4int index = -1;
if ( iScoringVolume >= 0 && iScoringVolume < fkNumberScoringVolumes &&
iKinematicRegion >= 0 && iKinematicRegion < fkNumberKinematicRegions &&
iParticleType >= 0 && iParticleType < fkNumberParticleTypes ) {
index = iScoringVolume * fkNumberKinematicRegions * fkNumberParticleTypes +
iKinematicRegion * fkNumberParticleTypes +
iParticleType;
if (iScoringVolume >= 0 && iScoringVolume < fkNumberScoringVolumes && iKinematicRegion >= 0
&& iKinematicRegion < fkNumberKinematicRegions && iParticleType >= 0
&& iParticleType < fkNumberParticleTypes)
{
index = iScoringVolume * fkNumberKinematicRegions * fkNumberParticleTypes
+ iKinematicRegion * fkNumberParticleTypes + iParticleType;
}
if ( index < 0 || index >= fkNumberCombinations ) {
if (index < 0 || index >= fkNumberCombinations) {
G4cerr << "SteppingAction::GetIndex : WRONG index=" << index << " set it to 0 !" << G4endl;
index = 0;
}
@@ -78,25 +81,27 @@ G4int SteppingAction::GetIndex( const G4int iScoringVolume, const G4int iKinemat
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
SteppingAction::SteppingAction() : G4UserSteppingAction() {
SteppingAction::SteppingAction() : G4UserSteppingAction()
{
Initialize();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void SteppingAction::Initialize() {
// Initialization needed at the beginning of each Run
void SteppingAction::Initialize()
{
// Initialization needed at the beginning of each Run
fPrimaryParticleId = 0;
fPrimaryParticleEnergy = 0.0;
fPrimaryParticleDirection = G4ThreeVector( 0.0, 0.0, 1.0 );
fPrimaryParticleDirection = G4ThreeVector(0.0, 0.0, 1.0);
fTargetMaterialName = "";
fIsFirstStepOfTheEvent = true;
fIsFirstStepInTarget = true;
fIsFirstStepInScoringUpDown = true;
fIsFirstStepInScoringSide = true;
fIsFirstStepInScoringUpDown = true;
fIsFirstStepInScoringSide = true;
fCubicVolumeScoringUpDown = 1.0;
fCubicVolumeScoringSide = 1.0;
for ( G4int i = 0; i < fkNumberCombinations; ++i ) {
for (G4int i = 0; i < fkNumberCombinations; ++i) {
fArraySumStepLengths[i] = 0.0;
}
/*
@@ -121,67 +126,72 @@ void SteppingAction::Initialize() {
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void SteppingAction::UserSteppingAction( const G4Step* theStep ) {
void SteppingAction::UserSteppingAction(const G4Step* theStep)
{
// Get information on the primary particle
if ( fIsFirstStepOfTheEvent ) {
if ( theStep->GetTrack()->GetParentID() == 0 ) {
if (fIsFirstStepOfTheEvent) {
if (theStep->GetTrack()->GetParentID() == 0) {
fPrimaryParticleId = theStep->GetTrack()->GetDefinition()->GetPDGEncoding();
fPrimaryParticleEnergy = theStep->GetPreStepPoint()->GetKineticEnergy();
fPrimaryParticleDirection = theStep->GetPreStepPoint()->GetMomentumDirection();
if ( fRunPtr ) {
fRunPtr->SetPrimaryParticleId( fPrimaryParticleId );
fRunPtr->SetPrimaryParticleEnergy( fPrimaryParticleEnergy );
fRunPtr->SetPrimaryParticleDirection( fPrimaryParticleDirection );
if (fRunPtr) {
fRunPtr->SetPrimaryParticleId(fPrimaryParticleId);
fRunPtr->SetPrimaryParticleEnergy(fPrimaryParticleEnergy);
fRunPtr->SetPrimaryParticleDirection(fPrimaryParticleDirection);
}
fIsFirstStepOfTheEvent = false;
}
}
// Get information on the target material
if ( fIsFirstStepInTarget &&
theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiLayer" ) {
if (fIsFirstStepInTarget
&& theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiLayer")
{
fTargetMaterialName = theStep->GetPreStepPoint()->GetMaterial()->GetName();
if ( fRunPtr ) fRunPtr->SetTargetMaterialName( fTargetMaterialName );
if (fRunPtr) fRunPtr->SetTargetMaterialName(fTargetMaterialName);
fIsFirstStepInTarget = false;
}
// Get information on step lengths in the scoring volumes
G4int iScoringVolume = -1;
if ( theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiScoringDownstream" ) {
if (theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiScoringDownstream") {
iScoringVolume = 0;
if ( fIsFirstStepInScoringUpDown ) {
if (fIsFirstStepInScoringUpDown) {
fCubicVolumeScoringUpDown =
theStep->GetTrack()->GetVolume()->GetLogicalVolume()->GetSolid()->GetCubicVolume();
if ( fRunPtr ) fRunPtr->SetCubicVolumeScoringUpDown( fCubicVolumeScoringUpDown );
fIsFirstStepInScoringUpDown = false;
}
} else if ( theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiScoringSide" ) {
iScoringVolume = 1;
if ( fIsFirstStepInScoringSide ) {
fCubicVolumeScoringSide =
theStep->GetTrack()->GetVolume()->GetLogicalVolume()->GetSolid()->GetCubicVolume();
if ( fRunPtr ) fRunPtr->SetCubicVolumeScoringSide( fCubicVolumeScoringSide );
fIsFirstStepInScoringSide = false;
}
} else if ( theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() ==
"physiScoringUpstream" ) {
iScoringVolume = 2;
if ( fIsFirstStepInScoringUpDown ) {
fCubicVolumeScoringUpDown =
theStep->GetTrack()->GetVolume()->GetLogicalVolume()->GetSolid()->GetCubicVolume();
if ( fRunPtr ) fRunPtr->SetCubicVolumeScoringUpDown( fCubicVolumeScoringUpDown );
if (fRunPtr) fRunPtr->SetCubicVolumeScoringUpDown(fCubicVolumeScoringUpDown);
fIsFirstStepInScoringUpDown = false;
}
}
if ( iScoringVolume >= 0 ) {
else if (theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiScoringSide") {
iScoringVolume = 1;
if (fIsFirstStepInScoringSide) {
fCubicVolumeScoringSide =
theStep->GetTrack()->GetVolume()->GetLogicalVolume()->GetSolid()->GetCubicVolume();
if (fRunPtr) fRunPtr->SetCubicVolumeScoringSide(fCubicVolumeScoringSide);
fIsFirstStepInScoringSide = false;
}
}
else if (theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiScoringUpstream") {
iScoringVolume = 2;
if (fIsFirstStepInScoringUpDown) {
fCubicVolumeScoringUpDown =
theStep->GetTrack()->GetVolume()->GetLogicalVolume()->GetSolid()->GetCubicVolume();
if (fRunPtr) fRunPtr->SetCubicVolumeScoringUpDown(fCubicVolumeScoringUpDown);
fIsFirstStepInScoringUpDown = false;
}
}
if (iScoringVolume >= 0) {
// In the case of the upstream scoring volume, consider only particles whose direction
// is opposite with respect to the primary particle (this is needed, in particular,
// for avoiding to account the incoming, primary beam particle in the "upstream" fluence).
if ( iScoringVolume == 2 && fPrimaryParticleDirection.dot(
theStep->GetPreStepPoint()->GetMomentumDirection() ) > 0.0 ) {
if (iScoringVolume == 2
&& fPrimaryParticleDirection.dot(theStep->GetPreStepPoint()->GetMomentumDirection()) > 0.0)
{
return;
}
G4double stepLength = theStep->GetTrack()->GetStepLength() * theStep->GetTrack()->GetWeight();
G4int absPdg = theStep->GetTrack()->GetDefinition() == nullptr ? 0 :
std::abs( theStep->GetTrack()->GetDefinition()->GetPDGEncoding() );
G4int absPdg = theStep->GetTrack()->GetDefinition() == nullptr
? 0
: std::abs(theStep->GetTrack()->GetDefinition()->GetPDGEncoding());
/*
G4cout << std::setprecision(6)
<< theStep->GetTrack()->GetDefinition()->GetParticleName() << " absPdg=" << absPdg
@@ -190,42 +200,52 @@ void SteppingAction::UserSteppingAction( const G4Step* theStep ) {
<< "," << theStep->GetTrack()->GetPosition().z() << ")"
<< " " << theStep->GetTrack()->GetVolume()->GetName()
<< " " << theStep->GetTrack()->GetMaterial()->GetName()
<< " L[mm]=" << stepLength << " "
<< ( fPrimaryParticleDirection.dot(
<< " L[mm]=" << stepLength << " "
<< ( fPrimaryParticleDirection.dot(
theStep->GetPreStepPoint()->GetMomentumDirection() ) > 0.0
? "forward" : "backward" )
? "forward" : "backward" )
<< G4endl;
*/
// Three kinematical regions: [0] : any value ; [1] : below 20 MeV ; [2] : above 20 MeV
G4int iKinematicRegion = theStep->GetPreStepPoint()->GetKineticEnergy() < 20.0 ? 1 : 2;
G4int iParticleType = -1;
if ( absPdg == 11 ) iParticleType = 1; // electron (and positron)
else if ( absPdg == 22 ) iParticleType = 2; // gamma
else if ( absPdg == 13 ) iParticleType = 3; // muons (mu- and mu+)
else if ( absPdg == 12 || absPdg == 14 || absPdg == 16 ) iParticleType = 4; // neutrinos
//(and anti-neutrinos), all flavors
else if ( absPdg == 111 || absPdg == 211 ) iParticleType = 5; // (charged) pions
else if ( absPdg == 2112 ) iParticleType = 6; // neutron (and anti-neutron)
else if ( absPdg == 2212 ) iParticleType = 7; // proton (and anti-proton)
else if ( G4IonTable::IsIon( theStep->GetTrack()->GetDefinition() ) || // ions (and anti-ions)
G4IonTable::IsAntiIon( theStep->GetTrack()->GetDefinition() ) ) iParticleType = 8;
else if ( absPdg < 1000 ) iParticleType = 9; // other mesons (e.g. kaons) (Note: this works
// in most cases, but not always!)
else if ( absPdg > 1000 ) iParticleType = 10; // other baryons (e.g. hyperons, anti-hyperons,
// etc.)
if (absPdg == 11)
iParticleType = 1; // electron (and positron)
else if (absPdg == 22)
iParticleType = 2; // gamma
else if (absPdg == 13)
iParticleType = 3; // muons (mu- and mu+)
else if (absPdg == 12 || absPdg == 14 || absPdg == 16)
iParticleType = 4; // neutrinos
//(and anti-neutrinos), all flavors
else if (absPdg == 111 || absPdg == 211)
iParticleType = 5; // (charged) pions
else if (absPdg == 2112)
iParticleType = 6; // neutron (and anti-neutron)
else if (absPdg == 2212)
iParticleType = 7; // proton (and anti-proton)
else if (G4IonTable::IsIon(theStep->GetTrack()->GetDefinition()) || // ions (and anti-ions)
G4IonTable::IsAntiIon(theStep->GetTrack()->GetDefinition()))
iParticleType = 8;
else if (absPdg < 1000)
iParticleType = 9; // other mesons (e.g. kaons) (Note: this works
// in most cases, but not always!)
else if (absPdg > 1000)
iParticleType = 10; // other baryons (e.g. hyperons, anti-hyperons,
// etc.)
// Consider the specific case : scoring volume, kinematic region and particle type
G4int index = GetIndex( iScoringVolume, iKinematicRegion, iParticleType );
G4int index = GetIndex(iScoringVolume, iKinematicRegion, iParticleType);
fArraySumStepLengths[index] += stepLength;
// Consider the "all" particle case, with the same scoring volume and kinematic region
index = GetIndex( iScoringVolume, iKinematicRegion, 0 );
index = GetIndex(iScoringVolume, iKinematicRegion, 0);
fArraySumStepLengths[index] += stepLength;
// Consider the "any" kinematic region case, with the same scoring volume and particle type
index = GetIndex( iScoringVolume, 0, iParticleType );
// Consider the "any" kinematic region case, with the same scoring volume and particle type
index = GetIndex(iScoringVolume, 0, iParticleType);
fArraySumStepLengths[index] += stepLength;
// Consider the "any" kinematic region and "all" particle, with the same scoring volume
index = GetIndex( iScoringVolume, 0, 0 );
index = GetIndex(iScoringVolume, 0, 0);
fArraySumStepLengths[index] += stepLength;
if ( fRunPtr ) fRunPtr->SetSteppingArray( fArraySumStepLengths );
if (fRunPtr) fRunPtr->SetSteppingArray(fArraySumStepLengths);
}
}
examples/extended/hadronic/ParticleFluence/Layer/src/TrackingAction.cc
+74 -59
View File
@@ -32,112 +32,127 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "TrackingAction.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTypes.hh"
#include "G4IonTable.hh"
#include "G4StepPoint.hh"
#include "G4SystemOfUnits.hh"
#include "Run.hh"
const std::array< G4String, TrackingAction::fkNumberScoringVolumes >
TrackingAction::fkArrayScoringVolumeNames = { "layer" };
#include "G4IonTable.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTypes.hh"
#include "G4Step.hh"
#include "G4StepPoint.hh"
#include "G4SystemOfUnits.hh"
#include "G4Track.hh"
const std::array< G4String, TrackingAction::fkNumberKinematicRegions >
TrackingAction::fkArrayKinematicRegionNames = { "", "below 20 MeV", "above 20 MeV" };
const std::array<G4String, TrackingAction::fkNumberScoringVolumes>
TrackingAction::fkArrayScoringVolumeNames = {"layer"};
const std::array< G4String, TrackingAction::fkNumberParticleTypes >
TrackingAction::fkArrayParticleTypeNames = { "all", "electron", "gamma", "muon", "neutrino",
"pion", "neutron", "proton", "ion", "otherMeson",
"otherBaryon" };
const std::array<G4String, TrackingAction::fkNumberKinematicRegions>
TrackingAction::fkArrayKinematicRegionNames = {"", "below 20 MeV", "above 20 MeV"};
const std::array<G4String, TrackingAction::fkNumberParticleTypes>
TrackingAction::fkArrayParticleTypeNames = {"all", "electron", "gamma", "muon",
"neutrino", "pion", "neutron", "proton",
"ion", "otherMeson", "otherBaryon"};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4int TrackingAction::GetIndex( const G4int iScoringVolume, const G4int iKinematicRegion,
const G4int iParticleType ) {
G4int TrackingAction::GetIndex(const G4int iScoringVolume, const G4int iKinematicRegion,
const G4int iParticleType)
{
G4int index = -1;
if ( iScoringVolume >= 0 && iScoringVolume < fkNumberScoringVolumes &&
iKinematicRegion >= 0 && iKinematicRegion < fkNumberKinematicRegions &&
iParticleType >= 0 && iParticleType < fkNumberParticleTypes ) {
index = iScoringVolume * fkNumberKinematicRegions * fkNumberParticleTypes +
iKinematicRegion * fkNumberParticleTypes +
iParticleType;
if (iScoringVolume >= 0 && iScoringVolume < fkNumberScoringVolumes && iKinematicRegion >= 0
&& iKinematicRegion < fkNumberKinematicRegions && iParticleType >= 0
&& iParticleType < fkNumberParticleTypes)
{
index = iScoringVolume * fkNumberKinematicRegions * fkNumberParticleTypes
+ iKinematicRegion * fkNumberParticleTypes + iParticleType;
}
return index;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
TrackingAction::TrackingAction() : G4UserTrackingAction() {
TrackingAction::TrackingAction() : G4UserTrackingAction()
{
Initialize();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void TrackingAction::Initialize() {
// Initialization needed at the beginning of each Run
fArrayMultiplicities.fill( 0 );
fArraySumKineticEnergies.fill( 0.0 );
void TrackingAction::Initialize()
{
// Initialization needed at the beginning of each Run
fArrayMultiplicities.fill(0);
fArraySumKineticEnergies.fill(0.0);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void TrackingAction::PreUserTrackingAction( const G4Track* aTrack ) {
// This method is called not only once when a particle is created,
void TrackingAction::PreUserTrackingAction(const G4Track* aTrack)
{
// This method is called not only once when a particle is created,
// but also each time it is resumed, in the case the track gets suspended,
// as it happens in the case of neutrons with _HP Physics Lists.
// To be sure that we collect information about a track one and only once,
// we require that the current step be the first one.
if ( aTrack == nullptr ||
aTrack->GetCurrentStepNumber() != 0 ||
aTrack->GetDefinition() == nullptr ||
aTrack->GetLogicalVolumeAtVertex() == nullptr ||
aTrack->GetLogicalVolumeAtVertex()->GetName() != "logicLayer" ) return;
if (aTrack == nullptr || aTrack->GetCurrentStepNumber() != 0 || aTrack->GetDefinition() == nullptr
|| aTrack->GetLogicalVolumeAtVertex() == nullptr
|| aTrack->GetLogicalVolumeAtVertex()->GetName() != "logicLayer")
return;
G4int iScoringVolume = 0;
// Three kinematical regions: [0] : any value ; [1] : below 20 MeV ; [2] : above 20 MeV
G4int iKinematicRegion = aTrack->GetKineticEnergy() < 20.0 ? 1 : 2;
G4int absPdg = std::abs( aTrack->GetDefinition()->GetPDGEncoding() );
G4int absPdg = std::abs(aTrack->GetDefinition()->GetPDGEncoding());
G4int iParticleType = -1;
if ( absPdg == 11 ) iParticleType = 1; // electron (and positron)
else if ( absPdg == 22 ) iParticleType = 2; // gamma
else if ( absPdg == 13 ) iParticleType = 3; // muons (mu- and mu+)
else if ( absPdg == 12 || absPdg == 14 || absPdg == 16 ) iParticleType = 4;
// neutrinos (and anti-neutrinos), all flavors
else if ( absPdg == 111 || absPdg == 211 ) iParticleType = 5; // (charged) pions
else if ( absPdg == 2112 ) iParticleType = 6; // neutron (and anti-neutron)
else if ( absPdg == 2212 ) iParticleType = 7; // proton (and anti-proton)
else if ( G4IonTable::IsIon( aTrack->GetDefinition() ) ||
G4IonTable::IsAntiIon( aTrack->GetDefinition() ) ) iParticleType = 8;
// ions (and anti-ions)
else if ( absPdg < 1000 ) iParticleType = 9; // other mesons (e.g. kaons)
// (Note: this works in most cases, but not always!)
else if ( absPdg > 1000 ) iParticleType = 10; // other baryons (e.g. hyperons,
// anti-hyperons, etc.)
if (absPdg == 11)
iParticleType = 1; // electron (and positron)
else if (absPdg == 22)
iParticleType = 2; // gamma
else if (absPdg == 13)
iParticleType = 3; // muons (mu- and mu+)
else if (absPdg == 12 || absPdg == 14 || absPdg == 16)
iParticleType = 4;
// neutrinos (and anti-neutrinos), all flavors
else if (absPdg == 111 || absPdg == 211)
iParticleType = 5; // (charged) pions
else if (absPdg == 2112)
iParticleType = 6; // neutron (and anti-neutron)
else if (absPdg == 2212)
iParticleType = 7; // proton (and anti-proton)
else if (G4IonTable::IsIon(aTrack->GetDefinition())
|| G4IonTable::IsAntiIon(aTrack->GetDefinition()))
iParticleType = 8;
// ions (and anti-ions)
else if (absPdg < 1000)
iParticleType = 9; // other mesons (e.g. kaons)
// (Note: this works in most cases, but not always!)
else if (absPdg > 1000)
iParticleType = 10; // other baryons (e.g. hyperons,
// anti-hyperons, etc.)
// Consider the specific case : scoring volume, kinematic region and particle type
G4int index = GetIndex( iScoringVolume, iKinematicRegion, iParticleType );
G4int index = GetIndex(iScoringVolume, iKinematicRegion, iParticleType);
++fArrayMultiplicities[index];
fArraySumKineticEnergies[index] += aTrack->GetKineticEnergy();
// Consider the "all" particle case, with the same scoring volume and kinematic region
index = GetIndex( iScoringVolume, iKinematicRegion, 0 );
index = GetIndex(iScoringVolume, iKinematicRegion, 0);
++fArrayMultiplicities[index];
fArraySumKineticEnergies[index] += aTrack->GetKineticEnergy();
// Consider the "any" kinematic region case, with the same scoring volume and particle type
index = GetIndex( iScoringVolume, 0, iParticleType );
index = GetIndex(iScoringVolume, 0, iParticleType);
++fArrayMultiplicities[index];
fArraySumKineticEnergies[index] += aTrack->GetKineticEnergy();
// Consider the "any" kinematic region and "all" particle, with the same scoring volume
index = GetIndex( iScoringVolume, 0, 0 );
index = GetIndex(iScoringVolume, 0, 0);
++fArrayMultiplicities[index];
fArraySumKineticEnergies[index] += aTrack->GetKineticEnergy();
if ( fRunPtr ) {
fRunPtr->SetTrackingArray1( fArrayMultiplicities );
fRunPtr->SetTrackingArray2( fArraySumKineticEnergies );
if (fRunPtr) {
fRunPtr->SetTrackingArray1(fArrayMultiplicities);
fRunPtr->SetTrackingArray2(fArraySumKineticEnergies);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void TrackingAction::PostUserTrackingAction( const G4Track* /* aTrack */ ) {}
void TrackingAction::PostUserTrackingAction(const G4Track* /* aTrack */) {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......