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

Import Geant4 11.1.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-07-01 10:44:02 +02:00
parent b3bf75a2a1
commit c07cea1fe0
2172 changed files with 183300 additions and 123938 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/extended/hadronic/ParticleFluence/Calo/.README.txt
+64
View File
@@ -0,0 +1,64 @@
///\file "hadronic/ParticleFluence/Calo/.README.txt"
///\brief Example ParticleFluence/Calo README page
/*! \page ExampeParticleFluenceCalo Example Calo
In this example, the particle fluence is evaluated for simplified,
cylindrical hadronic calorimeters with axis along the z-direction,
and a beam particle shot before the calorimeter along its axis.
The particle fluence is computed in three places: "upstream", "downstream"
and "side", defined as the positions immediately after, before and aside,
respectively, of the calorimeter with respect to the direction of the
primary particle.
The particle fluence is estimated by summing the track length in a
"scoring volume" - i.e. a thin cylinder (for "upstream" and "downstream"
cases) or a thin hemisphere shell (for the "side" case) filled up with
G4_Galactic (very low density gas) material, immediately outside the
calorimeter - and then dividing for the cubic volume of such scoring volume.
The particle fluence is evaluated for the following 11 particle types:
- all
- electron + positron
- gamma
- muon- + muon+
- neutrino (any flavour and including anti-neutrino)
- charged pions
- neutron + anti_neutron
- proton + anti_proton
- ion (and anti-ions)
- otherMeson (e.g. kaons, etc.)
- otherBaryon (e.g. hyperons, etc.)
The particle fluence is evaluated for the following 3 kinematical ranges:
- any kinetic energy
- kinetic energy < 20 MeV
- kinetic energy > 20 MeV
Look for the string "***LOOKHERE***" for those parameters/options that
are either hardwired in the code (i.e. not available via UI command),
or default values of UI commands.
This example uses the physics list factory, therefore you can specify
the reference physics list you want to use via the PHYSLIST
environmental variable (by default, if you don't set it, the FTFP_BERT
physics list is used).
To build this example:
mkdir Build; cd Build
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-DGeant4_DIR=/path-to-geant4-libraries ../.
make
To run it:
./Calo atlasHec.g4
which shoots 50 GeV pion- on a simplified ATLAS HEC hadronic calorimeter,
in one run of 100 events, and print out some information on the particle
fluence at the end of the run.
Other macros exist for other types of simplified hadronic calorimeters.
*/
examples/extended/hadronic/ParticleFluence/Calo/CMakeLists.txt
+61
View File
@@ -0,0 +1,61 @@
#----------------------------------------------------------------------------
# Setup the project
cmake_minimum_required(VERSION 3.16...3.21)
project(Calo)
#----------------------------------------------------------------------------
# Find Geant4 package, activating all available UI and Vis drivers by default
# You can set WITH_GEANT4_UIVIS to OFF via the command line or ccmake/cmake-gui
# to build a batch mode only executable
#
option(WITH_GEANT4_UIVIS "Build example with Geant4 UI and Vis drivers" ON)
if(WITH_GEANT4_UIVIS)
find_package(Geant4 REQUIRED ui_all vis_all)
else()
find_package(Geant4 REQUIRED)
endif()
#----------------------------------------------------------------------------
# Setup Geant4 include directories and compile definitions
#
include(${Geant4_USE_FILE})
#----------------------------------------------------------------------------
# Locate sources and headers for this project
#
include_directories(${PROJECT_SOURCE_DIR}/include
${Geant4_INCLUDE_DIR})
file(GLOB sources ${PROJECT_SOURCE_DIR}/src/*.cc)
file(GLOB headers ${PROJECT_SOURCE_DIR}/include/*.hh)
#----------------------------------------------------------------------------
# Add the executable, and link it to the Geant4 libraries
#
add_executable(Calo Calo.cc ${sources} ${headers})
target_link_libraries(Calo ${Geant4_LIBRARIES} )
#----------------------------------------------------------------------------
# Copy all scripts to the build directory, so that we can run the executable
# directly there.
#
set(SCRIPTS
atlasEcal.g4
atlasFcal.g4
atlasHec.g4
atlasTileCal.g4
cmsEcal.g4
lhcbEcal.g4
)
foreach(_script ${SCRIPTS})
configure_file(
${PROJECT_SOURCE_DIR}/${_script}
${PROJECT_BINARY_DIR}/${_script}
COPYONLY
)
endforeach()
#----------------------------------------------------------------------------
# Install the executable to 'bin' directory under CMAKE_INSTALL_PREFIX
#
install(TARGETS Calo DESTINATION bin)
examples/extended/hadronic/ParticleFluence/Calo/Calo.cc
Executable
+72
View File
@@ -0,0 +1,72 @@
//
// ********************************************************************
// * 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 Layer.cc
/// \brief Main program of the hadronic/ParticleFluence/Layer example
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4Threading.hh"
#include "G4RunManagerFactory.hh"
#include "G4UImanager.hh"
#include "G4PhysListFactory.hh"
#include "DetectorConstruction.hh"
#include "ActionInitialization.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
int main(int argc,char** argv) {
auto* runManager = G4RunManagerFactory::CreateRunManager();
DetectorConstruction* pDetectorInstance = new DetectorConstruction;
runManager->SetUserInitialization( pDetectorInstance );
// Physics list factory: use the PHYSLIST environmental variable.
G4PhysListFactory factory;
G4VModularPhysicsList* thePL = factory.ReferencePhysList();
runManager->SetUserInitialization( thePL );
runManager->SetUserInitialization( new ActionInitialization( pDetectorInstance ) );
runManager->Initialize();
G4UImanager* UI = G4UImanager::GetUIpointer();
if ( argc==1 ) { // Define UI session for interactive mode.
} else { // Batch mode
G4String command = "/control/execute ";
G4String fileName = argv[1];
UI->ApplyCommand(command+fileName);
}
// job termination
delete runManager;
return 0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Calo/GNUmakefile
Executable
+11
View File
@@ -0,0 +1,11 @@
name := Calo
G4TARGET := $(name)
G4EXLIB := true
include $(G4INSTALL)/config/architecture.gmk
.PHONY: all
all: lib bin
include $(G4INSTALL)/config/binmake.gmk
examples/extended/hadronic/ParticleFluence/Calo/History
+10
View File
@@ -0,0 +1,10 @@
# Example ParticleFluence History
See `CONTRIBUTING.rst` for details of **required** info/format for each entry,
which **must** added in reverse chronological order (newest at the top). It must **not**
be used as a substitute for writing good git commit messages!
## 2021-06-10 Alberto Ribon (exhadrParticleFluenceCalo-V11-00-00)
- Created the Calo variant of the ParticleFluence example.
examples/extended/hadronic/ParticleFluence/Calo/README
+57
View File
@@ -0,0 +1,57 @@
In this example, the particle fluence is evaluated for simplified,
cylindrical hadronic calorimeters with axis along the z-direction,
and a beam particle shot before the calorimeter along its axis.
The particle fluence is computed in three places: "upstream", "downstream"
and "side", defined as the positions immediately after, before and aside,
respectively, of the calorimeter with respect to the direction of the
primary particle.
The particle fluence is estimated by summing the track length in a
"scoring volume" - i.e. a thin cylinder (for "upstream" and "downstream"
cases) or a thin hemisphere shell (for the "side" case) filled up with
G4_Galactic (very low density gas) material, immediately outside the
calorimeter - and then dividing for the cubic volume of such scoring volume.
The particle fluence is evaluated for the following 11 particle types:
- all
- electron + positron
- gamma
- muon- + muon+
- neutrino (any flavour and including anti-neutrino)
- charged pions
- neutron + anti_neutron
- proton + anti_proton
- ion (and anti-ions)
- otherMeson (e.g. kaons, etc.)
- otherBaryon (e.g. hyperons, etc.)
The particle fluence is evaluated for the following 3 kinematical ranges:
- any kinetic energy
- kinetic energy < 20 MeV
- kinetic energy > 20 MeV
Look for the string "***LOOKHERE***" for those parameters/options that
are either hardwired in the code (i.e. not available via UI command),
or default values of UI commands.
This example uses the physics list factory, therefore you can specify
the reference physics list you want to use via the PHYSLIST
environmental variable (by default, if you don't set it, the FTFP_BERT
physics list is used).
To build this example:
mkdir Build; cd Build
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-DGeant4_DIR=/path-to-geant4-libraries ../.
make
To run it:
./Calo atlasHec.g4
which shoots 50 GeV pion- on a simplified ATLAS HEC hadronic calorimeter,
in one run of 100 events, and print out some information on the particle
fluence at the end of the run.
Other macros exist for other types of simplified hadronic calorimeters.
examples/extended/hadronic/ParticleFluence/Calo/atlasEcal.g4
+17
View File
@@ -0,0 +1,17 @@
/random/setSavingFlag 1
/run/verbose 1
/event/verbose 0
/tracking/verbose 0
/gun/particle pi-
/gun/energy 50 GeV
/mydet/absorberMaterial Lead
/mydet/activeMaterial LiquidArgon
/mydet/isCalHomogeneous 0
/mydet/isUnitInLambda 1
/mydet/absorberTotalLength 10
/mydet/calorimeterRadius 5
/mydet/activeLayerNumber 720
/mydet/activeLayerSize 4.2
/mydet/isRadiusUnitInLambda 1
/mydet/update
/run/beamOn 100
examples/extended/hadronic/ParticleFluence/Calo/atlasFcal.g4
+17
View File
@@ -0,0 +1,17 @@
/random/setSavingFlag 1
/run/verbose 1
/event/verbose 0
/tracking/verbose 0
/gun/particle pi-
/gun/energy 50 GeV
/mydet/absorberMaterial Tungsten
/mydet/activeMaterial LiquidArgon
/mydet/isCalHomogeneous 0
/mydet/isUnitInLambda 1
/mydet/absorberTotalLength 10
/mydet/calorimeterRadius 5
/mydet/activeLayerNumber 210
/mydet/activeLayerSize 0.5
/mydet/isRadiusUnitInLambda 1
/mydet/update
/run/beamOn 100
examples/extended/hadronic/ParticleFluence/Calo/atlasHec.g4
+17
View File
@@ -0,0 +1,17 @@
/random/setSavingFlag 1
/run/verbose 1
/event/verbose 0
/tracking/verbose 0
/gun/particle pi-
/gun/energy 50 GeV
/mydet/absorberMaterial Copper
/mydet/activeMaterial LiquidArgon
/mydet/isCalHomogeneous 0
/mydet/isUnitInLambda 1
/mydet/absorberTotalLength 10
/mydet/calorimeterRadius 5
/mydet/activeLayerNumber 60
/mydet/activeLayerSize 8.5
/mydet/isRadiusUnitInLambda 1
/mydet/update
/run/beamOn 100
examples/extended/hadronic/ParticleFluence/Calo/atlasTileCal.g4
+17
View File
@@ -0,0 +1,17 @@
/random/setSavingFlag 1
/run/verbose 1
/event/verbose 0
/tracking/verbose 0
/gun/particle pi-
/gun/energy 50 GeV
/mydet/absorberMaterial Iron
/mydet/activeMaterial Scintillator
/mydet/isCalHomogeneous 0
/mydet/isUnitInLambda 1
/mydet/absorberTotalLength 10.0
/mydet/calorimeterRadius 5.0
/mydet/activeLayerNumber 100
/mydet/activeLayerSize 4.0
/mydet/isRadiusUnitInLambda 1
/mydet/update
/run/beamOn 100
examples/extended/hadronic/ParticleFluence/Calo/cmsEcal.g4
+16
View File
@@ -0,0 +1,16 @@
/random/setSavingFlag 1
/run/verbose 1
/event/verbose 0
/tracking/verbose 0
/gun/particle pi-
/gun/energy 50 GeV
/mydet/absorberMaterial PbWO4
/mydet/isCalHomogeneous 1
/mydet/isUnitInLambda 1
/mydet/absorberTotalLength 10
/mydet/calorimeterRadius 5
/mydet/activeLayerNumber 1
/mydet/activeLayerSize 1e-06
/mydet/isRadiusUnitInLambda 1
/mydet/update
/run/beamOn 100
examples/extended/hadronic/ParticleFluence/Calo/include/ActionInitialization.hh
+55
View File
@@ -0,0 +1,55 @@
//
// ********************************************************************
// * 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 ActionInitialization.hh
/// \brief Definition of the ActionInitialization class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef ActionInitialization_h
#define ActionInitialization_h 1
#include "G4VUserActionInitialization.hh"
class DetectorConstruction;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class ActionInitialization : public G4VUserActionInitialization {
public:
ActionInitialization( const DetectorConstruction* inputDetectorConstruction = nullptr );
virtual ~ActionInitialization();
virtual void BuildForMaster() const override;
virtual void Build() const override;
private:
const DetectorConstruction* fPtrDetectorConstruction = nullptr;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
examples/extended/hadronic/ParticleFluence/Calo/include/DetectorConstruction.hh
Executable
+229
View File
@@ -0,0 +1,229 @@
//
// ********************************************************************
// * 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 DetectorConstruction.hh
/// \brief Definition of the DetectorConstruction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef DetectorConstruction_H
#define DetectorConstruction_H 1
#include "G4VUserDetectorConstruction.hh"
#include "globals.hh"
class G4LogicalVolume;
class G4VPhysicalVolume;
class G4FieldManager;
class G4UniformMagField;
class G4Material;
class DetectorMessenger;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class DetectorConstruction : public G4VUserDetectorConstruction {
public:
DetectorConstruction();
~DetectorConstruction();
G4VPhysicalVolume* Construct();
void ConstructSDandField();
void SetMagField( const G4double fieldValue );
void SetAbsorberMaterial( const G4String name );
void SetActiveMaterial( const G4String name );
// Use by the messenger.
inline G4Material* GetAbsorberMaterial() const;
inline G4Material* GetActiveMaterial() const;
inline void SetIsCalHomogeneous( const G4bool choice );
inline void SetIsUnitInLambda( const G4bool choice );
inline void SetAbsorberTotalLength( const G4double value );
inline void SetCalorimeterRadius( const G4double value );
inline void SetActiveLayerNumber( const G4int value );
inline void SetActiveLayerSize( const G4double value );
// To define the calorimeter geometry.
inline void SetIsRadiusUnitInLambda( const G4bool choice );
void UpdateGeometry();
inline G4double GetCaloLength() const;
private:
void DefineMaterials();
// Define all the materials.
G4VPhysicalVolume* ConstructCalorimeter();
// To be invoked each time the geometry needs to be updated.
G4bool areParametersOK();
// Return true if all the parameters are sensible, false otherwise.
void PrintParameters();
// Print the various parameters which define the calorimeter.
G4Material* fVacuum;
G4Material* fIron;
G4Material* fCopper;
G4Material* fTungsten;
G4Material* fLead;
G4Material* fUranium;
G4Material* fPbWO4;
G4Material* fPolystyrene;
G4Material* fLiquidArgon;
G4Material* fSilicon;
G4Material* fQuartz;
G4Material* fBrass;
G4Material* fAluminium;
G4Material* fGraphite;
G4Material* fAbsorberMaterial;
G4Material* fActiveMaterial;
G4LogicalVolume* fExperimentalHall_log;
G4VPhysicalVolume* fExperimentalHall_phys;
// World envelope.
G4LogicalVolume* fLogicCalo;
G4VPhysicalVolume* fPhysiCalo;
// "Calorimeter".
G4LogicalVolume* fLogicModule;
G4VPhysicalVolume* fPhysiModule;
// Module of the "calorimeter".
G4LogicalVolume* fLogicAbsorber;
G4VPhysicalVolume* fPhysiAbsorber;
// Absorber layer of the "calorimeter".
G4LogicalVolume* fLogicActive;
G4VPhysicalVolume* fPhysiActive;
// Active layer of the "calorimeter".
G4FieldManager* fFieldMgr;
// Pointer to the field manager.
G4UniformMagField* fUniformMagField;
// Pointer to the uniform magnetic field.
DetectorMessenger* fDetectorMessenger;
// Pointer to the Messenger.
G4bool fIsCalHomogeneous;
// If false then Sampling calorimeter;
// If true then Homogeneous calorimeter.
G4bool fIsUnitInLambda;
// If false then normal unit of length to express the absorber total length.
// If true then lambda (interaction length) to express the absorber total length.
G4double fAbsorberTotalLength;
// This is the total length of the absorber material, expressed
// in unit of length (e.g. m, cm, mm) if theIsUnitInLambda is false,
// otherwise in number of lambdas (interaction lengths).
// Notice that in the case of a sampling calorimeter (i.e.
// theIsCalHomogeneous is false), the active layers are not counted;
// in the case of an homogenous calorimeter, this length account
// for the overall dimension of the calorimeter.
G4double fCalorimeterRadius;
// This is the radius of the calorimeter which is a cylinder, expressed
// in unit of length (e.g. m, cm, mm) if theIsUnitInLambda is false,
// otherwise in number of lambdas (interaction lengths) of the absorber.
G4int fActiveLayerNumber;
G4double fActiveLayerSize;
// Number of active layers and length of each of them (in normal unit
// of length, e.g. mm): in the case of sampling calorimeter
// (i.e. theIsCalHomogeneous is false) the medium is theActiveMaterial;
// in the case of an homogeneous calorimeter, the "active layers" are
// only a fictitious way to sample the longitudinal energy deposits,
// but they are actually made of the same absorber material, and their
// thickness is taken into account in theAbsorberTotalLength.
G4bool fIsRadiusUnitInLambda;
// If false then normal unit of length to express the radius bin size.
// If true then lambda (interaction length of the absorber) to express
// the radius bin size.
G4double fCaloLength; // total length of the calorimeter along its (z) axis
// Scoring part
G4LogicalVolume* fLogicScoringUpDown;
G4VPhysicalVolume* fPhysiScoringUpstream;
G4VPhysicalVolume* fPhysiScoringDownstream;
G4LogicalVolume* fLogicScoringSide;
G4VPhysicalVolume* fPhysiScoringSide;
const G4double fScoringThickness = 10.0;
};
inline G4Material* DetectorConstruction::GetAbsorberMaterial() const {
return fAbsorberMaterial;
}
inline G4Material* DetectorConstruction::GetActiveMaterial() const {
return fActiveMaterial;
}
inline void DetectorConstruction::SetIsCalHomogeneous( const G4bool choice ) {
fIsCalHomogeneous = choice;
}
inline void DetectorConstruction::SetIsUnitInLambda( const G4bool choice ) {
fIsUnitInLambda = choice;
}
inline void DetectorConstruction::SetAbsorberTotalLength( const G4double value ) {
fAbsorberTotalLength = value;
}
inline void DetectorConstruction::SetCalorimeterRadius( const G4double value ) {
fCalorimeterRadius = value;
}
inline void DetectorConstruction::SetActiveLayerNumber( const G4int value ) {
fActiveLayerNumber = value;
}
inline void DetectorConstruction::SetActiveLayerSize( const G4double value ) {
fActiveLayerSize = value;
}
inline void DetectorConstruction::SetIsRadiusUnitInLambda( const G4bool choice ) {
fIsRadiusUnitInLambda = choice;
}
inline G4double DetectorConstruction::GetCaloLength() const {
return fCaloLength;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
examples/extended/hadronic/ParticleFluence/Calo/include/DetectorMessenger.hh
Executable
+76
View File
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * 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 DetectorMessenger.hh
/// \brief Definition of the DetectorMessenger class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef DetectorMessenger_h
#define DetectorMessenger_h 1
#include "globals.hh"
#include "G4UImessenger.hh"
class DetectorConstruction;
class G4UIdirectory;
class G4UIcmdWithADoubleAndUnit;
class G4UIcmdWithAString;
class G4UIcmdWithADouble;
class G4UIcmdWithABool;
class G4UIcmdWithAnInteger;
class G4UIcmdWithoutParameter;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class DetectorMessenger: public G4UImessenger {
public:
DetectorMessenger( DetectorConstruction* );
~DetectorMessenger();
void SetNewValue( G4UIcommand*, G4String ) override;
private:
DetectorConstruction* fDetector;
G4UIdirectory* fDetectorDir;
G4UIcmdWithADoubleAndUnit* fFieldCommand;
G4UIcmdWithAString* fAbsorberMaterial;
G4UIcmdWithAString* fActiveMaterial;
G4UIcmdWithABool* fIsCalHomogeneous;
G4UIcmdWithABool* fIsUnitInLambda;
G4UIcmdWithADouble* fAbsorberTotalLength;
G4UIcmdWithADouble* fCalorimeterRadius;
G4UIcmdWithAnInteger* fActiveLayerNumber;
G4UIcmdWithADouble* fActiveLayerSize;
G4UIcmdWithABool* fIsRadiusUnitInLambda;
G4UIcmdWithoutParameter* fUpdateCommand;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
examples/extended/hadronic/ParticleFluence/Calo/include/PrimaryGeneratorAction.hh
Executable
+58
View File
@@ -0,0 +1,58 @@
//
// ********************************************************************
// * 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 PrimaryGeneratorAction.hh
/// \brief Definition of the PrimaryGeneratorAction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef PrimaryGeneratorAction_h
#define PrimaryGeneratorAction_h 1
#include "G4VUserPrimaryGeneratorAction.hh"
class G4ParticleGun;
class G4Event;
class DetectorConstruction;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction {
public:
PrimaryGeneratorAction( const DetectorConstruction* );
~PrimaryGeneratorAction();
void GeneratePrimaries( G4Event* anEvent ) override;
void SetGunPosition() const;
private:
G4ParticleGun* fParticleGun;
const DetectorConstruction* fPointerDetectorConstruction = nullptr;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
examples/extended/hadronic/ParticleFluence/Calo/include/Run.hh
+112
View File
@@ -0,0 +1,112 @@
//
// ********************************************************************
// * 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 Run.hh
/// \brief Definition of the Run class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef Run_h
#define Run_h 1
#include "G4Run.hh"
#include "G4ThreeVector.hh"
#include "SteppingAction.hh"
#include <array>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class Run : public G4Run {
// This class accumulates relevant quantities related to particle fluence collected during
// the run.
// ( Note: these information are provided via calls of accessor methods of this Run class
// made by SteppingAction::UserSteppingAction. )
// At the end of a run, the printInfo method is called by the run-action to print out
// some summary information about these quantities.
// In multithreaded (MT) mode, an object of this class is filled up for each working thread,
// and then merged (automatically by the Geant4 kernel) into another object (of this class)
// owned by the master class; the printInfo method is then called only for the latter run
// object.
// Note that, for simplicity and brevity, we avoid histograms and print-out instead some
// statistics (compute by ourself) at the end of the run.
public:
Run();
~Run();
virtual void RecordEvent( const G4Event* anEvent ) override;
// This method is called automatically by the Geant4 kernel (not by the user!) at the end
// of each event. In the case of multithreaded mode, it is called only for the working thread
// that handled that event.
virtual void Merge( const G4Run* aRun ) override;
// 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.
void printInfo() const;
// This method is called by RunAction::EndOfRunAction : in the case of multithreaded mode,
// only the master thread calls it.
void setPrimaryParticleId( const G4int inputValue ) { fPrimaryParticleId = inputValue; }
void setPrimaryParticleEnergy( const G4double inputValue )
{ fPrimaryParticleEnergy = inputValue; }
void setPrimaryParticleDirection( const G4ThreeVector &inputValue )
{ fPrimaryParticleDirection = inputValue; }
void setAbsorberMaterialName( const G4String &inputValue )
{ fAbsorberMaterialName = inputValue; }
void setActiveMaterialName( const G4String &inputValue ) { fActiveMaterialName = inputValue; }
void setCubicVolumeScoringUpDown( const G4double inputValue )
{ fCubicVolumeScoringUpDown = inputValue; }
void setCubicVolumeScoringSide( const G4double inputValue )
{ fCubicVolumeScoringSide = inputValue; }
G4int getPrimaryParticleId() const { return fPrimaryParticleId; }
G4double getPrimaryParticleEnergy() const { return fPrimaryParticleEnergy; }
G4ThreeVector getPrimaryParticleDirection() const { return fPrimaryParticleDirection; }
G4String getAbsorberMaterialName() const { return fAbsorberMaterialName; }
G4String getActiveMaterialName() const { return fActiveMaterialName; }
G4double getCubicVolumeScoringUpDown() const { return fCubicVolumeScoringUpDown; }
G4double getCubicVolumeScoringSide() const { return fCubicVolumeScoringSide; }
void setArray( const std::array< G4double, SteppingAction::numberCombinations >& inputArray );
std::array< G4double, SteppingAction::numberCombinations > getArray() const { return fArray; }
// Accessor methods useful to transfer information collected by the stepping-action
// into this Run class
private:
G4int fNumEvents;
G4int fPrimaryParticleId;
G4double fPrimaryParticleEnergy;
G4ThreeVector fPrimaryParticleDirection;
G4String fAbsorberMaterialName;
G4String fActiveMaterialName;
G4double fCubicVolumeScoringUpDown;
G4double fCubicVolumeScoringSide;
std::array< G4double, SteppingAction::numberCombinations > fArray;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
examples/extended/hadronic/ParticleFluence/Calo/include/RunAction.hh
Executable
+57
View File
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * 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 RunAction.hh
/// \brief Definition of the RunAction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef RunAction_h
#define RunAction_h
#include "G4UserRunAction.hh"
class G4Run;
class SteppingAction;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class RunAction: public G4UserRunAction {
public:
RunAction( SteppingAction* steppingAction = nullptr );
virtual ~RunAction();
virtual void BeginOfRunAction( const G4Run* aRun ) override;
virtual void EndOfRunAction( const G4Run* aRun ) override;
virtual G4Run* GenerateRun() override;
private:
SteppingAction* fSteppingAction;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
examples/extended/hadronic/ParticleFluence/Calo/include/SteppingAction.hh
Executable
+114
View File
@@ -0,0 +1,114 @@
//
// ********************************************************************
// * 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 SteppingAction.hh
/// \brief Definition of the SteppingAction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef SteppingAction_H
#define SteppingAction_H 1
#include "globals.hh"
#include "G4UserSteppingAction.hh"
#include "G4ThreeVector.hh"
#include <array>
class Run;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class SteppingAction : public G4UserSteppingAction {
public:
SteppingAction();
virtual ~SteppingAction();
virtual void UserSteppingAction( const G4Step* ) override;
// This is the main method where the step lengths of particles inside
// the scoring volumes are collected, and then the corresponding fluences
// are filled up in the Run object where they are stored (and then
// printed out at the end of the Run).
// (For simplicity and brevity, we avoid histograms and compute instead
// some statistics ourself, which will be print-out at the end of the run.)
void initialize();
// This method is called by RunAction::BeginOfRunAction for the
// initialization of the stepping-action at the beginning of each Run.
// This is necessary because different runs can have different primary particle
// types, kinetic energies, and detector configurations.
void setRunPointer( Run* inputValue = nullptr ) { fRunPtr = inputValue; }
// This method is called by RunAction::BeginOfRunAction for providing to the
// stepping-action the pointer to the run object at the beginning of each Run.
// This pointer is then used to pass the information collected by the stepping-action
// to the run object.
G4double getCubicVolumeScoringUpDown() const { return fCubicVolumeScoringUpDown; }
G4double getCubicVolumeScoringSide() const { return fCubicVolumeScoringSide; }
// The cubic-volumes of the scoring volumes are needed to get the fluence from
// the sum of step lengths in those scoring volumes.
// Notice that two of the three scoring volumes - upstream and downstream -
// have the same cubic-volume, that we call "fCubicVolumeScoringUpDown".
static const G4int numberScoringVolumes = 3; // downstream, side, upstream
static const G4int numberKinematicRegions = 3; // all, below 20 MeV, above 20 MeV
static const G4int numberParticleTypes = 11; // all, e, gamma, mu, nu, pi, n, p, ions,
// other-mesons, other-baryons
static const G4int numberCombinations =
numberScoringVolumes*numberKinematicRegions*numberParticleTypes;
static const std::array< G4String, numberScoringVolumes > arrayScoringVolumeNames;
static const std::array< G4String, numberKinematicRegions > arrayKinematicRegionNames;
static const std::array< G4String, numberParticleTypes > arrayParticleTypeNames;
static G4int getIndex( const G4int iScoringVolume, const G4int iKinematicRegion,
const G4int iParticleType );
private:
Run* fRunPtr; // Pointer to the Run object
G4int fPrimaryParticleId;
G4double fPrimaryParticleEnergy;
G4ThreeVector fPrimaryParticleDirection;
G4String fAbsorberMaterialName;
G4String fActiveMaterialName;
G4bool fIsFirstStepOfTheEvent;
G4bool fIsFirstStepInAbsorberLayer;
G4bool fIsFirstStepInActiveLayer;
G4bool fIsFirstStepInScoringUpDown;
G4bool fIsFirstStepInScoringSide;
G4double fCubicVolumeScoringUpDown;
G4double fCubicVolumeScoringSide;
std::array< G4double, numberCombinations > fArraySumStepLengths;
// Array to collect the sum of step lengths in the scoring volumes for the whole run,
// according to the various cases (kinematical region and particle type).
// Note that the fluence in a scoring volume is defined as sum of step lengths
// in that scoring volume divided by the cubic-volume of that scoring volume.
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
examples/extended/hadronic/ParticleFluence/Calo/lhcbEcal.g4
+17
View File
@@ -0,0 +1,17 @@
/random/setSavingFlag 1
/run/verbose 1
/event/verbose 0
/tracking/verbose 0
/gun/particle pi-
/gun/energy 50 GeV
/mydet/absorberMaterial Lead
/mydet/activeMaterial Scintillator
/mydet/isCalHomogeneous 0
/mydet/isUnitInLambda 1
/mydet/absorberTotalLength 10.0
/mydet/calorimeterRadius 5.0
/mydet/activeLayerNumber 854
/mydet/activeLayerSize 4.0
/mydet/isRadiusUnitInLambda 1
/mydet/update
/run/beamOn 100
examples/extended/hadronic/ParticleFluence/Calo/src/ActionInitialization.cc
+67
View File
@@ -0,0 +1,67 @@
//
// ********************************************************************
// * 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 ActionInitialization.cc
/// \brief Implementation of the ActionInitialization class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "ActionInitialization.hh"
#include "PrimaryGeneratorAction.hh"
#include "RunAction.hh"
#include "SteppingAction.hh"
#include "Run.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
ActionInitialization::
ActionInitialization( const DetectorConstruction* inputDetectorConstruction ) :
G4VUserActionInitialization(), fPtrDetectorConstruction( inputDetectorConstruction ) {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
ActionInitialization::~ActionInitialization() {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void ActionInitialization::Build() const {
// This is called in the SEQ-mode and in the MT-mode only for Worker threads.
SetUserAction( new PrimaryGeneratorAction( fPtrDetectorConstruction ) );
SteppingAction* steppingAction = new SteppingAction;
SetUserAction( steppingAction );
SetUserAction( new RunAction( steppingAction ) );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Calo/src/DetectorConstruction.cc
Executable
+680
View File
@@ -0,0 +1,680 @@
//
// ********************************************************************
// * 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 DetectorConstruction.hh
/// \brief Definition of the DetectorConstruction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "DetectorConstruction.hh"
#include "G4Material.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4Cons.hh"
#include "G4LogicalVolume.hh"
#include "G4ThreeVector.hh"
#include "G4PVPlacement.hh"
#include "globals.hh"
#include "G4RotationMatrix.hh"
#include "G4PVReplica.hh"
#include "G4UniformMagField.hh"
#include "G4FieldManager.hh"
#include "G4TransportationManager.hh"
#include "DetectorMessenger.hh"
#include "G4SDManager.hh"
#include "G4GeometryManager.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4SolidStore.hh"
#include "G4RunManager.hh"
#include "G4SystemOfUnits.hh"
#include "G4PhysicalConstants.hh"
#include "PrimaryGeneratorAction.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorConstruction::DetectorConstruction() :
fVacuum( nullptr ), fIron( nullptr ), fCopper( nullptr ), fTungsten( nullptr ),
fLead( nullptr ), fUranium( nullptr ), fPbWO4( nullptr ), fPolystyrene( nullptr ),
fLiquidArgon( nullptr ), fSilicon( nullptr ), fQuartz( nullptr ), fBrass( nullptr ),
fAluminium( nullptr ), fGraphite( nullptr ),
fAbsorberMaterial( nullptr ), fActiveMaterial( nullptr ),
fExperimentalHall_log( nullptr ), fExperimentalHall_phys( nullptr ),
fLogicCalo( nullptr ), fPhysiCalo( nullptr ),
fLogicModule( nullptr ), fPhysiModule( nullptr ),
fLogicAbsorber( nullptr ), fPhysiAbsorber( nullptr ),
fLogicActive( nullptr ), fPhysiActive( nullptr ),
fFieldMgr( nullptr ), fUniformMagField( nullptr ),
fDetectorMessenger( nullptr ),
// Default values. ***LOOKHERE***
fIsCalHomogeneous( false ), // Sampling calorimeter.
fIsUnitInLambda( false ), // Unit of length for the absorber total length.
fAbsorberTotalLength( 2.0*CLHEP::m ),
fCalorimeterRadius( 1.0*CLHEP::m ),
fActiveLayerNumber( 50 ),
fActiveLayerSize( 4.0*CLHEP::mm ),
fIsRadiusUnitInLambda( false ), // Unit of length for the radius bin size.
// Extra
fCaloLength( 2.0*CLHEP::m ),
// Scoring part
fLogicScoringUpDown( nullptr ),
fPhysiScoringUpstream( nullptr ),
fPhysiScoringDownstream( nullptr ),
fLogicScoringSide( nullptr ),
fPhysiScoringSide( nullptr )
{
fFieldMgr = G4TransportationManager::GetTransportationManager()->GetFieldManager();
DefineMaterials();
fAbsorberMaterial = fIron;
fActiveMaterial = fPolystyrene;
fDetectorMessenger = new DetectorMessenger( this );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorConstruction::~DetectorConstruction() {
delete fDetectorMessenger;
delete fUniformMagField;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4VPhysicalVolume* DetectorConstruction::Construct() {
return ConstructCalorimeter();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::ConstructSDandField() {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::DefineMaterials() {
G4double a; // atomic mass
G4double z; // atomic number
G4double density, pressure, temperature, fractionmass;
G4String name, symbol;
G4int nel, natoms;
//--- elements
a = 1.01*g/mole;
G4Element* elH = new G4Element( name="Hydrogen", symbol="H2", z=1., a );
a = 2.01*g/mole;
//G4Element* elD = new G4Element( name="Deuterium", symbol="D", z=1., a );
a = 4.*g/mole;
//G4Element* elHe = new G4Element( name="Helium", symbol="He", z=2., a );
a = 6.94*g/mole;
//G4Element* elLi = new G4Element( name="Lithium", symbol="Li", z=3., a );
a = 9.01*g/mole;
//G4Element* elBe = new G4Element( name="Berillium", symbol="Be", z=4., a );
a = 12.01*g/mole;
G4Element* elC = new G4Element( name="Carbon", symbol="C", z=6., a );
a = 14.01*g/mole;
G4Element* elN = new G4Element( name="Nitrogen", symbol="N2", z=7., a );
a = 16.*g/mole;
G4Element* elO = new G4Element( name="Oxygen", symbol="O2", z=8., a );
a = 20.18*g/mole;
//G4Element* elNe = new G4Element( name="Neon", symbol="Ne", z=10., a );
a = 22.99*g/mole;
//G4Element* elNa = new G4Element( name="Sodium", symbol="Na", z=11., a );
a = 26.98*g/mole;
//G4Element* elAl = new G4Element( name="Aluminium", symbol="Al", z=13., a );
a = 28.085*g/mole;
G4Element* elSi = new G4Element( name="Silicon", symbol="Si", z=14., a );
a = 40.08*g/mole;
//G4Element* elCa = new G4Element( name="Calcium", symbol="Ca", z=20., a );
a = 55.850*g/mole;
//G4Element* elFe = new G4Element( name="Iron", symbol="Fe", z=26., a );
a = 63.54*g/mole;
G4Element* elCu = new G4Element( name="Copper", symbol="Cu", z=29., a );
a = 65.41*g/mole;
G4Element* elZn = new G4Element( name="Zinc", symbol="Zn", z=30., a );
a = 183.85*g/mole;
G4Element* elW = new G4Element( name="Tungstenm", symbol="W", z=74., a );
a = 207.19*g/mole;
G4Element* elPb = new G4Element( name="Lead", symbol="Pb", z=82., a );
a = 238.03*g/mole;
//G4Element* elU = new G4Element(name="Uranium", symbol="U", z=92., a);
//--- simple materials
// Iron has a X0 = 1.7585 cm and lambda_I = 16.760 cm.
density = 7.87*g/cm3;
a = 55.85*g/mole;
fIron = new G4Material( name="Iron", z=26., a, density );
// Copper has a X0 = 1.4353 cm and lambda_I = 15.056 cm.
density = 8.96*g/cm3;
a = 63.54*g/mole;
fCopper = new G4Material( name="Copper", z=29., a, density );
// Tungsten has a X0 = 0.35 cm and lambda_I = 9.5855 cm.
density = 19.3*g/cm3;
a = 183.85*g/mole;
fTungsten = new G4Material( name="Tungsten", z=74., a, density );
// Lead has a X0 = 0.56120 cm and lambda_I = 17.092 cm.
density = 11.35*g/cm3;
a = 207.19*g/mole;
fLead = new G4Material( name="Lead", z=82., a, density );
// Uranium has a X0 = 0.31662 cm and lambda_I = 10.501 cm.
density = 18.95*g/cm3;
a = 238.03*g/mole;
fUranium = new G4Material( name="Uranium", z=92., a, density );
// Liquid Argon has a X0 = 10.971 cm and lambda_I = 65.769 cm.
density = 1.4*g/cm3;
a = 39.95*g/mole;
fLiquidArgon = new G4Material( name="LiquidArgon", z=18., a, density );
density = 0.002*g/cm3;
a = 39.95*g/mole;
//G4Material* ArgonGas = new G4Material( name="ArgonGas", z=18., a, density );
// Silicon has a X0 = 9.3688 cm and lambda_I = 46.5436 cm
density = 2.33*g/cm3;
a = 28.085*g/mole;
fSilicon = new G4Material( name="Silicon", z=14., a, density );
// Aluminium has a X0 = 8.8959 cm and lambda_I = 39.7184 cm
density = 2.7*g/cm3;
a = 26.98*g/mole;
fAluminium = new G4Material( name="Aluminium", z=13., a, density );
// Graphite has a X0 = 19.3213 cm and lambda_I = 38.8235 cm
density = 2.210*g/cm3;
a = 12.0107*g/mole;
fGraphite = new G4Material( name="Graphite", z=6., a, density );
density = 8.96*g/cm3;
a = 58.69*g/mole;
//G4Material* Nickel = new G4Material( name="Nickel", z=28., a, density );
//--- mixtures
density = 1.290*mg/cm3;
G4Material* Air = new G4Material( name="Air", density, nel=2 );
Air->AddElement(elN, 0.7);
Air->AddElement(elO, 0.3);
density = 1.e-5*g/cm3;
pressure = 2.e-2*bar;
temperature = STP_Temperature; // From PhysicalConstants.h .
fVacuum = new G4Material( name="Vacuum", density, nel=1,
kStateGas, temperature, pressure );
fVacuum->AddMaterial( Air, fractionmass=1. );
// Plastic scintillator tiles (used both in CMS hadron calorimeter
// and ATLAS hadron barrel calorimeter):
// X0 = 42.4 cm and lambda_I = 79.360 cm.
density = 1.032*g/cm3;
fPolystyrene = new G4Material( name="Polystyrene", density, nel=2 );
fPolystyrene->AddElement( elC, natoms=19 );
fPolystyrene->AddElement( elH, natoms=21 );
// PbWO4 CMS crystals. It has a X0 = 0.89 cm and lambda_I = 22.4 cm.
density = 8.28*g/cm3;
fPbWO4 = new G4Material( name="PbWO4", density, nel=3 );
fPbWO4->AddElement( elPb, natoms=1 );
fPbWO4->AddElement( elW, natoms=1 );
fPbWO4->AddElement( elO, natoms=4 );
fQuartz = new G4Material( name="Quartz", density=2.200*g/cm3, nel=2 );
fQuartz->AddElement( elSi, 1 );
fQuartz->AddElement( elO , 2 );
fBrass = new G4Material( name="Brass", density=8.6*g/cm3, nel=2 );
fBrass->AddElement( elCu, 0.7 );
fBrass->AddElement( elZn, 0.3 );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4VPhysicalVolume* DetectorConstruction::ConstructCalorimeter() {
if ( ! areParametersOK() ) {
G4cout << " DetectorConstruction::ConstructCalorimeter() : ***ERROR*** "
<< G4endl << "\t PARAMETERS NOT WELL-DEFINED! GEOMETRY UNCHANGED."
<< G4endl;
return fExperimentalHall_phys;
}
// Clean old geometry, if any.
G4GeometryManager::GetInstance()->OpenGeometry();
G4PhysicalVolumeStore::GetInstance()->Clean();
G4LogicalVolumeStore::GetInstance()->Clean();
G4SolidStore::GetInstance()->Clean();
G4double lambda = 0.0; // G4double X0 = 0.0;
if ( fIsUnitInLambda ) {
if ( fAbsorberMaterial == fIron ) {
lambda = 16.760*cm; // X0 = 1.7585*cm;
} else if ( fAbsorberMaterial == fCopper ) {
lambda = 15.056*cm; // X0 = 1.4353*cm;
} else if ( fAbsorberMaterial == fBrass ) {
lambda = 15.056*cm; // Lack of PDG data: I am assuming the same as Copper. // X0=1.4353*cm
} else if ( fAbsorberMaterial == fTungsten ) {
lambda = 9.5855*cm; // X0 = 0.35*cm;
} else if ( fAbsorberMaterial == fLead ) {
lambda = 17.092*cm; // X0 = 0.56120*cm;
} else if ( fAbsorberMaterial == fPbWO4 ) {
lambda = 22.4*cm; // X0 = 0.89*cm;
} else if ( fAbsorberMaterial == fUranium ) {
lambda = 10.501*cm; // X0 = 0.31662*cm;
} else if ( fAbsorberMaterial == fGraphite ) {
lambda = 38.82*cm; // X0 = 19.32*cm;
} else {
std::cout << "ERROR: absorber material not recognized" << std::endl;
}
}
//------------------- volumes --------------------------
G4double absorberTotalLength = fAbsorberTotalLength;
G4double calorimeterRadius = fCalorimeterRadius;
if ( fIsUnitInLambda ) {
absorberTotalLength *= lambda;
calorimeterRadius *= lambda;
}
// --- experimental hall (world volume) ***LOOKHERE***
// beam line along the Z-axis
G4double expHall_x = 10.0*m; // half dimension along x
G4double expHall_y = 10.0*m; // half dimension along y
G4double expHall_z = 10.0*m; // half dimension along z
G4Box* experimentalHall_box = new G4Box( "expHall_box", expHall_x, expHall_y, expHall_z );
fExperimentalHall_log = new G4LogicalVolume( experimentalHall_box, // solid
fVacuum, // 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
// --- Detector
// The idea is to use Replica placement.
// To do that, we have to define two extra volumes: the "calorimeter" volume
// and the "module". The former, which has the world as its mother volume,
// is the mother of the module volume. The calorimeter volume is completely
// filled by a number (theActiveLayerNumber) of replicas of the module volume.
// A module volume, in its turn, is the mother volume of the absorber layer +
// active layer.
// --- absorber layer : logical
G4double zAbsorber = absorberTotalLength / static_cast< double >( fActiveLayerNumber );
// In the case of homogenous calorimeter the "active" part must be
// subtracted because it is made of the same material
// (the material of the "active" part is set to be the same as
// the aborber).
if ( fIsCalHomogeneous ) {
fActiveMaterial = fAbsorberMaterial;
zAbsorber -= fActiveLayerSize;
}
zAbsorber /= 2.0; // half dimension along z
G4Tubs* solidAbsorber = new G4Tubs( "solidAbsorber", // name
0.0, // inner radius
calorimeterRadius, // outer radius
zAbsorber, // half cylinder length in z
0.0, // starting phi angle in rad
2.0*pi ); // final phi angle in rad
fLogicAbsorber = new G4LogicalVolume( solidAbsorber, // solid
fAbsorberMaterial, // material
"logicAbsorber", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
// --- active layer : logical
G4double zActive = fActiveLayerSize / 2.0; // half dimension along z
G4Tubs* solidActive = new G4Tubs( "solidActive", // name
0.0, // inner radius
calorimeterRadius, // outer radius
zActive, // half cylinder length in z
0.0, // starting phi angle in rad
2.0*pi ); // final phi angle in rad
fLogicActive = new G4LogicalVolume( solidActive, // solid
fActiveMaterial, // material
"logicActive", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
// --- module : logical
G4double zModule = zAbsorber + zActive; // half dimension along z
G4Tubs* solidModule = new G4Tubs( "solidModule", // name
0.0, // inner radius
calorimeterRadius, // outer radius
zModule, // half cylinder length in z
0.0, // starting phi angle in rad
2.0*pi ); // final phi angle in rad
fLogicModule = new G4LogicalVolume( solidModule, // solid
fLead, // material, it does NOT matter
"logicModule", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
// --- calorimeter : logical
G4int numberOfModules = fActiveLayerNumber;
G4double zCalo = numberOfModules*zModule; // half dimension along z
fCaloLength = 2.0*zCalo;
G4Tubs* solidCalo = new G4Tubs( "solidCalo", // name
0.0, // inner radius
calorimeterRadius, // outer radius
zCalo, // half cylinder length in z
0.0, // starting phi angle in rad
2.0*pi ); // final phi angle in rad
fLogicCalo = new G4LogicalVolume( solidCalo, // solid
fLead, // material, it does NOT matter
"logicCalo", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
// --- absorber layer : physical
G4double zpos = - zActive;
fPhysiAbsorber = new G4PVPlacement( 0, // rotation
G4ThreeVector(0,0,zpos), // translation
fLogicAbsorber, // logical volume
"physiAbsorber", // name
fLogicModule, // mother logical volume
false, // boolean operation
1000 ); // copy number
// --- active layer : physical
zpos += zAbsorber + zActive;
fPhysiActive = new G4PVPlacement( 0, // rotation
G4ThreeVector(0,0,zpos), // translation
fLogicActive, // logical volume
"physiActive", // name
fLogicModule, // mother logical volume
false, // boolean operation
2000 ); // copy number
// --- module : physical (using replica)
fPhysiModule = new G4PVReplica( "Calo", // name
fLogicModule, // logical volume
fLogicCalo, // mother logical volume
kZAxis, // axis of replication
numberOfModules, // number of replica
2*(zAbsorber+zActive) ); // (full) width of replica
// --- calorimeter : physical
fPhysiCalo = new G4PVPlacement( 0, // rotation
G4ThreeVector(), // translation
"physiCalo", // its name
fLogicCalo, // logical volume
fExperimentalHall_phys, // mother physical volume
false, // boolean operation
100 ); // copy number
// Three scoring volumes: one thin layer downstream of the calorimeter ("down")
// one thin layer surrounding (lateral) of the calorimeter ("side")
// one thin layer upstream of the calorimeter ("up")
G4Tubs* solidScoringUpDown = new G4Tubs( "solidScoringUpDown", // name
0.0, // inner radius
calorimeterRadius, // 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
fVacuum, // material
"logicScoringUpDown", // name
0, // field manager
0, // sensitive detector
0 ); // user limits
G4double zScoringUpDown = 0.5*(fCaloLength + 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
calorimeterRadius, // inner radius
calorimeterRadius + fScoringThickness, // outer radius
0.5*fCaloLength, // 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
fVacuum, // 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
return fExperimentalHall_phys;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4bool DetectorConstruction::areParametersOK() {
bool isOk = true;
if ( ! fAbsorberMaterial ) {
isOk = false;
G4cout << " DetectorConstruction::areParametersOK() : UNDEFINED absorber material" << G4endl;
}
if ( ! fActiveMaterial ) {
isOk = false;
G4cout << " DetectorConstruction::areParametersOK() : UNDEFINED active material" << G4endl;
}
if ( fAbsorberTotalLength <= 0.0 ) {
isOk = false;
G4cout << " DetectorConstruction::areParametersOK() : fAbsorberTotalLength = "
<< fAbsorberTotalLength << G4endl;
}
if ( fCalorimeterRadius <= 0.0 ) {
isOk = false;
G4cout << " DetectorConstruction::areParametersOK() : fCalorimeterRadius = "
<< fCalorimeterRadius << G4endl;
}
if ( fActiveLayerNumber <= 0 ) {
isOk = false;
G4cout << " DetectorConstruction::areParametersOK() : fActiveLayerNumber = "
<< fActiveLayerNumber << G4endl;
}
if ( fActiveLayerSize <= 0.0 ) {
isOk = false;
G4cout << " DetectorConstruction::areParametersOK() : fActiveLayerSize = "
<< fActiveLayerSize << G4endl;
}
return isOk;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::SetMagField( const G4double fieldValue ) {
if ( fUniformMagField ) {
delete fUniformMagField;
}
if ( std::abs( fieldValue ) > 0.0 ) {
// Apply a global uniform magnetic field along the Y axis.
// Notice that only if the magnetic field is not zero, the Geant4
// transportion in field gets activated.
fUniformMagField = new G4UniformMagField( G4ThreeVector( 0.0, fieldValue, 0.0 ) );
fFieldMgr->SetDetectorField( fUniformMagField );
fFieldMgr->CreateChordFinder( fUniformMagField );
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::SetAbsorberMaterial( const G4String name ) {
if ( name == "Fe" || name == "Iron" || name == "iron" ) {
fAbsorberMaterial = fIron;
} else if ( name == "Cu" || name == "Copper" || name == "copper" ) {
fAbsorberMaterial = fCopper;
} else if ( name == "Brass" || name == "brass" ) {
fAbsorberMaterial = fBrass;
} else if ( name == "Pb" || name == "Lead" || name == "lead" ) {
fAbsorberMaterial = fLead;
} else if ( name == "PbWO4" ) {
fAbsorberMaterial = fPbWO4;
} else if ( name == "W" || name == "Tungsten" || name == "tungsten" ) {
fAbsorberMaterial = fTungsten;
} else if ( name == "U" || name == "Uranium" || name == "uranium" ) {
fAbsorberMaterial = fUranium;
} else if ( name == "C" || name == "Graphite" || name == "graphite" ) {
fAbsorberMaterial = fGraphite;
} else {
G4cout << G4endl << G4endl
<< "WARNING: the name of the material has not been recognized!" << G4endl
<< " ===> the default * Iron * will be used." << G4endl << G4endl;
fAbsorberMaterial = fIron;
}
fLogicAbsorber->SetMaterial( fAbsorberMaterial );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::SetActiveMaterial( const G4String name ) {
if ( name == "Scintillator" || name == "scintillator" ) {
fActiveMaterial = fPolystyrene;
} else if ( name == "LAr" || name == "LiquidArgon" || name == "liquidArgon" ) {
fActiveMaterial = fLiquidArgon;
} else if ( name == "PbWO4" ) {
fActiveMaterial = fPbWO4;
} else if ( name == "Si" || name == "Silicon" || name == "silicon" ) {
fActiveMaterial = fSilicon;
} else if ( name == "Quartz" || name == "quartz" ) {
fActiveMaterial = fQuartz;
} else if ( name == "C" || name == "Graphite" || name == "graphite" ) {
fActiveMaterial = fGraphite;
} else {
G4cout << G4endl << G4endl
<< "WARNING: the name of the material has not been recognized!" << G4endl
<< " ===> the default * Scintillator * will be used." << G4endl << G4endl;
fActiveMaterial = fPolystyrene;
}
fLogicActive->SetMaterial( fActiveMaterial );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::UpdateGeometry() {
//G4RunManager::GetRunManager()->DefineWorldVolume( ConstructCalorimeter() );
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();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorConstruction::PrintParameters() {
G4cout << G4endl << G4endl << " ------ DetectorConstruction::PrintParameters() ------ "
<< G4endl
<< " Absorber Material = ";
if ( fAbsorberMaterial ) {
G4cout << fAbsorberMaterial->GetName();
} else {
G4cout << " UNDEFINED ";
}
G4cout << G4endl << " Active Material = ";
if ( fActiveMaterial ) {
G4cout << fActiveMaterial->GetName();
} else {
G4cout << " UNDEFINED ";
}
G4cout << G4endl << " Is the Calorimeter Homogeneous ? " << fIsCalHomogeneous;
G4cout << G4endl << " Is the Unit in Lambda ? " << fIsUnitInLambda;
G4cout << G4endl << " Absorber Total Length = ";
if ( fIsUnitInLambda ) {
G4cout << fAbsorberTotalLength << " lambdas";
} else {
G4cout << fAbsorberTotalLength / m << " m";
}
G4cout << G4endl << " Calorimeter Radius = ";
if ( fIsUnitInLambda ) {
G4cout << fCalorimeterRadius << " lambdas";
} else {
G4cout << fCalorimeterRadius / m << " m";
}
G4cout << G4endl << " Active Layer Number = " << fActiveLayerNumber;
G4cout << G4endl << " Active Layer Size = " << fActiveLayerSize/mm << " mm";
G4cout << G4endl << " Is the Radius Unit in Lambda ? " << fIsRadiusUnitInLambda;
G4cout << G4endl << " Radius Bin Size = ";
G4cout << G4endl << " Magnetic field [T] = ";
if ( fUniformMagField ) {
G4cout << fUniformMagField->GetConstantFieldValue() / tesla;
} else {
G4cout << "(0,0,0)";
}
G4cout << G4endl << " -------------------------------------------------------- " << G4endl
<< G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Calo/src/DetectorMessenger.cc
Executable
+187
View File
@@ -0,0 +1,187 @@
//
// ********************************************************************
// * 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 DetectorMessenger.cc
/// \brief Implementation of the DetectorMessenger class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "DetectorMessenger.hh"
#include "DetectorConstruction.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithABool.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4UIcmdWithoutParameter.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
DetectorMessenger::DetectorMessenger( DetectorConstruction* myDet ) : fDetector( myDet ) {
fDetectorDir = new G4UIdirectory( "/mydet/" );
fDetectorDir->SetGuidance( "Detector control." );
fFieldCommand = new G4UIcmdWithADoubleAndUnit( "/mydet/setField", this );
fFieldCommand->SetGuidance( "Define uniform magnetic field along Y." );
fFieldCommand->SetGuidance( " -> in unit of [Tesla]" );
fFieldCommand->SetParameterName( "By", false );
fFieldCommand->SetDefaultValue( 0.0 );
fFieldCommand->SetUnitCategory( "Magnetic flux density" );
fFieldCommand->AvailableForStates( G4State_PreInit, G4State_Idle );
fAbsorberMaterial = new G4UIcmdWithAString( "/mydet/absorberMaterial", this );
fAbsorberMaterial->SetGuidance( "Choice of the absorber material:" );
fAbsorberMaterial->SetGuidance( " iron / copper / tungsten / lead / PbWO4 / uranium " );
fAbsorberMaterial->SetParameterName( "choiceAbsorberMaterial", true );
fAbsorberMaterial->SetDefaultValue( "iron" );
fAbsorberMaterial->AvailableForStates( G4State_PreInit, G4State_Idle );
fActiveMaterial = new G4UIcmdWithAString( "/mydet/activeMaterial", this );
fActiveMaterial->SetGuidance( "Choice of the active material:" );
fActiveMaterial->SetGuidance( " scintillator / liquidArgon / PbWO4 / silicon / quartz " );
fActiveMaterial->SetParameterName( "choiceActiveMaterial", true );
fActiveMaterial->SetDefaultValue( "scintillator" );
fActiveMaterial->AvailableForStates( G4State_PreInit, G4State_Idle );
fIsCalHomogeneous = new G4UIcmdWithABool( "/mydet/isCalHomogeneous", this );
fIsCalHomogeneous->SetParameterName( "choiceIsCalHomogeneous", true );
fIsCalHomogeneous->SetGuidance( "Is the calorimeter homogeneous?" );
fIsCalHomogeneous->SetGuidance( " -> yes|y|true|t|1 : Homogeneous calorimeter" );
fIsCalHomogeneous->SetGuidance( " -> no|n|false|f|0 : Sampling calorimeter" );
fIsCalHomogeneous->SetDefaultValue( false ); // default: sampling calorimeter
fIsCalHomogeneous->AvailableForStates( G4State_PreInit, G4State_Idle );
fIsUnitInLambda = new G4UIcmdWithABool( "/mydet/isUnitInLambda", this );
fIsUnitInLambda->SetParameterName( "choiceIsUnitInLambda", true );
fIsUnitInLambda->SetGuidance( "Is unit for absorber length in lambda?" );
fIsUnitInLambda->SetGuidance( " -> yes|y|true|t|1 : unit in lambda" );
fIsUnitInLambda->SetGuidance( " -> no|n|false|f|0 : unit in [mm]" );
fIsUnitInLambda->SetDefaultValue( false ); // default: unit in [mm].
fIsUnitInLambda->AvailableForStates( G4State_PreInit, G4State_Idle );
fAbsorberTotalLength = new G4UIcmdWithADouble( "/mydet/absorberTotalLength", this );
fAbsorberTotalLength->SetParameterName( "choiceAbsorberTotalLength", true );
fAbsorberTotalLength->SetGuidance( "Absorber total length" );
fAbsorberTotalLength->SetGuidance( " -> in unit of lambda or [mm]" );
fAbsorberTotalLength->SetGuidance( " -> depending on value of choiceIsUnitInLambda" );
fAbsorberTotalLength->SetDefaultValue( 2000.0 ); // default: 2 meters.
fAbsorberTotalLength->AvailableForStates( G4State_PreInit, G4State_Idle );
fCalorimeterRadius = new G4UIcmdWithADouble( "/mydet/calorimeterRadius", this );
fCalorimeterRadius->SetParameterName( "choiceCalorimeterRadius", true );
fCalorimeterRadius->SetGuidance( "Calorimeter Radius" );
fCalorimeterRadius->SetGuidance( " -> in unit of lambda or [mm]" );
fCalorimeterRadius->SetGuidance( " -> depending on value of choiceIsUnitInLambda" );
fCalorimeterRadius->SetDefaultValue( 1000.0 ); // default: 1 meter.
fCalorimeterRadius->AvailableForStates( G4State_PreInit, G4State_Idle );
fActiveLayerNumber = new G4UIcmdWithAnInteger( "/mydet/activeLayerNumber", this );
fActiveLayerNumber->SetParameterName( "choiceActiveLayerNumber", true );
fActiveLayerNumber->SetGuidance( "Number of active layers" );
fActiveLayerNumber->SetDefaultValue( 50 );
fActiveLayerNumber->AvailableForStates( G4State_PreInit, G4State_Idle );
fActiveLayerSize = new G4UIcmdWithADouble( "/mydet/activeLayerSize", this );
fActiveLayerSize->SetParameterName( "choiceActiveLayerSize", true );
fActiveLayerSize->SetGuidance( "Size (thickness) of the active layer, in [mm]" );
fActiveLayerSize->SetDefaultValue( 4.0 ); // default: 4 millimeters.
fActiveLayerSize->AvailableForStates( G4State_PreInit, G4State_Idle );
fIsRadiusUnitInLambda = new G4UIcmdWithABool( "/mydet/isRadiusUnitInLambda", this );
fIsRadiusUnitInLambda->SetParameterName( "choiceIsRadiusUnitInLambda", true );
fIsRadiusUnitInLambda->SetGuidance( "Is unit of radius in lambda?" );
fIsRadiusUnitInLambda->SetGuidance( " -> yes|y|true|t|1 : unit in lambda" );
fIsRadiusUnitInLambda->SetGuidance( " -> no|n|false|f|0 : unit in [mm]" );
fIsRadiusUnitInLambda->SetDefaultValue( false ); // default: unit in [mm].
fIsRadiusUnitInLambda->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() {
delete fFieldCommand;
delete fDetectorDir;
delete fAbsorberMaterial;
delete fActiveMaterial;
delete fIsCalHomogeneous;
delete fIsUnitInLambda;
delete fAbsorberTotalLength;
delete fCalorimeterRadius;
delete fActiveLayerNumber;
delete fActiveLayerSize;
delete fIsRadiusUnitInLambda;
delete fUpdateCommand;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void DetectorMessenger::SetNewValue( G4UIcommand* command, G4String newValue ) {
if ( command == fFieldCommand ) {
fDetector->SetMagField( fFieldCommand->GetNewDoubleValue( newValue ) );
}
if ( command == fAbsorberMaterial ) {
fDetector->SetAbsorberMaterial( newValue );
}
if ( command == fActiveMaterial ) {
fDetector->SetActiveMaterial( newValue );
}
if ( command == fIsCalHomogeneous ) {
fDetector->SetIsCalHomogeneous( fIsCalHomogeneous->GetNewBoolValue( newValue ) );
}
if ( command == fIsUnitInLambda ) {
fDetector->SetIsUnitInLambda( fIsUnitInLambda->GetNewBoolValue( newValue ) );
}
if ( command == fAbsorberTotalLength ) {
fDetector->SetAbsorberTotalLength( fAbsorberTotalLength->GetNewDoubleValue( newValue ) );
}
if ( command == fCalorimeterRadius ) {
fDetector->SetCalorimeterRadius( fCalorimeterRadius->GetNewDoubleValue(newValue) );
}
if ( command == fActiveLayerNumber ) {
fDetector->SetActiveLayerNumber( fActiveLayerNumber->GetNewIntValue( newValue ) );
}
if ( command == fActiveLayerSize ) {
fDetector->SetActiveLayerSize( fActiveLayerSize->GetNewDoubleValue( newValue ) );
}
if ( command == fIsRadiusUnitInLambda ) {
fDetector->SetIsRadiusUnitInLambda( fIsRadiusUnitInLambda->GetNewBoolValue( newValue ) );
}
if ( command == fUpdateCommand ) {
fDetector->UpdateGeometry();
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Calo/src/PrimaryGeneratorAction.cc
Executable
+83
View File
@@ -0,0 +1,83 @@
//
// ********************************************************************
// * 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 PrimaryGeneratorAction.cc
/// \brief Implementation of the PrimaryGeneratorAction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "PrimaryGeneratorAction.hh"
#include "DetectorConstruction.hh"
#include "G4Event.hh"
#include "G4ParticleGun.hh"
#include "G4ParticleTable.hh"
#include "G4ParticleDefinition.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PrimaryGeneratorAction::PrimaryGeneratorAction( const DetectorConstruction* pDetector ) :
fPointerDetectorConstruction( pDetector )
{
G4int n_particle = 1;
fParticleGun = new G4ParticleGun( n_particle );
G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
//***LOOKHERE*** Default particle and energy
fParticleGun->SetParticleDefinition( particleTable->FindParticle( "geantino" ) );
fParticleGun->SetParticleEnergy( 10.0*GeV );
SetGunPosition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
PrimaryGeneratorAction::~PrimaryGeneratorAction() {
delete fParticleGun;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void PrimaryGeneratorAction::SetGunPosition() const {
// Shoot the particle in the middle between the world and the calorimeter
G4double caloLength =
( fPointerDetectorConstruction ? fPointerDetectorConstruction->GetCaloLength() : 0.0 );
G4double gunPosition = -0.55*caloLength; //***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 );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Calo/src/Run.cc
+138
View File
@@ -0,0 +1,138 @@
//
// ********************************************************************
// * 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 Run.cc
/// \brief Implementation of the Run class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "Run.hh"
#include "G4SystemOfUnits.hh"
#include "G4Run.hh"
#include "G4RunManager.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
Run::Run() : G4Run(), fNumEvents( 0 ),
fPrimaryParticleId( 0 ), fPrimaryParticleEnergy( 0.0 ),
fPrimaryParticleDirection( G4ThreeVector( 0.0, 0.0, 0.0 ) ),
fAbsorberMaterialName( "" ), fActiveMaterialName( "" ),
fCubicVolumeScoringUpDown( 1.0 ), fCubicVolumeScoringSide( 1.0 )
{
for ( G4int i = 0; i < SteppingAction::numberCombinations; ++i ) fArray[i] = 0.0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
Run::~Run() {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 );
fPrimaryParticleId = localRun->getPrimaryParticleId();
fPrimaryParticleEnergy = localRun->getPrimaryParticleEnergy();
fPrimaryParticleDirection = localRun->getPrimaryParticleDirection();
fAbsorberMaterialName = localRun->getAbsorberMaterialName();
fActiveMaterialName = localRun->getActiveMaterialName();
fCubicVolumeScoringUpDown = localRun->getCubicVolumeScoringUpDown();
fCubicVolumeScoringSide = localRun->getCubicVolumeScoringSide();
fNumEvents += localRun->GetNumberOfEvent();
for ( G4int i = 0; i < SteppingAction::numberCombinations; ++i ) {
fArray[i] += localRun->getArray()[i];
}
G4Run::Merge( aRun );
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
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 );
// 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 );
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
<< " Absorber material = " << fAbsorberMaterialName << G4endl
<< " Active material = " << fActiveMaterialName << G4endl
<< " Cubic-volume scoring up-down = " << fCubicVolumeScoringUpDown << " 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::numberScoringVolumes; ++i ) {
G4double factor = ( i == 1 ? factorSide : factorUpDown );
for ( G4int j = 0; j < SteppingAction::numberKinematicRegions; ++j ) {
for ( G4int k = 0; k < SteppingAction::numberParticleTypes; ++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::arrayScoringVolumeNames[i]
<< " " << std::setw(12) << SteppingAction::arrayKinematicRegionNames[j]
<< " " << std::setw(12) << SteppingAction::arrayParticleTypeNames[k]
<< " " << factor*fArray[index] << G4endl;
}
}
}
G4cout << " ============================================================= " << G4endl << G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void Run::setArray( const std::array< G4double,
SteppingAction::numberCombinations >& inputArray ) {
for ( G4int i = 0; i < SteppingAction::numberCombinations; ++i ) {
fArray[i] = inputArray[i];
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Calo/src/RunAction.cc
Executable
+75
View File
@@ -0,0 +1,75 @@
//
// ********************************************************************
// * 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 RunAction.cc
/// \brief Implementation of the RunAction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "RunAction.hh"
#include "globals.hh"
#include "G4Run.hh"
#include "Run.hh"
#include "SteppingAction.hh"
#include "G4RunManager.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::RunAction( SteppingAction* steppingAction ) :
G4UserRunAction(), fSteppingAction( steppingAction ) {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
RunAction::~RunAction() {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4Run* RunAction::GenerateRun() {
return new Run;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void RunAction::BeginOfRunAction( const G4Run* aRun ) {
G4cout << "### Run " << aRun->GetRunID() << " starts." << G4endl;
if ( fSteppingAction ) {
fSteppingAction->initialize();
Run* run = const_cast< Run* >( static_cast< const Run* >( aRun ) );
if ( run != nullptr ) fSteppingAction->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();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
examples/extended/hadronic/ParticleFluence/Calo/src/SteppingAction.cc
Executable
+239
View File
@@ -0,0 +1,239 @@
//
// ********************************************************************
// * 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 SteppingAction.cc
/// \brief Implementation of the SteppingAction class
//
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....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::numberScoringVolumes >
SteppingAction::arrayScoringVolumeNames = { "downstream", "side", "upstream" };
const std::array< G4String, SteppingAction::numberKinematicRegions >
SteppingAction::arrayKinematicRegionNames = { "", "below 20 MeV", "above 20 MeV" };
const std::array< G4String, SteppingAction::numberParticleTypes >
SteppingAction::arrayParticleTypeNames = { "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 index = -1;
if ( iScoringVolume >= 0 && iScoringVolume < numberScoringVolumes &&
iKinematicRegion >= 0 && iKinematicRegion < numberKinematicRegions &&
iParticleType >= 0 && iParticleType < numberParticleTypes ) {
index = iScoringVolume * numberKinematicRegions * numberParticleTypes +
iKinematicRegion * numberParticleTypes +
iParticleType;
}
return index;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
SteppingAction::SteppingAction() :G4UserSteppingAction() {
initialize();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
SteppingAction::~SteppingAction() {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void SteppingAction::initialize() {
// Initialization needed at the beginning of each Run
fPrimaryParticleId = 0;
fPrimaryParticleEnergy = 0.0;
fPrimaryParticleDirection = G4ThreeVector( 0.0, 0.0, 1.0 );
fAbsorberMaterialName = "";
fActiveMaterialName = "";
fIsFirstStepOfTheEvent = true;
fIsFirstStepInAbsorberLayer = true;
fIsFirstStepInActiveLayer = true;
fIsFirstStepInScoringUpDown = true;
fIsFirstStepInScoringSide = true;
fCubicVolumeScoringUpDown = 1.0;
fCubicVolumeScoringSide = 1.0;
for ( G4int i = 0; i < numberCombinations; ++i ) {
fArraySumStepLengths[i] = 0.0;
}
/*
for ( G4int i = 0; i < numberCombinations; ++i ) fArraySumStepLengths[i] = 999.9;
G4cout << " numberCombinations=" << numberCombinations << G4endl;
for ( G4int i = 0; i < numberScoringVolumes; ++i ) {
for ( G4int j = 0; j < numberKinematicRegions; ++j ) {
for ( G4int k = 0; k < numberParticleTypes; ++k ) {
G4int index = getIndex( i, j, k );
G4cout << "(i, j, k)=(" << i << ", " << j << ", " << k << ") ->" << index;
if ( fArraySumStepLengths[ index ] < 1.0 ) G4cout << " <=== REPEATED!";
else fArraySumStepLengths[ index ] = 0.0;
G4cout << G4endl;
}
}
}
for ( G4int i = 0; i < numberCombinations; ++i ) {
if ( fArraySumStepLengths[i] > 999.0 ) G4cout << " i=" << i << " NOT COVERED !" << G4endl;
}
*/
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void SteppingAction::UserSteppingAction( const G4Step* theStep ) {
// Get information on the primary particle
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 );
}
fIsFirstStepOfTheEvent = false;
}
}
// Get information on the materials of the calorimeter
if ( fIsFirstStepInAbsorberLayer &&
theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiAbsorber" ) {
fAbsorberMaterialName = theStep->GetPreStepPoint()->GetMaterial()->GetName();
if ( fRunPtr ) fRunPtr->setAbsorberMaterialName( fAbsorberMaterialName );
fIsFirstStepInAbsorberLayer = false;
}
if ( fIsFirstStepInActiveLayer &&
theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiActive" ) {
fActiveMaterialName = theStep->GetPreStepPoint()->GetMaterial()->GetName();
if ( fRunPtr ) fRunPtr->setActiveMaterialName( fActiveMaterialName );
fIsFirstStepInActiveLayer = false;
}
// Get information on step lengths in the scoring volumes
G4int iScoringVolume = -1;
if ( theStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() == "physiScoringDownstream" ) {
iScoringVolume = 0;
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 );
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 ) return;
G4double stepLength = theStep->GetTrack()->GetStepLength() * theStep->GetTrack()->GetWeight();
G4int absPdg = theStep->GetTrack()->GetDefinition() == nullptr ? 0 :
std::abs( theStep->GetTrack()->GetDefinition()->GetPDGEncoding() );
/*
G4cout << std::setprecision(6)
<< theStep->GetTrack()->GetDefinition()->GetParticleName() << " absPdg=" << absPdg
<< " Ekin[MeV]=" << theStep->GetPreStepPoint()->GetKineticEnergy()
<< " (rho,z)[mm]=(" << theStep->GetTrack()->GetPosition().perp()
<< "," << theStep->GetTrack()->GetPosition().z() << ")"
<< " " << theStep->GetTrack()->GetVolume()->GetName()
<< " " << theStep->GetTrack()->GetMaterial()->GetName()
<< " L[mm]=" << stepLength << " "
<< ( fPrimaryParticleDirection.dot(
theStep->GetPreStepPoint()->GetMomentumDirection() ) > 0.0
? "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.)
// Consider the specific case : scoring volume, kinematic region and particle type
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 );
fArraySumStepLengths[index] += stepLength;
// 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 );
fArraySumStepLengths[index] += stepLength;
if ( fRunPtr ) fRunPtr->setArray( fArraySumStepLengths );
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......