From ab32aa8818da29776ff31c9da4d5a7a00c0b8d0f Mon Sep 17 00:00:00 2001
From: ralfulrich <ralf.ulrich@kit.edu>
Date: Mon, 21 Dec 2020 13:05:55 +0100
Subject: [PATCH] cascade and some exmples and modules
---
CMakeLists.txt | 16 +-
corsika/detail/framework/core/Cascade.inl | 307 +++++---
.../framework/core/ParticleProperties.inl | 10 +-
.../detail/framework/geometry/FourVector.inl | 2 +-
corsika/detail/framework/geometry/Plane.inl | 4 +-
corsika/detail/framework/geometry/Vector.inl | 2 +-
.../framework/process/ProcessSequence.inl | 13 +-
.../detail/framework/stack/CombinedStack.inl | 4 +-
.../detail/framework/stack/SecondaryView.inl | 4 +-
corsika/detail/framework/stack/Stack.inl | 693 +++++++++---------
corsika/detail/framework/utility/COMBoost.inl | 26 +-
.../framework/utility/SaveBoostHistogram.inl | 4 +-
.../LayeredSphericalAtmosphereBuilder.inl | 100 ++-
corsika/detail/media/NuclearComposition.inl | 2 +-
corsika/detail/modules/ParticleCut.inl | 131 ++--
corsika/detail/modules/StackInspector.inl | 24 +-
corsika/detail/modules/TrackWriter.inl | 35 +-
corsika/detail/modules/TrackingLine.inl | 18 +-
.../modules/energy_loss/BetheBlochPDG.inl | 239 +++---
.../detail/modules/qgsjetII/Interaction.inl | 197 +++--
corsika/detail/modules/sibyll/Decay.inl | 233 +++---
corsika/detail/modules/sibyll/Interaction.inl | 444 +++++------
.../modules/sibyll/NuclearInteraction.inl | 536 +++++++-------
.../modules/sibyll/ParticleConversion.inl | 8 +-
corsika/detail/setup/SetupEnvironment.inl | 33 -
corsika/detail/setup/SetupStack.hpp | 25 +-
corsika/detail/setup/SetupStack.inl | 41 --
.../detail/stack/NuclearStackExtension.inl | 136 ++--
corsika/framework/core/Cascade.hpp | 70 +-
corsika/framework/core/ParticleProperties.hpp | 11 +-
.../framework/geometry/CoordinateSystem.hpp | 4 +-
corsika/framework/geometry/FourVector.hpp | 8 +-
.../geometry/RootCoordinateSystem.hpp | 10 +-
corsika/framework/logging/Logging.hpp | 4 +-
.../process/BoundaryCrossingProcess.hpp | 23 +-
.../framework/process/ContinuousProcess.hpp | 2 +-
corsika/framework/process/ProcessSequence.hpp | 8 +-
corsika/framework/stack/CombinedStack.hpp | 30 +-
corsika/framework/stack/SecondaryView.hpp | 2 +-
corsika/framework/stack/Stack.hpp | 64 +-
corsika/framework/utility/COMBoost.hpp | 19 +-
.../framework/utility/SaveBoostHistogram.hpp | 6 +-
corsika/media/IMagneticFieldModel.hpp | 2 +-
.../LayeredSphericalAtmosphereBuilder.hpp | 85 ++-
corsika/media/NuclearComposition.hpp | 2 +-
corsika/media/UniformMagneticField.hpp | 9 +-
corsika/modules/ParticleCut.hpp | 59 +-
corsika/modules/Sibyll.hpp | 2 +
corsika/modules/StackInspector.hpp | 7 +-
corsika/modules/SwitchProcess.hpp | 101 ---
corsika/modules/TrackWriter.hpp | 21 +-
corsika/modules/TrackingLine.hpp | 42 +-
corsika/modules/energy_loss/BetheBlochPDG.hpp | 66 +-
corsika/modules/qgsjetII/Interaction.hpp | 28 +-
.../modules/qgsjetII/ParticleConversion.hpp | 74 +-
.../qgsjetII/QGSJetIIFragmentsStack.hpp | 39 +-
corsika/modules/qgsjetII/QGSJetIIStack.hpp | 116 +--
corsika/modules/sibyll/Decay.hpp | 69 +-
corsika/modules/sibyll/Interaction.hpp | 66 +-
corsika/modules/sibyll/NuclearInteraction.hpp | 53 +-
corsika/modules/sibyll/ParticleConversion.hpp | 14 +-
corsika/modules/sibyll/SibStack.hpp | 4 +-
corsika/setup/SetupEnvironment.hpp | 24 -
corsika/setup/SetupStack.hpp | 25 +-
corsika/stack/DummyStack.hpp | 2 +-
corsika/stack/GeometryNodeStackExtension.hpp | 2 +-
corsika/stack/NuclearStackExtension.hpp | 7 +-
corsika/stack/SuperStupidStack.hpp | 11 +-
examples/CMakeLists.txt | 4 +
examples/boundary_example.cpp | 133 ++--
examples/cascade_example.cpp | 135 ++--
examples/cascade_proton_example.cpp | 135 ++--
examples/geometry_example.cpp | 42 +-
examples/helix_example.cpp | 14 +-
examples/logger_example.cpp | 54 --
examples/stack_example.cpp | 49 +-
examples/staticsequence_example.cpp | 32 +-
examples/stopping_power.cpp | 44 +-
examples/vertical_EAS.cpp | 307 +++++---
externals/cnpy/CMakeLists.txt | 17 +-
externals/cnpy/cnpy.cpp | 6 +-
src/modules/qgsjetII/code_generator.py | 138 +++-
src/modules/qgsjetII/qgsjet-II-04-codes.dat | 92 ++-
tests/framework/CMakeLists.txt | 26 +-
tests/framework/testCOMBoost.cpp | 41 +-
tests/framework/testCascade.cpp | 165 ++---
tests/framework/testCascade.hpp | 16 +-
tests/framework/testGeometry.cpp | 51 +-
tests/framework/testParticles.cpp | 173 ++---
tests/framework/testSaveBoostHistogram.cpp | 2 +-
tests/media/CMakeLists.txt | 5 +-
tests/media/testEnvironment.cpp | 57 +-
tests/media/testMedium.cpp | 17 +-
tests/modules/CMakeLists.txt | 24 +-
tests/modules/testObservationPlane.cpp | 2 -
tests/modules/testParticleCut.cpp | 165 ++++-
tests/modules/testPythia8.cpp | 92 ++-
tests/modules/testQGSJetII.cpp | 145 ++--
tests/modules/testSibyll.cpp | 255 ++++---
tests/modules/testUrQMD.cpp | 123 +---
tests/stack/CMakeLists.txt | 6 +-
tests/stack/testNuclearStackExtension.cpp | 28 +-
tests/stack/testSuperStupidStack.cpp | 4 +-
103 files changed, 3817 insertions(+), 3260 deletions(-)
delete mode 100644 corsika/modules/SwitchProcess.hpp
delete mode 100644 examples/logger_example.cpp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1ed52bb5a..7e8e00721 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -114,11 +114,10 @@ endif (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
#
#+++++++++++++++++++++++++++++
# Setup external dependencies.
-
#
# the version of the cmake-conan project we use for build.
set (CMAKE_CONAN_VERSION "v0.13")
-
+#
# download the cmake-conan integration
if (NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
message (STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
@@ -126,15 +125,18 @@ if (NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
"${CMAKE_BINARY_DIR}/conan.cmake"
TLS_VERIFY ON)
endif ()
-
+#
# add the cmake-conan integration
include (${CMAKE_BINARY_DIR}/conan.cmake)
-
+#
# download and build all dependencies
conan_cmake_run (CONANFILE conanfile.txt
BASIC_SETUP CMAKE_TARGETS
BUILD missing)
-
+#
+# add cnpy temporarily. As long as SaveBoostHistogram does not save to parquet directly
+#
+add_subdirectory (externals/cnpy)
#
#+++++++++++++++++++++++++++++
# Coverage
@@ -216,12 +218,16 @@ target_include_directories (
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}>
)
+# since CORSIKA8 is a header only library we must specify all link dependencies here:
target_link_libraries (
CORSIKA8
INTERFACE
PhysUnits
CONAN_PKG::eigen
CONAN_PKG::spdlog
+ CONAN_PKG::boost
+ cnpy # for SaveBoostHistogram
+ stdc++fs # experimental::filesystem
)
# those are needed, since some headers (namely GeneratedParticleProperties.inc) are produced by python script from ParticleData.xml
add_subdirectory (src)
diff --git a/corsika/detail/framework/core/Cascade.inl b/corsika/detail/framework/core/Cascade.inl
index c67343b37..9a53644f2 100644
--- a/corsika/detail/framework/core/Cascade.inl
+++ b/corsika/detail/framework/core/Cascade.inl
@@ -27,127 +27,158 @@
#include <limits>
#include <type_traits>
+namespace corsika
+{
-namespace corsika {
-
- template <typename TTracking, typename TProcessList, typename TStack,
+ template <typename TTracking,
+ typename TProcessList,
+ typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::SetNodes() {
- std::for_each(fStack.begin(), fStack.end(), [&](auto& p) {
- auto const* numericalNode =
- fEnvironment.GetUniverse()->GetContainingNode(p.GetPosition());
- p.SetNode(numericalNode);
+ void Cascade<TTracking, TProcessList, TStack, TStackView>::setNodes()
+ {
+ std::for_each(stack_.begin(), stack_.end(), [&](auto &p) {
+ auto const *numericalNode
+ = environment_.getUniverse()->getContainingNode(p.getPosition());
+ p.setNode(numericalNode);
});
}
- template <typename TTracking, typename TProcessList, typename TStack,
+ template <typename TTracking,
+ typename TProcessList,
+ typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::Run() {
- SetNodes();
-
- while (!fStack.IsEmpty()) {
- while (!fStack.IsEmpty()) {
- auto pNext = fStack.GetNextParticle();
- std::cout << "========= next: " << pNext.GetPID() << std::endl;
- Step(pNext);
- std::cout << "========= stack ============" << std::endl;
- fProcessSequence.doStack(fStack);
+ void Cascade<TTracking, TProcessList, TStack, TStackView>::run()
+ {
+ setNodes(); // put each particle on stack in correct environment volume
+
+ while (!stack_.isEmpty())
+ {
+ while (!stack_.isEmpty())
+ {
+ CORSIKA_LOG_TRACE("Stack: {}", stack_.asString());
+ count_++;
+
+ auto pNext = stack_.getNextParticle();
+
+ CORSIKA_LOG_TRACE(
+ "============== next particle : count={}, pid={}, "
+ ", stack entries={}"
+ ", stack deleted={}",
+ count_,
+ pNext.getPID(),
+ stack_.getEntries(),
+ stack_.getErased());
+
+ step(pNext);
+ sequence_.doStack(stack_);
}
// do cascade equations, which can put new particles on Stack,
// thus, the double loop
- // DoCascadeEquations();
+ // doCascadeEquations();
}
}
- template <typename TTracking, typename TProcessList, typename TStack,
+ template <typename TTracking,
+ typename TProcessList,
+ typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::forceInteraction() {
- std::cout << "forced interaction!" << std::endl;
- auto vParticle = fStack.GetNextParticle();
+ void Cascade<TTracking, TProcessList, TStack, TStackView>::forceInteraction()
+ {
+ CORSIKA_LOG_TRACE("forced interaction!");
+ auto vParticle = stack_.getNextParticle();
TStackView secondaries(vParticle);
- auto projectile = secondaries.GetProjectile();
- interaction(vParticle, projectile);
- fProcessSequence.DoSecondaries(secondaries);
- vParticle.Delete(); // todo: this should be reviewed, see below
+ interaction(secondaries);
+ sequence_.doSecondaries(secondaries);
+ vParticle.erase(); // primary particle is done
}
- template <typename TTracking, typename TProcessList, typename TStack,
+ template <typename TTracking,
+ typename TProcessList,
+ typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::Step(Particle& vParticle) {
+ void Cascade<TTracking, TProcessList, TStack, TStackView>::step(Particle &vParticle)
+ {
// determine geometric tracking
- auto [step, geomMaxLength, nextVol] = fTracking.GetTrack(vParticle);
- [[maybe_unused]] auto const& dummy_nextVol = nextVol;
+ auto [step, geomMaxLength, nextVol] = tracking_.getTrack(vParticle);
+ [[maybe_unused]] auto const &dummy_nextVol = nextVol;
// determine combined total interaction length (inverse)
- InverseGrammageType const total_inv_lambda =
- fProcessSequence.getInverseInteractionLength(vParticle);
+ InverseGrammageType const total_inv_lambda
+ = sequence_.getInverseInteractionLength(vParticle);
// sample random exponential step length in grammage
corsika::ExponentialDistribution expDist(1 / total_inv_lambda);
- GrammageType const next_interact = expDist(fRNG);
+ GrammageType const next_interact = expDist(rng_);
- std::cout << "total_inv_lambda=" << total_inv_lambda
- << ", next_interact=" << next_interact << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "total_lambda={} g/cm2, "
+ ", next_interact={} g/cm2",
+ double((1. / total_inv_lambda) / 1_g * 1_cm * 1_cm),
+ double(next_interact / 1_g * 1_cm * 1_cm));
- auto const* currentLogicalNode = vParticle.GetNode();
+ auto const *currentLogicalNode = vParticle.getNode();
// assert that particle stays outside void Universe if it has no
// model properties set
- assert(currentLogicalNode != &*fEnvironment.GetUniverse() ||
- fEnvironment.GetUniverse()->HasModelProperties());
+ assert(currentLogicalNode != &*environment_.getUniverse()
+ || environment_.getUniverse()->hasModelProperties());
// convert next_step from grammage to length
- LengthType const distance_interact =
- currentLogicalNode->GetModelProperties().arclengthFromGrammage(step,
- next_interact);
+ LengthType const distance_interact
+ = currentLogicalNode->getModelProperties().getArclengthFromGrammage(
+ step, next_interact);
// determine the maximum geometric step length
- LengthType const distance_max = fProcessSequence.maxStepLength(vParticle, step);
- std::cout << "distance_max=" << distance_max << std::endl;
+ LengthType const distance_max = sequence_.getMaxStepLength(vParticle, step);
// determine combined total inverse decay time
- InverseTimeType const total_inv_lifetime =
- fProcessSequence.getInverseLifetime(vParticle);
+ InverseTimeType const total_inv_lifetime = sequence_.getInverseLifetime(vParticle);
// sample random exponential decay time
corsika::ExponentialDistribution expDistDecay(1 / total_inv_lifetime);
- TimeType const next_decay = expDistDecay(fRNG);
- std::cout << "total_inv_lifetime=" << total_inv_lifetime
- << ", next_decay=" << next_decay << std::endl;
+ TimeType const next_decay = expDistDecay(rng_);
+
+ CORSIKA_LOG_DEBUG(
+ "total_lifetime={} s"
+ ", next_decay={} s",
+ (1 / total_inv_lifetime) / 1_s,
+ next_decay / 1_s);
// convert next_decay from time to length [m]
- LengthType const distance_decay = next_decay * vParticle.GetMomentum().norm() /
- vParticle.GetEnergy() * constants::c;
+ LengthType const distance_decay = next_decay * vParticle.getMomentum().getNorm()
+ / vParticle.getEnergy() * constants::c;
// take minimum of geometry, interaction, decay for next step
- auto const min_distance =
- std::min({distance_interact, distance_decay, distance_max, geomMaxLength});
+ auto const min_distance
+ = std::min({distance_interact, distance_decay, distance_max, geomMaxLength});
- std::cout << " move particle by : " << min_distance << std::endl;
+ CORSIKA_LOG_DEBUG("transport particle by : {} m", min_distance / 1_m);
// here the particle is actually moved along the trajectory to new position:
// std::visit(setup::ParticleUpdate<particle_type>{vParticle}, step);
- vParticle.SetPosition(step.PositionFromArclength(min_distance));
+ vParticle.setPosition(step.getPositionFromArclength(min_distance));
// .... also update time, momentum, direction, ...
- vParticle.SetTime(vParticle.GetTime() + min_distance / constants::c);
+ vParticle.setTime(vParticle.getTime() + min_distance / constants::c);
- step.LimitEndTo(min_distance);
+ step.getLimitEndTo(min_distance);
// apply all continuous processes on particle + track
- corsika::ProcessReturn status = fProcessSequence.doContinuous(vParticle, step);
-
- if (status == corsika::ProcessReturn::ParticleAbsorbed) {
- std::cout << "Cascade: delete absorbed particle " << vParticle.GetPID() << " "
- << vParticle.GetEnergy() / 1_GeV << "GeV" << std::endl;
- vParticle.Delete();
+ if (sequence_.doContinuous(vParticle, step) == ProcessReturn::ParticleAbsorbed)
+ {
+ CORSIKA_LOG_DEBUG("Cascade: delete absorbed particle PID={} E={} GeV",
+ vParticle.getPID(),
+ vParticle.getEnergy() / 1_GeV);
+ if (!vParticle.isErased())
+ vParticle.erase();
return;
}
- std::cout << "sth. happening before geometric limit ? "
- << ((min_distance < geomMaxLength) ? "yes" : "no") << std::endl;
+ CORSIKA_LOG_DEBUG("sth. happening before geometric limit ? {}",
+ ((min_distance < geomMaxLength) ? "yes" : "no"));
- if (min_distance < geomMaxLength) { // interaction to happen within geometric limit
+ if (min_distance < geomMaxLength)
+ { // interaction to happen within geometric limit
// check whether decay or interaction limits this step the
// outcome of decay or interaction MAY be a) new particles in
@@ -156,89 +187,133 @@ namespace corsika {
TStackView secondaries(vParticle);
- if (min_distance != distance_max) {
+ if (min_distance != distance_max)
+ {
/*
Create SecondaryView object on Stack. The data container
remains untouched and identical, and 'projectil' is identical
to 'vParticle' above this line. However,
projectil.AddSecondaries populate the SecondaryView, which can
then be used afterwards for further processing. Thus: it is
- important to use projectle (and not vParticle) for Interaction,
+ important to use projectle/view (and not vParticle) for Interaction,
and Decay!
*/
- [[maybe_unused]] auto projectile = secondaries.GetProjectile();
+ [[maybe_unused]] auto projectile = secondaries.getProjectile();
- if (min_distance == distance_interact) {
- interaction(vParticle, projectile);
- } else {
+ if (min_distance == distance_interact)
+ {
+ interaction(secondaries);
+ }
+ else
+ {
assert(min_distance == distance_decay);
- decay(vParticle, projectile);
+ decay(secondaries);
// make sure particle actually did decay if it should have done so
- if (secondaries.GetSize() == 1 &&
- projectile.GetPID() == secondaries.GetNextParticle().GetPID())
- throw std::runtime_error("Cascade::Step: particle_type decays into itself!");
+ if (secondaries.getSize() == 1
+ && projectile.getPID() == secondaries.getNextParticle().getPID())
+ throw std::runtime_error(fmt::format("Particle {} decays into itself!",
+ get_name(projectile.getPID())));
}
- fProcessSequence.DoSecondaries(secondaries);
- vParticle.Delete(); // todo: this should be reviewed. Where
- // exactly are particles best deleted, and
- // where they should NOT be
- // deleted... maybe Delete function should
- // be "protected" and not accessible to physics
-
- } else { // step-length limitation within volume
+ sequence_.doSecondaries(secondaries);
+ vParticle.erase();
+ }
+ else
+ { // step-length limitation within volume
- std::cout << "step-length limitation" << std::endl;
- fProcessSequence.DoSecondaries(secondaries);
+ CORSIKA_LOG_DEBUG("step-length limitation");
}
[[maybe_unused]] auto const assertion = [&] {
- auto const* numericalNodeAfterStep =
- fEnvironment.GetUniverse()->GetContainingNode(vParticle.GetPosition());
+ auto const *numericalNodeAfterStep
+ = environment_.getUniverse()->getContainingNode(vParticle.getPosition());
+ CORSIKA_LOG_TRACE(
+ "Geometry check: numericalNodeAfterStep={} currentLogicalNode={}",
+ fmt::ptr(numericalNodeAfterStep),
+ fmt::ptr(currentLogicalNode));
return numericalNodeAfterStep == currentLogicalNode;
};
assert(assertion()); // numerical and logical nodes don't match
- } else { // boundary crossing, step is limited by volume boundary
- std::cout << "boundary crossing! next node = " << nextVol << std::endl;
- vParticle.SetNode(nextVol);
- // DoBoundary may delete the particle (or not)
- fProcessSequence.DoBoundaryCrossing(vParticle, *currentLogicalNode, *nextVol);
+ }
+ else
+ { // boundary crossing, step is limited by volume boundary
+ vParticle.setNode(nextVol);
+ /*
+ doBoundary may delete the particle (or not)
+
+ caveat: any changes to vParticle, or even the production
+ of new secondaries is currently not passed to ParticleCut,
+ thus, particles outside the desired phase space may be produced.
+
+ \todo: this must be fixed.
+ */
+
+ sequence_.doBoundaryCrossing(vParticle, *currentLogicalNode, *nextVol);
}
}
- template <typename TTracking, typename TProcessList, typename TStack,
+ template <typename TTracking,
+ typename TProcessList,
+ typename TStack,
typename TStackView>
- auto Cascade<TTracking, TProcessList, TStack, TStackView>::decay(
- Particle& particle,
- decltype(std::declval<TStackView>().GetProjectile()) projectile) {
- std::cout << "decay" << std::endl;
- InverseTimeType const actual_decay_time =
- fProcessSequence.GetTotalInverseLifetime(particle);
+ ProcessReturn
+ Cascade<TTracking, TProcessList, TStack, TStackView>::decay(TStackView &view)
+ {
+ CORSIKA_LOG_DEBUG("decay");
+ InverseTimeType const actual_decay_time = sequence_.getInverseLifetime(view.parent());
corsika::UniformRealDistribution<InverseTimeType> uniDist(actual_decay_time);
- const auto sample_process = uniDist(fRNG);
- InverseTimeType inv_decay_count = InverseTimeType::zero();
- return fProcessSequence.SelectDecay(particle, projectile, sample_process,
- inv_decay_count);
+ const auto sample_process = uniDist(rng_);
+
+ auto const returnCode = sequence_.selectDecay(view, sample_process);
+ if (returnCode != ProcessReturn::Decayed)
+ {
+ CORSIKA_LOG_WARN("Particle did not decay!");
+ }
+ setEventType(view, history::EventType::Decay);
+ return returnCode;
}
- template <typename TTracking, typename TProcessList, typename TStack,
+ template <typename TTracking,
+ typename TProcessList,
+ typename TStack,
typename TStackView>
- auto Cascade<TTracking, TProcessList, TStack, TStackView>::interaction(
- Particle& particle,
- decltype(std::declval<TStackView>().GetProjectile()) projectile) {
- std::cout << "collide" << std::endl;
+ ProcessReturn
+ Cascade<TTracking, TProcessList, TStack, TStackView>::interaction(TStackView &view)
+ {
+ CORSIKA_LOG_DEBUG("collide");
- InverseGrammageType const current_inv_length =
- fProcessSequence.getInverseInteractionLength(particle);
+ InverseGrammageType const current_inv_length
+ = sequence_.getInverseInteractionLength(view.parent());
corsika::UniformRealDistribution<InverseGrammageType> uniDist(current_inv_length);
- const auto sample_process = uniDist(fRNG);
- auto inv_lambda_count = InverseGrammageType::zero();
- return fProcessSequence.selectInteraction(view, sample_process
- inv_lambda_count);
+
+ const auto sample_process = uniDist(rng_);
+ auto const returnCode = sequence_.selectInteraction(view, sample_process);
+ if (returnCode != ProcessReturn::Interacted)
+ {
+ CORSIKA_LOG_WARN("Particle did not interace!");
+ }
+ setEventType(view, history::EventType::Interaction);
+ return returnCode;
+ }
+
+ template <typename TTracking,
+ typename TProcessList,
+ typename TStack,
+ typename TStackView>
+ void Cascade<TTracking, TProcessList, TStack, TStackView>::setEventType(
+ TStackView &view, [[maybe_unused]] history::EventType eventType)
+ {
+ if constexpr (TStackView::has_event)
+ {
+ for (auto &&sec : view)
+ {
+ sec.getEvent()->setEventType(eventType);
+ }
+ }
}
} // namespace corsika
diff --git a/corsika/detail/framework/core/ParticleProperties.inl b/corsika/detail/framework/core/ParticleProperties.inl
index 731efc1dd..6fc0bea95 100644
--- a/corsika/detail/framework/core/ParticleProperties.inl
+++ b/corsika/detail/framework/core/ParticleProperties.inl
@@ -90,10 +90,12 @@ namespace corsika {
}
}
- inline HEPMassType nucleus_mass(const int A, const int Z) {
- auto const absA = std::abs(A);
- auto const absZ = std::abs(Z);
- return get_mass(Code::Proton) * absZ + (absA - absZ) * get_mass(Code::Neutron);
+ inline HEPMassType get_nucleus_mass(unsigned int const A, unsigned int const Z) {
+ return get_mass(Code::Proton) * Z + (A - Z) * get_mass(Code::Neutron);
+ }
+
+ std::initializer_list<Code> constexpr get_all_particles() {
+ return particle::detail::all_particles;
}
} // namespace corsika
diff --git a/corsika/detail/framework/geometry/FourVector.inl b/corsika/detail/framework/geometry/FourVector.inl
index 454854288..8823f2132 100644
--- a/corsika/detail/framework/geometry/FourVector.inl
+++ b/corsika/detail/framework/geometry/FourVector.inl
@@ -20,7 +20,7 @@ namespace corsika {
}
template <typename TTimeType, typename TSpaceVecType>
- TSpaceVecType& FourVector<TTimeType, TSpaceVecType>::spaceLikeComponents() {
+ TSpaceVecType& FourVector<TTimeType, TSpaceVecType>::getSpaceLikeComponents() {
return spaceLike_;
}
diff --git a/corsika/detail/framework/geometry/Plane.inl b/corsika/detail/framework/geometry/Plane.inl
index af0160fd6..f35e23e17 100644
--- a/corsika/detail/framework/geometry/Plane.inl
+++ b/corsika/detail/framework/geometry/Plane.inl
@@ -20,8 +20,8 @@ namespace corsika {
return normal_.dot(vP - center_) > LengthType::zero();
}
- inline LengthType Plane::getDistanceTo(corsika::Point const& vP) const {
- return (normal_ * (vP - center_).dot(normal_)).norm();
+ inline LengthType Plane::getDistanceTo(Point const& vP) const {
+ return (normal_ * (vP - center_).dot(normal_)).getNorm();
}
inline Point const& Plane::getCenter() const { return center_; }
diff --git a/corsika/detail/framework/geometry/Vector.inl b/corsika/detail/framework/geometry/Vector.inl
index 67fb53d07..cbfd597b3 100644
--- a/corsika/detail/framework/geometry/Vector.inl
+++ b/corsika/detail/framework/geometry/Vector.inl
@@ -174,7 +174,7 @@ namespace corsika {
template <typename TDimension>
auto Vector<TDimension>::operator/(double const p) const {
return Vector<TDimension>(BaseVector<TDimension>::getCoordinateSystem(),
- BaseVector<TDimension>::quantityVector() / p);
+ BaseVector<TDimension>::getQuantityVector() / p);
}
template <typename TDimension>
diff --git a/corsika/detail/framework/process/ProcessSequence.inl b/corsika/detail/framework/process/ProcessSequence.inl
index 5317fe85c..4cfeb1ab5 100644
--- a/corsika/detail/framework/process/ProcessSequence.inl
+++ b/corsika/detail/framework/process/ProcessSequence.inl
@@ -25,9 +25,10 @@
namespace corsika {
template <typename TProcess1, typename TProcess2>
- template <typename Particle, typename VTNType>
+ template <typename TParticle>
ProcessReturn ProcessSequence<TProcess1, TProcess2>::doBoundaryCrossing(
- Particle& particle, VTNType const& from, VTNType const& to) {
+ TParticle& particle, typename TParticle::node_type const& from,
+ typename TParticle::node_type const& to) {
ProcessReturn ret = ProcessReturn::Ok;
if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process1_type>,
@@ -103,19 +104,19 @@ namespace corsika {
template <typename TProcess1, typename TProcess2>
template <typename TParticle, typename TTrack>
- LengthType ProcessSequence<TProcess1, TProcess2>::maxStepLength(TParticle& particle,
- TTrack& vTrack) {
+ LengthType ProcessSequence<TProcess1, TProcess2>::getMaxStepLength(TParticle& particle,
+ TTrack& vTrack) {
LengthType max_length = // if no other process in the sequence implements it
std::numeric_limits<double>::infinity() * meter;
if constexpr (std::is_base_of_v<ContinuousProcess<process1_type>, process1_type> ||
t1ProcSeq) {
- LengthType const len = A_.maxStepLength(particle, vTrack);
+ LengthType const len = A_.getMaxStepLength(particle, vTrack);
max_length = std::min(max_length, len);
}
if constexpr (std::is_base_of_v<ContinuousProcess<process2_type>, process2_type> ||
t2ProcSeq) {
- LengthType const len = B_.maxStepLength(particle, vTrack);
+ LengthType const len = B_.getMaxStepLength(particle, vTrack);
max_length = std::min(max_length, len);
}
return max_length;
diff --git a/corsika/detail/framework/stack/CombinedStack.inl b/corsika/detail/framework/stack/CombinedStack.inl
index f14caf0c7..ffc816b93 100644
--- a/corsika/detail/framework/stack/CombinedStack.inl
+++ b/corsika/detail/framework/stack/CombinedStack.inl
@@ -54,8 +54,8 @@ namespace corsika {
///@}
template <template <typename> class TParticleInterfaceA,
template <typename> class TParticleInterfaceB, typename TStackIterator>
- inline std::string CombinedParticleInterface<TParticleInterfaceA, TParticleInterfaceB, TStackIterator>::as_string() const {
- return fmt::format("[[{}][{}]]", pi_a_type::as_string(), pi_b_type::as_string());
+ inline std::string CombinedParticleInterface<TParticleInterfaceA, TParticleInterfaceB, TStackIterator>::asString() const {
+ return fmt::format("[[{}][{}]]", pi_a_type::asString(), pi_b_type::asString());
}
diff --git a/corsika/detail/framework/stack/SecondaryView.inl b/corsika/detail/framework/stack/SecondaryView.inl
index cfbd1d35a..d5db7472a 100644
--- a/corsika/detail/framework/stack/SecondaryView.inl
+++ b/corsika/detail/framework/stack/SecondaryView.inl
@@ -187,14 +187,14 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
std::string SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::as_string() const {
+ MSecondaryProducer>::asString() const {
std::string str(fmt::format("size {}\n", getSize()));
// we make our own begin/end since we want ALL entries
std::string new_line = " ";
for (unsigned int iPart = 0; iPart != getSize(); ++iPart) {
const_stack_view_iterator itPart(*this, iPart);
str += fmt::format(
- "{}{}{}", new_line, itPart.as_string(),
+ "{}{}{}", new_line, itPart.asString(),
(inner_stack_.deleted_[getIndexFromIterator(itPart.getIndex())] ? " [deleted]"
: ""));
new_line = "\n ";
diff --git a/corsika/detail/framework/stack/Stack.inl b/corsika/detail/framework/stack/Stack.inl
index 3c532426e..df175bd27 100644
--- a/corsika/detail/framework/stack/Stack.inl
+++ b/corsika/detail/framework/stack/Stack.inl
@@ -8,7 +8,6 @@
#pragma once
-
#include <corsika/framework/logging/Logging.hpp>
#include <corsika/framework/stack/StackIteratorInterface.hpp>
@@ -18,351 +17,365 @@
#include <utility>
#include <type_traits>
-
namespace corsika {
-
- template <typename StackData, template <typename> typename MParticleInterface>
- template <typename... TArgs>
- void Stack<StackData, MParticleInterface>::clear(TArgs... args) {
- data_.clear(args...);
- deleted_ = std::vector<bool>(data_.getSize(), false);
- nDeleted_ = 0;
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::begin() {
- unsigned int i = 0;
- for (; i < getSize(); ++i) {
- if (!deleted_[i]) break;
- }
- return stack_iterator_type(*this, i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::end() {
- return stack_iterator_type(*this, getSize());
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::last() {
- unsigned int i = 0;
- for (; i < getSize(); ++i) {
- if (!deleted_[getSize() - 1 - i]) break;
- }
- return stack_iterator_type(*this, getSize() - 1 - i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::begin() const {
- unsigned int i = 0;
- for (; i < getSize(); ++i) {
- if (!deleted_[i]) break;
- }
- return const_stack_iterator_type(*this, i);
- }
-
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::end() const {
- return const_stack_iterator_type(*this, getSize());
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::last() const {
- unsigned int i = 0;
- for (; i < getSize(); ++i) {
- if (!deleted_[getSize() - 1 - i]) break;
- }
- return const_stack_iterator_type(*this, getSize() - 1 - i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::cbegin() const {
- unsigned int i = 0;
- for (; i < getSize(); ++i) {
- if (!deleted_[i]) break;
- }
- return const_stack_iterator_type(*this, i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::cend() const {
- return const_stack_iterator_type(*this, getSize());
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::clast() const {
- unsigned int i = 0;
- for (; i < getSize(); ++i) {
- if (!deleted_[getSize() - 1 - i]) break;
- }
-
- return const_stack_iterator_type(*this, getSize() - 1 - i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::at(unsigned int i) {
- return stack_iterator_type(*this, i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::at(unsigned int i) const {
- return const_stack_iterator_type(*this, i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::first() {
- return stack_iterator_type{*this, 0};
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::cfirst() const {
- return const_stack_iterator_type{*this, 0};
- }
- /// @}
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::getNextParticle() {
- while (purgeLastIfDeleted()) {}
- return last();
- }
-
-
- template <typename StackData, template <typename> typename MParticleInterface>
- template <typename... TArgs>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::addParticle(const TArgs... v) {
- CORSIKA_LOG_TRACE("Stack::AddParticle");
- data_.incrementSize();
- deleted_.push_back(false);
- return stack_iterator_type(*this, getSize() - 1, v...);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::swap(stack_iterator_type a, stack_iterator_type b) {
- CORSIKA_LOG_TRACE("Stack::Swap");
- swap(a.getIndex(), b.getIndex());
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::copy(stack_iterator_type a, stack_iterator_type b) {
- CORSIKA_LOG_TRACE("Stack::Copy");
- copy(a.getIndex(), b.getIndex());
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::copy(const_stack_iterator_type a, stack_iterator_type b) {
- CORSIKA_LOG_TRACE("Stack::Copy");
- data_.copy(a.getIndex(), b.getIndex());
- if (deleted_[b.getIndex()] && !deleted_[a.getIndex()]) nDeleted_--;
- if (!deleted_[b.getIndex()] && deleted_[a.getIndex()]) nDeleted_++;
- deleted_[b.getIndex()] = deleted_[a.getIndex()];
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::erase(stack_iterator_type p) {
- CORSIKA_LOG_TRACE("Stack::Delete");
- if (this->isEmpty()) { /*error*/
- throw std::runtime_error("Stack, cannot delete entry since size is zero");
- }
- if (deleted_[p.getIndex()]) { /*error*/
- throw std::runtime_error("Stack, cannot delete entry since already deleted");
- }
- this->erase(p.getIndex());
- }
- /**
- * delete this particle
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::erase(particle_interface_type p) { this->erase(p.getIterator()); }
-
- /**
- * check if there are no further non-deleted particles on stack
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- bool Stack<StackData, MParticleInterface>::isEmpty() { return getEntries() == 0; }
-
- /**
- * check if this particle was already deleted
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- bool Stack<StackData, MParticleInterface>::isErased(const stack_iterator_type& p) const { return isErased(p.getIndex()); }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- bool Stack<StackData, MParticleInterface>::isErased(const const_stack_iterator_type& p) const {
- return isErased(p.getIndex());
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- bool Stack<StackData, MParticleInterface>::isErased(const particle_interface_type& p) const {
- return isErased(p.getIterator());
- }
-
- /**
- * Function to ultimatively remove the last entry from the stack,
- * if it was marked as deleted before. If this is not the case,
- * the function will just return false and do nothing.
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- bool Stack<StackData, MParticleInterface>::purgeLastIfDeleted() {
- if (!deleted_.back())
- return false; // the last particle is not marked for deletion. Do nothing.
-
- CORSIKA_LOG_TRACE("Stack::purgeLastIfDeleted: yes");
- data_.decrementSize();
- nDeleted_--;
- deleted_.pop_back();
- return true;
- }
-
- /**
- * Function to ultimatively remove all entries from the stack
- * marked as deleted.
- *
- * Careful: this will re-order the entries on the stack, since
- * "gaps" in the stack are filled with entries from the back
- * (copied).
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::purge() {
- unsigned int iStackFront = 0;
- unsigned int iStackBack = getSize() - 1;
-
- for (unsigned int iDeleted = 0; iDeleted < getErased(); ++iDeleted) {
- // search first delete entry on stack
- while (!deleted_[iStackFront]) { iStackFront++; }
- // search for last non-deleted particle on stack
- while (deleted_[iStackBack]) { iStackBack--; }
- // copy entry from iStackBack to iStackFront
- data_.copy(iStackBack, iStackFront);
- data_.decrementSize();
- }
- deleted_.clear();
- nDeleted_ = 0;
- }
-
-
- template <typename StackData, template <typename> typename MParticleInterface>
- unsigned int Stack<StackData, MParticleInterface>::getSize() const { return data_.getSize(); }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- std::string Stack<StackData, MParticleInterface>::as_string() const {
- std::string str(fmt::format("size {}, entries {}, deleted {} \n", getSize(),
- getEntries(), getErased()));
- // we make our own begin/end since we want ALL entries
- std::string new_line = " ";
- for (unsigned int iPart = 0; iPart != getSize(); ++iPart) {
- const_stack_iterator_type itPart(*this, iPart);
- str += fmt::format("{}{}{}", new_line, itPart.as_string(),
- (deleted_[itPart.getIndex()] ? " [deleted]" : ""));
- new_line = "\n ";
- }
- return str;
- }
-
-
- template <typename StackData, template <typename> typename MParticleInterface>
- template <typename... TArgs>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::addSecondary(stack_iterator_type& parent, const TArgs... v) {
- CORSIKA_LOG_TRACE("Stack::AddSecondary");
- data_.incrementSize();
- deleted_.push_back(false);
- return stack_iterator_type(*this, getSize() - 1, parent, v...);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::swap(unsigned int const a, unsigned int const b) {
- CORSIKA_LOG_TRACE("Stack::Swap(unsigned int)");
- data_.swap(a, b);
- std::swap(deleted_[a], deleted_[b]);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::copy(unsigned int const a, unsigned int const b) {
- CORSIKA_LOG_TRACE("Stack::Copy");
- data_.copy(a, b);
- if (deleted_[b] && !deleted_[a]) nDeleted_--;
- if (!deleted_[b] && deleted_[a]) nDeleted_++;
- deleted_[b] = deleted_[a];
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- bool Stack<StackData, MParticleInterface>::isErased(unsigned int const i) const {
- if (i >= deleted_.size()) return false;
- return deleted_.at(i);
- }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::erase(unsigned int const i) {
- deleted_[i] = true;
- nDeleted_++;
- }
-
- /**
- * will remove from storage the element i. This is a helper
- * function for SecondaryView.
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::purge(unsigned int i) {
- unsigned int iStackBack = getSize() - 1;
+ template <typename StackData, template <typename> typename MParticleInterface>
+ template <typename... TArgs>
+ void Stack<StackData, MParticleInterface>::clear(TArgs... args) {
+ data_.clear(args...);
+ deleted_ = std::vector<bool>(data_.getSize(), false);
+ nDeleted_ = 0;
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::begin() {
+ unsigned int i = 0;
+ for (; i < getSize(); ++i) {
+ if (!deleted_[i]) break;
+ }
+ return stack_iterator_type(*this, i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::end() {
+ return stack_iterator_type(*this, getSize());
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::last() {
+ unsigned int i = 0;
+ for (; i < getSize(); ++i) {
+ if (!deleted_[getSize() - 1 - i]) break;
+ }
+ return stack_iterator_type(*this, getSize() - 1 - i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::begin() const {
+ unsigned int i = 0;
+ for (; i < getSize(); ++i) {
+ if (!deleted_[i]) break;
+ }
+ return const_stack_iterator_type(*this, i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::end() const {
+ return const_stack_iterator_type(*this, getSize());
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::last() const {
+ unsigned int i = 0;
+ for (; i < getSize(); ++i) {
+ if (!deleted_[getSize() - 1 - i]) break;
+ }
+ return const_stack_iterator_type(*this, getSize() - 1 - i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::cbegin() const {
+ unsigned int i = 0;
+ for (; i < getSize(); ++i) {
+ if (!deleted_[i]) break;
+ }
+ return const_stack_iterator_type(*this, i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::cend() const {
+ return const_stack_iterator_type(*this, getSize());
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::clast() const {
+ unsigned int i = 0;
+ for (; i < getSize(); ++i) {
+ if (!deleted_[getSize() - 1 - i]) break;
+ }
+
+ return const_stack_iterator_type(*this, getSize() - 1 - i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::at(unsigned int i) {
+ return stack_iterator_type(*this, i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::at(unsigned int i) const {
+ return const_stack_iterator_type(*this, i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::first() {
+ return stack_iterator_type{*this, 0};
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
+ Stack<StackData, MParticleInterface>::cfirst() const {
+ return const_stack_iterator_type{*this, 0};
+ }
+ /// @}
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::getNextParticle() {
+ while (purgeLastIfDeleted()) {}
+ return last();
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ template <typename... TArgs>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::addParticle(const TArgs... v) {
+ CORSIKA_LOG_TRACE("Stack::AddParticle");
+ data_.incrementSize();
+ deleted_.push_back(false);
+ return stack_iterator_type(*this, getSize() - 1, v...);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::swap(stack_iterator_type a,
+ stack_iterator_type b) {
+ CORSIKA_LOG_TRACE("Stack::Swap");
+ swap(a.getIndex(), b.getIndex());
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::copy(stack_iterator_type a,
+ stack_iterator_type b) {
+ CORSIKA_LOG_TRACE("Stack::Copy");
+ copy(a.getIndex(), b.getIndex());
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::copy(const_stack_iterator_type a,
+ stack_iterator_type b) {
+ CORSIKA_LOG_TRACE("Stack::Copy");
+ data_.copy(a.getIndex(), b.getIndex());
+ if (deleted_[b.getIndex()] && !deleted_[a.getIndex()]) nDeleted_--;
+ if (!deleted_[b.getIndex()] && deleted_[a.getIndex()]) nDeleted_++;
+ deleted_[b.getIndex()] = deleted_[a.getIndex()];
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::erase(stack_iterator_type p) {
+ CORSIKA_LOG_TRACE("Stack::Delete");
+ if (this->isEmpty()) { /*error*/
+ throw std::runtime_error("Stack, cannot delete entry since size is zero");
+ }
+ if (deleted_[p.getIndex()]) { /*error*/
+ throw std::runtime_error("Stack, cannot delete entry since already deleted");
+ }
+ this->erase(p.getIndex());
+ }
+ /**
+ * delete this particle
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::erase(particle_interface_type p) {
+ this->erase(p.getIterator());
+ }
+
+ /**
+ * check if there are no further non-deleted particles on stack
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ bool Stack<StackData, MParticleInterface>::isEmpty() {
+ return getEntries() == 0;
+ }
+
+ /**
+ * check if this particle was already deleted
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ bool Stack<StackData, MParticleInterface>::isErased(
+ const stack_iterator_type& p) const {
+ return isErased(p.getIndex());
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ bool Stack<StackData, MParticleInterface>::isErased(
+ const const_stack_iterator_type& p) const {
+ return isErased(p.getIndex());
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ bool Stack<StackData, MParticleInterface>::isErased(
+ const particle_interface_type& p) const {
+ return isErased(p.getIterator());
+ }
+
+ /**
+ * Function to ultimatively remove the last entry from the stack,
+ * if it was marked as deleted before. If this is not the case,
+ * the function will just return false and do nothing.
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ bool Stack<StackData, MParticleInterface>::purgeLastIfDeleted() {
+ if (!deleted_.back())
+ return false; // the last particle is not marked for deletion. Do nothing.
+
+ CORSIKA_LOG_TRACE("Stack::purgeLastIfDeleted: yes");
+ data_.decrementSize();
+ nDeleted_--;
+ deleted_.pop_back();
+ return true;
+ }
+
+ /**
+ * Function to ultimatively remove all entries from the stack
+ * marked as deleted.
+ *
+ * Careful: this will re-order the entries on the stack, since
+ * "gaps" in the stack are filled with entries from the back
+ * (copied).
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::purge() {
+ unsigned int iStackFront = 0;
+ unsigned int iStackBack = getSize() - 1;
+
+ for (unsigned int iDeleted = 0; iDeleted < getErased(); ++iDeleted) {
+ // search first delete entry on stack
+ while (!deleted_[iStackFront]) { iStackFront++; }
// search for last non-deleted particle on stack
while (deleted_[iStackBack]) { iStackBack--; }
// copy entry from iStackBack to iStackFront
- data_.copy(iStackBack, i);
- if (deleted_[i]) nDeleted_--;
- deleted_[i] = deleted_[iStackBack];
+ data_.copy(iStackBack, iStackFront);
data_.decrementSize();
- deleted_.pop_back();
- }
-
- /**
- * Function to perform eventual transformation from
- * StackIterator::getIndex() to index in data stored in
- * StackData data_. By default (and in almost all cases) this
- * should just be identiy. See class SecondaryView for an alternative implementation.
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- unsigned int Stack<StackData, MParticleInterface>::getIndexFromIterator(const unsigned int vI) const {
- // this is too much: CORSIKA_LOG_TRACE("Stack::getIndexFromIterator({})={}", vI, vI);
- return vI;
}
-
- /**
- * @name Return reference to StackData object data_ for data access
- * @{
- */
-
- template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::value_type&
- Stack<StackData, MParticleInterface>::getStackData() { return data_; }
-
- template <typename StackData, template <typename> typename MParticleInterface>
- const typename Stack<StackData, MParticleInterface>::value_type&
- Stack<StackData, MParticleInterface>::getStackData() const { return data_; }
-
-
+ deleted_.clear();
+ nDeleted_ = 0;
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ unsigned int Stack<StackData, MParticleInterface>::getSize() const {
+ return data_.getSize();
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ std::string Stack<StackData, MParticleInterface>::asString() const {
+ std::string str(fmt::format("size {}, entries {}, deleted {} \n", getSize(),
+ getEntries(), getErased()));
+ // we make our own begin/end since we want ALL entries
+ std::string new_line = " ";
+ for (unsigned int iPart = 0; iPart != getSize(); ++iPart) {
+ const_stack_iterator_type itPart(*this, iPart);
+ str += fmt::format("{}{}{}", new_line, itPart.asString(),
+ (deleted_[itPart.getIndex()] ? " [deleted]" : ""));
+ new_line = "\n ";
+ }
+ return str;
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ template <typename... TArgs>
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ Stack<StackData, MParticleInterface>::addSecondary(stack_iterator_type& parent,
+ const TArgs... v) {
+ CORSIKA_LOG_TRACE("Stack::AddSecondary");
+ data_.incrementSize();
+ deleted_.push_back(false);
+ return stack_iterator_type(*this, getSize() - 1, parent, v...);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::swap(unsigned int const a,
+ unsigned int const b) {
+ CORSIKA_LOG_TRACE("Stack::Swap(unsigned int)");
+ data_.swap(a, b);
+ std::swap(deleted_[a], deleted_[b]);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::copy(unsigned int const a,
+ unsigned int const b) {
+ CORSIKA_LOG_TRACE("Stack::Copy");
+ data_.copy(a, b);
+ if (deleted_[b] && !deleted_[a]) nDeleted_--;
+ if (!deleted_[b] && deleted_[a]) nDeleted_++;
+ deleted_[b] = deleted_[a];
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ bool Stack<StackData, MParticleInterface>::isErased(unsigned int const i) const {
+ if (i >= deleted_.size()) return false;
+ return deleted_.at(i);
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::erase(unsigned int const i) {
+ deleted_[i] = true;
+ nDeleted_++;
+ }
+
+ /**
+ * will remove from storage the element i. This is a helper
+ * function for SecondaryView.
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ void Stack<StackData, MParticleInterface>::purge(unsigned int i) {
+ unsigned int iStackBack = getSize() - 1;
+ // search for last non-deleted particle on stack
+ while (deleted_[iStackBack]) { iStackBack--; }
+ // copy entry from iStackBack to iStackFront
+ data_.copy(iStackBack, i);
+ if (deleted_[i]) nDeleted_--;
+ deleted_[i] = deleted_[iStackBack];
+ data_.decrementSize();
+ deleted_.pop_back();
+ }
+
+ /**
+ * Function to perform eventual transformation from
+ * StackIterator::getIndex() to index in data stored in
+ * StackData data_. By default (and in almost all cases) this
+ * should just be identiy. See class SecondaryView for an alternative implementation.
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ unsigned int Stack<StackData, MParticleInterface>::getIndexFromIterator(
+ const unsigned int vI) const {
+ // this is too much: CORSIKA_LOG_TRACE("Stack::getIndexFromIterator({})={}", vI, vI);
+ return vI;
+ }
+
+ /**
+ * @name Return reference to StackData object data_ for data access
+ * @{
+ */
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ typename Stack<StackData, MParticleInterface>::value_type&
+ Stack<StackData, MParticleInterface>::getStackData() {
+ return data_;
+ }
+
+ template <typename StackData, template <typename> typename MParticleInterface>
+ const typename Stack<StackData, MParticleInterface>::value_type&
+ Stack<StackData, MParticleInterface>::getStackData() const {
+ return data_;
+ }
} // namespace corsika
diff --git a/corsika/detail/framework/utility/COMBoost.inl b/corsika/detail/framework/utility/COMBoost.inl
index 35dbdb10a..60201a398 100644
--- a/corsika/detail/framework/utility/COMBoost.inl
+++ b/corsika/detail/framework/utility/COMBoost.inl
@@ -19,14 +19,14 @@
#include <corsika/framework/geometry/Vector.hpp>
#include <corsika/framework/logging/Logging.hpp>
-// using namespace corsika::units::si;
-
namespace corsika {
- COMBoost::COMBoost(FourVector<HEPEnergyType, Vector<hepmomentum_d>> const& Pprojectile,
- HEPMassType const massTarget)
+ inline COMBoost::COMBoost(FourVector<HEPEnergyType, MomentumVector> const& Pprojectile,
+ HEPMassType const massTarget)
: originalCS_{Pprojectile.getSpaceLikeComponents().getCoordinateSystem()}
- , rotatedCS_{make_rotationToZ(originalCS_, Pprojectile.getSpaceLikeComponents())} {
+ , rotatedCS_{
+ make_rotationToZ(Pprojectile.getSpaceLikeComponents().getCoordinateSystem(),
+ Pprojectile.getSpaceLikeComponents())} {
auto const pProjectile = Pprojectile.getSpaceLikeComponents();
auto const pProjNormSquared = pProjectile.getSquaredNorm();
auto const pProjNorm = sqrt(pProjNormSquared);
@@ -42,13 +42,13 @@ namespace corsika {
setBoost(coshEta, sinhEta);
- CORSIKA_LOG_TRACE("COMBoost (1-beta)={}, gamma={}, det={}", 1 - sinhEta / coshEta, coshEta,
- boost_.determinant() - 1);
+ CORSIKA_LOG_TRACE("COMBoost (1-beta)={}, gamma={}, det={}", 1 - sinhEta / coshEta,
+ coshEta, boost_.determinant() - 1);
}
- COMBoost::COMBoost(Vector<hepmomentum_d> const& momentum, HEPEnergyType mass)
+ inline COMBoost::COMBoost(MomentumVector const& momentum, HEPEnergyType mass)
: originalCS_{momentum.getCoordinateSystem()}
- , rotatedCS_{make_rotationToZ(originalCS_, momentum)} {
+ , rotatedCS_{make_rotationToZ(momentum.getCoordinateSystem(), momentum)} {
auto const squaredNorm = momentum.getSquaredNorm();
auto const norm = sqrt(squaredNorm);
auto const sinhEta = -norm / mass;
@@ -57,7 +57,7 @@ namespace corsika {
}
template <typename FourVector>
- FourVector COMBoost::toCoM(FourVector const& p) const {
+ inline FourVector COMBoost::toCoM(FourVector const& p) const {
auto pComponents = p.getSpaceLikeComponents().getComponents(rotatedCS_);
Eigen::Vector3d eVecRotated = pComponents.getEigenVector();
Eigen::Vector2d lab;
@@ -70,11 +70,11 @@ namespace corsika {
eVecRotated(2) = boostedZ(1) * (1_GeV).magnitude();
- return FourVector(E_CoM, Vector<hepmomentum_d>(rotatedCS_, eVecRotated));
+ return FourVector(E_CoM, MomentumVector(rotatedCS_, eVecRotated));
}
template <typename FourVector>
- FourVector COMBoost::fromCoM(FourVector const& p) const {
+ inline FourVector COMBoost::fromCoM(FourVector const& p) const {
auto pCM = p.getSpaceLikeComponents().getComponents(rotatedCS_);
auto const Ecm = p.getTimeLikeComponent();
@@ -105,7 +105,7 @@ namespace corsika {
return f;
}
- void COMBoost::setBoost(double coshEta, double sinhEta) {
+ inline void COMBoost::setBoost(double coshEta, double sinhEta) {
boost_ << coshEta, sinhEta, sinhEta, coshEta;
inverseBoost_ << coshEta, -sinhEta, -sinhEta, coshEta;
}
diff --git a/corsika/detail/framework/utility/SaveBoostHistogram.inl b/corsika/detail/framework/utility/SaveBoostHistogram.inl
index d7ac77a97..94e5e1bbc 100644
--- a/corsika/detail/framework/utility/SaveBoostHistogram.inl
+++ b/corsika/detail/framework/utility/SaveBoostHistogram.inl
@@ -8,7 +8,7 @@
#pragma once
-#include <cnpy/cnpy.hpp>
+#include <cnpy.hpp>
#include <boost/histogram.hpp>
@@ -23,7 +23,7 @@ namespace corsika {
template <class Axes, class Storage>
inline void save_hist(boost::histogram::histogram<Axes, Storage> const& h,
- std::string const& filename, SaveMode mode = SaveMode::append) {
+ std::string const& filename, SaveMode mode) {
unsigned const rank = h.rank();
// append vs. overwrite
diff --git a/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl b/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl
index 76ab3bd70..2ffaecefc 100644
--- a/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl
+++ b/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl
@@ -12,68 +12,112 @@
#include <corsika/framework/logging/Logging.hpp>
-#include <corsika/media/LayeredSphericalAtmosphereBuilder.hpp>
#include <corsika/media/FlatExponential.hpp>
#include <corsika/media/HomogeneousMedium.hpp>
#include <corsika/media/SlidingPlanarExponential.hpp>
namespace corsika {
- void LayeredSphericalAtmosphereBuilder::checkRadius(LengthType r) const {
+ template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
+ typename... TModelArgs>
+ void LayeredSphericalAtmosphereBuilder<TMediumInterface, TMediumModelExtra,
+ TModelArgs...>::checkRadius(LengthType r) const {
if (r <= previousRadius_) {
throw std::runtime_error("radius must be greater than previous");
}
}
- void LayeredSphericalAtmosphereBuilder::setNuclearComposition(
- NuclearComposition composition) {
+ template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
+ typename... TModelArgs>
+ void LayeredSphericalAtmosphereBuilder<
+ TMediumInterface, TMediumModelExtra,
+ TModelArgs...>::setNuclearComposition(NuclearComposition const& composition) {
composition_ = std::make_unique<NuclearComposition>(composition);
}
- void LayeredSphericalAtmosphereBuilder::addExponentialLayer(GrammageType b,
- LengthType c,
- LengthType upperBoundary) {
- auto const radius = seaLevel_ + upperBoundary;
+ template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
+ typename... TModelArgs>
+ void LayeredSphericalAtmosphereBuilder<
+ TMediumInterface, TMediumModelExtra,
+ TModelArgs...>::addExponentialLayer(GrammageType b, LengthType c,
+ LengthType upperBoundary) {
+
+ auto const radius = earthRadius_ + upperBoundary;
checkRadius(radius);
previousRadius_ = radius;
- auto node = std::make_unique<VolumeTreeNode<IMediumModel>>(
+ auto node = std::make_unique<VolumeTreeNode<TMediumInterface>>(
std::make_unique<Sphere>(center_, radius));
auto const rho0 = b / c;
- CORSIKA_LOG_INFO("rho0 = {}, c = {}", rho0, c);
- node->setModelProperties<SlidingPlanarExponential<IMediumModel>>(
- center_, rho0, -c, *composition_, seaLevel_);
+ if constexpr (detail::has_extra_models<TMediumModelExtra>::value) {
+ // helper lambda in which the last 5 arguments to make_shared<...> are bound
+ auto lastBound = [&](auto... argPack) {
+ return std::make_shared<
+ TMediumModelExtra<SlidingPlanarExponential<TMediumInterface>>>(
+ argPack..., center_, rho0, -c, *composition_, earthRadius_);
+ };
+
+ // now unpack the additional arguments
+ auto model = std::apply(lastBound, additionalModelArgs_);
+ node->setModelProperties(std::move(model));
+ } else {
+ node->template setModelProperties<SlidingPlanarExponential<TMediumInterface>>(
+ center_, rho0, -c, *composition_, earthRadius_);
+ }
layers_.push(std::move(node));
}
- void LayeredSphericalAtmosphereBuilder::addLinearLayer(LengthType c,
- LengthType upperBoundary) {
- auto const radius = seaLevel_ + upperBoundary;
+ template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
+ typename... TModelArgs>
+ void LayeredSphericalAtmosphereBuilder<
+ TMediumInterface, TMediumModelExtra,
+ TModelArgs...>::addLinearLayer(LengthType c, LengthType upperBoundary) {
+ auto const radius = earthRadius_ + upperBoundary;
checkRadius(radius);
previousRadius_ = radius;
- GrammageType constexpr b = 1 * 1_g / (1_cm * 1_cm);
+ auto node = std::make_unique<VolumeTreeNode<TMediumInterface>>(
+ std::make_unique<Sphere>(center_, radius));
+
+ units::si::GrammageType constexpr b = 1 * 1_g / (1_cm * 1_cm);
auto const rho0 = b / c;
- CORSIKA_LOG_INFO("rho0 = {}", rho0);
+ if constexpr (detail::has_extra_models<TMediumModelExtra>::value) {
+ // helper lambda in which the last 2 arguments to make_shared<...> are bound
+ auto lastBound = [&](auto... argPack) {
+ return std::make_shared<TMediumModelExtra<HomogeneousMedium<TMediumInterface>>>(
+ argPack..., rho0, *composition_);
+ };
- auto node = std::make_unique<VolumeTreeNode<IMediumModel>>(
- std::make_unique<Sphere>(center_, radius));
- node->setModelProperties<HomogeneousMedium<IMediumModel>>(rho0, *composition_);
+ // now unpack the additional arguments
+ auto model = std::apply(lastBound, additionalModelArgs_);
+
+ node->setModelProperties(std::move(model));
+ } else {
+ node->template setModelProperties<HomogeneousMedium<TMediumInterface>>(
+ rho0, *composition_);
+ }
layers_.push(std::move(node));
}
- Environment<IMediumModel> LayeredSphericalAtmosphereBuilder::assemble() {
- Environment<IMediumModel> env;
+ template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
+ typename... TModelArgs>
+ Environment<TMediumInterface> LayeredSphericalAtmosphereBuilder<
+ TMediumInterface, TMediumModelExtra, TModelArgs...>::assemble() {
+ Environment<TMediumInterface> env;
assemble(env);
return env;
}
- void LayeredSphericalAtmosphereBuilder::assemble(Environment<IMediumModel>& env) {
+ template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
+ typename... TModelArgs>
+ void LayeredSphericalAtmosphereBuilder<
+ TMediumInterface, TMediumModelExtra,
+ TModelArgs...>::assemble(Environment<TMediumInterface>& env) {
auto& universe = env.getUniverse();
auto* outmost = universe.get();
@@ -86,4 +130,14 @@ namespace corsika {
}
}
+ template <typename TMediumInterface, template <typename> typename MExtraEnvirnoment>
+ struct make_layered_spherical_atmosphere_builder {
+ template <typename... TArgs>
+ static auto create(Point const& center, LengthType earthRadius, TArgs... args) {
+ return LayeredSphericalAtmosphereBuilder<TMediumInterface, MExtraEnvirnoment,
+ TArgs...>{std::forward<TArgs>(args)...,
+ center, earthRadius};
+ }
+ };
+
} // namespace corsika
diff --git a/corsika/detail/media/NuclearComposition.inl b/corsika/detail/media/NuclearComposition.inl
index 4c2d9982f..230dfe1a1 100644
--- a/corsika/detail/media/NuclearComposition.inl
+++ b/corsika/detail/media/NuclearComposition.inl
@@ -46,7 +46,7 @@ namespace corsika {
}
template <typename TFunction>
- inline double NuclearComposition::getWeightedSum(TFunction const& func) const {
+ inline auto NuclearComposition::getWeightedSum(TFunction const& func) const {
using ResultQuantity = decltype(func(*components_.cbegin()));
auto const prod = [&](auto const compID, auto const fraction) {
diff --git a/corsika/detail/modules/ParticleCut.inl b/corsika/detail/modules/ParticleCut.inl
index f079c1a0b..3890b4510 100644
--- a/corsika/detail/modules/ParticleCut.inl
+++ b/corsika/detail/modules/ParticleCut.inl
@@ -14,20 +14,30 @@
namespace corsika::particle_cut {
+ ParticleCut::ParticleCut(const HEPEnergyType eCut, bool em, bool inv)
+ : energy_cut_(eCut)
+ , doCutEm_(em)
+ , doCutInv_(inv)
+ , energy_(0_GeV)
+ , em_energy_(0_GeV)
+ , em_count_(0)
+ , inv_energy_(0_GeV)
+ , inv_count_(0) {}
+
template <typename TParticle>
- bool ParticleCut::ParticleIsBelowEnergyCut(TParticle const& vP) const {
- auto const energyLab = vP.GetEnergy();
+ bool ParticleCut::isBelowEnergyCut(TParticle const& vP) const {
+ auto const energyLab = vP.getEnergy();
// nuclei
- if (vP.GetPID() == corsika::Code::Nucleus) {
+ if (vP.getPID() == Code::Nucleus) {
// calculate energy per nucleon
- auto const ElabNuc = energyLab / vP.GetNuclearA();
- return (ElabNuc < fECut);
+ auto const ElabNuc = energyLab / vP.getNuclearA();
+ return (ElabNuc < energy_cut_);
} else {
- return (energyLab < fECut);
+ return (energyLab < energy_cut_);
}
}
- bool ParticleCut::ParticleIsEmParticle(Code vCode) const {
+ bool ParticleCut::isEmParticle(Code vCode) const {
// FOR NOW: switch
switch (vCode) {
case Code::Gamma:
@@ -39,7 +49,7 @@ namespace corsika::particle_cut {
}
}
- bool ParticleCut::ParticleIsInvisible(Code vCode) const {
+ bool ParticleCut::isInvisible(Code vCode) const {
switch (vCode) {
case Code::NuE:
case Code::NuEBar:
@@ -52,57 +62,74 @@ namespace corsika::particle_cut {
}
}
+ template <typename TParticle>
+ bool ParticleCut::checkCutParticle(const TParticle& particle) {
+
+ const Code pid = particle.getPID();
+ HEPEnergyType energy = particle.getEnergy();
+ CORSIKA_LOG_DEBUG(fmt::format("ParticleCut: checking {}, E= {} GeV, EcutTot={} GeV",
+ pid, energy / 1_GeV,
+ (em_energy_ + inv_energy_ + energy_) / 1_GeV));
+ if (doCutEm_ && isEmParticle(pid)) {
+ CORSIKA_LOG_DEBUG("removing em. particle...");
+ em_energy_ += energy;
+ em_count_ += 1;
+ return true;
+ } else if (doCutInv_ && isInvisible(pid)) {
+ CORSIKA_LOG_DEBUG("removing inv. particle...");
+ inv_energy_ += energy;
+ inv_count_ += 1;
+ return true;
+ } else if (isBelowEnergyCut(particle)) {
+ CORSIKA_LOG_DEBUG("removing low en. particle...");
+ energy_ += energy;
+ return true;
+ } else if (particle.getTime() > 10_ms) {
+ CORSIKA_LOG_DEBUG("removing OLD particle...");
+ energy_ += energy;
+ return true;
+ }
+ return false; // this particle will not be removed/cut
+ }
+
void ParticleCut::doSecondaries(corsika::setup::StackView& vS) {
+ auto particle = vS.begin();
+ while (particle != vS.end()) {
+ if (checkCutParticle(particle)) { particle.erase(); }
+ ++particle; // next entry in SecondaryView
+ }
+ }
- auto p = vS.begin();
- while (p != vS.end()) {
- const Code pid = p.GetPID();
- HEPEnergyType energy = p.GetEnergy();
- std::cout << "ProcessCut: DoSecondaries: " << pid << " E= " << energy
- << ", EcutTot=" << (fEmEnergy + fInvEnergy + fEnergy) / 1_GeV << " GeV"
- << std::endl;
- if (ParticleIsEmParticle(pid)) {
- std::cout << "removing em. particle..." << std::endl;
- fEmEnergy += energy;
- fEmCount += 1;
- p.Delete();
- } else if (ParticleIsInvisible(pid)) {
- std::cout << "removing inv. particle..." << std::endl;
- fInvEnergy += energy;
- fInvCount += 1;
- p.Delete();
- } else if (ParticleIsBelowEnergyCut(p)) {
- std::cout << "removing low en. particle..." << std::endl;
- fEnergy += energy;
- p.Delete();
- } else if (p.GetTime() > 10_ms) {
- std::cout << "removing OLD particle..." << std::endl;
- fEnergy += energy;
- p.Delete();
- } else {
- ++p; // next entry in SecondaryView
- }
+ ProcessReturn ParticleCut::doContinuous(corsika::setup::Stack::particle_type& particle,
+ corsika::setup::Trajectory const&) {
+ CORSIKA_LOG_TRACE("ParticleCut::DoContinuous");
+ if (checkCutParticle(particle)) {
+ CORSIKA_LOG_TRACE("removing during continuous");
+ particle.erase();
+ // signal to upstream code that this particle was deleted
+ return ProcessReturn::ParticleAbsorbed;
}
+ return ProcessReturn::Ok;
}
- void ParticleCut::Init() {
- fEmEnergy = 0_GeV;
- fEmCount = 0;
- fInvEnergy = 0_GeV;
- fInvCount = 0;
- fEnergy = 0_GeV;
- // defineEmParticles();
+ void ParticleCut::showResults() {
+ CORSIKA_LOG_INFO(
+ " ******************************\n"
+ " energy in em. component (GeV): {} \n "
+ " no. of em. particles injected: {} \n "
+ " energy in inv. component (GeV): {} \n "
+ " no. of inv. particles injected: {} \n "
+ " energy below particle cut (GeV): {} \n"
+ " ******************************",
+ em_energy_ / 1_GeV, em_count_, inv_energy_ / 1_GeV, inv_count_, energy_ / 1_GeV);
}
- void ParticleCut::ShowResults() {
- std::cout << " ******************************" << std::endl
- << " ParticleCut: " << std::endl
- << " energy in em. component (GeV): " << fEmEnergy / 1_GeV << std::endl
- << " no. of em. particles injected: " << fEmCount << std::endl
- << " energy in inv. component (GeV): " << fInvEnergy / 1_GeV << std::endl
- << " no. of inv. particles injected: " << fInvCount << std::endl
- << " energy below particle cut (GeV): " << fEnergy / 1_GeV << std::endl
- << " ******************************" << std::endl;
+ void ParticleCut::reset() {
+ em_energy_ = 0_GeV;
+ em_count_ = 0;
+ inv_energy_ = 0_GeV;
+ inv_count_ = 0;
+ energy_ = 0_GeV;
}
} // namespace corsika::particle_cut
diff --git a/corsika/detail/modules/StackInspector.inl b/corsika/detail/modules/StackInspector.inl
index bd9487bc0..5ddedeb1c 100644
--- a/corsika/detail/modules/StackInspector.inl
+++ b/corsika/detail/modules/StackInspector.inl
@@ -43,19 +43,17 @@ namespace corsika::stack_inspector {
HEPEnergyType Etot = 0_GeV;
for (const auto& iterP : vS) {
- HEPEnergyType E = iterP.GetEnergy();
+ HEPEnergyType E = iterP.getEnergy();
Etot += E;
if (ReportStack_) {
- corsika::CoordinateSystem& rootCS =
- corsika::RootCoordinateSystem::getInstance()
- .GetRootCoordinateSystem(); // for printout
- auto pos = iterP.GetPosition().GetCoordinates(rootCS);
+ CoordinateSystemPtr const& rootCS = get_root_CoordinateSystem(); // for printout
+ auto pos = iterP.getPosition().getCoordinates(rootCS);
std::cout << "StackInspector: i=" << std::setw(5) << std::fixed << (i++)
- << ", id=" << std::setw(30) << iterP.GetPID() << " E=" << std::setw(15)
+ << ", id=" << std::setw(30) << iterP.getPID() << " E=" << std::setw(15)
<< std::scientific << (E / 1_GeV) << " GeV, "
- << " pos=" << pos << " node = " << iterP.GetNode();
- if (iterP.GetPID() == Code::Nucleus)
- std::cout << " nuc_ref=" << iterP.GetNucleusRef();
+ << " pos=" << pos << " node = " << iterP.getNode();
+ if (iterP.getPID() == Code::Nucleus)
+ std::cout << " nuc_ref=" << iterP.getNucleusRef();
std::cout << std::endl;
}
}
@@ -75,15 +73,9 @@ namespace corsika::stack_inspector {
<< " time=" << std::put_time(std::localtime(&now_time), "%T")
<< ", running=" << elapsed_seconds.count() << " seconds"
<< " (" << std::setw(3) << int(progress * 100) << "%)"
- << ", nStep=" << getStep() << ", stackSize=" << vS.GetSize()
+ << ", nStep=" << getStep() << ", stackSize=" << vS.getSize()
<< ", Estack=" << Etot / 1_GeV << " GeV"
<< ", ETA=" << std::put_time(std::localtime(&eta_time), "%T") << std::endl;
}
- template <typename TStack>
- void StackInspector<TStack>::Init() {
- ReportStack_ = false;
- StartTime_ = std::chrono::system_clock::now();
- }
-
} // namespace corsika::stack_inspector
\ No newline at end of file
diff --git a/corsika/detail/modules/TrackWriter.inl b/corsika/detail/modules/TrackWriter.inl
index 1e28bf213..d22ea176b 100644
--- a/corsika/detail/modules/TrackWriter.inl
+++ b/corsika/detail/modules/TrackWriter.inl
@@ -22,37 +22,38 @@
namespace corsika::track_writer {
- void TrackWriter::Init() {
+ TrackWriter::TrackWriter(std::string const& filename)
+ : filename_(filename) {
using namespace std::string_literals;
- fFile.open(fFilename);
- fFile << "# PID, E / eV, start coordinates / m, displacement vector to end / m "s
+ file_.open(filename_);
+ file_ << "# PID, E / eV, start coordinates / m, displacement vector to end / m "s
<< '\n';
}
template <typename TParticle, typename TTrack>
- corsika::ProcessReturn TrackWriter::doContinuous(const TParticle& vP,
+ ProcessReturn TrackWriter::doContinuous(const TParticle& vP,
const TTrack& vT) {
- auto const start = vT.GetPosition(0).GetCoordinates();
- auto const delta = vT.GetPosition(1).GetCoordinates() - start;
- auto const pdg = static_cast<int>(corsika::get_PDG(vP.GetPID()));
+ auto const start = vT.getPosition(0).getCoordinates();
+ auto const delta = vT.getPosition(1).getCoordinates() - start;
+ auto const pdg = static_cast<int>(get_PDG(vP.getPID()));
// clang-format off
- fFile << std::setw(7) << pdg
- << std::setw(width) << std::scientific << std::setprecision(precision) << vP.GetEnergy() / 1_eV
- << std::setw(width) << std::scientific << std::setprecision(precision) << start[0] / 1_m
- << std::setw(width) << std::scientific << std::setprecision(precision) << start[1] / 1_m
- << std::setw(width) << std::scientific << std::setprecision(precision) << start[2] / 1_m
- << std::setw(width) << std::scientific << std::setprecision(precision) << delta[0] / 1_m
- << std::setw(width) << std::scientific << std::setprecision(precision) << delta[1] / 1_m
- << std::setw(width) << std::scientific << std::setprecision(precision) << delta[2] / 1_m << '\n';
+ file_ << std::setw(7) << pdg
+ << std::setw(width_) << std::scientific << std::setprecision(precision_) << vP.getEnergy() / 1_eV
+ << std::setw(width_) << std::scientific << std::setprecision(precision_) << start[0] / 1_m
+ << std::setw(width_) << std::scientific << std::setprecision(precision_) << start[1] / 1_m
+ << std::setw(width_) << std::scientific << std::setprecision(precision_) << start[2] / 1_m
+ << std::setw(width_) << std::scientific << std::setprecision(precision_) << delta[0] / 1_m
+ << std::setw(width_) << std::scientific << std::setprecision(precision_) << delta[1] / 1_m
+ << std::setw(width_) << std::scientific << std::setprecision(precision_) << delta[2] / 1_m << '\n';
// clang-format on
- return corsika::ProcessReturn::Ok;
+ return ProcessReturn::Ok;
}
template <typename TParticle, typename TTrack>
- LengthType TrackWriter::MaxStepLength(const TParticle&, const TTrack&) {
+ LengthType TrackWriter::getMaxStepLength(const TParticle&, const TTrack&) {
return meter * std::numeric_limits<double>::infinity();
}
diff --git a/corsika/detail/modules/TrackingLine.inl b/corsika/detail/modules/TrackingLine.inl
index d75d93e79..6f0f32304 100644
--- a/corsika/detail/modules/TrackingLine.inl
+++ b/corsika/detail/modules/TrackingLine.inl
@@ -26,15 +26,15 @@ namespace corsika::tracking_line {
std::optional<std::pair<TimeType, TimeType>> TimeOfIntersection(
corsika::Line const& line, corsika::Sphere const& sphere) {
- auto const delta = line.GetR0() - sphere.GetCenter();
- auto const v = line.GetV0();
+ auto const delta = line.getStartPoint() - sphere.getCenter();
+ auto const v = line.getVelocity();
auto const vSqNorm =
- v.squaredNorm(); // todo: get rid of this by having V0 normalized always
- auto const R = sphere.GetRadius();
+ v.getSquaredNorm(); // todo: get rid of this by having V0 normalized always
+ auto const R = sphere.getRadius();
auto const vDotDelta = v.dot(delta);
auto const discriminant =
- vDotDelta * vDotDelta - vSqNorm * (delta.squaredNorm() - R * R);
+ vDotDelta * vDotDelta - vSqNorm * (delta.getSquaredNorm() - R * R);
if (discriminant.magnitude() > 0) {
auto const sqDisc = sqrt(discriminant);
@@ -46,11 +46,11 @@ namespace corsika::tracking_line {
}
}
- TimeType TimeOfIntersection(Line const& vLine, Plane const& vPlane) {
+ TimeType getTimeOfIntersection(Line const& vLine, Plane const& vPlane) {
- auto const delta = vPlane.GetCenter() - vLine.GetR0();
- auto const v = vLine.GetV0();
- auto const n = vPlane.GetNormal();
+ auto const delta = vPlane.getCenter() - vLine.getStartPoint();
+ auto const v = vLine.getVelocity();
+ auto const n = vPlane.getNormal();
auto const c = n.dot(v);
if (c.magnitude() == 0) {
diff --git a/corsika/detail/modules/energy_loss/BetheBlochPDG.inl b/corsika/detail/modules/energy_loss/BetheBlochPDG.inl
index 76d64479a..9ba0107a9 100644
--- a/corsika/detail/modules/energy_loss/BetheBlochPDG.inl
+++ b/corsika/detail/modules/energy_loss/BetheBlochPDG.inl
@@ -10,44 +10,33 @@
#pragma once
-#include <corsika/modules/energy_loss/BetheBlochPDG.hpp>
-
#include <corsika/framework/core/ParticleProperties.hpp>
#include <corsika/setup/SetupStack.hpp>
#include <corsika/setup/SetupTrajectory.hpp>
#include <corsika/framework/geometry/Line.hpp>
+#include <corsika/framework/logging/Logging.hpp>
#include <cmath>
#include <fstream>
-#include <iostream>
#include <limits>
-using SetupParticle = corsika::setup::Stack::ParticleType;
-using SetupTrack = corsika::setup::Trajectory;
-
namespace corsika::energy_loss {
auto elab2plab = [](HEPEnergyType Elab, HEPMassType m) {
return sqrt((Elab - m) * (Elab + m));
};
- /**
- * PDG2018, passage of particles through matter
- *
- * Note, that \f$I_{\mathrm{eff}}\f$ of composite media a determined from \f$ \ln I =
- * \sum_i a_i \ln(I_i) \f$ where \f$ a_i \f$ is the fraction of the electron population
- * (\f$\sim Z_i\f$) of the \f$i\f$-th element. This can also be used for shell
- * corrections or density effects.
- *
- * The \f$I_{\mathrm{eff}}\f$ of compounds is not better than a few percent, if not
- * measured explicitly.
- *
- * For shell correction, see Sec 6 of https://www.nap.edu/read/20066/chapter/8#115
- *
- */
- HEPEnergyType BetheBlochPDG::BetheBloch(SetupParticle const& p, GrammageType const dX) {
+ BetheBlochPDG::BetheBlochPDG(ShowerAxis const& shower_axis, HEPEnergyType emCut)
+ : dX_(10_g / square(1_cm)) // profile binning
+ , dX_threshold_(0.0001_g / square(1_cm))
+ , shower_axis_(shower_axis)
+ , emCut_(emCut)
+ , profile_(int(shower_axis.getMaximumX() / dX_) + 1) {}
+
+ HEPEnergyType BetheBlochPDG::getBetheBloch(setup::Stack::particle_type const& p,
+ GrammageType const dX) {
// all these are material constants and have to come through Environment
// right now: values for nitrogen_D
@@ -65,12 +54,12 @@ namespace corsika::energy_loss {
// this is the Bethe-Bloch coefficiet 4pi N_A r_e^2 m_e c^2
auto constexpr K = 0.307075_MeV / 1_mol * square(1_cm);
- HEPEnergyType const E = p.GetEnergy();
- HEPMassType const m = p.GetMass();
+ HEPEnergyType const E = p.getEnergy();
+ HEPMassType const m = p.getMass();
double const gamma = E / m;
- int const Z = p.GetChargeNumber();
+ int const Z = p.getChargeNumber();
int const Z2 = Z * Z;
- HEPMassType constexpr me = corsika::Electron::mass;
+ HEPMassType constexpr me = Electron::mass;
auto const m2 = m * m;
auto constexpr me2 = me * me;
double const gamma2 = gamma * gamma;
@@ -78,20 +67,20 @@ namespace corsika::energy_loss {
double const beta2 = (gamma2 - 1) / gamma2; // 1-1/gamma2 (1-1/gamma)*(1+1/gamma);
// (gamma_2-1)/gamma_2 = (1-1/gamma2);
double constexpr c2 = 1; // HEP convention here c=c2=1
- std::cout << "BetheBloch beta2=" << beta2 << " gamma2=" << gamma2 << std::endl;
+ CORSIKA_LOG_DEBUG("BetheBloch beta2={}, gamma2={}", beta2, gamma2);
[[maybe_unused]] double const eta2 = beta2 / (1 - beta2);
HEPMassType const Wmax =
2 * me * c2 * beta2 * gamma2 / (1 + 2 * gamma * me / m + me2 / m2);
// approx, but <<1% HEPMassType const Wmax = 2*me*c2*beta2*gamma2; for HEAVY
// PARTICLES Wmax ~ 2me v2 for non-relativistic particles
- std::cout << "BetheBloch Wmax=" << Wmax << std::endl;
+ CORSIKA_LOG_DEBUG("BetheBloch Wmax={}", Wmax);
// Sternheimer parameterization, density corrections towards high energies
// NOTE/TODO: when Cbar is 0 it needs to be approximated from parameterization ->
// MISSING
- std::cout << "BetheBloch p.GetMomentum().GetNorm()/m="
- << p.GetMomentum().GetNorm() / m << std::endl;
- double const x = log10(p.GetMomentum().GetNorm() / m);
+ CORSIKA_LOG_DEBUG("BetheBloch p.getMomentum().getNorm()/m{}=",
+ p.getMomentum().getNorm() / m);
+ double const x = log10(p.getMomentum().getNorm() / m);
double delta = 0;
if (x >= x1) {
delta = 2 * (log(10)) * x - Cbar;
@@ -100,7 +89,7 @@ namespace corsika::energy_loss {
} else if (x < x0) { // and IF conductor (otherwise, this is 0)
delta = delta0 * pow(100, 2 * (x - x0));
}
- std::cout << "BetheBloch delta=" << delta << std::endl;
+ CORSIKA_LOG_DEBUG("BetheBloch delta={}", delta);
// with further low energies correction, accurary ~1% down to beta~0.05 (1MeV for p)
@@ -120,8 +109,8 @@ namespace corsika::energy_loss {
// Barkas correction O(Z3) higher-order Born approximation
// see Appl. Phys. 85 (1999) 1249
// double A = 1;
- // if (p.GetPID() == corsika::Code::Nucleus) A = p.GetNuclearA();
- // double const Erel = (p.GetEnergy()-p.GetMass()) / A / 1_keV;
+ // if (p.getPID() == Code::Nucleus) A = p.getNuclearA();
+ // double const Erel = (p.getEnergy()-p.getMass()) / A / 1_keV;
// double const Llow = 0.01 * Erel;
// double const Lhigh = 1.5/pow(Erel, 0.4) + 45000./Zmat * pow(Erel, 1.6);
// double const barkas = Z * Llow*Lhigh/(Llow+Lhigh); // RU, I think the Z was
@@ -134,141 +123,141 @@ namespace corsika::energy_loss {
double const y2 = Z * Z * alpha * alpha / beta2;
double const bloch = -y2 * (1.202 - y2 * (1.042 - 0.855 * y2 + 0.343 * y2 * y2));
- // std::cout << "BetheBloch Erel=" << Erel << " barkas=" << barkas << " bloch=" <<
- // bloch << std::endl;
-
double const aux = 2 * me * c2 * beta2 * gamma2 * Wmax / (Ieff * Ieff);
return -K * Z2 * ZoverA / beta2 *
(0.5 * log(aux) - beta2 - Cadj / Z - delta / 2 + barkas + bloch) * dX;
}
// radiation losses according to PDG 2018, ch. 33 ref. [5]
- HEPEnergyType BetheBlochPDG::RadiationLosses(SetupParticle const& vP,
- GrammageType const vDX) {
+ HEPEnergyType BetheBlochPDG::getRadiationLosses(setup::Stack::particle_type const& vP,
+ GrammageType const vDX) {
// simple-minded hard-coded value for b(E) inspired by data from
// http://pdg.lbl.gov/2018/AtomicNuclearProperties/ for N and O.
auto constexpr b = 3.0 * 1e-6 * square(1_cm) / 1_g;
- return -vP.GetEnergy() * b * vDX;
+ return -vP.getEnergy() * b * vDX;
}
- HEPEnergyType BetheBlochPDG::TotalEnergyLoss(SetupParticle const& vP,
- GrammageType const vDX) {
- return BetheBloch(vP, vDX) + RadiationLosses(vP, vDX);
+ HEPEnergyType BetheBlochPDG::getTotalEnergyLoss(setup::Stack::particle_type const& vP,
+ GrammageType const vDX) {
+ return getBetheBloch(vP, vDX) + getRadiationLosses(vP, vDX);
}
- corsika::ProcessReturn BetheBlochPDG::doContinuous(SetupParticle& p,
- SetupTrack const& t) {
- if (p.GetChargeNumber() == 0) return corsika::ProcessReturn::Ok;
+ ProcessReturn BetheBlochPDG::doContinuous(setup::Stack::particle_type& p,
+ setup::Trajectory const& t) {
+ if (p.getChargeNumber() == 0) return ProcessReturn::Ok;
GrammageType const dX =
- p.GetNode()->GetModelProperties().getIntegratedGrammage(t, t.GetLength());
- std::cout << "BetheBlochPDG " << p.GetPID() << ", z=" << p.GetChargeNumber()
- << ", dX=" << dX / 1_g * square(1_cm) << "g/cm2" << std::endl;
- HEPEnergyType dE = TotalEnergyLoss(p, dX);
- auto E = p.GetEnergy();
- const auto Ekin = E - p.GetMass();
+ p.getNode()->getModelProperties().getIntegratedGrammage(t, t.getLength());
+ CORSIKA_LOG_DEBUG("EnergyLoss pid={}, z={}, dX={} g/cm2", p.getPID(),
+ p.getChargeNumber(), dX / 1_g * square(1_cm));
+ HEPEnergyType dE = getTotalEnergyLoss(p, dX);
+ auto E = p.getEnergy();
+ const auto Ekin = E - p.getMass();
auto Enew = E + dE;
- std::cout << "BetheBlochPDG dE=" << dE / 1_MeV << "MeV, "
- << " E=" << E / 1_GeV << "GeV, Ekin=" << Ekin / 1_GeV
- << ", Enew=" << Enew / 1_GeV << "GeV" << std::endl;
- auto status = corsika::ProcessReturn::Ok;
- if (-dE > Ekin) {
- dE = -Ekin;
- Enew = p.GetMass();
- status = corsika::ProcessReturn::ParticleAbsorbed;
- }
- p.SetEnergy(Enew);
- MomentumUpdate(p, Enew);
- BetheBlochPDGTot_ += dE;
- FillProfile(p, t, dE);
- return status;
+ CORSIKA_LOG_DEBUG("EnergyLoss dE={} MeV, E={} GeV, Ekin={} GeV, Enew={} GeV",
+ dE / 1_MeV, E / 1_GeV, Ekin / 1_GeV, Enew / 1_GeV);
+ p.setEnergy(Enew);
+ updateMomentum(p, Enew);
+ fillProfile(t, dE);
+ return ProcessReturn::Ok;
}
- LengthType BetheBlochPDG::MaxStepLength(SetupParticle const& vParticle,
- SetupTrack const& vTrack) const {
- if (vParticle.GetChargeNumber() == 0) {
+ LengthType BetheBlochPDG::getMaxStepLength(setup::Stack::particle_type const& vParticle,
+ setup::Trajectory const& vTrack) const {
+ if (vParticle.getChargeNumber() == 0) {
return meter * std::numeric_limits<double>::infinity();
}
auto constexpr dX = 1_g / square(1_cm);
- auto const dE = -TotalEnergyLoss(vParticle, dX); // dE > 0
- //~ auto const Ekin = vParticle.GetEnergy() - vParticle.GetMass();
- auto const maxLoss = 0.01 * vParticle.GetEnergy();
- auto const maxGrammage = maxLoss / dE * dX;
-
- return vParticle.GetNode()->GetModelProperties().getArclengthFromGrammage(
- vTrack,
- maxGrammage) *
- 1.0001; // to make sure particle gets absorbed when DoContinuous() is called
+ auto const dEdX = -getTotalEnergyLoss(vParticle, dX) / dX; // dE > 0
+ //~ auto const Ekin = vParticle.getEnergy() - vParticle.getMass();
+
+ // in any case: never go below 0.99*emCut_ This needs to be
+ // slightly smaller than emCut_ since, either this Step is limited
+ // by energy_lim, then the particle is stopped in a very short
+ // range (before doing anythin else) and is then removed
+ // instantly. The exact position where it reaches emCut is not
+ // important, the important fact is that its E_kin is zero
+ // afterwards.
+ //
+ const auto energy = vParticle.getEnergy();
+ auto energy_lim = std::max(0.9 * energy, 0.99 * emCut_);
+
+ auto const maxGrammage = (energy - energy_lim) / dEdX;
+
+ return vParticle.getNode()->getModelProperties().getArclengthFromGrammage(
+ vTrack, maxGrammage);
}
- void BetheBlochPDG::MomentumUpdate(corsika::setup::Stack::ParticleType& vP,
+ void BetheBlochPDG::updateMomentum(corsika::setup::Stack::particle_type& vP,
HEPEnergyType Enew) {
- HEPMomentumType Pnew = elab2plab(Enew, vP.GetMass());
- auto pnew = vP.GetMomentum();
- vP.SetMomentum(pnew * Pnew / pnew.GetNorm());
+ HEPMomentumType Pnew = elab2plab(Enew, vP.getMass());
+ auto pnew = vP.getMomentum();
+ vP.setMomentum(pnew * Pnew / pnew.getNorm());
}
- void BetheBlochPDG::FillProfile(SetupParticle const& vP, SetupTrack const& vTrack,
+ void BetheBlochPDG::fillProfile(setup::Trajectory const& vTrack,
const HEPEnergyType dE) {
- auto const toStart = vTrack.GetPosition(0) - InjectionPoint_;
- auto const toEnd = vTrack.GetPosition(1) - InjectionPoint_;
-
- auto const v1 = (toStart * 1_Hz).dot(ShowerAxisDirection_);
- auto const v2 = (toEnd * 1_Hz).dot(ShowerAxisDirection_);
- corsika::Line const lineToStartBin(InjectionPoint_, ShowerAxisDirection_ * v1);
- corsika::Line const lineToEndBin(InjectionPoint_, ShowerAxisDirection_ * v2);
-
- SetupTrack const trajToStartBin(lineToStartBin, 1_s);
- SetupTrack const trajToEndBin(lineToEndBin, 1_s);
-
- GrammageType const grammageStart =
- vP.GetNode()->GetModelProperties().getIntegratedGrammage(
- trajToStartBin, trajToStartBin.GetLength());
- GrammageType const grammageEnd =
- vP.GetNode()->GetModelProperties().getIntegratedGrammage(
- trajToEndBin, trajToEndBin.GetLength());
+ GrammageType const grammageStart = shower_axis_.getProjectedX(vTrack.getPosition(0));
+ GrammageType const grammageEnd = shower_axis_.getProjectedX(vTrack.getPosition(1));
+ const auto deltaX = grammageEnd - grammageStart;
- const int binStart = grammageStart / dX_;
- const int binEnd = grammageEnd / dX_;
+ int binStart = grammageStart / dX_;
+ if (binStart < 0) return;
+ int binEnd = grammageEnd / dX_;
+ if (binEnd > int(profile_.size() - 1)) return;
+ if (deltaX < dX_threshold_) return;
- std::cout << "energy deposit of " << -dE << " between " << grammageStart << " and "
- << grammageEnd << std::endl;
+ CORSIKA_LOG_DEBUG("energy deposit of -dE={} between {} and {}", -dE, grammageStart,
+ grammageEnd);
auto energyCount = HEPEnergyType::zero();
- auto fill = [&](int bin, GrammageType weight) {
- const auto dX = grammageEnd - grammageStart;
- if (dX > dX_threshold_) {
- auto const increment = -dE * weight / (grammageEnd - grammageStart);
- Profile_[bin] += increment;
- energyCount += increment;
+ auto fill = [&](const int bin, const double weight) {
+ auto const increment = -dE * weight;
+ profile_[bin] += increment;
+ energyCount += increment;
- std::cout << "filling bin " << bin << " with weight " << weight << ": "
- << increment << std::endl;
- }
+ CORSIKA_LOG_DEBUG("filling bin {} with weight {} : {} ", bin, weight, increment);
};
// fill longitudinal profile
- fill(binStart, (1 + binStart) * dX_ - grammageStart);
- fill(binEnd, grammageEnd - binEnd * dX_);
-
- if (binStart == binEnd) { fill(binStart, -dX_); }
-
- for (int bin = binStart + 1; bin < binEnd; ++bin) { fill(bin, dX_); }
+ if (binStart == binEnd) {
+ fill(binStart, 1);
+ } else {
+ fill(binStart, ((1 + binStart) * dX_ - grammageStart) / deltaX);
+ fill(binEnd, (grammageEnd - binEnd * dX_) / deltaX);
+ for (int bin = binStart + 1; bin < binEnd; ++bin) { fill(bin, 1); }
+ }
- std::cout << "total energy added to histogram: " << energyCount << std::endl;
+ CORSIKA_LOG_DEBUG("total energy added to histogram: {} ", energyCount);
}
- void BetheBlochPDG::PrintProfile() const {
- std::ofstream file("BetheBlochPDGProfile.dat");
- std::cout << "# BetheBlochPDG PrintProfile X-bin [g/cm2] dE/dX [GeV/g/cm2] "
- << std::endl;
+ void BetheBlochPDG::printProfile() const {
+ std::ofstream file("EnergyLossProfile.dat");
+ file << "# EnergyLoss profile" << std::endl
+ << "# lower X bin edge [g/cm2] dE/dX [GeV/g/cm2]\n";
double const deltaX = dX_ / 1_g * square(1_cm);
- for (auto v : Profile_) {
- file << v.first * deltaX << " " << v.second / (deltaX * 1_GeV) << std::endl;
+ for (size_t i = 0; i < profile_.size(); ++i) {
+ file << std::scientific << std::setw(15) << i * deltaX << std::setw(15)
+ << profile_.at(i) / (deltaX * 1_GeV) << '\n';
}
+ file.close();
+ }
+
+ HEPEnergyType BetheBlochPDG::getTotal() const {
+ return std::accumulate(profile_.cbegin(), profile_.cend(), HEPEnergyType::zero());
+ }
+
+ void BetheBlochPDG::showResults() const {
+ CORSIKA_LOG_INFO(
+ " ******************************\n"
+ " PROCESS::ContinuousProcess: \n"
+ " energy lost dE (GeV) : {}\n ",
+ energy_lost_ / 1_GeV);
}
+ void BetheBlochPDG::reset() { energy_lost_ = 0_GeV; }
+
} // namespace corsika::energy_loss
diff --git a/corsika/detail/modules/qgsjetII/Interaction.inl b/corsika/detail/modules/qgsjetII/Interaction.inl
index 35bb3f882..7a9287276 100644
--- a/corsika/detail/modules/qgsjetII/Interaction.inl
+++ b/corsika/detail/modules/qgsjetII/Interaction.inl
@@ -37,37 +37,33 @@ namespace corsika::qgsjetII {
std::cout << "Searching for QGSJetII data tables in " << data_path_ << std::endl;
}
}
- }
-
- Interaction::~Interaction() {
- std::cout << "QgsjetII::Interaction n=" << count_ << std::endl;
- }
-
- void Interaction::Init() {
-
- using corsika::RNGManager;
// initialize QgsjetII
- if (!initialized_) {
+ static bool initialized = false;
+ if (!initialized) {
qgset_();
datadir DIR(data_path_);
qgaini_(DIR.data);
- initialized_ = true;
+ initialized = true;
}
}
- CrossSectionType Interaction::GetCrossSection(const corsika::Code beamId,
- const corsika::Code targetId,
+ Interaction::~Interaction() {
+ std::cout << "QgsjetII::Interaction n=" << count_ << std::endl;
+ }
+
+ CrossSectionType Interaction::getCrossSection(const Code beamId,
+ const Code targetId,
const HEPEnergyType Elab,
const unsigned int Abeam,
const unsigned int targetA) const {
double sigProd = std::numeric_limits<double>::infinity();
- if (corsika::qgsjetII::CanInteract(beamId)) {
+ if (corsika::qgsjetII::canInteract(beamId)) {
- const int iBeam = corsika::qgsjetII::GetQgsjetIIXSCode(beamId);
+ int const iBeam = static_cast<QgsjetIIXSClassIntType>(corsika::qgsjetII::getQgsjetIIXSCode(beamId));
int iTarget = 1;
- if (corsika::is_nucleus(targetId)) {
+ if (is_nucleus(targetId)) {
iTarget = targetA;
if (iTarget > maxMassNumber_ || iTarget <= 0) {
std::ostringstream txt;
@@ -76,49 +72,48 @@ namespace corsika::qgsjetII {
}
}
int iProjectile = 1;
- if (corsika::is_nucleus(beamId)) {
+ if (is_nucleus(beamId)) {
iProjectile = Abeam;
if (iProjectile > maxMassNumber_ || iProjectile <= 0)
throw std::runtime_error("QgsjetII target outside range. ");
}
- std::cout << "QgsjetII::GetCrossSection Elab=" << Elab << " iBeam=" << iBeam
+ std::cout << "QgsjetII::getCrossSection Elab=" << Elab << " iBeam=" << iBeam
<< " iProjectile=" << iProjectile << " iTarget=" << iTarget << std::endl;
sigProd = qgsect_(Elab / 1_GeV, iBeam, iProjectile, iTarget);
- std::cout << "QgsjetII::GetCrossSection sigProd=" << sigProd << std::endl;
+ std::cout << "QgsjetII::getCrossSection sigProd=" << sigProd << std::endl;
}
return sigProd * 1_mb;
}
template <typename TParticle>
- GrammageType Interaction::GetInteractionLength(const TParticle& vP) const {
+ GrammageType Interaction::getInteractionLength(const TParticle& vP) const {
// coordinate system, get global frame of reference
- CoordinateSystem& rootCS =
- RootCoordinateSystem::getInstance().GetRootCoordinateSystem();
+ CoordinateSystemPtr const& rootCS = get_root_CoordinateSystem();
- const corsika::Code corsikaBeamId = vP.GetPID();
+ const Code corsikaBeamId = vP.getPID();
// beam particles for qgsjetII : 1, 2, 3 for p, pi, k
// read from cross section code table
- const bool kInteraction = corsika::qgsjetII::CanInteract(corsikaBeamId);
+ const bool kInteraction = corsika::qgsjetII::canInteract(corsikaBeamId);
// FOR NOW: assume target is at rest
MomentumVector pTarget(rootCS, {0_GeV, 0_GeV, 0_GeV});
// total momentum and energy
- HEPEnergyType Elab = vP.GetEnergy();
+ HEPEnergyType Elab = vP.getEnergy();
std::cout << "Interaction: LambdaInt: \n"
- << " input energy: " << vP.GetEnergy() / 1_GeV << std::endl
+ << " input energy: " << vP.getEnergy() / 1_GeV << std::endl
<< " beam can interact:" << kInteraction << std::endl
- << " beam pid:" << vP.GetPID() << std::endl;
+ << " beam pid:" << vP.getPID() << std::endl;
if (kInteraction) {
int Abeam = 0;
- if (corsika::is_nucleus(vP.GetPID())) Abeam = vP.GetNuclearA();
+ if (is_nucleus(vP.getPID())) Abeam = vP.getNuclearA();
// get target from environment
/*
@@ -127,15 +122,15 @@ namespace corsika::qgsjetII {
and the boosts can be defined..
*/
- auto const* currentNode = vP.GetNode();
+ auto const* currentNode = vP.getNode();
const auto& mediumComposition =
- currentNode->GetModelProperties().getNuclearComposition();
+ currentNode->getModelProperties().getNuclearComposition();
CrossSectionType weightedProdCrossSection =
- mediumComposition.WeightedSum([=](corsika::Code targetID) -> CrossSectionType {
+ mediumComposition.getWeightedSum([=](Code targetID) -> CrossSectionType {
int targetA = 0;
- if (corsika::is_nucleus(targetID)) targetA = corsika::get_nucleus_A(targetID);
- return GetCrossSection(corsikaBeamId, targetID, Elab, Abeam, targetA);
+ if (is_nucleus(targetID)) targetA = get_nucleus_A(targetID);
+ return getCrossSection(corsikaBeamId, targetID, Elab, Abeam, targetA);
});
std::cout << "Interaction: "
@@ -143,7 +138,7 @@ namespace corsika::qgsjetII {
<< weightedProdCrossSection / 1_mb << std::endl;
// calculate interaction length in medium
- GrammageType const int_length = mediumComposition.GetAverageMassNumber() *
+ GrammageType const int_length = mediumComposition.getAverageMassNumber() *
constants::u / weightedProdCrossSection;
std::cout << "Interaction: "
<< "interaction length (g/cm2): " << int_length / (0.001_kg) * 1_cm * 1_cm
@@ -163,19 +158,18 @@ namespace corsika::qgsjetII {
template <typename TParticle>
void Interaction::doInteraction(TParticle& vP) {
- const auto corsikaBeamId = vP.GetPID();
+ const auto corsikaBeamId = vP.getPID();
std::cout << "ProcessQgsjetII: "
<< "DoInteraction: " << corsikaBeamId << " interaction? "
- << corsika::qgsjetII::CanInteract(corsikaBeamId) << std::endl;
+ << corsika::qgsjetII::canInteract(corsikaBeamId) << std::endl;
- if (corsika::qgsjetII::CanInteract(corsikaBeamId)) {
+ if (corsika::qgsjetII::canInteract(corsikaBeamId)) {
- const CoordinateSystem& rootCS =
- RootCoordinateSystem::getInstance().GetRootCoordinateSystem();
+ CoordinateSystemPtr const& rootCS = get_root_CoordinateSystem();
// position and time of interaction, not used in QgsjetII
- Point pOrig = vP.GetPosition();
- TimeType tOrig = vP.GetTime();
+ Point pOrig = vP.getPosition();
+ TimeType tOrig = vP.getTime();
// define target
// for QgsjetII is always a single nucleon
@@ -185,58 +179,58 @@ namespace corsika::qgsjetII {
const FourVector PtargLab(targetEnergyLab, targetMomentumLab);
// define projectile
- HEPEnergyType const projectileEnergyLab = vP.GetEnergy();
- auto const projectileMomentumLab = vP.GetMomentum();
+ HEPEnergyType const projectileEnergyLab = vP.getEnergy();
+ auto const projectileMomentumLab = vP.getMomentum();
int beamA = 0;
- if (corsika::is_nucleus(corsikaBeamId)) beamA = vP.GetNuclearA();
+ if (is_nucleus(corsikaBeamId)) beamA = vP.getNuclearA();
std::cout << "Interaction: ebeam lab: " << projectileEnergyLab / 1_GeV << std::endl
<< "Interaction: pbeam lab: "
- << projectileMomentumLab.GetComponents() / 1_GeV << std::endl;
+ << projectileMomentumLab.getComponents() / 1_GeV << std::endl;
std::cout << "Interaction: etarget lab: " << targetEnergyLab / 1_GeV << std::endl
<< "Interaction: ptarget lab: "
- << targetMomentumLab.GetComponents() / 1_GeV << std::endl;
+ << targetMomentumLab.getComponents() / 1_GeV << std::endl;
- std::cout << "Interaction: position of interaction: " << pOrig.GetCoordinates()
+ std::cout << "Interaction: position of interaction: " << pOrig.getCoordinates()
<< std::endl;
std::cout << "Interaction: time: " << tOrig << std::endl;
// sample target mass number
- auto const* currentNode = vP.GetNode();
+ auto const* currentNode = vP.getNode();
auto const& mediumComposition =
- currentNode->GetModelProperties().getNuclearComposition();
+ currentNode->getModelProperties().getNuclearComposition();
// get cross sections for target materials
/*
Here we read the cross section from the interaction model again,
- should be passed from GetInteractionLength if possible
+ should be passed from getInteractionLength if possible
*/
- auto const& compVec = mediumComposition.GetComponents();
+ auto const& compVec = mediumComposition.getComponents();
std::vector<CrossSectionType> cross_section_of_components(compVec.size());
for (size_t i = 0; i < compVec.size(); ++i) {
auto const targetId = compVec[i];
int targetA = 0;
- if (corsika::is_nucleus(targetId)) targetA = corsika::get_nucleus_A(targetId);
+ if (is_nucleus(targetId)) targetA = get_nucleus_A(targetId);
const auto sigProd =
- GetCrossSection(corsikaBeamId, targetId, projectileEnergyLab, beamA, targetA);
+ getCrossSection(corsikaBeamId, targetId, projectileEnergyLab, beamA, targetA);
cross_section_of_components[i] = sigProd;
}
const auto targetCode =
- mediumComposition.SampleTarget(cross_section_of_components, fRNG);
+ mediumComposition.sampleTarget(cross_section_of_components, rng_);
std::cout << "Interaction: target selected: " << targetCode << std::endl;
int targetQgsCode = -1;
- if (corsika::is_nucleus(targetCode))
- targetQgsCode = corsika::get_nucleus_A(targetCode);
- if (targetCode == corsika::Code::Proton) targetQgsCode = 1;
+ if (is_nucleus(targetCode))
+ targetQgsCode = get_nucleus_A(targetCode);
+ if (targetCode == Code::Proton) targetQgsCode = 1;
std::cout << "Interaction: target qgsjetII code/A: " << targetQgsCode << std::endl;
if (targetQgsCode > maxMassNumber_ || targetQgsCode < 1)
throw std::runtime_error("QgsjetII target outside range.");
int projQgsCode = 1;
- if (corsika::is_nucleus(corsikaBeamId)) projQgsCode = vP.GetNuclearA();
+ if (is_nucleus(corsikaBeamId)) projQgsCode = vP.getNuclearA();
std::cout << "Interaction: projectile qgsjetII code/A: " << projQgsCode << " "
<< corsikaBeamId << std::endl;
if (projQgsCode > maxMassNumber_ || projQgsCode < 1)
@@ -244,8 +238,8 @@ namespace corsika::qgsjetII {
// beam id for qgsjetII
int kBeam = 2; // default: proton Shouldn't we randomize neutron/proton for nuclei?
- if (corsikaBeamId != corsika::Code::Nucleus) {
- kBeam = corsika::qgsjetII::ConvertToQgsjetIIRaw(corsikaBeamId);
+ if (corsikaBeamId != Code::Nucleus) {
+ kBeam = corsika::qgsjetII::convertToQgsjetIIRaw(corsikaBeamId);
// from conex
if (kBeam == 0) { // replace pi0 or rho0 with pi+/pi-
static int select = 1;
@@ -275,37 +269,36 @@ namespace corsika::qgsjetII {
// to read the secondaries
// define rotation to and from CoM frame
// CoM frame definition in QgsjetII projectile: +z
- auto const& originalCS = projectileMomentumLab.GetCoordinateSystem();
- corsika::CoordinateSystem const zAxisFrame =
- originalCS.RotateToZ(projectileMomentumLab);
+ auto const& originalCS = projectileMomentumLab.getCoordinateSystem();
+ CoordinateSystemPtr const zAxisFrame =
+ make_rotationToZ(originalCS, projectileMomentumLab);
// fragments
QGSJetIIFragmentsStack qfs;
for (auto& fragm : qfs) {
- corsika::Code idFragm = corsika::Code::Nucleus;
- int A = fragm.GetFragmentSize();
+ Code idFragm = Code::Nucleus;
+ int A = fragm.getFragmentSize();
int Z = 0;
switch (A) {
case 1: { // proton/neutron
- idFragm = corsika::Code::Proton;
+ idFragm = Code::Proton;
- auto momentum = corsika::Vector(
- zAxisFrame, corsika::QuantityVector<hepmomentum_d>{
+ auto momentum = Vector(
+ zAxisFrame, QuantityVector<hepmomentum_d>{
0.0_GeV, 0.0_GeV,
- sqrt((projectileEnergyLab + corsika::Proton::mass) *
- (projectileEnergyLab - corsika::Proton::mass))});
+ sqrt((projectileEnergyLab + Proton::mass) *
+ (projectileEnergyLab - Proton::mass))});
auto const energy =
- sqrt(momentum.squaredNorm() + square(corsika::get_mass(idFragm)));
+ sqrt(momentum.getSquaredNorm() + square(get_mass(idFragm)));
momentum.rebase(originalCS); // transform back into standard lab frame
std::cout << "secondary fragment> id=" << idFragm
- << " p=" << momentum.GetComponents() << std::endl;
- auto pnew = vP.AddSecondary(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector,
- corsika::Point, TimeType>{idFragm, energy, momentum, pOrig,
- tOrig});
- Plab_final += pnew.GetMomentum();
- Elab_final += pnew.GetEnergy();
+ << " p=" << momentum.getComponents() << std::endl;
+ auto pnew = vP.addSecondary(
+ std::make_tuple(idFragm, energy, momentum, pOrig,
+ tOrig));
+ Plab_final += pnew.getMomentum();
+ Elab_final += pnew.getEnergy();
} break;
case 2: // deuterium
Z = 1;
@@ -322,25 +315,24 @@ namespace corsika::qgsjetII {
}
}
- if (idFragm == corsika::Code::Nucleus) {
- auto momentum = corsika::Vector(
- zAxisFrame, corsika::QuantityVector<hepmomentum_d>{
+ if (idFragm == Code::Nucleus) {
+ auto momentum = Vector(
+ zAxisFrame, QuantityVector<hepmomentum_d>{
0.0_GeV, 0.0_GeV,
sqrt((projectileEnergyLab + constants::nucleonMass * A) *
(projectileEnergyLab - constants::nucleonMass * A))});
auto const energy =
- sqrt(momentum.squaredNorm() + square(constants::nucleonMass * A));
+ sqrt(momentum.getSquaredNorm() + square(constants::nucleonMass * A));
momentum.rebase(originalCS); // transform back into standard lab frame
std::cout << "secondary fragment> id=" << idFragm
- << " p=" << momentum.GetComponents() << " A=" << A << " Z=" << Z
+ << " p=" << momentum.getComponents() << " A=" << A << " Z=" << Z
<< std::endl;
- auto pnew = vP.AddSecondary(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector,
- corsika::Point, TimeType, unsigned short, unsigned short>{
- idFragm, energy, momentum, pOrig, tOrig, A, Z});
- Plab_final += pnew.GetMomentum();
- Elab_final += pnew.GetEnergy();
+ auto pnew = vP.addSecondary(
+ std::make_tuple(
+ idFragm, energy, momentum, pOrig, tOrig, A, Z));
+ Plab_final += pnew.getMomentum();
+ Elab_final += pnew.getEnergy();
}
}
@@ -348,30 +340,29 @@ namespace corsika::qgsjetII {
QGSJetIIStack qs;
for (auto& psec : qs) {
- auto momentum = psec.GetMomentum(zAxisFrame);
- auto const energy = psec.GetEnergy();
+ auto momentum = psec.getMomentum(zAxisFrame);
+ auto const energy = psec.getEnergy();
momentum.rebase(originalCS); // transform back into standard lab frame
std::cout << "secondary fragment> id="
- << corsika::qgsjetII::ConvertFromQgsjetII(psec.GetPID())
- << " p=" << momentum.GetComponents() << std::endl;
+ << corsika::qgsjetII::convertFromQgsjetII(psec.getPID())
+ << " p=" << momentum.getComponents() << std::endl;
auto pnew =
- vP.AddSecondary(std::tuple<corsika::Code, HEPEnergyType,
- corsika::MomentumVector, corsika::Point, TimeType>{
- corsika::qgsjetII::ConvertFromQgsjetII(psec.GetPID()), energy, momentum,
- pOrig, tOrig});
- Plab_final += pnew.GetMomentum();
- Elab_final += pnew.GetEnergy();
+ vP.addSecondary(std::make_tuple(
+ corsika::qgsjetII::convertFromQgsjetII(psec.getPID()), energy, momentum,
+ pOrig, tOrig));
+ Plab_final += pnew.getMomentum();
+ Elab_final += pnew.getEnergy();
}
std::cout << "conservation (all GeV): Ecm_final= n/a" /* << Ecm_final / 1_GeV*/
<< std::endl
<< "Elab_final=" << Elab_final / 1_GeV
- << ", Plab_final=" << (Plab_final / 1_GeV).GetComponents()
+ << ", Plab_final=" << (Plab_final / 1_GeV).getComponents()
<< ", N_wounded,targ="
- << QGSJetIIFragmentsStackData::GetWoundedNucleonsTarget()
+ << QGSJetIIFragmentsStackData::getWoundedNucleonsTarget()
<< ", N_wounded,proj="
- << QGSJetIIFragmentsStackData::GetWoundedNucleonsProjectile()
- << ", N_fragm,proj=" << qfs.GetSize() << std::endl;
+ << QGSJetIIFragmentsStackData::getWoundedNucleonsProjectile()
+ << ", N_fragm,proj=" << qfs.getSize() << std::endl;
}
}
diff --git a/corsika/detail/modules/sibyll/Decay.inl b/corsika/detail/modules/sibyll/Decay.inl
index 8e82b65ca..d2f55b1c3 100644
--- a/corsika/detail/modules/sibyll/Decay.inl
+++ b/corsika/detail/modules/sibyll/Decay.inl
@@ -19,142 +19,207 @@
#include <vector>
using SetupView = corsika::setup::StackView;
-using SetupProjectile = corsika::setup::StackView::ParticleType;
-using SetupParticle = corsika::setup::Stack::ParticleType;
+using SetupProjectile = corsika::setup::StackView::particle_type;
+using SetupParticle = corsika::setup::Stack::particle_type;
namespace corsika::sibyll {
- Decay::Decay() {}
- Decay::~Decay() { std::cout << "Sibyll::Decay n=" << fCount << std::endl; }
- void Decay::Init() {
+ Decay::Decay(const bool sibyll_printout_on)
+ : sibyll_listing_(sibyll_printout_on) {
// switch off decays to avoid internal decay chains
- SetAllStable();
+ setAllStable();
+ // handle all decays by default
+ handleAllDecays_ = true;
}
- void Decay::SetStable(const std::vector<corsika::Code> vParticleList) {
- for (auto p : vParticleList) Decay::SetStable(p);
+ Decay::Decay(std::set<Code> const& vHandled)
+ : handleAllDecays_(false)
+ , handledDecays_(vHandled) {
+ setAllStable();
}
- void Decay::SetUnstable(const std::vector<corsika::Code> vParticleList) {
- for (auto p : vParticleList) Decay::SetUnstable(p);
+ Decay::~Decay() { CORSIKA_LOG_DEBUG("Sibyll::Decay n={}", count_); }
+
+ bool Decay::canHandleDecay(const Code vParticleCode) {
+ // if known to sibyll and not proton or neutrino it can decay
+ if (vParticleCode == Code::Proton || vParticleCode == Code::AntiProton ||
+ vParticleCode == Code::NuE || vParticleCode == Code::NuMu ||
+ vParticleCode == Code::NuTau || vParticleCode == Code::NuEBar ||
+ vParticleCode == Code::NuMuBar || vParticleCode == Code::NuTauBar ||
+ vParticleCode == Code::Electron || vParticleCode == Code::Positron)
+ return false;
+ else if (corsika::sibyll::convertToSibyllRaw(
+ vParticleCode)) // non-zero for particles known to sibyll
+ return true;
+ else
+ return false;
}
- bool Decay::IsStable(const corsika::Code vCode) {
- return abs(corsika::sibyll::ConvertToSibyllRaw(vCode)) <= 0 ? true : false;
+ void Decay::setHandleDecay(const Code vParticleCode) {
+ handleAllDecays_ = false;
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: set to handle decay of {}", vParticleCode);
+ if (Decay::canHandleDecay(vParticleCode))
+ handledDecays_.insert(vParticleCode);
+ else
+ throw std::runtime_error("this decay can not be handled by sibyll!");
}
- bool Decay::IsUnstable(const corsika::Code vCode) {
- return abs(corsika::sibyll::ConvertToSibyllRaw(vCode)) > 0 ? true : false;
+ void Decay::setHandleDecay(std::vector<Code> const& vParticleList) {
+ handleAllDecays_ = false;
+ for (auto p : vParticleList) Decay::setHandleDecay(p);
}
- void Decay::SetDecay(const corsika::Code vCode, const bool vMakeUnstable) {
- vMakeUnstable ? SetUnstable(vCode) : SetStable(vCode);
+ bool Decay::isDecayHandled(corsika::Code const vParticleCode) {
+ if (handleAllDecays_ && Decay::canHandleDecay(vParticleCode))
+ return true;
+ else
+ return Decay::handledDecays_.find(vParticleCode) != Decay::handledDecays_.end()
+ ? true
+ : false;
}
- void Decay::SetUnstable(const corsika::Code vCode) {
- std::cout << "Sibyll::Interaction: setting " << vCode << " unstable.." << std::endl;
- const int s_id = abs(corsika::sibyll::ConvertToSibyllRaw(vCode));
- s_csydec_.idb[s_id - 1] = abs(s_csydec_.idb[s_id - 1]);
+ void Decay::setStable(std::vector<Code> const& vParticleList) {
+ for (auto p : vParticleList) Decay::setStable(p);
}
- void Decay::SetStable(const corsika::Code vCode) {
- std::cout << "Sibyll::Interaction: setting " << vCode << " stable.." << std::endl;
- const int s_id = abs(corsika::sibyll::ConvertToSibyllRaw(vCode));
- s_csydec_.idb[s_id - 1] = (-1) * abs(s_csydec_.idb[s_id - 1]);
+ void Decay::setUnstable(std::vector<Code> const& vParticleList) {
+ for (auto p : vParticleList) Decay::setUnstable(p);
}
- void Decay::SetAllStable() {
- for (int i = 0; i < 99; ++i) s_csydec_.idb[i] = -1 * abs(s_csydec_.idb[i]);
+ bool Decay::isStable(Code const vCode) {
+ return abs(sibyll::convertToSibyllRaw(vCode)) <= 0 ? true : false;
}
- void Decay::SetAllUnstable() {
- for (int i = 0; i < 99; ++i) s_csydec_.idb[i] = abs(s_csydec_.idb[i]);
+ bool Decay::isUnstable(Code const vCode) {
+ return abs(sibyll::convertToSibyllRaw(vCode)) > 0 ? true : false;
}
- void Decay::PrintDecayConfig(const corsika::Code vCode) {
- std::cout << "Decay: Sibyll decay configuration:" << std::endl;
- const int sibCode = corsika::sibyll::ConvertToSibyllRaw(vCode);
- const int absSibCode = abs(sibCode);
- std::cout << vCode << " is ";
- if (s_csydec_.idb[absSibCode - 1] <= 0)
- std::cout << "stable" << std::endl;
- else
- std::cout << "unstable" << std::endl;
+ void Decay::setDecay(const Code vCode, const bool vMakeUnstable) {
+ vMakeUnstable ? setUnstable(vCode) : setStable(vCode);
}
- template <>
- TimeType Decay::GetLifetime(SetupParticle const& vP) const {
+ void Decay::setUnstable(Code const vCode) {
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: setting {} unstable. ", vCode);
+
+ const int s_id = abs(sibyll::convertToSibyllRaw(vCode));
+ s_csydec_.idb[s_id - 1] = abs(s_csydec_.idb[s_id - 1]);
+ }
- HEPEnergyType E = vP.GetEnergy();
- HEPMassType m = vP.GetMass();
+ void Decay::setStable(Code const vCode) {
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: setting {} stable. ", vCode);
- const double gamma = E / m;
+ const int s_id = abs(sibyll::convertToSibyllRaw(vCode));
+ s_csydec_.idb[s_id - 1] = (-1) * abs(s_csydec_.idb[s_id - 1]);
+ }
- const TimeType t0 = corsika::get_lifetime(vP.GetPID());
- auto const lifetime = gamma * t0;
+ void Decay::setAllStable() {
+ for (int i = 0; i < 99; ++i) s_csydec_.idb[i] = -1 * abs(s_csydec_.idb[i]);
+ }
- const auto mkin =
- (E * E - vP.GetMomentum().squaredNorm()); // delta_mass(vP.GetMomentum(), E, m);
- std::cout << "Decay: code: " << vP.GetPID() << std::endl;
- std::cout << "Decay: MinStep: t0: " << t0 << std::endl;
- std::cout << "Decay: MinStep: energy: " << E / 1_GeV << " GeV" << std::endl;
- std::cout << "Decay: momentum: " << vP.GetMomentum().GetComponents() / 1_GeV << " GeV"
- << std::endl;
- std::cout << "Decay: momentum: shell mass-kin. inv. mass " << mkin / 1_GeV / 1_GeV
- << " " << m / 1_GeV * m / 1_GeV << std::endl;
- auto sib_id = corsika::sibyll::ConvertToSibyllRaw(vP.GetPID());
- std::cout << "Decay: sib mass: " << get_sibyll_mass2(sib_id) << std::endl;
- std::cout << "Decay: MinStep: gamma: " << gamma << std::endl;
- std::cout << "Decay: MinStep: tau: " << lifetime << std::endl;
+ void Decay::setAllUnstable() {
+ for (int i = 0; i < 99; ++i) s_csydec_.idb[i] = abs(s_csydec_.idb[i]);
+ }
- return lifetime;
+ void Decay::printDecayConfig([[maybe_unused]] const Code vCode) {
+ [[maybe_unused]] const int sibCode = corsika::sibyll::convertToSibyllRaw(vCode);
+ [[maybe_unused]] const int absSibCode = abs(sibCode);
+ CORSIKA_LOG_DEBUG("Decay: Sibyll decay configuration: {} is {}", vCode,
+ (s_csydec_.idb[absSibCode - 1] <= 0) ? "stable" : "unstable");
+ }
+ void Decay::printDecayConfig() {
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: decay configuration:");
+ if (handleAllDecays_) {
+ CORSIKA_LOG_DEBUG(
+ " all particles known to Sibyll are handled by Sibyll::Decay!");
+
+ } else {
+ for ([[maybe_unused]] auto& pCode : handledDecays_) {
+ CORSIKA_LOG_DEBUG(" Decay of {} is handled by Sibyll!", pCode);
+ }
+ }
}
- template <>
- void Decay::DoDecay(SetupProjectile& vP) {
- using corsika::Point;
+ template <typename TParticle>
+ TimeType Decay::getLifetime(TParticle const& projectile) {
+
+ const Code pid = projectile.getPID();
+ if (Decay::isDecayHandled(pid)) {
+ HEPEnergyType E = projectile.getEnergy();
+ HEPMassType m = projectile.getMass();
+ const double gamma = E / m;
+ const TimeType t0 = get_lifetime(projectile.getPID());
+ auto const lifetime = gamma * t0;
+ [[maybe_unused]] const auto mkin =
+ +(E * E - projectile.getMomentum()
+ .getSquaredNorm()); // delta_mass(projectile.getMomentum(), E, m);
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: code: {} ", projectile.getPID());
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: MinStep: t0: {} ", t0);
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: MinStep: energy: {} GeV ", E / 1_GeV);
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: momentum: {} GeV ",
+ projectile.getMomentum().getComponents() / 1_GeV);
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: momentum: shell mass-kin. inv. mass {} {}",
+ mkin / 1_GeV / 1_GeV, m / 1_GeV * m / 1_GeV);
+ [[maybe_unused]] auto sib_id =
+ corsika::sibyll::convertToSibyllRaw(projectile.getPID());
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: sib mass: {}", get_sibyll_mass2(sib_id));
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: MinStep: gamma: {}", gamma);
+ CORSIKA_LOG_DEBUG("Sibyll::Decay: MinStep: tau {} s: ", lifetime / 1_s);
+ return lifetime;
+ }
+ return std::numeric_limits<double>::infinity() * 1_s;
+ } // namespace corsika::sibyll
+
+ template <typename TSecondaryView>
+ void Decay::doDecay(TSecondaryView& view) {
- fCount++;
+ auto projectile = view.getProjectile();
+ const Code pCode = projectile.getPID();
+ // check if sibyll is configured to handle this decay!
+ if (!isDecayHandled(pCode))
+ throw std::runtime_error("STOP! Sibyll not configured to execute this decay!");
+
+ count_++;
SibStack ss;
- ss.Clear();
- const corsika::Code pCode = vP.GetPID();
+ ss.clear();
// copy particle to sibyll stack
- ss.AddParticle(corsika::sibyll::ConvertToSibyllRaw(pCode), vP.GetEnergy(),
- vP.GetMomentum(),
+ ss.addParticle(sibyll::convertToSibyllRaw(pCode), projectile.getEnergy(),
+ projectile.getMomentum(),
// setting particle mass with Corsika values, may be inconsistent
// with sibyll internal values
- corsika::get_mass(pCode));
+ get_mass(pCode));
// remember position
- Point const decayPoint = vP.GetPosition();
- TimeType const t0 = vP.GetTime();
+ Point const decayPoint = projectile.getPosition();
+ TimeType const t0 = projectile.getTime();
// remember if particles is unstable
- // auto const priorIsUnstable = IsUnstable(pCode);
+ // auto const priorIsUnstable = isUnstable(pCode);
// switch on decay for this particle
- SetUnstable(pCode);
- PrintDecayConfig(pCode);
+ setUnstable(pCode);
+ printDecayConfig(pCode);
// call sibyll decay
- std::cout << "Decay: calling Sibyll decay routine.." << std::endl;
+ CORSIKA_LOG_DEBUG("Decay: calling Sibyll decay routine..");
decsib_();
+ if (sibyll_listing_) {
+ // print output
+ int print_unit = 6;
+ sib_list_(print_unit);
+ }
+
// reset to stable
- SetStable(pCode);
- // print output
- int print_unit = 6;
- sib_list_(print_unit);
+ setStable(pCode);
// copy particles from sibyll stack to corsika
- for (const auto& psib : ss) {
+ for (auto const& psib : ss) {
// FOR NOW: skip particles that have decayed in Sibyll, move to iterator?
- if (psib.HasDecayed()) continue;
+ if (psib.hasDecayed()) continue;
// add to corsika stack
- vP.AddSecondary(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector, Point,
- TimeType>{corsika::sibyll::ConvertFromSibyll(psib.GetPID()),
- psib.GetEnergy(), psib.GetMomentum(), decayPoint, t0});
+ projectile.addSecondary(std::make_tuple(sibyll::convertFromSibyll(psib.getPID()),
+ psib.getEnergy(), psib.getMomentum(),
+ decayPoint, t0));
}
// empty sibyll stack
- ss.Clear();
+ ss.clear();
}
} // namespace corsika::sibyll
diff --git a/corsika/detail/modules/sibyll/Interaction.inl b/corsika/detail/modules/sibyll/Interaction.inl
index 4435675d7..98611c2c3 100644
--- a/corsika/detail/modules/sibyll/Interaction.inl
+++ b/corsika/detail/modules/sibyll/Interaction.inl
@@ -23,67 +23,65 @@
#include <tuple>
-using std::make_tuple;
-using std::tuple;
-
using namespace corsika;
-using SetupParticle = setup::Stack::StackIterator;
+using SetupParticle = setup::Stack::stack_iterator_type;
using SetupView = setup::StackView;
using Track = setup::Trajectory;
namespace corsika::sibyll {
- Interaction::Interaction() {
- using corsika::RNGManager;
-
+ Interaction::Interaction(const bool sibyll_printout_on)
+ : sibyll_listing_(sibyll_printout_on) {
// initialize Sibyll
- if (!initialized_) {
+ static bool initialized = false;
+ if (!initialized) {
sibyll_ini_();
- initialized_ = true;
+ initialized = true;
}
}
Interaction::~Interaction() {
- std::cout << "Sibyll::Interaction n=" << count_ << " Nnuc=" << nucCount_ << std::endl;
+ CORSIKA_LOG_DEBUG(
+ fmt::format("Sibyll::Interaction n={}, Nnuc={}", count_, nucCount_));
}
- void Interaction::SetStable(std::vector<corsika::Code> const& vParticleList) {
- for (auto p : vParticleList) Interaction::SetStable(p);
+ void Interaction::setStable(std::vector<corsika::Code> const& vParticleList) {
+ for (auto p : vParticleList) Interaction::setStable(p);
}
- void Interaction::SetUnstable(std::vector<corsika::Code> const& vParticleList) {
- for (auto p : vParticleList) Interaction::SetUnstable(p);
+ void Interaction::setUnstable(std::vector<corsika::Code> const& vParticleList) {
+ for (auto p : vParticleList) Interaction::setUnstable(p);
}
- void Interaction::SetUnstable(const corsika::Code vCode) {
+ void Interaction::setUnstable(const corsika::Code vCode) {
std::cout << "Sibyll::Interaction: setting " << vCode << " unstable.." << std::endl;
- const int s_id = abs(corsika::sibyll::ConvertToSibyllRaw(vCode));
+ const int s_id = abs(corsika::sibyll::convertToSibyllRaw(vCode));
s_csydec_.idb[s_id - 1] = abs(s_csydec_.idb[s_id - 1]);
}
- void Interaction::SetStable(const corsika::Code vCode) {
+ void Interaction::setStable(const corsika::Code vCode) {
std::cout << "Sibyll::Interaction: setting " << vCode << " stable.." << std::endl;
- const int s_id = abs(corsika::sibyll::ConvertToSibyllRaw(vCode));
+ const int s_id = abs(corsika::sibyll::convertToSibyllRaw(vCode));
s_csydec_.idb[s_id - 1] = (-1) * abs(s_csydec_.idb[s_id - 1]);
}
- void Interaction::SetAllUnstable() {
+ void Interaction::setAllUnstable() {
for (int i = 0; i < 99; ++i) s_csydec_.idb[i] = abs(s_csydec_.idb[i]);
}
- void Interaction::SetAllStable() {
+ void Interaction::setAllStable() {
for (int i = 0; i < 99; ++i) s_csydec_.idb[i] = -1 * abs(s_csydec_.idb[i]);
}
- tuple<corsika::CrossSectionType, corsika::CrossSectionType>
- Interaction::GetCrossSection(const corsika::Code BeamId, const corsika::Code TargetId,
+ std::tuple<corsika::CrossSectionType, corsika::CrossSectionType>
+ Interaction::getCrossSection(const corsika::Code BeamId, const corsika::Code TargetId,
const corsika::HEPEnergyType CoMenergy) const {
double sigProd, sigEla, dummy, dum1, dum3, dum4;
double dumdif[3];
- const int iBeam = corsika::sibyll::GetSibyllXSCode(BeamId);
- if (!IsValidCoMEnergy(CoMenergy)) {
+ const int iBeam = corsika::sibyll::getSibyllXSCode(BeamId);
+ if (!isValidCoMEnergy(CoMenergy)) {
throw std::runtime_error(
- "Interaction: GetCrossSection: CoM energy outside range for Sibyll!");
+ "Interaction: getCrossSection: CoM energy outside range for Sibyll!");
}
const double dEcm = CoMenergy / 1_GeV;
if (corsika::is_nucleus(TargetId)) {
@@ -103,39 +101,41 @@ namespace corsika::sibyll {
}
template <>
- corsika::GrammageType Interaction::GetInteractionLength(SetupParticle const& vP) const {
+ corsika::GrammageType Interaction::getInteractionLength(
+ SetupParticle const& projectile) const {
- // coordinate system, get global frame of reference
- CoordinateSystem& rootCS =
- RootCoordinateSystem::getInstance().GetRootCoordinateSystem();
-
- const corsika::Code corsikaBeamId = vP.GetPID();
+ const corsika::Code corsikaBeamId = projectile.getPID();
// beam corsika for sibyll : 1, 2, 3 for p, pi, k
// read from cross section code table
- const bool kInteraction = corsika::sibyll::CanInteract(corsikaBeamId);
+ const bool kInteraction = corsika::sibyll::canInteract(corsikaBeamId);
+
+ MomentumVector const& pLab = projectile.getMomentum();
+ CoordinateSystemPtr const& labCS = pLab.getCoordinateSystem();
// FOR NOW: assume target is at rest
- MomentumVector pTarget(rootCS, {0_GeV, 0_GeV, 0_GeV});
+ MomentumVector pTarget(labCS, {0_GeV, 0_GeV, 0_GeV});
// total momentum and energy
- HEPEnergyType Elab = vP.GetEnergy() + constants::nucleonMass;
- MomentumVector pTotLab(rootCS, {0_GeV, 0_GeV, 0_GeV});
- pTotLab += vP.GetMomentum();
+ HEPEnergyType Elab = projectile.getEnergy() + constants::nucleonMass;
+ MomentumVector pTotLab(labCS, {0_GeV, 0_GeV, 0_GeV});
+ pTotLab += pLab;
pTotLab += pTarget;
- auto const pTotLabNorm = pTotLab.norm();
+ auto const pTotLabNorm = pTotLab.getNorm();
// calculate cm. energy
const HEPEnergyType ECoM = sqrt(
(Elab + pTotLabNorm) * (Elab - pTotLabNorm)); // binomial for numerical accuracy
- std::cout << "Interaction: LambdaInt: \n"
- << " input energy: " << vP.GetEnergy() / 1_GeV << std::endl
- << " beam can interact:" << kInteraction << std::endl
- << " beam pid:" << vP.GetPID() << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "Interaction: LambdaInt: \n"
+ " input energy: {} GeV "
+ " beam can interact: {} "
+ " beam pid: {}",
+ projectile.getEnergy() / 1_GeV, kInteraction, projectile.getPID());
// TODO: move limits into variables
// FR: removed && Elab >= 8.5_GeV
- if (kInteraction && IsValidCoMEnergy(ECoM)) {
+ if (kInteraction && isValidCoMEnergy(ECoM)) {
// get target from environment
/*
@@ -144,25 +144,27 @@ namespace corsika::sibyll {
and the boosts can be defined..
*/
- auto const* currentNode = vP.GetNode();
+ auto const* currentNode = projectile.getNode();
const auto& mediumComposition =
- currentNode->GetModelProperties().getNuclearComposition();
+ currentNode->getModelProperties().getNuclearComposition();
- si::CrossSectionType weightedProdCrossSection = mediumComposition.WeightedSum(
+ si::CrossSectionType weightedProdCrossSection = mediumComposition.getWeightedSum(
[=](corsika::Code targetID) -> si::CrossSectionType {
- return std::get<0>(this->GetCrossSection(corsikaBeamId, targetID, ECoM));
+ return std::get<0>(this->getCrossSection(corsikaBeamId, targetID, ECoM));
});
- std::cout << "Interaction: "
- << "IntLength: weighted CrossSection (mb): "
- << weightedProdCrossSection / 1_mb << std::endl;
+ CORSIKA_LOG_DEBUG(
+ fmt::format("Interaction: "
+ "IntLength: weighted CrossSection (mb): {} ",
+ weightedProdCrossSection / 1_mb));
// calculate interaction length in medium
- GrammageType const int_length = mediumComposition.GetAverageMassNumber() *
+ GrammageType const int_length = mediumComposition.getAverageMassNumber() *
constants::u / weightedProdCrossSection;
- std::cout << "Interaction: "
- << "interaction length (g/cm2): " << int_length / (0.001_kg) * 1_cm * 1_cm
- << std::endl;
+ CORSIKA_LOG_DEBUG(
+ fmt::format("Interaction: "
+ "interaction length (g/cm2): {} ",
+ int_length / (0.001_kg) * 1_cm * 1_cm));
return int_length;
}
@@ -175,184 +177,192 @@ namespace corsika::sibyll {
event is copied (and boosted) into the shower lab frame.
*/
- template <typename TProjectile>
- void Interaction::doInteraction(TProjectile& vP) {
+ template <typename TSecondaryView>
+ void Interaction::doInteraction(TSecondaryView& view) {
- const auto corsikaBeamId = vP.GetPID();
- std::cout << "ProcessSibyll: "
- << "DoInteraction: " << corsikaBeamId << " interaction? "
- << corsika::sibyll::CanInteract(corsikaBeamId) << std::endl;
+ auto const projectile = view.getProjectile();
+ const auto corsikaBeamId = projectile.getPID();
if (corsika::is_nucleus(corsikaBeamId)) {
// nuclei handled by different process, this should not happen
throw std::runtime_error("Nuclear projectile are not handled by SIBYLL!");
}
- if (corsika::sibyll::CanInteract(corsikaBeamId)) {
- const CoordinateSystem& rootCS =
- RootCoordinateSystem::getInstance().GetRootCoordinateSystem();
-
- // position and time of interaction, not used in Sibyll
- Point pOrig = vP.GetPosition();
- TimeType tOrig = vP.GetTime();
-
- // define target
- // for Sibyll is always a single nucleon
- // FOR NOW: target is always at rest
- const auto eTargetLab = 0_GeV + constants::nucleonMass;
- const auto pTargetLab = MomentumVector(rootCS, 0_GeV, 0_GeV, 0_GeV);
- const FourVector PtargLab(eTargetLab, pTargetLab);
-
- // define projectile
- HEPEnergyType const eProjectileLab = vP.GetEnergy();
- auto const pProjectileLab = vP.GetMomentum();
-
- std::cout << "Interaction: ebeam lab: " << eProjectileLab / 1_GeV << std::endl
- << "Interaction: pbeam lab: " << pProjectileLab.GetComponents() / 1_GeV
- << std::endl;
- std::cout << "Interaction: etarget lab: " << eTargetLab / 1_GeV << std::endl
- << "Interaction: ptarget lab: " << pTargetLab.GetComponents() / 1_GeV
- << std::endl;
-
- const FourVector PprojLab(eProjectileLab, pProjectileLab);
-
- // define target kinematics in lab frame
- // define boost to and from CoM frame
- // CoM frame definition in Sibyll projectile: +z
- COMBoost const boost(PprojLab, constants::nucleonMass);
-
- // just for show:
- // boost projecticle
- auto const PprojCoM = boost.toCoM(PprojLab);
-
- // boost target
- auto const PtargCoM = boost.toCoM(PtargLab);
-
- std::cout << "Interaction: ebeam CoM: " << PprojCoM.GetTimeLikeComponent() / 1_GeV
- << std::endl
- << "Interaction: pbeam CoM: "
- << PprojCoM.GetSpaceLikeComponents().GetComponents() / 1_GeV << std::endl;
- std::cout << "Interaction: etarget CoM: " << PtargCoM.GetTimeLikeComponent() / 1_GeV
- << std::endl
- << "Interaction: ptarget CoM: "
- << PtargCoM.GetSpaceLikeComponents().GetComponents() / 1_GeV << std::endl;
-
- std::cout << "Interaction: position of interaction: " << pOrig.GetCoordinates()
- << std::endl;
- std::cout << "Interaction: time: " << tOrig << std::endl;
-
- HEPEnergyType Etot = eProjectileLab + eTargetLab;
- MomentumVector Ptot = vP.GetMomentum();
- // invariant mass, i.e. cm. energy
- HEPEnergyType Ecm = sqrt(Etot * Etot - Ptot.squaredNorm());
-
- // sample target mass number
- auto const* currentNode = vP.GetNode();
- auto const& mediumComposition =
- currentNode->GetModelProperties().getNuclearComposition();
- // get cross sections for target materials
- /*
- Here we read the cross section from the interaction model again,
- should be passed from GetInteractionLength if possible
- */
- //#warning reading interaction cross section again, should not be necessary
- auto const& compVec = mediumComposition.GetComponents();
- std::vector<si::CrossSectionType> cross_section_of_components(compVec.size());
-
- for (size_t i = 0; i < compVec.size(); ++i) {
- auto const targetId = compVec[i];
- const auto [sigProd, sigEla] = GetCrossSection(corsikaBeamId, targetId, Ecm);
- [[maybe_unused]] const auto& dummy_sigEla = sigEla;
- cross_section_of_components[i] = sigProd;
- }
+ // position and time of interaction, not used in Sibyll
+ Point const pOrig = projectile.getPosition();
+ TimeType const tOrig = projectile.getTime();
+
+ // define projectile
+ HEPEnergyType const eProjectileLab = projectile.getEnergy();
+ auto const pProjectileLab = projectile.getMomentum();
+ CoordinateSystemPtr const& originalCS = pProjectileLab.getCoordinateSystem();
+
+ CORSIKA_LOG_DEBUG(
+ "ProcessSibyll: "
+ "DoInteraction: pid {} interaction ",
+ corsikaBeamId);
+
+ // define target
+ // for Sibyll is always a single nucleon
+ // FOR NOW: target is always at rest
+ const auto eTargetLab = 0_GeV + constants::nucleonMass;
+ const auto pTargetLab = MomentumVector(originalCS, 0_GeV, 0_GeV, 0_GeV);
+ const FourVector PtargLab(eTargetLab, pTargetLab);
+
+ CORSIKA_LOG_DEBUG(
+ "Interaction: ebeam lab: {} GeV"
+ "Interaction: pbeam lab: {} GeV",
+ eProjectileLab / 1_GeV, pProjectileLab.getComponents());
+ CORSIKA_LOG_DEBUG(
+ "Interaction: etarget lab: {} GeV "
+ "Interaction: ptarget lab: {} GeV",
+ eTargetLab / 1_GeV, pTargetLab.getComponents() / 1_GeV);
+
+ const FourVector PprojLab(eProjectileLab, pProjectileLab);
+
+ // define target kinematics in lab frame
+ // define boost to and from CoM frame
+ // CoM frame definition in Sibyll projectile: +z
+ COMBoost const boost(PprojLab, constants::nucleonMass);
+ auto const& csPrime = boost.getRotatedCS();
+
+ // just for show:
+ // boost projecticle
+ [[maybe_unused]] auto const PprojCoM = boost.toCoM(PprojLab);
+
+ // boost target
+ [[maybe_unused]] auto const PtargCoM = boost.toCoM(PtargLab);
+
+ CORSIKA_LOG_DEBUG(
+ "Interaction: ebeam CoM: {} GeV "
+ "Interaction: pbeam CoM: {} GeV ",
+ PprojCoM.getTimeLikeComponent() / 1_GeV,
+ PprojCoM.getSpaceLikeComponents().getComponents(csPrime) / 1_GeV);
+ CORSIKA_LOG_DEBUG(
+ "Interaction: etarget CoM: {} GeV "
+ "Interaction: ptarget CoM: {} GeV ",
+ PtargCoM.getTimeLikeComponent() / 1_GeV,
+ PtargCoM.getSpaceLikeComponents().getComponents(csPrime) / 1_GeV);
+
+ CORSIKA_LOG_DEBUG("Interaction: position of interaction: {} ",
+ pOrig.getCoordinates());
+ CORSIKA_LOG_DEBUG("Interaction: time: {} ", tOrig);
+
+ HEPEnergyType Etot = eProjectileLab + eTargetLab;
+ MomentumVector Ptot = projectile.getMomentum();
+ // invariant mass, i.e. cm. energy
+ HEPEnergyType Ecm = sqrt(Etot * Etot - Ptot.getSquaredNorm());
+
+ // sample target mass number
+ auto const* currentNode = projectile.getNode();
+ auto const& mediumComposition =
+ currentNode->getModelProperties().getNuclearComposition();
+ // get cross sections for target materials
+ /*
+ Here we read the cross section from the interaction model again,
+ should be passed from getInteractionLength if possible
+ */
+ //#warning reading interaction cross section again, should not be necessary
+ auto const& compVec = mediumComposition.getComponents();
+ std::vector<CrossSectionType> cross_section_of_components(compVec.size());
+
+ for (size_t i = 0; i < compVec.size(); ++i) {
+ auto const targetId = compVec[i];
+ const auto [sigProd, sigEla] = getCrossSection(corsikaBeamId, targetId, Ecm);
+ [[maybe_unused]] const auto& dummy_sigEla = sigEla;
+ cross_section_of_components[i] = sigProd;
+ }
- const auto targetCode =
- mediumComposition.SampleTarget(cross_section_of_components, RNG_);
- std::cout << "Interaction: target selected: " << targetCode << std::endl;
- /*
- FOR NOW: allow nuclei with A<18 or protons only.
- when medium composition becomes more complex, approximations will have to be
- allowed air in atmosphere also contains some Argon.
- */
- int targetSibCode = -1;
- if (is_nucleus(targetCode)) targetSibCode = get_nucleus_A(targetCode);
- if (targetCode == corsika::Code::Proton) targetSibCode = 1;
- std::cout << "Interaction: sibyll code: " << targetSibCode << std::endl;
- if (targetSibCode > maxTargetMassNumber_ || targetSibCode < 1)
- throw std::runtime_error(
- "Sibyll target outside range. Only nuclei with A<18 or protons are "
- "allowed.");
-
- // beam id for sibyll
- const int kBeam = corsika::sibyll::ConvertToSibyllRaw(corsikaBeamId);
-
- std::cout << "Interaction: "
- << " DoInteraction: E(GeV):" << eProjectileLab / 1_GeV
- << " Ecm(GeV): " << Ecm / 1_GeV << std::endl;
- if (Ecm > GetMaxEnergyCoM())
- throw std::runtime_error("Interaction::DoInteraction: CoM energy too high!");
- // FR: removed eProjectileLab < 8.5_GeV ||
- if (Ecm < GetMinEnergyCoM()) {
- std::cout << "Interaction: "
- << " DoInteraction: should have dropped particle.. "
- << "THIS IS AN ERROR" << std::endl;
- throw std::runtime_error("energy too low for SIBYLL");
- } else {
- count_++;
- // Sibyll does not know about units..
- const double sqs = Ecm / 1_GeV;
- // running sibyll, filling stack
- std::cout << "kBeam " << kBeam << " targetSibCode " << targetSibCode << " sqs "
- << sqs << std::endl;
- sibyll_(kBeam, targetSibCode, sqs);
- if (internalDecays_) {
- // corsika that decay internally will never appear on the corsika stack
- // switch on all decays except for the corsika we want to take part in the
- // tracking
- SetAllUnstable();
- SetStable(trackedParticles_);
- decsib_();
- // reset
- SetAllStable();
- }
+ const auto targetCode =
+ mediumComposition.sampleTarget(cross_section_of_components, RNG_);
+ CORSIKA_LOG_DEBUG("Interaction: target selected: {} ", targetCode);
+ /*
+ FOR NOW: allow nuclei with A<18 or protons only.
+ when medium composition becomes more complex, approximations will have to be
+ allowed air in atmosphere also contains some Argon.
+ */
+ int targetSibCode = -1;
+ if (is_nucleus(targetCode)) targetSibCode = get_nucleus_A(targetCode);
+ if (targetCode == Proton::code) targetSibCode = 1;
+ CORSIKA_LOG_DEBUG("Interaction: sibyll code: {}", targetSibCode);
+ if (targetSibCode > maxTargetMassNumber_ || targetSibCode < 1)
+ throw std::runtime_error(
+ "Sibyll target outside range. Only nuclei with A<18 or protons are "
+ "allowed.");
+
+ // beam id for sibyll
+ const int kBeam = corsika::sibyll::convertToSibyllRaw(corsikaBeamId);
+
+ CORSIKA_LOG_DEBUG(
+ "Interaction: "
+ " DoInteraction: E(GeV): {} "
+ " Ecm(GeV): {} ",
+ eProjectileLab / 1_GeV, Ecm / 1_GeV);
+ if (Ecm > getMaxEnergyCoM())
+ throw std::runtime_error("Interaction::DoInteraction: CoM energy too high!");
+ // FR: removed eProjectileLab < 8.5_GeV ||
+ if (Ecm < getMinEnergyCoM()) {
+ CORSIKA_LOG_DEBUG(
+ "Interaction: "
+ " DoInteraction: should have dropped particle.. "
+ "THIS IS AN ERROR");
+ throw std::runtime_error("energy too low for SIBYLL");
+ } else {
+ count_++;
+ // Sibyll does not know about units..
+ const double sqs = Ecm / 1_GeV;
+ // running sibyll, filling stack
+ sibyll_(kBeam, targetSibCode, sqs);
+
+ if (sibyll_listing_) {
// print final state
int print_unit = 6;
sib_list_(print_unit);
nucCount_ += get_nwounded() - 1;
+ }
- // add corsika from sibyll to stack
- // link to sibyll stack
- SibStack ss;
-
- MomentumVector Plab_final(rootCS, {0.0_GeV, 0.0_GeV, 0.0_GeV});
- HEPEnergyType Elab_final = 0_GeV, Ecm_final = 0_GeV;
- for (const auto& psib : ss) {
-
- // skip corsika that have decayed in Sibyll
- if (psib.HasDecayed()) continue;
-
- // transform energy to lab. frame
- auto const pCoM = psib.GetMomentum();
- HEPEnergyType const eCoM = psib.GetEnergy();
- auto const Plab = boost.fromCoM(FourVector(eCoM, pCoM));
-
- // add to corsika stack
- auto pnew = vP.AddSecondary(
- std::tuple<corsika::Code, corsika::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, corsika::TimeType>{
- corsika::sibyll::ConvertFromSibyll(psib.GetPID()),
- Plab.GetTimeLikeComponent(), Plab.GetSpaceLikeComponents(), pOrig,
- tOrig});
-
- Plab_final += pnew.GetMomentum();
- Elab_final += pnew.GetEnergy();
- Ecm_final += psib.GetEnergy();
- }
- std::cout << "conservation (all GeV): Ecm_final=" << Ecm_final / 1_GeV
- << std::endl
- << "Elab_final=" << Elab_final / 1_GeV
- << ", Plab_final=" << (Plab_final / 1_GeV).GetComponents() << std::endl;
+ // add particles from sibyll to stack
+ // link to sibyll stack
+ SibStack ss;
+
+ MomentumVector Plab_final(originalCS, {0.0_GeV, 0.0_GeV, 0.0_GeV});
+ HEPEnergyType Elab_final = 0_GeV, Ecm_final = 0_GeV;
+ for (auto& psib : ss) {
+
+ // abort on particles that have decayed in Sibyll. Should not happen!
+ if (psib.hasDecayed())
+ throw std::runtime_error("found particle that decayed in SIBYLL!");
+
+ // transform 4-momentum to lab. frame
+ // note that the momentum needs to be rotated back
+ auto const tmp = psib.getMomentum().getComponents();
+ auto const pCoM = Vector<hepmomentum_d>(csPrime, tmp);
+ HEPEnergyType const eCoM = psib.getEnergy();
+ auto const Plab = boost.fromCoM(FourVector(eCoM, pCoM));
+ auto const p3lab = Plab.getSpaceLikeComponents();
+ assert(p3lab.getCoordinateSystem() == originalCS); // just to be sure!
+
+ // add to corsika stack
+ auto pnew = view.addSecondary(
+ std::make_tuple(corsika::sibyll::convertFromSibyll(psib.getPID()),
+ Plab.getTimeLikeComponent(), p3lab, pOrig, tOrig));
+
+ Plab_final += pnew.getMomentum();
+ Elab_final += pnew.getEnergy();
+ Ecm_final += psib.getEnergy();
}
+ CORSIKA_LOG_DEBUG(
+ "conservation (all GeV):"
+ "Ecm_initial(per nucleon)={}, Ecm_final(per nucleon)={}, "
+ "Elab_initial={}, Elab_final={}, "
+ "diff (%)={}, "
+ "E in nucleons={}, "
+ "Plab_initial={}, "
+ "Plab_final={} ",
+ Ecm / 1_GeV, Ecm_final * 2. / (get_nwounded() + 1) / 1_GeV, Etot / 1_GeV,
+ Elab_final / 1_GeV, (Elab_final / Etot / get_nwounded() - 1) * 100,
+ constants::nucleonMass * get_nwounded() / 1_GeV,
+ (pProjectileLab / 1_GeV).getComponents(), (Plab_final / 1_GeV).getComponents());
}
}
diff --git a/corsika/detail/modules/sibyll/NuclearInteraction.inl b/corsika/detail/modules/sibyll/NuclearInteraction.inl
index 0043ceb56..1aad71bef 100644
--- a/corsika/detail/modules/sibyll/NuclearInteraction.inl
+++ b/corsika/detail/modules/sibyll/NuclearInteraction.inl
@@ -16,7 +16,9 @@
#include <corsika/framework/geometry/FourVector.hpp>
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/utility/COMBoost.hpp>
+#include <corsika/framework/logging/Logging.hpp>
+#include <corsika/setup/SetupEnvironment.hpp>
#include <corsika/setup/SetupStack.hpp>
#include <corsika/setup/SetupTrajectory.hpp>
@@ -24,52 +26,69 @@
namespace corsika::sibyll {
- template <>
- NuclearInteraction<corsika::setup::SetupEnvironment>::NuclearInteraction(
- corsika::sibyll::Interaction& hadint, corsika::setup::SetupEnvironment const& env)
+ template <typename TEnvironment>
+ NuclearInteraction<TEnvironment>::NuclearInteraction(sibyll::Interaction& hadint,
+ TEnvironment const& env)
: environment_(env)
- , hadronicInteraction_(hadint) {}
+ , hadronicInteraction_(hadint) {
- template <>
- NuclearInteraction<corsika::setup::SetupEnvironment>::~NuclearInteraction() {
- std::cout << "Nuclib::NuclearInteraction n=" << count_ << " Nnuc=" << nucCount_
- << std::endl;
+ // initialize hadronic interaction module
+
+ // check compatibility of energy ranges, someone could try to use low-energy model..
+ if (!hadronicInteraction_.isValidCoMEnergy(getMinEnergyPerNucleonCoM()) ||
+ !hadronicInteraction_.isValidCoMEnergy(getMaxEnergyPerNucleonCoM()))
+ throw std::runtime_error(
+ "NuclearInteraction: hadronic interaction model incompatible!");
+
+ // initialize nuclib
+ // TODO: make sure this does not overlap with sibyll
+ nuc_nuc_ini_();
+
+ // initialize cross sections
+ initializeNuclearCrossSections();
}
- template <>
- void NuclearInteraction<corsika::setup::SetupEnvironment>::PrintCrossSectionTable(
- corsika::Code pCode) {
+ template <typename TEnvironment>
+ NuclearInteraction<TEnvironment>::~NuclearInteraction() {
+ CORSIKA_LOG_DEBUG("Nuclib::NuclearInteraction n={} Nnuc={}", count_, nucCount_);
+ }
+
+ template <typename TEnvironment>
+ void NuclearInteraction<TEnvironment>::printCrossSectionTable(Code pCode) {
const int k = targetComponentsIndex_.at(pCode);
Code pNuclei[] = {Code::Helium, Code::Lithium7, Code::Oxygen,
Code::Neon, Code::Argon, Code::Iron};
- std::cout << "en/A ";
- for (auto& j : pNuclei) std::cout << std::setw(9) << j;
- std::cout << std::endl;
+
+ std::ostringstream table;
+ table << "Nuclear CrossSectionTable pCode=" << pCode << " :\n en/A ";
+ for (auto& j : pNuclei) table << std::setw(9) << j;
+ table << "\n";
// loop over energy bins
- for (unsigned int i = 0; i < GetNEnergyBins(); ++i) {
- std::cout << " " << i << " ";
+ for (unsigned int i = 0; i < getNEnergyBins(); ++i) {
+ table << " " << i << " ";
+
for (auto& n : pNuclei) {
- auto const j = corsika::get_nucleus_A(n);
- std::cout << " " << std::setprecision(5) << std::setw(8)
- << cnucsignuc_.sigma[j - 1][k][i];
+ auto const j = get_nucleus_A(n);
+ table << " " << std::setprecision(5) << std::setw(8)
+ << cnucsignuc_.sigma[j - 1][k][i];
}
- std::cout << std::endl;
+ table << "\n";
}
+ CORSIKA_LOG_DEBUG(table.str());
}
- template <>
- void
- NuclearInteraction<corsika::setup::SetupEnvironment>::InitializeNuclearCrossSections() {
+ template <typename TEnvironment>
+ void NuclearInteraction<TEnvironment>::initializeNuclearCrossSections() {
- auto& universe = *(environment_.GetUniverse());
+ auto& universe = *(environment_.getUniverse());
auto const allElementsInUniverse = std::invoke([&]() {
- std::set<corsika::Code> allElementsInUniverse;
+ std::set<Code> allElementsInUniverse;
auto collectElements = [&](auto& vtn) {
- if (vtn.HasModelProperties()) {
+ if (vtn.hasModelProperties()) {
auto const& comp =
- vtn.GetModelProperties().getNuclearComposition().GetComponents();
+ vtn.getModelProperties().getNuclearComposition().getComponents();
for (auto const c : comp) allElementsInUniverse.insert(c);
}
};
@@ -77,32 +96,31 @@ namespace corsika::sibyll {
return allElementsInUniverse;
});
- std::cout << "NuclearInteraction: initializing nuclear cross sections..."
- << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: initializing nuclear cross sections...");
// loop over target components, at most 4!!
int k = -1;
for (auto& ptarg : allElementsInUniverse) {
++k;
- std::cout << "NuclearInteraction: init target component: " << ptarg << std::endl;
- const int ib = corsika::get_nucleus_A(ptarg);
- if (!hadronicInteraction_.IsValidTarget(ptarg)) {
- std::cout
- << "NuclearInteraction::InitializeNuclearCrossSections: target nucleus? id="
- << ptarg << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: init target component: {}", ptarg);
+ const int ib = get_nucleus_A(ptarg);
+ if (!hadronicInteraction_.isValidTarget(ptarg)) {
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction::InitializeNuclearCrossSections: target nucleus? id={}",
+ ptarg);
throw std::runtime_error(
" target can not be handled by hadronic interaction model! ");
}
targetComponentsIndex_.insert(std::pair<Code, int>(ptarg, k));
// loop over energies, fNEnBins log. energy bins
- for (unsigned int i = 0; i < GetNEnergyBins(); ++i) {
+ for (unsigned int i = 0; i < getNEnergyBins(); ++i) {
// hard coded energy grid, has to be aligned to definition in signuc2!!, no
// comment..
const HEPEnergyType Ecm = pow(10., 1. + 1. * i) * 1_GeV;
// get p-p cross sections
auto const protonId = Code::Proton;
auto const [siginel, sigela] =
- hadronicInteraction_.GetCrossSection(protonId, protonId, Ecm);
+ hadronicInteraction_.getCrossSection(protonId, protonId, Ecm);
const double dsig = siginel / 1_mb;
const double dsigela = sigela / 1_mb;
// loop over projectiles, mass numbers from 2 to fMaxNucleusAProjectile
@@ -117,85 +135,64 @@ namespace corsika::sibyll {
}
}
}
- std::cout << "NuclearInteraction: cross sections for "
- << targetComponentsIndex_.size() << " components initialized!" << std::endl;
- for (auto& ptarg : allElementsInUniverse) {
- std::cout << "cross section table: " << ptarg << std::endl;
- PrintCrossSectionTable(ptarg);
- }
- }
-
- template <>
- void NuclearInteraction<corsika::setup::SetupEnvironment>::Init() {
-
- // initialize hadronic interaction module
- // TODO: safe to run multiple initializations?
- if (!hadronicInteraction_.WasInitialized()) hadronicInteraction_.Init();
-
- // check compatibility of energy ranges, someone could try to use low-energy model..
- if (!hadronicInteraction_.IsValidCoMEnergy(GetMinEnergyPerNucleonCoM()) ||
- !hadronicInteraction_.IsValidCoMEnergy(GetMaxEnergyPerNucleonCoM()))
- throw std::runtime_error(
- "NuclearInteraction: hadronic interaction model incompatible!");
-
- // initialize nuclib
- // TODO: make sure this does not overlap with sibyll
- nuc_nuc_ini_();
-
- // initialize cross sections
- InitializeNuclearCrossSections();
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: cross sections for {} "
+ " components initialized!",
+ targetComponentsIndex_.size());
+ for (auto& ptarg : allElementsInUniverse) { printCrossSectionTable(ptarg); }
}
- template <>
- CrossSectionType
- NuclearInteraction<corsika::setup::SetupEnvironment>::ReadCrossSectionTable(
- const int ia, corsika::Code pTarget, HEPEnergyType elabnuc) {
+ template <typename TEnvironment>
+ CrossSectionType NuclearInteraction<TEnvironment>::readCrossSectionTable(
+ const int ia, Code pTarget, HEPEnergyType elabnuc) {
const int ib = targetComponentsIndex_.at(pTarget) + 1; // table index in fortran
auto const ECoMNuc = sqrt(2. * constants::nucleonMass * elabnuc);
- if (ECoMNuc < GetMinEnergyPerNucleonCoM() || ECoMNuc > GetMaxEnergyPerNucleonCoM())
+ if (ECoMNuc < getMinEnergyPerNucleonCoM() || ECoMNuc > getMaxEnergyPerNucleonCoM())
throw std::runtime_error("NuclearInteraction: energy outside tabulated range!");
const double e0 = elabnuc / 1_GeV;
double sig;
- std::cout << "ReadCrossSectionTable: " << ia << " " << ib << " " << e0 << std::endl;
+ CORSIKA_LOG_DEBUG("ReadCrossSectionTable: {} {} {}", ia, ib, e0);
signuc2_(ia, ib, e0, sig);
- std::cout << "ReadCrossSectionTable: sig=" << sig << std::endl;
+ CORSIKA_LOG_DEBUG("ReadCrossSectionTable: sig={}", sig);
return sig * 1_mb;
}
// TODO: remove elastic cross section?
- template <>
+ template <typename TEnvironment>
template <typename TParticle>
std::tuple<CrossSectionType, CrossSectionType>
- NuclearInteraction<corsika::setup::SetupEnvironment>::GetCrossSection(
- const TParticle& vP, const corsika::Code TargetId) {
+ NuclearInteraction<TEnvironment>::getCrossSection(TParticle const& projectile,
+ Code const TargetId) {
- if (vP.GetPID() != corsika::Code::Nucleus)
+ if (projectile.getPID() != Code::Nucleus)
throw std::runtime_error(
- "NuclearInteraction: GetCrossSection: particle not a nucleus!");
+ "NuclearInteraction: getCrossSection: particle not a nucleus!");
- unsigned int const iBeamA = vP.GetNuclearA();
- HEPEnergyType LabEnergyPerNuc = vP.GetEnergy() / iBeamA;
- std::cout << "NuclearInteraction: GetCrossSection: called with: beamNuclA= " << iBeamA
- << " TargetId= " << TargetId
- << " LabEnergyPerNuc= " << LabEnergyPerNuc / 1_GeV << std::endl;
+ unsigned int const iBeamA = projectile.getNuclearA();
+ HEPEnergyType LabEnergyPerNuc = projectile.getEnergy() / iBeamA;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: getCrossSection: called with: beamNuclA={} "
+ " TargetId={} LabEnergyPerNuc={}GeV ",
+ iBeamA, TargetId, LabEnergyPerNuc / 1_GeV);
// use nuclib to calc. nuclear cross sections
// TODO: for now assumes air with hard coded composition
// extend to arbitrary mixtures, requires smarter initialization
// get nuclib projectile code: nucleon number
- if (iBeamA > GetMaxNucleusAProjectile() || iBeamA < 2) {
- std::cout << "NuclearInteraction: beam nucleus outside allowed range for NUCLIB!"
- << std::endl
- << "A=" << iBeamA << std::endl;
+ if (iBeamA > getMaxNucleusAProjectile() || iBeamA < 2) {
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: beam nucleus outside allowed range for NUCLIB!"
+ "A=" +
+ std::to_string(iBeamA));
throw std::runtime_error(
- "NuclearInteraction: GetCrossSection: beam nucleus outside allowed range for "
+ "NuclearInteraction: getCrossSection: beam nucleus outside allowed range for "
"NUCLIB!");
}
- if (hadronicInteraction_.IsValidTarget(TargetId)) {
- auto const sigProd = ReadCrossSectionTable(iBeamA, TargetId, LabEnergyPerNuc);
- std::cout << "cross section (mb): " << sigProd / 1_mb << std::endl;
+ if (hadronicInteraction_.isValidTarget(TargetId)) {
+ auto const sigProd = readCrossSectionTable(iBeamA, TargetId, LabEnergyPerNuc);
+ CORSIKA_LOG_DEBUG("cross section (mb): " + std::to_string(sigProd / 1_mb));
return std::make_tuple(sigProd, 0_mb);
} else {
throw std::runtime_error("target outside range.");
@@ -204,24 +201,22 @@ namespace corsika::sibyll {
std::numeric_limits<double>::infinity() * 1_mb);
}
- template <>
+ template <typename TEnvironment>
template <typename TParticle>
- GrammageType NuclearInteraction<corsika::setup::SetupEnvironment>::GetInteractionLength(
- const TParticle& vP) {
+ GrammageType NuclearInteraction<TEnvironment>::getInteractionLength(
+ TParticle const& projectile) {
// coordinate system, get global frame of reference
- CoordinateSystem& rootCS =
- RootCoordinateSystem::getInstance().GetRootCoordinateSystem();
- const corsika::Code corsikaBeamId = vP.GetPID();
+ const Code corsikaBeamId = projectile.getPID();
- if (corsikaBeamId != corsika::Code::Nucleus) {
+ if (corsikaBeamId != Code::Nucleus) {
// check if target-style nucleus (enum), these are not allowed as projectile
- if (corsika::is_nucleus(corsikaBeamId))
+ if (is_nucleus(corsikaBeamId)) {
throw std::runtime_error(
- "NuclearInteraction: GetInteractionLength: Wrong nucleus type. Nuclear "
+ "NuclearInteraction: getInteractionLength: Wrong nucleus type. Nuclear "
"projectiles should use NuclearStackExtension!");
- else {
+ } else {
// no nuclear interaction
return std::numeric_limits<double>::infinity() * 1_g / (1_cm * 1_cm);
}
@@ -229,30 +224,35 @@ namespace corsika::sibyll {
// read from cross section code table
+ MomentumVector pLab = projectile.getMomentum();
+ CoordinateSystemPtr const& labCS = pLab.getCoordinateSystem();
+
// FOR NOW: assume target is at rest
- corsika::MomentumVector pTarget(rootCS, {0.0_GeV, 0.0_GeV, 0.0_GeV});
+ MomentumVector pTarget(labCS, {0.0_GeV, 0.0_GeV, 0.0_GeV});
// total momentum and energy
- HEPEnergyType Elab = vP.GetEnergy() + constants::nucleonMass;
- int const nuclA = vP.GetNuclearA();
- auto const ElabNuc = vP.GetEnergy() / nuclA;
+ HEPEnergyType Elab = projectile.getEnergy() + constants::nucleonMass;
+ int const nuclA = projectile.getNuclearA();
+ auto const ElabNuc = projectile.getEnergy() / nuclA;
- corsika::MomentumVector pTotLab(rootCS, {0.0_GeV, 0.0_GeV, 0.0_GeV});
- pTotLab += vP.GetMomentum();
+ MomentumVector pTotLab(labCS, {0.0_GeV, 0.0_GeV, 0.0_GeV});
+ pTotLab += pLab;
pTotLab += pTarget;
- auto const pTotLabNorm = pTotLab.norm();
+ auto const pTotLabNorm = pTotLab.getNorm();
// calculate cm. energy
- const HEPEnergyType ECoM = sqrt(
+ HEPEnergyType const ECoM = sqrt(
(Elab + pTotLabNorm) * (Elab - pTotLabNorm)); // binomial for numerical accuracy
auto const ECoMNN = sqrt(2. * ElabNuc * constants::nucleonMass);
- std::cout << "NuclearInteraction: LambdaInt: \n"
- << " input energy: " << Elab / 1_GeV << std::endl
- << " input energy CoM: " << ECoM / 1_GeV << std::endl
- << " beam pid:" << corsikaBeamId << std::endl
- << " beam A: " << nuclA << std::endl
- << " input energy per nucleon: " << ElabNuc / 1_GeV << std::endl
- << " input energy CoM per nucleon: " << ECoMNN / 1_GeV << std::endl;
- // throw std::runtime_error("stop here");
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: LambdaInt: \n"
+ " input energy: {}GeV\n"
+ " input energy CoM: {}GeV\n"
+ " beam pid: {}\n"
+ " beam A: {}\n"
+ " input energy per nucleon: {}GeV\n"
+ " input energy CoM per nucleon: {}GeV ",
+ Elab / 1_GeV, ECoM / 1_GeV, get_name(corsikaBeamId), nuclA, ElabNuc / 1_GeV,
+ ECoMNN / 1_GeV);
// energy limits
// TODO: values depend on hadronic interaction model !! this is sibyll specific
@@ -265,39 +265,42 @@ namespace corsika::sibyll {
ideally as full particle object so that the four momenta
and the boosts can be defined..
*/
- auto const* const currentNode = vP.GetNode();
+ auto const* const currentNode = projectile.getNode();
auto const& mediumComposition =
- currentNode->GetModelProperties().getNuclearComposition();
+ currentNode->getModelProperties().getNuclearComposition();
// determine average interaction length
// weighted sum
int i = -1;
CrossSectionType weightedProdCrossSection = 0_mb;
// get weights of components from environment/medium
- const auto& w = mediumComposition.GetFractions();
+ const auto& w = mediumComposition.getFractions();
// loop over components in medium
- for (auto const targetId : mediumComposition.GetComponents()) {
+ for (auto const targetId : mediumComposition.getComponents()) {
i++;
- std::cout << "NuclearInteraction: get interaction length for target: " << targetId
- << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: get interaction length for target: {}",
+ get_name(targetId));
auto const [productionCrossSection, elaCrossSection] =
- GetCrossSection(vP, targetId);
+ getCrossSection(projectile, targetId);
[[maybe_unused]] auto& dummy_elaCrossSection = elaCrossSection;
- std::cout << "NuclearInteraction: "
- << "IntLength: nuclib return (mb): " << productionCrossSection / 1_mb
- << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: "
+ "IntLength: nuclib return (mb): " +
+ std::to_string(productionCrossSection / 1_mb));
weightedProdCrossSection += w[i] * productionCrossSection;
}
- std::cout << "NuclearInteraction: "
- << "IntLength: weighted CrossSection (mb): "
- << weightedProdCrossSection / 1_mb << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: "
+ "IntLength: weighted CrossSection (mb): {} ",
+ weightedProdCrossSection / 1_mb);
// calculate interaction length in medium
- GrammageType const int_length = mediumComposition.GetAverageMassNumber() *
+ GrammageType const int_length = mediumComposition.getAverageMassNumber() *
constants::u / weightedProdCrossSection;
- std::cout << "NuclearInteraction: "
- << "interaction length (g/cm2): "
- << int_length * (1_cm * 1_cm / (0.001_kg)) << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: "
+ "interaction length (g/cm2): {} ",
+ int_length * (1_cm * 1_cm / (0.001_kg)));
return int_length;
} else {
@@ -305,88 +308,91 @@ namespace corsika::sibyll {
}
}
- template <>
- template <typename TProjectile>
- void
- NuclearInteraction<corsika::setup::SetupEnvironment>::doInteraction(TProjectile& vP) {
+ template <typename TEnvironment>
+ template <typename TSecondaryView>
+ void NuclearInteraction<TEnvironment>::doInteraction(TSecondaryView& view) {
- using namespace si;
+ auto projectile = view.getProjectile();
// this routine superimposes different nucleon-nucleon interactions
// in a nucleus-nucleus interaction, based the SIBYLL routine SIBNUC
- const auto ProjId = vP.GetPID();
+ const auto ProjId = projectile.getPID();
// TODO: calculate projectile mass in nuclearStackExtension
- // const auto ProjMass = vP.GetMass();
- std::cout << "NuclearInteraction: DoInteraction: called with:" << ProjId << std::endl;
+ // const auto ProjMass = projectile.getMass();
+
+ CORSIKA_LOG_DEBUG("NuclearInteraction: DoInteraction: called with: {}",
+ get_name(ProjId));
// check if target-style nucleus (enum)
- if (ProjId != corsika::Code::Nucleus)
+ if (ProjId != Code::Nucleus)
throw std::runtime_error(
"NuclearInteraction: DoInteraction: Wrong nucleus type. Nuclear projectiles "
"should use NuclearStackExtension!");
- auto const ProjMass = corsika::nucleus_mass(vP.GetNuclearA(), vP.GetNuclearZ());
- std::cout << "NuclearInteraction: projectile mass: " << ProjMass / 1_GeV << std::endl;
+ auto const ProjMass =
+ projectile.getNuclearZ() * Proton::mass +
+ (projectile.getNuclearA() - projectile.getNuclearZ()) * Neutron::mass;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: projectile mass: {} ", ProjMass / 1_GeV);
count_++;
- const CoordinateSystem& rootCS =
- RootCoordinateSystem::getInstance().GetRootCoordinateSystem();
-
// position and time of interaction, not used in NUCLIB
- Point pOrig = vP.GetPosition();
- TimeType tOrig = vP.GetTime();
+ Point pOrig = projectile.getPosition();
+ TimeType tOrig = projectile.getTime();
- std::cout << "Interaction: position of interaction: " << pOrig.GetCoordinates()
- << std::endl;
- std::cout << "Interaction: time: " << tOrig << std::endl;
+ CORSIKA_LOG_DEBUG("Interaction: position of interaction: {}", pOrig.getCoordinates());
+ CORSIKA_LOG_DEBUG("Interaction: time: {} ", tOrig / 1_s);
// projectile nucleon number
- const unsigned int kAProj = vP.GetNuclearA();
- if (kAProj > GetMaxNucleusAProjectile())
+ const unsigned int kAProj = projectile.getNuclearA();
+ if (kAProj > getMaxNucleusAProjectile())
throw std::runtime_error("Projectile nucleus too large for NUCLIB!");
// kinematics
// define projectile nucleus
- HEPEnergyType const eProjectileLab = vP.GetEnergy();
- auto const pProjectileLab = vP.GetMomentum();
- const FourVector PprojLab(eProjectileLab, pProjectileLab);
+ HEPEnergyType const eProjectileLab = projectile.getEnergy();
+ MomentumVector const pProjectileLab = projectile.getMomentum();
+ FourVector const PprojLab(eProjectileLab, pProjectileLab);
+ CoordinateSystemPtr const& labCS = pProjectileLab.getCoordinateSystem();
- std::cout << "NuclearInteraction: eProj lab: " << eProjectileLab / 1_GeV << std::endl
- << "NuclearInteraction: pProj lab: "
- << pProjectileLab.GetComponents() / 1_GeV << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: eProj lab: {} "
+ "pProj lab: {} ",
+ eProjectileLab / 1_GeV, pProjectileLab.getComponents() / 1_GeV);
// define projectile nucleon
- HEPEnergyType const eProjectileNucLab = vP.GetEnergy() / kAProj;
- auto const pProjectileNucLab = vP.GetMomentum() / kAProj;
- const FourVector PprojNucLab(eProjectileNucLab, pProjectileNucLab);
+ HEPEnergyType const eProjectileNucLab = eProjectileLab / kAProj;
+ MomentumVector const pProjectileNucLab = pProjectileLab / kAProj;
+ FourVector const PprojNucLab(eProjectileNucLab, pProjectileNucLab);
- std::cout << "NuclearInteraction: eProjNucleon lab: " << eProjectileNucLab / 1_GeV
- << std::endl
- << "NuclearInteraction: pProjNucleon lab: "
- << pProjectileNucLab.GetComponents() / 1_GeV << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: eProjNucleon lab (GeV): {} "
+ "pProjNucleon lab (GeV): {} ",
+ eProjectileNucLab / 1_GeV, pProjectileNucLab.getComponents() / 1_GeV);
// define target
// always a nucleon
// target is always at rest
- const auto eTargetNucLab = 0_GeV + constants::nucleonMass;
- const auto pTargetNucLab = corsika::MomentumVector(rootCS, 0_GeV, 0_GeV, 0_GeV);
- const FourVector PtargNucLab(eTargetNucLab, pTargetNucLab);
+ auto const eTargetNucLab = 0_GeV + constants::nucleonMass;
+ auto const pTargetNucLab = MomentumVector(labCS, 0_GeV, 0_GeV, 0_GeV);
+ FourVector const PtargNucLab(eTargetNucLab, pTargetNucLab);
- std::cout << "NuclearInteraction: etarget lab: " << eTargetNucLab / 1_GeV << std::endl
- << "NuclearInteraction: ptarget lab: "
- << pTargetNucLab.GetComponents() / 1_GeV << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: etarget lab(GeV): {} "
+ "NuclearInteraction: ptarget lab(GeV): {} ",
+ eTargetNucLab / 1_GeV, pTargetNucLab.getComponents() / 1_GeV);
// center-of-mass energy in nucleon-nucleon frame
auto const PtotNN4 = PtargNucLab + PprojNucLab;
- HEPEnergyType EcmNN = PtotNN4.GetNorm();
- std::cout << "NuclearInteraction: nuc-nuc cm energy: " << EcmNN / 1_GeV << std::endl;
+ HEPEnergyType EcmNN = PtotNN4.getNorm();
- if (!hadronicInteraction_.IsValidCoMEnergy(EcmNN)) {
- std::cout << "NuclearInteraction: nuc-nuc. CoM energy too low for hadronic "
- "interaction model!"
- << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: nuc-nuc cm energy: {}", EcmNN / 1_GeV);
+
+ if (!hadronicInteraction_.isValidCoMEnergy(EcmNN)) {
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: nuc-nuc. CoM energy too low for hadronic "
+ "interaction model!");
throw std::runtime_error("NuclearInteraction: DoInteraction: energy too low!");
}
@@ -398,94 +404,98 @@ namespace corsika::sibyll {
// boost target
auto const PtargNucCoM = boost.toCoM(PtargNucLab);
- std::cout << "Interaction: ebeam CoM: " << PprojNucCoM.GetTimeLikeComponent() / 1_GeV
- << std::endl
- << "Interaction: pbeam CoM: "
- << PprojNucCoM.GetSpaceLikeComponents().GetComponents() / 1_GeV
- << std::endl;
- std::cout << "Interaction: etarget CoM: "
- << PtargNucCoM.GetTimeLikeComponent() / 1_GeV << std::endl
- << "Interaction: ptarget CoM: "
- << PtargNucCoM.GetSpaceLikeComponents().GetComponents() / 1_GeV
- << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "Interaction: ebeam CoM: {} "
+ ", pbeam CoM: {} ",
+ PprojNucCoM.getTimeLikeComponent() / 1_GeV,
+ PprojNucCoM.getSpaceLikeComponents().getComponents() / 1_GeV);
+ CORSIKA_LOG_DEBUG(
+ "Interaction: etarget CoM: {}"
+ ", ptarget CoM: {}",
+ PtargNucCoM.getTimeLikeComponent() / 1_GeV,
+ PtargNucCoM.getSpaceLikeComponents().getComponents() / 1_GeV);
// sample target nucleon number
//
// proton stand-in for nucleon
- const auto beamId = corsika::Code::Proton;
- auto const* const currentNode = vP.GetNode();
+ const auto beamId = Code::Proton;
+ auto const* const currentNode = projectile.getNode();
const auto& mediumComposition =
- currentNode->GetModelProperties().getNuclearComposition();
- std::cout << "get nucleon-nucleus cross sections for target materials.." << std::endl;
+ currentNode->getModelProperties().getNuclearComposition();
+ CORSIKA_LOG_DEBUG("get nucleon-nucleus cross sections for target materials..");
// get cross sections for target materials
// using nucleon-target-nucleus cross section!!!
/*
Here we read the cross section from the interaction model again,
- should be passed from GetInteractionLength if possible
+ should be passed from getInteractionLength if possible
*/
- auto const& compVec = mediumComposition.GetComponents();
+ auto const& compVec = mediumComposition.getComponents();
std::vector<CrossSectionType> cross_section_of_components(compVec.size());
for (size_t i = 0; i < compVec.size(); ++i) {
auto const targetId = compVec[i];
- std::cout << "target component: " << targetId << std::endl;
- std::cout << "beam id: " << beamId << std::endl;
+ CORSIKA_LOG_DEBUG("target component: {}", get_name(targetId));
+ CORSIKA_LOG_DEBUG("beam id: {}", get_name(beamId));
const auto [sigProd, sigEla] =
- hadronicInteraction_.GetCrossSection(beamId, targetId, EcmNN);
+ hadronicInteraction_.getCrossSection(beamId, targetId, EcmNN);
cross_section_of_components[i] = sigProd;
[[maybe_unused]] auto sigElaCopy = sigEla; // ONLY TO AVOID COMPILER WARNINGS
}
const auto targetCode =
- mediumComposition.SampleTarget(cross_section_of_components, RNG_);
- std::cout << "Interaction: target selected: " << targetCode << std::endl;
+ mediumComposition.sampleTarget(cross_section_of_components, RNG_);
+ CORSIKA_LOG_DEBUG("Interaction: target selected: {}", get_name(targetCode));
/*
FOR NOW: allow nuclei with A<18 or protons only.
when medium composition becomes more complex, approximations will have to be
allowed air in atmosphere also contains some Argon.
*/
int kATarget = -1;
- if (corsika::is_nucleus(targetCode))
- kATarget = corsika::get_nucleus_A(targetCode);
- else if (targetCode == corsika::Code::Proton)
+ if (is_nucleus(targetCode))
+ kATarget = get_nucleus_A(targetCode);
+ else if (targetCode == Code::Proton)
kATarget = 1;
- std::cout << "NuclearInteraction: nuclib target code: " << kATarget << std::endl;
- if (!hadronicInteraction_.IsValidTarget(targetCode))
+ CORSIKA_LOG_DEBUG("NuclearInteraction: nuclib target code: " +
+ std::to_string(kATarget));
+ if (!hadronicInteraction_.isValidTarget(targetCode))
throw std::runtime_error("target outside range. ");
// end of target sampling
// superposition
- std::cout << "NuclearInteraction: sampling nuc. multiple interaction structure.. "
- << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "NuclearInteraction: sampling nuc. multiple interaction structure.. ");
// get nucleon-nucleon cross section
// (needed to determine number of nucleon-nucleon scatterings)
- const auto protonId = corsika::Code::Proton;
+ const auto protonId = Code::Proton;
const auto [prodCrossSection, elaCrossSection] =
- hadronicInteraction_.GetCrossSection(protonId, protonId, EcmNN);
+ hadronicInteraction_.getCrossSection(protonId, protonId, EcmNN);
const double sigProd = prodCrossSection / 1_mb;
const double sigEla = elaCrossSection / 1_mb;
// sample number of interactions (only input variables, output in common cnucms)
// nuclear multiple scattering according to glauber (r.i.p.)
int_nuc_(kATarget, kAProj, sigProd, sigEla);
- std::cout << "number of nucleons in target : " << kATarget << std::endl
- << "number of wounded nucleons in target : " << cnucms_.na << std::endl
- << "number of nucleons in projectile : " << kAProj << std::endl
- << "number of wounded nucleons in project. : " << cnucms_.nb << std::endl
- << "number of inel. nuc.-nuc. interactions : " << cnucms_.ni << std::endl
- << "number of elastic nucleons in target : " << cnucms_.nael << std::endl
- << "number of elastic nucleons in project. : " << cnucms_.nbel << std::endl
- << "impact parameter: " << cnucms_.b << std::endl;
+ CORSIKA_LOG_DEBUG(
+ "number of nucleons in target : {}\n"
+ "number of wounded nucleons in target : {}\n"
+ "number of nucleons in projectile : {}\n"
+ "number of wounded nucleons in project. : {}\n"
+ "number of inel. nuc.-nuc. interactions : {}\n"
+ "number of elastic nucleons in target : {}\n"
+ "number of elastic nucleons in project. : {}\n"
+ "impact parameter: {}",
+ kATarget, cnucms_.na, kAProj, cnucms_.nb, cnucms_.ni, cnucms_.nael, cnucms_.nbel,
+ cnucms_.b);
// calculate fragmentation
- std::cout << "calculating nuclear fragments.." << std::endl;
+ CORSIKA_LOG_DEBUG("calculating nuclear fragments..");
// number of interactions
// include elastic
const int nElasticNucleons = cnucms_.nbel;
const int nInelNucleons = cnucms_.nb;
const int nIntProj = nInelNucleons + nElasticNucleons;
const double impactPar = cnucms_.b; // only needed to avoid passing common var.
- int nFragments;
+ int nFragments = 0;
// number of fragments is limited to 60
int AFragments[60];
// call fragmentation routine
@@ -495,19 +505,18 @@ namespace corsika::sibyll {
fragm_(kATarget, kAProj, nIntProj, impactPar, nFragments, AFragments);
// this should not occur but well :)
- if (nFragments > (int)GetMaxNFragments())
+ if (nFragments > (int)getMaxNFragments())
throw std::runtime_error("Number of nuclear fragments in NUCLIB exceeded!");
- std::cout << "number of fragments: " << nFragments << std::endl;
+ CORSIKA_LOG_DEBUG("number of fragments: " + std::to_string(nFragments));
for (int j = 0; j < nFragments; ++j)
- std::cout << "fragment: " << j << " A=" << AFragments[j]
- << " px=" << fragments_.ppp[j][0] << " py=" << fragments_.ppp[j][1]
- << " pz=" << fragments_.ppp[j][2] << std::endl;
+ CORSIKA_LOG_DEBUG("fragment {}: A={} px={} py={} pz={}", j, AFragments[j],
+ fragments_.ppp[j][0], fragments_.ppp[j][1], fragments_.ppp[j][2]);
- std::cout << "adding nuclear fragments to particle stack.." << std::endl;
+ CORSIKA_LOG_DEBUG("adding nuclear fragments to particle stack..");
// put nuclear fragments on corsika stack
for (int j = 0; j < nFragments; ++j) {
- corsika::Code specCode;
+ Code specCode;
const auto nuclA = AFragments[j];
// get Z from stability line
const auto nuclZ = int(nuclA / 2.15 + 0.7);
@@ -515,80 +524,85 @@ namespace corsika::sibyll {
// TODO: do we need to catch single nucleons??
if (nuclA == 1)
// TODO: sample neutron or proton
- specCode = corsika::Code::Proton;
+ specCode = Code::Proton;
else
- specCode = corsika::Code::Nucleus;
+ specCode = Code::Nucleus;
- const HEPMassType mass = corsika::nucleus_mass(nuclA, nuclZ);
+ const HEPMassType mass = get_nucleus_mass(nuclA, nuclZ);
- std::cout << "NuclearInteraction: adding fragment: " << specCode << std::endl;
- std::cout << "NuclearInteraction: A,Z: " << nuclA << "," << nuclZ << std::endl;
- std::cout << "NuclearInteraction: mass: " << mass / 1_GeV << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: adding fragment: {}", get_name(specCode));
+ CORSIKA_LOG_DEBUG("NuclearInteraction: A,Z: {}, {}", nuclA, nuclZ);
+ CORSIKA_LOG_DEBUG("NuclearInteraction: mass: {} GeV", std::to_string(mass / 1_GeV));
// CORSIKA 7 way
// spectators inherit momentum from original projectile
const double mass_ratio = mass / ProjMass;
- std::cout << "NuclearInteraction: mass ratio " << mass_ratio << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: mass ratio " + std::to_string(mass_ratio));
auto const Plab = PprojLab * mass_ratio;
- std::cout << "NuclearInteraction: fragment momentum: "
- << Plab.GetSpaceLikeComponents().GetComponents() / 1_GeV << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: fragment momentum: {}",
+ Plab.getSpaceLikeComponents().getComponents() / 1_GeV);
if (nuclA == 1)
// add nucleon
- vP.AddSecondary(std::tuple<corsika::Code, si::HEPEnergyType,
- corsika::MomentumVector, corsika::Point, si::TimeType>{
- specCode, Plab.GetTimeLikeComponent(), Plab.GetSpaceLikeComponents(), pOrig,
- tOrig});
+ projectile.addSecondary(std::make_tuple(specCode, Plab.getTimeLikeComponent(),
+ Plab.getSpaceLikeComponents(), pOrig,
+ tOrig));
else
// add nucleus
- vP.AddSecondary(
- std::tuple<corsika::Code, si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, si::TimeType, unsigned short, unsigned short>{
- specCode, Plab.GetTimeLikeComponent(), Plab.GetSpaceLikeComponents(),
- pOrig, tOrig, nuclA, nuclZ});
+ projectile.addSecondary(std::make_tuple(specCode, Plab.getTimeLikeComponent(),
+ Plab.getSpaceLikeComponents(), pOrig,
+ tOrig, nuclA, nuclZ));
}
// add elastic nucleons to corsika stack
// TODO: the elastic interaction could be external like the inelastic interaction,
// e.g. use existing ElasticModel
- std::cout << "adding elastically scattered nucleons to particle stack.." << std::endl;
+ CORSIKA_LOG_DEBUG("adding elastically scattered nucleons to particle stack..");
for (int j = 0; j < nElasticNucleons; ++j) {
// TODO: sample proton or neutron
- auto const elaNucCode = corsika::Code::Proton;
+ auto const elaNucCode = Code::Proton;
// CORSIKA 7 way
// elastic nucleons inherit momentum from original projectile
// neglecting momentum transfer in interaction
- const double mass_ratio = corsika::get_mass(elaNucCode) / ProjMass;
+ const double mass_ratio = get_mass(elaNucCode) / ProjMass;
auto const Plab = PprojLab * mass_ratio;
- vP.AddSecondary(std::tuple<corsika::Code, si::HEPEnergyType,
- corsika::MomentumVector, corsika::Point, si::TimeType>{
- elaNucCode, Plab.GetTimeLikeComponent(), Plab.GetSpaceLikeComponents(), pOrig,
- tOrig});
+ projectile.addSecondary(std::make_tuple(elaNucCode, Plab.getTimeLikeComponent(),
+ Plab.getSpaceLikeComponents(), pOrig,
+ tOrig));
}
// add inelastic interactions
std::cout << "calculate inelastic nucleon-nucleon interactions.." << std::endl;
for (int j = 0; j < nInelNucleons; ++j) {
// TODO: sample neutron or proton
- auto pCode = corsika::Code::Proton;
+ auto pCode = Code::Proton;
// temporarily add to stack, will be removed after interaction in DoInteraction
- std::cout << "inelastic interaction no. " << j << std::endl;
- auto inelasticNucleon = vP.AddSecondary(
- std::tuple<corsika::Code, si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, si::TimeType>{
- pCode, PprojNucLab.GetTimeLikeComponent(),
- PprojNucLab.GetSpaceLikeComponents(), pOrig, tOrig});
- // create inelastic interaction
- std::cout << "calling HadronicInteraction..." << std::endl;
- hadronicInteraction_.doInteraction(inelasticNucleon);
+ CORSIKA_LOG_DEBUG("inelastic interaction no. {}", j);
+ setup::Stack nucleonStack;
+ auto inelasticNucleon = nucleonStack.addParticle(
+ std::make_tuple(pCode, PprojNucLab.getTimeLikeComponent(),
+ PprojNucLab.getSpaceLikeComponents(), pOrig, tOrig));
+ inelasticNucleon.setNode(projectile.getNode());
+ // create inelastic interaction for each nucleon
+ CORSIKA_LOG_TRACE("calling HadronicInteraction...");
+ // create new StackView for each of the nucleons
+ setup::StackView nucleon_secondaries(inelasticNucleon);
+ // all inner hadronic event generator
+ hadronicInteraction_.doInteraction(nucleon_secondaries);
+ // inelasticNucleon.Delete(); // this is just a temporary object
+ for (const auto& pSec : nucleon_secondaries) {
+ projectile.addSecondary(std::make_tuple(pSec.getPID(), pSec.getEnergy(),
+ pSec.getMomentum(), pSec.getPosition(),
+ pSec.getTime()));
+ }
}
- std::cout << "NuclearInteraction: DoInteraction: done" << std::endl;
+ CORSIKA_LOG_DEBUG("NuclearInteraction: DoInteraction: done");
}
} // namespace corsika::sibyll
diff --git a/corsika/detail/modules/sibyll/ParticleConversion.inl b/corsika/detail/modules/sibyll/ParticleConversion.inl
index e458f36ee..0ac4efa25 100644
--- a/corsika/detail/modules/sibyll/ParticleConversion.inl
+++ b/corsika/detail/modules/sibyll/ParticleConversion.inl
@@ -10,12 +10,12 @@
#include <corsika/framework/core/ParticleProperties.hpp>
-corsika::HEPMassType corsika::sibyll::GetSibyllMass(corsika::Code const pCode) {
+corsika::HEPMassType corsika::sibyll::getSibyllMass(corsika::Code const pCode) {
if (pCode == corsika::Code::Nucleus)
- throw std::runtime_error("Cannot GetMass() of particle::Nucleus -> unspecified");
- auto sCode = ConvertToSibyllRaw(pCode);
+ throw std::runtime_error("Cannot getMass() of particle::Nucleus -> unspecified");
+ auto sCode = convertToSibyllRaw(pCode);
if (sCode == 0)
- throw std::runtime_error("GetSibyllMass: unknown particle!");
+ throw std::runtime_error("getSibyllMass: unknown particle!");
else
return sqrt(get_sibyll_mass2(sCode)) * 1_GeV;
}
diff --git a/corsika/detail/setup/SetupEnvironment.inl b/corsika/detail/setup/SetupEnvironment.inl
index 7b16b1c67..f78bc6313 100644
--- a/corsika/detail/setup/SetupEnvironment.inl
+++ b/corsika/detail/setup/SetupEnvironment.inl
@@ -5,36 +5,3 @@
#include <limits>
-namespace corsika::setup::testing {
-
- inline std::tuple<std::unique_ptr<setup::Environment>, CoordinateSystem const*,
- setup::Environment::BaseNodeType const*>
- setup_environment(Code vTargetCode) {
-
- auto env = std::make_unique<setup::Environment>();
- auto& universe = *(env->GetUniverse());
- CoordinateSystem const& cs = env->GetCoordinateSystem();
-
- /**
- * our world is a sphere at 0,0,0 with R=infty
- */
- auto world = setup::Environment::CreateNode<Sphere>(
- Point{cs, 0_m, 0_m, 0_m}, 1_km * std::numeric_limits<double>::infinity());
-
- /**
- * construct suited environment medium model:
- */
- using MyHomogeneousModel = MediumPropertyModel<
- UniformMagneticField<HomogeneousMedium<setup::EnvironmentInterface>>>;
-
- world->SetModelProperties<MyHomogeneousModel>(
- Medium::AirDry1Atm, Vector(cs, 0_T, 0_T, 1_T), 1_kg / (1_m * 1_m * 1_m),
- NuclearComposition(std::vector<Code>{vTargetCode}, std::vector<float>{1.}));
-
- setup::Environment::BaseNodeType const* nodePtr = world.get();
- universe.AddChild(std::move(world));
-
- return std::make_tuple(std::move(env), &cs, nodePtr);
- }
-
-} // namespace corsika::setup::testing
diff --git a/corsika/detail/setup/SetupStack.hpp b/corsika/detail/setup/SetupStack.hpp
index 712556461..7b5b3c3c5 100644
--- a/corsika/detail/setup/SetupStack.hpp
+++ b/corsika/detail/setup/SetupStack.hpp
@@ -1,10 +1,10 @@
#pragma once
#include <corsika/framework/stack/CombinedStack.hpp>
-#include <corsika/framework/stack/node/GeometryNodeStackExtension.hpp>
-#include <corsika/framework/stack/nuclear_extension/NuclearStackExtension.hpp>
-#include <corsika/framework/stack/history/HistorySecondaryProducer.hpp>
-#include <corsika/framework/stack/history/HistoryStackExtension.hpp>
+#include <corsika/stack/GeometryNodeStackExtension.hpp>
+#include <corsika/stack/NuclearStackExtension.hpp>
+#include <corsika/stack/history/HistorySecondaryProducer.hpp>
+#include <corsika/stack/history/HistoryStackExtension.hpp>
#include <corsika/setup/SetupEnvironment.hpp>
@@ -19,17 +19,17 @@ namespace corsika {
// environment:
template <typename TStackIter>
using SetupGeometryDataInterface =
- typename MakeGeometryDataInterface<TStackIter, setup::Environment>::type;
+ typename node::MakeGeometryDataInterface<TStackIter, setup::Environment>::type;
// combine particle data stack with geometry information for tracking
template <typename TStackIter>
using StackWithGeometryInterface =
- CombinedParticleInterface<nuclear_extension::ParticleDataStack::MPIType,
+ CombinedParticleInterface<nuclear_stack::ParticleDataStack::pi_type,
SetupGeometryDataInterface, TStackIter>;
- using StackWithGeometry =
- CombinedStack<typename nuclear_extension::ParticleDataStack::StackImpl,
- GeometryData<setup::Environment>, StackWithGeometryInterface>;
+ using StackWithGeometry = CombinedStack<
+ typename nuclear_stack::ParticleDataStack::stack_implementation_type,
+ node::GeometryData<setup::Environment>, StackWithGeometryInterface>;
// ------------------------------------------
// Add [optional] history data to stack, too:
@@ -37,11 +37,12 @@ namespace corsika {
// combine dummy stack with geometry information for tracking
template <typename TStackIter>
using StackWithHistoryInterface =
- CombinedParticleInterface<StackWithGeometry::MPIType, HistoryEventDataInterface,
+ CombinedParticleInterface<StackWithGeometry::pi_type, history::HistoryEventDataInterface,
TStackIter>;
- using StackWithHistory = CombinedStack<typename StackWithGeometry::StackImpl,
- HistoryEventData, StackWithHistoryInterface>;
+ using StackWithHistory =
+ CombinedStack<typename StackWithGeometry::stack_implementation_type,
+ history::HistoryEventData, StackWithHistoryInterface>;
} // namespace setup::detail
diff --git a/corsika/detail/setup/SetupStack.inl b/corsika/detail/setup/SetupStack.inl
index 3c1133555..e69de29bb 100644
--- a/corsika/detail/setup/SetupStack.inl
+++ b/corsika/detail/setup/SetupStack.inl
@@ -1,41 +0,0 @@
-#pragma once
-
-/**
- * \function setup_stack
- *
- * standard stack setup for unit tests.
- * \todo This can be moved to "test" directory, when available.
- */
-
-namespace corsika::setup::testing {
-
- inline std::tuple<std::unique_ptr<setup::Stack>, std::unique_ptr<setup::StackView>>
- setup_stack(Code vProjectileType, int vA, int vZ, HEPEnergyType vMomentum,
- setup::Environment::BaseNodeType* const vNodePtr,
- CoordinateSystem const& cs) {
-
- auto stack = std::make_unique<setup::Stack>();
-
- Point const origin(cs, {0_m, 0_m, 0_m});
- MomentumVector const pLab(cs, {vMomentum, 0_GeV, 0_GeV});
-
- if (vProjectileType == Code::Nucleus) {
- auto constexpr mN = constants::nucleonMass;
- HEPEnergyType const E0 = sqrt(static_pow<2>(mN * vA) + pLab.squaredNorm());
- auto particle = stack->AddParticle(
- std::make_tuple(Code::Nucleus, E0, pLab, origin, 0_ns, vA, vZ));
- particle.SetNode(vNodePtr);
- return std::make_tuple(std::move(stack),
- std::make_unique<setup::StackView>(particle));
- } else { // not a nucleus
- HEPEnergyType const E0 =
- sqrt(static_pow<2>(GetMass(vProjectileType)) + pLab.squaredNorm());
- auto particle =
- stack->AddParticle(std::make_tuple(vProjectileType, E0, pLab, origin, 0_ns));
- particle.SetNode(vNodePtr);
- return std::make_tuple(std::move(stack),
- std::make_unique<setup::StackView>(particle));
- }
- }
-
-} // namespace corsika::setup::testing
diff --git a/corsika/detail/stack/NuclearStackExtension.inl b/corsika/detail/stack/NuclearStackExtension.inl
index 00ead317f..2d10e28ee 100644
--- a/corsika/detail/stack/NuclearStackExtension.inl
+++ b/corsika/detail/stack/NuclearStackExtension.inl
@@ -21,44 +21,44 @@
namespace corsika::nuclear_stack {
-template <template <typename> class InnerParticleInterface,
- typename StackIteratorInterface>
-inline void NuclearParticleInterface< InnerParticleInterface,StackIteratorInterface>::setParticleData(particle_data_type const& v)
-{
-
- if (std::get<0>(v) == Code::Nucleus) {
- std::ostringstream err;
- err << "NuclearStackExtension: no A and Z specified for new Nucleus!";
- throw std::runtime_error(err.str());
- }
+ template <template <typename> class InnerParticleInterface,
+ typename StackIteratorInterface>
+ inline void NuclearParticleInterface<InnerParticleInterface, StackIteratorInterface>::
+ setParticleData(particle_data_type const& v) {
- super_type::setParticleData(v);
- setNucleusRef(-1); // this is not a nucleus
+ if (std::get<0>(v) == Code::Nucleus) {
+ std::ostringstream err;
+ err << "NuclearStackExtension: no A and Z specified for new Nucleus!";
+ throw std::runtime_error(err.str());
}
-template <template <typename> class InnerParticleInterface,
- typename StackIteratorInterface>
-inline void NuclearParticleInterface< InnerParticleInterface,StackIteratorInterface>::setParticleData(altenative_particle_data_type const& v)
-{
- const unsigned short A = std::get<5>(v);
- const unsigned short Z = std::get<6>(v);
- if (std::get<0>(v) != Code::Nucleus || A == 0 || Z == 0) {
- std::ostringstream err;
- err << "NuclearStackExtension: no A and Z specified for new Nucleus!";
- throw std::runtime_error(err.str());
- }
- setNucleusRef(
- super_type::getStackData().getNucleusNextRef()); // store this nucleus data ref
- setNuclearA(A);
- setNuclearZ(Z);
- super_type::setParticleData(particle_data_type{std::get<0>(v), std::get<1>(v),
- std::get<2>(v), std::get<3>(v),
- std::get<4>(v)});
+ super_type::setParticleData(v);
+ setNucleusRef(-1); // this is not a nucleus
+ }
+
+ template <template <typename> class InnerParticleInterface,
+ typename StackIteratorInterface>
+ inline void NuclearParticleInterface<InnerParticleInterface, StackIteratorInterface>::
+ setParticleData(altenative_particle_data_type const& v) {
+ const unsigned short A = std::get<5>(v);
+ const unsigned short Z = std::get<6>(v);
+ if (std::get<0>(v) != Code::Nucleus || A == 0 || Z == 0) {
+ std::ostringstream err;
+ err << "NuclearStackExtension: no A and Z specified for new Nucleus!";
+ throw std::runtime_error(err.str());
}
+ setNucleusRef(
+ super_type::getStackData().getNucleusNextRef()); // store this nucleus data ref
+ setNuclearA(A);
+ setNuclearZ(Z);
+ super_type::setParticleData(particle_data_type{
+ std::get<0>(v), std::get<1>(v), std::get<2>(v), std::get<3>(v), std::get<4>(v)});
+ }
-template <template <typename> class InnerParticleInterface,
- typename StackIteratorInterface>
-inline void NuclearParticleInterface< InnerParticleInterface,StackIteratorInterface>::setParticleData(super_type& p, particle_data_type const& v) {
+ template <template <typename> class InnerParticleInterface,
+ typename StackIteratorInterface>
+ inline void NuclearParticleInterface<InnerParticleInterface, StackIteratorInterface>::
+ setParticleData(super_type& p, particle_data_type const& v) {
if (std::get<0>(v) == Code::Nucleus) {
std::ostringstream err;
err << "NuclearStackExtension: no A and Z specified for new Nucleus!";
@@ -72,9 +72,10 @@ inline void NuclearParticleInterface< InnerParticleInterface,StackIteratorInterf
setNucleusRef(-1); // this is not a nucleus
}
-template <template <typename> class InnerParticleInterface,
- typename StackIteratorInterface>
-inline void NuclearParticleInterface< InnerParticleInterface,StackIteratorInterface>::setParticleData(super_type& p, altenative_particle_data_type const& v) {
+ template <template <typename> class InnerParticleInterface,
+ typename StackIteratorInterface>
+ inline void NuclearParticleInterface<InnerParticleInterface, StackIteratorInterface>::
+ setParticleData(super_type& p, altenative_particle_data_type const& v) {
const unsigned short A = std::get<5>(v);
const unsigned short Z = std::get<6>(v);
@@ -94,48 +95,51 @@ inline void NuclearParticleInterface< InnerParticleInterface,StackIteratorInterf
std::get<3>(v), std::get<4>(v)});
}
-template <template <typename> class InnerParticleInterface,
- typename StackIteratorInterface>
-inline std::string NuclearParticleInterface< InnerParticleInterface,StackIteratorInterface>::as_string() const {
+ template <template <typename> class InnerParticleInterface,
+ typename StackIteratorInterface>
+ inline std::string NuclearParticleInterface<InnerParticleInterface,
+ StackIteratorInterface>::asString() const {
return fmt::format(
- "{}, nuc({})", super_type::as_string(),
- (isNucleus() ? fmt::format("A={}, Z={}", getNuclearA(), getNuclearZ())
- : "n/a"));
+ "{}, nuc({})", super_type::asString(),
+ (isNucleus() ? fmt::format("A={}, Z={}", getNuclearA(), getNuclearZ()) : "n/a"));
}
-
-template <template <typename> class InnerParticleInterface,
- typename StackIteratorInterface>
-inline HEPMassType NuclearParticleInterface< InnerParticleInterface,StackIteratorInterface>::getMass() const {
+ template <template <typename> class InnerParticleInterface,
+ typename StackIteratorInterface>
+ inline HEPMassType NuclearParticleInterface<InnerParticleInterface,
+ StackIteratorInterface>::getMass() const {
if (super_type::getPID() == Code::Nucleus)
- return getNucleusMass(getNuclearA(), getNuclearZ());
+ return get_nucleus_mass(getNuclearA(), getNuclearZ());
return super_type::getMass();
}
-template <template <typename> class InnerParticleInterface,
- typename StackIteratorInterface>
-inline int16_t NuclearParticleInterface< InnerParticleInterface,StackIteratorInterface>::getChargeNumber() const {
+ template <template <typename> class InnerParticleInterface,
+ typename StackIteratorInterface>
+ inline int16_t NuclearParticleInterface<
+ InnerParticleInterface, StackIteratorInterface>::getChargeNumber() const {
if (super_type::getPID() == Code::Nucleus) return getNuclearZ();
return super_type::getChargeNumber();
}
-template <typename InnerStackImpl>
-inline int NuclearStackExtensionImpl<InnerStackImpl>::getNucleusNextRef(){
+ template <typename InnerStackImpl>
+ inline int NuclearStackExtensionImpl<InnerStackImpl>::getNucleusNextRef() {
nuclearA_.push_back(0);
nuclearZ_.push_back(0);
return nuclearA_.size() - 1;
}
-template <typename InnerStackImpl>
-inline int NuclearStackExtensionImpl<InnerStackImpl>::getNucleusRef(const unsigned int i) const {
+ template <typename InnerStackImpl>
+ inline int NuclearStackExtensionImpl<InnerStackImpl>::getNucleusRef(
+ const unsigned int i) const {
if (nucleusRef_[i] >= 0) return nucleusRef_[i];
std::ostringstream err;
err << "NuclearStackExtension: no nucleus at ref=" << i;
throw std::runtime_error(err.str());
}
-template <typename InnerStackImpl>
-inline void NuclearStackExtensionImpl<InnerStackImpl>::copy(const unsigned int i1, const unsigned int i2) {
+ template <typename InnerStackImpl>
+ inline void NuclearStackExtensionImpl<InnerStackImpl>::copy(const unsigned int i1,
+ const unsigned int i2) {
// index range check
if (i1 >= getSize() || i2 >= getSize()) {
std::ostringstream err;
@@ -176,16 +180,17 @@ inline void NuclearStackExtensionImpl<InnerStackImpl>::copy(const unsigned int i
}
}
-template <typename InnerStackImpl>
-inline void NuclearStackExtensionImpl<InnerStackImpl>::clear() {
+ template <typename InnerStackImpl>
+ inline void NuclearStackExtensionImpl<InnerStackImpl>::clear() {
super_type::clear();
nucleusRef_.clear();
nuclearA_.clear();
nuclearZ_.clear();
}
-template <typename InnerStackImpl>
-inline void NuclearStackExtensionImpl<InnerStackImpl>::swap(const unsigned int i1, const unsigned int i2) {
+ template <typename InnerStackImpl>
+ inline void NuclearStackExtensionImpl<InnerStackImpl>::swap(const unsigned int i1,
+ const unsigned int i2) {
// index range check
if (i1 >= getSize() || i2 >= getSize()) {
std::ostringstream err;
@@ -198,15 +203,14 @@ inline void NuclearStackExtensionImpl<InnerStackImpl>::swap(const unsigned int i
std::swap(nucleusRef_[i2], nucleusRef_[i1]);
}
-
-template <typename InnerStackImpl>
-inline void NuclearStackExtensionImpl<InnerStackImpl>::incrementSize() {
+ template <typename InnerStackImpl>
+ inline void NuclearStackExtensionImpl<InnerStackImpl>::incrementSize() {
super_type::incrementSize();
nucleusRef_.push_back(-1);
}
-template <typename InnerStackImpl>
-inline void NuclearStackExtensionImpl<InnerStackImpl>::decrementSize() {
+ template <typename InnerStackImpl>
+ inline void NuclearStackExtensionImpl<InnerStackImpl>::decrementSize() {
super_type::decrementSize();
if (nucleusRef_.size() > 0) {
const int ref = nucleusRef_.back();
@@ -222,6 +226,4 @@ inline void NuclearStackExtensionImpl<InnerStackImpl>::decrementSize() {
}
}
-
-
} // namespace corsika::nuclear_stack
diff --git a/corsika/framework/core/Cascade.hpp b/corsika/framework/core/Cascade.hpp
index 73dce0b79..ba0040c88 100644
--- a/corsika/framework/core/Cascade.hpp
+++ b/corsika/framework/core/Cascade.hpp
@@ -16,13 +16,13 @@
#include <corsika/framework/random/UniformRealDistribution.hpp>
#include <corsika/framework/stack/SecondaryView.hpp>
#include <corsika/media/Environment.hpp>
+#include <corsika/framework/logging/Logging.hpp>
#include <corsika/setup/SetupStack.hpp>
#include <corsika/setup/SetupTrajectory.hpp>
#include <cassert>
#include <cmath>
-#include <iostream>
#include <limits>
#include <type_traits>
@@ -33,7 +33,6 @@
namespace corsika {
/**
- * \class Cascade
*
* The Cascade class is constructed from template arguments making
* it very versatile. Via the template arguments physics models are
@@ -43,7 +42,7 @@ namespace corsika {
* TrackingInterface providing the functions:
*
* <code>
- * auto GetTrack(Particle const& p)</auto>,
+ * auto getTrack(Particle const& p)</auto>,
* with the return type <code>geometry::Trajectory<corsika::Line>
* </code>
*
@@ -57,8 +56,8 @@ namespace corsika {
typename TStackView = corsika::setup::StackView>
class Cascade {
- typedef typename TStack::ParticleType Particle;
- typedef std::remove_pointer_t<decltype(((Particle*)nullptr)->GetNode())>
+ typedef typename TStack::particle_type Particle;
+ typedef std::remove_pointer_t<decltype(((Particle*)nullptr)->getNode())>
VolumeTreeNode;
typedef typename VolumeTreeNode::IModelProperties MediumInterface;
@@ -67,50 +66,69 @@ namespace corsika {
Cascade(corsika::Environment<MediumInterface> const& env, TTracking& tr,
TProcessList& pl, TStack& stack)
- : fEnvironment(env)
- , fTracking(tr)
- , fProcessSequence(pl)
- , fStack(stack) {}
+ : environment_(env)
+ , tracking_(tr)
+ , sequence_(pl)
+ , stack_(stack) {
+ CORSIKA_LOG_INFO(c8_ascii_);
+ if constexpr (TStackView::has_event) {
+ CORSIKA_LOG_INFO(" - With full cascade HISTORY.");
+ }
+ }
/**
* The Init function is called before the actual cascade simulations.
* All components of the Cascade simulation must be configured here.
*/
- void Init();
+ void init();
/**
* set the nodes for all particles on the stack according to their numerical
* position
*/
- void SetNodes();
+ void setNodes();
/**
* The Run function is the main simulation loop, which processes
* particles from the Stack until the Stack is empty.
*/
- void Run();
+ void run();
/**
* Force an interaction of the top particle of the stack at its current position.
- * Note that SetNodes() or an equivalent procedure needs to be called first if you
+ * Note that setNodes() or an equivalent procedure needs to be called first if you
* want to call forceInteraction() for the primary interaction.
*/
void forceInteraction();
private:
- void Step(Particle& vParticle);
-
- auto decay(Particle& particle,
- decltype(std::declval<TStackView>().GetProjectile()) projectile);
-
- auto interaction(Particle& particle,
- decltype(std::declval<TStackView>().GetProjectile()) projectile);
-
- corsika::Environment<MediumInterface> const& fEnvironment;
- TTracking& fTracking;
- TProcessList& fProcessSequence;
- TStack& fStack;
- corsika::default_prng_type& fRNG = corsika::RNGManager::getInstance().getRandomStream("cascade");
+ void step(Particle& vParticle);
+
+ ProcessReturn decay(TStackView& view);
+ ProcessReturn interaction(TStackView& view);
+ void setEventType(TStackView& view, history::EventType);
+
+ // data members
+ corsika::Environment<MediumInterface> const& environment_;
+ TTracking& tracking_;
+ TProcessList& sequence_;
+ TStack& stack_;
+ corsika::default_prng_type& rng_ =
+ corsika::RNGManager::getInstance().getRandomStream("cascade");
+ unsigned int count_ = 0;
+
+ // but this here temporarily. Should go into dedicated file later:
+ const char* c8_ascii_ =
+ R"V0G0N(
+ ,ad8888ba, ,ad8888ba, 88888888ba ad88888ba 88 88 a8P db ad88888ba
+ d8"' `"8b d8"' `"8b 88 "8b d8" "8b 88 88 ,88' d88b d8" "8b
+d8' d8' `8b 88 ,8P Y8, 88 88 ,88" d8'`8b Y8a a8P
+88 88 88 88aaaaaa8P' `Y8aaaaa, 88 88,d88' d8' `8b "Y8aaa8P"
+88 88 88 88""""88' `"""""8b, 88 8888"88, d8YaaaaY8b ,d8"""8b,
+Y8, Y8, ,8P 88 `8b `8b 88 88P Y8b d8""""""""8b d8" "8b
+ Y8a. .a8P Y8a. .a8P 88 `8b Y8a a8P 88 88 "88, d8' `8b Y8a a8P
+ `"Y8888Y"' `"Y8888Y"' 88 `8b "Y88888P" 88 88 Y8b d8' `8b "Y88888P"
+ )V0G0N";
};
} // namespace corsika
diff --git a/corsika/framework/core/ParticleProperties.hpp b/corsika/framework/core/ParticleProperties.hpp
index d5620930d..adac5d0e1 100644
--- a/corsika/framework/core/ParticleProperties.hpp
+++ b/corsika/framework/core/ParticleProperties.hpp
@@ -24,8 +24,9 @@
#include <corsika/framework/core/PhysicalUnits.hpp>
/**
+ * \file ParticleProperties.hpp
*
- * The properties of all elementary particles is stored here. The data
+ * The properties of all elementary particles are accessible here. The data
* are taken from the Pythia ParticleData.xml file.
*
*/
@@ -60,19 +61,21 @@ namespace corsika {
int constexpr get_nucleus_Z(Code); //!< returns Z for hard-coded nucleus, otherwise 0
//! returns mass of (A,Z) nucleus, disregarding binding energy
- inline HEPMassType nucleus_mass(int, int);
+ inline HEPMassType get_nucleus_mass(unsigned int const, unsigned int const);
//! convert PDG code to CORSIKA 8 internal code
inline Code convert_from_PDG(PDGCode);
+ std::initializer_list<Code> constexpr get_all_particles();
+
//! the output stream operator for human-readable particle codes
inline std::ostream& operator<<(std::ostream&, corsika::Code);
} // namespace corsika
-// data arrays, etc.
+// data arrays, etc., as generated automatically
#include <corsika/framework/core/GeneratedParticleProperties.inc>
#include <corsika/detail/framework/core/ParticleProperties.inl>
-// constants in namespaces-like static classes
+// constants in namespaces-like static classes, generated automatically
#include <corsika/framework/core/GeneratedParticleClasses.inc>
diff --git a/corsika/framework/geometry/CoordinateSystem.hpp b/corsika/framework/geometry/CoordinateSystem.hpp
index af3d27085..bf4f5ab85 100644
--- a/corsika/framework/geometry/CoordinateSystem.hpp
+++ b/corsika/framework/geometry/CoordinateSystem.hpp
@@ -35,7 +35,7 @@ namespace corsika {
using CoordinateSystemPtr = std::shared_ptr<CoordinateSystem const>;
/// this is the only way to create ONE unique root CS
- static CoordinateSystemPtr get_root_CoordinateSystem();
+ static CoordinateSystemPtr& get_root_CoordinateSystem();
/**
* Creates new CoordinateSystemPtr by translation along \a vector
@@ -135,7 +135,7 @@ namespace corsika {
* \{
**/
- friend CoordinateSystemPtr get_root_CoordinateSystem();
+ friend CoordinateSystemPtr& get_root_CoordinateSystem();
friend CoordinateSystemPtr make_translation(CoordinateSystemPtr const& cs,
QuantityVector<length_d> const& vector);
diff --git a/corsika/framework/geometry/FourVector.hpp b/corsika/framework/geometry/FourVector.hpp
index 860d730b8..99932012d 100644
--- a/corsika/framework/geometry/FourVector.hpp
+++ b/corsika/framework/geometry/FourVector.hpp
@@ -82,7 +82,7 @@ namespace corsika {
*
* @return spaceLike_
*/
- TSpaceVecType& spaceLikeComponents();
+ TSpaceVecType& getSpaceLikeComponents();
/**
*
@@ -105,12 +105,12 @@ namespace corsika {
/**
* \todo FIXME: a better alternative would be to define an enumeration
* enum { SpaceLike =-1, TimeLike, LightLike } V4R_Category;
- * and a method called V4R_Category GetCategory() const;
+ * and a method called V4R_Category GetCategory() const;
* RU: then you have to decide in the constructor which avoids "lazyness"
**/
- ///\return if \f$|p_0|>|\vec{p}|\f$
+ ///\return if \f$|p_0|>|\vec{p}|\f$
bool isTimelike() const;
- ///\return if \f$|p_0|<|\vec{p}|\f$
+ ///\return if \f$|p_0|<|\vec{p}|\f$
bool isSpacelike() const;
/**
diff --git a/corsika/framework/geometry/RootCoordinateSystem.hpp b/corsika/framework/geometry/RootCoordinateSystem.hpp
index cc64e5ff9..7f73cdb29 100644
--- a/corsika/framework/geometry/RootCoordinateSystem.hpp
+++ b/corsika/framework/geometry/RootCoordinateSystem.hpp
@@ -14,6 +14,11 @@ n/*
namespace corsika {
+ /**
+ * To refer to CoordinateSystems, only the CoordinateSystemPtr must be used.
+ */
+ using CoordinateSystemPtr = std::shared_ptr<CoordinateSystem const>;
+
/*!
* Singleton factory function to produce the root CoordinateSystem
*
@@ -22,9 +27,8 @@ namespace corsika {
* RootCoordinateSystem
*/
- static std::shared_ptr<CoordinateSystem const> get_root_CoordinateSystem() {
- static std::shared_ptr<CoordinateSystem const> rootCS(
- new CoordinateSystem); // THIS IS IT
+ static CoordinateSystemPtr& get_root_CoordinateSystem() {
+ static CoordinateSystemPtr rootCS(new CoordinateSystem); // THIS IS IT
return rootCS;
}
diff --git a/corsika/framework/logging/Logging.hpp b/corsika/framework/logging/Logging.hpp
index 5378c8060..ade32ff6b 100644
--- a/corsika/framework/logging/Logging.hpp
+++ b/corsika/framework/logging/Logging.hpp
@@ -35,9 +35,9 @@
// if this is a Debug build, include debug messages in objects
#ifdef DEBUG
// trace is the highest level of logging (ALL messages will be printed)
-#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_TRACE
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#else // otherwise, remove everything but "error" and worse messages
-#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_ERROR
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
#endif
#include <spdlog/fmt/ostr.h> // will output whenerver a streaming operator is found
diff --git a/corsika/framework/process/BoundaryCrossingProcess.hpp b/corsika/framework/process/BoundaryCrossingProcess.hpp
index 960ab25db..97a265445 100644
--- a/corsika/framework/process/BoundaryCrossingProcess.hpp
+++ b/corsika/framework/process/BoundaryCrossingProcess.hpp
@@ -11,18 +11,35 @@ n/*
#include <corsika/framework/process/ProcessReturn.hpp>
#include <corsika/media/Environment.hpp>
+#include <type_traits>
+
namespace corsika {
+ /*
+ struct passepartout {
+ template <typename T>
+ operator T&();
+
+ template <typename T>
+ operator T &&();
+ };*/
+
template <typename TDerived>
class BoundaryCrossingProcess : public BaseProcess<TDerived> {
+
+ /* static_assert(std::is_invocable_v<decltype(&TDerived<>::doBoundaryCrossing), TDerived&,
+ passepartout>,
+ "BoundaryCrossingProcess needs doBoundaryCrossing(TParticle, "
+ "TParticle::node_type, TParticle::node_type)");*/
+
public:
/**
* This method is called when a particle crosses the boundary between the nodes
* \p from and \p to.
*/
- template <typename TParticle, typename TVolumeNode>
- ProcessReturn DoBoundaryCrossing(TParticle&, TVolumeNode const& from,
- TVolumeNode const& to);
+ template <typename TParticle>
+ ProcessReturn doBoundaryCrossing(TParticle&, typename TParticle::node_type const& from,
+ typename TParticle::node_type const& to);
};
} // namespace corsika
diff --git a/corsika/framework/process/ContinuousProcess.hpp b/corsika/framework/process/ContinuousProcess.hpp
index f692884f4..a0a1e1dee 100644
--- a/corsika/framework/process/ContinuousProcess.hpp
+++ b/corsika/framework/process/ContinuousProcess.hpp
@@ -34,7 +34,7 @@ namespace corsika {
// -> enforce TDerived to implement MaxStepLength...
template <typename TParticle, typename TTrack>
- LengthType maxStepLength(TParticle const& p, TTrack const& track) const;
+ LengthType getMaxStepLength(TParticle const& p, TTrack const& track) const;
};
} // namespace corsika
diff --git a/corsika/framework/process/ProcessSequence.hpp b/corsika/framework/process/ProcessSequence.hpp
index 411852b66..057730b95 100644
--- a/corsika/framework/process/ProcessSequence.hpp
+++ b/corsika/framework/process/ProcessSequence.hpp
@@ -90,9 +90,9 @@ namespace corsika {
: A_(in_A)
, B_(in_B) {}
- template <typename TParticle, typename TVTNType>
- ProcessReturn doBoundaryCrossing(TParticle& particle, TVTNType const& from,
- TVTNType const& to);
+ template <typename TParticle>
+ ProcessReturn doBoundaryCrossing(TParticle& particle, typename TParticle::node_type const& from,
+ typename TParticle::node_type const& to);
template <typename TParticle, typename TTrack>
inline ProcessReturn doContinuous(TParticle& particle, TTrack& vT);
@@ -117,7 +117,7 @@ namespace corsika {
inline void doStack(TStack& stack);
template <typename TParticle, typename TTrack>
- inline LengthType maxStepLength(TParticle& particle, TTrack& vTrack);
+ inline LengthType getMaxStepLength(TParticle& particle, TTrack& vTrack);
template <typename TParticle>
inline GrammageType getInteractionLength(TParticle&& particle) {
diff --git a/corsika/framework/stack/CombinedStack.hpp b/corsika/framework/stack/CombinedStack.hpp
index 77d0e11ea..89424775d 100644
--- a/corsika/framework/stack/CombinedStack.hpp
+++ b/corsika/framework/stack/CombinedStack.hpp
@@ -67,23 +67,22 @@ namespace corsika {
*/
template <typename... TArgs1>
- inline void setParticleData(std::tuple<TArgs1...> const vA);
-
+ inline void setParticleData(std::tuple<TArgs1...> const vA);
template <typename... TArgs1, typename... TArgs2>
- inline void setParticleData(std::tuple<TArgs1...> const vA, std::tuple<TArgs2...> const vB);
+ inline void setParticleData(std::tuple<TArgs1...> const vA,
+ std::tuple<TArgs2...> const vB);
template <typename... TArgs1>
- inline void setParticleData(pi_a_type& p, std::tuple<TArgs1...> const vA);
+ inline void setParticleData(pi_a_type& p, std::tuple<TArgs1...> const vA);
template <typename... TArgs1, typename... TArgs2>
- inline void setParticleData(pi_c_type& p, std::tuple<TArgs1...> const vA,
- std::tuple<TArgs2...> const vB);
+ inline void setParticleData(pi_c_type& p, std::tuple<TArgs1...> const vA,
+ std::tuple<TArgs2...> const vB);
///@}
- inline std::string as_string() const;
+ inline std::string asString() const;
- private:
protected:
};
@@ -100,25 +99,24 @@ namespace corsika {
struct CombinedStackImpl : public Stack1Impl, public Stack2Impl {
public:
+ inline void clear();
- inline void clear();
-
- inline unsigned int getSize() const { return Stack1Impl::getSize(); }
- inline unsigned int getCapacity() const { return Stack1Impl::getCapacity(); }
+ inline unsigned int getSize() const { return Stack1Impl::getSize(); }
+ inline unsigned int getCapacity() const { return Stack1Impl::getCapacity(); }
/**
* Function to copy particle at location i1 in stack to i2
*/
- inline void copy(const unsigned int i1, const unsigned int i2);
+ inline void copy(const unsigned int i1, const unsigned int i2);
/**
* Function to copy particle at location i2 in stack to i1
*/
- inline void swap(const unsigned int i1, const unsigned int i2);
+ inline void swap(const unsigned int i1, const unsigned int i2);
- inline void incrementSize();
+ inline void incrementSize();
- inline void decrementSize();
+ inline void decrementSize();
}; // end class CombinedStackImpl
diff --git a/corsika/framework/stack/SecondaryView.hpp b/corsika/framework/stack/SecondaryView.hpp
index 2843cd83f..112f5053d 100644
--- a/corsika/framework/stack/SecondaryView.hpp
+++ b/corsika/framework/stack/SecondaryView.hpp
@@ -321,7 +321,7 @@ namespace corsika {
*/
inline void purge() ;
- inline std::string as_string() const;
+ inline std::string asString() const;
protected:
friend class StackIteratorInterface<
diff --git a/corsika/framework/stack/Stack.hpp b/corsika/framework/stack/Stack.hpp
index d0d3b7f76..e23f543ca 100644
--- a/corsika/framework/stack/Stack.hpp
+++ b/corsika/framework/stack/Stack.hpp
@@ -83,7 +83,14 @@ namespace corsika {
*/
typedef stack_iterator_type particle_type;
- Stack() = default;
+ /**
+ * create a new Stack, if there is already data associated prepare
+ * needed initialization.
+ */
+ Stack()
+ : nDeleted_(0)
+ , data_()
+ , deleted_(std::vector<bool>(data_.getSize(), false)) {}
Stack(Stack&) = delete; ///< since Stack can be very big, we don't want to copy it
@@ -137,37 +144,37 @@ namespace corsika {
*/
inline stack_iterator_type begin();
- inline stack_iterator_type end() ;
+ inline stack_iterator_type end();
- inline stack_iterator_type last();
+ inline stack_iterator_type last();
- inline const_stack_iterator_type begin() const;
+ inline const_stack_iterator_type begin() const;
- inline const_stack_iterator_type end() const ;
+ inline const_stack_iterator_type end() const;
- inline const_stack_iterator_type last() const ;
+ inline const_stack_iterator_type last() const;
- inline const_stack_iterator_type cbegin() const;
+ inline const_stack_iterator_type cbegin() const;
- inline const_stack_iterator_type cend() const;
+ inline const_stack_iterator_type cend() const;
- inline const_stack_iterator_type clast() const;
+ inline const_stack_iterator_type clast() const;
- inline stack_iterator_type at(unsigned int i);
+ inline stack_iterator_type at(unsigned int i);
- inline const_stack_iterator_type at(unsigned int i) const;
+ inline const_stack_iterator_type at(unsigned int i) const;
inline stack_iterator_type first();
- inline const_stack_iterator_type cfirst() const;
+ inline const_stack_iterator_type cfirst() const;
- inline stack_iterator_type getNextParticle();
+ inline stack_iterator_type getNextParticle();
/**
* increase stack size, create new particle at end of stack
*/
template <typename... TArgs>
- inline stack_iterator_type addParticle(const TArgs... v) ;
+ inline stack_iterator_type addParticle(const TArgs... v);
inline void swap(stack_iterator_type a, stack_iterator_type b);
@@ -192,7 +199,7 @@ namespace corsika {
* check if this particle was already deleted
*/
- inline bool isErased(const stack_iterator_type& p) const;
+ inline bool isErased(const stack_iterator_type& p) const;
inline bool isErased(const const_stack_iterator_type& p) const;
@@ -203,7 +210,7 @@ namespace corsika {
* if it was marked as deleted before. If this is not the case,
* the function will just return false and do nothing.
*/
- inline bool purgeLastIfDeleted();
+ inline bool purgeLastIfDeleted();
/**
* Function to ultimatively remove all entries from the stack
* marked as deleted.
@@ -214,13 +221,11 @@ namespace corsika {
*/
inline void purge();
+ inline unsigned int getSize() const;
- inline unsigned int getSize() const;
-
- inline std::string as_string() const;
+ inline std::string asString() const;
protected:
-
/**
* increase stack size, create new particle at end of stack, related to parent
* particle/projectile
@@ -229,21 +234,22 @@ namespace corsika {
* StackIterator::AddSecondary via ParticleBase
*/
template <typename... TArgs>
- inline stack_iterator_type addSecondary(stack_iterator_type& parent, const TArgs... v) ;
+ inline stack_iterator_type addSecondary(stack_iterator_type& parent,
+ const TArgs... v);
- inline void swap(unsigned int const a, unsigned int const b);
+ inline void swap(unsigned int const a, unsigned int const b);
- inline void copy(unsigned int const a, unsigned int const b);
+ inline void copy(unsigned int const a, unsigned int const b);
- inline bool isErased(unsigned int const i) const;
+ inline bool isErased(unsigned int const i) const;
- inline void erase(unsigned int const i) ;
+ inline void erase(unsigned int const i);
/**
* will remove from storage the element i. This is a helper
* function for SecondaryView.
*/
- inline void purge(unsigned int i);
+ inline void purge(unsigned int i);
/**
* Function to perform eventual transformation from
@@ -251,15 +257,15 @@ namespace corsika {
* StackData data_. By default (and in almost all cases) this
* should just be identiy. See class SecondaryView for an alternative implementation.
*/
- inline unsigned int getIndexFromIterator(const unsigned int vI) const;
+ inline unsigned int getIndexFromIterator(const unsigned int vI) const;
/**
* @name Return reference to StackData object data_ for data access
* @{
*/
- inline value_type& getStackData();
+ inline value_type& getStackData();
- inline const value_type& getStackData() const;
+ inline const value_type& getStackData() const;
friend class StackIteratorInterface<value_type, MParticleInterface, Stack>;
friend class ConstStackIteratorInterface<value_type, MParticleInterface, Stack>;
diff --git a/corsika/framework/utility/COMBoost.hpp b/corsika/framework/utility/COMBoost.hpp
index 31644cd9a..7b79af451 100644
--- a/corsika/framework/utility/COMBoost.hpp
+++ b/corsika/framework/utility/COMBoost.hpp
@@ -10,6 +10,7 @@
#include <corsika/framework/geometry/CoordinateSystem.hpp>
#include <corsika/framework/geometry/FourVector.hpp>
+#include <corsika/framework/geometry/PhysicalGeometry.hpp>
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/logging/Logging.hpp>
@@ -26,28 +27,30 @@ namespace corsika {
public:
//! construct a COMBoost given four-vector of projectile and mass of target
- COMBoost(FourVector<HEPEnergyType, Vector<hepmomentum_d>> const& Pprojectile,
+ COMBoost(FourVector<HEPEnergyType, MomentumVector> const& Pprojectile,
HEPEnergyType const massTarget);
//! construct a COMBoost to boost into the rest frame given a 3-momentum and mass
- COMBoost(Vector<hepmomentum_d> const& momentum, HEPEnergyType mass);
+ COMBoost(MomentumVector const& momentum, HEPEnergyType mass);
//! transforms a 4-momentum from lab frame to the center-of-mass frame
template <typename FourVector>
- FourVector toCoM(FourVector const& p) const;
+ inline FourVector toCoM(FourVector const& p) const;
//! transforms a 4-momentum from the center-of-mass frame back to lab frame
template <typename FourVector>
- FourVector fromCoM(FourVector const& p) const;
+ inline FourVector fromCoM(FourVector const& p) const;
- CoordinateSystemPtr getRotatedCS() const;
+ inline CoordinateSystemPtr getRotatedCS() const;
protected:
- void setBoost(double coshEta, double sinhEta);
+ inline void setBoost(double coshEta, double sinhEta);
private:
- Eigen::Matrix2d boost_, inverseBoost_;
- CoordinateSystemPtr originalCS_, rotatedCS_;
+ Eigen::Matrix2d boost_;
+ Eigen::Matrix2d inverseBoost_;
+ CoordinateSystemPtr originalCS_;
+ CoordinateSystemPtr rotatedCS_;
};
} // namespace corsika
diff --git a/corsika/framework/utility/SaveBoostHistogram.hpp b/corsika/framework/utility/SaveBoostHistogram.hpp
index 707900466..8e12ba588 100644
--- a/corsika/framework/utility/SaveBoostHistogram.hpp
+++ b/corsika/framework/utility/SaveBoostHistogram.hpp
@@ -8,11 +8,8 @@
#pragma once
-
-
#include <boost/histogram.hpp>
-
namespace corsika {
enum class SaveMode { overwrite, append };
@@ -29,3 +26,6 @@ namespace corsika {
inline void save_hist(boost::histogram::histogram<Axes, Storage> const& h,
std::string const& filename, SaveMode mode = SaveMode::append);
} // namespace corsika
+
+#include <corsika/detail/framework/utility/SaveBoostHistogram.inl>
+
diff --git a/corsika/media/IMagneticFieldModel.hpp b/corsika/media/IMagneticFieldModel.hpp
index 91741085f..71ef51e34 100644
--- a/corsika/media/IMagneticFieldModel.hpp
+++ b/corsika/media/IMagneticFieldModel.hpp
@@ -10,7 +10,7 @@
#include <corsika/framework/geometry/Point.hpp>
#include <corsika/framework/geometry/Vector.hpp>
-#include <corsika/core/PhysicalUnits.hpp>
+#include <corsika/framework/core/PhysicalUnits.hpp>
namespace corsika {
diff --git a/corsika/media/LayeredSphericalAtmosphereBuilder.hpp b/corsika/media/LayeredSphericalAtmosphereBuilder.hpp
index 60da93956..603b66026 100644
--- a/corsika/media/LayeredSphericalAtmosphereBuilder.hpp
+++ b/corsika/media/LayeredSphericalAtmosphereBuilder.hpp
@@ -15,7 +15,9 @@
#include <corsika/media/NuclearComposition.hpp>
#include <corsika/media/VolumeTreeNode.hpp>
-#include <functional>
+// for detail namespace, NoExtraModelInner, NoExtraModel and traits
+#include <corsika/detail/media/LayeredSphericalAtmosphereBuilder.hpp>
+
#include <memory>
#include <stack>
#include <tuple>
@@ -23,37 +25,82 @@
namespace corsika {
+ /**
+ * \class make_layered_spherical_atmosphere_builder
+ *
+ * Helper class to create LayeredSphericalAtmosphereBuilder, the
+ * extra environment models have to be passed as template-template
+ * argument to make_layered_spherical_atmosphere_builder, the member
+ * function `create` does then take an unspecified number of extra
+ * parameters to internalize those models for all layers later
+ * produced.
+ **/
+ template <typename TMediumInterface = IMediumModel,
+ template <typename> typename MExtraEnvirnoment = detail::NoExtraModel>
+ struct make_layered_spherical_atmosphere_builder;
+
+ /**
+ * Helper class to setup concentric spheres of layered atmosphere
+ * with spcified density profiles (exponential, linear, ...).
+ *
+ * This can be used most importantly to replicate CORSIKA7
+ * atmospheres.
+ *
+ * Each layer by definition has a density profile and a (constant)
+ * nuclear composition model.
+ *
+ */
+
+ template <typename TMediumInterface = IMediumModel,
+ template <typename> typename TMediumModelExtra = detail::NoExtraModel,
+ typename... TModelArgs>
class LayeredSphericalAtmosphereBuilder {
- std::unique_ptr<NuclearComposition> composition_;
- Point center_;
- LengthType previousRadius_{LengthType::zero()};
- LengthType seaLevel_;
-
- std::stack<VolumeTreeNode<IMediumModel>::VTNUPtr> layers_; // innermost layer first
- void checkRadius(LengthType) const;
+ LayeredSphericalAtmosphereBuilder() = delete;
+ LayeredSphericalAtmosphereBuilder(const LayeredSphericalAtmosphereBuilder&) = delete;
+ LayeredSphericalAtmosphereBuilder(const LayeredSphericalAtmosphereBuilder&&) = delete;
+ LayeredSphericalAtmosphereBuilder& operator=(
+ const LayeredSphericalAtmosphereBuilder&) = delete;
- public:
- static auto constexpr earthRadius = 6'371'000 * meter;
+ // friend, to allow construction
+ template <typename, template <typename> typename>
+ friend struct make_layered_spherical_atmosphere_builder;
- LayeredSphericalAtmosphereBuilder(corsika::Point center,
- LengthType seaLevel = earthRadius)
+ protected:
+ LayeredSphericalAtmosphereBuilder(TModelArgs... args, Point const& center,
+ LengthType earthRadius)
: center_(center)
, earthRadius_(earthRadius)
, additionalModelArgs_{args...} {}
- void setNuclearComposition(NuclearComposition);
+ public:
+ void setNuclearComposition(NuclearComposition const& composition);
+ void addExponentialLayer(GrammageType b, LengthType c, LengthType upperBoundary);
+ void addLinearLayer(LengthType c, LengthType upperBoundary);
+
+ int getSize() const { return layers_.size(); }
- void addExponentialLayer(GrammageType, LengthType, LengthType);
+ void assemble(Environment<TMediumInterface>& env);
+ Environment<TMediumInterface> assemble();
- size_t getSize() const { return layers_.size(); }
+ /**
+ * Get the current Earth radius.
+ */
+ LengthType getEarthRadius() const { return earthRadius_; }
- void addLinearLayer(LengthType, LengthType);
+ private:
+ void checkRadius(LengthType r) const;
- void assemble(Environment<IMediumModel>&);
+ std::unique_ptr<NuclearComposition> composition_;
+ Point center_;
+ LengthType previousRadius_{LengthType::zero()};
+ LengthType earthRadius_;
+ std::tuple<TModelArgs...> const additionalModelArgs_;
- Environment<IMediumModel> assemble();
- };
+ std::stack<typename VolumeTreeNode<TMediumInterface>::VTNUPtr>
+ layers_; // innermost layer first
+
+ }; // end class LayeredSphericalAtmosphereBuilder
} // namespace corsika
diff --git a/corsika/media/NuclearComposition.hpp b/corsika/media/NuclearComposition.hpp
index b394b463a..548e7c809 100644
--- a/corsika/media/NuclearComposition.hpp
+++ b/corsika/media/NuclearComposition.hpp
@@ -46,7 +46,7 @@ namespace corsika {
* @retval returns the weighted sum with the type defined by the return type of func
**/
template <typename TFunction>
- inline double getWeightedSum(TFunction const& func) const;
+ inline auto getWeightedSum(TFunction const& func) const;
/** Number of elements in the composition array
* @retval returns the number of elements in the composition array
diff --git a/corsika/media/UniformMagneticField.hpp b/corsika/media/UniformMagneticField.hpp
index e85ae5d36..1a87af4da 100644
--- a/corsika/media/UniformMagneticField.hpp
+++ b/corsika/media/UniformMagneticField.hpp
@@ -24,7 +24,7 @@ namespace corsika {
class UniformMagneticField : public T {
// a type-alias for a magnetic field vector
- using MagneticFieldVector = corsika::Vector<phys::units::magnetic_flux_density_d>;
+ using MagneticFieldVector = Vector<magnetic_flux_density_d>;
public:
/**
@@ -46,10 +46,7 @@ namespace corsika {
* @param point The location to evaluate the field at.
* @returns The magnetic field vector.
*/
- MagneticFieldVector getMagneticField(
- corsika::geometry::Point const&) const final override {
- return B_;
- }
+ MagneticFieldVector getMagneticField(Point const&) const final override { return B_; }
/**
* Set the magnetic field returned by this instance.
@@ -65,5 +62,3 @@ namespace corsika {
}; // END: class MagneticField
} // namespace corsika
-
-#include <corsika/detail/media/UniformMagneticField.inl>
\ No newline at end of file
diff --git a/corsika/modules/ParticleCut.hpp b/corsika/modules/ParticleCut.hpp
index a00bb9714..35bec63fe 100644
--- a/corsika/modules/ParticleCut.hpp
+++ b/corsika/modules/ParticleCut.hpp
@@ -11,40 +11,55 @@
#include <corsika/framework/core/ParticleProperties.hpp>
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/process/SecondariesProcess.hpp>
+#include <corsika/framework/process/ContinuousProcess.hpp>
+
#include <corsika/setup/SetupStack.hpp>
+#include <corsika/setup/SetupTrajectory.hpp>
namespace corsika::particle_cut {
- class ParticleCut : public corsika::SecondariesProcess<ParticleCut> {
-
- HEPEnergyType const fECut;
-
- HEPEnergyType fEnergy = 0 * electronvolt;
- HEPEnergyType fEmEnergy = 0 * electronvolt;
- unsigned int fEmCount = 0;
- HEPEnergyType fInvEnergy = 0 * electronvolt;
- unsigned int fInvCount = 0;
+ class ParticleCut : public SecondariesProcess<ParticleCut>,
+ public ContinuousProcess<ParticleCut> {
public:
- ParticleCut(const HEPEnergyType vCut)
- : fECut(vCut) {}
+ ParticleCut(const HEPEnergyType eCut, bool em, bool inv);
- bool ParticleIsInvisible(corsika::Code) const;
void doSecondaries(corsika::setup::StackView&);
+ ProcessReturn doContinuous(corsika::setup::Stack::particle_type& vParticle,
+ corsika::setup::Trajectory const& vTrajectory);
+ LengthType getMaxStepLength(corsika::setup::Stack::particle_type const&,
+ corsika::setup::Trajectory const&) {
+ return meter * std::numeric_limits<double>::infinity();
+ }
- template <typename TParticle>
- bool ParticleIsBelowEnergyCut(TParticle const&) const;
+ void showResults();
+ void reset();
- bool ParticleIsEmParticle(corsika::Code) const;
+ HEPEnergyType getECut() const { return energy_cut_; }
+ HEPEnergyType getInvEnergy() const { return inv_energy_; }
+ HEPEnergyType getCutEnergy() const { return energy_; }
+ HEPEnergyType getEmEnergy() const { return em_energy_; }
+ unsigned int getNumberEmParticles() const { return em_count_; }
+ unsigned int getNumberInvParticles() const { return inv_count_; }
- void Init();
- void ShowResults();
+ private:
+ template <typename TParticle>
+ bool checkCutParticle(const TParticle& p);
+
+ template <typename TParticle>
+ bool isBelowEnergyCut(TParticle const&) const;
+ bool isEmParticle(Code) const;
+ bool isInvisible(Code) const;
- HEPEnergyType GetInvEnergy() const { return fInvEnergy; }
- HEPEnergyType GetCutEnergy() const { return fEnergy; }
- HEPEnergyType GetEmEnergy() const { return fEmEnergy; }
- unsigned int GetNumberEmParticles() const { return fEmCount; }
- unsigned int GetNumberInvParticles() const { return fInvCount; }
+ private:
+ HEPEnergyType energy_cut_;
+ bool doCutEm_;
+ bool doCutInv_;
+ HEPEnergyType energy_ = 0 * electronvolt;
+ HEPEnergyType em_energy_ = 0 * electronvolt;
+ unsigned int em_count_ = 0;
+ HEPEnergyType inv_energy_ = 0 * electronvolt;
+ unsigned int inv_count_ = 0;
};
} // namespace corsika::particle_cut
diff --git a/corsika/modules/Sibyll.hpp b/corsika/modules/Sibyll.hpp
index 49ba49b76..12b3ff37e 100644
--- a/corsika/modules/Sibyll.hpp
+++ b/corsika/modules/Sibyll.hpp
@@ -8,6 +8,8 @@
#pragma once
+#include <corsika/modules/sibyll/Random.hpp>
+#include <corsika/modules/sibyll/ParticleConversion.hpp>
#include <corsika/modules/sibyll/Interaction.hpp>
#include <corsika/modules/sibyll/Decay.hpp>
#include <corsika/modules/sibyll/NuclearInteraction.hpp>
diff --git a/corsika/modules/StackInspector.hpp b/corsika/modules/StackInspector.hpp
index b20078047..7e6ee9ded 100644
--- a/corsika/modules/StackInspector.hpp
+++ b/corsika/modules/StackInspector.hpp
@@ -18,7 +18,7 @@ namespace corsika::stack_inspector {
template <typename TStack>
class StackInspector : public corsika::StackProcess<StackInspector<TStack>> {
- typedef typename TStack::ParticleType Particle;
+ typedef typename TStack::particle_type Particle;
using corsika::StackProcess<StackInspector<TStack>>::getStep;
@@ -26,18 +26,17 @@ namespace corsika::stack_inspector {
StackInspector(const int vNStep, const bool vReportStack, const HEPEnergyType vE0);
~StackInspector();
- void Init();
void doStack(const TStack&);
/**
* To set a new E0, for example when a new shower event is started
*/
- void SetE0(const HEPEnergyType vE0) { E0_ = vE0; }
+ void setE0(const HEPEnergyType vE0) { E0_ = vE0; }
private:
bool ReportStack_;
HEPEnergyType E0_;
- const HEPEnergyType dE_threshold_ = std::invoke([]() { return 1_eV; });
+ const HEPEnergyType dE_threshold_ = 1_eV;
decltype(std::chrono::system_clock::now()) StartTime_;
};
diff --git a/corsika/modules/SwitchProcess.hpp b/corsika/modules/SwitchProcess.hpp
deleted file mode 100644
index b71c568b7..000000000
--- a/corsika/modules/SwitchProcess.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
- *
- * This software is distributed under the terms of the GNU General Public
- * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
- * the license.
- */
-
-#pragma once
-
-#include <corsika/framework/core/PhysicalUnits.hpp>
-#include <corsika/framework/process/InteractionProcess.hpp>
-#include <corsika/framework/process/ProcessSequence.hpp>
-
-namespace corsika::switch_process {
-
- /**
- * This process provides an energy-based switch between two interaction processes P1 and
- * P1. For energies below the threshold, P1 is invoked, otherwise P2. Both can be either
- * single interaction processes or multiple ones combined in a ProcessSequence. A
- * SwitchProcess itself will always be regarded as a distinct case when assembled into a
- * (greater) ProcessSequence.
- */
-
- template <class TLowEProcess, class THighEProcess>
- class SwitchProcess : public BaseProcess<SwitchProcess<TLowEProcess, THighEProcess>> {
- TLowEProcess& fLowEProcess;
- THighEProcess& fHighEProcess;
- HEPEnergyType const fThresholdEnergy;
-
- public:
- SwitchProcess(TLowEProcess& vLowEProcess, THighEProcess& vHighEProcess,
- HEPEnergyType vThresholdEnergy)
- : fLowEProcess(vLowEProcess)
- , fHighEProcess(vHighEProcess)
- , fThresholdEnergy(vThresholdEnergy) {}
-
- void Init() {
- fLowEProcess.Init();
- fHighEProcess.Init();
- }
-
- template <typename TParticle>
- InverseGrammageType GetInverseInteractionLength(TParticle& p) {
- return 1 / GetInteractionLength(p);
- }
-
- template <typename TParticle>
- GrammageType GetInteractionLength(TParticle& vParticle) {
- if (vParticle.GetEnergy() < fThresholdEnergy) {
- if constexpr (is_process_sequence_v<TLowEProcess>) {
- return fLowEProcess.getInteractionLength(vParticle);
- } else {
- return fLowEProcess.getInteractionLength(vParticle);
- }
- } else {
- if constexpr (is_process_sequence_v<THighEProcess>) {
- return fHighEProcess.getInteractionLength(vParticle);
- } else {
- return fHighEProcess.getInteractionLength(vParticle);
- }
- }
- }
-
- // required to conform to ProcessSequence interface. We cannot just
- // implement DoInteraction() because we want to call SelectInteraction
- // in case a member process is a ProcessSequence.
- template <typename TParticle, typename TSecondaries>
- ProcessReturn SelectInteraction(TParticle& vP, TSecondaries& vS,
- [[maybe_unused]] InverseGrammageType lambda_select,
- InverseGrammageType& lambda_inv_count) {
- if (vP.GetEnergy() < fThresholdEnergy) {
- if constexpr (is_process_sequence_v<TLowEProcess>) {
- return fLowEProcess.SelectInteraction(vP, vS, lambda_select, lambda_inv_count);
- } else {
- lambda_inv_count += fLowEProcess.getInverseInteractionLength(vP);
- // check if we should execute THIS process and then EXIT
- if (lambda_select < lambda_inv_count) {
- fLowEProcess.doInteraction(vS);
- return ProcessReturn::Interacted;
- } else {
- return ProcessReturn::Ok;
- }
- }
- } else {
- if constexpr (is_process_sequence_v<THighEProcess>) {
- return fHighEProcess.SelectInteraction(vP, vS, lambda_select, lambda_inv_count);
- } else {
- lambda_inv_count += fHighEProcess.getInverseInteractionLength(vP);
- // check if we should execute THIS process and then EXIT
- if (lambda_select < lambda_inv_count) {
- fHighEProcess.doInteraction(vS);
- return ProcessReturn::Interacted;
- } else {
- return ProcessReturn::Ok;
- }
- }
- }
- }
- };
-} // namespace corsika::switch_process
diff --git a/corsika/modules/TrackWriter.hpp b/corsika/modules/TrackWriter.hpp
index 7cbabf027..4d4a718c6 100644
--- a/corsika/modules/TrackWriter.hpp
+++ b/corsika/modules/TrackWriter.hpp
@@ -19,23 +19,20 @@ namespace corsika::track_writer {
class TrackWriter : public corsika::ContinuousProcess<TrackWriter> {
public:
- TrackWriter(std::string const& filename)
- : fFilename(filename) {}
+ TrackWriter(std::string const& filename);
- void Init();
+ template <typename TParticle, typename TTrack>
+ ProcessReturn doContinuous(TParticle const&, TTrack const&);
- template <typename Particle, typename Track>
- ProcessReturn doContinuous(const Particle&, const Track&);
-
- template <typename Particle, typename Track>
- LengthType MaxStepLength(const Particle&, const Track&);
+ template <typename TParticle, typename TTrack>
+ LengthType getMaxStepLength(TParticle const&, TTrack const&);
private:
- std::string const fFilename;
- std::ofstream fFile;
+ std::string const filename_;
+ std::ofstream file_;
- int width = 14;
- int precision = 6;
+ int width_ = 14;
+ int precision_ = 6;
};
} // namespace corsika::track_writer
diff --git a/corsika/modules/TrackingLine.hpp b/corsika/modules/TrackingLine.hpp
index e33a94d46..c49c4bbdc 100644
--- a/corsika/modules/TrackingLine.hpp
+++ b/corsika/modules/TrackingLine.hpp
@@ -33,36 +33,36 @@ namespace corsika::tracking_line {
template <typename Particle> // was Stack previously, and argument was
// Stack::StackIterator
- auto GetTrack(Particle const& p) {
+ auto getTrack(Particle const& p) {
Vector<SpeedType::dimension_type> const velocity =
- p.GetMomentum() / p.GetEnergy() * constants::c;
-
- auto const currentPosition = p.GetPosition();
- std::cout << "TrackingLine pid: " << p.GetPID()
- << " , E = " << p.GetEnergy() / 1_GeV << " GeV" << std::endl;
- std::cout << "TrackingLine pos: " << currentPosition.GetCoordinates() << std::endl;
- std::cout << "TrackingLine E: " << p.GetEnergy() / 1_GeV << " GeV" << std::endl;
- std::cout << "TrackingLine p: " << p.GetMomentum().GetComponents() / 1_GeV
+ p.getMomentum() / p.getEnergy() * constants::c;
+
+ auto const currentPosition = p.getPosition();
+ std::cout << "TrackingLine pid: " << p.getPID()
+ << " , E = " << p.getEnergy() / 1_GeV << " GeV" << std::endl;
+ std::cout << "TrackingLine pos: " << currentPosition.getCoordinates() << std::endl;
+ std::cout << "TrackingLine E: " << p.getEnergy() / 1_GeV << " GeV" << std::endl;
+ std::cout << "TrackingLine p: " << p.getMomentum().getComponents() / 1_GeV
<< " GeV " << std::endl;
- std::cout << "TrackingLine v: " << velocity.GetComponents() << std::endl;
+ std::cout << "TrackingLine v: " << velocity.getComponents() << std::endl;
// to do: include effect of magnetic field
Line line(currentPosition, velocity);
- auto const* currentLogicalVolumeNode = p.GetNode();
+ auto const* currentLogicalVolumeNode = p.getNode();
auto const numericallyInside =
- currentLogicalVolumeNode->GetVolume().Contains(currentPosition);
+ currentLogicalVolumeNode->getVolume().isInside(currentPosition);
std::cout << "numericallyInside = " << (numericallyInside ? "true" : "false");
- auto const& children = currentLogicalVolumeNode->GetChildNodes();
- auto const& excluded = currentLogicalVolumeNode->GetExcludedNodes();
+ auto const& children = currentLogicalVolumeNode->getChildNodes();
+ auto const& excluded = currentLogicalVolumeNode->getExcludedNodes();
- std::vector<std::pair<TimeType, decltype(p.GetNode())>> intersections;
+ std::vector<std::pair<TimeType, decltype(p.getNode())>> intersections;
// for entering from outside
auto addIfIntersects = [&](auto const& vtn) {
- auto const& volume = vtn.GetVolume();
+ auto const& volume = vtn.getVolume();
auto const& sphere = dynamic_cast<Sphere const&>(
volume); // for the moment we are a bit bold here and assume
// everything is a sphere, crashes with exception if not
@@ -71,7 +71,7 @@ namespace corsika::tracking_line {
auto const [t1, t2] = *opt;
std::cout << "intersection times: " << t1 / 1_s << "; "
<< t2 / 1_s
- // << " " << vtn.GetModelProperties().GetName()
+ // << " " << vtn.getModelProperties().getName()
<< std::endl;
if (t1.magnitude() > 0)
intersections.emplace_back(t1, &vtn);
@@ -85,12 +85,12 @@ namespace corsika::tracking_line {
{
auto const& sphere =
- dynamic_cast<Sphere const&>(currentLogicalVolumeNode->GetVolume());
+ dynamic_cast<Sphere const&>(currentLogicalVolumeNode->getVolume());
// for the moment we are a bit bold here and assume
// everything is a sphere, crashes with exception if not
[[maybe_unused]] auto const [t1, t2] = *TimeOfIntersection(line, sphere);
[[maybe_unused]] auto dummy_t1 = t1;
- intersections.emplace_back(t2, currentLogicalVolumeNode->GetParent());
+ intersections.emplace_back(t2, currentLogicalVolumeNode->getParent());
}
auto const minIter = std::min_element(
@@ -109,10 +109,10 @@ namespace corsika::tracking_line {
std::cout << " t-intersect: "
<< min
- // << " " << minIter->second->GetModelProperties().GetName()
+ // << " " << minIter->second->getModelProperties().getName()
<< std::endl;
- return std::make_tuple(Trajectory<Line>(line, min), velocity.norm() * min,
+ return std::make_tuple(Trajectory<Line>(line, min), velocity.getNorm() * min,
minIter->second);
}
};
diff --git a/corsika/modules/energy_loss/BetheBlochPDG.hpp b/corsika/modules/energy_loss/BetheBlochPDG.hpp
index e3c2d78dc..124e9e59b 100644
--- a/corsika/modules/energy_loss/BetheBlochPDG.hpp
+++ b/corsika/modules/energy_loss/BetheBlochPDG.hpp
@@ -12,6 +12,7 @@
#include <corsika/framework/geometry/Point.hpp>
#include <corsika/framework/geometry/Vector.hpp>
#include <corsika/framework/process/ContinuousProcess.hpp>
+#include <corsika/media/ShowerAxis.hpp>
#include <corsika/setup/SetupStack.hpp>
#include <corsika/setup/SetupTrajectory.hpp>
@@ -20,44 +21,55 @@
namespace corsika::energy_loss {
+ /**
+ * PDG2018, passage of particles through matter
+ *
+ * Note, that \f$I_{\mathrm{eff}}\f$ of composite media a determined from \f$ \ln I =
+ * \sum_i a_i \ln(I_i) \f$ where \f$ a_i \f$ is the fraction of the electron population
+ * (\f$\sim Z_i\f$) of the \f$i\f$-th element. This can also be used for shell
+ * corrections or density effects.
+ *
+ * The \f$I_{\mathrm{eff}}\f$ of compounds is not better than a few percent, if not
+ * measured explicitly.
+ *
+ * For shell correction, see Sec 6 of https://www.nap.edu/read/20066/chapter/8#115
+ *
+ */
+
class BetheBlochPDG : public corsika::ContinuousProcess<BetheBlochPDG> {
using MeVgcm2 = decltype(1e6 * electronvolt / gram * square(1e-2 * meter));
- void MomentumUpdate(setup::Stack::ParticleType&, HEPEnergyType Enew);
-
public:
- template <typename TDim>
- BetheBlochPDG(Point const& injectionPoint, Vector<TDim> const& direction)
- : InjectionPoint_(injectionPoint)
- , ShowerAxisDirection_(direction.normalized()) {}
+ BetheBlochPDG(ShowerAxis const& showerAxis, HEPEnergyType emCut);
- BetheBlochPDG(setup::Trajectory const& trajectory)
- : BetheBlochPDG(trajectory.GetPosition(0), trajectory.GetV0()){};
+ ProcessReturn doContinuous(setup::Stack::particle_type&, setup::Trajectory const&);
+ LengthType getMaxStepLength(setup::Stack::particle_type const&,
+ setup::Trajectory const&) const;
+ static HEPEnergyType getBetheBloch(setup::Stack::particle_type const&,
+ const GrammageType);
+ static HEPEnergyType getRadiationLosses(setup::Stack::particle_type const&,
+ const GrammageType);
+ static HEPEnergyType getTotalEnergyLoss(setup::Stack::particle_type const&,
+ const GrammageType);
- void Init() {}
- ProcessReturn doContinuous(setup::Stack::ParticleType&, setup::Trajectory const&);
- LengthType MaxStepLength(setup::Stack::ParticleType const&,
- setup::Trajectory const&) const;
- HEPEnergyType GetTotal() const { return BetheBlochPDGTot_; }
- void PrintProfile() const;
- static HEPEnergyType BetheBloch(setup::Stack::ParticleType const&,
- const GrammageType);
- static HEPEnergyType RadiationLosses(setup::Stack::ParticleType const&,
- const GrammageType);
- static HEPEnergyType TotalEnergyLoss(setup::Stack::ParticleType const&,
- const GrammageType);
+ void showResults() const;
+ void reset();
+ HEPEnergyType energyLost() const { return energy_lost_; }
+ void printProfile() const;
+ HEPEnergyType getTotal() const;
+
private:
- void FillProfile(setup::Stack::ParticleType const&, setup::Trajectory const&,
- HEPEnergyType);
+ void updateMomentum(corsika::setup::Stack::particle_type&, HEPEnergyType Enew);
+ void fillProfile(setup::Trajectory const&, HEPEnergyType);
- HEPEnergyType BetheBlochPDGTot_ = HEPEnergyType::zero();
- std::map<int, HEPEnergyType> Profile_; // longitudinal profile
- corsika::Point const InjectionPoint_;
- corsika::Vector<dimensionless_d> const ShowerAxisDirection_;
GrammageType const dX_ = 10_g / square(1_cm); // profile binning
- const GrammageType dX_threshold_ = 0.0001_g / square(1_cm);
+ GrammageType const dX_threshold_ = 0.0001_g / square(1_cm);
+ ShowerAxis const& shower_axis_;
+ corsika::units::si::HEPEnergyType emCut_;
+ units::si::HEPEnergyType energy_lost_ = HEPEnergyType::zero();
+ std::vector<units::si::HEPEnergyType> profile_; // longitudinal profile
};
} // namespace corsika::energy_loss
diff --git a/corsika/modules/qgsjetII/Interaction.hpp b/corsika/modules/qgsjetII/Interaction.hpp
index d9fc32238..004788f13 100644
--- a/corsika/modules/qgsjetII/Interaction.hpp
+++ b/corsika/modules/qgsjetII/Interaction.hpp
@@ -14,6 +14,8 @@
#include <corsika/framework/process/InteractionProcess.hpp>
#include <corsika/modules/qgsjetII/Random.hpp>
+
+#include <corsika/modules/qgsjetII/ParticleConversion.hpp>
#include <qgsjet-II-04.hpp>
#include <string>
@@ -25,37 +27,37 @@ namespace corsika::qgsjetII {
std::string data_path_;
int count_ = 0;
bool initialized_ = false;
+ QgsjetIIHadronType alternate_ =
+ QgsjetIIHadronType::PiPlusType; // for pi0, rho0 projectiles
public:
Interaction(const std::string& dataPath = "");
~Interaction();
- void Init();
-
- bool WasInitialized() { return initialized_; }
- int GetMaxTargetMassNumber() const { return maxMassNumber_; }
- bool IsValidTarget(corsika::Code TargetId) const {
- return corsika::is_nucleus(TargetId) &&
- (corsika::nucleus_A(TargetId) < maxMassNumber_);
+ bool wasInitialized() { return initialized_; }
+ int getMaxTargetMassNumber() const { return maxMassNumber_; }
+ bool isValidTarget(corsika::Code TargetId) const {
+ return is_nucleus(TargetId) && (get_nucleus_A(TargetId) < maxMassNumber_);
}
- CrossSectionType GetCrossSection(const corsika::Code, const corsika::Code,
- const HEPEnergyType, const unsigned int Abeam = 0,
+ CrossSectionType getCrossSection(const Code, const Code, const HEPEnergyType,
+ const unsigned int Abeam = 0,
const unsigned int Atarget = 0) const;
template <typename TParticle>
- GrammageType GetInteractionLength(TParticle const&) const;
+ GrammageType getInteractionLength(TParticle const&) const;
/**
In this function QGSJETII is called to produce one event. The
event is copied (and boosted) into the shower lab frame.
*/
- template <typename TProjectile>
- void doInteraction(TProjectile&);
+ template <typename TSecondaryView>
+ void doInteraction(TSecondaryView&);
private:
- corsika::default_prng_type& fRNG = corsika::RNGManager::getInstance().getRandomStream("qgsjet");
+ corsika::default_prng_type& rng_ =
+ corsika::RNGManager::getInstance().getRandomStream("qgsjet");
const int maxMassNumber_ = 208;
};
diff --git a/corsika/modules/qgsjetII/ParticleConversion.hpp b/corsika/modules/qgsjetII/ParticleConversion.hpp
index 4ff133403..65141b366 100644
--- a/corsika/modules/qgsjetII/ParticleConversion.hpp
+++ b/corsika/modules/qgsjetII/ParticleConversion.hpp
@@ -14,20 +14,58 @@
namespace corsika::qgsjetII {
+ /**
+ These are the possible secondaries produced by QGSJetII
+ */
enum class QgsjetIICode : int8_t;
using QgsjetIICodeIntType = std::underlying_type<QgsjetIICode>::type;
+ /**
+ These are the possible projectile for which QGSJetII knwos cross section
+ */
+ enum class QgsjetIIXSClass : int8_t {
+ CannotInteract = 0,
+ LightMesons = 1,
+ Baryons = 2,
+ Kaons = 3,
+ };
+ using QgsjetIIXSClassIntType = std::underlying_type<QgsjetIIXSClass>::type;
+
+ /**
+ These are the only possible projectile types in QGSJetII
+ */
+ enum class QgsjetIIHadronType : int8_t {
+ UndefinedType = 0,
+ PiPlusType = +1,
+ PiMinusType = -1,
+ ProtonType = +2,
+ AntiProtonType = -2,
+ NeutronType = +3,
+ AntiNeutronType = -3,
+ KaonPlusType = +4,
+ KaonMinusType = -4,
+ Kaon0LType = +5,
+ Kaon0SType = -5,
+ // special codes, not in QGSJetII
+ NucleusType = 100,
+ NeutralLightMesonType = 101,
+ };
+ using QgsjetIIHadronTypeIntType = std::underlying_type<QgsjetIIHadronType>::type;
+}
+
+// include automatically generated code:
#include <corsika/modules/qgsjetII/Generated.inc>
- QgsjetIICode constexpr ConvertToQgsjetII(corsika::Code pCode) {
- return static_cast<QgsjetIICode>(
- corsika2qgsjetII[static_cast<corsika::CodeIntType>(pCode)]);
+namespace corsika::qgsjetII {
+
+ QgsjetIICode constexpr convertToQgsjetII(Code pCode) {
+ return corsika2qgsjetII[static_cast<CodeIntType>(pCode)];
}
- corsika::Code constexpr ConvertFromQgsjetII(QgsjetIICode pCode) {
+ Code constexpr convertFromQgsjetII(QgsjetIICode pCode) {
auto const pCodeInt = static_cast<QgsjetIICodeIntType>(pCode);
auto const corsikaCode = qgsjetII2corsika[pCodeInt - minQgsjetII];
- if (corsikaCode == corsika::Code::Unknown) {
+ if (corsikaCode == Code::Unknown) {
throw std::runtime_error(std::string("QGSJETII/CORSIKA conversion of pCodeInt=")
.append(std::to_string(pCodeInt))
.append(" impossible"));
@@ -35,19 +73,27 @@ namespace corsika::qgsjetII {
return corsikaCode;
}
- int constexpr ConvertToQgsjetIIRaw(corsika::Code pCode) {
- return static_cast<int>(ConvertToQgsjetII(pCode));
+ QgsjetIICodeIntType constexpr convertToQgsjetIIRaw(Code pCode) {
+ return static_cast<QgsjetIICodeIntType>(convertToQgsjetII(pCode));
}
- int constexpr GetQgsjetIIXSCode(corsika::Code pCode) {
- if (pCode == corsika::Code::Nucleus) return 2;
- return corsika2qgsjetIIXStype[static_cast<corsika::CodeIntType>(pCode)];
+ QgsjetIIXSClass constexpr getQgsjetIIXSCode(Code pCode) {
+ // if (pCode == corsika::particles::Code::Nucleus)
+ // static_cast(QgsjetIIXSClassIntType>();
+ return corsika2qgsjetIIXStype[static_cast<CodeIntType>(pCode)];
}
- bool constexpr CanInteract(corsika::Code pCode) {
- return (GetQgsjetIIXSCode(pCode) > 0) && (ConvertToQgsjetIIRaw(pCode) <= 5);
+ QgsjetIIXSClassIntType constexpr getQgsjetIIXSCodeRaw(Code pCode) {
+ return static_cast<QgsjetIIXSClassIntType>(getQgsjetIIXSCode(pCode));
}
-} // namespace corsika::qgsjetII
+ bool constexpr canInteract(Code pCode) {
+ return getQgsjetIIXSCode(pCode) != QgsjetIIXSClass::CannotInteract;
+ }
+
+ QgsjetIIHadronType constexpr getQgsjetIIHadronType(Code pCode) {
+ return corsika2qgsjetIIHadronType[static_cast<CodeIntType>(
+ pCode)];
+ }
-#include <corsika/detail/modules/qgsjetII/ParticleConversion.inl>
+} // namespace corsika::process::qgsjetII
diff --git a/corsika/modules/qgsjetII/QGSJetIIFragmentsStack.hpp b/corsika/modules/qgsjetII/QGSJetIIFragmentsStack.hpp
index 012368cd1..5539ec807 100644
--- a/corsika/modules/qgsjetII/QGSJetIIFragmentsStack.hpp
+++ b/corsika/modules/qgsjetII/QGSJetIIFragmentsStack.hpp
@@ -21,32 +21,31 @@ namespace corsika::qgsjetII {
class QGSJetIIFragmentsStackData {
public:
- void Init();
- void Dump() const {}
+ void dump() const {}
- void Clear() {
+ void clear() {
qgarr13_.nsf = 0;
qgarr55_.nwt = 0;
}
- unsigned int GetSize() const { return qgarr13_.nsf; }
- unsigned int GetCapacity() const { return iapmax; }
+ unsigned int getSize() const { return qgarr13_.nsf; }
+ unsigned int getCapacity() const { return iapmax; }
- static unsigned int GetWoundedNucleonsTarget() { return qgarr55_.nwt; }
- static unsigned int GetWoundedNucleonsProjectile() { return qgarr55_.nwp; }
+ static unsigned int getWoundedNucleonsTarget() { return qgarr55_.nwt; }
+ static unsigned int getWoundedNucleonsProjectile() { return qgarr55_.nwp; }
- int GetFragmentSize(const unsigned int i) const { return qgarr13_.iaf[i]; }
- void SetFragmentSize(const unsigned int i, const int v) { qgarr13_.iaf[i] = v; }
+ int getFragmentSize(const unsigned int i) const { return qgarr13_.iaf[i]; }
+ void setFragmentSize(const unsigned int i, const int v) { qgarr13_.iaf[i] = v; }
- void Copy(const unsigned int i1, const unsigned int i2) {
+ void copy(const unsigned int i1, const unsigned int i2) {
qgarr13_.iaf[i2] = qgarr13_.iaf[i1];
}
- void Swap(const unsigned int i1, const unsigned int i2) {
+ void swap(const unsigned int i1, const unsigned int i2) {
std::swap(qgarr13_.iaf[i1], qgarr13_.iaf[i2]);
}
- void IncrementSize() { qgarr13_.nsf++; }
- void DecrementSize() {
+ void incrementSize() { qgarr13_.nsf++; }
+ void decrementSize() {
if (qgarr13_.nsf > 0) { qgarr13_.nsf--; }
}
};
@@ -54,20 +53,20 @@ namespace corsika::qgsjetII {
template <typename StackIteratorInterface>
class FragmentsInterface : public corsika::ParticleBase<StackIteratorInterface> {
- using corsika::ParticleBase<StackIteratorInterface>::GetStackData;
- using corsika::ParticleBase<StackIteratorInterface>::GetIndex;
+ using corsika::ParticleBase<StackIteratorInterface>::getStackData;
+ using corsika::ParticleBase<StackIteratorInterface>::getIndex;
public:
- void SetParticleData(const int vSize) { SetFragmentSize(vSize); }
+ void setParticleData(const int vSize) { setFragmentSize(vSize); }
- void SetParticleData(FragmentsInterface<StackIteratorInterface>& /*parent*/,
+ void setParticleData(FragmentsInterface<StackIteratorInterface>& /*parent*/,
const int vSize) {
- SetFragmentSize(vSize);
+ setFragmentSize(vSize);
}
- void SetFragmentSize(const int v) { GetStackData().SetFragmentSize(GetIndex(), v); }
+ void setFragmentSize(const int v) { getStackData().setFragmentSize(getIndex(), v); }
- double GetFragmentSize() const { return GetStackData().GetFragmentSize(GetIndex()); }
+ double getFragmentSize() const { return getStackData().getFragmentSize(getIndex()); }
};
typedef corsika::Stack<QGSJetIIFragmentsStackData, FragmentsInterface>
diff --git a/corsika/modules/qgsjetII/QGSJetIIStack.hpp b/corsika/modules/qgsjetII/QGSJetIIStack.hpp
index d47d4a541..bde5bdeac 100644
--- a/corsika/modules/qgsjetII/QGSJetIIStack.hpp
+++ b/corsika/modules/qgsjetII/QGSJetIIStack.hpp
@@ -11,6 +11,7 @@
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/geometry/CoordinateSystem.hpp>
#include <corsika/framework/geometry/Vector.hpp>
+#include <corsika/framework/geometry/PhysicalGeometry.hpp>
#include <corsika/framework/stack/Stack.hpp>
#include <corsika/modules/qgsjetII/ParticleConversion.hpp>
@@ -18,105 +19,56 @@
namespace corsika::qgsjetII {
- typedef corsika::Vector<hepmomentum_d> MomentumVector;
-
class QGSJetIIStackData {
public:
- void Init();
- void Dump() const {}
-
- void Clear() {
- qgarr12_.nsp = 0;
- qgarr13_.nsf = 0;
- qgarr55_.nwt = 0;
- }
- unsigned int GetSize() const { return qgarr12_.nsp; }
- unsigned int GetCapacity() const { return nptmax; }
-
- void SetId(const unsigned int i, const int v) { qgarr14_.ich[i] = v; }
- void SetEnergy(const unsigned int i, const HEPEnergyType v) {
- qgarr14_.esp[i][0] = v / 1_GeV;
- }
-
- void SetMomentum(const unsigned int i, const MomentumVector& v) {
- auto tmp = v.GetComponents();
- qgarr14_.esp[i][2] = tmp[0] / 1_GeV;
- qgarr14_.esp[i][3] = tmp[1] / 1_GeV;
- qgarr14_.esp[i][1] = tmp[2] / 1_GeV;
- }
-
- int GetId(const unsigned int i) const { return qgarr14_.ich[i]; }
- HEPEnergyType GetEnergy(const int i) const { return qgarr14_.esp[i][0] * 1_GeV; }
- MomentumVector GetMomentum(const unsigned int i,
- const corsika::CoordinateSystem& CS) const {
- corsika::QuantityVector<hepmomentum_d> components = {qgarr14_.esp[i][2] * 1_GeV,
- qgarr14_.esp[i][3] * 1_GeV,
- qgarr14_.esp[i][1] * 1_GeV};
- return MomentumVector(CS, components);
- }
-
- void Copy(const unsigned int i1, const unsigned int i2) {
- qgarr14_.ich[i2] = qgarr14_.ich[i1];
- for (unsigned int i = 0; i < 4; ++i) qgarr14_.esp[i2][i] = qgarr14_.esp[i1][i];
- }
-
- void Swap(const unsigned int i1, const unsigned int i2) {
- std::swap(qgarr14_.ich[i1], qgarr14_.ich[i2]);
- for (unsigned int i = 0; i < 4; ++i)
- std::swap(qgarr14_.esp[i1][i], qgarr14_.esp[i2][i]);
- }
-
- void IncrementSize() { qgarr12_.nsp++; }
- void DecrementSize() {
- if (qgarr12_.nsp > 0) { qgarr12_.nsp--; }
- }
+ void dump() const {}
+
+ void clear();
+ unsigned int getSize() const;
+ unsigned int getCapacity() const;
+
+ void setId(const unsigned int i, const int v);
+ void setEnergy(const unsigned int i, const HEPEnergyType v);
+
+ void setMomentum(const unsigned int i, const MomentumVector& v);
+
+ int getId(const unsigned int i) const;
+ HEPEnergyType getEnergy(const int i) const;
+ MomentumVector getMomentum(const unsigned int i, const CoordinateSystemPtr& CS) const;
+
+ void copy(const unsigned int i1, const unsigned int i2);
+ void swap(const unsigned int i1, const unsigned int i2);
+
+ void incrementSize();
+ void decrementSize();
};
template <typename StackIteratorInterface>
class ParticleInterface : public corsika::ParticleBase<StackIteratorInterface> {
- using corsika::ParticleBase<StackIteratorInterface>::GetStackData;
- using corsika::ParticleBase<StackIteratorInterface>::GetIndex;
+ using corsika::ParticleBase<StackIteratorInterface>::getStackData;
+ using corsika::ParticleBase<StackIteratorInterface>::getIndex;
public:
- void SetParticleData(const int vID, const HEPEnergyType vE, const MomentumVector& vP,
- const HEPMassType) {
- SetPID(vID);
- SetEnergy(vE);
- SetMomentum(vP);
- }
-
- void SetParticleData(ParticleInterface<StackIteratorInterface>& /*parent*/,
+ void setParticleData(const int vID, const HEPEnergyType vE, const MomentumVector& vP,
+ const HEPMassType);
+ void setParticleData(ParticleInterface<StackIteratorInterface>& /*parent*/,
const int vID, const HEPEnergyType vE, const MomentumVector& vP,
- const HEPMassType) {
- SetPID(vID);
- SetEnergy(vE);
- SetMomentum(vP);
- }
-
- void SetEnergy(const HEPEnergyType v) { GetStackData().SetEnergy(GetIndex(), v); }
-
- HEPEnergyType GetEnergy() const { return GetStackData().GetEnergy(GetIndex()); }
-
- void SetPID(const int v) { GetStackData().SetId(GetIndex(), v); }
+ const HEPMassType);
- corsika::qgsjetII::QgsjetIICode GetPID() const {
- return static_cast<corsika::qgsjetII::QgsjetIICode>(
- GetStackData().GetId(GetIndex()));
- }
+ void setEnergy(const HEPEnergyType v);
+ HEPEnergyType getEnergy() const;
- MomentumVector GetMomentum(const corsika::CoordinateSystem& CS) const {
- return GetStackData().GetMomentum(GetIndex(), CS);
- }
+ void setPID(const int v);
+ corsika::qgsjetII::QgsjetIICode getPID() const;
- void SetMomentum(const MomentumVector& v) {
- GetStackData().SetMomentum(GetIndex(), v);
- }
+ MomentumVector getMomentum(const CoordinateSystemPtr& CS) const;
+ void setMomentum(const MomentumVector& v);
};
typedef corsika::Stack<QGSJetIIStackData, ParticleInterface> QGSJetIIStack;
} // end namespace corsika::qgsjetII
-//#include <corsika/detail/modules/qgsjetII/QGSJetIIStack.inl>
+#include <corsika/detail/modules/qgsjetII/QGSJetIIStack.inl>
diff --git a/corsika/modules/sibyll/Decay.hpp b/corsika/modules/sibyll/Decay.hpp
index 6d6210e38..3a7555911 100644
--- a/corsika/modules/sibyll/Decay.hpp
+++ b/corsika/modules/sibyll/Decay.hpp
@@ -18,65 +18,64 @@
namespace corsika::sibyll {
- class Decay : public corsika::DecayProcess<Decay> {
- int fCount = 0;
- bool handleAllDecays_ = true;
+ class Decay : public DecayProcess<Decay> {
public:
- Decay();
- Decay(std::set<Code>);
+ Decay(const bool sibyll_listing = false);
+ Decay(std::set<Code> const&);
~Decay();
- void Init();
-
- void SetStable(const std::vector<Code>);
- void SetUnstable(const std::vector<Code>);
-
- void SetStable(const corsika::Code);
- void SetUnstable(const corsika::Code);
-
- // internally set all particles to decay/not to decay
- void SetAllUnstable();
- void SetAllStable();
-
- // will this particle be stable in sibyll ?
- bool IsStable(const corsika::Code);
- // will this particle decay in sibyll ?
- bool IsUnstable(const corsika::Code);
- // set particle with input code to decay or not
- void SetDecay(const Code, const bool);
-
- void PrintDecayConfig(const corsika::Code);
- void PrintDecayConfig();
- void SetHadronsUnstable();
+ void printDecayConfig(const Code);
+ void printDecayConfig();
+ void setHadronsUnstable();
// is Sibyll::Decay set to handle the decay of this particle?
- bool IsDecayHandled(const corsika::Code);
+ bool isDecayHandled(const Code);
// is decay possible in principle?
- bool CanHandleDecay(const corsika::Code);
+ bool canHandleDecay(const Code);
// set Sibyll::Decay to handle the decay of this particle!
- void SetHandleDecay(const corsika::Code);
+ void setHandleDecay(const Code);
// set Sibyll::Decay to handle the decay of this list of particles!
- void SetHandleDecay(const std::vector<Code>);
+ void setHandleDecay(std::vector<Code> const&);
// set Sibyll::Decay to handle all particle decays
- void SetHandleAllDecay();
+ void setHandleAllDecay();
template <typename TParticle>
- TimeType GetLifetime(TParticle const&) const;
+ TimeType getLifetime(TParticle const&);
/**
In this function SIBYLL is called to produce to decay the input particle.
*/
- template <typename TSecondaryParticle>
- void DoDecay(TSecondaryParticle&);
+ template <typename TSecondaryView>
+ void doDecay(TSecondaryView&);
private:
// internal routines to set particles stable and unstable in the COMMON blocks in
// sibyll
+ void setStable(std::vector<Code> const&);
+ void setUnstable(std::vector<Code> const&);
+
+ void setStable(Code const);
+ void setUnstable(Code const);
+ // internally set all particles to decay/not to decay
+ void setAllUnstable();
+ void setAllStable();
+
+ // will this particle be stable in sibyll ?
+ bool isStable(Code const);
+ // will this particle decay in sibyll ?
+ bool isUnstable(Code const);
+ // set particle with input code to decay or not
+ void setDecay(Code const, bool const);
+
+ // data members
+ int count_ = 0;
+ bool handleAllDecays_ = true;
+ bool sibyll_listing_ = false;
std::set<Code> handledDecays_;
};
diff --git a/corsika/modules/sibyll/Interaction.hpp b/corsika/modules/sibyll/Interaction.hpp
index 8abf35794..66d50e039 100644
--- a/corsika/modules/sibyll/Interaction.hpp
+++ b/corsika/modules/sibyll/Interaction.hpp
@@ -18,66 +18,56 @@
namespace corsika::sibyll {
- class Interaction : public corsika::InteractionProcess<Interaction> {
-
- int count_ = 0;
- int nucCount_ = 0;
- bool initialized_ = false;
+ class Interaction : public InteractionProcess<Interaction> {
public:
- Interaction();
+ Interaction(bool const sibyll_printout_on = false);
~Interaction();
- void Init() {}
-
- void SetStable(std::vector<corsika::Code> const&);
- void SetUnstable(std::vector<corsika::Code> const&);
-
- void SetUnstable(const corsika::Code);
- void SetStable(const corsika::Code);
- void SetAllUnstable();
- void SetAllStable();
-
- bool WasInitialized() { return initialized_; }
- bool IsValidCoMEnergy(HEPEnergyType ecm) const {
+ bool isValidCoMEnergy(HEPEnergyType const ecm) const {
return (minEnergyCoM_ <= ecm) && (ecm <= maxEnergyCoM_);
}
- int GetMaxTargetMassNumber() const { return maxTargetMassNumber_; }
- HEPEnergyType GetMinEnergyCoM() const { return minEnergyCoM_; }
- HEPEnergyType GetMaxEnergyCoM() const { return maxEnergyCoM_; }
- bool IsValidTarget(corsika::Code TargetId) const {
- return corsika::is_nucleus(TargetId) && (corsika::get_nucleus_A(TargetId) < maxTargetMassNumber_);
+ bool isValidTarget(Code const TargetId) const {
+ return is_nucleus(TargetId) && (get_nucleus_A(TargetId) < maxTargetMassNumber_);
}
- std::tuple<CrossSectionType, CrossSectionType> GetCrossSection(
- const corsika::Code, const corsika::Code, const HEPEnergyType) const;
+ std::tuple<CrossSectionType, CrossSectionType> getCrossSection(
+ Code const, Code const, HEPEnergyType const) const;
template <typename TParticle>
- GrammageType GetInteractionLength(TParticle const&) const;
+ GrammageType getInteractionLength(TParticle const&) const;
/**
In this function SIBYLL is called to produce one event. The
event is copied (and boosted) into the shower lab frame.
*/
- template <typename TProjectile>
- void doInteraction(TProjectile&);
+ template <typename TSecondaries>
+ void doInteraction(TSecondaries&);
private:
- corsika::default_prng_type& RNG_ = corsika::RNGManager::getInstance().getRandomStream("sibyll");
- // FOR NOW keep trackedParticles private, could be configurable
- std::vector<corsika::Code> const trackedParticles_ = {
- corsika::Code::PiPlus, corsika::Code::PiMinus, corsika::Code::Pi0,
- corsika::Code::KMinus, corsika::Code::KPlus, corsika::Code::K0Long,
- corsika::Code::K0Short, corsika::Code::SigmaPlus, corsika::Code::Sigma0,
- corsika::Code::Sigma0Bar, corsika::Code::SigmaMinus, corsika::Code::Lambda0,
- corsika::Code::Xi0, corsika::Code::XiMinus, corsika::Code::OmegaMinus,
- corsika::Code::DPlus, corsika::Code::DMinus, corsika::Code::D0,
- corsika::Code::MuMinus, corsika::Code::MuPlus, corsika::Code::D0Bar};
+ void setStable(std::vector<Code> const&);
+ void setUnstable(std::vector<Code> const&);
+
+ void setUnstable(Code const);
+ void setStable(Code const);
+ void setAllUnstable();
+ void setAllStable();
+
+ int getMaxTargetMassNumber() const { return maxTargetMassNumber_; }
+ HEPEnergyType getMinEnergyCoM() const { return minEnergyCoM_; }
+ HEPEnergyType getMaxEnergyCoM() const { return maxEnergyCoM_; }
+
+ default_prng_type& RNG_ = RNGManager::getInstance().getRandomStream("sibyll");
const bool internalDecays_ = true;
const HEPEnergyType minEnergyCoM_ = 10. * 1e9 * electronvolt;
const HEPEnergyType maxEnergyCoM_ = 1.e6 * 1e9 * electronvolt;
const int maxTargetMassNumber_ = 18;
+
+ // data members
+ int count_ = 0;
+ int nucCount_ = 0;
+ bool sibyll_listing_;
};
} // namespace corsika::sibyll
diff --git a/corsika/modules/sibyll/NuclearInteraction.hpp b/corsika/modules/sibyll/NuclearInteraction.hpp
index 3386c7935..22a70bcb2 100644
--- a/corsika/modules/sibyll/NuclearInteraction.hpp
+++ b/corsika/modules/sibyll/NuclearInteraction.hpp
@@ -21,51 +21,48 @@ namespace corsika::sibyll {
*
**/
template <class TEnvironment>
- class NuclearInteraction
- : public corsika::InteractionProcess<NuclearInteraction<TEnvironment>> {
-
- int count_ = 0;
- int nucCount_ = 0;
+ class NuclearInteraction : public InteractionProcess<NuclearInteraction<TEnvironment>> {
public:
- NuclearInteraction(corsika::sibyll::Interaction&, TEnvironment const&);
+ NuclearInteraction(sibyll::Interaction&, TEnvironment const&);
~NuclearInteraction();
- void Init();
-
- void InitializeNuclearCrossSections();
- void PrintCrossSectionTable(corsika::Code);
- CrossSectionType ReadCrossSectionTable(const int, corsika::Code, HEPEnergyType);
- HEPEnergyType GetMinEnergyPerNucleonCoM() { return gMinEnergyPerNucleonCoM_; }
- HEPEnergyType GetMaxEnergyPerNucleonCoM() { return gMaxEnergyPerNucleonCoM_; }
- unsigned int constexpr GetMaxNucleusAProjectile() { return gMaxNucleusAProjectile_; }
- unsigned int constexpr GetMaxNFragments() { return gMaxNFragments_; }
- unsigned int constexpr GetNEnergyBins() { return gNEnBins_; }
+ void initializeNuclearCrossSections();
+ void printCrossSectionTable(Code);
+ CrossSectionType readCrossSectionTable(int const, Code const, HEPEnergyType const);
+ HEPEnergyType getMinEnergyPerNucleonCoM() { return gMinEnergyPerNucleonCoM_; }
+ HEPEnergyType getMaxEnergyPerNucleonCoM() { return gMaxEnergyPerNucleonCoM_; }
+ unsigned int constexpr getMaxNucleusAProjectile() { return gMaxNucleusAProjectile_; }
+ unsigned int constexpr getMaxNFragments() { return gMaxNFragments_; }
+ unsigned int constexpr getNEnergyBins() { return gNEnBins_; }
template <typename Particle>
- std::tuple<CrossSectionType, CrossSectionType> GetCrossSection(
- Particle const& p, const corsika::Code TargetId);
+ std::tuple<CrossSectionType, CrossSectionType> getCrossSection(Particle const& p,
+ const Code TargetId);
template <typename Particle>
- GrammageType GetInteractionLength(Particle const&);
+ GrammageType getInteractionLength(Particle const&);
template <typename TSecondaryView>
void doInteraction(TSecondaryView&);
private:
+ int count_ = 0;
+ int nucCount_ = 0;
+
TEnvironment const& environment_;
- corsika::sibyll::Interaction& hadronicInteraction_;
- std::map<corsika::Code, int> targetComponentsIndex_;
- corsika::default_prng_type& RNG_ = corsika::RNGManager::getInstance().getRandomStream("sibyll");
- static constexpr unsigned int gNSample_ =
+ sibyll::Interaction& hadronicInteraction_;
+ std::map<Code, int> targetComponentsIndex_;
+ default_prng_type& RNG_ = RNGManager::getInstance().getRandomStream("sibyll");
+ static unsigned int constexpr gNSample_ =
500; // number of samples in MC estimation of cross section
- static constexpr unsigned int gMaxNucleusAProjectile_ = 56;
- static constexpr unsigned int gNEnBins_ = 6;
- static constexpr unsigned int gMaxNFragments_ = 60;
+ static unsigned int constexpr gMaxNucleusAProjectile_ = 56;
+ static unsigned int constexpr gNEnBins_ = 6;
+ static unsigned int constexpr gMaxNFragments_ = 60;
// energy limits defined by table used for cross section in signuc.f
// 10**1 GeV to 10**6 GeV
- static constexpr HEPEnergyType gMinEnergyPerNucleonCoM_ = 10. * 1e9 * electronvolt;
- static constexpr HEPEnergyType gMaxEnergyPerNucleonCoM_ = 1.e6 * 1e9 * electronvolt;
+ static HEPEnergyType constexpr gMinEnergyPerNucleonCoM_ = 10. * 1e9 * electronvolt;
+ static HEPEnergyType constexpr gMaxEnergyPerNucleonCoM_ = 1.e6 * 1e9 * electronvolt;
};
} // namespace corsika::sibyll
diff --git a/corsika/modules/sibyll/ParticleConversion.hpp b/corsika/modules/sibyll/ParticleConversion.hpp
index 27a1f856d..5351280f9 100644
--- a/corsika/modules/sibyll/ParticleConversion.hpp
+++ b/corsika/modules/sibyll/ParticleConversion.hpp
@@ -33,11 +33,11 @@ namespace corsika::sibyll {
#include <corsika/modules/sibyll/Generated.inc>
- SibyllCode constexpr ConvertToSibyll(corsika::Code pCode) {
+ SibyllCode constexpr convertToSibyll(corsika::Code pCode) {
return corsika2sibyll[static_cast<corsika::CodeIntType>(pCode)];
}
- corsika::Code constexpr ConvertFromSibyll(SibyllCode pCode) {
+ corsika::Code constexpr convertFromSibyll(SibyllCode pCode) {
auto const s = static_cast<SibyllCodeIntType>(pCode);
auto const corsikaCode = sibyll2corsika[s - minSibyll];
if (corsikaCode == corsika::Code::Unknown) {
@@ -48,18 +48,18 @@ namespace corsika::sibyll {
return corsikaCode;
}
- int constexpr ConvertToSibyllRaw(corsika::Code pCode) {
- return static_cast<int>(ConvertToSibyll(pCode));
+ int constexpr convertToSibyllRaw(corsika::Code pCode) {
+ return static_cast<int>(convertToSibyll(pCode));
}
- int constexpr GetSibyllXSCode(corsika::Code pCode) {
+ int constexpr getSibyllXSCode(corsika::Code pCode) {
return static_cast<SibyllXSClassIntType>(
corsika2sibyllXStype[static_cast<corsika::CodeIntType>(pCode)]);
}
- bool constexpr CanInteract(corsika::Code pCode) { return GetSibyllXSCode(pCode) > 0; }
+ bool constexpr canInteract(corsika::Code pCode) { return getSibyllXSCode(pCode) > 0; }
- HEPMassType GetSibyllMass(corsika::Code const);
+ HEPMassType getSibyllMass(corsika::Code const);
} // namespace corsika::sibyll
diff --git a/corsika/modules/sibyll/SibStack.hpp b/corsika/modules/sibyll/SibStack.hpp
index 4cb10cb08..68e2d63d5 100644
--- a/corsika/modules/sibyll/SibStack.hpp
+++ b/corsika/modules/sibyll/SibStack.hpp
@@ -45,13 +45,13 @@ namespace corsika::sibyll {
HEPEnergyType getEnergy(const int i) const { return s_plist_.p[3][i] * 1_GeV; }
HEPEnergyType getMass(const unsigned int i) const { return s_plist_.p[4][i] * 1_GeV; }
MomentumVector getMomentum(const unsigned int i) const {
- CoordinateSystemPtr& rootCS = get_root_CoordinateSystem();
+ CoordinateSystemPtr const& rootCS = get_root_CoordinateSystem();
QuantityVector<hepmomentum_d> components = {
s_plist_.p[0][i] * 1_GeV, s_plist_.p[1][i] * 1_GeV, s_plist_.p[2][i] * 1_GeV};
return MomentumVector(rootCS, components);
}
- void Copy(const unsigned int i1, const unsigned int i2) {
+ void copy(const unsigned int i1, const unsigned int i2) {
s_plist_.llist[i2] = s_plist_.llist[i1];
for (unsigned int i = 0; i < 5; ++i) s_plist_.p[i][i2] = s_plist_.p[i][i1];
}
diff --git a/corsika/setup/SetupEnvironment.hpp b/corsika/setup/SetupEnvironment.hpp
index 3d88b8c18..fade01a63 100644
--- a/corsika/setup/SetupEnvironment.hpp
+++ b/corsika/setup/SetupEnvironment.hpp
@@ -27,27 +27,3 @@ namespace corsika::setup {
} // end namespace corsika::setup
-#include <corsika/media/HomogeneousMedium.hpp>
-#include <corsika/media/InhomogeneousMedium.hpp>
-#include <corsika/media/MediumPropertyModel.hpp>
-#include <corsika/media/UniformMagneticField.hpp>
-
-#include <tuple>
-#include <unique_ptr>
-
-/**
- * \function setup_environment
- *
- * standard environment for unit testing.
- *
- * \todo This can be moved to "test" directory, when available.
- */
-namespace corsika::setup::testing {
-
- inline std::tuple<std::unique_ptr<setup::Environment>, CoordinateSystem const*,
- setup::Environment::BaseNodeType const*>
- setup_environment(Code vTargetCode);
-
-} // namespace corsika::setup::testing
-
-#include <corsika/detail/setup/SetupEnvironment.inl>
diff --git a/corsika/setup/SetupStack.hpp b/corsika/setup/SetupStack.hpp
index 580e47fe2..ee1c85df4 100644
--- a/corsika/setup/SetupStack.hpp
+++ b/corsika/setup/SetupStack.hpp
@@ -9,7 +9,7 @@
#include <corsika/detail/setup/SetupStack.hpp>
#include <array>
-#include <unique_ptr>
+#include <memory>
namespace corsika::setup {
@@ -32,7 +32,7 @@ namespace corsika::setup {
*/
using Stack = detail::StackWithGeometry;
template <typename T1, template <typename> typename M2>
- using StackViewProducer = corsika::stack::DefaultSecondaryProducer<T1, M2>;
+ using StackViewProducer = corsika::DefaultSecondaryProducer<T1, M2>;
#endif
@@ -54,7 +54,7 @@ namespace corsika::setup {
#ifdef WITH_HISTORY
#if defined(__clang__)
- using StackView = SecondaryView<typename Stack::StackImpl,
+ using StackView = SecondaryView<typename Stack::stack_implementation_type,
// CHECK with CLANG: setup::Stack::MPIType>;
detail::StackWithHistoryInterface, StackViewProducer>;
#elif defined(__GNUC__) || defined(__GNUG__)
@@ -64,12 +64,12 @@ namespace corsika::setup {
#else // WITH_HISTORY
#if defined(__clang__)
- using StackView = SecondaryView<typename setup::Stack::StackImpl,
+ using StackView = SecondaryView<typename setup::Stack::stack_implementation_type,
// CHECK with CLANG:
// setup::Stack::MPIType>;
setup::detail::StackWithGeometryInterface>;
#elif defined(__GNUC__) || defined(__GNUG__)
- using StackView = make_view<setup::Stack>::type;
+ using StackView = corsika::MakeView<setup::Stack>::type;
#endif
} // namespace detail
@@ -84,18 +84,3 @@ namespace corsika::setup {
} // namespace corsika::setup
-/**
- * standard stack setup for unit tests. This can be moved to "test"
- * directory, when available.
- */
-
-namespace corsika::setup::testing {
-
- inline std::tuple<std::unique_ptr<setup::Stack>, std::unique_ptr<setup::StackView>>
- setup_stack(Code vProjectileType, int vA, int vZ, HEPEnergyType vMomentum,
- const setup::Environment::BaseNodeType* vNodePtr,
- CoordinateSystem const& cs);
-
-} // namespace corsika::setup::testing
-
-#include <corsika/detail/setup/SetupStack.inl>
diff --git a/corsika/stack/DummyStack.hpp b/corsika/stack/DummyStack.hpp
index 3077bfaae..0e1cc5161 100644
--- a/corsika/stack/DummyStack.hpp
+++ b/corsika/stack/DummyStack.hpp
@@ -39,7 +39,7 @@ namespace corsika::dummy_stack {
void setParticleData(const std::tuple<NoData>& /*v*/) {}
void setParticleData(super_type& /*parent*/, const std::tuple<NoData>& /*v*/) {}
- std::string as_string() const { return "dummy-data"; }
+ std::string asString() const { return "dummy-data"; }
};
/**
diff --git a/corsika/stack/GeometryNodeStackExtension.hpp b/corsika/stack/GeometryNodeStackExtension.hpp
index eed559c53..6c46fa14b 100644
--- a/corsika/stack/GeometryNodeStackExtension.hpp
+++ b/corsika/stack/GeometryNodeStackExtension.hpp
@@ -51,7 +51,7 @@ namespace corsika::node {
setNode(parent.getNode()); // copy Node from parent particle!
}
- inline std::string as_string() const {
+ inline std::string asString() const {
return fmt::format("node={}", fmt::ptr(getNode()));
}
diff --git a/corsika/stack/NuclearStackExtension.hpp b/corsika/stack/NuclearStackExtension.hpp
index e594d414d..e429aa89c 100644
--- a/corsika/stack/NuclearStackExtension.hpp
+++ b/corsika/stack/NuclearStackExtension.hpp
@@ -13,6 +13,7 @@
#include <corsika/framework/stack/Stack.hpp>
#include <corsika/framework/geometry/Point.hpp>
#include <corsika/framework/geometry/Vector.hpp>
+#include <corsika/framework/geometry/PhysicalGeometry.hpp>
#include <corsika/stack/SuperStupidStack.hpp>
#include <algorithm>
@@ -46,10 +47,10 @@ namespace corsika::nuclear_stack {
typedef InnerParticleInterface<StackIteratorInterface> super_type;
public:
- typedef std::tuple<Code, HEPEnergyType, simple_stack::MomentumVector, Point, TimeType>
+ typedef std::tuple<Code, HEPEnergyType, MomentumVector, Point, TimeType>
particle_data_type;
- typedef std::tuple<Code, HEPEnergyType, simple_stack::MomentumVector, Point, TimeType,
+ typedef std::tuple<Code, HEPEnergyType, MomentumVector, Point, TimeType,
unsigned short, unsigned short>
altenative_particle_data_type;
@@ -61,7 +62,7 @@ namespace corsika::nuclear_stack {
inline void setParticleData(super_type& p, altenative_particle_data_type const& v);
- inline std::string as_string() const;
+ inline std::string asString() const;
/**
* @name individual setters
diff --git a/corsika/stack/SuperStupidStack.hpp b/corsika/stack/SuperStupidStack.hpp
index 605415fb1..df07a8924 100644
--- a/corsika/stack/SuperStupidStack.hpp
+++ b/corsika/stack/SuperStupidStack.hpp
@@ -13,18 +13,16 @@
#include <corsika/framework/stack/Stack.hpp>
#include <corsika/framework/geometry/Point.hpp>
-#include <corsika/framework/geometry/RootCoordinateSystem.hpp> // remove
+//#include <corsika/framework/geometry/RootCoordinateSystem.hpp> // remove
#include <corsika/framework/geometry/Vector.hpp>
+#include <corsika/framework/geometry/PhysicalGeometry.hpp>
#include <string>
#include <tuple>
#include <vector>
namespace corsika::simple_stack {
-
- typedef corsika::Vector<hepmomentum_d>
- MomentumVector; //! \todo this has to move to PhysicalUnits.hpp
-
+
/**
* Example of a particle object on the stack.
*/
@@ -36,7 +34,7 @@ namespace corsika::simple_stack {
typedef corsika::ParticleBase<StackIteratorInterface> super_type;
public:
- std::string as_string() const {
+ std::string asString() const {
using namespace corsika::units::si;
return fmt::format("particle: i={}, PID={}, E={}GeV", super_type::getIndex(),
corsika::get_name(this->getPID()), this->getEnergy() / 1_GeV);
@@ -122,7 +120,6 @@ namespace corsika::simple_stack {
SuperStupidStackImpl& operator=(SuperStupidStackImpl&& other) = default;
- void init() {}
void dump() const {}
inline void clear() ;
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 6b47de1c8..d0ddae703 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -38,3 +38,7 @@ CORSIKA_REGISTER_EXAMPLE (stopping_power)
add_executable (staticsequence_example staticsequence_example.cpp)
target_link_libraries (staticsequence_example CORSIKA8)
CORSIKA_REGISTER_EXAMPLE (staticsequence_example)
+
+add_executable (particle_list_example particle_list_example.cpp)
+target_link_libraries (particle_list_example CORSIKA8)
+CORSIKA_REGISTER_EXAMPLE (particle_list_example)
diff --git a/examples/boundary_example.cpp b/examples/boundary_example.cpp
index a7c595c04..573a0c6fd 100644
--- a/examples/boundary_example.cpp
+++ b/examples/boundary_example.cpp
@@ -1,5 +1,5 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
@@ -7,11 +7,12 @@
*/
#include <corsika/framework/core/Cascade.hpp>
-#include <corsika/framework/core/PhysicalUnits.hpp>
-#include <corsika/framework/geometry/Sphere.hpp>
#include <corsika/framework/process/ProcessSequence.hpp>
+#include <corsika/framework/geometry/Sphere.hpp>
+#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/random/RNGManager.hpp>
#include <corsika/framework/utility/CorsikaFenv.hpp>
+#include <corsika/framework/logging/Logging.hpp>
#include <corsika/setup/SetupEnvironment.hpp>
#include <corsika/setup/SetupStack.hpp>
@@ -20,82 +21,89 @@
#include <corsika/media/Environment.hpp>
#include <corsika/media/HomogeneousMedium.hpp>
#include <corsika/media/NuclearComposition.hpp>
+#include <corsika/media/UniformMagneticField.hpp>
+#include <corsika/media/MediumPropertyModel.hpp>
-#include <corsika/modules/ParticleCut.hpp>
+#include <corsika/modules/TrackingLine.hpp>
#include <corsika/modules/Sibyll.hpp>
#include <corsika/modules/TrackWriter.hpp>
-#include <corsika/modules/TrackingLine.hpp>
+#include <corsika/modules/ParticleCut.hpp>
#include <iostream>
#include <limits>
#include <typeinfo>
using namespace corsika;
-using namespace corsika::units::si;
using namespace std;
template <bool deleteParticle>
struct MyBoundaryCrossingProcess
: public BoundaryCrossingProcess<MyBoundaryCrossingProcess<deleteParticle>> {
- MyBoundaryCrossingProcess(std::string const& filename) { fFile.open(filename); }
+ MyBoundaryCrossingProcess(std::string const& filename) { file_.open(filename); }
template <typename Particle>
- EProcessReturn DoBoundaryCrossing(Particle& p,
- typename Particle::BaseNodeType const& from,
- typename Particle::BaseNodeType const& to) {
- std::cout << "boundary crossing! from: " << &from << "; to: " << &to << std::endl;
+ ProcessReturn doBoundaryCrossing(Particle& p, typename Particle::node_type const& from,
+ typename Particle::node_type const& to) {
- auto const& name = corsika::name(p.GetPID());
- auto const start = p.GetPosition().GetCoordinates();
+ CORSIKA_LOG_INFO("MyBoundaryCrossingProcess: crossing! from: {} to: {} ", fmt::ptr(&from),
+ fmt::ptr(&to));
- fFile << name << " " << start[0] / 1_m << ' ' << start[1] / 1_m << ' '
+ auto const& name = get_name(p.getPID());
+ auto const start = p.getPosition().getCoordinates();
+
+ file_ << name << " " << start[0] / 1_m << ' ' << start[1] / 1_m << ' '
<< start[2] / 1_m << '\n';
- if constexpr (deleteParticle) { p.Delete(); }
+ if constexpr (deleteParticle) { p.erase(); }
- return EProcessReturn::eOk;
+ return ProcessReturn::Ok;
}
- void Init() {}
-
private:
- std::ofstream fFile;
+ std::ofstream file_;
};
//
// The example main program for a particle cascade
//
int main() {
+
+ //logging::SetLevel(logging::level::info);
+
+ CORSIKA_LOG_INFO("boundary_example");
+
feenableexcept(FE_INVALID);
// initialize random number sequence(s)
- corsika::RNGManager::getInstance().registerRandomStream("cascade");
+ RNGManager::getInstance().registerRandomStream("cascade");
// setup environment, geometry
- using EnvType = Environment<setup::IEnvironmentModel>;
+ using EnvType = setup::Environment;
EnvType env;
- auto& universe = *(env.GetUniverse());
+ auto& universe = *(env.getUniverse());
- const CoordinateSystem& rootCS = env.GetCoordinateSystem();
+ CoordinateSystemPtr const& rootCS = env.getCoordinateSystem();
- auto outerMedium = EnvType::CreateNode<Sphere>(
+ // create "world" as infinite sphere filled with protons
+ auto world = EnvType::createNode<Sphere>(
Point{rootCS, 0_m, 0_m, 0_m}, 1_km * std::numeric_limits<double>::infinity());
- auto const props =
- outerMedium
- ->SetModelProperties<corsika::HomogeneousMedium<setup::IEnvironmentModel>>(
- 1_kg / (1_m * 1_m * 1_m),
- corsika::NuclearComposition(
- std::vector<corsika::Code>{corsika::Code::Proton},
- std::vector<float>{1.f}));
-
- auto innerMedium = EnvType::CreateNode<Sphere>(Point{rootCS, 0_m, 0_m, 0_m}, 5_km);
+ using MyHomogeneousModel =
+ MediumPropertyModel<UniformMagneticField<
+ HomogeneousMedium<setup::EnvironmentInterface>>>;
- innerMedium->SetModelProperties(props);
+ auto const props = world->setModelProperties<MyHomogeneousModel>(
+ Medium::AirDry1Atm, Vector(rootCS, 0_T, 0_T, 0_T),
+ 1_kg / (1_m * 1_m * 1_m),
+ NuclearComposition(std::vector<Code>{Code::Proton},
+ std::vector<float>{1.f}));
- outerMedium->AddChild(std::move(innerMedium));
+ // add a "target" sphere with 5km readius at 0,0,0
+ auto target = EnvType::createNode<Sphere>(Point{rootCS, 0_m, 0_m, 0_m}, 5_km);
+ target->setModelProperties(props);
- universe.AddChild(std::move(outerMedium));
+ world->addChild(std::move(target));
+ universe.addChild(std::move(world));
// setup processes, decays and interactions
tracking_line::TrackingLine tracking;
@@ -104,28 +112,28 @@ int main() {
corsika::sibyll::Interaction sibyll;
corsika::sibyll::Decay decay;
- corsika::particle_cut::ParticleCut cut(20_GeV);
+ particle_cut::ParticleCut cut(50_GeV, true, true);
- corsika::track_writer::TrackWriter trackWriter("tracks.dat");
+ track_writer::TrackWriter trackWriter("boundary_tracks.dat");
MyBoundaryCrossingProcess<true> boundaryCrossing("crossings.dat");
// assemble all processes into an ordered process list
- auto sequence = sibyll << decay << cut << boundaryCrossing << trackWriter;
+ auto sequence = make_sequence(sibyll, decay, cut, boundaryCrossing, trackWriter);
// setup particle stack, and add primary particles
setup::Stack stack;
- stack.Clear();
- const Code beamCode = Code::Proton;
- const HEPMassType mass = corsika::mass(Code::Proton);
- const HEPEnergyType E0 = 50_TeV;
+ stack.clear();
+ const Code beamCode = Code::MuPlus;
+ const HEPMassType mass = get_mass(beamCode);
+ const HEPEnergyType E0 = 100_GeV;
std::uniform_real_distribution distTheta(0., 180.);
std::uniform_real_distribution distPhi(0., 360.);
std::mt19937 rng;
for (int i = 0; i < 100; ++i) {
- auto const theta = distTheta(rng);
- auto const phi = distPhi(rng);
+ double const theta = distTheta(rng);
+ double const phi = distPhi(rng);
auto elab2plab = [](HEPEnergyType Elab, HEPMassType m) {
return sqrt((Elab - m) * (Elab + m));
@@ -137,25 +145,26 @@ int main() {
};
auto const [px, py, pz] =
momentumComponents(theta / 180. * M_PI, phi / 180. * M_PI, P0);
- auto plab = corsika::MomentumVector(rootCS, {px, py, pz});
- cout << "input particle: " << beamCode << endl;
- cout << "input angles: theta=" << theta << " phi=" << phi << endl;
- cout << "input momentum: " << plab.GetComponents() / 1_GeV << endl;
+ auto plab = MomentumVector(rootCS, {px, py, pz});
+ CORSIKA_LOG_INFO(
+ "input particle: {} "
+ "input angles: theta={} phi={}"
+ "input momentum: {} GeV",
+ beamCode, theta, phi, plab.getComponents() / 1_GeV);
+ // shoot particles from inside target out
Point pos(rootCS, 0_m, 0_m, 0_m);
- stack.AddParticle(
- std::tuple<corsika::Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{beamCode, E0, plab, pos, 0_ns});
+ stack.addParticle(std::make_tuple(beamCode, E0, plab, pos, 0_ns));
}
// define air shower object, run simulation
- corsika::Cascade EAS(env, tracking, sequence, stack);
- EAS.Init();
- EAS.Run();
-
- cout << "Result: E0=" << E0 / 1_GeV << endl;
- cut.ShowResults();
- const HEPEnergyType Efinal =
- cut.GetCutEnergy() + cut.GetInvEnergy() + cut.GetEmEnergy();
- cout << "total energy (GeV): " << Efinal / 1_GeV << endl
- << "relative difference (%): " << (Efinal / E0 - 1.) * 100 << endl;
+ Cascade EAS(env, tracking, sequence, stack);
+
+ EAS.run();
+
+ CORSIKA_LOG_INFO("Result: E0={}GeV", E0 / 1_GeV);
+ cut.showResults();
+ [[maybe_unused]] const HEPEnergyType Efinal =
+ (cut.getCutEnergy() + cut.getInvEnergy() + cut.getEmEnergy());
+ CORSIKA_LOG_INFO("Total energy (GeV): {} relative difference (%): {}", Efinal / 1_GeV,
+ (Efinal / E0 - 1.) * 100);
}
diff --git a/examples/cascade_example.cpp b/examples/cascade_example.cpp
index e0c04357e..f3cd9c19a 100644
--- a/examples/cascade_example.cpp
+++ b/examples/cascade_example.cpp
@@ -1,79 +1,100 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
-#include <corsika/framework/core/Cascade.hpp>
-#include <corsika/framework/core/PhysicalUnits.hpp>
-#include <corsika/framework/geometry/Sphere.hpp>
-#include <corsika/framework/random/RNGManager.hpp>
-#include <corsika/framework/process/ProcessSequence.hpp>
-#include <corsika/framework/utility/CorsikaFenv.hpp>
+#include <corsika/cascade/Cascade.h>
+#include <corsika/process/ProcessSequence.h>
+#include <corsika/process/energy_loss/EnergyLoss.h>
+#include <corsika/process/stack_inspector/StackInspector.h>
+#include <corsika/process/tracking_line/TrackingLine.h>
-#include <corsika/modules/BetheBlochPDG.hpp>
-#include <corsika/modules/ParticleCut.hpp>
-#include <corsika/modules/Sibyll.hpp>
-#include <corsika/modules/StackInspector.hpp>
-#include <corsika/modules/TrackWriter.hpp>
-#include <corsika/modules/TrackingLine.hpp>
+#include <corsika/setup/SetupEnvironment.h>
+#include <corsika/setup/SetupStack.h>
+#include <corsika/setup/SetupTrajectory.h>
-#include <corsika/setup/SetupEnvironment.hpp>
-#include <corsika/setup/SetupStack.hpp>
-#include <corsika/setup/SetupTrajectory.hpp>
+#include <corsika/environment/Environment.h>
+#include <corsika/environment/HomogeneousMedium.h>
+#include <corsika/environment/NuclearComposition.h>
+#include <corsika/environment/ShowerAxis.h>
-#include <corsika/media/Environment.hpp>
-#include <corsika/media/HomogeneousMedium.hpp>
-#include <corsika/media/NuclearComposition.hpp>
+#include <corsika/geometry/Sphere.h>
+
+#include <corsika/process/sibyll/Decay.h>
+#include <corsika/process/sibyll/Interaction.h>
+#include <corsika/process/sibyll/NuclearInteraction.h>
+
+#include <corsika/process/particle_cut/ParticleCut.h>
+#include <corsika/process/track_writer/TrackWriter.h>
+
+#include <corsika/units/PhysicalUnits.h>
+
+#include <corsika/random/RNGManager.h>
+
+#include <corsika/utl/CorsikaFenv.h>
+#include <corsika/logging/Logging.h>
#include <iostream>
#include <limits>
using namespace corsika;
-using namespace corsika::setup;
+using namespace corsika::process;
+using namespace corsika::units;
+using namespace corsika::particles;
+using namespace corsika::random;
+using namespace corsika::geometry;
+using namespace corsika::environment;
+
using namespace std;
+using namespace corsika::units::si;
//
// The example main program for a particle cascade
//
int main() {
+ logging::SetLevel(logging::level::info);
+
+ std::cout << "cascade_example" << std::endl;
+
const LengthType height_atmosphere = 112.8_km;
feenableexcept(FE_INVALID);
// initialize random number sequence(s)
- corsika::RNGManager::getInstance().registerRandomStream("cascade");
+ random::RNGManager::GetInstance().RegisterRandomStream("cascade");
// setup environment, geometry
- using EnvType = corsika::Environment<setup::IEnvironmentModel>;
- EnvType env;
+ setup::Environment env;
auto& universe = *(env.GetUniverse());
const CoordinateSystem& rootCS = env.GetCoordinateSystem();
- auto outerMedium = EnvType::CreateNode<Sphere>(
+ auto world = setup::Environment::CreateNode<Sphere>(
Point{rootCS, 0_m, 0_m, 0_m}, 1_km * std::numeric_limits<double>::infinity());
+ using MyHomogeneousModel =
+ environment::MediumPropertyModel<environment::UniformMagneticField<
+ environment::HomogeneousMedium<setup::EnvironmentInterface>>>;
+
// fraction of oxygen
const float fox = 0.20946;
- auto const props =
- outerMedium
- ->SetModelProperties<corsika::HomogeneousMedium<setup::IEnvironmentModel>>(
- 1_kg / (1_m * 1_m * 1_m),
- corsika::NuclearComposition(
- std::vector<corsika::Code>{corsika::Code::Nitrogen,
- corsika::Code::Oxygen},
- std::vector<float>{1.f - fox, fox}));
+ auto const props = world->SetModelProperties<MyHomogeneousModel>(
+ environment::Medium::AirDry1Atm, Vector(rootCS, 0_T, 0_T, 0_T),
+ 1_kg / (1_m * 1_m * 1_m),
+ environment::NuclearComposition(
+ std::vector<particles::Code>{particles::Code::Nitrogen,
+ particles::Code::Oxygen},
+ std::vector<float>{1.f - fox, fox}));
- auto innerMedium = EnvType::CreateNode<Sphere>(Point{rootCS, 0_m, 0_m, 0_m}, 5000_m);
+ auto innerMedium =
+ setup::Environment::CreateNode<Sphere>(Point{rootCS, 0_m, 0_m, 0_m}, 5000_m);
innerMedium->SetModelProperties(props);
-
- outerMedium->AddChild(std::move(innerMedium));
-
- universe.AddChild(std::move(outerMedium));
+ world->AddChild(std::move(innerMedium));
+ universe.AddChild(std::move(world));
// setup particle stack, and add primary particle
setup::Stack stack;
@@ -81,7 +102,7 @@ int main() {
const Code beamCode = Code::Nucleus;
const int nuclA = 4;
const int nuclZ = int(nuclA / 2.15 + 0.7);
- const HEPMassType mass = nucleus_mass(nuclA, nuclZ);
+ const HEPMassType mass = GetNucleusMass(nuclA, nuclZ);
const HEPEnergyType E0 = nuclA * 1_TeV;
double theta = 0.;
double phi = 0.;
@@ -90,6 +111,8 @@ int main() {
rootCS, 0_m, 0_m,
height_atmosphere); // this is the CORSIKA 7 start of atmosphere/universe
+ ShowerAxis const showerAxis{injectionPos, Vector{rootCS, 0_m, 0_m, -5000_km}, env};
+
{
auto elab2plab = [](HEPEnergyType Elab, HEPMassType m) {
return sqrt((Elab - m) * (Elab + m));
@@ -101,39 +124,38 @@ int main() {
};
auto const [px, py, pz] =
momentumComponents(theta / 180. * M_PI, phi / 180. * M_PI, P0);
- auto plab = corsika::MomentumVector(rootCS, {px, py, pz});
+ auto plab = corsika::stack::MomentumVector(rootCS, {px, py, pz});
cout << "input particle: " << beamCode << endl;
cout << "input angles: theta=" << theta << " phi=" << phi << endl;
cout << "input momentum: " << plab.GetComponents() / 1_GeV << endl;
- stack.AddParticle(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector, corsika::Point,
- TimeType, unsigned short, unsigned short>{
- beamCode, E0, plab, injectionPos, 0_ns, nuclA, nuclZ});
+ stack.AddParticle(std::tuple<particles::Code, units::si::HEPEnergyType,
+ corsika::stack::MomentumVector, geometry::Point,
+ units::si::TimeType, unsigned short, unsigned short>{
+ beamCode, E0, plab, injectionPos, 0_ns, nuclA, nuclZ});
}
// setup processes, decays and interactions
tracking_line::TrackingLine tracking;
stack_inspector::StackInspector<setup::Stack> stackInspect(1, true, E0);
- corsika::RNGManager::getInstance().registerRandomStream("sibyll");
- corsika::RNGManager::getInstance().registerRandomStream("pythia");
- corsika::sibyll::Interaction sibyll;
- corsika::sibyll::NuclearInteraction sibyllNuc(sibyll, env);
- corsika::sibyll::Decay decay;
+ random::RNGManager::GetInstance().RegisterRandomStream("sibyll");
+ random::RNGManager::GetInstance().RegisterRandomStream("pythia");
+ process::sibyll::Interaction sibyll;
+ process::sibyll::NuclearInteraction sibyllNuc(sibyll, env);
+ process::sibyll::Decay decay;
// cascade with only HE model ==> HE cut
- corsika::particle_cut::ParticleCut cut(80_GeV);
+ process::particle_cut::ParticleCut cut(80_GeV, true, true);
- corsika::track_writer::TrackWriter trackWriter("tracks.dat");
- corsika::energy_loss::BetheBlochPDG eLoss(
- injectionPos, corsika::Vector<dimensionless_d>(rootCS, {0, 0, -1}));
+ process::track_writer::TrackWriter trackWriter("tracks.dat");
+ process::energy_loss::EnergyLoss eLoss{showerAxis, cut.GetECut()};
// assemble all processes into an ordered process list
- auto sequence = corsika::make_sequence(stackInspect, sibyll, sibyllNuc, decay, eLoss, cut,
- trackWriter);
+ auto sequence =
+ process::sequence(stackInspect, sibyll, sibyllNuc, decay, eLoss, cut, trackWriter);
// define air shower object, run simulation
- corsika::Cascade EAS(env, tracking, sequence, stack);
- EAS.Init();
+ cascade::Cascade EAS(env, tracking, sequence, stack);
+
EAS.Run();
eLoss.PrintProfile(); // print longitudinal profile
@@ -145,4 +167,5 @@ int main() {
<< "relative difference (%): " << (Efinal / E0 - 1) * 100 << endl;
cout << "total dEdX energy (GeV): " << eLoss.GetTotal() / 1_GeV << endl
<< "relative difference (%): " << eLoss.GetTotal() / E0 * 100 << endl;
+ cut.Reset();
}
diff --git a/examples/cascade_proton_example.cpp b/examples/cascade_proton_example.cpp
index 8bcc7668b..2c5e1489e 100644
--- a/examples/cascade_proton_example.cpp
+++ b/examples/cascade_proton_example.cpp
@@ -1,75 +1,99 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
-#include <corsika/framework/core/Cascade.hpp>
-#include <corsika/framework/core/PhysicalUnits.hpp>
-#include <corsika/framework/geometry/Sphere.hpp>
-#include <corsika/framework/random/RNGManager.hpp>
-#include <corsika/framework/process/ProcessSequence.hpp>
-#include <corsika/framework/utility/CorsikaFenv.hpp>
-
-#include <corsika/modules/BetheBlochPDG.hpp>
-#include <corsika/modules/ParticleCut.hpp>
-#include <corsika/modules/Pythia8.hpp>
-#include <corsika/modules/Sibyll.hpp>
-#include <corsika/modules/StackInspector.hpp>
-#include <corsika/modules/TrackWriter.hpp>
-#include <corsika/modules/TrackingLine.hpp>
-
-#include <corsika/setup/SetupEnvironment.hpp>
-#include <corsika/setup/SetupStack.hpp>
-#include <corsika/setup/SetupTrajectory.hpp>
-
-#include <corsika/media/Environment.hpp>
-#include <corsika/media/HomogeneousMedium.hpp>
-#include <corsika/media/NuclearComposition.hpp>
+#include <corsika/cascade/Cascade.h>
+#include <corsika/process/ProcessSequence.h>
+#include <corsika/process/hadronic_elastic_model/HadronicElasticModel.h>
+#include <corsika/process/stack_inspector/StackInspector.h>
+#include <corsika/process/tracking_line/TrackingLine.h>
+
+#include <corsika/setup/SetupStack.h>
+#include <corsika/setup/SetupTrajectory.h>
+
+#include <corsika/environment/Environment.h>
+#include <corsika/environment/HomogeneousMedium.h>
+#include <corsika/environment/NuclearComposition.h>
+
+#include <corsika/geometry/Sphere.h>
+
+#include <corsika/process/sibyll/Decay.h>
+#include <corsika/process/sibyll/Interaction.h>
+#include <corsika/process/sibyll/NuclearInteraction.h>
+
+#include <corsika/process/pythia/Decay.h>
+#include <corsika/process/pythia/Interaction.h>
+
+#include <corsika/process/track_writer/TrackWriter.h>
+
+#include <corsika/process/particle_cut/ParticleCut.h>
+
+#include <corsika/units/PhysicalUnits.h>
+
+#include <corsika/random/RNGManager.h>
+
+#include <corsika/utl/CorsikaFenv.h>
+
+#include <corsika/logging/Logging.h>
#include <iostream>
#include <limits>
#include <typeinfo>
using namespace corsika;
-using namespace corsika::setup;
-using namespace corsika::units::si;
+using namespace corsika::process;
+using namespace corsika::units;
+using namespace corsika::particles;
+using namespace corsika::random;
+using namespace corsika::geometry;
+using namespace corsika::environment;
+
using namespace std;
+using namespace corsika::units::si;
//
// The example main program for a particle cascade
//
int main() {
+
+ logging::SetLevel(logging::level::info);
+
+ std::cout << "cascade_proton_example" << std::endl;
+
feenableexcept(FE_INVALID);
// initialize random number sequence(s)
- corsika::RNGManager::getInstance().registerRandomStream("cascade");
+ random::RNGManager::GetInstance().RegisterRandomStream("cascade");
// setup environment, geometry
- using EnvType = Environment<setup::IEnvironmentModel>;
+ using EnvType = setup::Environment;
EnvType env;
auto& universe = *(env.GetUniverse());
+ const CoordinateSystem& rootCS = env.GetCoordinateSystem();
+
+ auto theMedium = EnvType::CreateNode<Sphere>(
+ Point{rootCS, 0_m, 0_m, 0_m}, 1_km * std::numeric_limits<double>::infinity());
- auto theMedium =
- EnvType::CreateNode<Sphere>(Point{env.GetCoordinateSystem(), 0_m, 0_m, 0_m},
- 1_km * std::numeric_limits<double>::infinity());
+ using MyHomogeneousModel =
+ environment::MediumPropertyModel<environment::UniformMagneticField<
+ environment::HomogeneousMedium<setup::EnvironmentInterface>>>;
- using MyHomogeneousModel = HomogeneousMedium<IMediumModel>;
theMedium->SetModelProperties<MyHomogeneousModel>(
+ environment::Medium::AirDry1Atm, geometry::Vector(rootCS, 0_T, 0_T, 1_T),
1_kg / (1_m * 1_m * 1_m),
- NuclearComposition(std::vector<corsika::Code>{corsika::Code::Hydrogen},
+ NuclearComposition(std::vector<particles::Code>{particles::Code::Hydrogen},
std::vector<float>{(float)1.}));
universe.AddChild(std::move(theMedium));
- const CoordinateSystem& rootCS = env.GetCoordinateSystem();
-
// setup particle stack, and add primary particle
setup::Stack stack;
stack.Clear();
const Code beamCode = Code::Proton;
- const HEPMassType mass = corsika::mass(beamCode);
+ const HEPMassType mass = particles::Proton::GetMass();
const HEPEnergyType E0 = 100_GeV;
double theta = 0.;
double phi = 0.;
@@ -85,49 +109,46 @@ int main() {
};
auto const [px, py, pz] =
momentumComponents(theta / 180. * M_PI, phi / 180. * M_PI, P0);
- auto plab = corsika::MomentumVector(rootCS, {px, py, pz});
+ auto plab = corsika::stack::MomentumVector(rootCS, {px, py, pz});
cout << "input particle: " << beamCode << endl;
cout << "input angles: theta=" << theta << " phi=" << phi << endl;
cout << "input momentum: " << plab.GetComponents() / 1_GeV << endl;
Point pos(rootCS, 0_m, 0_m, 0_m);
stack.AddParticle(
- std::tuple<corsika::Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{beamCode, E0, plab, pos, 0_ns});
+ std::tuple<particles::Code, units::si::HEPEnergyType,
+ corsika::stack::MomentumVector, geometry::Point, units::si::TimeType>{
+ beamCode, E0, plab, pos, 0_ns});
}
// setup processes, decays and interactions
tracking_line::TrackingLine tracking;
stack_inspector::StackInspector<setup::Stack> stackInspect(1, true, E0);
- const std::vector<corsika::Code> trackedHadrons = {
- corsika::Code::PiPlus, corsika::Code::PiMinus, corsika::Code::KPlus,
- corsika::Code::KMinus, corsika::Code::K0Long, corsika::Code::K0Short};
-
- corsika::RNGManager::getInstance().registerRandomStream("sibyll");
- corsika::RNGManager::getInstance().registerRandomStream("pythia");
- // corsika::sibyll::Interaction sibyll(env);
- corsika::pythia8::Interaction pythia;
- // corsika::sibyll::NuclearInteraction sibyllNuc(env, sibyll);
- // corsika::sibyll::Decay decay(trackedHadrons);
- corsika::pythia8::Decay decay(trackedHadrons);
- corsika::particle_cut::ParticleCut cut(20_GeV);
-
- // corsika::RNGManager::getInstance().registerRandomStream("HadronicElasticModel");
- // corsika::HadronicElasticModel::HadronicElasticInteraction
+ random::RNGManager::GetInstance().RegisterRandomStream("sibyll");
+ random::RNGManager::GetInstance().RegisterRandomStream("pythia");
+ // process::sibyll::Interaction sibyll(env);
+ process::pythia::Interaction pythia;
+ // process::sibyll::NuclearInteraction sibyllNuc(env, sibyll);
+ // process::sibyll::Decay decay;
+ process::pythia::Decay decay;
+ process::particle_cut::ParticleCut cut(20_GeV, true, true);
+
+ // random::RNGManager::GetInstance().RegisterRandomStream("HadronicElasticModel");
+ // process::HadronicElasticModel::HadronicElasticInteraction
// hadronicElastic(env);
- corsika::track_writer::TrackWriter trackWriter("tracks.dat");
+ process::track_writer::TrackWriter trackWriter("tracks.dat");
// assemble all processes into an ordered process list
// auto sequence = sibyll << decay << hadronicElastic << cut << trackWriter;
- auto sequence = pythia << decay << cut << trackWriter << stackInspect;
+ auto sequence = process::sequence(pythia, decay, cut, trackWriter, stackInspect);
// cout << "decltype(sequence)=" << type_id_with_cvr<decltype(sequence)>().pretty_name()
// << "\n";
// define air shower object, run simulation
- corsika::Cascade EAS(env, tracking, sequence, stack);
- EAS.Init();
+ cascade::Cascade EAS(env, tracking, sequence, stack);
+
EAS.Run();
cout << "Result: E0=" << E0 / 1_GeV << endl;
diff --git a/examples/geometry_example.cpp b/examples/geometry_example.cpp
index 5cdf6043c..cca5656e3 100644
--- a/examples/geometry_example.cpp
+++ b/examples/geometry_example.cpp
@@ -1,36 +1,37 @@
-n/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+/*
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
-#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/geometry/Point.hpp>
#include <corsika/framework/geometry/RootCoordinateSystem.hpp>
#include <corsika/framework/geometry/Sphere.hpp>
#include <corsika/framework/geometry/Vector.hpp>
+#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/logging/Logging.hpp>
#include <cstdlib>
-#include <iostream>
#include <typeinfo>
using namespace corsika;
int main() {
+ CORSIKA_LOG_INFO("geometry_example");
+
// define the root coordinate system
- CoordinateSystemPtr root = get_root_CoordinateSystem();
+ CoordinateSystemPtr const& root = get_root_CoordinateSystem();
// another CS defined by a translation relative to the root CS
CoordinateSystemPtr cs2 = make_translation(root, {0_m, 0_m, 1_m});
// rotations are possible, too; parameters are axis vector and angle
CoordinateSystemPtr cs3 =
- make_rotation(root, QuantityVector<length_d>{1_m, 0_m, 0_m}, 90 * degree_angle);
-
+ make_rotation(root, QuantityVector<length_d>{1_m, 0_m, 0_m}, 90 * degree_angle);
+
// now let's define some geometrical objects:
Point const p1(root, {0_m, 0_m, 0_m}); // the origin of the root CS
Point const p2(cs2, {0_m, 0_m, 0_m}); // the origin of cs2
@@ -41,20 +42,20 @@ int main() {
auto const norm = diff.getSquaredNorm(); // squared length with the right dimension
// print the components of the vector as given in the different CS
- std::cout << "p2-p1 components in root: " << diff.getComponents(root) << std::endl;
- std::cout << "p2-p1 components in cs2: " << diff.getComponents(cs2)
- << std::endl; // by definition invariant under translations
- std::cout << "p2-p1 components in cs3: " << diff.getComponents(cs3)
- << std::endl; // but not under rotations
- std::cout << "p2-p1 norm^2: " << norm << std::endl;
+ CORSIKA_LOG_INFO(
+ "p2-p1 components in root: {} \n"
+ "p2-p1 components in cs2: {} \n"
+ "p2-p1 components in cs3: {}\n"
+ "p2-p1 norm^2: {} \n",
+ diff.getComponents(root), diff.getComponents(cs2), diff.getComponents(cs3), norm);
assert(norm == 1 * meter * meter);
Sphere s(p1, 10_m); // define a sphere around a point with a radius
- std::cout << "p1 inside s: " << s.isInside(p2) << std::endl;
+ CORSIKA_LOG_INFO("p1 inside s:{} ", s.isInside(p2));
assert(s.isInside(p2) == 1);
Sphere s2(p1, 3_um); // another sphere
- std::cout << "p1 inside s2: " << s2.isInside(p2) << std::endl;
+ CORSIKA_LOG_INFO("p1 inside s2: {}", s2.isInside(p2));
assert(s2.isInside(p2) == 0);
// let's try parallel projections:
@@ -69,11 +70,12 @@ int main() {
// if a CS is not given as parameter for getComponents(), the components
// in the "home" CS are returned
- std::cout << "v1: " << v1.getComponents() << std::endl;
- std::cout << "v2: " << v2.getComponents() << std::endl;
- std::cout << "parallel projection of v1 onto v2: " << v3.getComponents() << std::endl;
- std::cout << "normalized cross product of v1 x v2" << cross.getComponents()
- << std::endl;
+ CORSIKA_LOG_INFO(
+ "v1: {} \n"
+ "v2: {}\n "
+ "parallel projection of v1 onto v2: {} \n"
+ "normalized cross product of v1 x v2 {} \n",
+ v1.getComponents(), v2.getComponents(), v3.getComponents(), cross.getComponents());
return EXIT_SUCCESS;
}
diff --git a/examples/helix_example.cpp b/examples/helix_example.cpp
index 74994dc95..115fdd717 100644
--- a/examples/helix_example.cpp
+++ b/examples/helix_example.cpp
@@ -1,27 +1,29 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
-#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/geometry/Helix.hpp>
#include <corsika/framework/geometry/Point.hpp>
#include <corsika/framework/geometry/RootCoordinateSystem.hpp>
#include <corsika/framework/geometry/Vector.hpp>
+#include <corsika/framework/core/PhysicalUnits.hpp>
#include <array>
#include <cstdlib>
#include <iostream>
using namespace corsika;
-using namespace corsika::units::si;
int main() {
- corsika::CoordinateSystemPtr root = get_root_CoordinateSystem();
+ CORSIKA_LOG_INFO("helix_example");
+
+ CoordinateSystemPtr const& root = get_root_CoordinateSystem();
+
Point const r0(root, {0_m, 0_m, 0_m});
auto const omegaC = 2 * M_PI * 1_Hz;
Vector<speed_d> vPar(root, {0_m / second, 0_m / second, 10_cm / second});
@@ -46,8 +48,8 @@ int main() {
positions[i][3] = r[2] / 1_m;
}
- std::cout << positions[n - 2][0] << " " << positions[n - 2][1] << " "
- << positions[n - 2][2] << " " << positions[n - 2][3] << std::endl;
+ CORSIKA_LOG_INFO("test: {} {} {} {} ", positions[n - 2][0], positions[n - 2][1],
+ positions[n - 2][2], positions[n - 2][3]);
return EXIT_SUCCESS;
}
diff --git a/examples/logger_example.cpp b/examples/logger_example.cpp
deleted file mode 100644
index 5da1496e8..000000000
--- a/examples/logger_example.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
- *
- * This software is distributed under the terms of the GNU General Public
- * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
- * the license.
- */
-
-#include <corsika/logging/Logger.h>
-#include <boost/format.hpp>
-#include <fstream>
-#include <iostream>
-#include <string>
-
-using namespace std;
-using namespace corsika::logging;
-
-int main() {
- {
- cout << "writing to \"another.log\"" << endl;
- ofstream logfile("another.log");
- sink::SinkStream unbuffered_sink(logfile);
- sink::BufferedSinkStream sink(logfile, sink::StdBuffer(10000));
- Logger<MessageOn, sink::BufferedSinkStream> info("\033[32m", "info", sink);
- Logger<MessageOn, sink::BufferedSinkStream> err("\033[31m", "error", sink);
- // logger<ostream,messageconst,StdBuffer> info(std::cout, StdBuffer(10000));
-
- /*
- Logging& logs = Logging::getInstance();
- logs.AddLogger<>("info", info);
- auto& log_1 = logs.GetLogger("info"); // no so useful, since type of log_1 is
- std::any
- */
-
- for (int i = 0; i < 10000; ++i) {
- LOG(info, "irgendwas", " ", string("and more"), " ",
- boost::format("error: %i message: %s. done."), i, "stupido");
- LOG(err, "Fehler");
- }
- }
-
- {
- sink::NoSink off;
- Logger<MessageOff> info("", "", off);
-
- for (int i = 0; i < 10000; ++i) {
- LOG(info, "irgendwas", string("and more"),
- boost::format("error: %i message: %s. done."), i, "stupido", "a-number:", 8.99,
- "ENDE");
- }
- }
-
- return 0;
-}
diff --git a/examples/stack_example.cpp b/examples/stack_example.cpp
index 19db8018a..cc638dbe8 100644
--- a/examples/stack_example.cpp
+++ b/examples/stack_example.cpp
@@ -1,51 +1,58 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
-#include <corsika/framework/core/ParticleProperties.hpp>
-#include <corsika/framework/core/PhysicalUnits.hpp>
-#include <corsika/stack/SuperStupidStack.hpp>
+#include <corsika/particles/ParticleProperties.h>
+#include <corsika/stack/super_stupid/SuperStupidStack.h>
-#include <corsika/framework/geometry/Point.hpp>
-#include <corsika/framework/geometry/RootCoordinateSystem.hpp>
+#include <corsika/geometry/Point.h>
+#include <corsika/geometry/RootCoordinateSystem.h>
#include <cassert>
#include <iomanip>
#include <iostream>
using namespace corsika;
+using namespace corsika::units::si;
+using namespace corsika::stack;
+using namespace corsika::geometry;
using namespace std;
-void fill(simple_stack::SuperStupidStack& s) {
- const CoordinateSystemPtr& rootCS = get_root_CoordinateSystem();
+void fill(corsika::stack::super_stupid::SuperStupidStack& s) {
+ const geometry::CoordinateSystem& rootCS =
+ geometry::RootCoordinateSystem::GetInstance().GetRootCoordinateSystem();
for (int i = 0; i < 11; ++i) {
- s.addParticle(
- std::tuple<Code, HEPEnergyType, simple_stack::MomentumVector, Point,
- TimeType>{Code::Electron, 1.5_GeV * i,
- simple_stack::MomentumVector(rootCS, {0_GeV, 0_GeV, 1_GeV}),
- Point(rootCS, 0_m, 0_m, 0_m), 0_ns});
+ s.AddParticle(
+ std::tuple<particles::Code, units::si::HEPEnergyType,
+ corsika::stack::MomentumVector, geometry::Point, units::si::TimeType>{
+ particles::Code::Electron, 1.5_GeV * i,
+ corsika::stack::MomentumVector(rootCS, {0_GeV, 0_GeV, 1_GeV}),
+ geometry::Point(rootCS, 0_m, 0_m, 0_m), 0_ns});
}
}
-void read(simple_stack::SuperStupidStack& s) {
- assert(s.getSize() == 11); // stack has 11 particles
+void read(corsika::stack::super_stupid::SuperStupidStack& s) {
+ assert(s.getEntries() == 11); // stack has 11 particles
HEPEnergyType total_energy;
- [[maybe_unused]] int i = 0;
- for (const auto& p : s) {
- total_energy += p.getEnergy();
+ int i = 0;
+ for (auto& p : s) {
+ total_energy += p.GetEnergy();
// particles are electrons with 1.5 GeV energy times i
- assert(p.getPID() == Code::Electron);
- assert(p.getEnergy() == 1.5_GeV * (i++));
+ assert(p.GetPID() == particles::Code::Electron);
+ assert(p.GetEnergy() == 1.5_GeV * (i++));
}
}
int main() {
- simple_stack::SuperStupidStack s;
+
+ std::cout << "stack_example" << std::endl;
+
+ corsika::stack::super_stupid::SuperStupidStack s;
fill(s);
read(s);
return 0;
diff --git a/examples/staticsequence_example.cpp b/examples/staticsequence_example.cpp
index 44caf418b..a9d7a6284 100644
--- a/examples/staticsequence_example.cpp
+++ b/examples/staticsequence_example.cpp
@@ -1,23 +1,21 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
-#include <corsika/framework/process/ProcessSequence.hpp>
+#include <array>
+#include <iomanip>
+#include <iostream>
+#include <corsika/framework/process/ProcessSequence.hpp>
#include <corsika/framework/geometry/Point.hpp>
#include <corsika/framework/geometry/RootCoordinateSystem.hpp>
#include <corsika/framework/geometry/Vector.hpp>
-#include <array>
-#include <iomanip>
-#include <iostream>
-
using namespace corsika;
-using namespace corsika::units::si;
using namespace std;
const int nData = 10;
@@ -26,9 +24,9 @@ class Process1 : public ContinuousProcess<Process1> {
public:
Process1() {}
template <typename D, typename T>
- EProcessReturn DoContinuous(D& d, T&) const {
+ ProcessReturn doContinuous(D& d, T&) const {
for (int i = 0; i < nData; ++i) d.p[i] += 1;
- return EProcessReturn::eOk;
+ return ProcessReturn::Ok;
}
};
@@ -37,9 +35,9 @@ public:
Process2() {}
template <typename D, typename T>
- inline EProcessReturn DoContinuous(D& d, T&) const {
+ inline ProcessReturn doContinuous(D& d, T&) const {
for (int i = 0; i < nData; ++i) d.p[i] -= 0.1 * i;
- return EProcessReturn::eOk;
+ return ProcessReturn::Ok;
}
};
@@ -48,8 +46,8 @@ public:
Process3() {}
template <typename D, typename T>
- inline EProcessReturn DoContinuous(D&, T&) const {
- return EProcessReturn::eOk;
+ inline ProcessReturn doContinuous(D&, T&) const {
+ return ProcessReturn::Ok;
}
};
@@ -58,9 +56,9 @@ public:
Process4(const double v)
: fV(v) {}
template <typename D, typename T>
- inline EProcessReturn DoContinuous(D& d, T&) const {
+ inline ProcessReturn doContinuous(D& d, T&) const {
for (int i = 0; i < nData; ++i) d.p[i] *= fV;
- return EProcessReturn::eOk;
+ return ProcessReturn::Ok;
}
private:
@@ -83,7 +81,7 @@ void modular() {
Process3 m3; // * 1.0
Process4 m4(1.5); // * 1.5
- auto sequence = process::sequence(m1, m2, m3, m4);
+ auto sequence = make_sequence(m1, m2, m3, m4);
DummyData particle;
DummyTrajectory track;
@@ -92,7 +90,7 @@ void modular() {
const int nEv = 10;
for (int iEv = 0; iEv < nEv; ++iEv) {
- sequence.DoContinuous(particle, track);
+ sequence.doContinuous(particle, track);
for (int i = 0; i < nData; ++i) {
check[i] += 1. - 0.1 * i;
check[i] *= 1.5;
diff --git a/examples/stopping_power.cpp b/examples/stopping_power.cpp
index 5792af98d..0036c84ba 100644
--- a/examples/stopping_power.cpp
+++ b/examples/stopping_power.cpp
@@ -1,5 +1,5 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2019 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
@@ -7,42 +7,47 @@
*/
#include <corsika/media/Environment.hpp>
+#include <corsika/media/HomogeneousMedium.hpp>
+#include <corsika/media/IMediumModel.hpp>
+#include <corsika/media/ShowerAxis.hpp>
-#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/geometry/Sphere.hpp>
-#include <corsika/framework/utility/CorsikaFenv.hpp>
-
#include <corsika/modules/BetheBlochPDG.hpp>
-
#include <corsika/setup/SetupStack.hpp>
+#include <corsika/framework/core/PhysicalUnits.hpp>
+#include <corsika/framework/utility/CorsikaFenv.hpp>
#include <fstream>
#include <iostream>
#include <limits>
using namespace corsika;
-using namespace corsika::units::si;
using namespace std;
//
// This example demonstrates the energy loss of muons as function of beta*gamma (=p/m)
//
int main() {
+
+ std::cout << "stopping_power" << std::endl;
+
feenableexcept(FE_INVALID);
// setup environment, geometry
- using EnvType = Environment<setup::IEnvironmentModel>;
+ using EnvType = Environment<IMediumModel>;
EnvType env;
+ env.getUniverse()->setModelProperties<HomogeneousMedium<IMediumModel>>(
+ 1_g / cube(1_cm), NuclearComposition{{Code::Unknown}, {1.f}});
- const CoordinateSystem& rootCS = env.GetCoordinateSystem();
+ CoordinateSystemPtr const& rootCS = env.getCoordinateSystem();
Point const injectionPos(
rootCS, 0_m, 0_m,
112.8_km); // this is the CORSIKA 7 start of atmosphere/universe
- Vector<dimensionless_d> showerAxis(rootCS, {0, 0, -1});
-
- corsika::energy_loss::BetheBlochPDG eLoss(injectionPos, showerAxis);
+ ShowerAxis showerAxis{injectionPos,
+ Vector<length_d>{rootCS, 0_m, 0_m, 1_m}, env};
+ energy_loss::BetheBlochPDG eLoss{showerAxis, 300_MeV};
setup::Stack stack;
@@ -50,9 +55,9 @@ int main() {
file << "# beta*gamma, dE/dX / eV/(g/cm²)" << std::endl;
for (HEPEnergyType E0 = 300_MeV; E0 < 1_PeV; E0 *= 1.05) {
- stack.Clear();
+ stack.clear();
const Code beamCode = Code::MuPlus;
- const HEPMassType mass = corsika::mass(beamCode);
+ const HEPMassType mass = get_mass(beamCode);
double theta = 0.;
double phi = 0.;
@@ -66,18 +71,15 @@ int main() {
};
auto const [px, py, pz] =
momentumComponents(theta / 180. * M_PI, phi / 180. * M_PI, P0);
- auto plab = corsika::MomentumVector(rootCS, {px, py, pz});
+ auto plab = MomentumVector(rootCS, {px, py, pz});
cout << "input particle: " << beamCode << endl;
cout << "input angles: theta=" << theta << " phi=" << phi << endl;
- cout << "input momentum: " << plab.GetComponents() / 1_GeV << endl;
+ cout << "input momentum: " << plab.getComponents() / 1_GeV << endl;
- stack.AddParticle(
- std::tuple<corsika::Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{beamCode, E0, plab, injectionPos,
- 0_ns});
+ stack.addParticle(std::make_tuple(beamCode, E0, plab, injectionPos, 0_ns));
- auto const p = stack.GetNextParticle();
- HEPEnergyType dE = eLoss.TotalEnergyLoss(p, 1_g / square(1_cm));
+ auto const p = stack.getNextParticle();
+ HEPEnergyType dE = eLoss.getTotalEnergyLoss(p, 1_g / square(1_cm));
file << P0 / mass << "\t" << -dE / 1_eV << std::endl;
}
}
diff --git a/examples/vertical_EAS.cpp b/examples/vertical_EAS.cpp
index 53ce463bd..c6f2dbe61 100644
--- a/examples/vertical_EAS.cpp
+++ b/examples/vertical_EAS.cpp
@@ -1,68 +1,113 @@
/*
- * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
+ * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
*
* This software is distributed under the terms of the GNU General Public
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
-#include <corsika/framework/core/Cascade.hpp>
-#include <corsika/framework/core/PhysicalUnits.hpp>
-#include <corsika/framework/geometry/Plane.hpp>
-#include <corsika/framework/geometry/Sphere.hpp>
-#include <corsika/framework/process/ProcessSequence.hpp>
-#include <corsika/framework/process/StackProcess.hpp>
-#include <corsika/framework/random/RNGManager.hpp>
-#include <corsika/framework/utility/CorsikaFenv.hpp>
-
-#include <corsika/setup/SetupStack.hpp>
-#include <corsika/setup/SetupTrajectory.hpp>
-
-#include <corsika/media/Environment.hpp>
-#include <corsika/media/FlatExponential.hpp>
-#include <corsika/media/LayeredSphericalAtmosphereBuilder.hpp>
-#include <corsika/media/NuclearComposition.hpp>
-
-#include <corsika/modules/BetheBlochPDG.hpp>
-#include <corsika/modules/ObservationPlane.hpp>
-#include <corsika/modules/ParticleCut.hpp>
-#include <corsika/modules/Sibyll.hpp>
-#include <corsika/modules/SwitchProcess.hpp>
-#include <corsika/modules/TrackWriter.hpp>
-#include <corsika/modules/TrackingLine.hpp>
-#include <corsika/modules/UrQMD.hpp>
+/* clang-format off */
+// InteractionCounter used boost/histogram, which
+// fails if boost/type_traits have been included before. Thus, we have
+// to include it first...
+#include <corsika/process/interaction_counter/InteractionCounter.hpp>
+/* clang-format on */
+#include <corsika/cascade/Cascade.h>
+#include <corsika/environment/Environment.h>
+#include <corsika/environment/FlatExponential.h>
+#include <corsika/environment/LayeredSphericalAtmosphereBuilder.h>
+#include <corsika/environment/NuclearComposition.h>
+#include <corsika/environment/ShowerAxis.h>
+#include <corsika/geometry/Plane.h>
+#include <corsika/geometry/Sphere.h>
+#include <corsika/logging/Logging.h>
+#include <corsika/process/ProcessSequence.h>
+#include <corsika/process/SwitchProcessSequence.h>
+#include <corsika/process/StackProcess.h>
+#include <corsika/process/energy_loss/EnergyLoss.h>
+#include <corsika/process/longitudinal_profile/LongitudinalProfile.h>
+#include <corsika/process/observation_plane/ObservationPlane.h>
+#include <corsika/process/on_shell_check/OnShellCheck.h>
+#include <corsika/process/particle_cut/ParticleCut.h>
+#include <corsika/process/proposal/ContinuousProcess.h>
+#include <corsika/process/proposal/Interaction.h>
+#include <corsika/process/pythia/Decay.h>
+#include <corsika/process/sibyll/Decay.h>
+#include <corsika/process/sibyll/Interaction.h>
+#include <corsika/process/sibyll/NuclearInteraction.h>
+#include <corsika/process/tracking_line/TrackingLine.h>
+#include <corsika/process/urqmd/UrQMD.h>
+#include <corsika/random/RNGManager.h>
+#include <corsika/setup/SetupStack.h>
+#include <corsika/setup/SetupTrajectory.h>
+#include <corsika/units/PhysicalUnits.h>
+#include <corsika/utl/CorsikaFenv.h>
#include <iomanip>
#include <iostream>
#include <limits>
-#include <typeinfo>
+#include <string>
using namespace corsika;
-using namespace corsika::setup;
+using namespace corsika::process;
+using namespace corsika::units;
+using namespace corsika::particles;
+using namespace corsika::random;
+using namespace corsika::geometry;
+using namespace corsika::environment;
+
using namespace std;
+using namespace corsika::units::si;
+
+using Particle = setup::Stack::StackIterator;
+
+void registerRandomStreams(const int seed) {
+ random::RNGManager::GetInstance().RegisterRandomStream("cascade");
+ random::RNGManager::GetInstance().RegisterRandomStream("qgsjet");
+ random::RNGManager::GetInstance().RegisterRandomStream("sibyll");
+ random::RNGManager::GetInstance().RegisterRandomStream("pythia");
+ random::RNGManager::GetInstance().RegisterRandomStream("urqmd");
+ random::RNGManager::GetInstance().RegisterRandomStream("proposal");
+
+ if (seed == 0)
+ random::RNGManager::GetInstance().SeedAll();
+ else
+ random::RNGManager::GetInstance().SeedAll(seed);
+}
-void registerRandomStreams() {
- corsika::RNGManager::getInstance().registerRandomStream("cascade");
- corsika::RNGManager::getInstance().registerRandomStream("sibyll");
- // corsika::RNGManager::getInstance().registerRandomStream("pythia");
- corsika::RNGManager::getInstance().registerRandomStream("urqmd");
+template <typename T>
+using MyExtraEnv = environment::MediumPropertyModel<environment::UniformMagneticField<T>>;
- corsika::RNGManager::getInstance().seedAll();
-}
+int main(int argc, char** argv) {
-int main() {
+ logging::SetLevel(logging::level::info);
+
+ C8LOG_INFO("vertical_EAS");
+
+ if (argc < 4) {
+ std::cerr << "usage: vertical_EAS <A> <Z> <energy/GeV> [seed]" << std::endl;
+ std::cerr << " if no seed is given, a random seed is chosen" << std::endl;
+ return 1;
+ }
feenableexcept(FE_INVALID);
+
+ int seed = 0;
+ if (argc > 4) seed = std::stoi(std::string(argv[4]));
// initialize random number sequence(s)
- registerRandomStreams();
+ registerRandomStreams(seed);
// setup environment, geometry
- using EnvType = Environment<setup::IEnvironmentModel>;
+ using EnvType = setup::Environment;
EnvType env;
const CoordinateSystem& rootCS = env.GetCoordinateSystem();
-
- corsika::LayeredSphericalAtmosphereBuilder builder(Point{rootCS, 0_m, 0_m, 0_m});
+ Point const center{rootCS, 0_m, 0_m, 0_m};
+ auto builder = environment::make_layered_spherical_atmosphere_builder<
+ setup::EnvironmentInterface,
+ MyExtraEnv>::create(center, units::constants::EarthRadius::Mean,
+ environment::Medium::AirDry1Atm,
+ geometry::Vector{rootCS, 0_T, 0_T, 1_T});
builder.setNuclearComposition(
- {{corsika::Code::Nitrogen, corsika::Code::Oxygen},
+ {{particles::Code::Nitrogen, particles::Code::Oxygen},
{0.7847f, 1.f - 0.7847f}}); // values taken from AIRES manual, Ar removed for now
builder.addExponentialLayer(1222.6562_g / (1_cm * 1_cm), 994186.38_cm, 4_km);
@@ -70,92 +115,156 @@ int main() {
builder.addExponentialLayer(1305.5948_g / (1_cm * 1_cm), 636143.04_cm, 40_km);
builder.addExponentialLayer(540.1778_g / (1_cm * 1_cm), 772170.16_cm, 100_km);
builder.addLinearLayer(1e9_cm, 112.8_km);
-
builder.assemble(env);
// setup particle stack, and add primary particle
setup::Stack stack;
stack.Clear();
- const Code beamCode = Code::Proton;
- auto const mass = corsika::mass(beamCode);
- const HEPEnergyType E0 = 0.1_PeV;
+ const Code beamCode = Code::Nucleus;
+ unsigned short const A = std::stoi(std::string(argv[1]));
+ unsigned short Z = std::stoi(std::string(argv[2]));
+ auto const mass = particles::GetNucleusMass(A, Z);
+ const HEPEnergyType E0 = 1_GeV * std::stof(std::string(argv[3]));
double theta = 0.;
- double phi = 0.;
-
- Point const injectionPos(
- rootCS, 0_m, 0_m,
- 112.8_km * 0.999 +
- builder.earthRadius); // this is the CORSIKA 7 start of atmosphere/universe
+ auto const thetaRad = theta / 180. * M_PI;
- // {
auto elab2plab = [](HEPEnergyType Elab, HEPMassType m) {
return sqrt((Elab - m) * (Elab + m));
};
HEPMomentumType P0 = elab2plab(E0, mass);
- auto momentumComponents = [](double theta, double phi, HEPMomentumType ptot) {
- return std::make_tuple(ptot * sin(theta) * cos(phi), ptot * sin(theta) * sin(phi),
- -ptot * cos(theta));
+ auto momentumComponents = [](double thetaRad, HEPMomentumType ptot) {
+ return std::make_tuple(ptot * sin(thetaRad), 0_eV, -ptot * cos(thetaRad));
};
- auto const [px, py, pz] =
- momentumComponents(theta / 180. * M_PI, phi / 180. * M_PI, P0);
- auto plab = corsika::MomentumVector(rootCS, {px, py, pz});
- std::cout << "input particle: " << beamCode << std::endl;
- std::cout << "input angles: theta=" << theta << " phi=" << phi << std::endl;
- std::cout << "input momentum: " << plab.GetComponents() / 1_GeV << std::endl;
- stack.AddParticle(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector, corsika::Point,
- TimeType>{beamCode, E0, plab, injectionPos, 0_ns});
- // }
+ auto const [px, py, pz] = momentumComponents(thetaRad, P0);
+ auto plab = corsika::stack::MomentumVector(rootCS, {px, py, pz});
+ cout << "input particle: " << beamCode << endl;
+ cout << "input angles: theta=" << theta << endl;
+ cout << "input momentum: " << plab.GetComponents() / 1_GeV << ", norm = " << plab.norm()
+ << endl;
+
+ auto const observationHeight = 0_km + builder.getEarthRadius();
+ auto const injectionHeight = 112.75_km + builder.getEarthRadius();
+ auto const t = -observationHeight * cos(thetaRad) +
+ sqrt(-units::static_pow<2>(sin(thetaRad) * observationHeight) +
+ units::static_pow<2>(injectionHeight));
+ Point const showerCore{rootCS, 0_m, 0_m, observationHeight};
+ Point const injectionPos =
+ showerCore +
+ Vector<dimensionless_d>{rootCS, {-sin(thetaRad), 0, cos(thetaRad)}} * t;
+
+ std::cout << "point of injection: " << injectionPos.GetCoordinates() << std::endl;
+
+ if (A != 1) {
+ stack.AddParticle(std::make_tuple(beamCode, E0, plab, injectionPos, 0_ns, A, Z));
+
+ } else {
+ stack.AddParticle(
+ std::make_tuple(particles::Code::Proton, E0, plab, injectionPos, 0_ns));
+ }
+
+ // we make the axis much longer than the inj-core distance since the
+ // profile will go beyond the core, depending on zenith angle
+ std::cout << "shower axis length: " << (showerCore - injectionPos).norm() * 1.5
+ << std::endl;
+
+ environment::ShowerAxis const showerAxis{injectionPos,
+ (showerCore - injectionPos) * 1.5, env};
- Line const line(injectionPos, plab.normalized() * 1_m * 1_Hz);
- auto const velocity = line.GetV0().norm();
+ // setup processes, decays and interactions
- auto const observationHeight = 1.425_km + builder.earthRadius;
+ process::sibyll::Interaction sibyll;
+ process::interaction_counter::InteractionCounter sibyllCounted(sibyll);
- setup::Trajectory const showerAxis(line, (112.8_km - observationHeight) / velocity);
+ process::sibyll::NuclearInteraction sibyllNuc(sibyll, env);
+ process::interaction_counter::InteractionCounter sibyllNucCounted(sibyllNuc);
- // setup processes, decays and interactions
+ process::pythia::Decay decayPythia;
- corsika::sibyll::Interaction sibyll;
- corsika::sibyll::NuclearInteraction sibyllNuc(sibyll, env);
- corsika::sibyll::Decay decay;
+ // use sibyll decay routine for decays of particles unknown to pythia
+ process::sibyll::Decay decaySibyll{{
+ Code::N1440Plus,
+ Code::N1440MinusBar,
+ Code::N1440_0,
+ Code::N1440_0Bar,
+ Code::N1710Plus,
+ Code::N1710MinusBar,
+ Code::N1710_0,
+ Code::N1710_0Bar,
- corsika::particle_cut::ParticleCut cut(5_GeV);
+ Code::Pi1300Plus,
+ Code::Pi1300Minus,
+ Code::Pi1300_0,
- corsika::track_writer::TrackWriter trackWriter("tracks.dat");
- corsika::energy_loss::BetheBlochPDG eLoss(showerAxis);
+ Code::KStar0_1430_0,
+ Code::KStar0_1430_0Bar,
+ Code::KStar0_1430_Plus,
+ Code::KStar0_1430_MinusBar,
+ }};
- Plane const obsPlane(Point(rootCS, 0_m, 0_m, observationHeight),
- Vector<dimensionless_d>(rootCS, {0., 0., 1.}));
- corsika::observation_plane::ObservationPlane observationLevel(obsPlane,
- "particles.dat");
+ decaySibyll.PrintDecayConfig();
- // assemble all processes into an ordered process list
+ process::particle_cut::ParticleCut cut{60_GeV, false, true};
+ process::proposal::Interaction proposal(env, cut.GetECut());
+ process::proposal::ContinuousProcess em_continuous(env, cut.GetECut());
+ process::interaction_counter::InteractionCounter proposalCounted(proposal);
+
+ process::on_shell_check::OnShellCheck reset_particle_mass(1.e-3, 1.e-1, false);
- corsika::urqmd::UrQMD urqmd;
+ process::longitudinal_profile::LongitudinalProfile longprof{showerAxis};
- auto sibyllSequence = sibyll << sibyllNuc;
- corsika::switch_process::SwitchProcess switchProcess(urqmd, sibyllSequence, 55_GeV);
- auto sequence = switchProcess << decay << eLoss << cut << observationLevel
- << trackWriter;
+ Plane const obsPlane(showerCore, Vector<dimensionless_d>(rootCS, {0., 0., 1.}));
+ process::observation_plane::ObservationPlane observationLevel(obsPlane,
+ "particles.dat");
+
+ process::UrQMD::UrQMD urqmd;
+ process::interaction_counter::InteractionCounter urqmdCounted{urqmd};
+
+ // assemble all processes into an ordered process list
+ struct EnergySwitch {
+ HEPEnergyType cutE_;
+ EnergySwitch(HEPEnergyType cutE)
+ : cutE_(cutE) {}
+ process::SwitchResult operator()(const Particle& p) {
+ if (p.GetEnergy() < cutE_)
+ return process::SwitchResult::First;
+ else
+ return process::SwitchResult::Second;
+ }
+ };
+ auto hadronSequence =
+ process::select(urqmdCounted, process::sequence(sibyllNucCounted, sibyllCounted),
+ EnergySwitch(55_GeV));
+ auto decaySequence = process::sequence(decayPythia, decaySibyll);
+ auto sequence =
+ process::sequence(hadronSequence, reset_particle_mass, decaySequence,
+ proposalCounted, em_continuous, cut, observationLevel, longprof);
// define air shower object, run simulation
tracking_line::TrackingLine tracking;
- corsika::Cascade EAS(env, tracking, sequence, stack);
- EAS.Init();
- EAS.Run();
+ cascade::Cascade EAS(env, tracking, sequence, stack);
- eLoss.PrintProfile(); // print longitudinal profile
+ // to fix the point of first interaction, uncomment the following two lines:
+ // EAS.forceInteraction();
+
+ EAS.Run();
cut.ShowResults();
- const HEPEnergyType Efinal =
- cut.GetCutEnergy() + cut.GetInvEnergy() + cut.GetEmEnergy();
- std::cout << "total cut energy (GeV): " << Efinal / 1_GeV << std::endl
- << "relative difference (%): " << (Efinal / E0 - 1) * 100 << std::endl;
- std::cout << "total dEdX energy (GeV): " << eLoss.GetTotal() / 1_GeV << std::endl
- << "relative difference (%): " << eLoss.GetTotal() / E0 * 100 << std::endl;
-
- std::ofstream finish("finished");
- finish << "run completed without error" << std::endl;
+ em_continuous.showResults();
+ observationLevel.ShowResults();
+ const HEPEnergyType Efinal = cut.GetCutEnergy() + cut.GetInvEnergy() +
+ cut.GetEmEnergy() + em_continuous.energyLost() +
+ observationLevel.GetEnergyGround();
+ cout << "total cut energy (GeV): " << Efinal / 1_GeV << endl
+ << "relative difference (%): " << (Efinal / E0 - 1) * 100 << endl;
+ observationLevel.Reset();
+ cut.Reset();
+ em_continuous.reset();
+
+ auto const hists = sibyllCounted.GetHistogram() + sibyllNucCounted.GetHistogram() +
+ urqmdCounted.GetHistogram() + proposalCounted.GetHistogram();
+
+ hists.saveLab("inthist_lab_verticalEAS.npz");
+ hists.saveCMS("inthist_cms_verticalEAS.npz");
+ longprof.save("longprof_verticalEAS.txt");
}
diff --git a/externals/cnpy/CMakeLists.txt b/externals/cnpy/CMakeLists.txt
index 8fbd839c7..0fa38d3bd 100644
--- a/externals/cnpy/CMakeLists.txt
+++ b/externals/cnpy/CMakeLists.txt
@@ -8,20 +8,7 @@ set (
cnpy.hpp
)
-set (
- CNPY_NAMESPACE
- corsika/third_party/cnpy
- )
-
add_library (cnpy STATIC ${CNPY_SOURCES})
-CORSIKA_COPY_HEADERS_TO_NAMESPACE (cnpy ${CNPY_NAMESPACE} ${CNPY_HEADERS})
-
-set_target_properties (
- cnpy
- PROPERTIES
- VERSION ${PROJECT_VERSION}
- SOVERSION 1
- )
# target dependencies on other libraries (also the header onlys)
target_link_libraries (
@@ -33,8 +20,8 @@ target_link_libraries (
target_include_directories (
cnpy
INTERFACE
- $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
- $<INSTALL_INTERFACE:include/include>
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+ $<INSTALL_INTERFACE:include/externals/cnpy>
)
install (
diff --git a/externals/cnpy/cnpy.cpp b/externals/cnpy/cnpy.cpp
index 026afcd55..b32ed7617 100644
--- a/externals/cnpy/cnpy.cpp
+++ b/externals/cnpy/cnpy.cpp
@@ -64,8 +64,8 @@ std::vector<char>& cnpy::operator+=(std::vector<char>& lhs, const char* rhs) {
void cnpy::parse_npy_header(unsigned char* buffer, size_t& word_size,
std::vector<size_t>& shape, bool& fortran_order) {
// std::string magic_string(buffer,6);
- uint8_t major_version = *reinterpret_cast<uint8_t*>(buffer + 6);
- uint8_t minor_version = *reinterpret_cast<uint8_t*>(buffer + 7);
+ [[maybe_unused]] uint8_t major_version = *reinterpret_cast<uint8_t*>(buffer + 6);
+ [[maybe_unused]] uint8_t minor_version = *reinterpret_cast<uint8_t*>(buffer + 7);
uint16_t header_len = *reinterpret_cast<uint16_t*>(buffer + 8);
std::string header(reinterpret_cast<char*>(buffer + 9), header_len);
@@ -200,7 +200,7 @@ cnpy::NpyArray load_the_npz_array(FILE* fp, uint32_t compr_bytes,
size_t nread = fread(&buffer_compr[0], 1, compr_bytes, fp);
if (nread != compr_bytes) throw std::runtime_error("load_the_npy_file: failed fread");
- int err;
+ [[maybe_unused]] int err;
z_stream d_stream;
d_stream.zalloc = Z_NULL;
diff --git a/src/modules/qgsjetII/code_generator.py b/src/modules/qgsjetII/code_generator.py
index 0bb7c0a50..ce7fcae26 100755
--- a/src/modules/qgsjetII/code_generator.py
+++ b/src/modules/qgsjetII/code_generator.py
@@ -2,8 +2,6 @@
# (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 GNU General Public
# Licence version 3 (GPL Version 3). See file LICENSE for a full version of
# the license.
@@ -13,16 +11,82 @@ import pickle, sys, itertools
-# loads the pickled particle_db (which is an OrderedDict)
def load_particledb(filename):
+ '''
+ loads the pickled particle_db (which is an OrderedDict)
+ definition of particle_db dict is: "name", "antiName", "pdg", "mass", "electric_charge", "lifetime", "ngc_code", "isNucleus", "isHadron"
+ '''
with open(filename, "rb") as f:
particle_db = pickle.load(f)
return particle_db
+def set_default_qgsjetII_definition(particle_db):
+ '''
+ Also particles not explicitly known by QGSJetII may in fact interact via mapping
+ to cross section types (xsType) and hadron type (hadronType)
+
+ This is achieved here.
+
+ The function return nothing, but modified the input particle_db by adding the
+ fields 'xsType' and 'hadronType'
+ '''
+ for identifier, pData in particle_db.items():
+ # the cross-section types
+ xsType = "CannotInteract"
+ hadronType = "UndefinedType"
+ if (pData['isNucleus']):
+ xsType = "Baryons"
+ hadronType = "NucleusType"
+ elif (pData['isHadron']):
+ pdg = abs(pData['pdg'])
+ anti = pData['pdg'] < 0
+ isBaryon = (1000 <= pdg < 4000)
+ charge = pData['electric_charge']
+ if (pdg>=100 and pdg<300 and pdg!=130): # light mesons
+ xsType = "LightMesons"
+ if (charge==0):
+ hadronType = "NeutralLightMesonType"
+ else:
+ if (charge>0):
+ hadronType = "PiPlusType"
+ else:
+ hadronType = "PiMinusType"
+ elif ((pdg>=300 and pdg<400) or pdg in [130, 10313, 10323]): # kaons
+ xsType = "Kaons"
+ if (charge>0):
+ hadronType = "KaonPlusType"
+ else:
+ hadronType = "KaonMinusType"
+ if (charge==0):
+ hadronType = "Kaon0SType"
+ if (pdg == 130):
+ hadronType = "Kaon0LType"
+ elif (pdg == 310):
+ hadronType = "Kaon0SType"
+ elif (isBaryon or pData['isNucleus']): # baryons
+ xsType = "Baryons"
+ if (charge==0):
+ if (anti):
+ hadronType = "AntiNeutronType"
+ else:
+ hadronType = "NeutronType"
+ else:
+ if (charge>0):
+ hadronType = "ProtonType"
+ else:
+ hadronType = "AntiProtonType"
+ # all othe not-captured cased are hopefully irrelevant
+
+ pData['qgsjetII_xsType'] = xsType
+ pData['qgsjetII_hadronType'] = hadronType
-#
+
def read_qgsjetII_codes(filename, particle_db):
+ '''
+ reads the qgsjet-codes data file. For particles known to QGSJetII the 'qgsjetII_code' is set in the particle_db, as
+ well as the 'xsType' is updated in case it is different from its default value set above.
+ '''
with open(filename) as f:
for line in f:
line = line.strip()
@@ -33,47 +97,65 @@ def read_qgsjetII_codes(filename, particle_db):
identifier, model_code, xsType = line.split()
try:
particle_db[identifier]["qgsjetII_code"] = int(model_code)
- particle_db[identifier]["qgsjetII_xsType"] = int(xsType)
+ particle_db[identifier]["qgsjetII_xsType"] = xsType
except KeyError as e:
raise Exception("Identifier '{:s}' not found in particle_db".format(identifier))
-
-
-# generates the enum to access qgsjetII particles by readable names
def generate_qgsjetII_enum(particle_db):
+ '''
+ generates the enum to access qgsjetII particles by readable names
+ '''
output = "enum class QgsjetIICode : int8_t {\n"
for identifier, pData in particle_db.items():
- if pData.get('qgsjetII_code') != None:
+ if 'qgsjetII_code' in pData:
output += " {:s} = {:d},\n".format(identifier, pData['qgsjetII_code'])
output += "};\n"
return output
-
-# generates the look-up table to convert corsika codes to qgsjetII codes
def generate_corsika2qgsjetII(particle_db):
- string = "std::array<QgsjetIICodeIntType, {:d}> constexpr corsika2qgsjetII = {{\n".format(len(particle_db))
+ '''
+ generates the look-up table to convert corsika codes to qgsjetII codes
+ '''
+ string = "std::array<QgsjetIICode, {:d}> constexpr corsika2qgsjetII = {{\n".format(len(particle_db))
for identifier, pData in particle_db.items():
- modelCode = pData.get("qgsjetII_code", 0)
- string += " {:d}, // {:s}\n".format(modelCode, identifier if modelCode else identifier + " (not implemented in QGSJETII)")
+ if 'qgsjetII_code' in pData:
+ string += " QgsjetIICode::{:s}, \n".format(identifier)
+ else:
+ string += " QgsjetIICode::Unknown, // {:s}\n".format(identifier + ' not implemented in QGSJetII')
string += "};\n"
return string
-
-# generates the look-up table to convert corsika codes to qgsjetII codes
def generate_corsika2qgsjetII_xsType(particle_db):
- string = "std::array<int, {:d}> constexpr corsika2qgsjetIIXStype = {{\n".format(len(particle_db))
+ '''
+ generates the look-up table to convert corsika codes to qgsjetII codes
+ '''
+ string = "std::array<QgsjetIIXSClass, {:d}> constexpr corsika2qgsjetIIXStype = {{\n".format(len(particle_db))
for identifier, pData in particle_db.items():
- modelCodeXS = pData.get("qgsjetII_xsType", -1)
- string += " {:d}, // {:s}\n".format(modelCodeXS, identifier if modelCodeXS else identifier + " (not implemented in QGSJETII)")
+ modelCodeXS = pData.get("qgsjetII_xsType", "CannotInteract")
+ string += " QgsjetIIXSClass::{:s}, // {:s}\n".format(modelCodeXS, identifier if modelCodeXS else identifier + " (not implemented in QGSJETII)")
+ string += "};\n"
+ return string
+
+
+def generate_corsika2qgsjetII_hadronType(particle_db):
+ '''
+ generates the look-up table to convert corsika codes to qgsjetII codes
+ '''
+ string = "std::array<QgsjetIIHadronType, {:d}> constexpr corsika2qgsjetIIHadronType = {{\n".format(len(particle_db))
+ for identifier, pData in particle_db.items():
+ modelCode = pData.get("qgsjetII_hadronType", "UndefinedType")
+ string += " QgsjetIIHadronType::{:s}, // {:s}\n".format(modelCode, identifier if modelCode else identifier + " (not implemented in QGSJETII)")
string += "};\n"
return string
-# generates the look-up table to convert qgsjetII codes to corsika codes
def generate_qgsjetII2corsika(particle_db) :
+ '''
+ generates the look-up table to convert qgsjetII codes to corsika codes
+ '''
minID = 0
for identifier, pData in particle_db.items() :
if 'qgsjetII_code' in pData:
@@ -98,6 +180,18 @@ def generate_qgsjetII2corsika(particle_db) :
string += "};\n"
return string
+def generate_qgsjetII_start():
+ string = "// This file is auto-generated. Do not edit!\n"
+ string += "#pragma once\n"
+ string += "namespace corsika::qgsjetII {\n"
+ return string
+
+def generate_qgsjetII_end():
+ string = "}\n"
+ return string
+
+
+
if __name__ == "__main__":
if len(sys.argv) != 3:
print("usage: {:s} <particle_db.pkl> <qgsjetII_codes.dat>".format(sys.argv[0]), file=sys.stderr)
@@ -107,10 +201,14 @@ if __name__ == "__main__":
particle_db = load_particledb(sys.argv[1])
read_qgsjetII_codes(sys.argv[2], particle_db)
+ set_default_qgsjetII_definition(particle_db)
with open("Generated.inc", "w") as f:
print("// this file is automatically generated\n// edit at your own risk!\n", file=f)
+ print(generate_qgsjetII_start(), file=f)
print(generate_qgsjetII_enum(particle_db), file=f)
print(generate_corsika2qgsjetII(particle_db), file=f)
print(generate_qgsjetII2corsika(particle_db), file=f)
print(generate_corsika2qgsjetII_xsType(particle_db), file=f)
+ print(generate_corsika2qgsjetII_hadronType(particle_db), file=f)
+ print(generate_qgsjetII_end(), file=f)
diff --git a/src/modules/qgsjetII/qgsjet-II-04-codes.dat b/src/modules/qgsjetII/qgsjet-II-04-codes.dat
index 9cb511ec0..8b1bee7c7 100644
--- a/src/modules/qgsjetII/qgsjet-II-04-codes.dat
+++ b/src/modules/qgsjetII/qgsjet-II-04-codes.dat
@@ -1,52 +1,44 @@
# input file for particle conversion to/from QGSJet
-# the format of this file is: "corsika-identifier" "qgsjet-id" "hadron-class for x-section"
-
-# class 0 (cannot interact)
-Electron 11 0
-Positron -11 0
-
-# class 1
-Pi0 0 1
-PiPlus 1 1
-PiMinus -1 1
-# in crmc: all particles from 100 to 999 ???
-Eta 10 1
-Rho0 -10 1
-
-# class 2
-#Nucleus 40 2
-Neutron 3 2
-AntiNeutron -3 2
-Proton 2 2
-AntiProton -2 2
-# in crmc: 1000 to 9999 ???
-Lambda0 6 2
-Lambda0Bar -6 2
-LambdaCPlus 9 2
-LambdaCMinusBar -9 2
-
-# class 3
-K0Long -5 3
-K0 5 3
-K0Bar -5 3
-K0Short 5 3
-# ambiguity between the K0/b and K0s/l
-KPlus 4 3
-KMinus -4 3
-
-# class 4
-D0 8 4
-D0Bar 8 4
-DPlus 7 4
-DMinus -7 4
-#DS+/- (340)
-#etac (440)
-#j/psi (441)
-#h_1c0
-#psi'
-#Xi_0c0
-#Xi_1c0
-#Xi_2c0
-
-
+# the format of this file is: "corsika-identifier" "qgsjet-id" "xs-class"
+
+# The 'Unknown' particle is needed to mark all particles qgsjetII does
+# not know
+# IMPORTANT Note: the code "20" MAY NOT BE USED by qgsjetII. Change to
+# another positive integer if a conflict arises. Since we use std::array
+# to store PID data keep the number as low as reasonable.
+Unknown 20 CannotInteract
+
+# Note, we list here only the particles, which are produced by
+# QGSJetII as secondaries. There is additional mapping of corsika
+# particles on QGSJetII "xs-class"es and "hadron-type"s, which are
+# programmed in code_generator.py
+
+# class 1 (-> as pions)
+Pi0 0 LightMesons
+PiPlus 1 LightMesons
+PiMinus -1 LightMesons
+Eta 10 LightMesons
+Rho0 -10 LightMesons
+
+# class 2 (-> as proton)
+Neutron 3 Baryons
+AntiNeutron -3 Baryons
+Proton 2 Baryons
+AntiProton -2 Baryons
+Lambda0 6 Baryons
+Lambda0Bar -6 Baryons
+LambdaCPlus 9 Baryons
+LambdaCMinusBar -9 Baryons
+
+# class 3 (-> as kaon)
+K0Short 5 Kaons
+K0Long -5 Kaons
+KPlus 4 Kaons
+KMinus -4 Kaons
+
+# class 4 (-> charmed mesons, not in qgsjetII)
+D0 8 Charmed
+D0Bar -8 Charmed
+DPlus 7 Charmed
+DMinus -7 Charmed
diff --git a/tests/framework/CMakeLists.txt b/tests/framework/CMakeLists.txt
index 194438a92..21dc79b89 100644
--- a/tests/framework/CMakeLists.txt
+++ b/tests/framework/CMakeLists.txt
@@ -1,23 +1,25 @@
set (test_framework_sources
- # testCascade.cpp this is most important, but whole content of former Processes folder missing yet
- testClassTimer.cpp
- testCombinedStack.cpp
- testCOMBoost.cpp
- #testCorsikaFenv.cpp # does not work because of use of exceptions in catch2
+ TestMain.cpp
testFourVector.cpp
- testHelix.cpp
- testFunctionTimer.cpp
- testGeometry.cpp
+ testSaveBoostHistogram.cpp
+ # testSwitchProcessSequence.cpp this does only test the SwitchProcess -> removed
+ testClassTimer.cpp
testLogging.cpp
- TestMain.cpp
testParticles.cpp
- testNullModel.cpp
+ testStackInterface.cpp
testProcessSequence.cpp
- testRandom.cpp
+ testCOMBoost.cpp
+ #testCorsikaFenv.cpp # does not work because of use of exceptions in catch2
+ testFunctionTimer.cpp
testSecondaryView.cpp
- testStackInterface.cpp
+ testGeometry.cpp
+ testCombinedStack.cpp
testUnits.cpp
+ testCascade.cpp
+ testRandom.cpp
+ testNullModel.cpp
+ testHelix.cpp
)
CORSIKA_ADD_TEST (testFramework SOURCES ${test_framework_sources})
diff --git a/tests/framework/testCOMBoost.cpp b/tests/framework/testCOMBoost.cpp
index 0eb2bdebc..a96b6c0f6 100644
--- a/tests/framework/testCOMBoost.cpp
+++ b/tests/framework/testCOMBoost.cpp
@@ -12,6 +12,7 @@
#include <corsika/framework/geometry/FourVector.hpp>
#include <corsika/framework/geometry/RootCoordinateSystem.hpp>
#include <corsika/framework/geometry/Vector.hpp>
+#include <corsika/framework/geometry/PhysicalGeometry.hpp>
#include <corsika/framework/utility/COMBoost.hpp>
using namespace corsika;
@@ -25,7 +26,7 @@ CoordinateSystemPtr rootCS = get_root_CoordinateSystem();
**/
// helper function for energy-momentum
// relativistic energy
-auto const energy = [](HEPMassType m, Vector<hepmomentum_d> const& p) {
+auto const energy = [](HEPMassType m, MomentumVector const& p) {
return sqrt(m * m + p.getSquaredNorm());
};
@@ -40,13 +41,13 @@ TEST_CASE("rotation") {
// define projectile kinematics in lab frame
HEPMassType const projectileMass = 1_GeV;
HEPMassType const targetMass = 1.0e300_eV;
- Vector<hepmomentum_d> pProjectileLab{rootCS, {0_GeV, 0_PeV, 1_GeV}};
+ MomentumVector pProjectileLab{rootCS, {0_GeV, 0_PeV, 1_GeV}};
HEPEnergyType const eProjectileLab = energy(projectileMass, pProjectileLab);
FourVector const PprojLab(eProjectileLab, pProjectileLab);
- Vector<hepenergy_d> e1(rootCS, {1_GeV, 0_GeV, 0_GeV});
- Vector<hepenergy_d> e2(rootCS, {0_GeV, 1_GeV, 0_GeV});
- Vector<hepenergy_d> e3(rootCS, {0_GeV, 0_GeV, 1_GeV});
+ MomentumVector e1(rootCS, {1_GeV, 0_GeV, 0_GeV});
+ MomentumVector e2(rootCS, {0_GeV, 1_GeV, 0_GeV});
+ MomentumVector e3(rootCS, {0_GeV, 0_GeV, 1_GeV});
// define boost to com frame
SECTION("pos. z-axis") {
@@ -167,7 +168,7 @@ TEST_CASE("rotation") {
TEST_CASE("boosts") {
// define target kinematics in lab frame
HEPMassType const targetMass = 1_GeV;
- Vector<hepmomentum_d> pTargetLab{rootCS, {0_eV, 0_eV, 0_eV}};
+ MomentumVector pTargetLab{rootCS, {0_eV, 0_eV, 0_eV}};
HEPEnergyType const eTargetLab = energy(targetMass, pTargetLab);
/*
@@ -177,8 +178,8 @@ TEST_CASE("boosts") {
SECTION("General tests") {
// define projectile kinematics in lab frame
- HEPMassType const projectileMass = 1._GeV;
- Vector<hepmomentum_d> pProjectileLab{rootCS, {0_GeV, 20_GeV, 0_GeV}};
+ HEPMassType const projectileMass = 1_GeV;
+ MomentumVector pProjectileLab{rootCS, {0_GeV, 1_PeV, 0_GeV}};
HEPEnergyType const eProjectileLab = energy(projectileMass, pProjectileLab);
FourVector const PprojLab(eProjectileLab, pProjectileLab);
@@ -225,9 +226,13 @@ TEST_CASE("boosts") {
// define projectile kinematics in lab frame
HEPMassType const projectileMass = 1_GeV;
- Vector<hepmomentum_d> pProjectileLab{rootCS, {0_GeV, 0_GeV, -20_GeV}};
+ MomentumVector pProjectileLab{rootCS, {0_GeV, 0_PeV, -1_PeV}};
HEPEnergyType const eProjectileLab = energy(projectileMass, pProjectileLab);
FourVector const PprojLab(eProjectileLab, pProjectileLab);
+ const FourVector PprojLab(eProjectileLab, pProjectileLab);
+
+ auto const sqrt_s_lab =
+ sqrt(s(eProjectileLab + targetMass, pProjectileLab.GetComponents(rootCS)));
auto const sqrt_s_lab =
sqrt(s(eProjectileLab + targetMass, pProjectileLab.GetComponents(rootCS)));
@@ -270,7 +275,7 @@ TEST_CASE("boosts") {
// define projectile kinematics in lab frame
HEPMassType const projectileMass = 1_GeV;
- Vector<hepmomentum_d> pProjectileLab(rootCS, {px, py, pz});
+ MomentumVector pProjectileLab(rootCS, {px, py, pz});
HEPEnergyType const eProjectileLab = energy(projectileMass, pProjectileLab);
FourVector const PprojLab(eProjectileLab, pProjectileLab);
@@ -297,7 +302,7 @@ TEST_CASE("boosts") {
// define projectile kinematics in lab frame
HEPMassType const projectileMass = 1_GeV;
HEPMomentumType P0 = 1_ZeV;
- Vector<hepmomentum_d> pProjectileLab{rootCS, {0_GeV, 0_PeV, -P0}};
+ MomentumVector pProjectileLab{rootCS, {0_GeV, 0_PeV, -P0}};
HEPEnergyType const eProjectileLab = energy(projectileMass, pProjectileLab);
FourVector const PprojLab(eProjectileLab, pProjectileLab);
@@ -320,25 +325,25 @@ TEST_CASE("boosts") {
TEST_CASE("rest frame") {
HEPMassType const projectileMass = 1_GeV;
HEPMomentumType const P0 = 1_TeV;
- Vector<hepmomentum_d> pProjectileLab{rootCS, {0_GeV, P0, 0_GeV}};
+ MomentumVector pProjectileLab{rootCS, {0_GeV, P0, 0_GeV}};
HEPEnergyType const eProjectileLab = energy(projectileMass, pProjectileLab);
const FourVector PprojLab(eProjectileLab, pProjectileLab);
COMBoost boostRest(pProjectileLab, projectileMass);
- auto const& csPrime = boostRest.GetRotatedCS();
+ auto const& csPrime = boostRest.getRotatedCS();
FourVector const rest4Mom = boostRest.toCoM(PprojLab);
- CHECK(rest4Mom.GetTimeLikeComponent() / 1_GeV == Approx(projectileMass / 1_GeV));
- CHECK(rest4Mom.GetSpaceLikeComponents().norm() / 1_GeV == Approx(0).margin(absMargin));
+ CHECK(rest4Mom.getTimeLikeComponent() / 1_GeV == Approx(projectileMass / 1_GeV));
+ CHECK(rest4Mom.getSpaceLikeComponents().getNorm() / 1_GeV == Approx(0).margin(absMargin));
FourVector const a{0_eV, Vector{csPrime, 0_eV, 5_GeV, 0_eV}};
FourVector const b{0_eV, Vector{rootCS, 3_GeV, 0_eV, 0_eV}};
auto const aLab = boostRest.fromCoM(a);
auto const bLab = boostRest.fromCoM(b);
- CHECK(aLab.GetNorm() / a.GetNorm() == Approx(1));
- CHECK(aLab.GetSpaceLikeComponents().GetComponents(csPrime)[1].magnitude() ==
+ CHECK(aLab.getNorm() / a.getNorm() == Approx(1));
+ CHECK(aLab.getSpaceLikeComponents().getComponents(csPrime)[1].magnitude() ==
Approx((5_GeV).magnitude()));
- CHECK(bLab.GetSpaceLikeComponents().GetComponents(rootCS)[0].magnitude() ==
+ CHECK(bLab.getSpaceLikeComponents().getComponents(rootCS)[0].magnitude() ==
Approx((3_GeV).magnitude()));
}
diff --git a/tests/framework/testCascade.cpp b/tests/framework/testCascade.cpp
index 6fdbb86ab..5d5dd8b61 100644
--- a/tests/framework/testCascade.cpp
+++ b/tests/framework/testCascade.cpp
@@ -6,12 +6,12 @@
* the license.
*/
-#include <testCascade.h>
+#include <testCascade.hpp>
#include <corsika/framework/core/Cascade.hpp>
-#include <corsika/framework/sequence/ProcessSequence.hpp>
-#include <corsika/framework/sequence/NullModel.hpp>
+#include <corsika/framework/process/ProcessSequence.hpp>
+#include <corsika/framework/process/NullModel.hpp>
#include <corsika/modules/StackInspector.hpp>
#include <corsika/modules/TrackingLine.hpp>
@@ -26,100 +26,61 @@
#include <catch2/catch.hpp>
-using namespace corsika;
-using namespace corsika;
-using namespace corsika::units;
-using namespace corsika::units::si;
using namespace corsika;
#include <limits>
using namespace std;
-/**
- * testCascade implements an e.m. Heitler model with energy splitting
- * and a critical energy.
- *
- * It resembles one of the most simple cascades you can simulate with CORSIKA8.
- **/
-
-/*
- The dummy env (here) doesn't need to have any propoerties
- */
-auto MakeDummyEnv() {
+auto make_dummy_env() {
TestEnvironmentType env; // dummy environment
- auto& universe = *(env.GetUniverse());
+ auto& universe = *(env.getUniverse());
- auto world = TestEnvironmentType::CreateNode<Sphere>(
- Point{env.GetCoordinateSystem(), 0_m, 0_m, 0_m},
- 1_m * std::numeric_limits<double>::infinity());
+ auto theMedium = TestEnvironmentType::createNode<Sphere>(
+ Point{env.getCoordinateSystem(), 0_m, 0_m, 0_m},
+ 100_km * std::numeric_limits<double>::infinity());
- using MyHomogeneousModel = environment::HomogeneousMedium<environment::IMediumModel>;
- theMedium->SetModelProperties<MyHomogeneousModel>(
+ using MyHomogeneousModel = corsika::HomogeneousMedium<IMediumModel>;
+ theMedium->setModelProperties<MyHomogeneousModel>(
1_g / (1_cm * 1_cm * 1_cm),
- environment::NuclearComposition(std::vector<Code>{Code::Proton},
- std::vector<float>{1.}));
-
- universe.AddChild(std::move(world));
+ NuclearComposition(std::vector<Code>{Code::Proton}, std::vector<float>{1.}));
+ universe.addChild(std::move(theMedium));
return env;
}
-/**
- * \class DummyTracking
- *
- * For the Heitler model we don't need particle transport.
- **/
-class DummyTracking {
-
-public:
- template <typename TParticle>
- auto GetTrack(TParticle const& particle) {
- using namespace corsika::units::si;
- using namespace corsika::geometry;
- geometry::Vector<SpeedType::dimension_type> const initialVelocity =
- particle.GetMomentum() / particle.GetEnergy() * corsika::units::constants::c;
- return std::make_tuple(
- geometry::LineTrajectory(
- geometry::Line(particle.GetPosition(), initialVelocity),
- std::numeric_limits<TimeType::value_type>::infinity() * 1_s), // trajectory,
- // just
- // go
- // ahead
- // forever
- particle.GetNode()); // next volume node
- }
-};
-
-class ProcessSplit : public process::InteractionProcess<ProcessSplit> {
+class ProcessSplit : public InteractionProcess<ProcessSplit> {
- int fCalls = 0;
+ int calls_ = 0;
+ GrammageType X0_;
public:
+ ProcessSplit(GrammageType const X0)
+ : X0_(X0) {}
+
template <typename Particle>
- corsika::units::si::GrammageType GetInteractionLength(Particle const&) const {
- return 0_g / square(1_cm);
+ GrammageType getInteractionLength(Particle const&) const {
+ return X0_;
}
- template <typename TProjectile>
- corsika::EProcessReturn DoInteraction(TProjectile& vP) {
- fCalls++;
- const HEPEnergyType E = vP.GetEnergy();
- vP.AddSecondary(std::tuple<Code, units::si::HEPEnergyType, corsika::MomentumVector,
- geometry::Point, units::si::TimeType>{
- vP.GetPID(), E / 2, vP.GetMomentum(), vP.GetPosition(), vP.GetTime()});
- vP.AddSecondary(std::tuple<Code, units::si::HEPEnergyType, corsika::MomentumVector,
- geometry::Point, units::si::TimeType>{
- vP.GetPID(), E / 2, vP.GetMomentum(), vP.GetPosition(), vP.GetTime()});
- return EProcessReturn::eInteracted;
+ template <typename TView>
+ ProcessReturn doInteraction(TView& view) {
+ calls_++;
+ auto vP = view.getProjectile();
+ const HEPEnergyType E = vP.getEnergy();
+ vP.addSecondary(std::make_tuple(vP.getPID(), E / 2, vP.getMomentum(),
+ vP.getPosition(), vP.getTime()));
+ vP.addSecondary(std::make_tuple(vP.getPID(), E / 2, vP.getMomentum(),
+ vP.getPosition(), vP.getTime()));
+ return ProcessReturn::Interacted;
}
- int GetCalls() const { return fCalls; }
+ int getCalls() const { return calls_; }
};
-class ProcessCut : public process::SecondariesProcess<ProcessCut> {
+class ProcessCut : public SecondariesProcess<ProcessCut> {
- int fCount = 0;
- int fCalls = 0;
+ int count_ = 0;
+ int calls_ = 0;
HEPEnergyType fEcrit;
public:
@@ -127,24 +88,24 @@ public:
: fEcrit(e) {}
template <typename TStack>
- EProcessReturn DoSecondaries(TStack& vS) {
- fCalls++;
+ void doSecondaries(TStack& vS) {
+ calls_++;
auto p = vS.begin();
while (p != vS.end()) {
- HEPEnergyType E = p.GetEnergy();
+ HEPEnergyType E = p.getEnergy();
if (E < fEcrit) {
- p.Delete();
- fCount++;
+ p.erase();
+ count_++;
}
++p; // next particle
}
- C8LOG_INFO(fmt::format("ProcessCut::DoSecondaries size={} count={}", vS.getEntries(),
- fCount));
- return EProcessReturn::eOk;
+ CORSIKA_LOG_INFO(fmt::format("ProcessCut::doSecondaries size={} count={}",
+ vS.getEntries(), count_));
+
}
- int GetCount() const { return fCount; }
- int GetCalls() const { return fCalls; }
+ int getCount() const { return count_; }
+ int getCalls() const { return calls_; }
};
TEST_CASE("Cascade", "[Cascade]") {
@@ -153,41 +114,43 @@ TEST_CASE("Cascade", "[Cascade]") {
HEPEnergyType E0 = 100_GeV;
- random::RNGManager& rmng = random::RNGManager::getInstance();
+ RNGManager& rmng = RNGManager::getInstance();
rmng.registerRandomStream("cascade");
- auto env = MakeDummyEnv();
- auto const& rootCS = env.GetCoordinateSystem();
+ auto env = make_dummy_env();
+ auto const& rootCS = env.getCoordinateSystem();
+ tracking_line::TrackingLine tracking;
stack_inspector::StackInspector<TestCascadeStack> stackInspect(1, true, E0);
- process::NullModel nullModel;
+ NullModel nullModel;
const HEPEnergyType Ecrit = 85_MeV;
ProcessSplit split;
ProcessCut cut(Ecrit);
- auto sequence = process::sequence(nullModel, stackInspect, split, cut);
+ auto sequence = make_sequence(nullModel, stackInspect, split, cut);
TestCascadeStack stack;
- stack.Clear();
- stack.AddParticle(std::tuple<Code, units::si::HEPEnergyType, corsika::MomentumVector,
- geometry::Point, units::si::TimeType>{
- Code::Electron, E0, corsika::MomentumVector(rootCS, {0_GeV, 0_GeV, -1_GeV}),
- Point(rootCS, {0_m, 0_m, 10_km}), 0_ns});
-
- cascade::Cascade<tracking_line::TrackingLine, decltype(sequence), TestCascadeStack,
- TestCascadeStackView>
+ stack.clear();
+ stack.addParticle(std::make_tuple(Code::Electron, E0,
+ MomentumVector(rootCS, {0_GeV, 0_GeV, -1_GeV}),
+ Point(rootCS, {0_m, 0_m, 10_km}), 0_ns));
+
+ Cascade<tracking_line::TrackingLine, decltype(sequence), TestCascadeStack,
+ TestCascadeStackView>
EAS(env, tracking, sequence, stack);
SECTION("full cascade") {
- EAS.Run();
+ EAS.run();
- CHECK(cut.GetCount() == 2048);
- CHECK(cut.GetCalls() == 2047); // final particle is still on stack and not yet deleted
- CHECK(split.GetCalls() == 2047);
+ CHECK(cut.getCount() == 2048);
+ CHECK(cut.getCalls() == 2047);
+ CHECK(split.getCalls() == 2047);
}
SECTION("forced interaction") {
+ EAS.setNodes();
EAS.forceInteraction();
CHECK(stack.getEntries() == 2);
- CHECK(split.GetCalls() == 1);
+ CHECK(stack.getSize() == 3);
+ CHECK(split.getCalls() == 1);
}
}
diff --git a/tests/framework/testCascade.hpp b/tests/framework/testCascade.hpp
index 85863e03c..571584ee8 100644
--- a/tests/framework/testCascade.hpp
+++ b/tests/framework/testCascade.hpp
@@ -9,23 +9,27 @@
#pragma once
#include <corsika/media/Environment.hpp>
-#include <corsika/setup/SetupStack.hpp>
+
+#include <corsika/framework/stack/CombinedStack.hpp>
+#include <corsika/framework/stack/SecondaryView.hpp>
+#include <corsika/stack/GeometryNodeStackExtension.hpp>
+#include <corsika/stack/NuclearStackExtension.hpp>
using TestEnvironmentType = corsika::Environment<corsika::IMediumModel>;
template <typename T>
using SetupGeometryDataInterface =
- corsika::stack::node::GeometryDataInterface<T, TestEnvironmentType>;
+ corsika::node::GeometryDataInterface<T, TestEnvironmentType>;
// combine particle data stack with geometry information for tracking
template <typename StackIter>
using StackWithGeometryInterface =
- corsika::CombinedParticleInterface<corsika::setup::detail::ParticleDataStack::PIType,
+ corsika::CombinedParticleInterface<corsika::nuclear_stack::ParticleDataStack::pi_type,
SetupGeometryDataInterface, StackIter>;
-using TestCascadeStack =
- corsika::CombinedStack<typename corsika::setup::detail::ParticleDataStack::StackImpl,
- GeometryData<TestEnvironmentType>, StackWithGeometryInterface>;
+using TestCascadeStack = corsika::CombinedStack<
+ typename corsika::nuclear_stack::ParticleDataStack::stack_implementation_type,
+ corsika::node::GeometryData<TestEnvironmentType>, StackWithGeometryInterface>;
/*
See also Issue 161
diff --git a/tests/framework/testGeometry.cpp b/tests/framework/testGeometry.cpp
index 6d197f2c8..d1bc4bdc5 100644
--- a/tests/framework/testGeometry.cpp
+++ b/tests/framework/testGeometry.cpp
@@ -12,6 +12,7 @@
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/geometry/CoordinateSystem.hpp>
#include <corsika/framework/geometry/Line.hpp>
+#include <corsika/framework/geometry/Helix.hpp>
#include <corsika/framework/geometry/Point.hpp>
#include <corsika/framework/geometry/RootCoordinateSystem.hpp>
#include <corsika/framework/geometry/Sphere.hpp>
@@ -70,10 +71,10 @@ TEST_CASE("transformations between CoordinateSystems") {
CHECK(cs4->getReferenceCS()->getReferenceCS() == rootCS);
- CHECK(get_transformation(*cs3.get(), *cs2.get()).isApprox(
- make_translation(rootCS, {3_m, -5_m, 0_m})->getTransform()));
- CHECK(get_transformation(*cs2.get(), *cs3.get()).isApprox(
- make_translation(rootCS, {-3_m, +5_m, 0_m})->getTransform()));
+ CHECK(get_transformation(*cs3.get(), *cs2.get())
+ .isApprox(make_translation(rootCS, {3_m, -5_m, 0_m})->getTransform()));
+ CHECK(get_transformation(*cs2.get(), *cs3.get())
+ .isApprox(make_translation(rootCS, {-3_m, +5_m, 0_m})->getTransform()));
}
SECTION("rotations") {
@@ -240,7 +241,8 @@ TEST_CASE("CoordinateSystem hirarchy") {
CoordinateSystemPtr rootCS = get_root_CoordinateSystem();
- CHECK(get_transformation(*rootCS.get(), *rootCS.get()).isApprox(EigenTransform::Identity()));
+ CHECK(get_transformation(*rootCS.get(), *rootCS.get())
+ .isApprox(EigenTransform::Identity()));
// define the root coordinate system
CoordinateSystemPtr root = get_root_CoordinateSystem();
@@ -270,7 +272,8 @@ TEST_CASE("CoordinateSystem hirarchy") {
// all points should be on top of each other
- CHECK_FALSE(get_transformation(*root.get(), *cs2.get()).isApprox(EigenTransform::Identity()));
+ CHECK_FALSE(
+ get_transformation(*root.get(), *cs2.get()).isApprox(EigenTransform::Identity()));
CHECK(get_transformation(*root.get(), *cs3.get()).isApprox(EigenTransform::Identity()));
CHECK(get_transformation(*root.get(), *cs4.get()).isApprox(EigenTransform::Identity()));
CHECK(get_transformation(*cs5.get(), *cs6.get()).isApprox(EigenTransform::Identity()));
@@ -333,6 +336,40 @@ TEST_CASE("Trajectories") {
CHECK((base.getNormalizedDirection().getComponents(rootCS) -
QuantityVector<dimensionless_d>{1, 0, 0})
- .getNorm() == Approx(0).margin(absMargin));
+ .getNorm() == Approx(0).margin(absMargin));
+ }
+
+ SECTION("Helix") {
+ Vector<SpeedType::dimension_type> const vPar(
+ rootCS, {0_m / second, 0_m / second, 4_m / second});
+
+ Vector<SpeedType::dimension_type> const vPerp(
+ rootCS, {3_m / second, 0_m / second, 0_m / second});
+
+ auto const T = 1_s;
+ auto const omegaC = 2 * M_PI / T;
+
+ Helix const helix(r0, omegaC, vPar, vPerp);
+
+ CHECK((helix.getPosition(1_s).getCoordinates() -
+ QuantityVector<length_d>(0_m, 0_m, 4_m))
+ .getNorm()
+ .magnitude() == Approx(0).margin(absMargin));
+
+ CHECK((helix.getPosition(0.25_s).getCoordinates() -
+ QuantityVector<length_d>(-3_m / (2 * M_PI), -3_m / (2 * M_PI), 1_m))
+ .getNorm()
+ .magnitude() == Approx(0).margin(absMargin));
+
+ CHECK((helix.getPosition(7_s) -
+ helix.getPositionFromArclength(helix.getArcLength(0_s, 7_s)))
+ .getNorm()
+ .magnitude() == Approx(0).margin(absMargin));
+
+ auto const t = 1234_s;
+ Trajectory<Helix> const base(helix, t);
+ CHECK(helix.getPosition(t).getCoordinates() == base.getPosition(1.).getCoordinates());
+
+ CHECK(base.getArcLength(0_s, 1_s) / 1_m == Approx(5));
}
}
diff --git a/tests/framework/testParticles.cpp b/tests/framework/testParticles.cpp
index ae7784cba..6f63172fe 100644
--- a/tests/framework/testParticles.cpp
+++ b/tests/framework/testParticles.cpp
@@ -16,128 +16,131 @@ using namespace corsika;
TEST_CASE("ParticleProperties", "[Particles]") {
SECTION("Types") {
- REQUIRE(Electron::code == Code::Electron);
- REQUIRE(Positron::code == Code::Positron);
- REQUIRE(Proton::code == Code::Proton);
- REQUIRE(Neutron::code == Code::Neutron);
- REQUIRE(Gamma::code == Code::Gamma);
- REQUIRE(PiPlus::code == Code::PiPlus);
+ CHECK(Electron::code == Code::Electron);
+ CHECK(Positron::code == Code::Positron);
+ CHECK(Proton::code == Code::Proton);
+ CHECK(Neutron::code == Code::Neutron);
+ CHECK(Gamma::code == Code::Gamma);
+ CHECK(PiPlus::code == Code::PiPlus);
}
SECTION("Masses") {
- REQUIRE(Electron::mass / (511_keV) == Approx(1));
- REQUIRE(Electron::mass / get_mass(Code::Electron) == 1.);
+ CHECK(Electron::mass / (511_keV) == Approx(1));
+ CHECK(Electron::mass / get_mass(Code::Electron) == 1.);
- REQUIRE((Proton::mass + Neutron::mass) / constants::nucleonMass == Approx(2));
+ CHECK((Proton::mass + Neutron::mass) / constants::nucleonMass == Approx(2));
}
SECTION("Charges") {
- REQUIRE(Electron::charge / constants::e == Approx(-1));
- REQUIRE(Positron::charge / constants::e == Approx(+1));
- REQUIRE(get_charge(Positron::anti_code) / constants::e == Approx(-1));
+ CHECK(Electron::charge / constants::e == Approx(-1));
+ CHECK(Positron::charge / constants::e == Approx(+1));
+ CHECK(get_charge(Positron::anti_code) / constants::e == Approx(-1));
}
SECTION("Names") {
- REQUIRE(Electron::name == "e-");
- REQUIRE(get_name(Code::Electron) == "e-");
- REQUIRE(PiMinus::name == "pi-");
- REQUIRE(Iron::name == "iron");
+ CHECK(Electron::name == "e-");
+ CHECK(get_name(Code::Electron) == "e-");
+ CHECK(PiMinus::name == "pi-");
+ CHECK(Iron::name == "iron");
}
SECTION("PDG") {
- REQUIRE(get_PDG(Code::PiPlus) == PDGCode::PiPlus);
- REQUIRE(get_PDG(Code::DPlus) == PDGCode::DPlus);
- REQUIRE(get_PDG(Code::NuMu) == PDGCode::NuMu);
- REQUIRE(get_PDG(Code::NuE) == PDGCode::NuE);
- REQUIRE(get_PDG(Code::MuMinus) == PDGCode::MuMinus);
-
- REQUIRE(static_cast<int>(get_PDG(Code::PiPlus)) == 211);
- REQUIRE(static_cast<int>(get_PDG(Code::DPlus)) == 411);
- REQUIRE(static_cast<int>(get_PDG(Code::NuMu)) == 14);
- REQUIRE(static_cast<int>(get_PDG(Code::NuEBar)) == -12);
- REQUIRE(static_cast<int>(get_PDG(Code::MuMinus)) == 13);
+ CHECK(get_PDG(Code::PiPlus) == PDGCode::PiPlus);
+ CHECK(get_PDG(Code::DPlus) == PDGCode::DPlus);
+ CHECK(get_PDG(Code::NuMu) == PDGCode::NuMu);
+ CHECK(get_PDG(Code::NuE) == PDGCode::NuE);
+ CHECK(get_PDG(Code::MuMinus) == PDGCode::MuMinus);
+
+ CHECK(static_cast<int>(get_PDG(Code::PiPlus)) == 211);
+ CHECK(static_cast<int>(get_PDG(Code::DPlus)) == 411);
+ CHECK(static_cast<int>(get_PDG(Code::NuMu)) == 14);
+ CHECK(static_cast<int>(get_PDG(Code::NuEBar)) == -12);
+ CHECK(static_cast<int>(get_PDG(Code::MuMinus)) == 13);
}
SECTION("Conversion PDG -> internal") {
- REQUIRE(convert_from_PDG(PDGCode::KStarMinus) == Code::KStarMinus);
- REQUIRE(convert_from_PDG(PDGCode::MuPlus) == Code::MuPlus);
- REQUIRE(convert_from_PDG(PDGCode::SigmaStarCMinusBar) == Code::SigmaStarCMinusBar);
+ CHECK(convert_from_PDG(PDGCode::KStarMinus) == Code::KStarMinus);
+ CHECK(convert_from_PDG(PDGCode::MuPlus) == Code::MuPlus);
+ CHECK(convert_from_PDG(PDGCode::SigmaStarCMinusBar) == Code::SigmaStarCMinusBar);
}
SECTION("Lifetimes") {
- REQUIRE(get_lifetime(Code::Electron) ==
+ CHECK(get_lifetime(Code::Electron) ==
std::numeric_limits<double>::infinity() * si::second);
- REQUIRE(get_lifetime(Code::DPlus) < get_lifetime(Code::Gamma));
- REQUIRE(get_lifetime(Code::RhoPlus) / si::second ==
+ CHECK(get_lifetime(Code::DPlus) < get_lifetime(Code::Gamma));
+ CHECK(get_lifetime(Code::RhoPlus) / si::second ==
(Approx(4.414566727909413e-24).epsilon(1e-3)));
- REQUIRE(get_lifetime(Code::SigmaMinusBar) / si::second ==
+ CHECK(get_lifetime(Code::SigmaMinusBar) / si::second ==
(Approx(8.018880848563575e-11).epsilon(1e-5)));
- REQUIRE(get_lifetime(Code::MuPlus) / si::second ==
+ CHECK(get_lifetime(Code::MuPlus) / si::second ==
(Approx(2.1970332555864364e-06).epsilon(1e-5)));
}
SECTION("Particle groups: electromagnetic") {
- REQUIRE(is_em(Code::Gamma));
- REQUIRE(is_em(Code::Electron));
- REQUIRE_FALSE(is_em(Code::MuPlus));
- REQUIRE_FALSE(is_em(Code::NuE));
- REQUIRE_FALSE(is_em(Code::Proton));
- REQUIRE_FALSE(is_em(Code::PiPlus));
- REQUIRE_FALSE(is_em(Code::Oxygen));
+ CHECK(is_em(Code::Gamma));
+ CHECK(is_em(Code::Electron));
+ CHECK_FALSE(is_em(Code::MuPlus));
+ CHECK_FALSE(is_em(Code::NuE));
+ CHECK_FALSE(is_em(Code::Proton));
+ CHECK_FALSE(is_em(Code::PiPlus));
+ CHECK_FALSE(is_em(Code::Oxygen));
}
SECTION("Particle groups: hadrons") {
- REQUIRE_FALSE(is_hadron(Code::Gamma));
- REQUIRE_FALSE(is_hadron(Code::Electron));
- REQUIRE_FALSE(is_hadron(Code::MuPlus));
- REQUIRE_FALSE(is_hadron(Code::NuE));
- REQUIRE(is_hadron(Code::Proton));
- REQUIRE(is_hadron(Code::PiPlus));
- REQUIRE(is_hadron(Code::Oxygen));
- REQUIRE(is_hadron(Code::Nucleus));
+ CHECK_FALSE(is_hadron(Code::Gamma));
+ CHECK_FALSE(is_hadron(Code::Electron));
+ CHECK_FALSE(is_hadron(Code::MuPlus));
+ CHECK_FALSE(is_hadron(Code::NuE));
+ CHECK(is_hadron(Code::Proton));
+ CHECK(is_hadron(Code::PiPlus));
+ CHECK(is_hadron(Code::Oxygen));
+ CHECK(is_hadron(Code::Nucleus));
}
SECTION("Particle groups: muons") {
- REQUIRE_FALSE(is_muon(Code::Gamma));
- REQUIRE_FALSE(is_muon(Code::Electron));
- REQUIRE(is_muon(Code::MuPlus));
- REQUIRE(is_muon(Code::MuMinus));
- REQUIRE_FALSE(is_muon(Code::NuE));
- REQUIRE_FALSE(is_muon(Code::Proton));
- REQUIRE_FALSE(is_muon(Code::PiPlus));
- REQUIRE_FALSE(is_muon(Code::Oxygen));
+ CHECK_FALSE(is_muon(Code::Gamma));
+ CHECK_FALSE(is_muon(Code::Electron));
+ CHECK(is_muon(Code::MuPlus));
+ CHECK(is_muon(Code::MuMinus));
+ CHECK_FALSE(is_muon(Code::NuE));
+ CHECK_FALSE(is_muon(Code::Proton));
+ CHECK_FALSE(is_muon(Code::PiPlus));
+ CHECK_FALSE(is_muon(Code::Oxygen));
}
SECTION("Particle groups: neutrinos") {
- REQUIRE_FALSE(is_neutrino(Code::Gamma));
- REQUIRE_FALSE(is_neutrino(Code::Electron));
- REQUIRE_FALSE(is_neutrino(Code::MuPlus));
- REQUIRE_FALSE(is_neutrino(Code::Proton));
- REQUIRE_FALSE(is_neutrino(Code::PiPlus));
- REQUIRE_FALSE(is_neutrino(Code::Oxygen));
-
- REQUIRE(is_neutrino(Code::NuE));
- REQUIRE(is_neutrino(Code::NuMu));
- REQUIRE(is_neutrino(Code::NuTau));
- REQUIRE(is_neutrino(Code::NuEBar));
- REQUIRE(is_neutrino(Code::NuMuBar));
- REQUIRE(is_neutrino(Code::NuTauBar));
+ CHECK_FALSE(is_neutrino(Code::Gamma));
+ CHECK_FALSE(is_neutrino(Code::Electron));
+ CHECK_FALSE(is_neutrino(Code::MuPlus));
+ CHECK_FALSE(is_neutrino(Code::Proton));
+ CHECK_FALSE(is_neutrino(Code::PiPlus));
+ CHECK_FALSE(is_neutrino(Code::Oxygen));
+
+ CHECK(is_neutrino(Code::NuE));
+ CHECK(is_neutrino(Code::NuMu));
+ CHECK(is_neutrino(Code::NuTau));
+ CHECK(is_neutrino(Code::NuEBar));
+ CHECK(is_neutrino(Code::NuMuBar));
+ CHECK(is_neutrino(Code::NuTauBar));
}
SECTION("Nuclei") {
- REQUIRE_FALSE(is_nucleus(Code::Gamma));
- REQUIRE(is_nucleus(Code::Argon));
- REQUIRE_FALSE(is_nucleus(Code::Proton));
- REQUIRE(is_nucleus(Code::Hydrogen));
- REQUIRE(Argon::is_nucleus);
- REQUIRE_FALSE(EtaC::is_nucleus);
-
- REQUIRE(get_nucleus_A(Code::Hydrogen) == 1);
- REQUIRE(get_nucleus_A(Code::Tritium) == 3);
- REQUIRE(Hydrogen::nucleus_Z == 1);
- REQUIRE(Tritium::nucleus_A == 3);
-
- REQUIRE_THROWS(get_nucleus_Z(Code::Nucleus));
- REQUIRE_THROWS(get_nucleus_A(Code::Nucleus));
+ CHECK_FALSE(is_nucleus(Code::Gamma));
+ CHECK(is_nucleus(Code::Argon));
+ CHECK_FALSE(is_nucleus(Code::Proton));
+ CHECK(is_nucleus(Code::Hydrogen));
+ CHECK(Argon::is_nucleus);
+ CHECK_FALSE(EtaC::is_nucleus);
+
+ CHECK(get_nucleus_A(Code::Hydrogen) == 1);
+ CHECK(get_nucleus_A(Code::Tritium) == 3);
+ CHECK(Hydrogen::nucleus_Z == 1);
+ CHECK(Tritium::nucleus_A == 3);
+
+ // Nucleus is a generic object, it has no specific properties
+ CHECK_THROWS(get_nucleus_Z(Code::Nucleus));
+ CHECK_THROWS(get_nucleus_A(Code::Nucleus));
+ CHECK_THROWS(get_mass(Code::Nucleus));
+ CHECK_THROWS(get_charge(Code::Nucleus));
}
}
diff --git a/tests/framework/testSaveBoostHistogram.cpp b/tests/framework/testSaveBoostHistogram.cpp
index b825816fe..7058811b0 100644
--- a/tests/framework/testSaveBoostHistogram.cpp
+++ b/tests/framework/testSaveBoostHistogram.cpp
@@ -7,7 +7,7 @@
*/
#include <catch2/catch.hpp>
-#include <corsika/utl/SaveBoostHistogram.hpp>
+#include <corsika/framework/utility/SaveBoostHistogram.hpp>
#include <random>
diff --git a/tests/media/CMakeLists.txt b/tests/media/CMakeLists.txt
index e366e73fa..292b5793e 100644
--- a/tests/media/CMakeLists.txt
+++ b/tests/media/CMakeLists.txt
@@ -1,9 +1,10 @@
set (test_media_sources
TestMain.cpp
- testMedium.cpp
testEnvironment.cpp
- testRefractiveIndex.cpp
testShowerAxis.cpp
+ testMedium.cpp
+ testRefractiveIndex.cpp
+ testMagneticField.cpp
)
CORSIKA_ADD_TEST (testMedia SOURCES ${test_media_sources})
diff --git a/tests/media/testEnvironment.cpp b/tests/media/testEnvironment.cpp
index 43ed6524f..d34c59490 100644
--- a/tests/media/testEnvironment.cpp
+++ b/tests/media/testEnvironment.cpp
@@ -14,7 +14,13 @@
#include <corsika/media/DensityFunction.hpp>
#include <corsika/media/FlatExponential.hpp>
#include <corsika/media/HomogeneousMedium.hpp>
+#include <corsika/media/MediumPropertyModel.hpp>
+#include <corsika/media/UniformMagneticField.hpp>
+#include <corsika/media/UniformRefractiveIndex.hpp>
#include <corsika/media/IMediumModel.hpp>
+#include <corsika/media/IMediumPropertyModel.hpp>
+#include <corsika/media/IMagneticFieldModel.hpp>
+#include <corsika/media/IRefractiveIndexModel.hpp>
#include <corsika/media/InhomogeneousMedium.hpp>
#include <corsika/media/LayeredSphericalAtmosphereBuilder.hpp>
#include <corsika/media/LinearApproximationIntegrator.hpp>
@@ -193,7 +199,11 @@ TEST_CASE("InhomogeneousMedium") {
}
TEST_CASE("LayeredSphericalAtmosphereBuilder") {
- LayeredSphericalAtmosphereBuilder builder(gOrigin);
+
+ LayeredSphericalAtmosphereBuilder builder =
+ make_layered_spherical_atmosphere_builder<>::create(gOrigin,
+ constants::EarthRadius::Mean);
+
builder.setNuclearComposition({{{Code::Nitrogen, Code::Oxygen}}, {{.6, .4}}});
builder.addLinearLayer(1_km, 10_km);
@@ -207,8 +217,7 @@ TEST_CASE("LayeredSphericalAtmosphereBuilder") {
CHECK(builder.getSize() == 0);
- // the end time of our line
- auto const tEnd = 1_s;
+ auto const R = builder.getEarthRadius();
CHECK(univ->getChildNodes().size() == 1);
@@ -223,3 +232,45 @@ TEST_CASE("LayeredSphericalAtmosphereBuilder") {
univ->getContainingNode(Point(gCS, 0_m, 0_m, R + 24_km))->getVolume())
.getRadius() == R + 30_km);
}
+
+TEST_CASE("LayeredSphericalAtmosphereBuilder w/ magnetic field") {
+ // setup our interface types
+ using ModelInterface = IMagneticFieldModel<IMediumModel>;
+
+ // the composition we use for the homogenous medium
+ NuclearComposition const protonComposition(std::vector<Code>{Code::Proton},
+ std::vector<float>{1.f});
+
+ // create magnetic field vectors
+ Vector B0(gCS, 0_T, 0_T, 1_T);
+
+ LayeredSphericalAtmosphereBuilder builder = make_layered_spherical_atmosphere_builder<
+ ModelInterface, UniformMagneticField>::create(gOrigin, constants::EarthRadius::Mean,
+ B0);
+
+ builder.setNuclearComposition({{{Code::Nitrogen, Code::Oxygen}}, {{.6, .4}}});
+ builder.addLinearLayer(1_km, 10_km);
+ builder.addExponentialLayer(1222.6562_g / (1_cm * 1_cm), 994186.38_cm, 20_km);
+
+ CHECK(builder.getSize() == 2);
+
+ auto const builtEnv = builder.assemble();
+ auto const& univ = builtEnv.getUniverse();
+
+ CHECK(builder.getSize() == 0);
+ CHECK(univ->getChildNodes().size() == 1);
+ auto const R = builder.getEarthRadius();
+
+ // check magnetic field at several locations
+ const Point pTest(gCS, -10_m, 4_m, R + 35_m);
+ CHECK(B0.getComponents(gCS) == univ->getContainingNode(pTest)
+ ->getModelProperties()
+ .getMagneticField(pTest)
+ .getComponents(gCS));
+ const Point pTest2(gCS, 10_m, -4_m, R + 15_km);
+ CHECK(B0.getComponents(gCS) == univ->getContainingNode(pTest2)
+ ->getModelProperties()
+ .getMagneticField(pTest2)
+ .getComponents(gCS));
+}
+
diff --git a/tests/media/testMedium.cpp b/tests/media/testMedium.cpp
index d658d7c31..09c4af17f 100644
--- a/tests/media/testMedium.cpp
+++ b/tests/media/testMedium.cpp
@@ -21,7 +21,22 @@
#include <catch2/catch.hpp>
using namespace corsika;
-using namespace corsika::units::si;
+
+TEST_CASE("MediumProperties") {
+
+ // test access of medium properties via enum and class types
+
+ const Medium type = Medium::AirDry1Atm;
+ const MediumData& air = mediumData(type);
+ CHECK(air.getIeff() == 85.7);
+ CHECK(air.getCbar() == 10.5961);
+ CHECK(air.getX0() == 1.7418);
+ CHECK(air.getX1() == 4.2759);
+ CHECK(air.getAA() == 0.10914);
+ CHECK(air.getSK() == 3.3994);
+ CHECK(air.getDlt0() == 0.0);
+}
+
TEST_CASE("MediumPropertyModel w/ Homogeneous") {
diff --git a/tests/modules/CMakeLists.txt b/tests/modules/CMakeLists.txt
index 0e79964a9..07caeb442 100644
--- a/tests/modules/CMakeLists.txt
+++ b/tests/modules/CMakeLists.txt
@@ -1,16 +1,20 @@
set (test_modules_sources
TestMain.cpp
- testSibyll.cpp
- testNullModel.cpp
- testObservationPlane.cpp
- testParticleCut.cpp
- testPythia8.cpp
+# ${CORSIKA_DATA}/readLib/source/testData.cc
+ #testStackInspector.cpp
+ #testTrackingLine.cpp
+ #testInteractionCounter.cpp
+ #testExecTime.cpp
+ #testObservationPlane.cpp
testQGSJetII.cpp
- testStackInspector.cpp
-# FIXME, remove entirly during migration: testSwitchProcess.cpp
- testTrackingLine.cpp
- testUrQMD.cpp
+ # testSwitchProcess.cpp -> gone
+ # testPythia8.cpp
+ #testUrQMD.cpp
+ #testCONEXSourceCut.cpp
+ #testOnShellCheck.cpp
+ testParticleCut.cpp
+ testSibyll.cpp
+ # testNullModel.cpp -> gone
)
CORSIKA_ADD_TEST (testModules SOURCES ${test_modules_sources})
-
diff --git a/tests/modules/testObservationPlane.cpp b/tests/modules/testObservationPlane.cpp
index c6f9adb5f..63f5ea337 100644
--- a/tests/modules/testObservationPlane.cpp
+++ b/tests/modules/testObservationPlane.cpp
@@ -58,7 +58,6 @@ TEST_CASE("ContinuousProcess interface", "[proccesses][observation_plane]") {
Vector<dimensionless_d>(rootCS, {0., 0., 1.}));
ObservationPlane obs(obsPlane, "particles.dat", true);
- obs.Init();
const LengthType length = obs.MaxStepLength(particle, track);
const ProcessReturn ret = obs.doContinuous(particle, track);
@@ -80,7 +79,6 @@ TEST_CASE("ContinuousProcess interface", "[proccesses][observation_plane]") {
Vector<dimensionless_d>(rootCS, {0., 0., 1.}));
ObservationPlane obs(obsPlane, "particles.dat", false);
- obs.Init();
const LengthType length = obs.MaxStepLength(particle, track);
const ProcessReturn ret = obs.doContinuous(particle, track);
diff --git a/tests/modules/testParticleCut.cpp b/tests/modules/testParticleCut.cpp
index 8cbab762d..06bf73d5d 100644
--- a/tests/modules/testParticleCut.cpp
+++ b/tests/modules/testParticleCut.cpp
@@ -21,81 +21,166 @@
using namespace corsika;
using namespace corsika::particle_cut;
-using namespace corsika::units::si;
TEST_CASE("ParticleCut", "[processes]") {
feenableexcept(FE_INVALID);
- using EnvType = corsika::Environment<setup::IEnvironmentModel>;
+ using EnvType = setup::Environment;
+
EnvType env;
- const corsika::CoordinateSystem& rootCS = env.GetCoordinateSystem();
+ CoordinateSystemPtr const& rootCS = env.getCoordinateSystem();
// setup empty particle stack
setup::Stack stack;
- stack.Clear();
+ stack.clear();
// two energies
- const HEPEnergyType Eabove = 1_TeV;
- const HEPEnergyType Ebelow = 10_GeV;
+ HEPEnergyType const Eabove = 1_TeV;
+ HEPEnergyType const Ebelow = 10_GeV;
// list of arbitrary particles
- std::vector<corsika::Code> particleList = {
- corsika::Code::PiPlus, corsika::Code::PiMinus, corsika::Code::KPlus,
- corsika::Code::KMinus, corsika::Code::K0Long, corsika::Code::K0Short,
- corsika::Code::Electron, corsika::Code::MuPlus, corsika::Code::NuE,
- corsika::Code::Neutron};
+ std::vector<Code> const particleList = {
+ Code::PiPlus, Code::PiMinus, Code::KPlus,
+ Code::KMinus, Code::K0Long, Code::K0Short,
+ Code::Electron, Code::MuPlus, Code::NuE,
+ Code::Neutron, Code::NuMu};
+
+ // common stating point
+ const Point point0(rootCS, 0_m, 0_m, 0_m);
- SECTION("cut on particle type") {
+ SECTION("cut on particle type: inv") {
- ParticleCut cut(20_GeV);
+ ParticleCut cut(20_GeV, false, true);
+ CHECK(cut.getECut() == 20_GeV);
// add primary particle to stack
- auto particle = stack.AddParticle(
- std::tuple<corsika::Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{
- corsika::Code::Proton, Eabove,
- corsika::MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
- corsika::Point(rootCS, 0_m, 0_m, 0_m), 0_ns});
+ auto particle = stack.addParticle(std::make_tuple(
+ Code::Proton, Eabove, MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
+ Point(rootCS, 0_m, 0_m, 0_m), 0_ns));
// view on secondary particles
- corsika::SecondaryView view(particle);
+ SecondaryView view(particle);
// ref. to primary particle through the secondary view.
// only this way the secondary view is populated
- auto projectile = view.GetProjectile();
+ auto projectile = view.getProjectile();
// add secondaries, all with energies above the threshold
// only cut is by species
for (auto proType : particleList)
- projectile.AddSecondary(
- std::tuple<corsika::Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{
- proType, Eabove, corsika::MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
- corsika::Point(rootCS, 0_m, 0_m, 0_m), 0_ns});
+ projectile.addSecondary(std::make_tuple(
+ proType, Eabove, MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}), point0, 0_ns));
+ CHECK(view.getEntries() == 11);
+ CHECK(stack.getEntries() == 12);
+
+ cut.doSecondaries(view);
+
+ CHECK(view.getEntries() == 9);
+ CHECK(cut.getNumberInvParticles() == 2);
+ CHECK(cut.getInvEnergy() / 1_GeV == 2000);
+ }
+
+ SECTION("cut on particle type: em") {
+
+ ParticleCut cut(20_GeV, true, false);
+ // add primary particle to stack
+ auto particle = stack.addParticle(
+ std::make_tuple(Code::Proton, Eabove,
+ MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}), point0, 0_ns));
+ // view on secondary particles
+ setup::StackView view(particle);
+ // ref. to primary particle through the secondary view.
+ // only this way the secondary view is populated
+ auto projectile = view.getProjectile();
+ // add secondaries, all with energies above the threshold
+ // only cut is by species
+ for (auto proType : particleList) {
+ projectile.addSecondary(std::make_tuple(
+ proType, Eabove, MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}), point0, 0_ns));
+ }
cut.doSecondaries(view);
- REQUIRE(view.GetSize() == 8);
+ CHECK(view.getEntries() == 10);
+ CHECK(cut.getNumberEmParticles() == 1);
+ CHECK(cut.getEmEnergy() / 1_GeV == 1000);
}
SECTION("cut low energy") {
- ParticleCut cut(20_GeV);
+ ParticleCut cut(20_GeV, true, true);
// add primary particle to stack
- auto particle = stack.AddParticle(
- std::tuple<corsika::Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{
- corsika::Code::Proton, Eabove,
- corsika::MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
- corsika::Point(rootCS, 0_m, 0_m, 0_m), 0_ns});
+ auto particle = stack.addParticle(
+ std::make_tuple(Code::Proton, Eabove,
+ MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}), point0, 0_ns));
// view on secondary particles
- corsika::SecondaryView view(particle);
+ SecondaryView view(particle);
// ref. to primary particle through the secondary view.
// only this way the secondary view is populated
- auto projectile = view.GetProjectile();
+ auto projectile = view.getProjectile();
// add secondaries, all with energies below the threshold
// only cut is by species
for (auto proType : particleList)
- projectile.AddSecondary(std::make_tuple(
- proType, Ebelow, corsika::MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
- corsika::Point(rootCS, 0_m, 0_m, 0_m), 0_ns));
+ projectile.addSecondary(std::make_tuple(
+ proType, Ebelow, MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}), point0, 0_ns));
+ unsigned short A = 18;
+ unsigned short Z = 8;
+ projectile.addSecondary(std::make_tuple(Code::Nucleus, Eabove * A,
+ MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
+ point0, 0_ns, A, Z));
+ projectile.addSecondary(std::make_tuple(Code::Nucleus, Ebelow * A,
+ MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
+ point0, 0_ns, A, Z));
cut.doSecondaries(view);
- REQUIRE(view.GetSize() == 0);
+ CHECK(view.getEntries() == 1);
+ CHECK(view.getSize() == 13);
+ }
+
+ SECTION("cut on time") {
+ ParticleCut cut(20_GeV, false, false);
+ const TimeType too_late = 1_s;
+
+ // add primary particle to stack
+ auto particle = stack.addParticle(
+ std::make_tuple(Code::Proton, Eabove,
+ MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}), point0, 1_ns));
+ // view on secondary particles
+ setup::StackView view(particle);
+ // ref. to primary particle through the secondary view.
+ // only this way the secondary view is populated
+ auto projectile = view.getProjectile();
+ // add secondaries, all with energies above the threshold
+ // only cut is by species
+ for (auto proType : particleList) {
+ projectile.addSecondary(
+ std::make_tuple(proType, Eabove, MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}),
+ point0, too_late));
+ }
+ cut.doSecondaries(view);
+
+ CHECK(view.getEntries() == 0);
+ CHECK(cut.getCutEnergy() / 1_GeV == 11000);
+ cut.reset();
+ CHECK(cut.getCutEnergy() == 0_GeV);
+ }
+
+ setup::Trajectory const track{
+ Line{point0,
+ Vector<SpeedType::dimension_type>{
+ rootCS, {0_m / second, 0_m / second, -constants::c}}},
+ 12_m / constants::c};
+
+ SECTION("cut on DoContinous, just invisibles") {
+
+ ParticleCut cut(20_GeV, false, true);
+ CHECK(cut.getECut() == 20_GeV);
+
+ // add particles, all with energies above the threshold
+ // only cut is by species
+ for (auto proType : particleList) {
+ auto particle = stack.addParticle(std::make_tuple(
+ proType, Eabove, MomentumVector(rootCS, {0_GeV, 0_GeV, 0_GeV}), point0, 0_ns));
+ cut.doContinuous(particle, track);
+ }
+
+ CHECK(stack.getEntries() == 9);
+ CHECK(cut.getNumberInvParticles() == 2);
+ CHECK(cut.getInvEnergy() / 1_GeV == 2000);
}
}
diff --git a/tests/modules/testPythia8.cpp b/tests/modules/testPythia8.cpp
index 765d0b109..e565edfdf 100644
--- a/tests/modules/testPythia8.cpp
+++ b/tests/modules/testPythia8.cpp
@@ -86,32 +86,29 @@ TEST_CASE("Pythia", "[processes]") {
using namespace corsika;
using namespace corsika::units::si;
-TEST_CASE("pythia process") {
-
- // setup environment, geometry
- corsika::Environment<corsika::IMediumModel> env;
+template <typename TStackView>
+auto sumMomentum(TStackView const& view, geometry::CoordinateSystem const& vCS) {
+ geometry::Vector<hepenergy_d> sum{vCS, 0_eV, 0_eV, 0_eV};
- corsika::CoordinateSystem const& cs = env.GetCoordinateSystem();
+ for (auto const& p : view) { sum += p.GetMomentum(); }
- auto theMedium =
- corsika::Environment<corsika::IMediumModel>::CreateNode<corsika::Sphere>(
- corsika::Point{cs, 0_m, 0_m, 0_m},
- 1_km * std::numeric_limits<double>::infinity());
+ return sum;
+}
- using MyHomogeneousModel = corsika::HomogeneousMedium<corsika::IMediumModel>;
- theMedium->SetModelProperties<MyHomogeneousModel>(
- 1_kg / (1_m * 1_m * 1_m),
- corsika::NuclearComposition(std::vector<corsika::Code>{corsika::Code::Hydrogen},
- std::vector<float>{1.}));
+TEST_CASE("pythia process") {
- auto const* nodePtr = theMedium.get(); // save the medium for later use before moving it
+ auto [env, csPtr, nodePtr] = setup::testing::setupEnvironment(particles::Code::Proton);
+ auto const& cs = *csPtr;
+ [[maybe_unused]] auto const& env_dummy = env;
+ [[maybe_unused]] auto const& node_dummy = nodePtr;
SECTION("pythia decay") {
+ feenableexcept(FE_INVALID);
+ auto [stackPtr, secViewPtr] =
+ setup::testing::setupStack(particles::Code::PiPlus, 0, 0, P0, nodePtr, *csPtr);
- setup::Stack stack;
const HEPEnergyType E0 = 10_GeV;
- HEPMomentumType P0 =
- sqrt(E0 * E0 - corsika::PiPlus::mass * corsika::PiPlus::mass);
+ HEPMomentumType P0 = sqrt(E0 * E0 - corsika::PiPlus::mass * corsika::PiPlus::mass);
auto plab = corsika::MomentumVector(cs, {0_GeV, 0_GeV, -P0});
corsika::Point pos(cs, 0_m, 0_m, 0_m);
auto particle = stack.AddParticle(
@@ -125,34 +122,51 @@ TEST_CASE("pythia process") {
corsika::RNGManager::getInstance().registerRandomStream("pythia");
- corsika::SecondaryView view(particle);
- auto projectile = view.GetProjectile();
-
corsika::pythia8::Decay model(particleList);
- model.Init();
- model.DoDecay(projectile);
+
[[maybe_unused]] const TimeType time = model.GetLifetime(particle);
+ model.DoDecay(view);
+ CHECK(stack.getEntries() == 3);
+ auto const pSum = sumMomentum(view, cs);
+ CHECK((pSum - plab).norm() / 1_GeV == Approx(0).margin(1e-4));
+ CHECK((pSum.norm() - plab.norm()) / 1_GeV == Approx(0).margin(1e-4));
+ }
+
+ SECTION("pythia decay config") {
+ process::pythia::Decay model({particles::Code::PiPlus, particles::Code::PiMinus});
+ REQUIRE(model.IsDecayHandled(particles::Code::PiPlus));
+ REQUIRE(model.IsDecayHandled(particles::Code::PiMinus));
+ REQUIRE_FALSE(model.IsDecayHandled(particles::Code::KPlus));
+
+ const std::vector<particles::Code> particleTestList = {
+ particles::Code::PiPlus, particles::Code::PiMinus, particles::Code::KPlus,
+ particles::Code::Lambda0Bar, particles::Code::D0Bar};
+
+ // setup decays
+ model.SetHandleDecay(particleTestList);
+ for (auto& pCode : particleTestList) REQUIRE(model.IsDecayHandled(pCode));
+
+ // individually
+ model.SetHandleDecay(particles::Code::KMinus);
+
+ // possible decays
+ REQUIRE_FALSE(model.CanHandleDecay(particles::Code::Proton));
+ REQUIRE_FALSE(model.CanHandleDecay(particles::Code::Electron));
+ REQUIRE(model.CanHandleDecay(particles::Code::PiPlus));
+ REQUIRE(model.CanHandleDecay(particles::Code::MuPlus));
}
SECTION("pythia interaction") {
- setup::Stack stack;
- const HEPEnergyType E0 = 100_GeV;
- HEPMomentumType P0 =
- sqrt(E0 * E0 - corsika::PiPlus::mass * corsika::PiPlus::mass);
- auto plab = corsika::MomentumVector(cs, {0_GeV, 0_GeV, -P0});
- corsika::Point pos(cs, 0_m, 0_m, 0_m);
- auto particle = stack.AddParticle(
- std::tuple<corsika::Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{corsika::Code::PiPlus, E0, plab,
- pos, 0_ns});
- particle.SetNode(nodePtr);
- corsika::SecondaryView view(particle);
- auto projectile = view.GetProjectile();
+ feenableexcept(FE_INVALID);
+ auto [stackPtr, secViewPtr] = setup::testing::setupStack(particles::Code::PiPlus, 0,
+ 0, 100_GeV, nodePtr, *csPtr);
+ auto& view = *secViewPtr;
+ auto particle = stackPtr->first();
- corsika::pythia8::Interaction model;
- model.Init();
- model.doInteraction(projectile);
+ process::pythia::Interaction model;
+
+ [[maybe_unused]] const process::EProcessReturn ret = model.DoInteraction(view);
[[maybe_unused]] const GrammageType length = model.GetInteractionLength(particle);
}
}
diff --git a/tests/modules/testQGSJetII.cpp b/tests/modules/testQGSJetII.cpp
index baf4c2fa2..00f0d8013 100644
--- a/tests/modules/testQGSJetII.cpp
+++ b/tests/modules/testQGSJetII.cpp
@@ -16,39 +16,83 @@
#include <catch2/catch.hpp>
+#include <string>
+#include <cstdlib>
+#include <experimental/filesystem>
+#include <iostream>
+
using namespace corsika;
-using namespace corsika::qgsjetII;
+
+template <typename TStackView>
+auto sumCharge(TStackView const& view) {
+ int totalCharge = 0;
+ for (auto const& p : view) { totalCharge += get_charge_number(p.getPID()); }
+ return totalCharge;
+}
+
+template <typename TStackView>
+auto sumMomentum(TStackView const& view, CoordinateSystemPtr const& vCS) {
+ Vector<hepenergy_d> sum{vCS, 0_eV, 0_eV, 0_eV};
+ for (auto const& p : view) { sum += p.getMomentum(); }
+ return sum;
+}
+
+TEST_CASE("CORSIKA_DATA", "[processes]") {
+
+ SECTION("check CORSIKA_DATA") {
+
+ const char* data = std::getenv("CORSIKA_DATA");
+ // these REQUIRES are needed:
+ REQUIRE(data != 0);
+ REQUIRE(std::experimental::filesystem::is_directory(
+ std::experimental::filesystem::path(std::string(data) + "/QGSJetII")));
+ std::cout << "data: " << data << " isDir: "
+ << std::experimental::filesystem::is_directory(std::string(data) +
+ "/QGSJetII")
+ << std::endl;
+ }
+}
TEST_CASE("QgsjetII", "[processes]") {
+ SECTION("Corsika -> QgsjetII") {
+ CHECK(corsika::qgsjetII::convertToQgsjetII(PiMinus::code) ==
+ corsika::qgsjetII::QgsjetIICode::PiMinus);
+ CHECK(corsika::qgsjetII::convertToQgsjetIIRaw(Proton::code) == 2);
+ }
+
SECTION("QgsjetII -> Corsika") {
- REQUIRE(corsika::Code::PiPlus == corsika::qgsjetII::ConvertFromQgsjetII(
- corsika::qgsjetII::QgsjetIICode::PiPlus));
+ REQUIRE(Code::PiPlus == corsika::qgsjetII::convertFromQgsjetII(
+ corsika::qgsjetII::QgsjetIICode::PiPlus));
}
SECTION("Corsika -> QgsjetII") {
- REQUIRE(corsika::qgsjetII::ConvertToQgsjetII(corsika::Code::PiMinus) ==
+ REQUIRE(corsika::qgsjetII::convertToQgsjetII(Code::PiMinus) ==
corsika::qgsjetII::QgsjetIICode::PiMinus);
- REQUIRE(corsika::qgsjetII::ConvertToQgsjetIIRaw(corsika::Code::Proton) == 2);
+ REQUIRE(corsika::qgsjetII::convertToQgsjetIIRaw(Code::Proton) == 2);
}
SECTION("canInteractInQgsjetII") {
- REQUIRE(corsika::qgsjetII::CanInteract(corsika::Code::Proton));
- REQUIRE(corsika::qgsjetII::CanInteract(corsika::Code::KPlus));
- REQUIRE(corsika::qgsjetII::CanInteract(corsika::Code::Nucleus));
- // REQUIRE(corsika::qgsjetII::CanInteract(corsika::Helium::GetCode()));
+ REQUIRE(corsika::qgsjetII::canInteract(Code::Proton));
+ REQUIRE(corsika::qgsjetII::canInteract(Code::KPlus));
+ REQUIRE(corsika::qgsjetII::canInteract(Code::Nucleus));
+ // REQUIRE(corsika::qgsjetII::canInteract(Helium::getCode()));
- REQUIRE_FALSE(corsika::qgsjetII::CanInteract(corsika::Code::EtaC));
- REQUIRE_FALSE(corsika::qgsjetII::CanInteract(corsika::Code::SigmaC0));
+ REQUIRE_FALSE(corsika::qgsjetII::canInteract(Code::EtaC));
+ REQUIRE_FALSE(corsika::qgsjetII::canInteract(Code::SigmaC0));
}
SECTION("cross-section type") {
- REQUIRE(corsika::qgsjetII::GetQgsjetIIXSCode(corsika::Code::Neutron) == 2);
- REQUIRE(corsika::qgsjetII::GetQgsjetIIXSCode(corsika::Code::K0Long) == 3);
- REQUIRE(corsika::qgsjetII::GetQgsjetIIXSCode(corsika::Code::Proton) == 2);
- REQUIRE(corsika::qgsjetII::GetQgsjetIIXSCode(corsika::Code::PiMinus) == 1);
+ REQUIRE(corsika::qgsjetII::getQgsjetIIXSCode(Code::Neutron) ==
+ corsika::qgsjetII::QgsjetIIXSClass::Baryons);
+ REQUIRE(corsika::qgsjetII::getQgsjetIIXSCode(Code::K0Long) ==
+ corsika::qgsjetII::QgsjetIIXSClass::Kaons);
+ REQUIRE(corsika::qgsjetII::getQgsjetIIXSCode(Code::Proton) ==
+ corsika::qgsjetII::QgsjetIIXSClass::Baryons);
+ REQUIRE(corsika::qgsjetII::getQgsjetIIXSCode(Code::PiMinus) ==
+ corsika::qgsjetII::QgsjetIIXSClass::LightMesons);
}
}
@@ -66,50 +110,45 @@ TEST_CASE("QgsjetII", "[processes]") {
#include <corsika/media/HomogeneousMedium.hpp>
#include <corsika/media/NuclearComposition.hpp>
-TEST_CASE("QgsjetIIInterface", "[processes]") {
-
- // setup environment, geometry
- corsika::Environment<corsika::IMediumModel> env;
- auto& universe = *(env.GetUniverse());
+#include <SetupTestEnvironment.hpp>
+#include <SetupTestStack.hpp>
- auto theMedium =
- corsika::Environment<corsika::IMediumModel>::CreateNode<corsika::Sphere>(
- corsika::Point{env.GetCoordinateSystem(), 0_m, 0_m, 0_m},
- 1_km * std::numeric_limits<double>::infinity());
-
- using MyHomogeneousModel = corsika::HomogeneousMedium<corsika::IMediumModel>;
- theMedium->SetModelProperties<MyHomogeneousModel>(
- 1_kg / (1_m * 1_m * 1_m),
- corsika::NuclearComposition(std::vector<corsika::Code>{corsika::Code::Oxygen},
- std::vector<float>{1.}));
-
- auto const* nodePtr = theMedium.get();
- universe.AddChild(std::move(theMedium));
+TEST_CASE("QgsjetIIInterface", "[processes]") {
- const corsika::CoordinateSystem& cs = env.GetCoordinateSystem();
+ auto [env, csPtr, nodePtr] = setup::testing::setup_environment(Code::Oxygen);
+ [[maybe_unused]] auto const& env_dummy = env;
+ [[maybe_unused]] auto const& node_dummy = nodePtr;
- corsika::RNGManager::getInstance().registerRandomStream("qgsjet");
+ RNGManager::getInstance().registerRandomStream("qgsjet");
SECTION("InteractionInterface") {
- setup::Stack stack;
- const HEPEnergyType E0 = 100_GeV;
- HEPMomentumType P0 =
- sqrt(E0 * E0 - corsika::Proton::mass * corsika::Proton::mass);
- auto plab = corsika::MomentumVector(cs, {0_GeV, 0_GeV, -P0});
- corsika::Point pos(cs, 0_m, 0_m, 0_m);
- auto particle = stack.AddParticle(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector, corsika::Point,
- TimeType, unsigned int, unsigned int>{corsika::Code::Nucleus, E0, plab,
- pos, 0_ns, 16, 8});
-
- particle.SetNode(nodePtr);
- corsika::SecondaryView view(particle);
- auto projectile = view.GetProjectile();
-
- Interaction model;
- model.Init();
+ auto [stackPtr, secViewPtr] = setup::testing::setup_stack(
+ Code::Proton, 0, 0, 110_GeV, (setup::Environment::BaseNodeType* const)nodePtr,
+ *csPtr);
+ setup::StackView& view = *(secViewPtr.get());
+ auto particle = stackPtr->first();
+ auto projectile = secViewPtr->getProjectile();
+ auto const projectileMomentum = projectile.getMomentum();
+
+ corsika::qgsjetII::Interaction model;
model.doInteraction(projectile);
- [[maybe_unused]] const GrammageType length = model.GetInteractionLength(particle);
+ [[maybe_unused]] const GrammageType length = model.getInteractionLength(particle);
+
+ CHECK(length / (1_g / square(1_cm)) == Approx(93.04).margin(0.1));
+
+ /***********************************
+ It as turned out already two times (#291 and #307) that the detailed output of
+ QGSJetII event generation depends on the gfortran version used. This is not reliable
+ and cannot be tested in a unit test here. One related problem was already found (#291)
+ and is realted to undefined behaviour in the evaluation of functions in logical
+ expressions. It is not clear if #307 is the same issue.
+
+ CHECK(view.getSize() == 14);
+ CHECK(sumCharge(view) == 2);
+ ************************************/
+ auto const secMomSum = sumMomentum(view, projectileMomentum.getCoordinateSystem());
+ CHECK((secMomSum - projectileMomentum).getNorm() / projectileMomentum.getNorm() ==
+ Approx(0).margin(1e-2));
}
}
diff --git a/tests/modules/testSibyll.cpp b/tests/modules/testSibyll.cpp
index 518752b57..8b37e65b4 100644
--- a/tests/modules/testSibyll.cpp
+++ b/tests/modules/testSibyll.cpp
@@ -23,34 +23,41 @@ using namespace corsika::sibyll;
TEST_CASE("Sibyll", "[processes]") {
SECTION("Sibyll -> Corsika") {
- REQUIRE(Code::Electron ==
- corsika::sibyll::ConvertFromSibyll(corsika::sibyll::SibyllCode::Electron));
+ CHECK(Code::Electron ==
+ corsika::sibyll::convertFromSibyll(corsika::sibyll::SibyllCode::Electron));
}
SECTION("Corsika -> Sibyll") {
- REQUIRE(corsika::sibyll::ConvertToSibyll(Code::Electron) ==
- corsika::sibyll::SibyllCode::Electron);
- REQUIRE(corsika::sibyll::ConvertToSibyllRaw(Code::Proton) == 13);
+ CHECK(corsika::sibyll::convertToSibyll(Electron::code) ==
+ corsika::sibyll::SibyllCode::Electron);
+ CHECK(corsika::sibyll::convertToSibyllRaw(Proton::code) == 13);
+ CHECK(corsika::sibyll::convertToSibyll(XiStarC0::code) ==
+ corsika::sibyll::SibyllCode::XiStarC0);
}
SECTION("canInteractInSibyll") {
- REQUIRE(corsika::sibyll::CanInteract(Code::Proton));
- REQUIRE(corsika::sibyll::CanInteract(Code::XiCPlus));
+ CHECK(corsika::sibyll::canInteract(Code::Proton));
+ CHECK(corsika::sibyll::canInteract(Code::XiCPlus));
- REQUIRE_FALSE(corsika::sibyll::CanInteract(Code::Electron));
- REQUIRE_FALSE(corsika::sibyll::CanInteract(Code::SigmaC0));
+ CHECK_FALSE(corsika::sibyll::canInteract(Code::Electron));
+ CHECK_FALSE(corsika::sibyll::canInteract(Code::SigmaC0));
- REQUIRE_FALSE(corsika::sibyll::CanInteract(Code::Nucleus));
- REQUIRE_FALSE(corsika::sibyll::CanInteract(Code::Helium));
+ CHECK_FALSE(corsika::sibyll::canInteract(Code::Nucleus));
+ CHECK_FALSE(corsika::sibyll::canInteract(Code::Helium));
}
SECTION("cross-section type") {
- REQUIRE(corsika::sibyll::GetSibyllXSCode(Code::Electron) == 0);
- REQUIRE(corsika::sibyll::GetSibyllXSCode(Code::K0Long) == 3);
- REQUIRE(corsika::sibyll::GetSibyllXSCode(Code::SigmaPlus) == 1);
- REQUIRE(corsika::sibyll::GetSibyllXSCode(Code::PiMinus) == 2);
+ CHECK(corsika::sibyll::getSibyllXSCode(Code::Electron) == 0);
+ CHECK(corsika::sibyll::getSibyllXSCode(Code::K0Long) == 3);
+ CHECK(corsika::sibyll::getSibyllXSCode(Code::SigmaPlus) == 1);
+ CHECK(corsika::sibyll::getSibyllXSCode(Code::PiMinus) == 2);
+ }
+
+ SECTION("sibyll mass") {
+
+ CHECK_FALSE(corsika::sibyll::getSibyllMass(Code::Electron) == 0_GeV);
}
}
@@ -61,125 +68,173 @@ TEST_CASE("Sibyll", "[processes]") {
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/core/ParticleProperties.hpp>
-#include <corsika/setup/SetupStack.hpp>
-#include <corsika/setup/SetupTrajectory.hpp>
+
+#include <SetupTestEnvironment.hpp>
+#include <SetupTestStack.hpp>
#include <corsika/media/Environment.hpp>
#include <corsika/media/HomogeneousMedium.hpp>
#include <corsika/media/NuclearComposition.hpp>
+#include <corsika/media/UniformMagneticField.hpp>
-#include <sibyll2.3d.hpp>
-
-using namespace corsika::units::si;
-using namespace corsika::units;
+template <typename TStackView>
+auto sumMomentum(TStackView const& view, CoordinateSystemPtr const& vCS) {
+ Vector<hepenergy_d> sum{vCS, 0_eV, 0_eV, 0_eV};
+ for (auto const& p : view) { sum += p.getMomentum(); }
+ return sum;
+}
TEST_CASE("SibyllInterface", "[processes]") {
- // setup environment, geometry
- corsika::Environment<corsika::IMediumModel> env;
- auto& universe = *(env.GetUniverse());
-
- auto theMedium =
- corsika::Environment<corsika::IMediumModel>::CreateNode<corsika::Sphere>(
- corsika::Point{env.GetCoordinateSystem(), 0_m, 0_m, 0_m},
- 1_km * std::numeric_limits<double>::infinity());
+ auto [env, csPtr, nodePtr] = setup::testing::setup_environment(Code::Oxygen);
+ auto const& cs = *csPtr;
+ [[maybe_unused]] auto const& env_dummy = env;
- using MyHomogeneousModel = corsika::HomogeneousMedium<corsika::IMediumModel>;
- theMedium->SetModelProperties<MyHomogeneousModel>(
- 1_kg / (1_m * 1_m * 1_m),
- corsika::NuclearComposition(std::vector<Code>{Code::Oxygen},
- std::vector<float>{1.}));
+ RNGManager::getInstance().registerRandomStream("sibyll");
- auto const* nodePtr = theMedium.get();
- universe.AddChild(std::move(theMedium));
+ SECTION("InteractionInterface - low energy") {
- const corsika::CoordinateSystem& cs = env.GetCoordinateSystem();
+ const HEPEnergyType P0 = 60_GeV;
+ auto [stack, viewPtr] = setup::testing::setup_stack(
+ Code::Proton, 0, 0, P0, (setup::Environment::BaseNodeType* const)nodePtr, cs);
+ MomentumVector plab =
+ MomentumVector(cs, {P0, 0_eV, 0_eV}); // this is secret knowledge about setupStack
+ setup::StackView& view = *viewPtr;
- corsika::RNGManager::getInstance().registerRandomStream("sibyll");
-
- SECTION("InteractionInterface") {
-
- corsika::setup::Stack stack;
- const HEPEnergyType E0 = 100_GeV;
- HEPMomentumType P0 = sqrt(E0 * E0 - Proton::mass * Proton::mass);
- auto plab = corsika::MomentumVector(cs, {0_GeV, 0_GeV, -P0});
- corsika::Point pos(cs, 0_m, 0_m, 0_m);
- auto particle = stack.AddParticle(
- std::tuple<Code, corsika::units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, corsika::units::si::TimeType>{Code::Proton, E0, plab,
- pos, 0_ns});
- particle.SetNode(nodePtr);
- corsika::SecondaryView view(particle);
- auto projectile = view.GetProjectile();
+ auto particle = stack->first();
Interaction model;
-
- model.doInteraction(projectile);
- [[maybe_unused]] const GrammageType length = model.GetInteractionLength(particle);
+ model.doInteraction(view);
+ auto const pSum = sumMomentum(view, cs);
+
+ /*
+ Interactions between hadrons (h) and nuclei (A) in Sibyll are treated in the
+ hadron-nucleon center-of-mass frame (hnCoM). The incoming hadron (h) and
+ nucleon (N) are assumed massless, such that the energy and momentum in the hnCoM are
+ : E_i_cm = 0.5 * SQS and P_i_cm = +- 0.5 * SQS where i is either the projectile
+ hadron or the target nucleon and SQS is the hadron-nucleon center-of-mass energy.
+
+ The true energies and momenta, accounting for the hadron masses, are: E_i = ( S +
+ m_i**2 - m_j**2 ) / (2 * SQS) and Pcm = +-
+ sqrt( (S-(m_j+m_i)**2) * (s-(m_j-m_i)**2) ) / (2*SQS) where m_i is the projectiles
+ mass and m_j is the target particles mass. In terms of lab. frame variables Pcm =
+ m_j * Plab_i / SQS, where Plab_i is the momentum of the projectile (i) in the lab.
+ and m_j is the mass of the target, i.e. the particle at rest (usually a nucleon).
+
+ Any hadron-nucleus event can contain several nucleon interactions. In case of Nw
+ (number of wounded nucleons) nucleons interacting in the hadron-nucleus interaction,
+ the total energy and momentum in the hadron(i)-nucleon(N) center-of-mass frame are:
+ momentum: p_projectile + p_nucleon_1 + p_nucleon_2 + .... p_nucleon_Nw = -(Nw-1) *
+ Pcm with center-of-mass momentum Pcm = p_projectile = - p_nucleon_i. For the energy:
+ E_projectile + E_nucleon_1 + ... E_nucleon_Nw = E_projectile + Nw * E_nucleon.
+
+ Using the above definitions of center-of-mass energies and momenta this leads to the
+ total energy: E_tot = SQS/2 * (1+Nw) + (m_N**2-m_i**2)/(2*SQS) * (Nw-1) and P_tot
+ = -m_N * Plab_i / SQS * (Nw-1).
+
+ A Lorentztransformation of these quantities to the lab. frame recovers Plab_i for
+ the total momentum, so momentum is exactly conserved, and Elab_i + Nw * m_N for the
+ total energy. Not surprisingly the total energy differs from the total energy before
+ the collision by the mass of the additional nucleons (Nw-1)*m_N. In relative terms
+ the additional energy is entirely negligible and as it is not kinetic energy there
+ is zero influence on the shower development.
+
+ Due to the ommission of the hadron masses in Sibyll, the total energy and momentum
+ in the center-of-mass system after the collision are just: E_tot = SQS/2 * (1+Nw)
+ and P_tot = SQS/2 * (1-Nw). After the Lorentztransformation the total momentum in
+ the lab. thus differs from the initial value by (1-Nw)/2 * ( m_N + m_i**2 / (2 *
+ Plab_i) ) and momentum is NOT conserved. Note however that the second term quickly
+ vanishes as the lab. momentum of the projectile increases. The first term is fixed
+ as it depends only on the number of additional nucleons, in relative terms it is
+ always small at high energies.
+
+ For this reason the numerical precision in these tests is limited to 5% to still
+ pass at low energies and no absolute check is implemented, e.g.
+
+ CHECK(pSum.getComponents(cs).getX() / P0 == Approx(1).margin(0.05));
+ CHECK((pSum - plab).norm()/1_GeV == Approx(0).margin(plab.norm() * 0.05/1_GeV));
+
+ /FR'2020
+
+ See also:
+
+ Issue 272 / MR 204
+ https://gitlab.ikp.kit.edu/AirShowerPhysics/corsika/-/merge_requests/204
+
+ */
+
+ CHECK(pSum.getComponents(cs).getX() / P0 == Approx(1).margin(0.05));
+ CHECK(pSum.getComponents(cs).getY() / 1_GeV == Approx(0).margin(1e-4));
+ CHECK(pSum.getComponents(cs).getZ() / 1_GeV == Approx(0).margin(1e-4));
+
+ CHECK((pSum - plab).getNorm() / 1_GeV ==
+ Approx(0).margin(plab.getNorm() * 0.05 / 1_GeV));
+ CHECK(pSum.getNorm() / P0 == Approx(1).margin(0.05));
+ [[maybe_unused]] const GrammageType length = model.getInteractionLength(particle);
+ CHECK(length / 1_g * 1_cm * 1_cm == Approx(88.7).margin(0.1));
+ CHECK(view.getEntries() == 9); //! \todo: this was 20 before refactory-2020: check
}
SECTION("NuclearInteractionInterface") {
- setup::Stack stack;
- const HEPEnergyType E0 = 400_GeV;
- HEPMomentumType P0 = sqrt(E0 * E0 - Proton::mass * Proton::mass);
- auto plab = corsika::MomentumVector(cs, {0_GeV, 0_GeV, -P0});
- corsika::Point pos(cs, 0_m, 0_m, 0_m);
-
- auto particle = stack.AddParticle(
- std::tuple<Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType, unsigned short, unsigned short>{
- Code::Nucleus, E0, plab, pos, 0_ns, 4, 2});
- particle.SetNode(nodePtr);
- corsika::SecondaryView view(particle);
- auto projectile = view.GetProjectile();
+ auto [stack, viewPtr] =
+ setup::testing::setup_stack(Code::Nucleus, 4, 2, 500_GeV,
+ (setup::Environment::BaseNodeType* const)nodePtr, cs);
+ setup::StackView& view = *viewPtr;
+ auto particle = stack->first();
Interaction hmodel;
- NuclearInteraction model(hmodel, env);
-
- model.Init();
- model.doInteraction(projectile);
- [[maybe_unused]] const GrammageType length = model.GetInteractionLength(particle);
+ NuclearInteraction model(hmodel, *env);
+
+ model.doInteraction(view);
+ [[maybe_unused]] const GrammageType length = model.getInteractionLength(particle);
+ // Felix, are those changes OK? Below are the checks before refactory-2020
+ //CHECK(length / 1_g * 1_cm * 1_cm == Approx(44.2).margin(.1));
+ //CHECK(view.getSize() == 11);
+ CHECK(length / 1_g * 1_cm * 1_cm == Approx(42.8).margin(.1));
+ CHECK(view.getSize() == 40);
}
SECTION("DecayInterface") {
- setup::Stack stack;
- const HEPEnergyType E0 = 10_GeV;
- HEPMomentumType P0 = sqrt(E0 * E0 - Proton::mass * Proton::mass);
- auto plab = corsika::MomentumVector(cs, {0_GeV, 0_GeV, -P0});
- corsika::Point pos(cs, 0_m, 0_m, 0_m);
- auto particle = stack.AddParticle(
- std::tuple<Code, units::si::HEPEnergyType, corsika::MomentumVector,
- corsika::Point, units::si::TimeType>{Code::Lambda0, E0, plab, pos,
- 0_ns});
- corsika::SecondaryView view(particle);
- auto projectile = view.GetProjectile();
+ auto [stackPtr, viewPtr] =
+ setup::testing::setup_stack(Code::Lambda0, 0, 0, 10_GeV,
+ (setup::Environment::BaseNodeType* const)nodePtr, cs);
+ setup::StackView& view = *viewPtr;
+ auto& stack = *stackPtr;
+ auto particle = stack.first();
Decay model;
+ model.printDecayConfig();
+ [[maybe_unused]] const TimeType time = model.getLifetime(particle);
- model.Init();
- /*[[maybe_unused]] const corsika::EProcessReturn ret =*/model.DoDecay(projectile);
+ model.doDecay(view);
// run checks
- [[maybe_unused]] const TimeType time = model.GetLifetime(particle);
+ // lambda decays into proton and pi- or neutron and pi+
+ CHECK(stack.getEntries() == 3);
}
SECTION("DecayConfiguration") {
- Decay model;
+ Decay model({Code::PiPlus, Code::PiMinus});
+ CHECK(model.isDecayHandled(Code::PiPlus));
+ CHECK(model.isDecayHandled(Code::PiMinus));
+ CHECK_FALSE(model.isDecayHandled(Code::KPlus));
+
+ const std::vector<Code> particleTestList = {Code::PiPlus, Code::PiMinus, Code::KPlus,
+ Code::Lambda0Bar, Code::D0Bar};
- const std::vector<Code> particleTestList = {Code::PiPlus, Code::PiMinus,
- Code::KPlus, Code::Lambda0Bar,
- Code::NuE, Code::D0Bar};
+ // setup decays
+ model.setHandleDecay(particleTestList);
+ for (auto& pCode : particleTestList) CHECK(model.isDecayHandled(pCode));
- for (auto& pCode : particleTestList) {
- model.SetUnstable(pCode);
- // get state of sibyll internal config
- REQUIRE(0 <= s_csydec_.idb[abs(corsika::sibyll::ConvertToSibyllRaw(pCode)) - 1]);
+ // individually
+ model.setHandleDecay(Code::KMinus);
- model.SetStable(pCode);
- // get state of sibyll internal config
- REQUIRE(0 >= s_csydec_.idb[abs(corsika::sibyll::ConvertToSibyllRaw(pCode)) - 1]);
- }
+ // possible decays
+ CHECK_FALSE(model.canHandleDecay(Code::Proton));
+ CHECK_FALSE(model.canHandleDecay(Code::Electron));
+ CHECK(model.canHandleDecay(Code::PiPlus));
+ CHECK(model.canHandleDecay(Code::MuPlus));
}
}
diff --git a/tests/modules/testUrQMD.cpp b/tests/modules/testUrQMD.cpp
index 8a1eaf3bc..a51081fe4 100644
--- a/tests/modules/testUrQMD.cpp
+++ b/tests/modules/testUrQMD.cpp
@@ -50,70 +50,6 @@ auto sumMomentum(TStackView const& view, corsika::CoordinateSystem const& vCS) {
return sum;
}
-auto setupEnvironment(corsika::Code vTargetCode) {
- // setup environment, geometry
- auto env = std::make_unique<corsika::Environment<corsika::IMediumModel>>();
- auto& universe = *(env->GetUniverse());
- const corsika::CoordinateSystem& cs = env->GetCoordinateSystem();
-
- auto theMedium =
- corsika::Environment<corsika::IMediumModel>::CreateNode<corsika::Sphere>(
- corsika::Point{cs, 0_m, 0_m, 0_m},
- 1_km * std::numeric_limits<double>::infinity());
-
- using MyHomogeneousModel = corsika::HomogeneousMedium<corsika::IMediumModel>;
- theMedium->SetModelProperties<MyHomogeneousModel>(
- 1_kg / (1_m * 1_m * 1_m),
- corsika::NuclearComposition(std::vector<corsika::Code>{vTargetCode},
- std::vector<float>{1.}));
-
- auto const* nodePtr = theMedium.get();
- universe.AddChild(std::move(theMedium));
-
- return std::make_tuple(std::move(env), &cs, nodePtr);
-}
-
-template <typename TNodeType>
-auto setupStack(int vA, int vZ, HEPEnergyType vMomentum, TNodeType* vNodePtr,
- corsika::CoordinateSystem const& cs) {
- auto stack = std::make_unique<setup::Stack>();
- auto constexpr mN = corsika::constants::nucleonMass;
-
- corsika::Point const origin(cs, {0_m, 0_m, 0_m});
- corsika::MomentumVector const pLab(cs, {vMomentum, 0_GeV, 0_GeV});
-
- HEPEnergyType const E0 = sqrt(static_pow<2>(mN * vA) + pLab.squaredNorm());
- auto particle = stack->AddParticle(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector, corsika::Point,
- TimeType, unsigned short, unsigned short>{corsika::Code::Nucleus, E0,
- pLab, origin, 0_ns, vA, vZ});
-
- particle.SetNode(vNodePtr);
- return std::make_tuple(
- std::move(stack),
- std::make_unique<decltype(corsika::SecondaryView(particle))>(particle));
-}
-
-template <typename TNodeType>
-auto setupStack(corsika::Code vProjectileType, HEPEnergyType vMomentum,
- TNodeType* vNodePtr, corsika::CoordinateSystem const& cs) {
- auto stack = std::make_unique<setup::Stack>();
-
- corsika::Point const origin(cs, {0_m, 0_m, 0_m});
- corsika::MomentumVector const pLab(cs, {vMomentum, 0_GeV, 0_GeV});
-
- HEPEnergyType const E0 =
- sqrt(static_pow<2>(corsika::mass(vProjectileType)) + pLab.squaredNorm());
- auto particle = stack->AddParticle(
- std::tuple<corsika::Code, HEPEnergyType, corsika::MomentumVector, corsika::Point,
- TimeType>{vProjectileType, E0, pLab, origin, 0_ns});
-
- particle.SetNode(vNodePtr);
- return std::make_tuple(
- std::move(stack),
- std::make_unique<decltype(corsika::SecondaryView(particle))>(particle));
-}
-
TEST_CASE("UrQMD") {
SECTION("conversion") {
REQUIRE_THROWS(corsika::urqmd::ConvertFromUrQMD(106, 0));
@@ -126,8 +62,9 @@ TEST_CASE("UrQMD") {
corsika::RNGManager::getInstance().registerRandomStream("urqmd");
UrQMD urqmd;
- SECTION("cross sections") {
- auto [env, csPtr, nodePtr] = setupEnvironment(corsika::Code::Unknown);
+ SECTION("interaction length") {
+ auto [env, csPtr, nodePtr] =
+ setup::testing::setupEnvironment(particles::Code::Nitrogen);
auto const& cs = *csPtr;
{ [[maybe_unused]] auto const& env_dummy = env; }
@@ -137,8 +74,9 @@ TEST_CASE("UrQMD") {
corsika::Code::K0, corsika::Code::K0Bar, corsika::Code::K0Long};
for (auto code : validProjectileCodes) {
- auto [stack, view] = setupStack(code, 100_GeV, nodePtr, cs);
- REQUIRE(stack->GetSize() == 1);
+ auto [stack, view] = setup::testing::setupStack(code, 0, 0, 100_GeV, nodePtr, cs);
+ REQUIRE(stack->getEntries() == 1);
+ REQUIRE(view->getEntries() == 0);
// simple check whether the cross-section is non-vanishing
REQUIRE(urqmd.GetCrossSection(view->GetProjectile(), corsika::Code::Proton) / 1_mb >
@@ -153,17 +91,22 @@ TEST_CASE("UrQMD") {
}
}
- SECTION("nucleon projectile") {
- auto [env, csPtr, nodePtr] = setupEnvironment(corsika::Code::Oxygen);
- { [[maybe_unused]] auto const& env_dummy = env; }
+ SECTION("nucleus projectile") {
+ auto [env, csPtr, nodePtr] =
+ setup::testing::setupEnvironment(particles::Code::Oxygen);
+ [[maybe_unused]] auto const& env_dummy = env; // against warnings
+ [[maybe_unused]] auto const& node_dummy = nodePtr; // against warnings
+
unsigned short constexpr A = 14, Z = 7;
- auto [stackPtr, secViewPtr] = setupStack(A, Z, 400_GeV, nodePtr, *csPtr);
- { [[maybe_unused]] auto const& dummy = stackPtr; }
+ auto [stackPtr, secViewPtr] = setup::testing::setupStack(particles::Code::Nucleus, A,
+ Z, 400_GeV, nodePtr, *csPtr);
+ REQUIRE(stackPtr->getEntries() == 1);
+ REQUIRE(secViewPtr->getEntries() == 0);
// must be assigned to variable, cannot be used as rvalue?!
auto projectile = secViewPtr->GetProjectile();
auto const projectileMomentum = projectile.GetMomentum();
- urqmd.doInteraction(projectile);
+ [[maybe_unused]] process::EProcessReturn const ret = urqmd.DoInteraction(*secViewPtr);
REQUIRE(sumCharge(*secViewPtr) == Z + corsika::charge_number(corsika::Code::Oxygen));
@@ -174,17 +117,21 @@ TEST_CASE("UrQMD") {
}
SECTION("\"special\" projectile") {
- auto [env, csPtr, nodePtr] = setupEnvironment(corsika::Code::Oxygen);
- { [[maybe_unused]] auto const& env_dummy = env; }
- auto [stackPtr, secViewPtr] =
- setupStack(corsika::Code::PiPlus, 400_GeV, nodePtr, *csPtr);
- { [[maybe_unused]] auto const& dummy = stackPtr; }
+ auto [env, csPtr, nodePtr] =
+ setup::testing::setupEnvironment(particles::Code::Oxygen);
+ [[maybe_unused]] auto const& env_dummy = env; // against warnings
+ [[maybe_unused]] auto const& node_dummy = nodePtr; // against warnings
+
+ auto [stackPtr, secViewPtr] = setup::testing::setupStack(particles::Code::PiPlus, 0,
+ 0, 400_GeV, nodePtr, *csPtr);
+ REQUIRE(stackPtr->getEntries() == 1);
+ REQUIRE(secViewPtr->getEntries() == 0);
// must be assigned to variable, cannot be used as rvalue?!
auto projectile = secViewPtr->GetProjectile();
auto const projectileMomentum = projectile.GetMomentum();
- urqmd.doInteraction(projectile);
+ [[maybe_unused]] process::EProcessReturn const ret = urqmd.DoInteraction(*secViewPtr);
REQUIRE(sumCharge(*secViewPtr) == corsika::charge_number(corsika::Code::PiPlus) +
corsika::charge_number(corsika::Code::Oxygen));
@@ -196,17 +143,21 @@ TEST_CASE("UrQMD") {
}
SECTION("K0Long projectile") {
- auto [env, csPtr, nodePtr] = setupEnvironment(corsika::Code::Oxygen);
- { [[maybe_unused]] auto const& env_dummy = env; }
- auto [stackPtr, secViewPtr] =
- setupStack(corsika::Code::K0Long, 400_GeV, nodePtr, *csPtr);
- { [[maybe_unused]] auto const& dummy = stackPtr; }
+ auto [env, csPtr, nodePtr] =
+ setup::testing::setupEnvironment(particles::Code::Oxygen);
+ [[maybe_unused]] auto const& env_dummy = env; // against warnings
+ [[maybe_unused]] auto const& node_dummy = nodePtr; // against warnings
+
+ auto [stackPtr, secViewPtr] = setup::testing::setupStack(particles::Code::K0Long, 0,
+ 0, 400_GeV, nodePtr, *csPtr);
+ REQUIRE(stackPtr->getEntries() == 1);
+ REQUIRE(secViewPtr->getEntries() == 0);
// must be assigned to variable, cannot be used as rvalue?!
auto projectile = secViewPtr->GetProjectile();
auto const projectileMomentum = projectile.GetMomentum();
- urqmd.doInteraction(projectile);
+ [[maybe_unused]] process::EProcessReturn const ret = urqmd.DoInteraction(*secViewPtr);
REQUIRE(sumCharge(*secViewPtr) == corsika::charge_number(corsika::Code::K0Long) +
corsika::charge_number(corsika::Code::Oxygen));
diff --git a/tests/stack/CMakeLists.txt b/tests/stack/CMakeLists.txt
index 26c8fb911..d559a5e13 100644
--- a/tests/stack/CMakeLists.txt
+++ b/tests/stack/CMakeLists.txt
@@ -1,9 +1,11 @@
set (test_stack_sources
TestMain.cpp
- testSuperStupidStack.cpp
- testNuclearStackExtension.cpp
+ testHistoryStack.cpp
+ testHistoryView.cpp
testGeometryNodeStackExtension.cpp
testDummyStack.cpp
+ testSuperStupidStack.cpp
+ testNuclearStackExtension.cpp
)
CORSIKA_ADD_TEST (testStack SOURCES ${test_stack_sources})
diff --git a/tests/stack/testNuclearStackExtension.cpp b/tests/stack/testNuclearStackExtension.cpp
index 491904d51..6edd0cc67 100644
--- a/tests/stack/testNuclearStackExtension.cpp
+++ b/tests/stack/testNuclearStackExtension.cpp
@@ -27,7 +27,7 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
s;
s.addParticle(
std::make_tuple(Code::Electron, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s));
CHECK(s.getEntries() == 1);
}
@@ -38,7 +38,7 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
s;
s.addParticle(std::make_tuple(
Code::Nucleus, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, 10, 10));
CHECK(s.getEntries() == 1);
}
@@ -47,7 +47,7 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
nuclear_stack::ParticleDataStack s;
CHECK_THROWS(s.addParticle(
std::make_tuple(Code::Nucleus, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, 0, 0)));
}
@@ -55,7 +55,7 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
nuclear_stack::ParticleDataStack s;
s.addParticle(
std::make_tuple(Code::Electron, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s));
const auto pout = s.getNextParticle();
CHECK(pout.getPID() == Code::Electron);
@@ -67,7 +67,7 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
nuclear_stack::ParticleDataStack s;
s.addParticle(
std::make_tuple(Code::Nucleus, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, 10, 9));
const auto pout = s.getNextParticle();
CHECK(pout.getPID() == Code::Nucleus);
@@ -81,7 +81,7 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
nuclear_stack::ParticleDataStack s;
s.addParticle(
std::make_tuple(Code::Electron, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s));
const auto pout = s.getNextParticle();
CHECK_THROWS(pout.getNuclearA());
@@ -96,12 +96,12 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
if ((i + 1) % 10 == 0) {
s.addParticle(std::make_tuple(
Code::Nucleus, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, i, i / 2));
} else {
s.addParticle(
std::make_tuple(Code::Electron, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s));
}
}
@@ -120,12 +120,12 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
if ((i + 1) % 10 == 0) {
s.addParticle(std::make_tuple(
Code::Nucleus, i * 15_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, i, i / 2));
} else {
s.addParticle(
std::make_tuple(Code::Electron, i * 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s));
}
}
@@ -227,25 +227,25 @@ TEST_CASE("NuclearStackExtension", "[stack]") {
// not valid:
CHECK_THROWS(s.addParticle(std::make_tuple(
Code::Oxygen, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, 16, 8)));
// valid
auto particle = s.addParticle(
std::make_tuple(Code::Nucleus, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, 10, 9));
// not valid
CHECK_THROWS(particle.addSecondary(std::make_tuple(
Code::Oxygen, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, 16, 8)));
// add a another nucleus, so there are two now
s.addParticle(
std::make_tuple(Code::Nucleus, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s, 10, 9));
// not valid, since end() is not a valid entry
diff --git a/tests/stack/testSuperStupidStack.cpp b/tests/stack/testSuperStupidStack.cpp
index cae1bbd44..4c520bcbb 100644
--- a/tests/stack/testSuperStupidStack.cpp
+++ b/tests/stack/testSuperStupidStack.cpp
@@ -26,7 +26,7 @@ TEST_CASE("SuperStupidStack", "[stack]") {
simple_stack::SuperStupidStack s;
s.addParticle(
std::make_tuple(Code::Electron, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s));
// read
@@ -44,7 +44,7 @@ TEST_CASE("SuperStupidStack", "[stack]") {
for (int i = 0; i < 99; ++i)
s.addParticle(
std::make_tuple(Code::Electron, 1.5_GeV,
- simple_stack::MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
+ MomentumVector(dummyCS, {1_GeV, 1_GeV, 1_GeV}),
Point(dummyCS, {1 * meter, 1 * meter, 1 * meter}), 100_s));
CHECK(s.getSize() == 99);
--
GitLab