Proton Calorimetry/Detector Simulation: Difference between revisions

From PBTWiki
Jump to navigation Jump to search
(27 intermediate revisions by the same user not shown)
Line 6: Line 6:
== Local Installation of GEANT4 on MacOS ==
== Local Installation of GEANT4 on MacOS ==


''Correct for MacOS High Sierra 10.13.6''
''Tested on macOS Big Sur 11.6.5 and Monterey 12.3''


* Install Xcode 10 or higher from Mac App Store and install command line tools by executing in a terminal window <code>xcode-select --install</code>. Agree to the Xcode license: <code>sudo xcodebuild -license</code>
* Install Xcode 13 or higher from the Mac App Store and install command line tools by executing in a terminal window <code>xcode-select --install</code>. Agree to the Xcode license: <code>sudo xcodebuild -license</code>
* Install XQuartz [https://www.xquartz.org/]
* Install MacPorts appropriate for your system [https://www.macports.org/install.php].
* Install MacPorts appropriate for your system [https://www.macports.org/install.php].
* Install CMake 3.8 or higher [https://github.com/Kitware/CMake/releases/download/v3.16.4/cmake-3.16.4-Darwin-x86_64.dmg]
* Install CMake using MacPorts: <code> sudo port install cmake </code>
* Optional: Install CLHEP 2.4.1.0 or higher [http://proj-clhep.web.cern.ch/proj-clhep/dist1/clhep-2.4.1.3.tgz] (see README for build/install instructions)
* Install Qt5 [https://www.qt.io/download-open-source]
** <code><source_code_dir></code> is the directory where the README is located.
** You will need to register for an account as an open-source developer.
** <code><build_directory></code> can be any folder you like (can be deleted after installation).
** Only need to install the latest version of Qt5 (5.15.2)
** <code><install_directory></code> should be the default: <code>/usr/local</code>
*Install GEANT4 [http://geant4.web.cern.ch/support/download]
* Install Expat 2.0.1 or higher [https://github.com/libexpat/libexpat/archive/R_2_2_9.tar.gz] (see README for build/install instructions)
**See installation guide [http://geant4-userdoc.web.cern.ch/geant4-userdoc/UsersGuides/InstallationGuide/html/installguide.html here]
** Execute <code>./buildconf.sh</code> and then <code>./configure</code> in the directory <code><download_directory>/expat</code>
**In the GEANT4 build folder, execute: <code>cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DGEANT4_BUILD_MULTITHREADED=ON -DGEANT4_INSTALL_DATA=ON -DGEANT4_USE_GDML=OFF -DGEANT4_USE_QT=ON -DQT_QMAKE_EXECUTABLE=/<path to Qt installation folder>/5.15.2/clang_64/bin/qmake -DCMAKE_PREFIX_PATH=<path to Qt installation folder>/5.15.2/clang_64/lib/cmake -DGEANT4_USE_OPENGL_X11=OFF -DGEANT4_USE_RAYTRACER_X11=OFF -DGEANT4_USE_SYSTEM_EXPAT=OFF -DGEANT4_USE_SYSTEM_ZLIB=OFF <path to GEANT4 download folder></code>
***If <code>autoreconf</code> is not found, install <code>autoconf</code> by executing: <code>sudo port install automake autoconf libtool</code>
**Then execute: <code>make -jN</code> where N is the number of cores your machine has.
** Might need to use <code>sudo</code> when executing <code>make install</code>
**Then execute: <code>sudo make install</code>
* Install zlib 1.2.3 or higher [https://zlib.net/zlib-1.2.11.tar.gz] (see README for build/install instructions)
*In your <code>.bash_profile</code> (in your home directory, press CMD+SHIFT+. to make the file visible) add the line <code>. /usr/local/bin/geant4.sh</code> so that the environment is set every time a new terminal window is opened.
** Might need to use <code>sudo</code> when executing <code>make install</code.>
*Try compiling the basic example B1:
* Install Xerces-C++ headers and library 3 or higher [https://downloads.apache.org//xerces/c/3/sources/xerces-c-3.2.2.tar.gz]
**Navigate to source folder of example B1: <code>cd /usr/local/share/Geant4-<your version here>/examples/basic/B1</code>
** Will need to install GPG [https://gpgtools.org/] to verify KEYS
**Make a directory in which to build: <code>sudo mkdir build</code> and then move to this directory, <code>cd build</code>
** Installation instructions can be found here [http://xerces.apache.org/xerces-c/install-3.html]
**Execute <code>sudo cmake -DCMAKE_PREFIX_PATH=/usr/local/lib/Geant4-<your version here>/ ../</code>
* Install GEANT4 [http://geant4-userdoc.web.cern.ch/geant4-userdoc/UsersGuides/InstallationGuide/html/installguide.html#geant4buildoptions]
**Execute <code>sudo make -jN</code> where N is the number of cores your machine has.
** Enable additional build options: multithreading, install data, GDML, QT, OpenGL, RayTracer, zlib
**Run the example: <code>./exampleB1</code>
** Apparently system CLHEP should not be used unless absolutely necessary


== Running QUARC Detector Simulation ==
== Running QUARC Detector Simulation ==
Line 35: Line 35:
*To run the simulation with the default macro, <code>inter.mac</code>, execute: <code>./ProtonSimulation</code>
*To run the simulation with the default macro, <code>inter.mac</code>, execute: <code>./ProtonSimulation</code>
*To run the simulation with a different macro, e.g. <code>interactive.mac</code>, execute: <code>./ProtonSimulation ../macros/interactive.mac</code>
*To run the simulation with a different macro, e.g. <code>interactive.mac</code>, execute: <code>./ProtonSimulation ../macros/interactive.mac</code>
=== Running QUARC Detector Simulation in Eclipse IDE ===
*Create new makefile project with existing code in Eclipse and choose the directory containing <code>CMakeLists.txt</code> as the Existing Code Location.
*Under Run -> External Tools -> External Tools Configurations:
**Create a new launch configuration and set the variables Location to <code>${workspace_loc:/Simulation/eclipse_build.sh}</code> and Working Directory to: <code>${workspace_loc:/Simulation/build}</code> (adjust paths if needed).
**This will run <code>cmake</code>, which is necessary before building.
**Set Refresh behaviour to refresh the workspace after completion.
**Uncheck Build Before Launch
*Under Project Properties –> C/C++ build:
**Uncheck "Use Default Build Command" and "Generate Makefiles Automatically".
**Set the build command to: <code>make -jN</code> where N is the number of cores your machine has.
**Set the build location to: <code>${workspace_loc:/Simulation}/build</code>, adjusting path if needed.
*Under Project Properties –> C/C++ General –> Paths and Symbols -> Includes, add the variables to include GEANT4 headers (for all languages and configurations, adjusting directories appropriately for your installations):
**<code>/usr/local/include/GEANT4</code>
**<code>/usr/local/include/CLHEP</code> (May not be necessary and requires non-GEANT4 installation of CLHEP).
**<code>/Applications/root_v6.20.00</code> (If ROOT is required)
*Under Run -> Run Configurations, create a new configuration of type C/C++ application for the project:
**Set C/C++ application to <code>build/ProtonSimulation</code>
**Under Arguments, set the working directory to: <code>${workspace_loc:Simulation}/build</code>
**Under Environment, define the variables pointing to GEANT4's data sets:
***These are defined at the bottom of <code>/usr/local/bin/geant4.sh</code> under 'Export resource file paths'
***e.g. Variable: <code>G4ENSDFSTATEDATA</code>, Value: <code>/usr/local/share/Geant4-10.6.1/data/G4ENSDFSTATE2.2</code>
***There are 11 of them in GEANT4 10.6.1.
*To then run the simulation, run the external tool and then run the launch configuration (which by default will make and run the application).


== General Notes ==
== General Notes ==

Revision as of 15:13, 16 March 2022

This page contains information on the Geant4 code that form the Proton Calorimetry detector simulation.

In order to run Geant4 simulations, you will either need to download and install the software yourself or make use of the existing installation on the UCL HEP Linux cluster. To use the existing installation, follow this dedicated page.

Local Installation of GEANT4 on MacOS

Tested on macOS Big Sur 11.6.5 and Monterey 12.3

  • Install Xcode 13 or higher from the Mac App Store and install command line tools by executing in a terminal window xcode-select --install. Agree to the Xcode license: sudo xcodebuild -license
  • Install XQuartz [1]
  • Install MacPorts appropriate for your system [2].
  • Install CMake using MacPorts: sudo port install cmake
  • Install Qt5 [3]
    • You will need to register for an account as an open-source developer.
    • Only need to install the latest version of Qt5 (5.15.2)
  • Install GEANT4 [4]
    • See installation guide here
    • In the GEANT4 build folder, execute: cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DGEANT4_BUILD_MULTITHREADED=ON -DGEANT4_INSTALL_DATA=ON -DGEANT4_USE_GDML=OFF -DGEANT4_USE_QT=ON -DQT_QMAKE_EXECUTABLE=/<path to Qt installation folder>/5.15.2/clang_64/bin/qmake -DCMAKE_PREFIX_PATH=<path to Qt installation folder>/5.15.2/clang_64/lib/cmake -DGEANT4_USE_OPENGL_X11=OFF -DGEANT4_USE_RAYTRACER_X11=OFF -DGEANT4_USE_SYSTEM_EXPAT=OFF -DGEANT4_USE_SYSTEM_ZLIB=OFF <path to GEANT4 download folder>
    • Then execute: make -jN where N is the number of cores your machine has.
    • Then execute: sudo make install
  • In your .bash_profile (in your home directory, press CMD+SHIFT+. to make the file visible) add the line . /usr/local/bin/geant4.sh so that the environment is set every time a new terminal window is opened.
  • Try compiling the basic example B1:
    • Navigate to source folder of example B1: cd /usr/local/share/Geant4-<your version here>/examples/basic/B1
    • Make a directory in which to build: sudo mkdir build and then move to this directory, cd build
    • Execute sudo cmake -DCMAKE_PREFIX_PATH=/usr/local/lib/Geant4-<your version here>/ ../
    • Execute sudo make -jN where N is the number of cores your machine has.
    • Run the example: ./exampleB1

Running QUARC Detector Simulation

  • You can copy the simulation files from this path on the HEP cluster: /unix/pbt/users/sshaikh/Simulation
  • In the folder 'build', execute: sudo cmake -DCMAKE_PREFIX_PATH=/usr/local/lib/Geant4-<YOUR VERSION HERE>/ <YOUR PATH TO SIMULATION FOLDER>
  • Then, execute: sudo make
  • To run the simulation with the default macro, inter.mac, execute: ./ProtonSimulation
  • To run the simulation with a different macro, e.g. interactive.mac, execute: ./ProtonSimulation ../macros/interactive.mac

Running QUARC Detector Simulation in Eclipse IDE

  • Create new makefile project with existing code in Eclipse and choose the directory containing CMakeLists.txt as the Existing Code Location.
  • Under Run -> External Tools -> External Tools Configurations:
    • Create a new launch configuration and set the variables Location to ${workspace_loc:/Simulation/eclipse_build.sh} and Working Directory to: ${workspace_loc:/Simulation/build} (adjust paths if needed).
    • This will run cmake, which is necessary before building.
    • Set Refresh behaviour to refresh the workspace after completion.
    • Uncheck Build Before Launch
  • Under Project Properties –> C/C++ build:
    • Uncheck "Use Default Build Command" and "Generate Makefiles Automatically".
    • Set the build command to: make -jN where N is the number of cores your machine has.
    • Set the build location to: ${workspace_loc:/Simulation}/build, adjusting path if needed.
  • Under Project Properties –> C/C++ General –> Paths and Symbols -> Includes, add the variables to include GEANT4 headers (for all languages and configurations, adjusting directories appropriately for your installations):
    • /usr/local/include/GEANT4
    • /usr/local/include/CLHEP (May not be necessary and requires non-GEANT4 installation of CLHEP).
    • /Applications/root_v6.20.00 (If ROOT is required)
  • Under Run -> Run Configurations, create a new configuration of type C/C++ application for the project:
    • Set C/C++ application to build/ProtonSimulation
    • Under Arguments, set the working directory to: ${workspace_loc:Simulation}/build
    • Under Environment, define the variables pointing to GEANT4's data sets:
      • These are defined at the bottom of /usr/local/bin/geant4.sh under 'Export resource file paths'
      • e.g. Variable: G4ENSDFSTATEDATA, Value: /usr/local/share/Geant4-10.6.1/data/G4ENSDFSTATE2.2
      • There are 11 of them in GEANT4 10.6.1.
  • To then run the simulation, run the external tool and then run the launch configuration (which by default will make and run the application).

General Notes

  • In output file EdepAccurate, each number represents the energy deposited in the user-defined sheet thickness, divided by spatial resolution (not in file name)
    • e.g. EdepAccurate_252.7MeV_200x2_500mustep_100p_refl.out represents 252.7 MeV beam, 200 sheets of 2mm thickness, 500 micron StepMax, 100 protons, reflection allowed.
    • StepMax represents the minimum resolution in GEANT4’s tracking of particles, characteristics are calculated in distance intervals. If undefined, GEANT4 will choose a step size that represents the finest increment required by the various physics lists. Default value might be ~2mm.
  • Can choose to record number of photons produced or number of photons that reach the edge of the scintillator. In the latter, allowing reflections is necessary.
    • Number of photons produced is stored in NPhoton
    • Number of photons that reach edge of scintillator is stored in NPhotonTop
  • In file Hits, there is a list of all protons produced in simulation with their energy, 2 mystery numbers and their stopping depth.
    • Small numbers are indicative of a nuclear interaction, which results in a proton being deflected sufficient to warrant a new particle ID.
  • The parameter rangeCut defines the minimum range of a secondary particle (electrons, positrons & gammas) such that it is tracked until it stops. Such particles with ranges below rangeCut just have their energy deposited in place and are then deleted. This is such to avoid long-computation times.
    • This does not however apply to any other secondaries, e.g. neutrons or alpha particles.
  • Notation: e.g. /control/multiply x {y} {z}
    • x = y times z
    • Brackets are required when using previously defined variables
  • Positional origin of simulation is in middle of scintillator
  • It is more important to have sufficient numbers of protons in simulation in order to accurately simulate the energy deposition curve. While in reality approx. 10000 photons per MeV lost in protons is produced, this would take far too long to simulate and would require reducing the number of protons. However, the depth-light curve can only ever be as good as the energy deposition curve – so sampling more photons with only few protons will NOT give a good depth-light curve.

Existing Issues

  • The macros, e.g. inter.mac attempt to define aspects of the detector geometry, but fail do so. It appears that GEANT4 defines a geometry based on PTDetectorConstruction and then does not allow the macro to update the geometry. See ProtonSimulation.cc: the macro is called after the geometry is defined. Find some code where a macro redefines the geometry successfully to find out where to place the macro-defined geometry parameters. Probably needs work in the Messenger source files or PTDetectorConstruction::UpdateGeometry().