Processes/NullModel/NullModel.h

-#ifndef _Physics_NullModel_NullModel_h_
-#define _Physics_NullModel_NullModel_h_
-
-namespace physics {
-
-  namespace processes {
-
-    class NullModel {
-
-    public:
-      NullModel();
-      ~NullModel();
-
-      void init();
-      void run();
-      double GetStepLength();
-    };
-    
-  }
-}
-
-#endif
-

README.md

+# CORSIKA 8 Framework for Particle Cascades in Astroparticle Physics
+
+The purpose of CORSIKA 8 is to simulate any particle cascades in
+astroparticle physics or astrophysical context. A lot of emphasis has been
+put on modularity, flexibility, completeness, validation and
+correctness. To boost computational efficiency, different techniques
+are provided, like thinning or cascade equations. The aim is that
+CORSIKA 8 remains the most comprehensive framework for simulating
+particle cascades with stochastic and continuous processes.
+
+The software makes extensive use of static design patterns and
+compiler optimization. Thus, the most fundamental configuration
+decisions of the user must be performed at compile time. At run time,
+model parameters can still be changed.
+
+CORSIKA 8 is by default released under the BSD 3-Clause License. See [license
+file](https://gitlab.iap.kit.edu/AirShowerPhysics/corsika/blob/master/LICENSE)
+which is part of every release and the source code.
+
+If you use, or want to refer to, CORSIKA 8 please cite ["Towards a Next
+Generation of CORSIKA: A Framework for the Simulation of Particle
+Cascades in Astroparticle Physics", Comput. Softw. Big Sci. 3 (2019)
+2](https://doi.org/10.1007/s41781-018-0013-0) as well as
+["Simulating radio emission from particle cascades with CORSIKA 8", Astropart. Phys. 166 (2025)
+103072](https://doi.org/10.1016/j.astropartphys.2024.103072).
+
+We kindly ask (and require) any relevant improvement or addition to be offered or
+contributed to the main CORSIKA 8 repository for the benefit of the
+whole community.
+
+CORSIKA 8 makes use of various third-party code, in particular interaction
+models. Please check the [using and collaborating
+agreement](https://gitlab.iap.kit.edu/AirShowerPhysics/corsika/blob/master/USING_COLLABORATING.md)
+for further information on this topic.
+
+If you plan to contribute to CORSIKA 8, please check the guidelines outlined here:
+[coding
+guidelines](https://gitlab.iap.kit.edu/AirShowerPhysics/corsika/blob/master/CONTRIBUTING.md). Code
+that fails the review by the CORSIKA 8 author group must be improved
+before it can be merged in the official code base. After your code has
+been accepted and merged, you become a contributor of the CORSIKA 8
+project (code author).
+
+IMPORTANT: Before you contribute, you need to read and agree to the conditions set out in the
+[using and collaborating
+agreement](https://gitlab.iap.kit.edu/AirShowerPhysics/corsika/blob/master/USING_COLLABORATING.md).
+The agreement can be discussed, and eventually improved if necessary.
+
+
+## Get in contact
+  * Join our chat threads using Mattermost via this [invite link](https://mattermost.hzdr.de/signup_user_complete/?id=xtdd8jyt6trbiezt71gaz3z4ge&md=link&sbr=su). Click the `GitLab` button, then `Sign in with Helmholtz ID`. You will be able to make an account by either finding your institution, or using your e.g. ORCID, GitHub, or Google account.
+  * Connect to https://gitlab.iap.kit.edu, register yourself and join the "Air Shower Physics" group. Write to us on Mattermost (in the User Questions channel), or directly contact one of the [steering comittee members](https://gitlab.iap.kit.edu/AirShowerPhysics/corsika/-/wikis/Steering-Committee) in case there are problems with that.
+  * Connect to corsika-devel@lists.kit.edu (self-register at
+    https://www.lists.kit.edu/sympa/subscribe/corsika-devel) to get in
+    touch with the project.
+
+
+## Installation
+
+CORSIKA 8 is tested regularly at least on `gcc11.0.0` and `clang-14.0.0`.
+
+### Prerequisites
+
+You will also need:
+
+- Python 3 (supported versions are Python >= 3.6), with pip
+- cmake > 3.4
+- git
+- g++, gfortran, binutils, make
+- optional: FLUKA (see below)
+
+
+On a bare Ubuntu machine, just add:
+``` shell
+sudo apt-get install python3 python3-pip cmake g++ gfortran git doxygen graphviz
+```
+
+### Creating a virtual environment and Conan
+
+It is recommended that you install CORSIKA 8 and its dependencies within a python3 virtual environment.
+To do so, you can run the following.
+``` shell
+# Create the environment using your native python3 binary
+python3 -m venv /path/to/new/virtual/environment/corsika-8
+# Load the environment (should be run each time you open a new terminal)
+source /path/to/new/virtual/environment/corsika-8/bin/activate
+
+```
+
+You will need to load the environment each time that you open a new terminal.
+
+CORSIKA 8 uses the [conan](https://conan.io/) package manager to
+manage our dependencies. Currently, version 2.50.0 or higher is required.
+**Note**: if you are NOT using a virtual environment, you may want to use the `pip install --user` flag.
+
+``` shell
+pip install conan particle==0.25.1 numpy
+```
+
+### Enabling FLUKA support
+
+For legal reasons we do not distribute/bundle FLUKA together with CORSIKA 8.
+As FLUKA is the standard low-energy hadronic interaction model for CORSIKA 8, you have to download
+it separately from (http://www.fluka.org/), which requires registering there as FLUKA user.
+The following should be done *before* compiling CORSIKA 8:
+
+ 1. Note your system's version of gfortran (`gfortran --version`) and glibc (`ldd --version`)
+ 2. Download the FLUKA __binary__, ensuring that it matches the versions you found above
+ 3. Download the FLUKA __data file__ (will be named something similar to __fluka20xy.z-data.tar.gz__).
+ 4. Un-tar the files that you downloaded using `tar -xf <filename>`
+ 5. Set environmental variables `export FLUFOR=gfortran` and `export FLUPRO=<path to where you unzipped the files>`. Note that the `FLUPRO` directory should contain __libflukahp.a__. Both of these variables will have to be set every time you open a new terminal.
+ 6. Go to the `FLUPRO` directory and run `make`. This will compile an exe, __flukahp__, in your current directory.
+ 7. Follow the normal steps to compile CORSIKA 8 (see below).
+
+When you later install CORSIKA 8, you should see a message during the __cmake__ step indicating the FLUKA was correctly found.
+
+``` shell
+libflukahp.a found in directory <some location here> via FLUPRO environment variable
+FLUKA support is enabled.
+```
+
+### Compiling CORSIKA 8
+
+Once Conan is installed and FLUKA provided, follow these steps to download and install CORSIKA 8:
+
+``` shell
+cd ./top/directory/for/corsika/installation
+git clone --recursive git@gitlab.iap.kit.edu:AirShowerPhysics/corsika.git
+# Or for https: git clone --recursive https://gitlab.iap.kit.edu/AirShowerPhysics/corsika.git
+mkdir corsika-build
+cd corsika-build
+../corsika/conan-install.sh --source-directory ../corsika --release-with-debug
+# conan-install.sh takes required options from command line to install dependencies for 'Debug', 'Release' and 'RelWithDebInfo' builds.
+../corsika/corsika-cmake.sh -c "-DCMAKE_BUILD_TYPE="RelWithDebInfo" -DWITH_FLUKA=ON -DCMAKE_INSTALL_PREFIX=../corsika-install"
+make -j4  #The number should match the number of available cores on your machine
+make install
+```
+
+## Alternate installation using docker containers
+
+There are docker containers prepared that bring all the environment and packages you need to run CORSIKA. See [docker hub](https://hub.docker.com/repository/docker/corsika/devel) for a complete overview.
+
+### Prerequisites
+
+You only need docker, e.g. on Ubuntu: `sudo apt-get install docker` and of course root access.
+
+### Compiling
+
+Follow these steps to download and install CORSIKA 8, master development version
+```shell
+cd ./top/directory/for/corsika/installation
+git clone --recursive git@gitlab.iap.kit.edu:AirShowerPhysics/corsika.git
+sudo docker run -v $PWD:/corsika -it corsika/devel:clang-8 /bin/bash
+mkdir corsika-build
+cd corsika-build
+../corsika/conan-install.sh --source-directory ../corsika --release-with-debug
+# conan-install.sh takes required options from command line to install dependencies for 'Debug', 'Release' and 'RelWithDebInfo' builds.
+../corsika/corsika-cmake.sh -c "-DCMAKE_BUILD_TYPE="RelWithDebInfo" -DWITH_FLUKA=ON -DCMAKE_INSTALL_PREFIX=../corsika-install"
+make -j4  #The number should match the number of available cores on your machine
+make install
+```
+
+## Running Unit Tests
+
+To run the unit tests, do the following.
+
+```shell
+cd ./corsika-build
+ctest -j4  #The number should match the number of available cores on your machine
+```
+
+## Running applications and examples
+
+### Standard applications
+
+Applications for standard use-cases are located in the `applications` directory.
+These are example scripts that can be used directly or slightly modified for your use case.
+See [applications/README.md] for more.
+The applications are compiled automatically after running `make` and will appear your `corsika-build/bin` directory.
+After running `make install` the binaries will also be copied into your `corsika-install/bin` directory as well.
+
+
+For example, from inside your `corsika-install/bin` directory, run
+```shell
+c8_air_shower --pdg 2212 -E 1e5 -f my_shower
+```
+This will run a vertical 100 TeV proton shower and will create and put the output into `./my_shower`.
+
+
+### Building the examples
+
+Unlike the applications, the examples must be compiled as a second step.
+From your top corsika directory, (the one that includes `corsika-build` and `corsika-install`) run
+```shell
+export CONAN_DEPENDENCIES=$PWD/corsika-install/lib/cmake/dependencies
+cmake -DCMAKE_TOOLCHAIN_FILE=${CONAN_DEPENDENCIES}/conan_toolchain.cmake -DCMAKE_PREFIX_PATH=${CONAN_DEPENDENCIES} -DCMAKE_POLICY_DEFAULT_CMP0091=NEW -DCMAKE_BUILD_TYPE=RelWithDebInfo -Dcorsika_DIR=$PWD/corsika-build -DWITH_FLUKA=ON -S $PWD/corsika/examples -B $PWD/corsika-build-examples
+cd corsika-build-examples
+make -j4 #The number should match the number of available cores on your machine
+```
+
+You can run the examples by using the binaries in `corsika-build-examples/bin/`.
+For example:
+```shell
+corsika-build-examples/bin/known_particles
+```
+This will print out all of the particles that are known by CORSIKA.
+
+
+### Generating doxygen documentation
+
+To generate the documentation, you need doxygen and graphviz. If you work with
+the docker corsika/devel containers this is already included.
+Otherwise, e.g. on Ubuntu machines, do:
+```shell
+sudo apt-get install doxygen graphviz
+```
+Switch to the `corsika-build` directory and do
+```shell
+make docs
+make install
+```
+open with firefox:
+```shell
+firefox ../corsika-install/share/corsika/doc/html/index.html
+```

USING_COLLABORATING.md

+# Usage and collaboration agreement
+
+The CORSIKA 8 project very much welcomes all collaboration and
+contributions. The aim of the project is to create a
+scientific software framework as a fundamental tool for research.
+
+The project consists of the contributions from the scientific
+community and individuals in a best effort to deliver the best
+possible performance and physics output. 
+
+
+## The software license of the CORSIKA project
+
+CORSIKA 8 is by default released under the BSD 3-Clause License, as copied in full in the file
+[LICENSE](LICENSE). Each source file of the CORSIKA project contains a
+short statement of the copyright and this license. Each binary or
+source code release of CORSIKA contains the file LICENSE.
+
+The code, documentation and content in the folder [./externals](./externals)
+is not integral part of the CORSIKA project and can be based on, or
+include, other licenses, which must be compatible with the CORSIKA 8 license. 
+
+The folder [./modules](./modules) contains the code of several
+external physics models for your convenience. They each come with
+their own license which we ask you to honor.  Please also make sure to cite the
+adequate reference papers when using their models in scientific work
+and publications.
+
+Of course, we have the authors' consent to
+distribute their code together with CORSIKA 8. 
+
+Check the content of these folders carefully for details and additional 
+license information. It depends on the configuration of
+the build system to what extent this code is used to build CORSIKA.
+
+
+## Contributing
+
+If you want to contribute, you need to read
+[the contributing GUIDELINES](CONTRIBUTING.md) and comply with these rules, or help to
+improve them. 
+
+
+## General guidelines
+
+We reproduce below some guidelines copied from  http://www.montecarlonet.org/ that we also ask you to follow in the spirit of academic collaboration.
+
+1) The integrity of the program should be respected.
+    -------------------------------------------------
+
+1.1) Suspected bugs and proposed fixes should be reported back to the
+    original authors to be considered for inclusion in the standard
+    distribution.  No independently developed and maintained forks
+    should be created as long as the original authors actively work on
+    the program.
+
+1.2) The program should normally be redistributed in its entirety.
+    When there are special reasons, an agreement should be sought with
+    the original authors to redistribute only specific parts. This
+    should be arranged such that the redistributed parts remain
+    updated in step with the standard distribution.
+
+1.3) Any changes in the code must be clearly marked in the source
+   (reason, author, date) and documented. If any modified version is
+   redistributed it should be stated at the point of distribution
+   (download link) that it has been modified and why.
+
+1.4) If a significant part of the code is used by another program,
+    this should be clearly specified in that program's documentation and
+    stated at its point of distribution.
+
+1.5) Copyright information and references may not be removed.
+    Copyright-related program messages may not be altered and must be
+    printed even if only a part of the program is used. Adding further
+    messages specifying any modifications is encouraged.
+
+
+2) The program and its physics should be properly cited when used for
+    academic publications
+    ------------------------------------------------------------------
+
+2.1) The main software reference as designated by the program authors
+    should always be cited.
+
+2.2) In addition, the original literature on which the program is based
+    should be cited to the extent that it is of relevance for a study,
+    applying the same threshold criteria as for other literature.
+
+2.3) When several programs are combined, they should all be mentioned,
+    commensurate with their importance for the physics study at hand.
+
+2.4) To make published results reproducible, the exact versions of the
+    codes that were used and any relevant program and parameter
+    modifications should be spelled out.
+
+
+(These guidelines were originally edited by Nils Lavesson and David Grellscheid
+for the MCnet collaboration, which has approved and agreed to respect
+them.  MCnet is a Marie Curie Research Training Network funded under
+Framework Programme 6 contract MRTN-CT-2006-035606.)

