From 896d611ba6b4044dfc401b8049e5b71e24ca03b4 Mon Sep 17 00:00:00 2001
From: ralfulrich <ralf.ulrich@kit.edu>
Date: Wed, 3 Feb 2021 09:26:14 +0100
Subject: [PATCH] fixed a lot of inlines and other details
---
.../detail/framework/analytics/ClassTimer.inl | 22 +--
.../framework/analytics/FunctionTimer.inl | 4 +-
corsika/detail/framework/core/Cascade.inl | 15 +-
.../framework/core/ParticleProperties.inl | 34 +++--
.../detail/framework/geometry/BaseVector.inl | 7 +-
.../framework/geometry/CoordinateSystem.inl | 6 +-
.../detail/framework/geometry/FourVector.inl | 40 ++---
corsika/detail/framework/geometry/Helix.inl | 10 +-
corsika/detail/framework/geometry/Point.inl | 15 +-
corsika/detail/framework/geometry/Vector.inl | 34 +++--
.../framework/process/InteractionCounter.inl | 2 +-
.../process/InteractionHistogram.inl | 11 +-
.../framework/process/ProcessSequence.inl | 30 ++--
.../process/SwitchProcessSequence.inl | 2 +-
.../detail/framework/stack/CombinedStack.inl | 1 -
.../detail/framework/stack/SecondaryView.inl | 59 ++++----
corsika/detail/framework/stack/Stack.inl | 142 ++++++++----------
corsika/detail/framework/utility/COMBoost.inl | 2 +-
.../detail/framework/utility/CorsikaData.inl | 2 +-
.../framework/utility/CorsikaFenvOSX.inl | 4 +-
corsika/detail/media/BaseExponential.inl | 11 +-
corsika/detail/media/Environment.inl | 15 +-
corsika/detail/media/FlatExponential.inl | 20 +--
corsika/detail/media/HomogeneousMedium.inl | 17 ++-
corsika/detail/media/InhomogeneousMedium.inl | 10 +-
.../LayeredSphericalAtmosphereBuilder.inl | 15 +-
.../media/LinearApproximationIntegrator.inl | 8 +-
corsika/detail/media/MediumPropertyModel.inl | 6 +-
corsika/detail/media/NuclearComposition.inl | 4 +-
corsika/detail/media/ShowerAxis.inl | 20 +--
.../detail/media/SlidingPlanarExponential.inl | 12 +-
.../detail/media/UniformRefractiveIndex.inl | 6 +-
corsika/detail/media/Universe.inl | 4 +-
corsika/detail/media/VolumeTreeNode.inl | 20 +--
corsika/detail/media/WeightProvider.inl | 12 +-
.../detail/modules/HadronicElasticModel.inl | 13 +-
.../detail/modules/LongitudinalProfile.inl | 12 +-
corsika/detail/modules/ObservationPlane.inl | 13 +-
corsika/detail/modules/OnShellCheck.inl | 8 +-
corsika/detail/modules/ParticleCut.inl | 36 +++--
corsika/detail/modules/StackInspector.inl | 8 +-
corsika/detail/modules/TrackWriter.inl | 8 +-
corsika/detail/modules/TrackingLine.inl | 4 +-
corsika/detail/modules/conex/CONEXhybrid.inl | 16 +-
.../modules/energy_loss/BetheBlochPDG.inl | 40 ++---
.../modules/proposal/ContinuousProcess.inl | 24 +--
.../detail/modules/proposal/Interaction.inl | 8 +-
.../modules/proposal/ProposalProcessBase.inl | 7 +-
corsika/detail/modules/pythia8/Decay.inl | 34 ++---
.../detail/modules/pythia8/Interaction.inl | 25 +--
corsika/detail/modules/pythia8/Random.inl | 2 +-
.../detail/modules/qgsjetII/Interaction.inl | 17 ++-
.../detail/modules/qgsjetII/QGSJetIIStack.inl | 51 ++++---
.../detail/modules/qgsjetII/qgsjet-II-04.inl | 10 +-
.../modules/sibyll/NuclearInteraction.inl | 21 ++-
.../tracking/TrackingLeapFrogCurved.inl | 4 +-
.../modules/tracking/TrackingStraight.inl | 12 +-
corsika/detail/modules/urqmd/UrQMD.inl | 22 +--
corsika/detail/stack/VectorStack.inl | 4 +-
.../stack/history/HistoryObservationPlane.inl | 14 +-
corsika/framework/analytics/Timer.hpp | 10 +-
corsika/framework/core/ParticleProperties.hpp | 6 +-
.../framework/geometry/CoordinateSystem.hpp | 29 ++--
corsika/framework/geometry/FourVector.hpp | 4 +-
corsika/framework/geometry/Helix.hpp | 10 +-
corsika/framework/geometry/Line.hpp | 16 +-
corsika/framework/geometry/Point.hpp | 20 +--
corsika/framework/geometry/QuantityVector.hpp | 4 +-
corsika/framework/geometry/Vector.hpp | 20 +--
corsika/framework/process/ProcessSequence.hpp | 50 +++---
.../framework/process/SecondariesProcess.hpp | 2 +-
corsika/framework/process/StackProcess.hpp | 2 +-
.../process/SwitchProcessSequence.hpp | 27 ++--
corsika/framework/random/RNGManager.hpp | 21 ++-
.../random/UniformRealDistribution.hpp | 12 +-
corsika/framework/stack/CombinedStack.hpp | 27 ++--
corsika/framework/stack/ParticleBase.hpp | 22 ++-
corsika/framework/stack/SecondaryView.hpp | 78 +++++-----
corsika/framework/stack/Stack.hpp | 85 ++++++-----
.../stack/StackIteratorInterface.hpp | 38 ++---
corsika/framework/utility/COMBoost.hpp | 8 +-
.../framework/utility/SaveBoostHistogram.hpp | 4 +-
corsika/framework/utility/Singleton.hpp | 2 -
corsika/media/NameModel.hpp | 1 -
corsika/media/NuclearComposition.hpp | 22 +--
corsika/media/Universe.hpp | 4 +-
corsika/media/VolumeTreeNode.hpp | 29 ++--
corsika/modules/qgsjetII/Interaction.hpp | 3 -
corsika/stack/DummyStack.hpp | 16 +-
corsika/stack/GeometryNodeStackExtension.hpp | 36 +++--
corsika/stack/NuclearStackExtension.hpp | 58 ++++---
corsika/stack/VectorStack.hpp | 10 +-
examples/vertical_EAS.cpp | 4 +
tests/framework/testProcessSequence.cpp | 20 +--
tests/modules/testQGSJetII.cpp | 10 ++
95 files changed, 868 insertions(+), 877 deletions(-)
diff --git a/corsika/detail/framework/analytics/ClassTimer.inl b/corsika/detail/framework/analytics/ClassTimer.inl
index dca6fb5ce..8f2c6945a 100644
--- a/corsika/detail/framework/analytics/ClassTimer.inl
+++ b/corsika/detail/framework/analytics/ClassTimer.inl
@@ -23,12 +23,13 @@ namespace corsika {
template <typename TClass, typename TRet, typename... TArgs,
TRet (TClass::*TFuncPtr)(TArgs...), typename TTimer>
- ClassTimer<TRet (TClass::*)(TArgs...), TFuncPtr, TTimer>::ClassTimer(TClass& obj)
+ inline ClassTimer<TRet (TClass::*)(TArgs...), TFuncPtr, TTimer>::ClassTimer(TClass& obj)
: ClassTimerImpl<TClass, TTimer>(obj) {}
template <typename TClass, typename TRet, typename... TArgs,
TRet (TClass::*TFuncPtr)(TArgs...), typename TTimer>
- TRet ClassTimer<TRet (TClass::*)(TArgs...), TFuncPtr, TTimer>::call(TArgs... args) {
+ inline TRet ClassTimer<TRet (TClass::*)(TArgs...), TFuncPtr, TTimer>::call(
+ TArgs... args) {
this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
auto tmp = (this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
this->timeDiff_ = std::chrono::duration_cast<
@@ -41,12 +42,13 @@ namespace corsika {
template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...),
typename TTimer>
- ClassTimer<void (TClass::*)(TArgs...), TFuncPtr, TTimer>::ClassTimer(TClass& obj)
+ inline ClassTimer<void (TClass::*)(TArgs...), TFuncPtr, TTimer>::ClassTimer(TClass& obj)
: ClassTimerImpl<TClass, TTimer>(obj) {}
template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...),
typename TTimer>
- void ClassTimer<void (TClass::*)(TArgs...), TFuncPtr, TTimer>::call(TArgs... args) {
+ inline void ClassTimer<void (TClass::*)(TArgs...), TFuncPtr, TTimer>::call(
+ TArgs... args) {
this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
(this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
this->timeDiff_ = std::chrono::duration_cast<
@@ -59,12 +61,13 @@ namespace corsika {
template <typename TClass, typename TRet, typename... TArgs,
TRet (TClass::*TFuncPtr)(TArgs...) const, typename TTimer>
- ClassTimer<TRet (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::ClassTimer(TClass& obj)
+ inline ClassTimer<TRet (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::ClassTimer(
+ TClass& obj)
: ClassTimerImpl<TClass, TTimer>(obj) {}
template <typename TClass, typename TRet, typename... TArgs,
TRet (TClass::*TFuncPtr)(TArgs...) const, typename TTimer>
- TRet ClassTimer<TRet (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::call(
+ inline TRet ClassTimer<TRet (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::call(
TArgs... args) {
this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
auto tmp = (this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
@@ -77,12 +80,13 @@ namespace corsika {
/// Specialisation 3
template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...) const,
typename TTimer>
- ClassTimer<void (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::ClassTimer(TClass& obj)
+ inline ClassTimer<void (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::ClassTimer(
+ TClass& obj)
: ClassTimerImpl<TClass, TTimer>(obj) {}
template <typename TClass, typename... TArgs, void (TClass::*TFuncPtr)(TArgs...) const,
typename TTimer>
- void ClassTimer<void (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::call(
+ inline void ClassTimer<void (TClass::*)(TArgs...) const, TFuncPtr, TTimer>::call(
TArgs... args) {
this->start_ = ClassTimerImpl<TClass, TTimer>::clock_type::now();
(this->obj_.*TFuncPtr)(std::forward<TArgs>(args)...);
@@ -92,4 +96,4 @@ namespace corsika {
return;
}
-} // namespace corsika
\ No newline at end of file
+} // namespace corsika
diff --git a/corsika/detail/framework/analytics/FunctionTimer.inl b/corsika/detail/framework/analytics/FunctionTimer.inl
index e00bebc33..911fb683c 100644
--- a/corsika/detail/framework/analytics/FunctionTimer.inl
+++ b/corsika/detail/framework/analytics/FunctionTimer.inl
@@ -13,12 +13,12 @@
namespace corsika {
template <typename TFunc, typename TTime>
- FunctionTimer<TFunc, TTime>::FunctionTimer(TFunc f)
+ inline FunctionTimer<TFunc, TTime>::FunctionTimer(TFunc f)
: function_(f) {}
template <typename TFunc, typename TTime>
template <typename... TArgs>
- auto FunctionTimer<TFunc, TTime>::operator()(TArgs&&... args)
+ inline auto FunctionTimer<TFunc, TTime>::operator()(TArgs&&... args)
-> std::invoke_result_t<TFunc, TArgs...> {
this->startTimer();
auto tmp = function_(std::forward<TArgs>(args)...);
diff --git a/corsika/detail/framework/core/Cascade.inl b/corsika/detail/framework/core/Cascade.inl
index 75c74d2b7..5f218b878 100644
--- a/corsika/detail/framework/core/Cascade.inl
+++ b/corsika/detail/framework/core/Cascade.inl
@@ -28,7 +28,7 @@ namespace corsika {
template <typename TTracking, typename TProcessList, typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::run() {
+ inline void Cascade<TTracking, TProcessList, TStack, TStackView>::run() {
setNodes(); // put each particle on stack in correct environment volume
while (!stack_.isEmpty()) {
@@ -55,7 +55,7 @@ namespace corsika {
template <typename TTracking, typename TProcessList, typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::forceInteraction() {
+ inline void Cascade<TTracking, TProcessList, TStack, TStackView>::forceInteraction() {
CORSIKA_LOG_TRACE("forced interaction!");
setNodes();
auto vParticle = stack_.getNextParticle();
@@ -67,7 +67,8 @@ namespace corsika {
template <typename TTracking, typename TProcessList, typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::step(Particle& vParticle) {
+ inline void Cascade<TTracking, TProcessList, TStack, TStackView>::step(
+ Particle& vParticle) {
// determine combined total interaction length (inverse)
InverseGrammageType const total_inv_lambda =
@@ -236,7 +237,7 @@ namespace corsika {
template <typename TTracking, typename TProcessList, typename TStack,
typename TStackView>
- ProcessReturn Cascade<TTracking, TProcessList, TStack, TStackView>::decay(
+ inline ProcessReturn Cascade<TTracking, TProcessList, TStack, TStackView>::decay(
TStackView& view) {
CORSIKA_LOG_DEBUG("decay");
InverseTimeType const actual_decay_time = sequence_.getInverseLifetime(view.parent());
@@ -254,7 +255,7 @@ namespace corsika {
template <typename TTracking, typename TProcessList, typename TStack,
typename TStackView>
- ProcessReturn Cascade<TTracking, TProcessList, TStack, TStackView>::interaction(
+ inline ProcessReturn Cascade<TTracking, TProcessList, TStack, TStackView>::interaction(
TStackView& view) {
CORSIKA_LOG_DEBUG("collide");
@@ -274,7 +275,7 @@ namespace corsika {
template <typename TTracking, typename TProcessList, typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::setNodes() {
+ inline void Cascade<TTracking, TProcessList, TStack, TStackView>::setNodes() {
std::for_each(stack_.begin(), stack_.end(), [&](auto& p) {
auto const* numericalNode =
environment_.getUniverse()->getContainingNode(p.getPosition());
@@ -284,7 +285,7 @@ namespace corsika {
template <typename TTracking, typename TProcessList, typename TStack,
typename TStackView>
- void Cascade<TTracking, TProcessList, TStack, TStackView>::setEventType(
+ inline 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); }
diff --git a/corsika/detail/framework/core/ParticleProperties.inl b/corsika/detail/framework/core/ParticleProperties.inl
index b478b1e17..7d0aa253b 100644
--- a/corsika/detail/framework/core/ParticleProperties.inl
+++ b/corsika/detail/framework/core/ParticleProperties.inl
@@ -13,72 +13,74 @@
namespace corsika {
- HEPEnergyType constexpr get_energy_threshold(Code const p) {
+ inline HEPEnergyType constexpr get_energy_threshold(Code const p) {
return particle::detail::thresholds[static_cast<CodeIntType>(p)];
}
- void constexpr set_energy_threshold(Code const p, HEPEnergyType const val) {
+ inline void constexpr set_energy_threshold(Code const p, HEPEnergyType const val) {
particle::detail::thresholds[static_cast<CodeIntType>(p)] = val;
}
- HEPMassType constexpr get_mass(Code const p) {
+ inline HEPMassType constexpr get_mass(Code const p) {
if (p == Code::Nucleus)
throw std::runtime_error("Cannot GetMass() of particle::Nucleus -> unspecified");
return particle::detail::masses[static_cast<CodeIntType>(p)];
}
- PDGCode constexpr get_PDG(Code const p) {
+ inline PDGCode constexpr get_PDG(Code const p) {
return particle::detail::pdg_codes[static_cast<CodeIntType>(p)];
}
- int16_t constexpr get_charge_number(Code const code) {
+ inline int16_t constexpr get_charge_number(Code const code) {
if (code == Code::Nucleus)
throw std::runtime_error("charge of particle::Nucleus undefined");
return particle::detail::electric_charges[static_cast<CodeIntType>(code)];
}
- ElectricChargeType constexpr get_charge(Code const code) {
+ inline ElectricChargeType constexpr get_charge(Code const code) {
return get_charge_number(code) * constants::e;
}
- std::string_view constexpr get_name(Code const code) {
+ inline std::string_view constexpr get_name(Code const code) {
return particle::detail::names[static_cast<CodeIntType>(code)];
}
- TimeType constexpr get_lifetime(Code const p) {
+ inline TimeType constexpr get_lifetime(Code const p) {
return particle::detail::lifetime[static_cast<CodeIntType>(p)] * second;
}
- bool constexpr is_hadron(Code const p) {
+ inline bool constexpr is_hadron(Code const p) {
return particle::detail::isHadron[static_cast<CodeIntType>(p)];
}
- bool constexpr is_em(Code c) {
+ inline bool constexpr is_em(Code c) {
return c == Code::Electron || c == Code::Positron || c == Code::Gamma;
}
- bool constexpr is_muon(Code c) { return c == Code::MuPlus || c == Code::MuMinus; }
+ inline bool constexpr is_muon(Code c) {
+ return c == Code::MuPlus || c == Code::MuMinus;
+ }
- bool constexpr is_neutrino(Code c) {
+ inline bool constexpr is_neutrino(Code c) {
return c == Code::NuE || c == Code::NuMu || c == Code::NuTau || c == Code::NuEBar ||
c == Code::NuMuBar || c == Code::NuTauBar;
}
- int constexpr get_nucleus_A(Code const code) {
+ inline int constexpr get_nucleus_A(Code const code) {
if (code == Code::Nucleus) {
throw std::runtime_error("get_nucleus_A(Code::Nucleus) is impossible!");
}
return particle::detail::nucleusA[static_cast<CodeIntType>(code)];
}
- int constexpr get_nucleus_Z(Code const code) {
+ inline int constexpr get_nucleus_Z(Code const code) {
if (code == Code::Nucleus) {
throw std::runtime_error("get_nucleus_Z(Code::Nucleus) is impossible!");
}
return particle::detail::nucleusZ[static_cast<CodeIntType>(code)];
}
- bool constexpr is_nucleus(Code const code) {
+ inline bool constexpr is_nucleus(Code const code) {
return (code == Code::Nucleus) || (get_nucleus_A(code) != 0);
}
@@ -102,7 +104,7 @@ namespace corsika {
return get_mass(Code::Proton) * Z + (A - Z) * get_mass(Code::Neutron);
}
- std::initializer_list<Code> constexpr get_all_particles() {
+ inline std::initializer_list<Code> constexpr get_all_particles() {
return particle::detail::all_particles;
}
diff --git a/corsika/detail/framework/geometry/BaseVector.inl b/corsika/detail/framework/geometry/BaseVector.inl
index 50ec4b03b..486a62d26 100644
--- a/corsika/detail/framework/geometry/BaseVector.inl
+++ b/corsika/detail/framework/geometry/BaseVector.inl
@@ -14,17 +14,18 @@
namespace corsika {
template <typename TDimension>
- CoordinateSystemPtr BaseVector<TDimension>::getCoordinateSystem() const {
+ inline CoordinateSystemPtr BaseVector<TDimension>::getCoordinateSystem() const {
return cs_;
}
template <typename TDimension>
- QuantityVector<TDimension> const& BaseVector<TDimension>::getQuantityVector() const {
+ inline QuantityVector<TDimension> const& BaseVector<TDimension>::getQuantityVector()
+ const {
return quantityVector_;
}
template <typename TDimension>
- QuantityVector<TDimension>& BaseVector<TDimension>::getQuantityVector() {
+ inline QuantityVector<TDimension>& BaseVector<TDimension>::getQuantityVector() {
return quantityVector_;
}
diff --git a/corsika/detail/framework/geometry/CoordinateSystem.inl b/corsika/detail/framework/geometry/CoordinateSystem.inl
index efcf716d3..faa759aa7 100644
--- a/corsika/detail/framework/geometry/CoordinateSystem.inl
+++ b/corsika/detail/framework/geometry/CoordinateSystem.inl
@@ -19,9 +19,11 @@
namespace corsika {
- CoordinateSystemPtr CoordinateSystem::getReferenceCS() const { return referenceCS_; }
+ inline CoordinateSystemPtr CoordinateSystem::getReferenceCS() const {
+ return referenceCS_;
+ }
- EigenTransform const& CoordinateSystem::getTransform() const { return transf_; }
+ inline EigenTransform const& CoordinateSystem::getTransform() const { return transf_; }
inline bool CoordinateSystem::operator==(CoordinateSystem const& cs) const {
return referenceCS_ == cs.referenceCS_ && transf_.matrix() == cs.transf_.matrix();
diff --git a/corsika/detail/framework/geometry/FourVector.inl b/corsika/detail/framework/geometry/FourVector.inl
index 6c0a039e5..5d871430d 100644
--- a/corsika/detail/framework/geometry/FourVector.inl
+++ b/corsika/detail/framework/geometry/FourVector.inl
@@ -15,47 +15,47 @@
namespace corsika {
template <typename TTimeType, typename TSpaceVecType>
- TTimeType FourVector<TTimeType, TSpaceVecType>::getTimeLikeComponent() const {
+ inline TTimeType FourVector<TTimeType, TSpaceVecType>::getTimeLikeComponent() const {
return timeLike_;
}
template <typename TTimeType, typename TSpaceVecType>
- TSpaceVecType& FourVector<TTimeType, TSpaceVecType>::getSpaceLikeComponents() {
+ inline TSpaceVecType& FourVector<TTimeType, TSpaceVecType>::getSpaceLikeComponents() {
return spaceLike_;
}
template <typename TTimeType, typename TSpaceVecType>
- TSpaceVecType const& FourVector<TTimeType, TSpaceVecType>::getSpaceLikeComponents()
- const {
+ inline TSpaceVecType const&
+ FourVector<TTimeType, TSpaceVecType>::getSpaceLikeComponents() const {
return spaceLike_;
}
template <typename TTimeType, typename TSpaceVecType>
- typename FourVector<TTimeType, TSpaceVecType>::norm_square_type
+ inline typename FourVector<TTimeType, TSpaceVecType>::norm_square_type
FourVector<TTimeType, TSpaceVecType>::getNormSqr() const {
return getTimeSquared() - spaceLike_.getSquaredNorm();
}
template <typename TTimeType, typename TSpaceVecType>
- typename FourVector<TTimeType, TSpaceVecType>::norm_type
+ inline typename FourVector<TTimeType, TSpaceVecType>::norm_type
FourVector<TTimeType, TSpaceVecType>::getNorm() const {
return sqrt(abs(getNormSqr()));
}
template <typename TTimeType, typename TSpaceVecType>
- bool FourVector<TTimeType, TSpaceVecType>::isTimelike() const {
+ inline bool FourVector<TTimeType, TSpaceVecType>::isTimelike() const {
return getTimeSquared() < spaceLike_.getSquaredNorm();
}
template <typename TTimeType, typename TSpaceVecType>
- bool FourVector<TTimeType, TSpaceVecType>::isSpacelike() const {
+ inline bool FourVector<TTimeType, TSpaceVecType>::isSpacelike() const {
return getTimeSquared() > spaceLike_.getSquaredNorm();
}
template <typename TTimeType, typename TSpaceVecType>
- FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::operator+=(
- FourVector const& b) {
+ inline FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::
+ operator+=(FourVector const& b) {
timeLike_ += b.timeLike_;
spaceLike_ += b.spaceLike_;
@@ -63,38 +63,38 @@ namespace corsika {
}
template <typename TTimeType, typename TSpaceVecType>
- FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::operator-=(
- FourVector const& b) {
+ inline FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::
+ operator-=(FourVector const& b) {
timeLike_ -= b.timeLike_;
spaceLike_ -= b.spaceLike_;
return *this;
}
template <typename TTimeType, typename TSpaceVecType>
- FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::operator*=(
- double const b) {
+ inline FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::
+ operator*=(double const b) {
timeLike_ *= b;
spaceLike_ *= b;
return *this;
}
template <typename TTimeType, typename TSpaceVecType>
- FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::operator/=(
- double const b) {
+ inline FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::
+ operator/=(double const b) {
timeLike_ /= b;
spaceLike_.getComponents() /= b;
return *this;
}
template <typename TTimeType, typename TSpaceVecType>
- FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::operator/(
- double const b) {
+ inline FourVector<TTimeType, TSpaceVecType>& FourVector<TTimeType, TSpaceVecType>::
+ operator/(double const b) {
*this /= b;
return *this;
}
template <typename TTimeType, typename TSpaceVecType>
- typename FourVector<TTimeType, TSpaceVecType>::norm_type
+ inline typename FourVector<TTimeType, TSpaceVecType>::norm_type
FourVector<TTimeType, TSpaceVecType>::operator*(FourVector const& b) {
if constexpr (std::is_same<time_type, decltype(std::declval<space_type>() / meter *
second)>::value)
@@ -104,7 +104,7 @@ namespace corsika {
}
template <typename TTimeType, typename TSpaceVecType>
- typename FourVector<TTimeType, TSpaceVecType>::norm_square_type
+ inline typename FourVector<TTimeType, TSpaceVecType>::norm_square_type
FourVector<TTimeType, TSpaceVecType>::getTimeSquared() const {
if constexpr (std::is_same<time_type, decltype(std::declval<space_type>() / meter *
second)>::value)
diff --git a/corsika/detail/framework/geometry/Helix.inl b/corsika/detail/framework/geometry/Helix.inl
index daf0c310f..03c0fd85d 100644
--- a/corsika/detail/framework/geometry/Helix.inl
+++ b/corsika/detail/framework/geometry/Helix.inl
@@ -15,23 +15,23 @@
namespace corsika {
- LengthType Helix::getRadius() const { return radius_; }
+ inline LengthType Helix::getRadius() const { return radius_; }
- Point Helix::getPosition(TimeType const t) const {
+ inline Point Helix::getPosition(TimeType const t) const {
return r0_ + vPar_ * t +
(vPerp_ * (std::cos(omegaC_ * t) - 1) + uPerp_ * std::sin(omegaC_ * t)) /
omegaC_;
}
- Point Helix::getPositionFromArclength(LengthType const l) const {
+ inline Point Helix::getPositionFromArclength(LengthType const l) const {
return getPosition(getTimeFromArclength(l));
}
- LengthType Helix::getArcLength(TimeType const t1, TimeType const t2) const {
+ inline LengthType Helix::getArcLength(TimeType const t1, TimeType const t2) const {
return (vPar_ + vPerp_).getNorm() * (t2 - t1);
}
- TimeType Helix::getTimeFromArclength(LengthType const l) const {
+ inline TimeType Helix::getTimeFromArclength(LengthType const l) const {
return l / (vPar_ + vPerp_).getNorm();
}
diff --git a/corsika/detail/framework/geometry/Point.inl b/corsika/detail/framework/geometry/Point.inl
index 45c6900f5..c5c0a98a6 100644
--- a/corsika/detail/framework/geometry/Point.inl
+++ b/corsika/detail/framework/geometry/Point.inl
@@ -15,11 +15,11 @@
namespace corsika {
- QuantityVector<length_d> const& Point::getCoordinates() const {
+ inline QuantityVector<length_d> const& Point::getCoordinates() const {
return BaseVector<length_d>::getQuantityVector();
}
- QuantityVector<length_d>& Point::getCoordinates() {
+ inline QuantityVector<length_d>& Point::getCoordinates() {
return BaseVector<length_d>::getQuantityVector();
}
@@ -60,7 +60,8 @@ namespace corsika {
}
/// this always returns a QuantityVector as triple
- QuantityVector<length_d> Point::getCoordinates(CoordinateSystemPtr const& pCS) const {
+ inline QuantityVector<length_d> Point::getCoordinates(
+ CoordinateSystemPtr const& pCS) const {
CoordinateSystemPtr const& cs = BaseVector<length_d>::getCoordinateSystem();
if (*pCS == *cs) {
return BaseVector<length_d>::getQuantityVector();
@@ -72,12 +73,12 @@ namespace corsika {
}
/// this always returns a QuantityVector as triple
- QuantityVector<length_d>& Point::getCoordinates(CoordinateSystemPtr const& pCS) {
+ inline QuantityVector<length_d>& Point::getCoordinates(CoordinateSystemPtr const& pCS) {
if (*pCS != *BaseVector<length_d>::getCoordinateSystem()) { rebase(pCS); }
return BaseVector<length_d>::getQuantityVector();
}
- void Point::rebase(CoordinateSystemPtr const& pCS) {
+ inline void Point::rebase(CoordinateSystemPtr const& pCS) {
BaseVector<length_d>::setQuantityVector(QuantityVector<length_d>(
get_transformation(*BaseVector<length_d>::getCoordinateSystem().get(),
*pCS.get()) *
@@ -85,12 +86,12 @@ namespace corsika {
BaseVector<length_d>::setCoordinateSystem(pCS);
}
- Point Point::operator+(Vector<length_d> const& pVec) const {
+ inline Point Point::operator+(Vector<length_d> const& pVec) const {
CoordinateSystemPtr const& cs = BaseVector<length_d>::getCoordinateSystem();
return Point(cs, getCoordinates() + pVec.getComponents(cs));
}
- Vector<length_d> Point::operator-(Point const& pB) const {
+ inline Vector<length_d> Point::operator-(Point const& pB) const {
CoordinateSystemPtr const& cs = BaseVector<length_d>::getCoordinateSystem();
return Vector<length_d>(cs, getCoordinates() - pB.getCoordinates(cs));
}
diff --git a/corsika/detail/framework/geometry/Vector.inl b/corsika/detail/framework/geometry/Vector.inl
index ff968693f..352eb8b30 100644
--- a/corsika/detail/framework/geometry/Vector.inl
+++ b/corsika/detail/framework/geometry/Vector.inl
@@ -88,7 +88,7 @@ namespace corsika {
}
template <typename TDimension>
- void Vector<TDimension>::rebase(CoordinateSystemPtr const& pCS) {
+ inline void Vector<TDimension>::rebase(CoordinateSystemPtr const& pCS) {
BaseVector<TDimension>::setQuantityVector(QuantityVector<TDimension>(
get_transformation(*BaseVector<TDimension>::getCoordinateSystem().get(),
*pCS.get())
@@ -110,7 +110,7 @@ namespace corsika {
template <typename TDimension>
template <typename TDimension2>
- auto Vector<TDimension>::getParallelProjectionOnto(
+ inline auto Vector<TDimension>::getParallelProjectionOnto(
Vector<TDimension2> const& pVec, CoordinateSystemPtr const& pCS) const {
auto const ourCompVec = getComponents(pCS);
auto const otherCompVec = pVec.getComponents(pCS);
@@ -123,34 +123,36 @@ namespace corsika {
template <typename TDimension>
template <typename TDimension2>
- auto Vector<TDimension>::getParallelProjectionOnto(
+ inline auto Vector<TDimension>::getParallelProjectionOnto(
Vector<TDimension2> const& pVec) const {
return getParallelProjectionOnto<TDimension2>(
pVec, BaseVector<TDimension>::getCoordinateSystem());
}
template <typename TDimension>
- Vector<TDimension> Vector<TDimension>::operator+(Vector<TDimension> const& pVec) const {
+ inline Vector<TDimension> Vector<TDimension>::operator+(
+ Vector<TDimension> const& pVec) const {
CoordinateSystemPtr const& cs = BaseVector<TDimension>::getCoordinateSystem();
auto const components = getComponents(cs) + pVec.getComponents(cs);
return Vector<TDimension>(BaseVector<TDimension>::getCoordinateSystem(), components);
}
template <typename TDimension>
- Vector<TDimension> Vector<TDimension>::operator-(Vector<TDimension> const& pVec) const {
+ inline Vector<TDimension> Vector<TDimension>::operator-(
+ Vector<TDimension> const& pVec) const {
CoordinateSystemPtr const& cs = BaseVector<TDimension>::getCoordinateSystem();
return Vector<TDimension>(cs, getComponents() - pVec.getComponents(cs));
}
template <typename TDimension>
- auto& Vector<TDimension>::operator*=(double const p) {
+ inline auto& Vector<TDimension>::operator*=(double const p) {
BaseVector<TDimension>::getQuantityVector() *= p;
return *this;
}
template <typename TDimension>
template <typename TScalarDim>
- auto Vector<TDimension>::operator*(
+ inline auto Vector<TDimension>::operator*(
phys::units::quantity<TScalarDim, double> const p) const {
using ProdDim = phys::units::detail::product_d<TDimension, TScalarDim>;
@@ -160,51 +162,51 @@ namespace corsika {
template <typename TDimension>
template <typename TScalarDim>
- auto Vector<TDimension>::operator/(
+ inline auto Vector<TDimension>::operator/(
phys::units::quantity<TScalarDim, double> const p) const {
return (*this) * (1 / p);
}
template <typename TDimension>
- auto Vector<TDimension>::operator*(double const p) const {
+ inline auto Vector<TDimension>::operator*(double const p) const {
return Vector<TDimension>(BaseVector<TDimension>::getCoordinateSystem(),
BaseVector<TDimension>::getQuantityVector() * p);
}
template <typename TDimension>
- auto Vector<TDimension>::operator/(double const p) const {
+ inline auto Vector<TDimension>::operator/(double const p) const {
return Vector<TDimension>(BaseVector<TDimension>::getCoordinateSystem(),
BaseVector<TDimension>::getQuantityVector() / p);
}
template <typename TDimension>
- auto& Vector<TDimension>::operator+=(Vector<TDimension> const& pVec) {
+ inline auto& Vector<TDimension>::operator+=(Vector<TDimension> const& pVec) {
BaseVector<TDimension>::getQuantityVector() +=
pVec.getComponents(BaseVector<TDimension>::getCoordinateSystem());
return *this;
}
template <typename TDimension>
- auto& Vector<TDimension>::operator-=(Vector<TDimension> const& pVec) {
+ inline auto& Vector<TDimension>::operator-=(Vector<TDimension> const& pVec) {
BaseVector<TDimension>::getQuantityVector() -=
pVec.getComponents(BaseVector<TDimension>::getCoordinateSystem());
return *this;
}
template <typename TDimension>
- auto& Vector<TDimension>::operator-() const {
+ inline auto& Vector<TDimension>::operator-() const {
return Vector<TDimension>(BaseVector<TDimension>::getCoordinateSystem(),
-BaseVector<TDimension>::getQuantityVector());
}
template <typename TDimension>
- auto Vector<TDimension>::normalized() const {
+ inline auto Vector<TDimension>::normalized() const {
return (*this) * (1 / getNorm());
}
template <typename TDimension>
template <typename TDimension2>
- auto Vector<TDimension>::cross(Vector<TDimension2> const& pV) const {
+ inline auto Vector<TDimension>::cross(Vector<TDimension2> const& pV) const {
auto const c1 = getComponents().eigenVector_;
auto const c2 =
pV.getComponents(BaseVector<TDimension>::getCoordinateSystem()).eigenVector_;
@@ -216,7 +218,7 @@ namespace corsika {
template <typename TDimension>
template <typename TDimension2>
- auto Vector<TDimension>::dot(Vector<TDimension2> const& pV) const {
+ inline auto Vector<TDimension>::dot(Vector<TDimension2> const& pV) const {
auto const c1 = getComponents().eigenVector_;
auto const c2 =
pV.getComponents(BaseVector<TDimension>::getCoordinateSystem()).eigenVector_;
diff --git a/corsika/detail/framework/process/InteractionCounter.inl b/corsika/detail/framework/process/InteractionCounter.inl
index 34c93ce43..d3572bf98 100644
--- a/corsika/detail/framework/process/InteractionCounter.inl
+++ b/corsika/detail/framework/process/InteractionCounter.inl
@@ -13,7 +13,7 @@
namespace corsika {
template <class TCountedProcess>
- InteractionCounter<TCountedProcess>::InteractionCounter(TCountedProcess& process)
+ inline InteractionCounter<TCountedProcess>::InteractionCounter(TCountedProcess& process)
: process_(process) {}
template <class TCountedProcess>
diff --git a/corsika/detail/framework/process/InteractionHistogram.inl b/corsika/detail/framework/process/InteractionHistogram.inl
index e6cfae869..efeb29c00 100644
--- a/corsika/detail/framework/process/InteractionHistogram.inl
+++ b/corsika/detail/framework/process/InteractionHistogram.inl
@@ -16,13 +16,13 @@
namespace corsika {
- InteractionHistogram::InteractionHistogram()
+ inline InteractionHistogram::InteractionHistogram()
: inthist_cms_{detail::hist_factory(num_bins_cms, lower_edge_cms, upper_edge_cms)}
, inthist_lab_{detail::hist_factory(num_bins_lab, lower_edge_lab, upper_edge_lab)} {
}
- void InteractionHistogram::fill(Code projectile_id, HEPEnergyType lab_energy,
- HEPEnergyType mass_target, int A, int Z) {
+ inline void InteractionHistogram::fill(Code projectile_id, HEPEnergyType lab_energy,
+ HEPEnergyType mass_target, int A, int Z) {
auto constexpr inv_eV = 1 / 1_eV;
if (projectile_id == Code::Nucleus) {
auto const sqrtS = sqrt(A * A * (constants::nucleonMass * constants::nucleonMass) +
@@ -42,7 +42,7 @@ namespace corsika {
}
}
- InteractionHistogram& InteractionHistogram::operator+=(
+ inline InteractionHistogram& InteractionHistogram::operator+=(
InteractionHistogram const& other) {
inthist_lab_ += other.inthist_lab_;
inthist_cms_ += other.inthist_cms_;
@@ -50,7 +50,8 @@ namespace corsika {
return *this;
}
- InteractionHistogram InteractionHistogram::operator+(InteractionHistogram other) const {
+ inline InteractionHistogram InteractionHistogram::operator+(
+ InteractionHistogram other) const {
other.inthist_lab_ += inthist_lab_;
other.inthist_cms_ += inthist_cms_;
diff --git a/corsika/detail/framework/process/ProcessSequence.inl b/corsika/detail/framework/process/ProcessSequence.inl
index 19056ad6c..7a0d6409f 100644
--- a/corsika/detail/framework/process/ProcessSequence.inl
+++ b/corsika/detail/framework/process/ProcessSequence.inl
@@ -29,7 +29,7 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TParticle>
- ProcessReturn ProcessSequence<
+ inline ProcessReturn ProcessSequence<
TProcess1, TProcess2, IndexStart, IndexProcess1,
IndexProcess2>::doBoundaryCrossing(TParticle& particle,
typename TParticle::node_type const& from,
@@ -54,7 +54,7 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TParticle, typename TTrack>
- ProcessReturn
+ inline ProcessReturn
ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1, IndexProcess2>::
doContinuous(TParticle& particle, TTrack& vT,
[[maybe_unused]] ContinuousProcessIndex const limitId) {
@@ -81,8 +81,8 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TSecondaries>
- void ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
- IndexProcess2>::doSecondaries(TSecondaries& vS) {
+ inline void ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
+ IndexProcess2>::doSecondaries(TSecondaries& vS) {
if constexpr (std::is_base_of_v<SecondariesProcess<process1_type>, process1_type> ||
t1ProcSeq) {
A_.doSecondaries(vS);
@@ -95,8 +95,8 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
- bool ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
- IndexProcess2>::checkStep() {
+ inline bool ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
+ IndexProcess2>::checkStep() {
bool ret = false;
if constexpr (std::is_base_of_v<StackProcess<process1_type>, process1_type> ||
(t1ProcSeq && !t1SwitchProcSeq)) {
@@ -112,8 +112,8 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TStack>
- void ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
- IndexProcess2>::doStack(TStack& stack) {
+ inline void ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
+ IndexProcess2>::doStack(TStack& stack) {
if constexpr (std::is_base_of_v<StackProcess<process1_type>, process1_type> ||
(t1ProcSeq && !t1SwitchProcSeq)) {
if (A_.checkStep()) { A_.doStack(stack); }
@@ -124,20 +124,10 @@ namespace corsika {
}
}
- /**
- * Calculate the maximum allowed length of the next tracking step, based on all
- * ContinuousProcess-es
- *
- * The maximum allowed step length is the minimum of the allowed track lenght over all
- * ContinuousProcess-es in the ProcessSequence.
- *
- * \return: ContinuousProcessStepLength which contains the step length itself in
- * LengthType, and a unique identifier of the related ContinuousProcess.
- **/
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TParticle, typename TTrack>
- ContinuousProcessStepLength
+ inline ContinuousProcessStepLength
ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
IndexProcess2>::getMaxStepLength(TParticle& particle, TTrack& vTrack) {
// if no other process in the sequence implements it
@@ -167,7 +157,7 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TParticle>
- InverseGrammageType
+ inline InverseGrammageType
ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
IndexProcess2>::getInverseInteractionLength(TParticle&& particle) {
diff --git a/corsika/detail/framework/process/SwitchProcessSequence.inl b/corsika/detail/framework/process/SwitchProcessSequence.inl
index 2eadc8782..c4f8ede12 100644
--- a/corsika/detail/framework/process/SwitchProcessSequence.inl
+++ b/corsika/detail/framework/process/SwitchProcessSequence.inl
@@ -30,7 +30,7 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
int IndexProcess1, int IndexProcess2>
template <typename TParticle, typename TVTNType>
- ProcessReturn
+ inline ProcessReturn
SwitchProcessSequence<TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
IndexProcess2>::doBoundaryCrossing(TParticle& particle,
TVTNType const& from,
diff --git a/corsika/detail/framework/stack/CombinedStack.inl b/corsika/detail/framework/stack/CombinedStack.inl
index 0c95ad15e..1cdc7abd9 100644
--- a/corsika/detail/framework/stack/CombinedStack.inl
+++ b/corsika/detail/framework/stack/CombinedStack.inl
@@ -59,7 +59,6 @@ namespace corsika {
pi_b_type::setParticleData(static_cast<pi_b_type&>(p), vB);
}
- ///@}
template <template <typename> class TParticleInterfaceA,
template <typename> class TParticleInterfaceB, typename TStackIterator>
inline std::string CombinedParticleInterface<TParticleInterfaceA, TParticleInterfaceB,
diff --git a/corsika/detail/framework/stack/SecondaryView.inl b/corsika/detail/framework/stack/SecondaryView.inl
index 33160aa08..4b27a5087 100644
--- a/corsika/detail/framework/stack/SecondaryView.inl
+++ b/corsika/detail/framework/stack/SecondaryView.inl
@@ -15,17 +15,11 @@
#include <vector>
namespace corsika {
- /*
- template <typename TStackDataType, template <typename> typename TParticleInterface,
- template <typename T1, template <class> class T2> class MSecondaryProducer>
- SecondaryView< TStackDataType,TParticleInterface, MSecondaryProducer>::
-
- */
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
template <typename... Args>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::addSecondary(
const Args... v) {
CORSIKA_LOG_TRACE("SecondaryView::addSecondary(Args&&)");
@@ -35,8 +29,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::begin() {
unsigned int i = 0;
for (; i < getSize(); ++i) {
@@ -48,8 +42,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::const_stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::const_stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::begin() const {
unsigned int i = 0;
for (; i < getSize(); ++i) {
@@ -61,8 +55,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::const_stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::const_stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::cbegin() const {
unsigned int i = 0;
for (; i < getSize(); ++i) {
@@ -74,8 +68,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::last() {
unsigned int i = 0;
for (; i < getSize(); ++i) {
@@ -86,8 +80,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::const_stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::const_stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::last() const {
unsigned int i = 0;
for (; i < getSize(); ++i) {
@@ -98,8 +92,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::const_stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::const_stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::clast() const {
unsigned int i = 0;
for (; i < getSize(); ++i) {
@@ -111,7 +105,7 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::swap(
+ inline void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::swap(
stack_view_iterator a, stack_view_iterator b) {
CORSIKA_LOG_TRACE("View::swap");
@@ -121,7 +115,7 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::copy(
+ inline void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::copy(
stack_view_iterator a, stack_view_iterator b) {
CORSIKA_LOG_TRACE("View::copy");
@@ -131,7 +125,7 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::copy(
+ inline void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::copy(
const_stack_view_iterator a, stack_view_iterator b) {
CORSIKA_LOG_TRACE("View::copy");
@@ -141,8 +135,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::erase(
- stack_view_iterator p) {
+ inline void SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::erase(stack_view_iterator p) {
CORSIKA_LOG_TRACE("SecondaryView::Delete");
if (isEmpty()) { /*error*/
@@ -157,8 +151,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- bool SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::purgeLastIfDeleted() {
+ inline bool SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::purgeLastIfDeleted() {
CORSIKA_LOG_TRACE("SecondaryView::purgeLastIfDeleted");
if (!isErased(getSize() - 1))
return false; // the last particle is not marked for deletion. Do nothing.
@@ -170,7 +164,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- void SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::purge() {
+ inline void
+ SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::purge() {
unsigned int iStack = 0;
unsigned int size = getSize();
while (iStack < size) {
@@ -187,8 +182,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
- std::string SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::asString() const {
+ inline std::string SecondaryView<TStackDataType, TParticleInterface,
+ 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 = " ";
@@ -206,8 +201,8 @@ namespace corsika {
template <typename TStackDataType, template <typename> typename TParticleInterface,
template <typename T1, template <class> class T2> class MSecondaryProducer>
template <typename... Args>
- typename SecondaryView<TStackDataType, TParticleInterface,
- MSecondaryProducer>::stack_view_iterator
+ inline typename SecondaryView<TStackDataType, TParticleInterface,
+ MSecondaryProducer>::stack_view_iterator
SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>::addSecondary(
stack_view_iterator& proj, const Args... v) {
CORSIKA_LOG_TRACE("SecondaryView::addSecondary(stack_view_iterator&, Args&&)");
diff --git a/corsika/detail/framework/stack/Stack.inl b/corsika/detail/framework/stack/Stack.inl
index 30c7c7460..4569a23a8 100644
--- a/corsika/detail/framework/stack/Stack.inl
+++ b/corsika/detail/framework/stack/Stack.inl
@@ -21,15 +21,15 @@ namespace corsika {
template <typename StackData, template <typename> typename MParticleInterface>
template <typename... TArgs>
- void Stack<StackData, MParticleInterface>::clear(TArgs... args) {
+ inline 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() {
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type inline Stack<
+ StackData, MParticleInterface>::begin() {
unsigned int i = 0;
for (; i < getSize(); ++i) {
if (!deleted_[i]) break;
@@ -38,14 +38,14 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::end() {
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type inline 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() {
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type inline Stack<
+ StackData, MParticleInterface>::last() {
unsigned int i = 0;
for (; i < getSize(); ++i) {
if (!deleted_[getSize() - 1 - i]) break;
@@ -54,8 +54,8 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::begin() const {
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type inline Stack<
+ StackData, MParticleInterface>::begin() const {
unsigned int i = 0;
for (; i < getSize(); ++i) {
if (!deleted_[i]) break;
@@ -64,8 +64,8 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::end() const {
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type inline Stack<
+ StackData, MParticleInterface>::end() const {
return const_stack_iterator_type(*this, getSize());
}
@@ -80,8 +80,8 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::cbegin() const {
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type inline Stack<
+ StackData, MParticleInterface>::cbegin() const {
unsigned int i = 0;
for (; i < getSize(); ++i) {
if (!deleted_[i]) break;
@@ -90,14 +90,14 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::const_stack_iterator_type
- Stack<StackData, MParticleInterface>::cend() const {
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type inline 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 {
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type inline Stack<
+ StackData, MParticleInterface>::clast() const {
unsigned int i = 0;
for (; i < getSize(); ++i) {
if (!deleted_[getSize() - 1 - i]) break;
@@ -107,41 +107,40 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
- Stack<StackData, MParticleInterface>::at(unsigned int i) {
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type inline 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 {
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type inline 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() {
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type inline 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 {
+ typename Stack<StackData, MParticleInterface>::const_stack_iterator_type inline 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() {
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type inline 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) {
+ typename Stack<StackData, MParticleInterface>::stack_iterator_type inline Stack<
+ StackData, MParticleInterface>::addParticle(const TArgs... v) {
CORSIKA_LOG_TRACE("Stack::AddParticle");
data_.incrementSize();
deleted_.push_back(false);
@@ -149,22 +148,22 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::swap(stack_iterator_type a,
- stack_iterator_type b) {
+ inline 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) {
+ inline 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) {
+ inline 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_--;
@@ -173,7 +172,7 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::erase(stack_iterator_type p) {
+ inline 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");
@@ -183,54 +182,52 @@ namespace corsika {
}
this->erase(p.getIndex());
}
- /**
+
+ /*
* delete this particle
*/
-
template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::erase(particle_interface_type p) {
+ inline 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() {
+ inline 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(
+ inline 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(
+ inline 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(
+ inline 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() {
+ inline bool Stack<StackData, MParticleInterface>::purgeLastIfDeleted() {
if (!deleted_.back())
return false; // the last particle is not marked for deletion. Do nothing.
@@ -241,7 +238,7 @@ namespace corsika {
return true;
}
- /**
+ /*
* Function to ultimatively remove all entries from the stack
* marked as deleted.
*
@@ -251,7 +248,7 @@ namespace corsika {
*/
template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::purge() {
+ inline void Stack<StackData, MParticleInterface>::purge() {
unsigned int iStackFront = 0;
unsigned int iStackBack = getSize() - 1;
@@ -269,12 +266,12 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- unsigned int Stack<StackData, MParticleInterface>::getSize() const {
+ inline unsigned int Stack<StackData, MParticleInterface>::getSize() const {
return data_.getSize();
}
template <typename StackData, template <typename> typename MParticleInterface>
- std::string Stack<StackData, MParticleInterface>::asString() const {
+ inline 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
@@ -290,7 +287,7 @@ namespace corsika {
template <typename StackData, template <typename> typename MParticleInterface>
template <typename... TArgs>
- typename Stack<StackData, MParticleInterface>::stack_iterator_type
+ inline typename Stack<StackData, MParticleInterface>::stack_iterator_type
Stack<StackData, MParticleInterface>::addSecondary(stack_iterator_type& parent,
const TArgs... v) {
CORSIKA_LOG_TRACE("Stack::AddSecondary");
@@ -300,16 +297,16 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- void Stack<StackData, MParticleInterface>::swap(unsigned int const a,
- unsigned int const b) {
+ inline 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) {
+ inline 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_--;
@@ -318,24 +315,23 @@ namespace corsika {
}
template <typename StackData, template <typename> typename MParticleInterface>
- bool Stack<StackData, MParticleInterface>::isErased(unsigned int const i) const {
+ inline 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) {
+ inline 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) {
+ inline 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--; }
@@ -347,33 +343,21 @@ namespace corsika {
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(
+ inline 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&
+ inline 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&
+ inline const typename Stack<StackData, MParticleInterface>::value_type&
Stack<StackData, MParticleInterface>::getStackData() const {
return data_;
}
diff --git a/corsika/detail/framework/utility/COMBoost.inl b/corsika/detail/framework/utility/COMBoost.inl
index 54d1162c3..9b05bef0e 100644
--- a/corsika/detail/framework/utility/COMBoost.inl
+++ b/corsika/detail/framework/utility/COMBoost.inl
@@ -108,6 +108,6 @@ namespace corsika {
inverseBoost_ << coshEta, -sinhEta, -sinhEta, coshEta;
}
- CoordinateSystemPtr COMBoost::getRotatedCS() const { return rotatedCS_; }
+ inline CoordinateSystemPtr COMBoost::getRotatedCS() const { return rotatedCS_; }
} // namespace corsika
diff --git a/corsika/detail/framework/utility/CorsikaData.inl b/corsika/detail/framework/utility/CorsikaData.inl
index 80a1b77ca..e2ea1e99b 100644
--- a/corsika/detail/framework/utility/CorsikaData.inl
+++ b/corsika/detail/framework/utility/CorsikaData.inl
@@ -11,7 +11,7 @@
#include <stdexcept>
#include <string>
-std::string corsika::corsika_data(std::string const& key) {
+inline std::string corsika::corsika_data(std::string const& key) {
if (auto const* p = std::getenv("CORSIKA_DATA"); p != nullptr) {
auto const path = std::string(p) + "/" + key;
return path;
diff --git a/corsika/detail/framework/utility/CorsikaFenvOSX.inl b/corsika/detail/framework/utility/CorsikaFenvOSX.inl
index b57a6973d..e1f7cc480 100644
--- a/corsika/detail/framework/utility/CorsikaFenvOSX.inl
+++ b/corsika/detail/framework/utility/CorsikaFenvOSX.inl
@@ -28,7 +28,7 @@
extern "C" {
-int feenableexcept(int excepts) noexcept {
+inline int feenableexcept(int excepts) noexcept {
static fenv_t fenv;
int new_excepts = excepts & FE_ALL_EXCEPT;
// previous masks
@@ -44,7 +44,7 @@ int feenableexcept(int excepts) noexcept {
return fesetenv(&fenv) ? -1 : old_excepts;
}
-int fedisableexcept(int excepts) noexcept {
+inline int fedisableexcept(int excepts) noexcept {
static fenv_t fenv;
int new_excepts = excepts & FE_ALL_EXCEPT;
// all previous masks
diff --git a/corsika/detail/media/BaseExponential.inl b/corsika/detail/media/BaseExponential.inl
index 35b506610..a40981bef 100644
--- a/corsika/detail/media/BaseExponential.inl
+++ b/corsika/detail/media/BaseExponential.inl
@@ -15,12 +15,12 @@
namespace corsika {
template <typename TDerived>
- auto const& BaseExponential<TDerived>::getImplementation() const {
+ inline auto const& BaseExponential<TDerived>::getImplementation() const {
return *static_cast<TDerived const*>(this);
}
template <typename TDerived>
- GrammageType BaseExponential<TDerived>::getIntegratedGrammage(
+ inline GrammageType BaseExponential<TDerived>::getIntegratedGrammage(
setup::Trajectory const& traj, LengthType vL, DirectionVector const& axis) const {
if (vL == LengthType::zero()) { return GrammageType::zero(); }
@@ -35,7 +35,7 @@ namespace corsika {
}
template <typename TDerived>
- LengthType BaseExponential<TDerived>::getArclengthFromGrammage(
+ inline LengthType BaseExponential<TDerived>::getArclengthFromGrammage(
setup::Trajectory const& traj, GrammageType grammage,
DirectionVector const& axis) const {
auto const uDotA = traj.getDirection(0).dot(axis).magnitude();
@@ -55,8 +55,9 @@ namespace corsika {
}
template <typename TDerived>
- BaseExponential<TDerived>::BaseExponential(Point const& point, MassDensityType rho0,
- LengthType lambda)
+ inline BaseExponential<TDerived>::BaseExponential(Point const& point,
+ MassDensityType rho0,
+ LengthType lambda)
: rho0_(rho0)
, lambda_(lambda)
, invLambda_(1 / lambda)
diff --git a/corsika/detail/media/Environment.inl b/corsika/detail/media/Environment.inl
index 792182a9e..40ab05db9 100644
--- a/corsika/detail/media/Environment.inl
+++ b/corsika/detail/media/Environment.inl
@@ -13,33 +13,34 @@
namespace corsika {
template <typename IEnvironmentModel>
- Environment<IEnvironmentModel>::Environment()
+ inline Environment<IEnvironmentModel>::Environment()
: coordinateSystem_{get_root_CoordinateSystem()}
, universe_(std::make_unique<BaseNodeType>(
std::make_unique<Universe>(coordinateSystem_))) {}
template <typename IEnvironmentModel>
- typename Environment<IEnvironmentModel>::BaseNodeType::VTNUPtr&
+ inline typename Environment<IEnvironmentModel>::BaseNodeType::VTNUPtr&
Environment<IEnvironmentModel>::getUniverse() {
return universe_;
}
template <typename IEnvironmentModel>
- typename Environment<IEnvironmentModel>::BaseNodeType::VTNUPtr const&
+ inline typename Environment<IEnvironmentModel>::BaseNodeType::VTNUPtr const&
Environment<IEnvironmentModel>::getUniverse() const {
return universe_;
}
template <typename IEnvironmentModel>
- CoordinateSystemPtr const& Environment<IEnvironmentModel>::getCoordinateSystem() const {
+ inline CoordinateSystemPtr const& Environment<IEnvironmentModel>::getCoordinateSystem()
+ const {
return coordinateSystem_;
}
// factory method for creation of VolumeTreeNodes
template <typename IEnvironmentModel>
template <class TVolumeType, typename... TVolumeArgs>
- std::unique_ptr<VolumeTreeNode<IEnvironmentModel> >
- Environment<IEnvironmentModel>::createNode(TVolumeArgs&&... args) {
+ std::unique_ptr<VolumeTreeNode<IEnvironmentModel> > inline Environment<
+ IEnvironmentModel>::createNode(TVolumeArgs&&... args) {
static_assert(std::is_base_of_v<IVolume, TVolumeType>,
"unusable type provided, needs to be derived from "
"\"Volume\"");
@@ -48,4 +49,4 @@ namespace corsika {
std::make_unique<TVolumeType>(std::forward<TVolumeArgs>(args)...));
}
-} // namespace corsika
\ No newline at end of file
+} // namespace corsika
diff --git a/corsika/detail/media/FlatExponential.inl b/corsika/detail/media/FlatExponential.inl
index bc782945f..cdada02df 100644
--- a/corsika/detail/media/FlatExponential.inl
+++ b/corsika/detail/media/FlatExponential.inl
@@ -17,16 +17,16 @@
namespace corsika {
template <typename T>
- FlatExponential<T>::FlatExponential(Point const& point,
- Vector<dimensionless_d> const& axis,
- MassDensityType rho, LengthType lambda,
- NuclearComposition const& nuclComp)
+ inline FlatExponential<T>::FlatExponential(Point const& point,
+ Vector<dimensionless_d> const& axis,
+ MassDensityType rho, LengthType lambda,
+ NuclearComposition const& nuclComp)
: BaseExponential<FlatExponential<T>>(point, rho, lambda)
, axis_(axis)
, nuclComp_(nuclComp) {}
template <typename T>
- MassDensityType FlatExponential<T>::getMassDensity(Point const& point) const {
+ inline MassDensityType FlatExponential<T>::getMassDensity(Point const& point) const {
return BaseExponential<FlatExponential<T>>::getRho0() *
exp(BaseExponential<FlatExponential<T>>::getInvLambda() *
(point - BaseExponential<FlatExponential<T>>::getAnchorPoint())
@@ -34,19 +34,19 @@ namespace corsika {
}
template <typename T>
- NuclearComposition const& FlatExponential<T>::getNuclearComposition() const {
+ inline NuclearComposition const& FlatExponential<T>::getNuclearComposition() const {
return nuclComp_;
}
template <typename T>
- GrammageType FlatExponential<T>::getIntegratedGrammage(setup::Trajectory const& line,
- LengthType to) const {
+ inline GrammageType FlatExponential<T>::getIntegratedGrammage(
+ setup::Trajectory const& line, LengthType to) const {
return BaseExponential<FlatExponential<T>>::getIntegratedGrammage(line, to, axis_);
}
template <typename T>
- LengthType FlatExponential<T>::getArclengthFromGrammage(setup::Trajectory const& line,
- GrammageType grammage) const {
+ inline LengthType FlatExponential<T>::getArclengthFromGrammage(
+ setup::Trajectory const& line, GrammageType grammage) const {
return BaseExponential<FlatExponential<T>>::getArclengthFromGrammage(line, grammage,
axis_);
}
diff --git a/corsika/detail/media/HomogeneousMedium.inl b/corsika/detail/media/HomogeneousMedium.inl
index d73354aa6..fd0148b02 100644
--- a/corsika/detail/media/HomogeneousMedium.inl
+++ b/corsika/detail/media/HomogeneousMedium.inl
@@ -16,29 +16,30 @@
namespace corsika {
template <typename T>
- HomogeneousMedium<T>::HomogeneousMedium(MassDensityType density,
- NuclearComposition const& nuclComp)
+ inline HomogeneousMedium<T>::HomogeneousMedium(MassDensityType density,
+ NuclearComposition const& nuclComp)
: density_(density)
, nuclComp_(nuclComp) {}
template <typename T>
- MassDensityType HomogeneousMedium<T>::getMassDensity(Point const&) const {
+ inline MassDensityType HomogeneousMedium<T>::getMassDensity(Point const&) const {
return density_;
}
+
template <typename T>
- NuclearComposition const& HomogeneousMedium<T>::getNuclearComposition() const {
+ inline NuclearComposition const& HomogeneousMedium<T>::getNuclearComposition() const {
return nuclComp_;
}
template <typename T>
- GrammageType HomogeneousMedium<T>::getIntegratedGrammage(setup::Trajectory const&,
- LengthType to) const {
+ inline GrammageType HomogeneousMedium<T>::getIntegratedGrammage(
+ setup::Trajectory const&, LengthType to) const {
return to * density_;
}
template <typename T>
- LengthType HomogeneousMedium<T>::getArclengthFromGrammage(setup::Trajectory const&,
- GrammageType grammage) const {
+ inline LengthType HomogeneousMedium<T>::getArclengthFromGrammage(
+ setup::Trajectory const&, GrammageType grammage) const {
return grammage / density_;
}
} // namespace corsika
diff --git a/corsika/detail/media/InhomogeneousMedium.inl b/corsika/detail/media/InhomogeneousMedium.inl
index 064e9610e..48d1d266e 100644
--- a/corsika/detail/media/InhomogeneousMedium.inl
+++ b/corsika/detail/media/InhomogeneousMedium.inl
@@ -17,31 +17,31 @@ namespace corsika {
template <typename T, typename TDensityFunction>
template <typename... TArgs>
- InhomogeneousMedium<T, TDensityFunction>::InhomogeneousMedium(
+ inline InhomogeneousMedium<T, TDensityFunction>::InhomogeneousMedium(
NuclearComposition const& nuclComp, TArgs&&... rhoTArgs)
: nuclComp_(nuclComp)
, densityFunction_(rhoTArgs...) {}
template <typename T, typename TDensityFunction>
- MassDensityType InhomogeneousMedium<T, TDensityFunction>::getMassDensity(
+ inline MassDensityType InhomogeneousMedium<T, TDensityFunction>::getMassDensity(
Point const& point) const {
return densityFunction_.evaluateAt(point);
}
template <typename T, typename TDensityFunction>
- NuclearComposition const&
+ inline NuclearComposition const&
InhomogeneousMedium<T, TDensityFunction>::getNuclearComposition() const {
return nuclComp_;
}
template <typename T, typename TDensityFunction>
- GrammageType InhomogeneousMedium<T, TDensityFunction>::getIntegratedGrammage(
+ inline GrammageType InhomogeneousMedium<T, TDensityFunction>::getIntegratedGrammage(
setup::Trajectory const& line, LengthType to) const {
return densityFunction_.getIntegrateGrammage(line, to);
}
template <typename T, typename TDensityFunction>
- LengthType InhomogeneousMedium<T, TDensityFunction>::getArclengthFromGrammage(
+ inline LengthType InhomogeneousMedium<T, TDensityFunction>::getArclengthFromGrammage(
setup::Trajectory const& line, GrammageType grammage) const {
return densityFunction_.getArclengthFromGrammage(line, grammage);
}
diff --git a/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl b/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl
index e42310da2..74f00f101 100644
--- a/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl
+++ b/corsika/detail/media/LayeredSphericalAtmosphereBuilder.inl
@@ -18,8 +18,9 @@ namespace corsika {
template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
typename... TModelArgs>
- void LayeredSphericalAtmosphereBuilder<TMediumInterface, TMediumModelExtra,
- TModelArgs...>::checkRadius(LengthType r) const {
+ inline void LayeredSphericalAtmosphereBuilder<TMediumInterface, TMediumModelExtra,
+ TModelArgs...>::checkRadius(LengthType r)
+ const {
if (r <= previousRadius_) {
throw std::runtime_error("radius must be greater than previous");
}
@@ -27,7 +28,7 @@ namespace corsika {
template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
typename... TModelArgs>
- void LayeredSphericalAtmosphereBuilder<
+ inline void LayeredSphericalAtmosphereBuilder<
TMediumInterface, TMediumModelExtra,
TModelArgs...>::setNuclearComposition(NuclearComposition const& composition) {
composition_ = std::make_unique<NuclearComposition>(composition);
@@ -35,7 +36,7 @@ namespace corsika {
template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
typename... TModelArgs>
- void LayeredSphericalAtmosphereBuilder<
+ inline void LayeredSphericalAtmosphereBuilder<
TMediumInterface, TMediumModelExtra,
TModelArgs...>::addExponentialLayer(GrammageType b, LengthType c,
LengthType upperBoundary) {
@@ -70,7 +71,7 @@ namespace corsika {
template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
typename... TModelArgs>
- void LayeredSphericalAtmosphereBuilder<
+ inline void LayeredSphericalAtmosphereBuilder<
TMediumInterface, TMediumModelExtra,
TModelArgs...>::addLinearLayer(LengthType c, LengthType upperBoundary) {
auto const radius = earthRadius_ + upperBoundary;
@@ -104,7 +105,7 @@ namespace corsika {
template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
typename... TModelArgs>
- Environment<TMediumInterface> LayeredSphericalAtmosphereBuilder<
+ inline Environment<TMediumInterface> LayeredSphericalAtmosphereBuilder<
TMediumInterface, TMediumModelExtra, TModelArgs...>::assemble() {
Environment<TMediumInterface> env;
assemble(env);
@@ -113,7 +114,7 @@ namespace corsika {
template <typename TMediumInterface, template <typename> typename TMediumModelExtra,
typename... TModelArgs>
- void LayeredSphericalAtmosphereBuilder<
+ inline void LayeredSphericalAtmosphereBuilder<
TMediumInterface, TMediumModelExtra,
TModelArgs...>::assemble(Environment<TMediumInterface>& env) {
auto& universe = env.getUniverse();
diff --git a/corsika/detail/media/LinearApproximationIntegrator.inl b/corsika/detail/media/LinearApproximationIntegrator.inl
index 7452ff31d..78b7733ed 100644
--- a/corsika/detail/media/LinearApproximationIntegrator.inl
+++ b/corsika/detail/media/LinearApproximationIntegrator.inl
@@ -13,12 +13,12 @@
namespace corsika {
template <typename TDerived>
- auto const& LinearApproximationIntegrator<TDerived>::getImplementation() const {
+ inline auto const& LinearApproximationIntegrator<TDerived>::getImplementation() const {
return *static_cast<TDerived const*>(this);
}
template <typename TDerived>
- auto LinearApproximationIntegrator<TDerived>::getIntegrateGrammage(
+ inline auto LinearApproximationIntegrator<TDerived>::getIntegrateGrammage(
setup::Trajectory const& line, LengthType length) const {
auto const c0 = getImplementation().evaluateAt(line.getPosition(0));
auto const c1 = getImplementation().rho_.getFirstDerivative(line.getPosition(0),
@@ -27,7 +27,7 @@ namespace corsika {
}
template <typename TDerived>
- auto LinearApproximationIntegrator<TDerived>::getArclengthFromGrammage(
+ inline auto LinearApproximationIntegrator<TDerived>::getArclengthFromGrammage(
setup::Trajectory const& line, GrammageType grammage) const {
auto const c0 = getImplementation().rho_(line.getPosition(0));
auto const c1 = getImplementation().rho_.getFirstDerivative(line.getPosition(0),
@@ -37,7 +37,7 @@ namespace corsika {
}
template <typename TDerived>
- auto LinearApproximationIntegrator<TDerived>::getMaximumLength(
+ inline auto LinearApproximationIntegrator<TDerived>::getMaximumLength(
setup::Trajectory const& line, [[maybe_unused]] double relError) const {
[[maybe_unused]] auto const c1 = getImplementation().rho_.getSecondDerivative(
line.getPosition(0), line.getDirection(0));
diff --git a/corsika/detail/media/MediumPropertyModel.inl b/corsika/detail/media/MediumPropertyModel.inl
index 90cdd9754..604175989 100644
--- a/corsika/detail/media/MediumPropertyModel.inl
+++ b/corsika/detail/media/MediumPropertyModel.inl
@@ -14,17 +14,17 @@ namespace corsika {
template <typename T>
template <typename... Args>
- MediumPropertyModel<T>::MediumPropertyModel(Medium const medium, Args&&... args)
+ inline MediumPropertyModel<T>::MediumPropertyModel(Medium const medium, Args&&... args)
: T(std::forward<Args>(args)...)
, medium_(medium) {}
template <typename T>
- Medium MediumPropertyModel<T>::getMedium(Point const&) const {
+ inline Medium MediumPropertyModel<T>::getMedium(Point const&) const {
return medium_;
}
template <typename T>
- void MediumPropertyModel<T>::setMedium(Medium const medium) {
+ inline void MediumPropertyModel<T>::setMedium(Medium const medium) {
medium_ = medium;
}
diff --git a/corsika/detail/media/NuclearComposition.inl b/corsika/detail/media/NuclearComposition.inl
index 230dfe1a1..85582510e 100644
--- a/corsika/detail/media/NuclearComposition.inl
+++ b/corsika/detail/media/NuclearComposition.inl
@@ -22,8 +22,8 @@
namespace corsika {
- NuclearComposition::NuclearComposition(std::vector<Code> const& pComponents,
- std::vector<float> const& pFractions)
+ inline NuclearComposition::NuclearComposition(std::vector<Code> const& pComponents,
+ std::vector<float> const& pFractions)
: numberFractions_(pFractions)
, components_(pComponents)
, avgMassNumber_(std::inner_product(
diff --git a/corsika/detail/media/ShowerAxis.inl b/corsika/detail/media/ShowerAxis.inl
index 1be5d40a6..a42989e92 100644
--- a/corsika/detail/media/ShowerAxis.inl
+++ b/corsika/detail/media/ShowerAxis.inl
@@ -14,9 +14,9 @@
namespace corsika {
template <typename TEnvModel>
- ShowerAxis::ShowerAxis(Point const& pStart, Vector<length_d> const& length,
- Environment<TEnvModel> const& env, bool const doThrow,
- int const steps)
+ inline ShowerAxis::ShowerAxis(Point const& pStart, Vector<length_d> const& length,
+ Environment<TEnvModel> const& env, bool const doThrow,
+ int const steps)
: pointStart_(pStart)
, length_(length)
, throw_(doThrow)
@@ -58,7 +58,7 @@ namespace corsika {
assert(std::is_sorted(d_.cbegin(), d_.cend()));
}
- GrammageType ShowerAxis::getX(LengthType l) const {
+ inline GrammageType ShowerAxis::getX(LengthType l) const {
double const fractionalBin = l / steplength_;
int const lower = fractionalBin; // indices of nearest X support points
double const fraction = fractionalBin - lower;
@@ -97,21 +97,21 @@ namespace corsika {
return X_[upper] * fraction + X_[lower] * (1 - fraction);
}
- LengthType ShowerAxis::getSteplength() const { return steplength_; }
+ inline LengthType ShowerAxis::getSteplength() const { return steplength_; }
- GrammageType ShowerAxis::getMaximumX() const { return *X_.rbegin(); }
+ inline GrammageType ShowerAxis::getMaximumX() const { return *X_.rbegin(); }
- GrammageType ShowerAxis::getMinimumX() const { return GrammageType::zero(); }
+ inline GrammageType ShowerAxis::getMinimumX() const { return GrammageType::zero(); }
- GrammageType ShowerAxis::getProjectedX(Point const& p) const {
+ inline GrammageType ShowerAxis::getProjectedX(Point const& p) const {
auto const projectedLength = (p - pointStart_).dot(axis_normalized_);
return getX(projectedLength);
}
- Vector<dimensionless_d> const& ShowerAxis::getDirection() const {
+ inline DirectionVector const& ShowerAxis::getDirection() const {
return axis_normalized_;
}
- Point const& ShowerAxis::getStart() const { return pointStart_; }
+ inline Point const& ShowerAxis::getStart() const { return pointStart_; }
} // namespace corsika
diff --git a/corsika/detail/media/SlidingPlanarExponential.inl b/corsika/detail/media/SlidingPlanarExponential.inl
index c5c517954..56d99404c 100644
--- a/corsika/detail/media/SlidingPlanarExponential.inl
+++ b/corsika/detail/media/SlidingPlanarExponential.inl
@@ -13,7 +13,7 @@
namespace corsika {
template <typename T>
- SlidingPlanarExponential<T>::SlidingPlanarExponential(
+ inline SlidingPlanarExponential<T>::SlidingPlanarExponential(
Point const& p0, MassDensityType rho0, LengthType lambda,
NuclearComposition const& nuclComp, LengthType referenceHeight)
: BaseExponential<SlidingPlanarExponential<T>>(p0, rho0, lambda)
@@ -21,7 +21,8 @@ namespace corsika {
, referenceHeight_(referenceHeight) {}
template <typename T>
- MassDensityType SlidingPlanarExponential<T>::getMassDensity(Point const& point) const {
+ inline MassDensityType SlidingPlanarExponential<T>::getMassDensity(
+ Point const& point) const {
auto const height =
(point - BaseExponential<SlidingPlanarExponential<T>>::getAnchorPoint())
.getNorm() -
@@ -31,12 +32,13 @@ namespace corsika {
}
template <typename T>
- NuclearComposition const& SlidingPlanarExponential<T>::getNuclearComposition() const {
+ inline NuclearComposition const& SlidingPlanarExponential<T>::getNuclearComposition()
+ const {
return nuclComp_;
}
template <typename T>
- GrammageType SlidingPlanarExponential<T>::getIntegratedGrammage(
+ inline GrammageType SlidingPlanarExponential<T>::getIntegratedGrammage(
setup::Trajectory const& traj, LengthType l) const {
auto const axis = (traj.getPosition(0) -
BaseExponential<SlidingPlanarExponential<T>>::getAnchorPoint())
@@ -46,7 +48,7 @@ namespace corsika {
}
template <typename T>
- LengthType SlidingPlanarExponential<T>::getArclengthFromGrammage(
+ inline LengthType SlidingPlanarExponential<T>::getArclengthFromGrammage(
setup::Trajectory const& traj, GrammageType const grammage) const {
auto const axis = (traj.getPosition(0) -
BaseExponential<SlidingPlanarExponential<T>>::getAnchorPoint())
diff --git a/corsika/detail/media/UniformRefractiveIndex.inl b/corsika/detail/media/UniformRefractiveIndex.inl
index 1abea2470..d6e5f5a9d 100644
--- a/corsika/detail/media/UniformRefractiveIndex.inl
+++ b/corsika/detail/media/UniformRefractiveIndex.inl
@@ -14,17 +14,17 @@ namespace corsika {
template <typename T>
template <typename... Args>
- UniformRefractiveIndex<T>::UniformRefractiveIndex(double const n, Args&&... args)
+ inline UniformRefractiveIndex<T>::UniformRefractiveIndex(double const n, Args&&... args)
: T(std::forward<Args>(args)...)
, n_(n) {}
template <typename T>
- double UniformRefractiveIndex<T>::getRefractiveIndex(Point const&) const {
+ inline double UniformRefractiveIndex<T>::getRefractiveIndex(Point const&) const {
return n_;
}
template <typename T>
- void UniformRefractiveIndex<T>::setRefractiveIndex(double const& n) {
+ inline void UniformRefractiveIndex<T>::setRefractiveIndex(double const& n) {
n_ = n;
}
diff --git a/corsika/detail/media/Universe.inl b/corsika/detail/media/Universe.inl
index b3f4d2541..c965ab335 100644
--- a/corsika/detail/media/Universe.inl
+++ b/corsika/detail/media/Universe.inl
@@ -12,10 +12,10 @@
namespace corsika {
- Universe::Universe(CoordinateSystemPtr const& pCS)
+ inline Universe::Universe(CoordinateSystemPtr const& pCS)
: corsika::Sphere(Point{pCS, 0 * meter, 0 * meter, 0 * meter},
meter * std::numeric_limits<double>::infinity()) {}
- bool Universe::contains(corsika::Point const&) const { return true; }
+ inline bool Universe::contains(corsika::Point const&) const { return true; }
} // namespace corsika
diff --git a/corsika/detail/media/VolumeTreeNode.inl b/corsika/detail/media/VolumeTreeNode.inl
index bdae7cc12..7a334e61f 100644
--- a/corsika/detail/media/VolumeTreeNode.inl
+++ b/corsika/detail/media/VolumeTreeNode.inl
@@ -14,7 +14,7 @@
namespace corsika {
template <typename IModelProperties>
- bool VolumeTreeNode<IModelProperties>::contains(Point const& p) const {
+ inline bool VolumeTreeNode<IModelProperties>::contains(Point const& p) const {
return geoVolume_->contains(p);
}
@@ -32,7 +32,7 @@ namespace corsika {
* \class Point \p p, or nullptr iff \p p is not contained in this volume.
*/
template <typename IModelProperties>
- VolumeTreeNode<IModelProperties> const*
+ inline VolumeTreeNode<IModelProperties> const*
VolumeTreeNode<IModelProperties>::getContainingNode(Point const& p) const {
if (!contains(p)) { return nullptr; }
@@ -54,7 +54,7 @@ namespace corsika {
template <typename IModelProperties>
template <typename TCallable, bool preorder>
- void VolumeTreeNode<IModelProperties>::walk(TCallable func) {
+ inline void VolumeTreeNode<IModelProperties>::walk(TCallable func) {
if constexpr (preorder) { func(*this); }
std::for_each(childNodes_.begin(), childNodes_.end(),
@@ -64,7 +64,7 @@ namespace corsika {
}
template <typename IModelProperties>
- void VolumeTreeNode<IModelProperties>::addChild(
+ inline void VolumeTreeNode<IModelProperties>::addChild(
typename VolumeTreeNode<IModelProperties>::VTNUPtr pChild) {
pChild->parentNode_ = this;
childNodes_.push_back(std::move(pChild));
@@ -74,19 +74,9 @@ namespace corsika {
}
template <typename IModelProperties>
- void VolumeTreeNode<IModelProperties>::excludeOverlapWith(
+ inline void VolumeTreeNode<IModelProperties>::excludeOverlapWith(
typename VolumeTreeNode<IModelProperties>::VTNUPtr const& pNode) {
excludedNodes_.push_back(pNode.get());
}
- /*
- template <typename IModelProperties>
- template <class MediumType, typename... Args>
- auto VolumeTreeNode<IModelProperties>::createMedium(Args&&... args) {
- static_assert(std::is_base_of_v<IMediumModel, MediumType>,
- "unusable type provided, needs to be derived from \"IMediumModel\"");
-
- return std::make_shared<MediumType>(std::forward<Args>(args)...);
- }
- */
} // namespace corsika
diff --git a/corsika/detail/media/WeightProvider.inl b/corsika/detail/media/WeightProvider.inl
index af9849aa3..b9cf1be7a 100644
--- a/corsika/detail/media/WeightProvider.inl
+++ b/corsika/detail/media/WeightProvider.inl
@@ -13,19 +13,19 @@
namespace corsika {
template <class AConstIterator, class BConstIterator>
- WeightProviderIterator<AConstIterator, BConstIterator>::WeightProviderIterator(
+ inline WeightProviderIterator<AConstIterator, BConstIterator>::WeightProviderIterator(
AConstIterator a, BConstIterator b)
: aIter_(a)
, bIter_(b) {}
template <class AConstIterator, class BConstIterator>
- typename WeightProviderIterator<AConstIterator, BConstIterator>::value_type
+ inline typename WeightProviderIterator<AConstIterator, BConstIterator>::value_type
WeightProviderIterator<AConstIterator, BConstIterator>::operator*() const {
return ((*aIter_) * (*bIter_)).magnitude();
}
template <class AConstIterator, class BConstIterator>
- WeightProviderIterator<AConstIterator, BConstIterator>&
+ inline WeightProviderIterator<AConstIterator, BConstIterator>&
WeightProviderIterator<AConstIterator,
BConstIterator>::operator++() { // prefix ++
++aIter_;
@@ -34,15 +34,15 @@ namespace corsika {
}
template <class AConstIterator, class BConstIterator>
- bool WeightProviderIterator<AConstIterator, BConstIterator>::operator==(
+ inline bool WeightProviderIterator<AConstIterator, BConstIterator>::operator==(
WeightProviderIterator other) {
return aIter_ == other.aIter_;
}
template <class AConstIterator, class BConstIterator>
- bool WeightProviderIterator<AConstIterator, BConstIterator>::operator!=(
+ inline bool WeightProviderIterator<AConstIterator, BConstIterator>::operator!=(
WeightProviderIterator other) {
return !(*this == other);
}
-} // namespace corsika
\ No newline at end of file
+} // namespace corsika
diff --git a/corsika/detail/modules/HadronicElasticModel.inl b/corsika/detail/modules/HadronicElasticModel.inl
index bb5c16133..e048a2d91 100644
--- a/corsika/detail/modules/HadronicElasticModel.inl
+++ b/corsika/detail/modules/HadronicElasticModel.inl
@@ -23,13 +23,14 @@
namespace corsika {
- HadronicElasticInteraction::HadronicElasticInteraction(CrossSectionType x,
- CrossSectionType y)
+ inline HadronicElasticInteraction::HadronicElasticInteraction(CrossSectionType x,
+ CrossSectionType y)
: parX_(x)
, parY_(y) {}
template <>
- GrammageType HadronicElasticInteraction::getInteractionLength(SetupParticle const& p) {
+ inline GrammageType HadronicElasticInteraction::getInteractionLength(
+ SetupParticle const& p) {
if (p.getPID() == Code::Proton) {
auto const* currentNode = p.getNode();
auto const& mediumComposition =
@@ -69,7 +70,7 @@ namespace corsika {
}
template <typename TParticle>
- ProcessReturn HadronicElasticInteraction::doInteraction(TParticle& p) {
+ inline ProcessReturn HadronicElasticInteraction::doInteraction(TParticle& p) {
if (p.getPID() != Code::Proton) { return ProcessReturn::Ok; }
const auto* currentNode = p.getNode();
@@ -160,7 +161,7 @@ namespace corsika {
return ProcessReturn::Ok;
}
- HadronicElasticInteraction::inveV2 HadronicElasticInteraction::B(eV2 s) const {
+ inline HadronicElasticInteraction::inveV2 HadronicElasticInteraction::B(eV2 s) const {
auto constexpr b_p = 2.3;
auto const result =
(2 * b_p + 2 * b_p + 4 * pow(s * constants::invGeVsq, gfEpsilon) - 4.2) *
@@ -170,7 +171,7 @@ namespace corsika {
return result;
}
- CrossSectionType HadronicElasticInteraction::getCrossSection(
+ inline CrossSectionType HadronicElasticInteraction::getCrossSection(
SquaredHEPEnergyType s) const {
// assuming every target behaves like a proton, parX_ and parY_ are universal
CrossSectionType const sigmaTotal = parX_ * pow(s * constants::invGeVsq, gfEpsilon) +
diff --git a/corsika/detail/modules/LongitudinalProfile.inl b/corsika/detail/modules/LongitudinalProfile.inl
index df6bb471d..d332913b5 100644
--- a/corsika/detail/modules/LongitudinalProfile.inl
+++ b/corsika/detail/modules/LongitudinalProfile.inl
@@ -20,14 +20,16 @@
namespace corsika {
- LongitudinalProfile::LongitudinalProfile(ShowerAxis const& shower_axis, GrammageType dX)
+ inline LongitudinalProfile::LongitudinalProfile(ShowerAxis const& shower_axis,
+ GrammageType dX)
: dX_(dX)
, shower_axis_{shower_axis}
, profiles_{static_cast<unsigned int>(shower_axis.getMaximumX() / dX_) + 1} {}
template <typename TParticle, typename TTrack>
- ProcessReturn LongitudinalProfile::doContinuous(TParticle const& vP,
- TTrack const& vTrack, bool const) {
+ inline ProcessReturn LongitudinalProfile::doContinuous(TParticle const& vP,
+ TTrack const& vTrack,
+ bool const) {
auto const pid = vP.getPID();
GrammageType const grammageStart = shower_axis_.getProjectedX(vTrack.getPosition(0));
@@ -60,8 +62,8 @@ namespace corsika {
return ProcessReturn::Ok;
}
- void LongitudinalProfile::save(std::string const& filename, const int width,
- const int precision) {
+ inline void LongitudinalProfile::save(std::string const& filename, const int width,
+ const int precision) {
std::ofstream f{filename};
f << "# X / g·cm¯², gamma, e+, e-, mu+, mu-, all hadrons" << std::endl;
for (size_t b = 0; b < profiles_.size(); ++b) {
diff --git a/corsika/detail/modules/ObservationPlane.inl b/corsika/detail/modules/ObservationPlane.inl
index 697481b8b..f3e77a4c8 100644
--- a/corsika/detail/modules/ObservationPlane.inl
+++ b/corsika/detail/modules/ObservationPlane.inl
@@ -14,8 +14,9 @@
namespace corsika {
- ObservationPlane::ObservationPlane(Plane const& obsPlane, DirectionVector const& x_axis,
- std::string const& filename, bool deleteOnHit)
+ inline ObservationPlane::ObservationPlane(Plane const& obsPlane,
+ DirectionVector const& x_axis,
+ std::string const& filename, bool deleteOnHit)
: plane_(obsPlane)
, outputStream_(filename)
, deleteOnHit_(deleteOnHit)
@@ -27,7 +28,7 @@ namespace corsika {
<< std::endl;
}
- ProcessReturn ObservationPlane::doContinuous(
+ inline ProcessReturn ObservationPlane::doContinuous(
corsika::setup::Stack::particle_type& particle, corsika::setup::Trajectory&,
bool const stepLimit) {
@@ -54,7 +55,7 @@ namespace corsika {
}
}
- LengthType ObservationPlane::getMaxStepLength(
+ inline LengthType ObservationPlane::getMaxStepLength(
corsika::setup::Stack::particle_type const& particle,
corsika::setup::Trajectory const& trajectory) {
@@ -82,7 +83,7 @@ namespace corsika {
return dist;
}
- void ObservationPlane::showResults() const {
+ inline void ObservationPlane::showResults() const {
CORSIKA_LOG_INFO(
" ******************************\n"
" ObservationPlane: \n"
@@ -92,7 +93,7 @@ namespace corsika {
energy_ground_ / 1_GeV, count_ground_);
}
- void ObservationPlane::reset() {
+ inline void ObservationPlane::reset() {
energy_ground_ = 0_GeV;
count_ground_ = 0;
}
diff --git a/corsika/detail/modules/OnShellCheck.inl b/corsika/detail/modules/OnShellCheck.inl
index f8f0b0081..c7ee250f2 100644
--- a/corsika/detail/modules/OnShellCheck.inl
+++ b/corsika/detail/modules/OnShellCheck.inl
@@ -14,8 +14,8 @@
namespace corsika {
- OnShellCheck::OnShellCheck(double const vMassTolerance, double const vEnergyTolerance,
- bool const vError)
+ inline OnShellCheck::OnShellCheck(double const vMassTolerance,
+ double const vEnergyTolerance, bool const vError)
: mass_tolerance_(vMassTolerance)
, energy_tolerance_(vEnergyTolerance)
, throw_error_(vError) {
@@ -25,7 +25,7 @@ namespace corsika {
energy_tolerance_ * 100);
}
- OnShellCheck::~OnShellCheck() {
+ inline OnShellCheck::~OnShellCheck() {
logger_->info(
" summary \n"
" particles shifted: {} \n"
@@ -35,7 +35,7 @@ namespace corsika {
}
template <typename TView>
- void OnShellCheck::doSecondaries(TView& vS) {
+ inline void OnShellCheck::doSecondaries(TView& vS) {
for (auto& p : vS) {
auto const pid = p.getPID();
if (is_nucleus(pid)) continue;
diff --git a/corsika/detail/modules/ParticleCut.inl b/corsika/detail/modules/ParticleCut.inl
index 3fd882225..f4d756675 100644
--- a/corsika/detail/modules/ParticleCut.inl
+++ b/corsika/detail/modules/ParticleCut.inl
@@ -12,9 +12,10 @@
namespace corsika {
- ParticleCut::ParticleCut(HEPEnergyType const eEleCut, HEPEnergyType const ePhoCut,
- HEPEnergyType const eHadCut, HEPEnergyType const eMuCut,
- bool const inv)
+ inline ParticleCut::ParticleCut(HEPEnergyType const eEleCut,
+ HEPEnergyType const ePhoCut,
+ HEPEnergyType const eHadCut, HEPEnergyType const eMuCut,
+ bool const inv)
: doCutEm_(false)
, doCutInv_(inv)
, energy_(0_GeV)
@@ -41,8 +42,8 @@ namespace corsika {
printThresholds();
}
- ParticleCut::ParticleCut(HEPEnergyType const eHadCut, HEPEnergyType const eMuCut,
- bool const inv)
+ inline ParticleCut::ParticleCut(HEPEnergyType const eHadCut, HEPEnergyType const eMuCut,
+ bool const inv)
: doCutEm_(true)
, doCutInv_(inv)
, energy_(0_GeV)
@@ -63,7 +64,7 @@ namespace corsika {
printThresholds();
}
- ParticleCut::ParticleCut(HEPEnergyType const eCut, bool const em, bool const inv)
+ inline ParticleCut::ParticleCut(HEPEnergyType const eCut, bool const em, bool const inv)
: doCutEm_(em)
, doCutInv_(inv)
, energy_(0_GeV)
@@ -76,7 +77,7 @@ namespace corsika {
printThresholds();
}
- ParticleCut::ParticleCut(
+ inline ParticleCut::ParticleCut(
std::unordered_map<Code const, HEPEnergyType const> const& eCuts, bool const em,
bool const inv)
: doCutEm_(em)
@@ -92,7 +93,7 @@ namespace corsika {
}
template <typename TParticle>
- bool ParticleCut::isBelowEnergyCut(TParticle const& vP) const {
+ inline bool ParticleCut::isBelowEnergyCut(TParticle const& vP) const {
auto const energyLab = vP.getEnergy();
auto const pid = vP.getPID();
// nuclei
@@ -105,10 +106,12 @@ namespace corsika {
}
}
- bool ParticleCut::isInvisible(Code const& vCode) const { return is_neutrino(vCode); }
+ inline bool ParticleCut::isInvisible(Code const& vCode) const {
+ return is_neutrino(vCode);
+ }
template <typename TParticle>
- bool ParticleCut::checkCutParticle(TParticle const& particle) {
+ inline bool ParticleCut::checkCutParticle(TParticle const& particle) {
Code const pid = particle.getPID();
HEPEnergyType energy = particle.getEnergy();
@@ -136,7 +139,7 @@ namespace corsika {
return false; // this particle will not be removed/cut
}
- void ParticleCut::doSecondaries(corsika::setup::StackView& vS) {
+ inline void ParticleCut::doSecondaries(corsika::setup::StackView& vS) {
auto particle = vS.begin();
while (particle != vS.end()) {
if (checkCutParticle(particle)) { particle.erase(); }
@@ -144,8 +147,9 @@ namespace corsika {
}
}
- ProcessReturn ParticleCut::doContinuous(corsika::setup::Stack::particle_type& particle,
- corsika::setup::Trajectory const&, bool const) {
+ inline ProcessReturn ParticleCut::doContinuous(
+ corsika::setup::Stack::particle_type& particle, corsika::setup::Trajectory const&,
+ bool const) {
CORSIKA_LOG_TRACE("ParticleCut::DoContinuous");
if (checkCutParticle(particle)) {
CORSIKA_LOG_TRACE("removing during continuous");
@@ -156,14 +160,14 @@ namespace corsika {
return ProcessReturn::Ok;
}
- void ParticleCut::printThresholds() {
+ inline void ParticleCut::printThresholds() {
for (auto p : get_all_particles()) {
auto const Eth = get_energy_threshold(p);
CORSIKA_LOG_INFO("energy threshold for particle {} is {} GeV", p, Eth / 1_GeV);
}
}
- void ParticleCut::showResults() {
+ inline void ParticleCut::showResults() {
CORSIKA_LOG_INFO(
" ******************************\n"
" energy in em. component (GeV): {} \n "
@@ -175,7 +179,7 @@ namespace corsika {
em_energy_ / 1_GeV, em_count_, inv_energy_ / 1_GeV, inv_count_, energy_ / 1_GeV);
}
- void ParticleCut::reset() {
+ inline void ParticleCut::reset() {
em_energy_ = 0_GeV;
em_count_ = 0;
inv_energy_ = 0_GeV;
diff --git a/corsika/detail/modules/StackInspector.inl b/corsika/detail/modules/StackInspector.inl
index b657e1531..10b0f1582 100644
--- a/corsika/detail/modules/StackInspector.inl
+++ b/corsika/detail/modules/StackInspector.inl
@@ -24,18 +24,18 @@
namespace corsika {
template <typename TStack>
- StackInspector<TStack>::StackInspector(const int vNStep, const bool vReportStack,
- const HEPEnergyType vE0)
+ inline StackInspector<TStack>::StackInspector(const int vNStep, const bool vReportStack,
+ const HEPEnergyType vE0)
: StackProcess<StackInspector<TStack>>(vNStep)
, ReportStack_(vReportStack)
, E0_(vE0)
, StartTime_(std::chrono::system_clock::now()) {}
template <typename TStack>
- StackInspector<TStack>::~StackInspector() {}
+ inline StackInspector<TStack>::~StackInspector() {}
template <typename TStack>
- void StackInspector<TStack>::doStack(const TStack& vS) {
+ inline void StackInspector<TStack>::doStack(const TStack& vS) {
[[maybe_unused]] int i = 0;
HEPEnergyType Etot = 0_GeV;
diff --git a/corsika/detail/modules/TrackWriter.inl b/corsika/detail/modules/TrackWriter.inl
index c6f72edf4..6d4ef2c73 100644
--- a/corsika/detail/modules/TrackWriter.inl
+++ b/corsika/detail/modules/TrackWriter.inl
@@ -20,7 +20,7 @@
namespace corsika {
- TrackWriter::TrackWriter(std::string const& filename)
+ inline TrackWriter::TrackWriter(std::string const& filename)
: filename_(filename) {
using namespace std::string_literals;
@@ -31,8 +31,8 @@ namespace corsika {
}
template <typename TParticle, typename TTrack>
- ProcessReturn TrackWriter::doContinuous(const TParticle& vP, const TTrack& vT,
- bool const) {
+ inline ProcessReturn TrackWriter::doContinuous(const TParticle& vP, const TTrack& vT,
+ bool const) {
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()));
@@ -54,7 +54,7 @@ namespace corsika {
}
template <typename TParticle, typename TTrack>
- LengthType TrackWriter::getMaxStepLength(const TParticle&, const TTrack&) {
+ inline 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 52200c42d..84400b81d 100644
--- a/corsika/detail/modules/TrackingLine.inl
+++ b/corsika/detail/modules/TrackingLine.inl
@@ -20,7 +20,7 @@
namespace corsika::tracking_line {
- std::optional<std::pair<TimeType, TimeType>> TimeOfIntersection(
+ inline std::optional<std::pair<TimeType, TimeType>> TimeOfIntersection(
corsika::Line const& line, corsika::Sphere const& sphere) {
auto const delta = line.getStartPoint() - sphere.getCenter();
auto const v = line.getVelocity();
@@ -42,7 +42,7 @@ namespace corsika::tracking_line {
}
}
- TimeType getTimeOfIntersection(Line const& vLine, Plane const& vPlane) {
+ inline TimeType getTimeOfIntersection(Line const& vLine, Plane const& vPlane) {
auto const delta = vPlane.getCenter() - vLine.getStartPoint();
auto const v = vLine.getVelocity();
diff --git a/corsika/detail/modules/conex/CONEXhybrid.inl b/corsika/detail/modules/conex/CONEXhybrid.inl
index 29c3886aa..5b350013f 100644
--- a/corsika/detail/modules/conex/CONEXhybrid.inl
+++ b/corsika/detail/modules/conex/CONEXhybrid.inl
@@ -22,9 +22,9 @@
namespace corsika {
- CONEXhybrid::CONEXhybrid(Point center, ShowerAxis const& showerAxis,
- LengthType groundDist, LengthType injectionHeight,
- HEPEnergyType primaryEnergy, PDGCode primaryPDG)
+ inline CONEXhybrid::CONEXhybrid(Point center, ShowerAxis const& showerAxis,
+ LengthType groundDist, LengthType injectionHeight,
+ HEPEnergyType primaryEnergy, PDGCode primaryPDG)
: center_{center}
, showerAxis_{showerAxis}
, groundDist_{groundDist}
@@ -124,7 +124,7 @@ namespace corsika {
::conex::conexrun_(ipart, eprima, theta, phi, xminp, dimpact, ioseed.data());
}
- void CONEXhybrid::doSecondaries(setup::StackView& vS) {
+ inline void CONEXhybrid::doSecondaries(setup::StackView& vS) {
auto p = vS.begin();
while (p != vS.end()) {
Code const pid = p.getPID();
@@ -136,9 +136,9 @@ namespace corsika {
}
}
- bool CONEXhybrid::addParticle(Code pid, HEPEnergyType energy, HEPEnergyType mass,
- Point const& position, DirectionVector const& direction,
- TimeType t) {
+ inline bool CONEXhybrid::addParticle(Code pid, HEPEnergyType energy, HEPEnergyType mass,
+ Point const& position,
+ DirectionVector const& direction, TimeType t) {
auto const it = std::find_if(egs_em_codes_.cbegin(), egs_em_codes_.cend(),
[=](auto const& p) { return pid == p.first; });
@@ -222,7 +222,7 @@ namespace corsika {
return true;
}
- void CONEXhybrid::solveCE() {
+ inline void CONEXhybrid::solveCE() {
::conex::conexcascade_();
diff --git a/corsika/detail/modules/energy_loss/BetheBlochPDG.inl b/corsika/detail/modules/energy_loss/BetheBlochPDG.inl
index cbabb0892..dff3b2bfb 100644
--- a/corsika/detail/modules/energy_loss/BetheBlochPDG.inl
+++ b/corsika/detail/modules/energy_loss/BetheBlochPDG.inl
@@ -26,14 +26,14 @@ namespace corsika {
return sqrt((Elab - m) * (Elab + m));
};
- BetheBlochPDG::BetheBlochPDG(ShowerAxis const& shower_axis)
+ inline BetheBlochPDG::BetheBlochPDG(ShowerAxis const& shower_axis)
: dX_(10_g / square(1_cm)) // profile binning
, dX_threshold_(0.0001_g / square(1_cm))
, shower_axis_(shower_axis)
, profile_(int(shower_axis.getMaximumX() / dX_) + 1) {}
- HEPEnergyType BetheBlochPDG::getBetheBloch(setup::Stack::particle_type const& p,
- GrammageType const dX) {
+ inline 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
@@ -126,21 +126,22 @@ namespace corsika {
}
// radiation losses according to PDG 2018, ch. 33 ref. [5]
- HEPEnergyType BetheBlochPDG::getRadiationLosses(setup::Stack::particle_type const& vP,
- GrammageType const vDX) {
+ inline 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;
}
- HEPEnergyType BetheBlochPDG::getTotalEnergyLoss(setup::Stack::particle_type const& vP,
- GrammageType const vDX) {
+ inline HEPEnergyType BetheBlochPDG::getTotalEnergyLoss(
+ setup::Stack::particle_type const& vP, GrammageType const vDX) {
return getBetheBloch(vP, vDX) + getRadiationLosses(vP, vDX);
}
- ProcessReturn BetheBlochPDG::doContinuous(setup::Stack::particle_type& p,
- setup::Trajectory const& t, bool const) {
+ inline ProcessReturn BetheBlochPDG::doContinuous(setup::Stack::particle_type& p,
+ setup::Trajectory const& t,
+ bool const) {
if (p.getChargeNumber() == 0) return ProcessReturn::Ok;
GrammageType const dX =
@@ -159,8 +160,9 @@ namespace corsika {
return ProcessReturn::Ok;
}
- LengthType BetheBlochPDG::getMaxStepLength(setup::Stack::particle_type const& vParticle,
- setup::Trajectory const& vTrack) const {
+ inline 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();
}
@@ -187,15 +189,15 @@ namespace corsika {
vTrack, maxGrammage);
}
- void BetheBlochPDG::updateMomentum(corsika::setup::Stack::particle_type& vP,
- HEPEnergyType Enew) {
+ inline 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());
}
- void BetheBlochPDG::fillProfile(setup::Trajectory const& vTrack,
- const HEPEnergyType dE) {
+ inline void BetheBlochPDG::fillProfile(setup::Trajectory const& vTrack,
+ const HEPEnergyType dE) {
GrammageType grammageStart = shower_axis_.getProjectedX(vTrack.getPosition(0));
GrammageType grammageEnd = shower_axis_.getProjectedX(vTrack.getPosition(1));
@@ -243,7 +245,7 @@ namespace corsika {
CORSIKA_LOG_DEBUG("total energy added to histogram: {} ", energyCount);
}
- void BetheBlochPDG::printProfile() const {
+ inline 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";
@@ -255,11 +257,11 @@ namespace corsika {
file.close();
}
- HEPEnergyType BetheBlochPDG::getTotal() const {
+ inline HEPEnergyType BetheBlochPDG::getTotal() const {
return std::accumulate(profile_.cbegin(), profile_.cend(), HEPEnergyType::zero());
}
- void BetheBlochPDG::showResults() const {
+ inline void BetheBlochPDG::showResults() const {
CORSIKA_LOG_INFO(
" ******************************\n"
" PROCESS::ContinuousProcess: \n"
@@ -267,6 +269,6 @@ namespace corsika {
energy_lost_ / 1_GeV);
}
- void BetheBlochPDG::reset() { energy_lost_ = 0_GeV; }
+ inline void BetheBlochPDG::reset() { energy_lost_ = 0_GeV; }
} // namespace corsika
diff --git a/corsika/detail/modules/proposal/ContinuousProcess.inl b/corsika/detail/modules/proposal/ContinuousProcess.inl
index b494c7b72..b4b0bf963 100644
--- a/corsika/detail/modules/proposal/ContinuousProcess.inl
+++ b/corsika/detail/modules/proposal/ContinuousProcess.inl
@@ -23,7 +23,8 @@
namespace corsika::proposal {
- void ContinuousProcess::buildCalculator(Code code, NuclearComposition const& comp) {
+ inline void ContinuousProcess::buildCalculator(Code code,
+ NuclearComposition const& comp) {
// search crosssection builder for given particle
auto p_cross = cross.find(code);
if (p_cross == cross.end())
@@ -47,13 +48,13 @@ namespace corsika::proposal {
}
template <>
- ContinuousProcess::ContinuousProcess(setup::Environment const& _env)
+ inline ContinuousProcess::ContinuousProcess(setup::Environment const& _env)
: ProposalProcessBase(_env) {}
template <>
- void ContinuousProcess::scatter(setup::Stack::particle_type& vP,
- HEPEnergyType const& loss,
- GrammageType const& grammage) {
+ inline void ContinuousProcess::scatter(setup::Stack::particle_type& vP,
+ HEPEnergyType const& loss,
+ GrammageType const& grammage) {
// get or build corresponding calculators
auto c = getCalculator(vP, calc);
@@ -87,8 +88,9 @@ namespace corsika::proposal {
}
template <>
- ProcessReturn ContinuousProcess::doContinuous(setup::Stack::particle_type& vP,
- setup::Trajectory const& vT, bool const) {
+ inline ProcessReturn ContinuousProcess::doContinuous(setup::Stack::particle_type& vP,
+ setup::Trajectory const& vT,
+ bool const) {
if (!canInteract(vP.getPID())) return ProcessReturn::Ok;
if (vT.getLength() == 0_m) return ProcessReturn::Ok;
@@ -114,8 +116,8 @@ namespace corsika::proposal {
}
template <>
- LengthType ContinuousProcess::getMaxStepLength(setup::Stack::particle_type const& vP,
- setup::Trajectory const& vT) {
+ inline LengthType ContinuousProcess::getMaxStepLength(
+ setup::Stack::particle_type const& vP, setup::Trajectory const& vT) {
auto const code = vP.getPID();
if (!canInteract(code)) return meter * std::numeric_limits<double>::infinity();
@@ -148,7 +150,7 @@ namespace corsika::proposal {
return dist;
}
- void ContinuousProcess::showResults() const {
+ inline void ContinuousProcess::showResults() const {
CORSIKA_LOG_DEBUG(
" ******************************\n"
" PROCESS::ContinuousProcess: \n"
@@ -156,6 +158,6 @@ namespace corsika::proposal {
energy_lost_ / 1_GeV);
}
- void ContinuousProcess::reset() { energy_lost_ = 0_GeV; }
+ inline void ContinuousProcess::reset() { energy_lost_ = 0_GeV; }
} // namespace corsika::proposal
diff --git a/corsika/detail/modules/proposal/Interaction.inl b/corsika/detail/modules/proposal/Interaction.inl
index 4874bda1f..fb6c157da 100644
--- a/corsika/detail/modules/proposal/Interaction.inl
+++ b/corsika/detail/modules/proposal/Interaction.inl
@@ -24,10 +24,10 @@
namespace corsika::proposal {
template <>
- Interaction::Interaction(setup::Environment const& _env)
+ inline Interaction::Interaction(setup::Environment const& _env)
: ProposalProcessBase(_env) {}
- void Interaction::buildCalculator(Code code, NuclearComposition const& comp) {
+ inline void Interaction::buildCalculator(Code code, NuclearComposition const& comp) {
// search crosssection builder for given particle
auto p_cross = cross.find(code);
if (p_cross == cross.end())
@@ -52,7 +52,7 @@ namespace corsika::proposal {
}
template <>
- ProcessReturn Interaction::doInteraction(setup::StackView& view) {
+ inline ProcessReturn Interaction::doInteraction(setup::StackView& view) {
auto const projectile = view.getProjectile();
@@ -103,7 +103,7 @@ namespace corsika::proposal {
}
template <>
- GrammageType Interaction::getInteractionLength(
+ inline GrammageType Interaction::getInteractionLength(
setup::Stack::particle_type const& projectile) {
if (canInteract(projectile.getPID())) {
diff --git a/corsika/detail/modules/proposal/ProposalProcessBase.inl b/corsika/detail/modules/proposal/ProposalProcessBase.inl
index 21d0cce57..992d24e4d 100644
--- a/corsika/detail/modules/proposal/ProposalProcessBase.inl
+++ b/corsika/detail/modules/proposal/ProposalProcessBase.inl
@@ -25,12 +25,12 @@
namespace corsika::proposal {
- bool ProposalProcessBase::canInteract(Code pcode) const {
+ inline bool ProposalProcessBase::canInteract(Code pcode) const {
if (std::find(begin(tracked), end(tracked), pcode) != end(tracked)) return true;
return false;
}
- ProposalProcessBase::ProposalProcessBase(setup::Environment const& _env)
+ inline ProposalProcessBase::ProposalProcessBase(setup::Environment const& _env)
: RNG_(RNGManager::getInstance().getRandomStream("proposal")) {
_env.getUniverse()->walk([&](auto& vtn) {
if (vtn.hasModelProperties()) {
@@ -71,7 +71,8 @@ namespace corsika::proposal {
}
}
- size_t ProposalProcessBase::hash::operator()(const calc_key_t& p) const noexcept {
+ inline size_t ProposalProcessBase::hash::operator()(const calc_key_t& p) const
+ noexcept {
return p.first ^ std::hash<Code>{}(p.second);
}
diff --git a/corsika/detail/modules/pythia8/Decay.inl b/corsika/detail/modules/pythia8/Decay.inl
index a0dcc7e7c..d41c14902 100644
--- a/corsika/detail/modules/pythia8/Decay.inl
+++ b/corsika/detail/modules/pythia8/Decay.inl
@@ -17,21 +17,21 @@
namespace corsika::pythia8 {
- Decay::Decay(bool const print_listing)
+ inline Decay::Decay(bool const print_listing)
: Pythia8::Pythia(CORSIKA_Pythia8_XML_DIR)
, print_listing_(print_listing) {
init();
}
- Decay::Decay(std::set<Code> const& those)
+ inline Decay::Decay(std::set<Code> const& those)
: handleAllDecays_(false)
, handledDecays_(those) {
init();
}
- Decay::~Decay() { CORSIKA_LOG_INFO("Pythia::Decay n={}", count_); }
+ inline Decay::~Decay() { CORSIKA_LOG_INFO("Pythia::Decay n={}", count_); }
- void Decay::init() {
+ inline void Decay::init() {
// run this only once during construction
@@ -66,7 +66,7 @@ namespace corsika::pythia8 {
throw std::runtime_error("Pythia::Decay: Initialization failed!");
}
- bool Decay::canHandleDecay(Code const vParticleCode) {
+ inline bool Decay::canHandleDecay(Code const vParticleCode) {
// if known to pythia and not proton, electron or neutrino it can decay
if (vParticleCode == Code::Proton || vParticleCode == Code::AntiProton ||
vParticleCode == Code::NuE || vParticleCode == Code::NuMu ||
@@ -80,7 +80,7 @@ namespace corsika::pythia8 {
return false;
}
- void Decay::setHandleDecay(Code const vParticleCode) {
+ inline void Decay::setHandleDecay(Code const vParticleCode) {
handleAllDecays_ = false;
CORSIKA_LOG_INFO("Pythia::Decay: set to handle decay of {} ", vParticleCode);
if (Decay::canHandleDecay(vParticleCode))
@@ -89,37 +89,37 @@ namespace corsika::pythia8 {
throw std::runtime_error("this decay can not be handled by pythia!");
}
- void Decay::setHandleDecay(std::vector<Code> const& vParticleList) {
+ inline void Decay::setHandleDecay(std::vector<Code> const& vParticleList) {
handleAllDecays_ = false;
for (auto p : vParticleList) setHandleDecay(p);
}
- bool Decay::isDecayHandled(Code const vParticleCode) {
+ inline bool Decay::isDecayHandled(Code const vParticleCode) {
if (handleAllDecays_ && canHandleDecay(vParticleCode))
return true;
else
return handledDecays_.find(vParticleCode) != Decay::handledDecays_.end();
}
- void Decay::setStable(std::vector<Code> const& particleList) {
+ inline void Decay::setStable(std::vector<Code> const& particleList) {
for (auto p : particleList) Decay::setStable(p);
}
- void Decay::setUnstable(Code const pCode) {
+ inline void Decay::setUnstable(Code const pCode) {
CORSIKA_LOG_INFO("Pythia::Decay: setting {} unstable..", pCode);
Pythia8::Pythia::particleData.mayDecay(static_cast<int>(get_PDG(pCode)), true);
}
- void Decay::setStable(Code const pCode) {
+ inline void Decay::setStable(Code const pCode) {
CORSIKA_LOG_INFO("Pythia::Decay: setting {} stable..", pCode);
Pythia8::Pythia::particleData.mayDecay(static_cast<int>(get_PDG(pCode)), false);
}
- bool Decay::isStable(Code const vCode) {
+ inline bool Decay::isStable(Code const vCode) {
return Pythia8::Pythia::particleData.canDecay(static_cast<int>(get_PDG(vCode)));
}
- bool Decay::canDecay(Code const pCode) {
+ inline bool Decay::canDecay(Code const pCode) {
bool const ans =
Pythia8::Pythia::particleData.canDecay(static_cast<int>(get_PDG(pCode)));
CORSIKA_LOG_INFO("Pythia::Decay: checking if particle: {} can decay in PYTHIA? {} ",
@@ -127,12 +127,12 @@ namespace corsika::pythia8 {
return ans;
}
- void Decay::printDecayConfig(Code const vCode) {
+ inline void Decay::printDecayConfig(Code const vCode) {
CORSIKA_LOG_INFO("Decay: Pythia decay configuration:");
CORSIKA_LOG_INFO(" {} is {} ", vCode, (isStable(vCode) ? "stable" : "unstable"));
}
- void Decay::printDecayConfig() {
+ inline void Decay::printDecayConfig() {
CORSIKA_LOG_INFO("Pythia::Decay: decay configuration:");
if (handleAllDecays_)
CORSIKA_LOG_INFO(" all particles known to Pythia are handled by Pythia::Decay!");
@@ -142,7 +142,7 @@ namespace corsika::pythia8 {
}
template <typename TParticle>
- TimeType Decay::getLifetime(TParticle const& particle) {
+ inline TimeType Decay::getLifetime(TParticle const& particle) {
auto const pid = particle.getPID();
if (canDecay(pid)) {
@@ -167,7 +167,7 @@ namespace corsika::pythia8 {
}
template <typename TView>
- void Decay::doDecay(TView& view) {
+ inline void Decay::doDecay(TView& view) {
auto projectile = view.getProjectile();
diff --git a/corsika/detail/modules/pythia8/Interaction.inl b/corsika/detail/modules/pythia8/Interaction.inl
index 5395e8b1f..4b74ed67f 100644
--- a/corsika/detail/modules/pythia8/Interaction.inl
+++ b/corsika/detail/modules/pythia8/Interaction.inl
@@ -21,9 +21,11 @@
namespace corsika::pythia8 {
- Interaction::~Interaction() { CORSIKA_LOG_INFO("Pythia::Interaction n= {}", count_); }
+ inline Interaction::~Interaction() {
+ CORSIKA_LOG_INFO("Pythia::Interaction n= {}", count_);
+ }
- Interaction::Interaction(bool const print_listing)
+ inline Interaction::Interaction(bool const print_listing)
: Pythia8::Pythia(CORSIKA_Pythia8_XML_DIR)
, print_listing_(print_listing) {
@@ -64,22 +66,23 @@ namespace corsika::pythia8 {
&(Pythia8::Pythia::particleData), &(Pythia8::Pythia::rndm));
}
- void Interaction::setStable(std::vector<Code> const& particleList) {
+ inline void Interaction::setStable(std::vector<Code> const& particleList) {
for (auto p : particleList) Interaction::setStable(p);
}
- void Interaction::setUnstable(Code const pCode) {
+ inline void Interaction::setUnstable(Code const pCode) {
CORSIKA_LOG_DEBUG("Pythia::Interaction: setting {} unstable..", pCode);
Pythia8::Pythia::particleData.mayDecay(static_cast<int>(get_PDG(pCode)), true);
}
- void Interaction::setStable(Code const pCode) {
+ inline void Interaction::setStable(Code const pCode) {
CORSIKA_LOG_DEBUG("Pythia::Interaction: setting {} stable..", pCode);
Pythia8::Pythia::particleData.mayDecay(static_cast<int>(get_PDG(pCode)), false);
}
- void Interaction::configureLabFrameCollision(Code const BeamId, Code const TargetId,
- HEPEnergyType const BeamEnergy) {
+ inline void Interaction::configureLabFrameCollision(Code const BeamId,
+ Code const TargetId,
+ HEPEnergyType const BeamEnergy) {
// Pythia configuration of the current event
// very clumsy. I am sure this can be done better..
@@ -111,12 +114,12 @@ namespace corsika::pythia8 {
throw std::runtime_error("Pythia::Interaction: Initialization failed!");
}
- bool Interaction::canInteract(Code const pCode) {
+ inline bool Interaction::canInteract(Code const pCode) {
return pCode == Code::Proton || pCode == Code::Neutron || pCode == Code::AntiProton ||
pCode == Code::AntiNeutron || pCode == Code::PiMinus || pCode == Code::PiPlus;
}
- std::tuple<CrossSectionType, CrossSectionType> Interaction::getCrossSection(
+ inline std::tuple<CrossSectionType, CrossSectionType> Interaction::getCrossSection(
Code const BeamId, Code const TargetId, HEPEnergyType const CoMenergy) {
// interaction possible in pythia?
if (TargetId == Code::Proton || TargetId == Code::Hydrogen) {
@@ -146,7 +149,7 @@ namespace corsika::pythia8 {
}
}
- GrammageType Interaction::getInteractionLength(
+ inline GrammageType Interaction::getInteractionLength(
corsika::setup::Stack::particle_type const& particle) {
// coordinate system, get global frame of reference
@@ -216,7 +219,7 @@ namespace corsika::pythia8 {
}
template <class TView>
- void Interaction::doInteraction(TView& view) {
+ inline void Interaction::doInteraction(TView& view) {
auto projectile = view.getProjectile();
diff --git a/corsika/detail/modules/pythia8/Random.inl b/corsika/detail/modules/pythia8/Random.inl
index c077e0bf7..cf1408f1e 100644
--- a/corsika/detail/modules/pythia8/Random.inl
+++ b/corsika/detail/modules/pythia8/Random.inl
@@ -12,6 +12,6 @@
namespace corsika::pythia8 {
- double Random::flat() { return Dist_(RNG_); }
+ inline double Random::flat() { return Dist_(RNG_); }
} // namespace corsika::pythia8
diff --git a/corsika/detail/modules/qgsjetII/Interaction.inl b/corsika/detail/modules/qgsjetII/Interaction.inl
index da703d7ef..a97265abc 100644
--- a/corsika/detail/modules/qgsjetII/Interaction.inl
+++ b/corsika/detail/modules/qgsjetII/Interaction.inl
@@ -27,7 +27,7 @@
namespace corsika::qgsjetII {
- Interaction::Interaction(const std::string& dataPath)
+ inline Interaction::Interaction(const std::string& dataPath)
: data_path_(dataPath) {
if (dataPath == "") {
if (std::getenv("CORSIKA_DATA")) {
@@ -46,14 +46,15 @@ namespace corsika::qgsjetII {
}
}
- Interaction::~Interaction() {
+ inline Interaction::~Interaction() {
CORSIKA_LOG_DEBUG("QgsjetII::Interaction n= {}", count_);
}
- CrossSectionType Interaction::getCrossSection(const Code beamId, const Code targetId,
- const HEPEnergyType Elab,
- const unsigned int Abeam,
- const unsigned int targetA) const {
+ inline 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)) {
@@ -88,7 +89,7 @@ namespace corsika::qgsjetII {
}
template <typename TParticle>
- GrammageType Interaction::getInteractionLength(const TParticle& vP) const {
+ inline GrammageType Interaction::getInteractionLength(const TParticle& vP) const {
// coordinate system, get global frame of reference
CoordinateSystemPtr const& rootCS = get_root_CoordinateSystem();
@@ -160,7 +161,7 @@ namespace corsika::qgsjetII {
*/
template <typename TView>
- void Interaction::doInteraction(TView& view) {
+ inline void Interaction::doInteraction(TView& view) {
auto const projectile = view.getProjectile();
diff --git a/corsika/detail/modules/qgsjetII/QGSJetIIStack.inl b/corsika/detail/modules/qgsjetII/QGSJetIIStack.inl
index 60f86fb48..92422c1dc 100644
--- a/corsika/detail/modules/qgsjetII/QGSJetIIStack.inl
+++ b/corsika/detail/modules/qgsjetII/QGSJetIIStack.inl
@@ -10,58 +10,61 @@
namespace corsika::qgsjetII {
- void QGSJetIIStackData::clear() {
+ inline void QGSJetIIStackData::clear() {
qgarr12_.nsp = 0;
qgarr13_.nsf = 0;
qgarr55_.nwt = 0;
}
- unsigned int QGSJetIIStackData::getSize() const { return qgarr12_.nsp; }
- unsigned int QGSJetIIStackData::getCapacity() const { return nptmax; }
+ inline unsigned int QGSJetIIStackData::getSize() const { return qgarr12_.nsp; }
+ inline unsigned int QGSJetIIStackData::getCapacity() const { return nptmax; }
- void QGSJetIIStackData::setId(const unsigned int i, const int v) {
+ inline void QGSJetIIStackData::setId(const unsigned int i, const int v) {
qgarr14_.ich[i] = v;
}
- void QGSJetIIStackData::setEnergy(const unsigned int i, const HEPEnergyType v) {
+ inline void QGSJetIIStackData::setEnergy(const unsigned int i, const HEPEnergyType v) {
qgarr14_.esp[i][0] = v / 1_GeV;
}
- void QGSJetIIStackData::setMomentum(const unsigned int i, const MomentumVector& v) {
+ inline void QGSJetIIStackData::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 QGSJetIIStackData::getId(const unsigned int i) const { return qgarr14_.ich[i]; }
- HEPEnergyType QGSJetIIStackData::getEnergy(const int i) const {
+ inline int QGSJetIIStackData::getId(const unsigned int i) const {
+ return qgarr14_.ich[i];
+ }
+ inline HEPEnergyType QGSJetIIStackData::getEnergy(const int i) const {
return qgarr14_.esp[i][0] * 1_GeV;
}
- MomentumVector QGSJetIIStackData::getMomentum(const unsigned int i,
- const CoordinateSystemPtr& CS) const {
+ inline MomentumVector QGSJetIIStackData::getMomentum(
+ const unsigned int i, const CoordinateSystemPtr& CS) const {
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 QGSJetIIStackData::copy(const unsigned int i1, const unsigned int i2) {
+ inline void QGSJetIIStackData::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 QGSJetIIStackData::swap(const unsigned int i1, const unsigned int i2) {
+ inline void QGSJetIIStackData::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 QGSJetIIStackData::incrementSize() { qgarr12_.nsp++; }
- void QGSJetIIStackData::decrementSize() {
+ inline void QGSJetIIStackData::incrementSize() { qgarr12_.nsp++; }
+ inline void QGSJetIIStackData::decrementSize() {
if (qgarr12_.nsp > 0) { qgarr12_.nsp--; }
}
template <typename StackIteratorInterface>
- void ParticleInterface<StackIteratorInterface>::setParticleData(
+ inline void ParticleInterface<StackIteratorInterface>::setParticleData(
const int vID, const HEPEnergyType vE, const MomentumVector& vP,
const HEPMassType) {
setPID(vID);
@@ -70,7 +73,7 @@ namespace corsika::qgsjetII {
}
template <typename StackIteratorInterface>
- void ParticleInterface<StackIteratorInterface>::setParticleData(
+ inline void ParticleInterface<StackIteratorInterface>::setParticleData(
ParticleInterface<StackIteratorInterface>& /*parent*/, const int vID,
const HEPEnergyType vE, const MomentumVector& vP, const HEPMassType) {
setPID(vID);
@@ -79,34 +82,36 @@ namespace corsika::qgsjetII {
}
template <typename StackIteratorInterface>
- void ParticleInterface<StackIteratorInterface>::setEnergy(const HEPEnergyType v) {
+ inline void ParticleInterface<StackIteratorInterface>::setEnergy(
+ const HEPEnergyType v) {
getStackData().setEnergy(getIndex(), v);
}
template <typename StackIteratorInterface>
- HEPEnergyType ParticleInterface<StackIteratorInterface>::getEnergy() const {
+ inline HEPEnergyType ParticleInterface<StackIteratorInterface>::getEnergy() const {
return getStackData().getEnergy(getIndex());
}
template <typename StackIteratorInterface>
- void ParticleInterface<StackIteratorInterface>::setPID(const int v) {
+ inline void ParticleInterface<StackIteratorInterface>::setPID(const int v) {
getStackData().setId(getIndex(), v);
}
template <typename StackIteratorInterface>
- corsika::qgsjetII::QgsjetIICode ParticleInterface<StackIteratorInterface>::getPID()
- const {
+ inline corsika::qgsjetII::QgsjetIICode
+ ParticleInterface<StackIteratorInterface>::getPID() const {
return static_cast<corsika::qgsjetII::QgsjetIICode>(getStackData().getId(getIndex()));
}
template <typename StackIteratorInterface>
- MomentumVector ParticleInterface<StackIteratorInterface>::getMomentum(
+ inline MomentumVector ParticleInterface<StackIteratorInterface>::getMomentum(
const CoordinateSystemPtr& CS) const {
return getStackData().getMomentum(getIndex(), CS);
}
template <typename StackIteratorInterface>
- void ParticleInterface<StackIteratorInterface>::setMomentum(const MomentumVector& v) {
+ inline void ParticleInterface<StackIteratorInterface>::setMomentum(
+ const MomentumVector& v) {
getStackData().setMomentum(getIndex(), v);
}
diff --git a/corsika/detail/modules/qgsjetII/qgsjet-II-04.inl b/corsika/detail/modules/qgsjetII/qgsjet-II-04.inl
index aca1429c3..a36268cf5 100644
--- a/corsika/detail/modules/qgsjetII/qgsjet-II-04.inl
+++ b/corsika/detail/modules/qgsjetII/qgsjet-II-04.inl
@@ -16,7 +16,7 @@
#include <iostream>
#include <random>
-datadir::datadir(const std::string& dir) {
+inline datadir::datadir(const std::string& dir) {
if (dir.length() > 130) {
CORSIKA_LOG_ERROR("QGSJetII error, will cut datadir \"{}\" to 130 characters: ", {});
}
@@ -26,7 +26,7 @@ datadir::datadir(const std::string& dir) {
data[i + 1] = '\0';
}
-double qgran_(int&) {
+inline double qgran_(int&) {
static corsika::default_prng_type& rng =
corsika::RNGManager::getInstance().GetRandomStream("qgran");
@@ -34,6 +34,6 @@ double qgran_(int&) {
return dist(rng);
}
-void lzmaopenfile_(const char*, int) {}
-void lzmaclosefile_() {}
-void lzmafillarray_(const double&, const int&) {}
+inline void lzmaopenfile_(const char*, int) {}
+inline void lzmaclosefile_() {}
+inline void lzmafillarray_(const double&, const int&) {}
diff --git a/corsika/detail/modules/sibyll/NuclearInteraction.inl b/corsika/detail/modules/sibyll/NuclearInteraction.inl
index e5d8662fb..91b85c681 100644
--- a/corsika/detail/modules/sibyll/NuclearInteraction.inl
+++ b/corsika/detail/modules/sibyll/NuclearInteraction.inl
@@ -27,8 +27,8 @@
namespace corsika::sibyll {
template <typename TEnvironment>
- NuclearInteraction<TEnvironment>::NuclearInteraction(sibyll::Interaction& hadint,
- TEnvironment const& env)
+ inline NuclearInteraction<TEnvironment>::NuclearInteraction(sibyll::Interaction& hadint,
+ TEnvironment const& env)
: environment_(env)
, hadronicInteraction_(hadint) {
@@ -49,12 +49,12 @@ namespace corsika::sibyll {
}
template <typename TEnvironment>
- NuclearInteraction<TEnvironment>::~NuclearInteraction() {
+ inline NuclearInteraction<TEnvironment>::~NuclearInteraction() {
CORSIKA_LOG_DEBUG("Nuclib::NuclearInteraction n={} Nnuc={}", count_, nucCount_);
}
template <typename TEnvironment>
- void NuclearInteraction<TEnvironment>::printCrossSectionTable(Code pCode) {
+ inline 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};
@@ -79,7 +79,7 @@ namespace corsika::sibyll {
}
template <typename TEnvironment>
- void NuclearInteraction<TEnvironment>::initializeNuclearCrossSections() {
+ inline void NuclearInteraction<TEnvironment>::initializeNuclearCrossSections() {
auto& universe = *(environment_.getUniverse());
@@ -143,7 +143,7 @@ namespace corsika::sibyll {
}
template <typename TEnvironment>
- CrossSectionType NuclearInteraction<TEnvironment>::readCrossSectionTable(
+ inline CrossSectionType NuclearInteraction<TEnvironment>::readCrossSectionTable(
const int ia, Code pTarget, HEPEnergyType elabnuc) {
const int ib = targetComponentsIndex_.at(pTarget) + 1; // table index in fortran
@@ -161,9 +161,8 @@ namespace corsika::sibyll {
// TODO: remove elastic cross section?
template <typename TEnvironment>
template <typename TParticle>
- std::tuple<CrossSectionType, CrossSectionType>
- NuclearInteraction<TEnvironment>::getCrossSection(TParticle const& projectile,
- Code const TargetId) {
+ std::tuple<CrossSectionType, CrossSectionType> inline NuclearInteraction<
+ TEnvironment>::getCrossSection(TParticle const& projectile, Code const TargetId) {
if (projectile.getPID() != Code::Nucleus)
throw std::runtime_error(
@@ -203,7 +202,7 @@ namespace corsika::sibyll {
template <typename TEnvironment>
template <typename TParticle>
- GrammageType NuclearInteraction<TEnvironment>::getInteractionLength(
+ inline GrammageType NuclearInteraction<TEnvironment>::getInteractionLength(
TParticle const& projectile) {
// coordinate system, get global frame of reference
@@ -310,7 +309,7 @@ namespace corsika::sibyll {
template <typename TEnvironment>
template <typename TSecondaryView>
- void NuclearInteraction<TEnvironment>::doInteraction(TSecondaryView& view) {
+ inline void NuclearInteraction<TEnvironment>::doInteraction(TSecondaryView& view) {
auto projectile = view.getProjectile();
diff --git a/corsika/detail/modules/tracking/TrackingLeapFrogCurved.inl b/corsika/detail/modules/tracking/TrackingLeapFrogCurved.inl
index 5be8e516e..18a1bf0d2 100644
--- a/corsika/detail/modules/tracking/TrackingLeapFrogCurved.inl
+++ b/corsika/detail/modules/tracking/TrackingLeapFrogCurved.inl
@@ -226,8 +226,8 @@ namespace corsika {
}
template <typename TParticle, typename TMedium>
- Intersections Tracking::intersect(TParticle const& particle, Plane const& plane,
- TMedium const& medium) {
+ inline Intersections Tracking::intersect(TParticle const& particle,
+ Plane const& plane, TMedium const& medium) {
int chargeNumber;
if (is_nucleus(particle.getPID())) {
diff --git a/corsika/detail/modules/tracking/TrackingStraight.inl b/corsika/detail/modules/tracking/TrackingStraight.inl
index 5869601a5..7fc57b21b 100644
--- a/corsika/detail/modules/tracking/TrackingStraight.inl
+++ b/corsika/detail/modules/tracking/TrackingStraight.inl
@@ -49,8 +49,8 @@ namespace corsika::tracking_line {
}
template <typename TParticle, typename TMedium>
- Intersections Tracking::intersect(TParticle const& particle, Sphere const& sphere,
- TMedium const&) {
+ inline Intersections Tracking::intersect(TParticle const& particle,
+ Sphere const& sphere, TMedium const&) {
auto const delta = particle.getPosition() - sphere.getCenter();
auto const velocity = particle.getMomentum() / particle.getEnergy() * constants::c;
auto const vSqNorm = velocity.getSquaredNorm();
@@ -70,8 +70,8 @@ namespace corsika::tracking_line {
}
template <typename TParticle, typename TBaseNodeType>
- Intersections Tracking::intersect(TParticle const& particle,
- TBaseNodeType const& volumeNode) {
+ inline Intersections Tracking::intersect(TParticle const& particle,
+ TBaseNodeType const& volumeNode) {
Sphere const* sphere = dynamic_cast<Sphere const*>(&volumeNode.getVolume());
if (sphere) {
typedef typename std::remove_const_t<
@@ -85,8 +85,8 @@ namespace corsika::tracking_line {
}
template <typename TParticle, typename TMedium>
- Intersections Tracking::intersect(TParticle const& particle, Plane const& plane,
- TMedium const&) {
+ inline Intersections Tracking::intersect(TParticle const& particle, Plane const& plane,
+ TMedium const&) {
auto const delta = plane.getCenter() - particle.getPosition();
auto const velocity = particle.getMomentum() / particle.getEnergy() * constants::c;
auto const n = plane.getNormal();
diff --git a/corsika/detail/modules/urqmd/UrQMD.inl b/corsika/detail/modules/urqmd/UrQMD.inl
index c0f530a81..a1abaa6ab 100644
--- a/corsika/detail/modules/urqmd/UrQMD.inl
+++ b/corsika/detail/modules/urqmd/UrQMD.inl
@@ -23,11 +23,11 @@
namespace corsika::urqmd {
- UrQMD::UrQMD() { ::urqmd::iniurqmdc8_(); }
+ inline UrQMD::UrQMD() { ::urqmd::iniurqmdc8_(); }
- CrossSectionType UrQMD::getCrossSection(Code vProjectileCode, Code vTargetCode,
- HEPEnergyType vLabEnergy,
- int vAProjectile = 1) {
+ inline CrossSectionType UrQMD::getCrossSection(Code vProjectileCode, Code vTargetCode,
+ HEPEnergyType vLabEnergy,
+ int vAProjectile = 1) {
// the following is a translation of ptsigtot() into C++
if (vProjectileCode != Code::Nucleus &&
@@ -63,8 +63,8 @@ namespace corsika::urqmd {
template <typename TParticle> // need template here, as this is called both with
// SetupParticle as well as SetupProjectile
- CrossSectionType UrQMD::getCrossSection(TParticle const& vProjectile,
- Code vTargetCode) const {
+ inline CrossSectionType UrQMD::getCrossSection(TParticle const& vProjectile,
+ Code vTargetCode) const {
// TODO: return 0 for non-hadrons?
auto const projectileCode = vProjectile.getPID();
@@ -79,7 +79,7 @@ namespace corsika::urqmd {
return getCrossSection(projectileCode, vTargetCode, projectileEnergyLab, Ap);
}
- bool UrQMD::canInteract(Code vCode) const {
+ inline bool UrQMD::canInteract(Code vCode) const {
// According to the manual, UrQMD can use all mesons, baryons and nucleons
// which are modeled also as input particles. I think it is safer to accept
// only the usual long-lived species as input.
@@ -95,7 +95,7 @@ namespace corsika::urqmd {
}
template <typename TParticle>
- GrammageType UrQMD::getInteractionLength(TParticle const& vParticle) const {
+ inline GrammageType UrQMD::getInteractionLength(TParticle const& vParticle) const {
if (!canInteract(vParticle.getPID())) {
// we could do the canInteract check in getCrossSection, too but if
@@ -115,7 +115,7 @@ namespace corsika::urqmd {
}
template <typename TView>
- void UrQMD::doInteraction(TView& view) {
+ inline void UrQMD::doInteraction(TView& view) {
auto projectile = view.getProjectile();
@@ -231,7 +231,7 @@ namespace corsika::urqmd {
CORSIKA_LOG_DEBUG("UrQMD generated {} secondaries!", ::urqmd::sys_.npart);
}
- Code convertFromUrQMD(int vItyp, int vIso3) {
+ inline Code convertFromUrQMD(int vItyp, int vIso3) {
int const pdgInt =
::urqmd::pdgid_(vItyp, vIso3); // use the conversion function provided by UrQMD
if (pdgInt == 0) { // ::urqmd::pdgid_ returns 0 on error
@@ -241,7 +241,7 @@ namespace corsika::urqmd {
return convert_from_PDG(pdg);
}
- std::pair<int, int> convertToUrQMD(Code code) {
+ inline std::pair<int, int> convertToUrQMD(Code code) {
static const std::map<int, std::pair<int, int>> mapPDGToUrQMD{
// data mostly from github.com/afedynitch/ParticleDataTool
{22, {100, 0}}, // gamma
diff --git a/corsika/detail/stack/VectorStack.inl b/corsika/detail/stack/VectorStack.inl
index 44384a131..a89c85ed9 100644
--- a/corsika/detail/stack/VectorStack.inl
+++ b/corsika/detail/stack/VectorStack.inl
@@ -23,7 +23,7 @@
namespace corsika {
template <typename StackIteratorInterface>
- void ParticleInterface<StackIteratorInterface>::setParticleData(
+ inline void ParticleInterface<StackIteratorInterface>::setParticleData(
std::tuple<Code, HEPEnergyType, MomentumVector, Point, TimeType> const& v) {
this->setPID(std::get<0>(v));
this->setEnergy(std::get<1>(v));
@@ -33,7 +33,7 @@ namespace corsika {
}
template <typename StackIteratorInterface>
- void ParticleInterface<StackIteratorInterface>::setParticleData(
+ inline void ParticleInterface<StackIteratorInterface>::setParticleData(
ParticleInterface<StackIteratorInterface> const&,
std::tuple<Code, HEPEnergyType, MomentumVector, Point, TimeType> const& v) {
this->setPID(std::get<0>(v));
diff --git a/corsika/detail/stack/history/HistoryObservationPlane.inl b/corsika/detail/stack/history/HistoryObservationPlane.inl
index 0536eaf3a..66b0f11e4 100644
--- a/corsika/detail/stack/history/HistoryObservationPlane.inl
+++ b/corsika/detail/stack/history/HistoryObservationPlane.inl
@@ -13,14 +13,14 @@
namespace corsika::history {
- HistoryObservationPlane::HistoryObservationPlane(setup::Stack const& stack,
- Plane const& obsPlane,
- bool deleteOnHit)
+ inline HistoryObservationPlane::HistoryObservationPlane(setup::Stack const& stack,
+ Plane const& obsPlane,
+ bool deleteOnHit)
: stack_{stack}
, plane_{obsPlane}
, deleteOnHit_{deleteOnHit} {}
- ProcessReturn HistoryObservationPlane::DoContinuous(
+ inline ProcessReturn HistoryObservationPlane::DoContinuous(
setup::Stack::ParticleType const& particle, setup::Trajectory const& trajectory) {
TimeType const timeOfIntersection =
(plane_.getCenter() - trajectory.getR0()).dot(plane_.getNormal()) /
@@ -45,8 +45,8 @@ namespace corsika::history {
}
}
- LengthType HistoryObservationPlane::MaxStepLength(setup::Stack::ParticleType const&,
- setup::Trajectory const& trajectory) {
+ inline LengthType HistoryObservationPlane::MaxStepLength(
+ setup::Stack::ParticleType const&, setup::Trajectory const& trajectory) {
TimeType const timeOfIntersection =
(plane_.getCenter() - trajectory.getR0()).dot(plane_.getNormal()) /
trajectory.getV0().dot(plane_.getNormal());
@@ -59,7 +59,7 @@ namespace corsika::history {
return (trajectory.getR0() - pointOfIntersection).norm() * 1.0001;
}
- void HistoryObservationPlane::fillHistoryHistogram(
+ inline void HistoryObservationPlane::fillHistoryHistogram(
setup::Stack::ParticleType const& muon) {
double const muon_energy = muon.getEnergy() / 1_GeV;
diff --git a/corsika/framework/analytics/Timer.hpp b/corsika/framework/analytics/Timer.hpp
index 4df67f488..a2dba0ea5 100644
--- a/corsika/framework/analytics/Timer.hpp
+++ b/corsika/framework/analytics/Timer.hpp
@@ -36,10 +36,10 @@ namespace corsika {
: timeDiff_(0){};
/// Start the timer
- inline void startTimer() { start_ = clock_type::now(); }
+ void startTimer() { start_ = clock_type::now(); }
/// Stop the timer
- inline void stopTimer() {
+ void stopTimer() {
timeDiff_ = std::chrono::duration_cast<duration_type>(clock_type::now() - start_);
}
@@ -48,7 +48,7 @@ namespace corsika {
* @return Returns the measured runtime of the wrapped function/functor in the unit
* given by TDuration
**/
- inline duration_type getTime() const { return timeDiff_; }
+ duration_type getTime() const { return timeDiff_; }
};
std::false_type is_timer_impl(...);
@@ -56,7 +56,7 @@ namespace corsika {
std::true_type is_timer_impl(Timer<T, U> const volatile&);
template <typename T>
- inline constexpr bool is_timer_v =
+ constexpr bool is_timer_v =
std::is_same_v<decltype(is_timer_impl(std::declval<T&>())), std::true_type>;
-} // namespace corsika
\ No newline at end of file
+} // namespace corsika
diff --git a/corsika/framework/core/ParticleProperties.hpp b/corsika/framework/core/ParticleProperties.hpp
index 85227425c..dafc1f024 100644
--- a/corsika/framework/core/ParticleProperties.hpp
+++ b/corsika/framework/core/ParticleProperties.hpp
@@ -81,15 +81,15 @@ 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 get_nucleus_mass(unsigned int const, unsigned int const);
+ HEPMassType get_nucleus_mass(unsigned int const, unsigned int const);
//! convert PDG code to CORSIKA 8 internal code
- inline Code convert_from_PDG(PDGCode);
+ 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);
+ std::ostream& operator<<(std::ostream&, corsika::Code);
} // namespace corsika
// data arrays, etc., as generated automatically
diff --git a/corsika/framework/geometry/CoordinateSystem.hpp b/corsika/framework/geometry/CoordinateSystem.hpp
index ed9c81848..f15b89e99 100644
--- a/corsika/framework/geometry/CoordinateSystem.hpp
+++ b/corsika/framework/geometry/CoordinateSystem.hpp
@@ -40,31 +40,30 @@ namespace corsika {
/**
* Creates new CoordinateSystemPtr by translation along \a vector
*/
- inline CoordinateSystemPtr make_translation(CoordinateSystemPtr const& cs,
- QuantityVector<length_d> const& vector);
+ CoordinateSystemPtr make_translation(CoordinateSystemPtr const& cs,
+ QuantityVector<length_d> const& vector);
/**
* creates a new CoordinateSystem in which vVec points in direction of the new z-axis,
* \a vVec
*/
template <typename TDim>
- inline CoordinateSystemPtr make_rotationToZ(CoordinateSystemPtr const& cs,
- Vector<TDim> const& vVec);
+ CoordinateSystemPtr make_rotationToZ(CoordinateSystemPtr const& cs,
+ Vector<TDim> const& vVec);
/**
* creates a new CoordinateSystem, rotated around axis by angle.
*/
template <typename TDim>
- inline CoordinateSystemPtr make_rotation(CoordinateSystemPtr const& cs,
- QuantityVector<TDim> const& axis,
- double const angle);
+ CoordinateSystemPtr make_rotation(CoordinateSystemPtr const& cs,
+ QuantityVector<TDim> const& axis, double const angle);
/**
* creates a new CoordinateSystem, translated by \a translation and rotated around \a
* axis by \a angle.
*/
template <typename TDim>
- inline CoordinateSystemPtr make_translationAndRotation(
+ CoordinateSystemPtr make_translationAndRotation(
CoordinateSystemPtr const& cs, QuantityVector<length_d> const& translation,
QuantityVector<TDim> const& axis, double const angle);
@@ -119,14 +118,14 @@ namespace corsika {
/**
* Checks, if this is the unique ROOT CS
*/
- inline bool isRoot() const { return !referenceCS_; }
+ bool isRoot() const { return !referenceCS_; }
- inline CoordinateSystemPtr getReferenceCS() const;
+ CoordinateSystemPtr getReferenceCS() const;
- inline EigenTransform const& getTransform() const;
+ EigenTransform const& getTransform() const;
- inline bool operator==(CoordinateSystem const&) const;
- inline bool operator!=(CoordinateSystem const&) const;
+ bool operator==(CoordinateSystem const&) const;
+ bool operator!=(CoordinateSystem const&) const;
protected:
static CoordinateSystem createCS() { return CoordinateSystem(); }
@@ -171,8 +170,8 @@ namespace corsika {
*
* \todo make this a protected member of CoordinateSystem
*/
- inline EigenTransform get_transformation(CoordinateSystem const& c1,
- CoordinateSystem const& c2);
+ EigenTransform get_transformation(CoordinateSystem const& c1,
+ CoordinateSystem const& c2);
} // namespace corsika
diff --git a/corsika/framework/geometry/FourVector.hpp b/corsika/framework/geometry/FourVector.hpp
index 99932012d..0b87accec 100644
--- a/corsika/framework/geometry/FourVector.hpp
+++ b/corsika/framework/geometry/FourVector.hpp
@@ -190,8 +190,8 @@ namespace corsika {
**/
template <typename TTimeType, typename TSpaceVecType>
- inline std::ostream& operator<<(
- std::ostream& os, corsika::FourVector<TTimeType, TSpaceVecType> const& qv);
+ std::ostream& operator<<(std::ostream& os,
+ corsika::FourVector<TTimeType, TSpaceVecType> const& qv);
} // namespace corsika
diff --git a/corsika/framework/geometry/Helix.hpp b/corsika/framework/geometry/Helix.hpp
index 5bd9fac77..0ed762d6a 100644
--- a/corsika/framework/geometry/Helix.hpp
+++ b/corsika/framework/geometry/Helix.hpp
@@ -44,17 +44,17 @@ namespace corsika {
, uPerp_(vPerp_.cross(vPar_.normalized()))
, radius_(pvPar.getNorm() / abs(pOmegaC)) {}
- inline LengthType getRadius() const;
+ LengthType getRadius() const;
- inline Point getPosition(TimeType const t) const;
+ Point getPosition(TimeType const t) const;
VelocityVec getVelocity(TimeType const t) const;
- inline Point getPositionFromArclength(LengthType const l) const;
+ Point getPositionFromArclength(LengthType const l) const;
- inline LengthType getArcLength(TimeType const t1, TimeType const t2) const;
+ LengthType getArcLength(TimeType const t1, TimeType const t2) const;
- inline TimeType getTimeFromArclength(LengthType const l) const;
+ TimeType getTimeFromArclength(LengthType const l) const;
private:
Point r0_; ///! origin of helix, but this is in the center of the
diff --git a/corsika/framework/geometry/Line.hpp b/corsika/framework/geometry/Line.hpp
index cdb03d624..7f68984bd 100644
--- a/corsika/framework/geometry/Line.hpp
+++ b/corsika/framework/geometry/Line.hpp
@@ -31,21 +31,21 @@ namespace corsika {
: start_point_(pR0)
, velocity_(pV0) {}
- inline Point getPosition(TimeType const t) const;
+ Point getPosition(TimeType const t) const;
- inline VelocityVector const& getVelocity(TimeType const) const;
+ VelocityVector const& getVelocity(TimeType const) const;
- inline Point getPositionFromArclength(LengthType const l) const;
+ Point getPositionFromArclength(LengthType const l) const;
- inline LengthType getArcLength(TimeType const t1, TimeType const t2) const;
+ LengthType getArcLength(TimeType const t1, TimeType const t2) const;
- inline TimeType getTimeFromArclength(LengthType const t) const;
+ TimeType getTimeFromArclength(LengthType const t) const;
- inline Point const& getStartPoint() const;
+ Point const& getStartPoint() const;
- inline DirectionVector getDirection() const;
+ DirectionVector getDirection() const;
- inline VelocityVector const& getVelocity() const;
+ VelocityVector const& getVelocity() const;
private:
Point start_point_;
diff --git a/corsika/framework/geometry/Point.hpp b/corsika/framework/geometry/Point.hpp
index b06a68bde..2c6844384 100644
--- a/corsika/framework/geometry/Point.hpp
+++ b/corsika/framework/geometry/Point.hpp
@@ -31,8 +31,8 @@ namespace corsika {
/** \todo TODO: this should be private or protected, we don NOT want to expose numbers
* without reference to outside:
*/
- inline QuantityVector<length_d> const& getCoordinates() const;
- inline QuantityVector<length_d>& getCoordinates();
+ QuantityVector<length_d> const& getCoordinates() const;
+ QuantityVector<length_d>& getCoordinates();
/**
this always returns a QuantityVector as triple
@@ -40,7 +40,7 @@ namespace corsika {
\returns A value type QuantityVector, since it may have to create a temporary
object to transform to pCS.
**/
- inline QuantityVector<length_d> getCoordinates(CoordinateSystemPtr const& pCS) const;
+ QuantityVector<length_d> getCoordinates(CoordinateSystemPtr const& pCS) const;
/**
* this always returns a QuantityVector as triple
@@ -49,7 +49,7 @@ namespace corsika {
* is actually transformed to pCS, if needed. Thus, there may be an implicit call to
* \ref rebase.
**/
- inline QuantityVector<length_d>& getCoordinates(CoordinateSystemPtr const& pCS);
+ QuantityVector<length_d>& getCoordinates(CoordinateSystemPtr const& pCS);
/**
* \name access coordinate components
@@ -60,23 +60,23 @@ namespace corsika {
* created and destroyed each call. This can be avoided by using
* \ref rebase first.
**/
- inline LengthType getX(CoordinateSystemPtr const& pCS) const;
- inline LengthType getY(CoordinateSystemPtr const& pCS) const;
- inline LengthType getZ(CoordinateSystemPtr const& pCS) const;
+ LengthType getX(CoordinateSystemPtr const& pCS) const;
+ LengthType getY(CoordinateSystemPtr const& pCS) const;
+ LengthType getZ(CoordinateSystemPtr const& pCS) const;
/** \} **/
/*!
* transforms the Point into another CoordinateSystem by changing its
* coordinates interally
*/
- inline void rebase(CoordinateSystemPtr const& pCS);
+ void rebase(CoordinateSystemPtr const& pCS);
- inline Point operator+(Vector<length_d> const& pVec) const;
+ Point operator+(Vector<length_d> const& pVec) const;
/*!
* returns the distance Vector between two points
*/
- inline Vector<length_d> operator-(Point const& pB) const;
+ Vector<length_d> operator-(Point const& pB) const;
};
} // namespace corsika
diff --git a/corsika/framework/geometry/QuantityVector.hpp b/corsika/framework/geometry/QuantityVector.hpp
index eb6c2f11e..d9199dc57 100644
--- a/corsika/framework/geometry/QuantityVector.hpp
+++ b/corsika/framework/geometry/QuantityVector.hpp
@@ -113,8 +113,8 @@ namespace corsika {
**/
template <typename TDimension>
- inline std::ostream& operator<<(std::ostream& os,
- corsika::QuantityVector<TDimension> const& qv);
+ std::ostream& operator<<(std::ostream& os,
+ corsika::QuantityVector<TDimension> const& qv);
} // namespace corsika
diff --git a/corsika/framework/geometry/Vector.hpp b/corsika/framework/geometry/Vector.hpp
index 0d37c66c7..fec720e4d 100644
--- a/corsika/framework/geometry/Vector.hpp
+++ b/corsika/framework/geometry/Vector.hpp
@@ -47,14 +47,14 @@ namespace corsika {
* \todo this should best be protected, we don't want users to use
* bare coordinates without reference frame
*/
- inline QuantityVector<TDimension> const& getComponents() const;
- inline QuantityVector<TDimension>& getComponents();
+ QuantityVector<TDimension> const& getComponents() const;
+ QuantityVector<TDimension>& getComponents();
/*!
* returns a QuantityVector with the components given in an arbitrary
* CoordinateSystem
*/
- inline QuantityVector<TDimension> getComponents(CoordinateSystemPtr const& pCS) const;
+ QuantityVector<TDimension> getComponents(CoordinateSystemPtr const& pCS) const;
/**
* this always returns a QuantityVector as triple
@@ -63,7 +63,7 @@ namespace corsika {
* is actually transformed to pCS, if needed. Thus, there may be an implicit call to
* \ref rebase.
**/
- inline QuantityVector<TDimension>& getComponents(CoordinateSystemPtr const& pCS);
+ QuantityVector<TDimension>& getComponents(CoordinateSystemPtr const& pCS);
/**
* \name Access coordinate components
@@ -76,28 +76,28 @@ namespace corsika {
* \{
**/
- inline quantity_type getX(CoordinateSystemPtr const& pCS) const;
- inline quantity_type getY(CoordinateSystemPtr const& pCS) const;
- inline quantity_type getZ(CoordinateSystemPtr const& pCS) const;
+ quantity_type getX(CoordinateSystemPtr const& pCS) const;
+ quantity_type getY(CoordinateSystemPtr const& pCS) const;
+ quantity_type getZ(CoordinateSystemPtr const& pCS) const;
/** \} **/
/*!
* transforms the Vector into another CoordinateSystem by changing
* its components internally
*/
- inline void rebase(CoordinateSystemPtr const& pCS);
+ void rebase(CoordinateSystemPtr const& pCS);
/*!
* returns the norm/length of the Vector. Before using this method,
* think about whether squaredNorm() might be cheaper for your computation.
*/
- inline quantity_type getNorm() const;
+ quantity_type getNorm() const;
/*!
* returns the squared norm of the Vector. Before using this method,
* think about whether norm() might be cheaper for your computation.
*/
- inline quantity_square_type getSquaredNorm() const;
+ quantity_square_type getSquaredNorm() const;
/*!
* returns a Vector \f$ \vec{v}_{\parallel} \f$ which is the parallel projection
diff --git a/corsika/framework/process/ProcessSequence.hpp b/corsika/framework/process/ProcessSequence.hpp
index d909d0715..30c270bcb 100644
--- a/corsika/framework/process/ProcessSequence.hpp
+++ b/corsika/framework/process/ProcessSequence.hpp
@@ -118,11 +118,11 @@ namespace corsika {
typename TParticle::node_type const& to);
template <typename TParticle, typename TTrack>
- inline ProcessReturn doContinuous(TParticle& particle, TTrack& vT,
- ContinuousProcessIndex const limitID);
+ ProcessReturn doContinuous(TParticle& particle, TTrack& vT,
+ ContinuousProcessIndex const limitID);
template <typename TSecondaries>
- inline void doSecondaries(TSecondaries& vS);
+ void doSecondaries(TSecondaries& vS);
/**
The processes of type StackProcess do have an internal counter,
@@ -132,53 +132,53 @@ namespace corsika {
tested if either A_ or B_ are StackProcess and if they are due
for execution.
*/
- inline bool checkStep();
+ bool checkStep();
/**
Execute the StackProcess-es in the ProcessSequence
*/
template <typename TStack>
- inline void doStack(TStack& stack);
+ void doStack(TStack& stack);
/**
- * Determines the step-length limitation caused by ContinuousProcess-es in this
- ProcessSequence.
+ * Calculate the maximum allowed length of the next tracking step, based on all
+ * ContinuousProcess-es
*
- * Returns a ContinuousProcessStepLength object, which contains both: the actual
- * length (LengthType) as well as the index of the ContinuousProcess inside the
- * ProcessSequence (for identification).
-
+ * The maximum allowed step length is the minimum of the allowed track lenght over all
+ * ContinuousProcess-es in the ProcessSequence.
+ *
+ * \return: ContinuousProcessStepLength which contains the step length itself in
+ * LengthType, and a unique identifier of the related ContinuousProcess.
**/
template <typename TParticle, typename TTrack>
- inline ContinuousProcessStepLength getMaxStepLength(TParticle& particle,
- TTrack& vTrack);
+ ContinuousProcessStepLength getMaxStepLength(TParticle& particle, TTrack& vTrack);
template <typename TParticle>
- inline GrammageType getInteractionLength(TParticle&& particle) {
+ GrammageType getInteractionLength(TParticle&& particle) {
return 1. / getInverseInteractionLength(particle);
}
template <typename TParticle>
- inline InverseGrammageType getInverseInteractionLength(TParticle&& particle);
+ InverseGrammageType getInverseInteractionLength(TParticle&& particle);
template <typename TSecondaryView>
- inline ProcessReturn selectInteraction(
+ ProcessReturn selectInteraction(
TSecondaryView& view, [[maybe_unused]] InverseGrammageType lambda_inv_select,
[[maybe_unused]] InverseGrammageType lambda_inv_sum =
InverseGrammageType::zero());
template <typename TParticle>
- inline TimeType getLifetime(TParticle& particle) {
+ TimeType getLifetime(TParticle& particle) {
return 1. / getInverseLifetime(particle);
}
template <typename TParticle>
- inline InverseTimeType getInverseLifetime(TParticle&& particle);
+ InverseTimeType getInverseLifetime(TParticle&& particle);
// select decay process
template <typename TSecondaryView>
- inline ProcessReturn selectDecay(
+ ProcessReturn selectDecay(
TSecondaryView& view, [[maybe_unused]] InverseTimeType decay_inv_select,
[[maybe_unused]] InverseTimeType decay_inv_sum = InverseTimeType::zero());
@@ -219,7 +219,7 @@ namespace corsika {
**/
template <typename... TProcesses, typename TProcess1>
- inline typename std::enable_if_t<
+ typename std::enable_if_t<
is_process_v<typename std::decay_t<TProcess1>>,
ProcessSequence<TProcess1, decltype(make_sequence(std::declval<TProcesses>()...))>>
make_sequence(TProcess1&& vA, TProcesses&&... vBs) {
@@ -237,9 +237,9 @@ namespace corsika {
* \param vB needs to derive BaseProcess or ProcessSequence
**/
template <typename TProcess1, typename TProcess2>
- inline typename std::enable_if_t<is_process_v<typename std::decay_t<TProcess1>> &&
- is_process_v<typename std::decay_t<TProcess2>>,
- ProcessSequence<TProcess1, TProcess2>>
+ typename std::enable_if_t<is_process_v<typename std::decay_t<TProcess1>> &&
+ is_process_v<typename std::decay_t<TProcess2>>,
+ ProcessSequence<TProcess1, TProcess2>>
make_sequence(TProcess1&& vA, TProcess2&& vB) {
return ProcessSequence<TProcess1, TProcess2>(vA, vB);
}
@@ -253,8 +253,8 @@ namespace corsika {
* \param vA needs to derive from BaseProcess or ProcessSequence
**/
template <typename TProcess>
- inline typename std::enable_if_t<is_process_v<typename std::decay_t<TProcess>>,
- ProcessSequence<TProcess, NullModel>>
+ typename std::enable_if_t<is_process_v<typename std::decay_t<TProcess>>,
+ ProcessSequence<TProcess, NullModel>>
make_sequence(TProcess&& vA) {
return ProcessSequence<TProcess, NullModel>(vA, NullModel());
}
diff --git a/corsika/framework/process/SecondariesProcess.hpp b/corsika/framework/process/SecondariesProcess.hpp
index 0d6db4783..daa45cc39 100644
--- a/corsika/framework/process/SecondariesProcess.hpp
+++ b/corsika/framework/process/SecondariesProcess.hpp
@@ -28,7 +28,7 @@ namespace corsika {
/// here starts the interface-definition part
// -> enforce TDerived to implement DoSecondaries...
template <typename TSecondaries>
- inline void doSecondaries(TSecondaries&);
+ void doSecondaries(TSecondaries&);
};
} // namespace corsika
diff --git a/corsika/framework/process/StackProcess.hpp b/corsika/framework/process/StackProcess.hpp
index 77ca2a479..7bf23c82c 100644
--- a/corsika/framework/process/StackProcess.hpp
+++ b/corsika/framework/process/StackProcess.hpp
@@ -34,7 +34,7 @@ namespace corsika {
/// here starts the interface-definition part
// -> enforce TDerived to implement DoStack...
template <typename TStack>
- inline void doStack(TStack&);
+ void doStack(TStack&);
int getStep() const { return iStep_; }
bool checkStep() { return !((++iStep_) % nStep_); }
diff --git a/corsika/framework/process/SwitchProcessSequence.hpp b/corsika/framework/process/SwitchProcessSequence.hpp
index dcf4b214e..22da0facc 100644
--- a/corsika/framework/process/SwitchProcessSequence.hpp
+++ b/corsika/framework/process/SwitchProcessSequence.hpp
@@ -132,41 +132,40 @@ namespace corsika {
TVTNType const& to);
template <typename TParticle, typename TTrack>
- inline ProcessReturn doContinuous(TParticle& particle, TTrack& vT,
- ContinuousProcessIndex const limitId);
+ ProcessReturn doContinuous(TParticle& particle, TTrack& vT,
+ ContinuousProcessIndex const limitId);
template <typename TSecondaries>
- inline void doSecondaries(TSecondaries& vS);
+ void doSecondaries(TSecondaries& vS);
template <typename TParticle, typename TTrack>
- inline ContinuousProcessStepLength getMaxStepLength(TParticle& particle,
- TTrack& vTrack);
+ ContinuousProcessStepLength getMaxStepLength(TParticle& particle, TTrack& vTrack);
template <typename TParticle>
- inline GrammageType getInteractionLength(TParticle&& particle) {
+ GrammageType getInteractionLength(TParticle&& particle) {
return 1. / getInverseInteractionLength(particle);
}
template <typename TParticle>
- inline InverseGrammageType getInverseInteractionLength(TParticle&& particle);
+ InverseGrammageType getInverseInteractionLength(TParticle&& particle);
template <typename TSecondaryView>
- inline ProcessReturn selectInteraction(
+ ProcessReturn selectInteraction(
TSecondaryView& view, [[maybe_unused]] InverseGrammageType lambda_inv_select,
[[maybe_unused]] InverseGrammageType lambda_inv_sum =
InverseGrammageType::zero());
template <typename TParticle>
- inline TimeType getLifetime(TParticle&& particle) {
+ TimeType getLifetime(TParticle&& particle) {
return 1. / getInverseLifetime(particle);
}
template <typename TParticle>
- inline InverseTimeType getInverseLifetime(TParticle&& particle);
+ InverseTimeType getInverseLifetime(TParticle&& particle);
// select decay process
template <typename TSecondaryView>
- inline ProcessReturn selectDecay(
+ ProcessReturn selectDecay(
TSecondaryView& view, [[maybe_unused]] InverseTimeType decay_inv_select,
[[maybe_unused]] InverseTimeType decay_inv_sum = InverseTimeType::zero());
@@ -197,9 +196,9 @@ namespace corsika {
**/
template <typename TProcess1, typename TProcess2, typename TSelect>
- inline typename std::enable_if_t<is_process_v<typename std::decay_t<TProcess1>> &&
- is_process_v<typename std::decay_t<TProcess2>>,
- SwitchProcessSequence<TProcess1, TProcess2, TSelect>>
+ typename std::enable_if_t<is_process_v<typename std::decay_t<TProcess1>> &&
+ is_process_v<typename std::decay_t<TProcess2>>,
+ SwitchProcessSequence<TProcess1, TProcess2, TSelect>>
make_select(TProcess1&& vA, TProcess2&& vB, TSelect selector) {
return SwitchProcessSequence<TProcess1, TProcess2, TSelect>(vA, vB, selector);
}
diff --git a/corsika/framework/random/RNGManager.hpp b/corsika/framework/random/RNGManager.hpp
index 2dd6160e9..0e687adf4 100644
--- a/corsika/framework/random/RNGManager.hpp
+++ b/corsika/framework/random/RNGManager.hpp
@@ -43,36 +43,35 @@ namespace corsika {
*
* \throws sth. when stream \a pModuleName is already registered
*/
- inline void registerRandomStream(string_type const& streamName);
+ void registerRandomStream(string_type const& streamName);
/*!
* returns the pre-stored stream of given name \a pStreamName if
* available
*/
- inline prng_type& getRandomStream(string_type const& streamName);
+ prng_type& getRandomStream(string_type const& streamName);
/*!
* Check whether a stream has been registered.
*/
- inline bool isRegistered(string_type const& streamName) const;
+ bool isRegistered(string_type const& streamName) const;
/*!
* dumps the names and states of all registered random-number streams
* into a std::stringstream.
*/
- inline std::stringstream dumpState() const;
+ std::stringstream dumpState() const;
/**
* Set explicit seeds for all currently registered streams. The actual seed values
* are incremented from \a vSeed.
*/
- inline void seedAll(seed_type seed);
+ void seedAll(seed_type seed);
/**
* Set seeds for all currently registered streams.
*/
- inline void seedAll(
- void); //!< seed all currently registered streams with "real" randomness
+ void seedAll(void); //!< seed all currently registered streams with "real" randomness
/**
* @fn const streams_type getRngs&()const
@@ -82,7 +81,7 @@ namespace corsika {
* @post
* @return RNGManager::streams_type
*/
- inline const streams_type& getRngs() const { return rngs_; }
+ const streams_type& getRngs() const { return rngs_; }
/**
* @fn const seeds_type getSeeds&()const
@@ -92,7 +91,7 @@ namespace corsika {
* @post
* @return RNGManager::seeds_type
*/
- inline const seeds_type& getSeeds() const { return seeds_; }
+ const seeds_type& getSeeds() const { return seeds_; }
/**
* @fn streams_type Rngs()
@@ -102,7 +101,7 @@ namespace corsika {
* @post
* @return RNGManager::streams_type&
*/
- inline streams_type Rngs() { return rngs_; }
+ streams_type Rngs() { return rngs_; }
/**
* @fn seeds_type Seeds&()
@@ -112,7 +111,7 @@ namespace corsika {
* @post
* @return RNGManager::seeds_type&
*/
- inline seeds_type& Seeds() { return seeds_; }
+ seeds_type& getSeeds() { return seeds_; }
protected:
RNGManager() = default;
diff --git a/corsika/framework/random/UniformRealDistribution.hpp b/corsika/framework/random/UniformRealDistribution.hpp
index 781a23717..76f147de5 100644
--- a/corsika/framework/random/UniformRealDistribution.hpp
+++ b/corsika/framework/random/UniformRealDistribution.hpp
@@ -36,7 +36,7 @@ namespace corsika {
: min_(other.getMin())
, max_(other.getMax()) {}
- inline UniformRealDistribution<value_type>& operator=(
+ UniformRealDistribution<value_type>& operator=(
UniformRealDistribution<value_type> const& other) {
if (this == &other) return *this;
min_ = other.getMin();
@@ -52,7 +52,7 @@ namespace corsika {
* @post
* @return quantity_type
*/
- inline value_type getMax() const { return max_; }
+ value_type getMax() const { return max_; }
/**
* @fn void setMax(quantity_type)
@@ -62,7 +62,7 @@ namespace corsika {
* @post
* @param vMax
*/
- inline void setMax(value_type const& pmax) { max_ = pmax; }
+ void setMax(value_type const& pmax) { max_ = pmax; }
/**
* @fn quantity_type getMin()const
@@ -72,7 +72,7 @@ namespace corsika {
* @post
* @return
*/
- inline value_type getMin() const { return min_; }
+ value_type getMin() const { return min_; }
/**
* @fn void setMin(quantity_type)
@@ -82,7 +82,7 @@ namespace corsika {
* @post
* @param vMin
*/
- inline void setMin(value_type const& pmin) { min_ = pmin; }
+ void setMin(value_type const& pmin) { min_ = pmin; }
/**
* @fn quantity_type operator ()(Generator&)
@@ -95,7 +95,7 @@ namespace corsika {
* @return quantity_type
*/
template <class Generator>
- inline value_type operator()(Generator& g) {
+ value_type operator()(Generator& g) {
return min_ + dist_(g) * (max_ - min_);
}
diff --git a/corsika/framework/stack/CombinedStack.hpp b/corsika/framework/stack/CombinedStack.hpp
index d452d8f8b..e83e33a2f 100644
--- a/corsika/framework/stack/CombinedStack.hpp
+++ b/corsika/framework/stack/CombinedStack.hpp
@@ -67,21 +67,20 @@ namespace corsika {
*/
template <typename... TArgs1>
- inline void setParticleData(std::tuple<TArgs1...> const vA);
+ 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);
+ 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);
+ 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);
+ void setParticleData(pi_c_type& p, std::tuple<TArgs1...> const vA,
+ std::tuple<TArgs2...> const vB);
///@}
- inline std::string asString() const;
+ std::string asString() const;
protected:
};
@@ -99,24 +98,24 @@ namespace corsika {
struct CombinedStackImpl : public Stack1Impl, public Stack2Impl {
public:
- inline void clear();
+ void clear();
- inline unsigned int getSize() const { return Stack1Impl::getSize(); }
- inline unsigned int getCapacity() const { return Stack1Impl::getCapacity(); }
+ unsigned int getSize() const { return Stack1Impl::getSize(); }
+ 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);
+ 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);
+ void swap(const unsigned int i1, const unsigned int i2);
- inline void incrementSize();
+ void incrementSize();
- inline void decrementSize();
+ void decrementSize();
}; // end class CombinedStackImpl
diff --git a/corsika/framework/stack/ParticleBase.hpp b/corsika/framework/stack/ParticleBase.hpp
index c7b086c5c..2c62285d5 100644
--- a/corsika/framework/stack/ParticleBase.hpp
+++ b/corsika/framework/stack/ParticleBase.hpp
@@ -58,13 +58,13 @@ namespace corsika {
* Delete this particle on the stack. The corresponding iterator
* will be invalidated by this operation
*/
- inline void erase() { this->getIterator().getStack().erase(this->getIterator()); }
+ void erase() { this->getIterator().getStack().erase(this->getIterator()); }
/**
* Method to retrieve the status of the Particle. Is it already deleted? Or not.
*/
- inline bool isErased() const {
+ bool isErased() const {
return this->getIterator().getStack().isErased(this->getIterator());
}
@@ -74,7 +74,7 @@ namespace corsika {
* function description in the user defined ParticleInterface::AddSecondary(...)
*/
template <typename... TArgs>
- inline stack_iterator_type addSecondary(const TArgs... args) {
+ stack_iterator_type addSecondary(const TArgs... args) {
return this->getStack().addSecondary(this->getIterator(), args...);
}
@@ -84,11 +84,11 @@ namespace corsika {
/**
* return the corresponding StackIterator for this particle
*/
- inline stack_iterator_type& getIterator() {
+ stack_iterator_type& getIterator() {
return static_cast<stack_iterator_type&>(*this);
}
- inline const stack_iterator_type& getIterator() const {
+ const stack_iterator_type& getIterator() const {
return static_cast<const stack_iterator_type&>(*this);
}
@@ -99,21 +99,19 @@ namespace corsika {
and getStackData to retrieve data
@{
*/
- inline auto& getStackData() { return this->getIterator().getStackData(); }
+ auto& getStackData() { return this->getIterator().getStackData(); }
- inline const auto& getStackData() const { return this->getIterator().getStackData(); }
+ const auto& getStackData() const { return this->getIterator().getStackData(); }
- inline auto& getStack() { return this->getIterator().getStack(); }
+ auto& getStack() { return this->getIterator().getStack(); }
- inline const auto& getStack() const { return this->getIterator().getStack(); }
+ const auto& getStack() const { return this->getIterator().getStack(); }
/**
* return the index number of the underlying iterator object
*/
- inline std::size_t getIndex() const {
- return this->getIterator().getIndexFromIterator();
- }
+ std::size_t getIndex() const { return this->getIterator().getIndexFromIterator(); }
///@}
};
diff --git a/corsika/framework/stack/SecondaryView.hpp b/corsika/framework/stack/SecondaryView.hpp
index e15179c7e..9e5f60324 100644
--- a/corsika/framework/stack/SecondaryView.hpp
+++ b/corsika/framework/stack/SecondaryView.hpp
@@ -167,7 +167,7 @@ namespace corsika {
* SecondaryView is derived from. This projectile should not be
* used to modify the Stack!
*/
- inline stack_value_iterator parent()
+ stack_value_iterator parent()
const { // todo: check if this can't be Conststack_value_iterator
return stack_value_iterator(inner_stack_, projectile_index_);
}
@@ -177,7 +177,7 @@ namespace corsika {
* SecondaryView is derived from. This projectile should not be
* used to modify the Stack!
*/
- inline stack_value_iterator asNewParent() const {
+ stack_value_iterator asNewParent() const {
return stack_value_iterator(inner_stack_, projectile_index_);
}
@@ -185,7 +185,7 @@ namespace corsika {
* This return a projectile of this SecondaryView, which can be
* used to modify the SecondaryView
*/
- inline stack_view_iterator getProjectile() {
+ stack_view_iterator getProjectile() {
// NOTE: 0 is special marker here for PROJECTILE, see getIndexFromIterator
return stack_view_iterator(*this, 0);
}
@@ -194,7 +194,7 @@ namespace corsika {
* This return a projectile of this SecondaryView, which can be
* used to modify the SecondaryView
*/
- inline const_stack_view_iterator getProjectile() const {
+ const_stack_view_iterator getProjectile() const {
// NOTE: 0 is special marker here for PROJECTILE, see getIndexFromIterator
return const_stack_view_iterator(*this, 0);
}
@@ -203,18 +203,18 @@ namespace corsika {
* Method to add a new secondary particle on this SecondaryView
*/
template <typename... Args>
- inline stack_view_iterator addSecondary(const Args... v);
+ stack_view_iterator addSecondary(const Args... v);
/**
* overwrite Stack::getSize to return actual number of secondaries
*/
- inline unsigned int getSize() const { return indices_.size(); }
+ unsigned int getSize() const { return indices_.size(); }
- inline unsigned int getEntries() const {
+ unsigned int getEntries() const {
return getSize() - inner_stack_reference_type::getErased();
}
- inline bool isEmpty() const { return getEntries() == 0; }
+ bool isEmpty() const { return getEntries() == 0; }
/**
* @name These are functions required by std containers and std loops
@@ -224,48 +224,46 @@ namespace corsika {
*/
// NOTE: the "+1" is since "0" is special marker here for PROJECTILE, see
// getIndexFromIterator
- inline stack_view_iterator begin();
+ stack_view_iterator begin();
- inline stack_view_iterator end() { return stack_view_iterator(*this, getSize() + 1); }
+ stack_view_iterator end() { return stack_view_iterator(*this, getSize() + 1); }
- inline stack_view_iterator last();
+ stack_view_iterator last();
- inline const_stack_view_iterator begin() const;
+ const_stack_view_iterator begin() const;
- inline const_stack_view_iterator end() const {
+ const_stack_view_iterator end() const {
return const_stack_view_iterator(*this, getSize() + 1);
}
- inline const_stack_view_iterator last() const;
+ const_stack_view_iterator last() const;
- inline const_stack_view_iterator cbegin() const;
+ const_stack_view_iterator cbegin() const;
- inline const_stack_view_iterator cend() const {
+ const_stack_view_iterator cend() const {
return const_stack_view_iterator(*this, getSize());
}
- inline const_stack_view_iterator clast() const;
+ const_stack_view_iterator clast() const;
- inline stack_view_iterator at(unsigned int i) {
- return stack_view_iterator(*this, i);
- }
+ stack_view_iterator at(unsigned int i) { return stack_view_iterator(*this, i); }
- inline const_stack_view_iterator at(unsigned int i) const {
+ const_stack_view_iterator at(unsigned int i) const {
return const_stack_view_iterator(*this, i);
}
- inline stack_view_iterator first() { return stack_view_iterator{*this, 0}; }
+ stack_view_iterator first() { return stack_view_iterator{*this, 0}; }
- inline const_stack_view_iterator cfirst() const {
+ const_stack_view_iterator cfirst() const {
return const_stack_view_iterator{*this, 0};
}
/// @}
- inline void swap(stack_view_iterator a, stack_view_iterator b);
+ void swap(stack_view_iterator a, stack_view_iterator b);
- inline void copy(stack_view_iterator a, stack_view_iterator b);
+ void copy(stack_view_iterator a, stack_view_iterator b);
- inline void copy(const_stack_view_iterator a, stack_view_iterator b);
+ void copy(const_stack_view_iterator a, stack_view_iterator b);
/**
* need overwrite Stack::Delete, since we want to call
@@ -279,13 +277,13 @@ namespace corsika {
* remove the last particle.
*
*/
- inline void erase(stack_view_iterator p);
+ void erase(stack_view_iterator p);
/**
* return next particle from stack, need to overwrtie Stack::getNextParticle to get
* right reference
*/
- inline stack_view_iterator getNextParticle() {
+ stack_view_iterator getNextParticle() {
while (purgeLastIfDeleted()) {}
return last();
}
@@ -296,21 +294,21 @@ namespace corsika {
* need to re-implement for SecondaryView since stack_view_iterator types are a bit
* different
*/
- inline bool isErased(const stack_view_iterator& p) const {
+ bool isErased(const stack_view_iterator& p) const {
return isErased(p.getIndex() - 1);
}
- inline bool isErased(const const_stack_view_iterator& p) const {
+ bool isErased(const const_stack_view_iterator& p) const {
return isErased(p.getIndex() - 1);
}
/**
* delete this particle
*/
- inline bool isErased(const ParticleInterfaceType& p) const {
+ bool isErased(const ParticleInterfaceType& p) const {
return isErased(p.getIterator());
}
- inline bool isDeleted(const const_stack_view_iterator& p) const {
+ bool isDeleted(const const_stack_view_iterator& p) const {
return isDeleted(p.getIndex() - 1);
}
/**
@@ -318,7 +316,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();
+ bool purgeLastIfDeleted();
/**
* Function to ultimatively remove all entries from the stack
@@ -328,9 +326,9 @@ namespace corsika {
* "gaps" in the stack are filled with entries from the back
* (copied).
*/
- inline void purge();
+ void purge();
- inline std::string asString() const;
+ std::string asString() const;
protected:
friend class StackIteratorInterface<
@@ -353,11 +351,11 @@ namespace corsika {
* stack_view_iterator::addSecondary via ParticleBase
*/
template <typename... Args>
- inline stack_view_iterator addSecondary(stack_view_iterator& proj, const Args... v);
+ stack_view_iterator addSecondary(stack_view_iterator& proj, const Args... v);
// forward to inner stack
// this also checks the allowed bounds of 'i'
- inline bool isErased(unsigned int i) const {
+ bool isErased(unsigned int i) const {
if (i >= indices_.size()) return false;
return inner_stack_.isErased(getIndexFromIterator(i + 1));
}
@@ -367,7 +365,7 @@ namespace corsika {
* function the conversion form iterator-index to stack-index is
* performed.
*/
- inline unsigned int getIndexFromIterator(const unsigned int vI) const {
+ unsigned int getIndexFromIterator(const unsigned int vI) const {
// this is too much: CORSIKA_LOG_TRACE("SecondaryView::getIndexFromIterator({})={}",
// vI, (vI?indices_[vI-1]:projectile_index_));
if (vI == 0) return projectile_index_;
@@ -399,7 +397,7 @@ namespace corsika {
* is of course a reference into the SecondaryView itself.
*/
template <typename Particle>
- inline void new_secondary(Particle&&) const {
+ void new_secondary(Particle&&) const {
CORSIKA_LOG_TRACE("DefaultSecondaryProducer::new_secondary(Particle&&)");
}
@@ -412,7 +410,7 @@ namespace corsika {
* itself.
*/
template <typename Particle>
- inline DefaultSecondaryProducer(Particle const&) {
+ DefaultSecondaryProducer(Particle const&) {
CORSIKA_LOG_TRACE("DefaultSecondaryProducer::DefaultSecondaryProducer(Particle&)");
}
diff --git a/corsika/framework/stack/Stack.hpp b/corsika/framework/stack/Stack.hpp
index e72dc94db..2ff173fb3 100644
--- a/corsika/framework/stack/Stack.hpp
+++ b/corsika/framework/stack/Stack.hpp
@@ -152,89 +152,89 @@ namespace corsika {
* @name Most generic proxy methods for StackData data_
* @{
*/
- inline unsigned int getCapacity() const { return data_.getCapacity(); }
+ unsigned int getCapacity() const { return data_.getCapacity(); }
- inline unsigned int getErased() const { return nDeleted_; }
+ unsigned int getErased() const { return nDeleted_; }
- inline unsigned int getEntries() const { return getSize() - getErased(); }
+ unsigned int getEntries() const { return getSize() - getErased(); }
template <typename... TArgs>
- inline void clear(TArgs... args);
+ void clear(TArgs... args);
///@}
/**
* @name These are functions required by std containers and std loops
* @{
*/
- inline stack_iterator_type begin();
+ stack_iterator_type begin();
- inline stack_iterator_type end();
+ stack_iterator_type end();
- inline stack_iterator_type last();
+ stack_iterator_type last();
- inline const_stack_iterator_type begin() const;
+ const_stack_iterator_type begin() const;
- inline const_stack_iterator_type end() const;
+ const_stack_iterator_type end() const;
- inline const_stack_iterator_type last() const;
+ const_stack_iterator_type last() const;
- inline const_stack_iterator_type cbegin() const;
+ const_stack_iterator_type cbegin() const;
- inline const_stack_iterator_type cend() const;
+ const_stack_iterator_type cend() const;
- inline const_stack_iterator_type clast() const;
+ const_stack_iterator_type clast() const;
- inline stack_iterator_type at(unsigned int i);
+ stack_iterator_type at(unsigned int i);
- inline const_stack_iterator_type at(unsigned int i) const;
+ const_stack_iterator_type at(unsigned int i) const;
- inline stack_iterator_type first();
+ stack_iterator_type first();
- inline const_stack_iterator_type cfirst() const;
+ const_stack_iterator_type cfirst() const;
- inline stack_iterator_type getNextParticle();
+ 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);
+ stack_iterator_type addParticle(const TArgs... v);
- inline void swap(stack_iterator_type a, stack_iterator_type b);
+ void swap(stack_iterator_type a, stack_iterator_type b);
- inline void copy(stack_iterator_type a, stack_iterator_type b);
+ void copy(stack_iterator_type a, stack_iterator_type b);
- inline void copy(const_stack_iterator_type a, stack_iterator_type b);
+ void copy(const_stack_iterator_type a, stack_iterator_type b);
- inline void erase(stack_iterator_type p);
+ void erase(stack_iterator_type p);
/**
* delete this particle
*/
- inline void erase(particle_interface_type p);
+ void erase(particle_interface_type p);
/**
* check if there are no further non-deleted particles on stack
*/
-
- inline bool isEmpty();
+ bool isEmpty();
/**
* check if this particle was already deleted
*/
- inline bool isErased(const stack_iterator_type& p) const;
+ bool isErased(const stack_iterator_type& p) const;
- inline bool isErased(const const_stack_iterator_type& p) const;
+ bool isErased(const const_stack_iterator_type& p) const;
- inline bool isErased(const particle_interface_type& p) const;
+ bool isErased(const particle_interface_type& p) const;
/**
* 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.
*/
- inline bool purgeLastIfDeleted();
+ bool purgeLastIfDeleted();
+
/**
* Function to ultimatively remove all entries from the stack
* marked as deleted.
@@ -243,11 +243,11 @@ namespace corsika {
* "gaps" in the stack are filled with entries from the back
* (copied).
*/
- inline void purge();
+ void purge();
- inline unsigned int getSize() const;
+ unsigned int getSize() const;
- inline std::string asString() const;
+ std::string asString() const;
protected:
/**
@@ -258,22 +258,21 @@ namespace corsika {
* StackIterator::AddSecondary via ParticleBase
*/
template <typename... TArgs>
- inline stack_iterator_type addSecondary(stack_iterator_type& parent,
- const TArgs... v);
+ stack_iterator_type addSecondary(stack_iterator_type& parent, const TArgs... v);
- inline void swap(unsigned int const a, unsigned int const b);
+ void swap(unsigned int const a, unsigned int const b);
- inline void copy(unsigned int const a, unsigned int const b);
+ void copy(unsigned int const a, unsigned int const b);
- inline bool isErased(unsigned int const i) const;
+ bool isErased(unsigned int const i) const;
- inline void erase(unsigned int const i);
+ 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);
+ void purge(unsigned int i);
/**
* Function to perform eventual transformation from
@@ -281,15 +280,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;
+ unsigned int getIndexFromIterator(const unsigned int vI) const;
/**
* @name Return reference to StackData object data_ for data access
* @{
*/
- inline value_type& getStackData();
+ value_type& getStackData();
- inline const value_type& getStackData() const;
+ const value_type& getStackData() const;
friend class StackIteratorInterface<value_type, MParticleInterface, Stack>;
friend class ConstStackIteratorInterface<value_type, MParticleInterface, Stack>;
diff --git a/corsika/framework/stack/StackIteratorInterface.hpp b/corsika/framework/stack/StackIteratorInterface.hpp
index f6240e878..76815746a 100644
--- a/corsika/framework/stack/StackIteratorInterface.hpp
+++ b/corsika/framework/stack/StackIteratorInterface.hpp
@@ -146,14 +146,14 @@ namespace corsika {
/** @name Iterator interface
@{
**/
- inline StackIteratorInterface& operator++() {
+ StackIteratorInterface& operator++() {
do {
++index_;
} while (
getStack().isErased(*this)); // this also check the allowed bounds of index_
return *this;
}
- inline StackIteratorInterface operator++(int) {
+ StackIteratorInterface operator++(int) {
StackIteratorInterface tmp(*this);
do {
++index_;
@@ -161,19 +161,19 @@ namespace corsika {
getStack().isErased(*this)); // this also check the allowed bounds of index_
return tmp;
}
- inline StackIteratorInterface operator+(int delta) const {
+ StackIteratorInterface operator+(int delta) const {
return StackIteratorInterface(*data_, index_ + delta);
}
- inline bool operator==(StackIteratorInterface const& rhs) const {
+ bool operator==(StackIteratorInterface const& rhs) const {
return index_ == rhs.index_;
}
- inline bool operator!=(StackIteratorInterface const& rhs) const {
+ bool operator!=(StackIteratorInterface const& rhs) const {
return index_ != rhs.index_;
}
- inline bool operator==(
+ bool operator==(
const ConstStackIteratorInterface<TStackData, TParticleInterface, TStackType>&
rhs) const; // implemented below
- inline bool operator!=(
+ bool operator!=(
const ConstStackIteratorInterface<TStackData, TParticleInterface, TStackType>&
rhs) const; // implemented below
@@ -181,7 +181,7 @@ namespace corsika {
* Convert iterator to value type, where value type is the user-provided particle
* readout class
**/
- inline particle_interface_type& operator*() {
+ particle_interface_type& operator*() {
return static_cast<particle_interface_type&>(*this);
}
@@ -189,7 +189,7 @@ namespace corsika {
* Convert iterator to const value type, where value type is the user-provided
* particle readout class
**/
- inline particle_interface_type const& operator*() const {
+ particle_interface_type const& operator*() const {
return static_cast<particle_interface_type const&>(*this);
}
///@}
@@ -200,17 +200,17 @@ namespace corsika {
* @{
**/
/// Get current particle index
- inline unsigned int getIndex() const { return index_; }
+ unsigned int getIndex() const { return index_; }
/// Get current particle Stack object
- inline TStackType& getStack() { return *data_; }
+ TStackType& getStack() { return *data_; }
/// Get current particle const Stack object
- inline TStackType const& getStack() const { return *data_; }
+ TStackType const& getStack() const { return *data_; }
/// Get current user particle TStackData object
- inline TStackData& getStackData() { return data_->getStackData(); }
+ TStackData& getStackData() { return data_->getStackData(); }
/// Get current const user particle TStackData object
- inline TStackData const& getStackData() const { return data_->getStackData(); }
+ TStackData const& getStackData() const { return data_->getStackData(); }
/// Get data index as mapped in Stack class
- inline unsigned int getIndexFromIterator() const {
+ unsigned int getIndexFromIterator() const {
return data_->getIndexFromIterator(index_);
}
///@}
@@ -326,11 +326,11 @@ namespace corsika {
Only the const versions for read-only access
@{
*/
- inline unsigned int getIndex() const { return index_; }
- inline TStackType const& getStack() const { return *data_; }
- inline TStackData const& getStackData() const { return data_->getStackData(); }
+ unsigned int getIndex() const { return index_; }
+ TStackType const& getStack() const { return *data_; }
+ TStackData const& getStackData() const { return data_->getStackData(); }
/// Get data index as mapped in Stack class
- inline unsigned int getIndexFromIterator() const {
+ unsigned int getIndexFromIterator() const {
return data_->getIndexFromIterator(index_);
}
///@}
diff --git a/corsika/framework/utility/COMBoost.hpp b/corsika/framework/utility/COMBoost.hpp
index 63b8f0a44..befd30250 100644
--- a/corsika/framework/utility/COMBoost.hpp
+++ b/corsika/framework/utility/COMBoost.hpp
@@ -35,16 +35,16 @@ namespace corsika {
//! transforms a 4-momentum from lab frame to the center-of-mass frame
template <typename FourVector>
- inline FourVector toCoM(FourVector const& p) const;
+ FourVector toCoM(FourVector const& p) const;
//! transforms a 4-momentum from the center-of-mass frame back to lab frame
template <typename FourVector>
- inline FourVector fromCoM(FourVector const& p) const;
+ FourVector fromCoM(FourVector const& p) const;
- inline CoordinateSystemPtr getRotatedCS() const;
+ CoordinateSystemPtr getRotatedCS() const;
protected:
- inline void setBoost(double coshEta, double sinhEta);
+ void setBoost(double coshEta, double sinhEta);
private:
Eigen::Matrix2d boost_;
diff --git a/corsika/framework/utility/SaveBoostHistogram.hpp b/corsika/framework/utility/SaveBoostHistogram.hpp
index 90a5621bd..14e037996 100644
--- a/corsika/framework/utility/SaveBoostHistogram.hpp
+++ b/corsika/framework/utility/SaveBoostHistogram.hpp
@@ -24,8 +24,8 @@ namespace corsika {
* runtime_error
*/
template <class Axes, class Storage>
- inline void save_hist(boost::histogram::histogram<Axes, Storage> const& h,
- std::string const& filename, bool overwrite = true);
+ void save_hist(boost::histogram::histogram<Axes, Storage> const& h,
+ std::string const& filename, bool overwrite = true);
} // namespace corsika
#include <corsika/detail/framework/utility/SaveBoostHistogram.inl>
diff --git a/corsika/framework/utility/Singleton.hpp b/corsika/framework/utility/Singleton.hpp
index 78a7df97b..d67fca048 100644
--- a/corsika/framework/utility/Singleton.hpp
+++ b/corsika/framework/utility/Singleton.hpp
@@ -8,8 +8,6 @@
#pragma once
-//#define OFFLINE_USE_GAMMA_SINGLETON
-
namespace corsika {
/**
* \class Singleton Singleton.h utl/Singleton.h
diff --git a/corsika/media/NameModel.hpp b/corsika/media/NameModel.hpp
index 8fe9698ed..f046809c3 100644
--- a/corsika/media/NameModel.hpp
+++ b/corsika/media/NameModel.hpp
@@ -9,7 +9,6 @@
#pragma once
#include <string>
-//#include <utility>
namespace corsika {
diff --git a/corsika/media/NuclearComposition.hpp b/corsika/media/NuclearComposition.hpp
index f8f08704d..5341554cd 100644
--- a/corsika/media/NuclearComposition.hpp
+++ b/corsika/media/NuclearComposition.hpp
@@ -33,8 +33,8 @@ namespace corsika {
* @param pFractions List of fractions how much each particle contributes. The sum
* needs to add up to 1
**/
- inline NuclearComposition(std::vector<Code> const& pComponents,
- std::vector<float> const& pFractions);
+ NuclearComposition(std::vector<Code> const& pComponents,
+ std::vector<float> const& pFractions);
/** Sum all all relative composition weighted by func(element)
* This function sums all relative compositions given during this classes
@@ -46,29 +46,29 @@ namespace corsika {
* @retval returns the weighted sum with the type defined by the return type of func
**/
template <typename TFunction>
- inline auto getWeightedSum(TFunction const& func) const;
+ auto getWeightedSum(TFunction const& func) const;
/** Number of elements in the composition array
* @retval returns the number of elements in the composition array
**/
- inline size_t getSize() const;
+ size_t getSize() const;
/// Returns a const reference to the fraction
- inline std::vector<float> const& getFractions() const;
+ std::vector<float> const& getFractions() const;
/// Returns a const reference to the fraction
- inline std::vector<Code> const& getComponents() const;
- inline double const getAverageMassNumber() const;
+ std::vector<Code> const& getComponents() const;
+ double const getAverageMassNumber() const;
template <class TRNG>
- inline Code sampleTarget(std::vector<CrossSectionType> const& sigma,
- TRNG& randomStream) const;
+ Code sampleTarget(std::vector<CrossSectionType> const& sigma,
+ TRNG& randomStream) const;
// Note: when this class ever modifies its internal data, the hash
// must be updated, too!
- inline size_t getHash() const;
+ size_t getHash() const;
private:
- inline void updateHash();
+ void updateHash();
std::vector<float> const numberFractions_; //!< relative fractions of number density
std::vector<Code> const components_; //!< particle codes of consitutents
diff --git a/corsika/media/Universe.hpp b/corsika/media/Universe.hpp
index cdd5c2bd2..e481052d9 100644
--- a/corsika/media/Universe.hpp
+++ b/corsika/media/Universe.hpp
@@ -14,8 +14,8 @@
namespace corsika {
struct Universe : public corsika::Sphere {
- inline Universe(corsika::CoordinateSystemPtr const& pCS);
- inline bool contains(corsika::Point const&) const override;
+ Universe(corsika::CoordinateSystemPtr const& pCS);
+ bool contains(corsika::Point const&) const override;
};
} // namespace corsika
diff --git a/corsika/media/VolumeTreeNode.hpp b/corsika/media/VolumeTreeNode.hpp
index fba07bc58..dd4b11c34 100644
--- a/corsika/media/VolumeTreeNode.hpp
+++ b/corsika/media/VolumeTreeNode.hpp
@@ -29,15 +29,14 @@ namespace corsika {
: geoVolume_(std::move(pVolume)) {}
//! convenience function equivalent to Volume::isInside
- inline bool contains(Point const& p) const;
+ bool contains(Point const& p) const;
- inline VolumeTreeNode<IModelProperties> const* excludes(Point const& p) const;
+ VolumeTreeNode<IModelProperties> const* excludes(Point const& p) const;
/** returns a pointer to the sub-VolumeTreeNode which is "responsible" for the given
* \class Point \p p, or nullptr iff \p p is not contained in this volume.
*/
- inline VolumeTreeNode<IModelProperties> const* getContainingNode(
- Point const& p) const;
+ VolumeTreeNode<IModelProperties> const* getContainingNode(Point const& p) const;
/**
* Traverses the VolumeTree pre- or post-order and calls the functor \p func for each
@@ -45,33 +44,33 @@ namespace corsika {
* func is ignored.
*/
template <typename TCallable, bool preorder = true>
- inline void walk(TCallable func);
+ void walk(TCallable func);
- inline void addChild(VTNUPtr pChild);
+ void addChild(VTNUPtr pChild);
- inline void excludeOverlapWith(VTNUPtr const& pNode);
+ void excludeOverlapWith(VTNUPtr const& pNode);
- inline VTN_type const* getParent() const { return parentNode_; };
+ VTN_type const* getParent() const { return parentNode_; };
- inline auto const& getChildNodes() const { return childNodes_; }
+ auto const& getChildNodes() const { return childNodes_; }
- inline auto const& getExcludedNodes() const { return excludedNodes_; }
+ auto const& getExcludedNodes() const { return excludedNodes_; }
- inline auto const& getVolume() const { return *geoVolume_; }
+ auto const& getVolume() const { return *geoVolume_; }
- inline auto const& getModelProperties() const { return *modelProperties_; }
+ auto const& getModelProperties() const { return *modelProperties_; }
- inline bool hasModelProperties() const { return modelProperties_.get() != nullptr; }
+ bool hasModelProperties() const { return modelProperties_.get() != nullptr; }
template <typename ModelProperties, typename... Args>
- inline auto setModelProperties(Args&&... args) {
+ auto setModelProperties(Args&&... args) {
// static_assert(std::is_base_of_v<IModelProperties, ModelProperties>,
// "unusable type provided");
modelProperties_ = std::make_shared<ModelProperties>(std::forward<Args>(args)...);
return modelProperties_;
}
- inline void setModelProperties(IMPSharedPtr ptr) { modelProperties_ = ptr; }
+ void setModelProperties(IMPSharedPtr ptr) { modelProperties_ = ptr; }
// template <class MediumType, typename... Args>
// static auto createMedium(Args&&... args);
diff --git a/corsika/modules/qgsjetII/Interaction.hpp b/corsika/modules/qgsjetII/Interaction.hpp
index 004788f13..a45282f58 100644
--- a/corsika/modules/qgsjetII/Interaction.hpp
+++ b/corsika/modules/qgsjetII/Interaction.hpp
@@ -12,9 +12,6 @@
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/random/RNGManager.hpp>
#include <corsika/framework/process/InteractionProcess.hpp>
-
-#include <corsika/modules/qgsjetII/Random.hpp>
-
#include <corsika/modules/qgsjetII/ParticleConversion.hpp>
#include <qgsjet-II-04.hpp>
diff --git a/corsika/stack/DummyStack.hpp b/corsika/stack/DummyStack.hpp
index bbbfff91a..9bbd51403 100644
--- a/corsika/stack/DummyStack.hpp
+++ b/corsika/stack/DummyStack.hpp
@@ -61,21 +61,21 @@ namespace corsika::dummy_stack {
void init() { entries_ = 0; }
- inline void clear() { entries_ = 0; }
+ void clear() { entries_ = 0; }
- inline int getSize() const { return entries_; }
- inline int getCapacity() const { return entries_; }
+ int getSize() const { return entries_; }
+ int getCapacity() const { return entries_; }
/**
* Function to copy particle at location i2 in stack to i1
*/
- inline void copy(const int /*i1*/, const int /*i2*/) {}
+ void copy(const int /*i1*/, const int /*i2*/) {}
- inline void incrementSize() { entries_++; }
- inline void decrementSize() { entries_--; }
+ void incrementSize() { entries_++; }
+ void decrementSize() { entries_--; }
- inline int getEntries() const { return entries_; }
- inline void setEntries(int entries = 0) { entries_ = entries; }
+ int getEntries() const { return entries_; }
+ void setEntries(int entries = 0) { entries_ = entries; }
private:
int entries_ = 0;
diff --git a/corsika/stack/GeometryNodeStackExtension.hpp b/corsika/stack/GeometryNodeStackExtension.hpp
index b3a15854f..e7298bea4 100644
--- a/corsika/stack/GeometryNodeStackExtension.hpp
+++ b/corsika/stack/GeometryNodeStackExtension.hpp
@@ -38,28 +38,26 @@ namespace corsika::node {
typedef typename TEnvType::BaseNodeType node_type;
// default version for particle-creation from input data
- inline void setParticleData(const std::tuple<node_type const*> v) {
+ void setParticleData(const std::tuple<node_type const*> v) {
setNode(std::get<0>(v));
}
- inline void setParticleData(GeometryDataInterface& parent,
- const std::tuple<node_type const*>) {
+ void setParticleData(GeometryDataInterface& parent,
+ const std::tuple<node_type const*>) {
setNode(parent.getNode()); // copy Node from parent particle!
}
- inline void setParticleData() { setNode(nullptr); }
- inline void setParticleData(GeometryDataInterface& parent) {
+ void setParticleData() { setNode(nullptr); }
+ void setParticleData(GeometryDataInterface& parent) {
setNode(parent.getNode()); // copy Node from parent particle!
}
- inline std::string asString() const {
- return fmt::format("node={}", fmt::ptr(getNode()));
- }
+ std::string asString() const { return fmt::format("node={}", fmt::ptr(getNode())); }
- inline void setNode(node_type const* v) {
+ void setNode(node_type const* v) {
super_type::getStackData().setNode(super_type::getIndex(), v);
}
- inline node_type const* getNode() const {
+ node_type const* getNode() const {
return super_type::getStackData().getNode(super_type::getIndex());
}
};
@@ -89,27 +87,27 @@ namespace corsika::node {
GeometryData<TEnvType>& operator=(GeometryData<TEnvType>&&) = default;
// these functions are needed for the Stack interface
- inline void clear() { node_vector_.clear(); }
+ void clear() { node_vector_.clear(); }
- inline unsigned int getSize() const { return node_vector_.size(); }
+ unsigned int getSize() const { return node_vector_.size(); }
- inline unsigned int getCapacity() const { return node_vector_.size(); }
+ unsigned int getCapacity() const { return node_vector_.size(); }
- inline void copy(const int i1, const int i2) { node_vector_[i2] = node_vector_[i1]; }
+ void copy(const int i1, const int i2) { node_vector_[i2] = node_vector_[i1]; }
- inline void swap(const int i1, const int i2) {
+ void swap(const int i1, const int i2) {
std::swap(node_vector_[i1], node_vector_[i2]);
}
// custom data access function
- inline void setNode(const int i, node_type const* v) { node_vector_[i] = v; }
+ void setNode(const int i, node_type const* v) { node_vector_[i] = v; }
- inline node_type const* getNode(const int i) const { return node_vector_[i]; }
+ node_type const* getNode(const int i) const { return node_vector_[i]; }
// these functions are also needed by the Stack interface
- inline void incrementSize() { node_vector_.push_back(nullptr); }
+ void incrementSize() { node_vector_.push_back(nullptr); }
- inline void decrementSize() {
+ void decrementSize() {
if (node_vector_.size() > 0) { node_vector_.pop_back(); }
}
diff --git a/corsika/stack/NuclearStackExtension.hpp b/corsika/stack/NuclearStackExtension.hpp
index 5d8d573ed..34bd1377d 100644
--- a/corsika/stack/NuclearStackExtension.hpp
+++ b/corsika/stack/NuclearStackExtension.hpp
@@ -54,24 +54,24 @@ namespace corsika::nuclear_stack {
unsigned short, unsigned short>
altenative_particle_data_type;
- inline void setParticleData(particle_data_type const& v);
+ void setParticleData(particle_data_type const& v);
- inline void setParticleData(altenative_particle_data_type const& v);
+ void setParticleData(altenative_particle_data_type const& v);
- inline void setParticleData(super_type& p, particle_data_type const& v);
+ void setParticleData(super_type& p, particle_data_type const& v);
- inline void setParticleData(super_type& p, altenative_particle_data_type const& v);
+ void setParticleData(super_type& p, altenative_particle_data_type const& v);
- inline std::string asString() const;
+ std::string asString() const;
/**
* @name individual setters
* @{
*/
- inline void setNuclearA(const unsigned short vA) {
+ void setNuclearA(const unsigned short vA) {
super_type::getStackData().setNuclearA(super_type::getIndex(), vA);
}
- inline void setNuclearZ(const unsigned short vZ) {
+ void setNuclearZ(const unsigned short vZ) {
super_type::getStackData().setNuclearZ(super_type::getIndex(), vZ);
}
/// @}
@@ -80,10 +80,10 @@ namespace corsika::nuclear_stack {
* @name individual getters
* @{
*/
- inline int getNuclearA() const {
+ int getNuclearA() const {
return super_type::getStackData().getNuclearA(super_type::getIndex());
}
- inline int getNuclearZ() const {
+ int getNuclearZ() const {
return super_type::getStackData().getNuclearZ(super_type::getIndex());
}
/// @}
@@ -91,22 +91,22 @@ namespace corsika::nuclear_stack {
/**
* Overwrite normal getParticleMass function with nuclear version
*/
- inline HEPMassType getMass() const;
+ HEPMassType getMass() const;
/**
* Overwirte normal getChargeNumber function with nuclear version
**/
- inline int16_t getChargeNumber() const;
+ int16_t getChargeNumber() const;
- inline int getNucleusRef() const {
+ int getNucleusRef() const {
return super_type::getStackData().getNucleusRef(super_type::getIndex());
} // LCOV_EXCL_LINE
protected:
- inline void setNucleusRef(const int vR) {
+ void setNucleusRef(const int vR) {
super_type::getStackData().setNucleusRef(super_type::getIndex(), vR);
}
- inline bool isNucleus() const {
+ bool isNucleus() const {
return super_type::getStackData().isNucleus(super_type::getIndex());
}
};
@@ -149,49 +149,45 @@ namespace corsika::nuclear_stack {
void dump() { super_type::dump(); }
- inline void clear();
+ void clear();
unsigned int getSize() const { return nucleusRef_.size(); }
unsigned int getCapacity() const { return nucleusRef_.capacity(); }
- inline void setNuclearA(const unsigned int i, const unsigned short vA) {
+ void setNuclearA(const unsigned int i, const unsigned short vA) {
nuclearA_[getNucleusRef(i)] = vA;
}
- inline void setNuclearZ(const unsigned int i, const unsigned short vZ) {
+ void setNuclearZ(const unsigned int i, const unsigned short vZ) {
nuclearZ_[getNucleusRef(i)] = vZ;
}
- inline void setNucleusRef(const unsigned int i, const int v) { nucleusRef_[i] = v; }
+ void setNucleusRef(const unsigned int i, const int v) { nucleusRef_[i] = v; }
- inline int getNuclearA(const unsigned int i) const {
- return nuclearA_[getNucleusRef(i)];
- }
+ int getNuclearA(const unsigned int i) const { return nuclearA_[getNucleusRef(i)]; }
- inline int getNuclearZ(const unsigned int i) const {
- return nuclearZ_[getNucleusRef(i)];
- }
+ int getNuclearZ(const unsigned int i) const { return nuclearZ_[getNucleusRef(i)]; }
// this function will create new storage for Nuclear Properties, and return the
// reference to it
- inline int getNucleusNextRef();
+ int getNucleusNextRef();
- inline int getNucleusRef(const unsigned int i) const;
+ int getNucleusRef(const unsigned int i) const;
- inline bool isNucleus(const unsigned int i) const { return nucleusRef_[i] >= 0; }
+ bool isNucleus(const unsigned int i) const { return nucleusRef_[i] >= 0; }
/**
* Function to copy particle at location i1 in stack to i2
*/
- inline void copy(const unsigned int i1, const unsigned int i2);
+ 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);
+ void swap(const unsigned int i1, const unsigned int i2);
- inline void incrementSize();
+ void incrementSize();
- inline void decrementSize();
+ void decrementSize();
private:
/// the actual memory to store particle data
diff --git a/corsika/stack/VectorStack.hpp b/corsika/stack/VectorStack.hpp
index 7877469ee..adaae996b 100644
--- a/corsika/stack/VectorStack.hpp
+++ b/corsika/stack/VectorStack.hpp
@@ -119,7 +119,7 @@ namespace corsika {
void dump() const {}
- inline void clear();
+ void clear();
unsigned int getSize() const { return dataPID_.size(); }
unsigned int getCapacity() const { return dataPID_.size(); }
@@ -149,15 +149,15 @@ namespace corsika {
/**
* Function to copy particle at location i2 in stack to i1
*/
- inline void copy(size_t i1, size_t i2);
+ void copy(size_t i1, size_t i2);
/**
* Function to copy particle at location i2 in stack to i1
*/
- inline void swap(size_t i1, size_t i2);
+ void swap(size_t i1, size_t i2);
- inline void incrementSize();
- inline void decrementSize();
+ void incrementSize();
+ void decrementSize();
private:
/// the actual memory to store particle data
diff --git a/examples/vertical_EAS.cpp b/examples/vertical_EAS.cpp
index 04ddbb222..c04ae2c4c 100644
--- a/examples/vertical_EAS.cpp
+++ b/examples/vertical_EAS.cpp
@@ -47,6 +47,7 @@
#include <corsika/modules/Sibyll.hpp>
#include <corsika/modules/UrQMD.hpp>
#include <corsika/modules/PROPOSAL.hpp>
+#include <corsika/modules/QGSJetII.hpp>
#include <corsika/setup/SetupStack.hpp>
#include <corsika/setup/SetupTrajectory.hpp>
@@ -66,6 +67,7 @@
*/
#include <corsika/modules/sibyll/Random.hpp>
#include <corsika/modules/urqmd/Random.hpp>
+#include <corsika/modules/qgsjetII/Random.hpp>
using namespace corsika;
using namespace std;
@@ -190,6 +192,8 @@ int main(int argc, char** argv) {
// setup processes, decays and interactions
+ corsika::qgsjetII::Interaction qgsjet;
+
corsika::sibyll::Interaction sibyll;
InteractionCounter sibyllCounted(sibyll);
diff --git a/tests/framework/testProcessSequence.cpp b/tests/framework/testProcessSequence.cpp
index 3d60d2de1..efdaa2fc4 100644
--- a/tests/framework/testProcessSequence.cpp
+++ b/tests/framework/testProcessSequence.cpp
@@ -49,7 +49,7 @@ public:
void setStep(LengthType const v) { step_ = v; }
template <typename D, typename T>
- inline ProcessReturn doContinuous(D& d, T&, bool const flag) const {
+ ProcessReturn doContinuous(D& d, T&, bool const flag) const {
flag_ = flag;
CORSIKA_LOG_TRACE("ContinuousProcess1::DoContinuous");
checkCont |= 1;
@@ -58,7 +58,7 @@ public:
}
template <typename TParticle, typename TTrack>
- inline LengthType getMaxStepLength(TParticle&, TTrack&) {
+ LengthType getMaxStepLength(TParticle&, TTrack&) {
return step_;
}
@@ -86,7 +86,7 @@ public:
void setStep(LengthType const v) { step_ = v; }
template <typename D, typename T>
- inline ProcessReturn doContinuous(D& d, T&, bool const flag) const {
+ ProcessReturn doContinuous(D& d, T&, bool const flag) const {
flag_ = flag;
CORSIKA_LOG_DEBUG("ContinuousProcess2::DoContinuous");
checkCont |= 2;
@@ -95,7 +95,7 @@ public:
}
template <typename TParticle, typename TTrack>
- inline LengthType getMaxStepLength(TParticle&, TTrack&) {
+ LengthType getMaxStepLength(TParticle&, TTrack&) {
return step_;
}
@@ -123,7 +123,7 @@ public:
void setStep(LengthType const v) { step_ = v; }
template <typename D, typename T>
- inline ProcessReturn doContinuous(D& d, T&, bool const flag) const {
+ ProcessReturn doContinuous(D& d, T&, bool const flag) const {
flag_ = flag;
CORSIKA_LOG_DEBUG("ContinuousProcess3::DoContinuous");
checkCont |= 4;
@@ -132,7 +132,7 @@ public:
}
template <typename TParticle, typename TTrack>
- inline LengthType getMaxStepLength(TParticle&, TTrack&) {
+ LengthType getMaxStepLength(TParticle&, TTrack&) {
return step_;
}
@@ -158,7 +158,7 @@ public:
}
template <typename TView>
- inline void doInteraction(TView& v) const {
+ void doInteraction(TView& v) const {
checkInteract |= 1;
for (int i = 0; i < nData; ++i) v.parent().data_[i] += 1 + i;
}
@@ -184,7 +184,7 @@ public:
}
template <typename TView>
- inline void doInteraction(TView& v) const {
+ void doInteraction(TView& v) const {
checkInteract |= 2;
for (int i = 0; i < nData; ++i) v.parent().data_[i] /= 1.1;
CORSIKA_LOG_DEBUG("Process2::doInteraction");
@@ -211,7 +211,7 @@ public:
}
template <typename TView>
- inline void doInteraction(TView& v) const {
+ void doInteraction(TView& v) const {
checkInteract |= 4;
for (int i = 0; i < nData; ++i) v.parent().data_[i] *= 1.01;
CORSIKA_LOG_DEBUG("Process3::doInteraction");
@@ -238,7 +238,7 @@ public:
}
template <typename D, typename T>
- inline ProcessReturn doContinuous(D& d, T&, bool const) const {
+ ProcessReturn doContinuous(D& d, T&, bool const) const {
CORSIKA_LOG_DEBUG("Base::doContinuous");
checkCont |= 8;
for (int i = 0; i < nData; ++i) { d.data_[i] /= 1.2; }
diff --git a/tests/modules/testQGSJetII.cpp b/tests/modules/testQGSJetII.cpp
index 86bb8fce9..8b039f87c 100644
--- a/tests/modules/testQGSJetII.cpp
+++ b/tests/modules/testQGSJetII.cpp
@@ -20,6 +20,16 @@
#include <cstdlib>
#include <experimental/filesystem>
+/*
+ NOTE, WARNING, ATTENTION
+
+ The sibyll/Random.hpp implements the hook of sibyll to the C8 random
+ number generator. It has to occur excatly ONCE per linked
+ executable. If you include the header below in multiple "tests" and
+ link them togehter, it will fail.
+ */
+#include <corsika/modules/qgsjetII/Random.hpp>
+
using namespace corsika;
template <typename TStackView>
--
GitLab