applications/CMakeLists.txt

+SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")
+
+add_executable (c8_air_shower c8_air_shower.cpp)
+target_link_libraries (c8_air_shower CORSIKA8)
+
+if(WITH_FLUKA)
+  message("compiling c8_air_shower.cpp with FLUKA")
+  target_compile_definitions(c8_air_shower PRIVATE WITH_FLUKA)
+else()
+  message("compiling c8_air_shower.cpp with UrQMD")
+endif()
+
+install (
+  TARGETS c8_air_shower DESTINATION bin
+)

applications/README.md

+# CORSIKA 8 Applications
+
+This directory contains standard applications which are typical for astroparticle physics solutions.
+They are "physics-complete" and are suitable for generating simulations that can be used in publications.
+
+For example, `c8_air_shower.cpp` would be a similar binary to what would be built by CORSIKA 7 and will simulate
+air showers in a curved atmosphere.

cmake/CodeCoverage

+# Copyright (c) 2012 - 2017, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# CHANGES:
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-02-03, Lars Bilke
+# - Refactored functions to use named parameters
+#
+# 2017-06-02, Lars Bilke
+# - Merged with modified version from github.com/ufz/ogs
+#
+#
+# USAGE:
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      include(CodeCoverage)
+#
+# 3. Append necessary compiler flags:
+#      APPEND_COVERAGE_COMPILER_FLAGS()
+#
+# 4. If you need to exclude additional directories from the report, specify them
+#    using the COVERAGE_LCOV_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE_LCOV.
+#    Example:
+#      set(COVERAGE_LCOV_EXCLUDES 'dir1/*' 'dir2/*')
+#
+# 5. Use the functions described below to create a custom make target which
+#    runs your test executable and produces a code coverage report.
+#
+# 6. Build a Debug build:
+#      cmake -DCMAKE_BUILD_TYPE=Debug ..
+#      make
+#      make my_coverage_target
+#
+
+include(CMakeParseArguments)
+
+# Check prereqs
+find_program( GCOV_PATH gcov )
+find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
+find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
+find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program( SIMPLE_PYTHON_EXECUTABLE python )
+
+if(NOT GCOV_PATH)
+    message(FATAL_ERROR "gcov not found! Aborting...")
+endif() # NOT GCOV_PATH
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+        message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+    endif()
+elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
+    message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+endif()
+
+set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE INTERNAL "")
+
+set(CMAKE_CXX_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+set(CMAKE_C_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+mark_as_advanced(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
+endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+    link_libraries(gcov)
+else()
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+endif()
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_LCOV(
+#     NAME testrunner_coverage                    # New target name
+#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES testrunner                     # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_LCOV)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT LCOV_PATH)
+        message(FATAL_ERROR "lcov not found! Aborting...")
+    endif() # NOT LCOV_PATH
+
+    if(NOT GENHTML_PATH)
+        message(FATAL_ERROR "genhtml not found! Aborting...")
+    endif() # NOT GENHTML_PATH
+
+    # Setup target
+    add_custom_target(${Coverage_NAME}
+
+        # Cleanup lcov
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -directory . --zerocounters
+        # Create baseline to make sure untouched files show up in the report
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -c -i -d . -o ${Coverage_NAME}.base
+
+        # Run tests
+        COMMAND ${Coverage_EXECUTABLE}
+
+        # Capturing lcov counters and generating report
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info
+        # add baseline counters
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base -a ${Coverage_NAME}.info --output-file ${Coverage_NAME}.total
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} --remove ${Coverage_NAME}.total ${COVERAGE_LCOV_EXCLUDES} --output-file ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+        COMMAND ${GENHTML_PATH} -o ${Coverage_NAME} ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+        COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.base ${Coverage_NAME}.total ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+    )
+
+    # Show where to find the lcov info report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_LCOV
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_GCOVR_XML(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_GCOVR_XML)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT SIMPLE_PYTHON_EXECUTABLE)
+        message(FATAL_ERROR "python not found! Aborting...")
+    endif() # NOT SIMPLE_PYTHON_EXECUTABLE
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDES "-e")
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+
+    add_custom_target(${Coverage_NAME}
+        # Run tests
+        ${Coverage_EXECUTABLE}
+
+        # Running gcovr
+        COMMAND ${GCOVR_PATH} --xml
+            -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
+            --object-directory=${PROJECT_BINARY_DIR}
+            -o ${Coverage_NAME}.xml
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Running gcovr to produce Cobertura code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_XML
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT SIMPLE_PYTHON_EXECUTABLE)
+        message(FATAL_ERROR "python not found! Aborting...")
+    endif() # NOT SIMPLE_PYTHON_EXECUTABLE
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDES "-e")
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+
+    add_custom_target(${Coverage_NAME}
+        # Run tests
+        ${Coverage_EXECUTABLE}
+
+        # Create folder
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
+
+        # Running gcovr
+        COMMAND ${GCOVR_PATH} --html --html-details
+            -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
+            --object-directory=${PROJECT_BINARY_DIR}
+            -o ${Coverage_NAME}/index.html
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Running gcovr to produce HTML code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML
+
+function(APPEND_COVERAGE_COMPILER_FLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
+endfunction() # APPEND_COVERAGE_COMPILER_FLAGS

cmake/CodeCoverage.cmake

+# Copyright (c) 2012 - 2017, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# CHANGES:
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-02-03, Lars Bilke
+# - Refactored functions to use named parameters
+#
+# 2017-06-02, Lars Bilke
+# - Merged with modified version from github.com/ufz/ogs
+#
+#
+# USAGE:
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt:
+#      include(CodeCoverage)
+#
+# 3. Append necessary compiler flags:
+#      APPEND_COVERAGE_COMPILER_FLAGS()
+#
+# 4. If you need to exclude additional directories from the report, specify them
+#    using the COVERAGE_LCOV_EXCLUDES variable before calling SETUP_TARGET_FOR_COVERAGE_LCOV.
+#    Example:
+#      set(COVERAGE_LCOV_EXCLUDES 'dir1/*' 'dir2/*')
+#
+# 5. Use the functions described below to create a custom make target which
+#    runs your test executable and produces a code coverage report.
+#
+# 6. Build a Debug build:
+#      cmake -DCMAKE_BUILD_TYPE=Debug ..
+#      make
+#      make my_coverage_target
+#
+
+include(CMakeParseArguments)
+
+# Check prereqs
+find_program( GCOV_PATH gcov )
+find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
+find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
+find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
+find_program( SIMPLE_PYTHON_EXECUTABLE python )
+
+if(NOT GCOV_PATH)
+    message(FATAL_ERROR "gcov not found! Aborting...")
+endif() # NOT GCOV_PATH
+
+if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 3)
+        message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
+    endif()
+elseif(NOT CMAKE_COMPILER_IS_GNUCXX)
+    message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...")
+endif()
+
+set(COVERAGE_COMPILER_FLAGS "-g -O0 --coverage -fprofile-arcs -ftest-coverage"
+    CACHE INTERNAL "")
+
+set(CMAKE_CXX_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+set(CMAKE_C_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+mark_as_advanced(
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
+endif() # NOT CMAKE_BUILD_TYPE STREQUAL "Debug"
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+    link_libraries(gcov)
+else()
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+endif()
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_LCOV(
+#     NAME testrunner_coverage                    # New target name
+#     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES testrunner                     # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_LCOV)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT LCOV_PATH)
+        message(FATAL_ERROR "lcov not found! Aborting...")
+    endif() # NOT LCOV_PATH
+
+    if(NOT GENHTML_PATH)
+        message(FATAL_ERROR "genhtml not found! Aborting...")
+    endif() # NOT GENHTML_PATH
+
+    # Setup target
+    add_custom_target(${Coverage_NAME}
+
+        # Cleanup lcov
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -directory . --zerocounters
+        # Create baseline to make sure untouched files show up in the report
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -c -i -d . -o ${Coverage_NAME}.base
+
+        # Run tests
+        COMMAND ${Coverage_EXECUTABLE}
+
+        # Capturing lcov counters and generating report
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} --directory . --capture --output-file ${Coverage_NAME}.info
+        # add baseline counters
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base -a ${Coverage_NAME}.info --output-file ${Coverage_NAME}.total
+        COMMAND ${LCOV_PATH} --gcov-tool ${GCOV_PATH} --remove ${Coverage_NAME}.total ${COVERAGE_LCOV_EXCLUDES} --output-file ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+        COMMAND ${GENHTML_PATH} -o ${Coverage_NAME} ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+        COMMAND ${CMAKE_COMMAND} -E remove ${Coverage_NAME}.base ${Coverage_NAME}.total ${PROJECT_BINARY_DIR}/${Coverage_NAME}.info.cleaned
+
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
+    )
+
+    # Show where to find the lcov info report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_LCOV
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_GCOVR_XML(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_GCOVR_XML)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT SIMPLE_PYTHON_EXECUTABLE)
+        message(FATAL_ERROR "python not found! Aborting...")
+    endif() # NOT SIMPLE_PYTHON_EXECUTABLE
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDES "-e")
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+
+    add_custom_target(${Coverage_NAME}
+        # Run tests
+        ${Coverage_EXECUTABLE}
+
+        # Running gcovr
+        COMMAND ${GCOVR_PATH} --xml
+            -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
+            --object-directory=${PROJECT_BINARY_DIR}
+            -o ${Coverage_NAME}.xml
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Running gcovr to produce Cobertura code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_XML
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+# )
+function(SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML)
+
+    set(options NONE)
+    set(oneValueArgs NAME)
+    set(multiValueArgs EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(NOT SIMPLE_PYTHON_EXECUTABLE)
+        message(FATAL_ERROR "python not found! Aborting...")
+    endif() # NOT SIMPLE_PYTHON_EXECUTABLE
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "gcovr not found! Aborting...")
+    endif() # NOT GCOVR_PATH
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDES "")
+    foreach(EXCLUDE ${COVERAGE_GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDES "-e")
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+
+    add_custom_target(${Coverage_NAME}
+        # Run tests
+        ${Coverage_EXECUTABLE}
+
+        # Create folder
+        COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
+
+        # Running gcovr
+        COMMAND ${GCOVR_PATH} --html --html-details
+            -r ${PROJECT_SOURCE_DIR} ${GCOVR_EXCLUDES}
+            --object-directory=${PROJECT_BINARY_DIR}
+            -o ${Coverage_NAME}/index.html
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        COMMENT "Running gcovr to produce HTML code coverage report."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
+    )
+
+endfunction() # SETUP_TARGET_FOR_COVERAGE_GCOVR_HTML
+
+function(APPEND_COVERAGE_COMPILER_FLAGS)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
+endfunction() # APPEND_COVERAGE_COMPILER_FLAGS

cmake/FindCONEX.cmake

+#
+# (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+#
+# See file AUTHORS for a list of contributors.
+#
+# This software is distributed under the terms of the 3-clause BSD license.
+# See file LICENSE for a full version of the license.
+#
+
+# - find Conex
+#
+# This module defines
+# CONEX_PREFIX
+# CONEX_INCLUDE_DIR
+# CONEX_LIBRARY
+
+set (SEARCH_conex_
+  ${WITH_CONEX}
+  ${CONEXROOT}
+  ${CONEX_ROOT}
+  $ENV{CONEXROOT}
+  $ENV{CONEX_ROOT}
+  )
+
+find_path (CONEX_PREFIX
+  NAMES lib/${CMAKE_SYSTEM_NAME}
+  PATHS ${SEARCH_conex_}
+  DOC "The CONEX root directory"
+  NO_DEFAULT_PATH
+  )
+
+find_path (CONEX_INCLUDE_DIR
+  NAMES ConexDynamicInterface.h
+  PATHS ${CONEX_PREFIX}
+  PATH_SUFFIXES src
+  DOC "The CONEX include directory"
+  )
+
+find_library (CONEX_LIBRARY
+  NAMES libCONEXdynamic.a
+  PATHS ${CONEX_PREFIX}
+  PATH_SUFFIXES lib/${CMAKE_SYSTEM_NAME}
+  DOC "The CONEX library"
+  )
+
+# standard cmake infrastructure:
+include (FindPackageHandleStandardArgs)
+find_package_handle_standard_args (CONEX
+  "Did not find system-level CONEX."
+  CONEX_INCLUDE_DIR CONEX_LIBRARY CONEX_PREFIX)
+mark_as_advanced (CONEX_INCLUDE_DIR CONEX_LIBRARY CONEX_PREFIX)

cmake/FindPhysUnits.cmake

+#
+# (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
+#
+# See file AUTHORS for a list of contributors.
+#
+# This software is distributed under the terms of the 3-clause BSD license.
+# See file LICENSE for a full version of the license.
+#
+
+add_library (PhysUnits INTERFACE)
+
+target_compile_options (PhysUnits
+  INTERFACE
+  -I${CMAKE_SOURCE_DIR}/externals/phys_units
+  )
+
+set (PhysUnits_FOUND True)

cmake/FindPythia8.cmake

+#
+# (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
+#
+# See file AUTHORS for a list of contributors.
+#
+# This software is distributed under the terms of the 3-clause BSD license.
+# See file LICENSE for a full version of the license.
+#
+
+#################################################
+#
+# run pythia8-config and interpret result
+#
+
+function (_Pythia8_CONFIG_ option variable type doc)
+  execute_process (COMMAND ${Pythia8_CONFIG} ${option}
+    OUTPUT_VARIABLE _local_out_
+    RESULT_VARIABLE _local_res_)
+  string (REGEX REPLACE "\n$" "" _local_out_ "${_local_out_}")
+  if (NOT ${_local_res_} EQUAL 0)
+    message ("Error in running ${Pythia8_CONFIG} ${option}")
+  else ()
+    set (${variable} "${_local_out_}" CACHE ${type} ${doc})
+  endif ()
+endfunction (_Pythia8_CONFIG_)
+  
+#################################################
+#
+# take directory and assume standard install layout
+#
+
+function (_Pythia8_LAYOUT_ dir variable type doc)
+  set (${variable} "${dir}" CACHE ${type} ${doc})
+endfunction (_Pythia8_LAYOUT_)
+
+
+#################################################
+# 
+# Searched Pythia8 on system. Expect pythia8-config in PATH, or typical installation location
+#
+# This module defines
+# HAVE_Pythia8
+# Pythia8_INCLUDE_DIR   where to locate Pythia.h file
+# Pythia8_LIBRARY       where to find the libpythia8 library
+# Pythia8_LIBRARIES     (not cached) the libraries to link against to use Pythia8
+# Pythia8_VERSION       version of Pythia8 if found
+#
+
+set (_SEARCH_Pythia8_
+  ${PROJECT_BINARY_DIR}/ThirdParty/pythia8-install
+  ${PYTHIA8}
+  $ENV{PYTHIA8}
+  ${PYTHIA8DIR}
+  $ENV{PYTHIA8DIR}
+  ${PYTHIA8_ROOT}
+  $ENV{PYTHIA8_ROOT}
+  ${PYTHIA8_DIR}
+  $ENV{PYTHIA8_DIR}
+  ${Pythia8_DIR}
+  $ENV{Pythia8_DIR}
+  /opt/pythia8
+  )
+
+find_file (Pythia8_Pythia_h_LOC
+  NAME Pythia.h
+  PATHS ${_SEARCH_Pythia8_}
+  PATH_SUFFIXES include/Pythia8
+  DOC "The location of the Pythia8/Pythia.h script"
+  REQUIRED)
+
+if ("${Pythia8_Pythia_h_LOC}" STREQUAL "Pythia8_Pythia_h_LOC-NOTFOUND")
+  message (FATAL_ERROR "Did not find SYSTEM-level Pythia8 in: \"${_SEARCH_Pythia8_}\"")
+endif ()
+
+string (REPLACE "/include/Pythia8/Pythia.h" "" Pythia8_DIR ${Pythia8_Pythia_h_LOC})
+
+set (Pythia8_CONFIG ${Pythia8_DIR}/bin/pythia-config)
+if (Pythia8_CONFIG)
+  set (HAVE_Pythia8 1 CACHE BOOL "presence of pythia8, found via pythia8-config")
+
+  # pythia-config is not relocatable
+  #_Pythia8_CONFIG_ ("--prefix" Pythia8_PREFIX PATH "location of pythia8 installation")
+  #_Pythia8_CONFIG_ ("--includedir" Pythia8_INCLUDE_DIR PATH "pythia8 include directory")
+  #_Pythia8_CONFIG_ ("--libdir" Pythia8_LIBRARY STRING "the pythia8 libs")
+  #_Pythia8_CONFIG_ ("--datadir" Pythia8_DATA_DIR PATH "the pythia8 data dir")
+  _Pythia8_LAYOUT_ ("${Pythia8_DIR}" Pythia8_PREFIX PATH "location of pythia8 installation")
+  _Pythia8_LAYOUT_ ("${Pythia8_DIR}/include" Pythia8_INCLUDE_DIR PATH "pythia8 include directory")
+  _Pythia8_LAYOUT_ ("${Pythia8_DIR}/lib" Pythia8_LIBRARY STRING "the pythia8 libs")
+  _Pythia8_LAYOUT_ ("${Pythia8_DIR}/share/Pythia8/xmldoc" Pythia8_DATA_DIR PATH "the pythia8 data dir")
+  
+  # read the config string
+  file (READ "${Pythia8_INCLUDE_DIR}/Pythia8/Pythia.h" Pythia8_TMP_PYTHIA_H)
+  string (REGEX MATCH "#define PYTHIA_VERSION_INTEGER ([0-9]*)" _ ${Pythia8_TMP_PYTHIA_H})  
+  set (Pythia8_VERSION ${CMAKE_MATCH_1})
+  message (STATUS "Found Pythia8 version: ${Pythia8_VERSION}")
+  
+endif ()
+
+# standard cmake infrastructure:
+include (FindPackageHandleStandardArgs)
+find_package_handle_standard_args (Pythia8 REQUIRED_VARS Pythia8_PREFIX Pythia8_INCLUDE_DIR Pythia8_LIBRARY VERSION_VAR Pythia8_VERSION)
+mark_as_advanced (Pythia8_DATA_DIR Pythia8_INCLUDE_DIR Pythia8_LIBRARY)

cmake/FindSphinx.cmake

+#
+# (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
+#
+# See file AUTHORS for a list of contributors.
+#
+# This software is distributed under the terms of the 3-clause BSD license.
+# See file LICENSE for a full version of the license.
+#
+
+# Look for an executable called sphinx-build
+find_program (SPHINX_EXECUTABLE
+              NAMES sphinx-build
+              DOC "Path to sphinx-build executable")
+
+include (FindPackageHandleStandardArgs)
+
+#Handle standard arguments to find_package like REQUIRED and QUIET
+find_package_handle_standard_args (Sphinx
+                                  "Failed to find sphinx-build executable"
+                                  SPHINX_EXECUTABLE)

cmake/corsikaConfig.cmake.in

+#
+# (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
+#
+# See file AUTHORS for a list of contributors.
+#
+# This software is distributed under the terms of the 3-clause BSD license.
+# See file LICENSE for a full version of the license.
+#
+
+set (CORSIKA8_VERSION @c8_version@)
+
+@PACKAGE_INIT@
+
+#+++++++++++++++++++++++++++++
+# Setup hardware and infrastructure dependent defines and other setting
+#
+include (${CMAKE_CURRENT_LIST_DIR}/corsikaDefines.cmake)
+
+#+++++++++++++++++++++++++++
+# Options
+#
+option (WITH_HISTORY "Flag to switch on/off HISTORY" ON)
+  
+#++++++++++++++++++++++++++++
+# General config and flags
+#
+set (CMAKE_CXX_STANDARD @CMAKE_CXX_STANDARD@)
+set (CMAKE_CXX_EXTENSIONS @CMAKE_CXX_EXTENSIONS@)
+set (COMPILE_OPTIONS @COMPILE_OPTIONS@)
+set (CMAKE_VERBOSE_MAKEFILE  @CMAKE_VERBOSE_MAKEFILE@) 
+
+#+++++++++++++++++++++++++++++
+# external dependencies
+# same list as top-level CML.txt, except for Catch2 (not needed here)
+#
+find_package(Boost COMPONENTS filesystem REQUIRED)
+find_package(CLI11 REQUIRED)
+find_package(Eigen3 REQUIRED)
+find_package(spdlog REQUIRED)
+find_package(yaml-cpp REQUIRED)
+find_package(Arrow REQUIRED)
+find_package(PROPOSAL REQUIRED)
+
+#+++++++++++++++++++++++++++++
+# Import Pythia8
+# since we always import pythia (ExternalProject_Add) we have to
+# import here, too.
+#
+add_library (C8::ext::pythia8 STATIC IMPORTED GLOBAL)
+set_target_properties (
+  C8::ext::pythia8 PROPERTIES
+  IMPORTED_LOCATION @Pythia8_LIBDIR@/libpythia8.a
+  IMPORTED_LINK_INTERFACE_LIBRARIES dl
+  INTERFACE_INCLUDE_DIRECTORIES @Pythia8_INCDIR@
+  )
+set (Pythia8_FOUND @Pythia8_FOUND@)
+message (STATUS "Pythia8 at: @Pythia8_PREFIX@")
+
+#+++++++++++++++++++++++++++++
+# Import TAUOLA
+# since we always import TAUOLA (ExternalProject_Add) we have to
+# import here, too.
+#
+add_library (C8::ext::tauola::CxxInterface STATIC IMPORTED GLOBAL)
+add_library (C8::ext::tauola::Fortran STATIC IMPORTED GLOBAL)
+add_library(C8::ext::tauola INTERFACE IMPORTED)
+set_property(TARGET C8::ext::tauola 
+    PROPERTY
+    INTERFACE_LINK_LIBRARIES 
+    C8::ext::tauola::CxxInterface
+    C8::ext::tauola::Fortran)
+set_target_properties (
+  C8::ext::tauola::CxxInterface PROPERTIES
+  IMPORTED_LOCATION @TAUOLA_LIBDIR@/libTauolaCxxInterface.a
+  IMPORTED_LINK_INTERFACE_LIBRARIES dl
+  INTERFACE_INCLUDE_DIRECTORIES @TAUOLA_INCDIR@
+  )
+set_target_properties (
+  C8::ext::tauola::Fortran PROPERTIES
+  IMPORTED_LOCATION @TAUOLA_LIBDIR@/libTauolaFortran.a
+  IMPORTED_LINK_INTERFACE_LIBRARIES dl
+  INTERFACE_INCLUDE_DIRECTORIES @TAUOLA_INCDIR@
+  )
+
+set (TAUOLA_FOUND @TAUOLA_FOUND@)
+message (STATUS "TAUOLA at: @TAUOLA_PREFIX@")
+
+
+#++++++++++++++++++++++++++++++
+# import CORSIKA8
+#     
+include ("${CMAKE_CURRENT_LIST_DIR}/corsikaTargets.cmake")
+check_required_components (corsika)
+
+
+#+++++++++++++++++++++++++++++++
+# add further definitions / options
+#
+if (WITH_HISTORY)
+  set_property (
+    TARGET CORSIKA8::CORSIKA8
+    APPEND PROPERTY
+    INTERFACE_COMPILE_DEFINITIONS "WITH_HISTORY"
+  )
+endif (WITH_HISTORY)
+  
+
+
+#+++++++++++++++++++++++++++++++
+#
+# final summary output
+#
+include (FeatureSummary)
+add_feature_info (HISTORY WITH_HISTORY "Full information on cascade history for particles.")
+feature_summary (WHAT ALL)

cmake/corsikaDefines.cmake

+#
+# (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
+#
+# See file AUTHORS for a list of contributors.
+#
+# This software is distributed under the terms of the 3-clause BSD license.
+# See file LICENSE for a full version of the license.
+#
+
+
+#+++++++++++++++++++++++++++++
+# as long as there still are modules using it:
+#
+enable_language (Fortran)
+set (CMAKE_Fortran_FLAGS "-std=legacy -Wfunction-elimination")
+
+
+#+++++++++++++++++++++++++++++
+# Build types settings
+#
+# setup coverage build type
+set (CMAKE_CXX_FLAGS_COVERAGE "-g --coverage")
+set (CMAKE_EXE_LINKER_FLAGS_COVERAGE "--coverage")
+set (CMAKE_SHARED_LINKER_FLAGS_COVERAGE "--coverage")
+# set a flag to inform code that we are in debug mode
+set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -D_C8_DEBUG_")
+
+
+#+++++++++++++++++++++++++++++
+# Build type selection
+#
+# Set the possible values of build type for cmake-gui and command line check
+set (ALLOWED_BUILD_TYPES Debug Release MinSizeRel RelWithDebInfo Coverage)
+set_property (CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${ALLOWED_BUILD_TYPES})
+
+set (DEFAULT_BUILD_TYPE "Release")
+if (EXISTS "${CMAKE_SOURCE_DIR}/.git")
+  set (DEFAULT_BUILD_TYPE "Debug")
+endif ()
+
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message (STATUS "Setting build type to '${DEFAULT_BUILD_TYPE}' as no other was specified.")
+  set (CMAKE_BUILD_TYPE "${DEFAULT_BUILD_TYPE}" CACHE
+      STRING "Choose the type of build." FORCE)
+else (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  # Ignore capitalization when build type is selected manually and check for valid setting
+  string (TOLOWER ${CMAKE_BUILD_TYPE} SELECTED_LOWER)
+  string (TOLOWER "${ALLOWED_BUILD_TYPES}" BUILD_TYPES_LOWER)
+  if (NOT SELECTED_LOWER IN_LIST BUILD_TYPES_LOWER)
+    message (FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE} [allowed: ${ALLOWED_BUILD_TYPES}]")
+  endif ()
+  message (STATUS "Build type is: ${CMAKE_BUILD_TYPE}")
+endif (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+
+
+
+#
+# Floating point exception support - select implementation to use
+#
+include (CheckIncludeFileCXX)
+CHECK_INCLUDE_FILE_CXX ("fenv.h" HAS_FEENABLEEXCEPT)
+if (HAS_FEENABLEEXCEPT) # FLOATING_POINT_ENVIRONMENT
+    set (CORSIKA_HAS_FEENABLEEXCEPT 1)
+    set_property (DIRECTORY ${CMAKE_HOME_DIRECTORY} APPEND PROPERTY COMPILE_DEFINITIONS "CORSIKA_HAS_FEENABLEEXCEPT")
+endif ()
+
+
+#
+# General OS Detection
+#
+if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+    set (CORSIKA_OS_WINDOWS TRUE)
+    set (CORSIKA_OS "Windows")
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    set (CORSIKA_OS_LINUX TRUE)
+    set (CORSIKA_OS "Linux")
+    # check for RedHat/CentOS compiler from the software collections (scl)
+    string (FIND ${CMAKE_CXX_COMPILER} "/opt/rh/devtoolset-" index)
+    if (${index} EQUAL 0)
+      set (CORSIKA_SCL_CXX TRUE)
+    endif ()
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    set (CORSIKA_OS_MAC TRUE)  
+    set (CORSIKA_OS "Mac") 
+endif ()

cmake/corsikaUtilities.cmake

+#
+# (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
+#
+# See file AUTHORS for a list of contributors.
+#
+# This software is distributed under the terms of the 3-clause BSD license.
+# See file LICENSE for a full version of the license.
+#
+
+#################################################
+#
+# central macro to register unit tests in cmake
+#
+# 1) Simple use:
+# Pass the name of the test.cc file as the first
+# argument, without the ".cc" extention.
+#
+# Example: CORSIKA_ADD_TEST (testSomething)
+#
+# This generates target testSomething from file testSomething.cc.
+#
+# 2) Customize sources:
+# If 1) doesn't work, use the SOURCES keyword to explicitly
+# specify the sources.
+#
+# Example: CORSIKA_ADD_TEST (testSomething
+#              SOURCES source1.cc source2.cc someheader.h)
+#
+# 3) Customize sanitizers:
+# You can override which sanitizers are compiled into the
+# test, but only do this if the defaults do not work.
+#
+# Example: CORSIKA_ADD_TEST (testSomething SANITIZE undefined)
+#
+# Only uses the sanitizer for undefined behavior.
+#
+# In all cases, you can further customize the target with
+# target_link_libraries(testSomething ...) and so on.
+#
+# TEMPORARY: All sanitizers are currently globally disabled by default, to enable them,
+# set CORSIKA_SANITIZERS_ENABLED to TRUE.
+function (CORSIKA_ADD_TEST)
+  cmake_parse_arguments (PARSE_ARGV 1 C8_ADD_TEST "" "SANITIZE" "SOURCES")
+  set (name ${ARGV0})
+
+  if (NOT C8_ADD_TEST_SOURCES)
+    set (sources ${name}.cc)
+  else ()
+    set (sources ${C8_ADD_TEST_SOURCES})
+  endif ()
+
+  if (NOT C8_ADD_TEST_SANITIZE)
+    set(sanitize "address,undefined")
+  else ()
+    set(sanitize ${C8_ADD_TEST_SANITIZE})
+  endif ()
+ 
+  find_package(Catch2 REQUIRED)
+  add_executable (${name} ${sources})
+  target_link_libraries (${name} CORSIKA8 Catch2::Catch2WithMain CorsikaTestingCommon)
+  target_compile_options (${name} PRIVATE -g) # do not skip asserts
+  target_include_directories (${name} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+  file (MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/test_outputs/)
+  if (CORSIKA_SANITIZERS_ENABLED)
+    # -O1 is suggested in clang docs to get reasonable performance
+    target_compile_options (${name} PRIVATE -O1 -fno-omit-frame-pointer -fsanitize=${sanitize} -fno-sanitize-recover=all)
+    set_target_properties (${name} PROPERTIES LINK_FLAGS "-fsanitize=${sanitize}")
+  endif ()
+  add_test (NAME ${name} COMMAND ${name} -o ${PROJECT_BINARY_DIR}/test_outputs/junit-${name}.xml -s -r junit)
+endfunction (CORSIKA_ADD_TEST)

conan-install.sh

+#!/bin/bash
+
+
+function show_usage(){
+    printf "\n\nUsage:"
+    printf "$0 options [parameters]\n"
+    printf "\n"
+    printf "Options:\n"
+    printf "\n -s or --source-directory:\n Corsika 8 download directory, which contains the 'conanfile.py' recipe. Default is the current directory."
+    printf "\n -d or --debug:\n Specify 'Debug' as build type for the installed dependences. This should be matched when building CORSIKA 8."
+    printf "\n -r or --release:\n Specify 'Release' as build type for the installed dependences. This should be matched when building CORSIKA 8."
+    printf "\n -rd or --release-with-debug:\n Specify 'RelWithDebInfo' as build type for the installed dependences. This should be matched when building CORSIKA 8."
+    printf "\n\nExample: ./conan-install.sh --source-directory /some_path/corsika --debug"
+    printf "\n -h or --help:\n Prints this message.\n"
+
+exit 0
+}
+
+echo "|---------------------------------------------------|"
+echo "|-----------------[ CORSIKA 8 ]---------------------|"
+echo "|-----[ CONAN2 DEPENDENCIES INSTALL SCRIPT ]------- |"
+echo "|---------------------------------------------------|"
+echo "|-------------------- BEGIN ------------------------| "
+
+echo " "
+
+SOURCE=${BASH_SOURCE[0]}
+while [ -L "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+  DIR=$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )
+  SOURCE=$(readlink "$SOURCE")
+  [[ $SOURCE != /* ]] && SOURCE=$DIR/$SOURCE # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
+done
+
+SCRIPT_DIR=$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )
+
+BUILD_TYPE="RelWithDebInfo"
+CORSIKA_DIR=${CURRENT_DIR}
+CORSIKA_DIR_INFORMED=${CURRENT_DIR}
+CONAN2_OUTPUT_FOLDER_NAME="conan_cmake"
+
+printf "[ conan-install | info > This script is located at the directory: ${SCRIPT_DIR}\n"
+
+
+
+if [[ "$1" == "--help" ]] || [[ "$1" == "-h" ]];then
+    show_usage
+fi
+
+while [ ! -z "$1" ]; do
+  case "$1" in
+     --source-directory|-s)
+         shift
+         CORSIKA_DIR=$(readlink -e ${1})
+         CORSIKA_DIR_INFORMED=${1}
+         ;;
+     --debug|-d)
+         #shift
+         BUILD_TYPE="Debug"
+         ;;
+     --release|-r)
+         #shift
+         BUILD_TYPE="Release"
+         ;;
+     --release-with-debug|-rd)
+         #shift
+         BUILD_TYPE="RelWithDebInfo"
+         ;;
+      --help|-h)
+        #shift
+         show_usage
+         ;;
+     *)
+        show_usage
+        ;;
+  esac
+if [ $# -gt 0 ]; then
+shift
+fi
+done
+
+if [[ ${#CORSIKA_DIR} -eq 0 ]]; then
+  printf "[ conan-install | warning > Output folder for cmake scripts generated by conan2 not found.\n"
+  printf "[ conan-install | warning > Directory '${CORSIKA_DIR_INFORMED}' does not exist.\n"
+  exit 1
+fi
+
+
+if [ -d "${CORSIKA_DIR}/${CONAN2_OUTPUT_FOLDER_NAME}" ]; then
+  printf "[ conan-install | info > Output folder for cmake scripts generated by conan2 is: ${CORSIKA_DIR}/${CONAN2_OUTPUT_FOLDER_NAME}\n"
+else
+  printf "[ conan-install | warning > Output folder for cmake scripts generated by conan2 not found.\n"
+  printf "[ conan-install | warning > Creating directory  ${CORSIKA_DIR}/${CONAN2_OUTPUT_FOLDER_NAME}.\n"
+  mkdir -p "${CORSIKA_DIR}/${CONAN2_OUTPUT_FOLDER_NAME}"
+fi
+
+if [ -f "${CORSIKA_DIR}/conanfile.py" ]; then
+  printf "[ conan-install | info > conan2 recipe: ${CORSIKA_DIR}/conanfile.py\n"
+else
+  printf "[ conan-install | warning > conan2 recipe not found.\n"
+  printf "[ conan-install | warning > File  '${CORSIKA_DIR}/conanfile.py' does not exist.\n"
+  exit 1 
+fi
+
+# Conan2 variabes
+CONAN2_HOME=$(readlink -e `conan config home`)
+CONAN2_PROFILE_NAME="corsika8"
+printf "[ conan-install | info > conan2 home: ${CONAN2_HOME}\n"
+
+# Conan2 commands 
+CONAN2_DEFAULT_PROFILE_COMMAND="conan profile detect --force"
+CONAN2_PROFILE_COMMAND="conan profile detect --name ${CONAN2_PROFILE_NAME} --force"
+CONAN2_INSTALL_COMMAND="conan install ${CORSIKA_DIR} --output-folder=${CORSIKA_DIR}/${CONAN2_OUTPUT_FOLDER_NAME} --build=missing  --settings=build_type=${BUILD_TYPE} --profile=${CONAN2_PROFILE_NAME}"
+CONAN2_SHOW_PROFLE_COMMAND="conan profile show -pr ${CONAN2_PROFILE_NAME}"
+
+printf "[ conan-install | info > Creating default profile...\n\n"
+eval $CONAN2_DEFAULT_PROFILE_COMMAND
+if [ ! $? -eq 0 ]; then 
+	printf "[ conan-install | error > Exit code 126 (Command invoked cannot execute):\n ${CONAN2_DEFAULT_PROFILE_COMMAND}.\n"
+	exit 126
+fi	
+
+printf "[ conan-install | info > Creating '${CONAN2_PROFILE_NAME}' profile...\n\n"
+eval $CONAN2_PROFILE_COMMAND
+if [ ! $? -eq 0 ]; then 
+	printf "[ conan-install | error > Exit code 126 (Command invoked cannot execute):\n ${CONAN2_PROFILE_COMMAND}.\n"
+	exit 126
+fi	
+
+printf "\n\n[ conan-install | info > Editing '${CONAN2_PROFILE_NAME}' profile\n"
+
+#========== cppstd setting ============
+STD_NUMBER=`grep -n -m 1 "compiler.cppstd=" ${CONAN2_HOME}/profiles/${CONAN2_PROFILE_NAME} | cut -d: -f1`
+SED_STD_COMMAND="sed -i '${STD_NUMBER}s/.*/compiler.cppstd=gnu17/' ${CONAN2_HOME}/profiles/${CONAN2_PROFILE_NAME}"
+
+eval $SED_STD_COMMAND
+if [ ! $? -eq 0 ]; then 
+	printf "[ conan-install | error > Exit code 126 (Command invoked cannot execute):\n ${SED_STD_COMMAND}\n"
+	exit 126
+fi	
+
+#========== libcxx setting ============
+CXX_NUMBER=`grep -n -m 1 "compiler.libcxx=" ${CONAN2_HOME}/profiles/${CONAN2_PROFILE_NAME} | cut -d: -f1`
+SED_CXX_COMMAND="sed -i '${CXX_NUMBER}s/.*/compiler.libcxx=libstdc++11/' ${CONAN2_HOME}/profiles/${CONAN2_PROFILE_NAME}"
+
+eval $SED_CXX_COMMAND
+if [ ! $? -eq 0 ]; then 
+	printf "[ conan-install | error > Exit code 126 (Command invoked cannot execute):\n ${SED_CXX_COMMAND}\n"
+	exit 126
+fi	
+
+eval $CONAN2_SHOW_PROFLE_COMMAND
+if [ ! $? -eq 0 ]; then 
+	printf "[ conan-install | error > Exit code 126 (Command invoked cannot execute):\n ${CONAN2_SHOW_PROFLE_COMMAND}\n"
+	exit 126
+fi	
+
+printf "[ conan-install | info > ${CONAN2_INSTALL_COMMAND}\n"
+
+eval ${CONAN2_INSTALL_COMMAND}
+if [ ! $? -eq 0 ]; then 
+	printf "[ conan-install | error > Exit code 126 (Command invoked cannot execute):\n ${CONAN2_INSTALL_COMMAND}\n"
+	exit 126
+fi	
+
+CORSIKA_CMAKE_SCRIPT="#!/bin/bash
+
+
+function show_usage(){
+    printf \"\n\nUsage:\"
+    printf \"\$0 options [parameters]\n\"
+    printf \"\n\"
+    printf \"Options:\n\"
+    printf \"\n -c or --cmake-flags:\n Additional flags and settings to cmake base command. Default is empty string.\"
+    printf \"\n\nExample: ./corsika-cmake.sh --cmake-flags '-DUSE_Pythia8_C8=C8' \"
+    printf \"\n\nNote: the source directory (the one containing CMakeLists.txt), CMAKE_BUILD_TYPE, CMAKE_POLICY_DEFAULT_CMP0091 and CMAKE_TOOLCHAIN_FILE are already set. Do not repeat them.\"
+    printf \"\n -h or --help:\n Prints this message.\n\"
+
+exit 0
+}
+
+echo \"|---------------------------------------------------|\"
+echo \"|-----------------[ CORSIKA 8 ]---------------------|\"
+echo \"|----------[ CMAKE CONFIGURATION SCRIPT ]---------- |\"
+echo \"|---------------------------------------------------|\"
+echo \"|-------------------- BEGIN ------------------------|\"
+
+CMAKE_BASE_SETTINGS=\"cmake  -S ${CORSIKA_DIR} -D CONAN_CMAKE_DIR=${CORSIKA_DIR}/${CONAN2_OUTPUT_FOLDER_NAME} -D CMAKE_TOOLCHAIN_FILE=${CORSIKA_DIR}/${CONAN2_OUTPUT_FOLDER_NAME}/conan_toolchain.cmake  -D CMAKE_POLICY_DEFAULT_CMP0091=NEW -DCMAKE_BUILD_TYPE=${BUILD_TYPE}\"
+CMAKE_ADDITIONAL_SETTINGS=\"\"
+
+if [[ \"\$1\" == \"--help\" ]] || [[ \"\$1\" == \"-h\" ]];then
+    show_usage
+fi
+
+while [ ! -z \"\$1\" ]; do
+  case \"\$1\" in
+     --cmake-flags|-c)
+         shift
+         CMAKE_ADDITIONAL_SETTINGS=\${1}
+         ;;
+      --help|-h)
+        #shift
+         show_usage
+         ;;
+     *)
+        show_usage
+        ;;
+  esac
+if [ \$# -gt 0 ]; then
+shift
+fi
+done
+
+printf \"[corsika-cmake | info >  Issuing CMake command :\n\"
+printf '[corsika-cmake | info > \e[1;36m%s\e[0m\n\n\n' \"\${CMAKE_BASE_SETTINGS} \${CMAKE_ADDITIONAL_SETTINGS}\"
+
+eval \"\${CMAKE_BASE_SETTINGS} \${CMAKE_ADDITIONAL_SETTINGS}\"
+
+if [ ! \$? -eq 0 ]; then 
+	printf \"[ corsika | error > Project configuration (CMake) failed. \n\"
+	exit 1
+fi
+
+echo \"|---------------------------------------------------|\"
+echo \"|-----------------[ CORSIKA 8 ]---------------------|\"
+echo \"|----------[ CMAKE CONFIGURATION SCRIPT ]---------- |\"
+echo \"|---------------------------------------------------|\"
+echo \"|-------------------- END --------------------------|\"
+"
+
+printf "%s" "${CORSIKA_CMAKE_SCRIPT}" > ${SCRIPT_DIR}/corsika-cmake.sh
+chmod +x ${SCRIPT_DIR}/corsika-cmake.sh
+
+printf "\n\n[ conan-install | info > Copy and paste the commands below in the corsika-build directory:\n\n"
+printf '\e[1;36m%s\e[0m\n' "> ${SCRIPT_DIR}/corsika-cmake.sh "
+printf '\e[1;36m%s\e[0m\n' "> make -j8"
+
+echo " "
+echo "|---------------------------------------------------|"
+echo "|-----------------[ CORSIKA 8 ]---------------------|"
+echo "|-----[ CONAN2 DEPENDENCIES INSTALL SCRIPT ]------- |"
+echo "|---------------------------------------------------|"
+echo "|-------------------- END --------------------------| "
+echo " "
+
+exit 0

conanfile.py

+from conan import ConanFile
+from conan.tools.cmake import cmake_layout,CMakeToolchain, CMakeDeps
+
+class Pkg(ConanFile):
+    generators = "CMakeDeps", #"CMakeToolchain",
+    settings = "os", "arch", "compiler", "build_type"
+    default_options = {
+		'readline*:shared': 'True',
+		'arrow*:shared': 'False',
+		'arrow*:parquet': 'True',
+		'arrow*:fPIC': 'False',
+		'arrow*:with_re2': 'True',
+		'arrow*:with_protobuf': 'False',
+		'arrow*:with_openssl': 'False',
+		'arrow*:with_gflags': 'False',
+		'arrow*:with_glog': 'False',
+		'arrow*:with_grpc': 'False',
+		'arrow*:with_utf8proc': 'False',
+		'arrow*:with_zstd': 'False',
+		'arrow*:with_bz2': 'False',
+		'arrow*:with_lz4': 'True',
+		'arrow*:with_thrift': 'True',
+		'arrow*:with_boost': 'True',
+		'boost*:without_container': 'True',
+		'boost*:without_context': 'True',
+		'boost*:without_contract': 'True',
+		'boost*:without_coroutine': 'True',
+		'boost*:without_date_time': 'True',
+		'boost*:without_fiber': 'True',
+		'boost*:without_filesystem': 'False',
+		'boost*:without_graph': 'True',
+		'boost*:without_graph_parallel': 'True',
+		'boost*:without_iostreams': 'False',
+		'boost*:without_json': 'True',
+		'boost*:without_locale': 'True',
+		'boost*:without_log': 'True',
+		'boost*:without_math': 'False',
+		'boost*:without_mpi': 'True',
+		'boost*:without_nowide': 'True',
+		'boost*:without_program_options': 'True',
+		'boost*:without_python': 'True',
+		'boost*:without_serialization': 'False',
+		'boost*:without_stacktrace': 'True',
+		'boost*:without_system': 'False',
+		'boost*:without_test': 'True',
+		'boost*:without_thread': 'True',
+		'boost*:without_timer': 'True',
+		'boost*:without_type_erasure': 'True',
+		'boost*:without_wave': 'True'
+}
+
+    def configure(self):
+        self.options['arrow'].with_boost = True
+        self.options['arrow'].parquet = True
+        self.options['arrow'].with_thrift = True
+        
+    def requirements(self):
+        self.requires("spdlog/1.14.1", force=True)
+        self.requires("catch2/3.6.0")
+        self.requires("bzip2/1.0.8")
+        self.requires("boost/1.85.0", force=True)
+        self.requires("eigen/3.4.0")
+        self.requires("zlib/1.3.1")
+        self.requires("yaml-cpp/0.8.0")
+        self.requires("cli11/1.9.1")
+        self.requires("arrow/16.1.0")
+        self.requires("proposal/7.6.2")
+
+    def build_requirements(self):
+        self.tool_requires("readline/8.0")
+        self.tool_requires("bison/[>1.0]")
+        
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.absolute_paths = True
+        tc.generate()
+        
+

corsika/detail/framework/analytics/ClassTimer.inl

+/*
+ * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ *
+ * This software is distributed under the terms of the 3-clause BSD license.
+ * See file LICENSE for a full version of the license.
+ */
+
+// Another possibility:
+// https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Execute-Around_Pointer
+// for a more global approach
+//
+// In this case here only a single function is measured via member function pointer.
+
+#pragma once
+
+#include <chrono>
+#include <utility>
+
+namespace corsika {
+
+  // Common
+
+  template <typename TClass, typename TRet, typename... TArgs,
+            TRet (TClass::*TFuncPtr)(TArgs...), typename TTimer>
+  inline ClassTimer<TRet (TClass::*)(TArgs...), TFuncPtr, TTimer>::ClassTimer(TClass& obj)
+      : ClassTimerImpl<TClass, TTimer>(obj) {}
+
+  template <typename TClass, typename TRet, typename... TArgs,
+            TRet (TClass::*TFuncPtr)(TArgs...), typename TTimer>
+  inline TRet ClassTimer<TRet (TClass::*)(TArgs...), TFuncPtr, TTimer>::call(
+      TArgs... args) {
+    this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
+    auto tmp = (this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
+    this->timeDiff_ = std::chrono::duration_cast<
+        typename ClassTimerImpl<TClass, TTimer>::duration_type>(
+        ClassTimerImpl<TClass, TTimer>::clock_type::now() - this->start_);
+    return tmp;
+  }
+
+  // Specialisation 1
+
+  template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...),
+            typename TTimer>
+  inline ClassTimer<void (TClass::*)(TArgs...), TFuncPtr, TTimer>::ClassTimer(TClass& obj)
+      : ClassTimerImpl<TClass, TTimer>(obj) {}
+
+  template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...),
+            typename TTimer>
+  inline void ClassTimer<void (TClass::*)(TArgs...), TFuncPtr, TTimer>::call(
+      TArgs... args) {
+    this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
+    (this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
+    this->timeDiff_ = std::chrono::duration_cast<
+        typename ClassTimerImpl<TClass, TTimer>::duration_type>(
+        ClassTimerImpl<TClass, TTimer>::clock_type::now() - this->start_);
+    return;
+  }
+
+  /// Specialisation 2
+
+  template <typename TClass, typename TRet, typename... TArgs,
+            TRet (TClass::*TFuncPtr)(TArgs...) const, typename TTimer>
+  inline ClassTimer<TRet (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::ClassTimer(
+      TClass& obj)
+      : ClassTimerImpl<TClass, TTimer>(obj) {}
+
+  template <typename TClass, typename TRet, typename... TArgs,
+            TRet (TClass::*TFuncPtr)(TArgs...) const, typename TTimer>
+  inline TRet ClassTimer<TRet (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::call(
+      TArgs... args) {
+    this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
+    auto tmp = (this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
+    this->timeDiff_ = std::chrono::duration_cast<
+        typename ClassTimerImpl<TClass, TTimer>::duration_type>(
+        ClassTimerImpl<TClass, TTimer>::clock_type::now() - this->start_);
+    return tmp;
+  }
+
+  /// Specialisation 3
+  template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...) const,
+            typename TTimer>
+  inline ClassTimer<void (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::ClassTimer(
+      TClass& obj)
+      : ClassTimerImpl<TClass, TTimer>(obj) {}
+
+  template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...) const,
+            typename TTimer>
+  inline void ClassTimer<void (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::call(
+      TArgs... args) {
+    this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
+    (this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
+    this->timeDiff_ = std::chrono::duration_cast<
+        typename ClassTimerImpl<TClass, TTimer>::duration_type>(
+        ClassTimerImpl<TClass, TTimer>::clock_type::now() - this->start_);
+    return;
+  }
+
+} // namespace corsika

corsika/detail/framework/analytics/FunctionTimer.inl

+/*
+ * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ *
+ * This software is distributed under the terms of the 3-clause BSD license.
+ * See file LICENSE for a full version of the license.
+ */
+#pragma once
+
+#include <chrono>
+#include <utility>
+
+namespace corsika {
+
+  template <typename TFunc, typename TTime>
+  inline FunctionTimer<TFunc, TTime>::FunctionTimer(TFunc f)
+      : function_(f) {}
+
+  template <typename TFunc, typename TTime>
+  template <typename... TArgs>
+  inline auto FunctionTimer<TFunc, TTime>::operator()(TArgs&&... args)
+      -> std::invoke_result_t<TFunc, TArgs...> {
+    this->startTimer();
+    auto tmp = function_(std::forward<TArgs>(args)...);
+    this->stopTimer();
+    return tmp;
+  }
+
+} // namespace corsika