diff --git a/corsika/detail/framework/process/ProcessSequence.inl b/corsika/detail/framework/process/ProcessSequence.inl
index 47b1805a60ddb7e0066bca98c3c575e41095a921..6c9bd789289a6fa24204bfe10df34e5413b5b6fa 100644
--- a/corsika/detail/framework/process/ProcessSequence.inl
+++ b/corsika/detail/framework/process/ProcessSequence.inl
@@ -26,6 +26,23 @@
namespace corsika {
+ template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
+ int IndexProcess2>
+ inline ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
+ IndexProcess2>::ProcessSequence(TProcess1 in_A, TProcess2 in_B)
+ : A_(in_A)
+ , B_(in_B) {
+
+ // make sure only BaseProcess types TProcess1/2 are passed
+
+ static_assert(is_process_v<TProcess1>,
+ "can only use process derived from BaseProcess in "
+ "ProcessSequence, for Process 1");
+ static_assert(is_process_v<TProcess2>,
+ "can only use process derived from BaseProcess in "
+ "ProcessSequence, for Process 2");
+ }
+
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TParticle>
@@ -34,14 +51,13 @@ namespace corsika {
IndexProcess2>::doBoundaryCrossing(TParticle& particle,
typename TParticle::node_type const& from,
typename TParticle::node_type const& to) {
- ProcessReturn ret = ProcessReturn::Ok;
- if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process1_type>,
- process1_type> ||
- t1ProcSeq) {
+ ProcessReturn ret = ProcessReturn::Ok;
- if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process1_type>,
- process1_type>) {
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (is_boundary_process_v<process1_type> ||
+ process1_type::is_process_sequence) {
// interface checking on TProcess1
static_assert(
@@ -50,17 +66,16 @@ namespace corsika {
"doBoundaryCrossing(TParticle&, VolumeNode const&, VolumeNode const&)\" "
"required for "
"BoundaryCrossingProcess<TDerived>. ");
- }
- ret |= A_.doBoundaryCrossing(particle, from, to);
+ ret |= A_.doBoundaryCrossing(particle, from, to);
+ }
}
- if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process2_type>,
- process2_type> ||
- t2ProcSeq) {
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (is_boundary_process_v<process2_type> ||
+ process2_type::is_process_sequence) {
- if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process2_type>,
- process2_type>) {
// interface checking on TProcess2
static_assert(
has_method_doBoundaryCrossing_v<TProcess2, ProcessReturn, TParticle>,
@@ -68,9 +83,9 @@ namespace corsika {
"doBoundaryCrossing(TParticle&, VolumeNode const&, VolumeNode const&)\" "
"required for "
"BoundaryCrossingProcess<TDerived>. ");
- }
- ret |= B_.doBoundaryCrossing(particle, from, to);
+ ret |= B_.doBoundaryCrossing(particle, from, to);
+ }
}
return ret;
@@ -84,43 +99,50 @@ namespace corsika {
doContinuous(TParticle& particle, TTrack& vT,
[[maybe_unused]] ContinuousProcessIndex const limitId) {
ProcessReturn ret = ProcessReturn::Ok;
- if constexpr (t1ProcSeq) {
-
- ret |= A_.doContinuous(particle, vT, limitId);
- } else if constexpr (is_continuous_process_v<process1_type>) {
-
- // interface checking on TProcess1
- static_assert(
- has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle&, TTrack&> ||
- has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle&,
- TTrack const&> ||
- has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"ProcessReturn "
- "doContinuous(TParticle [const]&,TTrack [const]&,bool)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- ret |=
- A_.doContinuous(particle, vT, limitId == ContinuousProcessIndex(IndexProcess1));
+
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (process1_type::is_process_sequence) {
+
+ ret |= A_.doContinuous(particle, vT, limitId);
+ } else if constexpr (is_continuous_process_v<process1_type>) {
+
+ // interface checking on TProcess1
+ static_assert(
+ has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle&, TTrack&> ||
+ has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle&,
+ TTrack const&> ||
+ has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle const&,
+ TTrack const&>,
+ "TDerived has no method with correct signature \"ProcessReturn "
+ "doContinuous(TParticle [const]&,TTrack [const]&,bool)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ ret |= A_.doContinuous(particle, vT,
+ limitId == ContinuousProcessIndex(IndexProcess1));
+ }
}
- if constexpr (t2ProcSeq) {
- ret |= B_.doContinuous(particle, vT, limitId);
- } else if constexpr (is_continuous_process_v<process2_type>) {
-
- // interface checking on TProcess2
- static_assert(
- has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle&, TTrack&> ||
- has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle&,
- TTrack const&> ||
- has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"ProcessReturn "
- "doContinuous(TParticle [const]&,TTrack [const]&,bool)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- ret |=
- B_.doContinuous(particle, vT, limitId == ContinuousProcessIndex(IndexProcess2));
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (process2_type::is_process_sequence) {
+ ret |= B_.doContinuous(particle, vT, limitId);
+ } else if constexpr (is_continuous_process_v<process2_type>) {
+
+ // interface checking on TProcess2
+ static_assert(
+ has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle&, TTrack&> ||
+ has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle&,
+ TTrack const&> ||
+ has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle const&,
+ TTrack const&>,
+ "TDerived has no method with correct signature \"ProcessReturn "
+ "doContinuous(TParticle [const]&,TTrack [const]&,bool)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ ret |= B_.doContinuous(particle, vT,
+ limitId == ContinuousProcessIndex(IndexProcess2));
+ }
}
return ret;
@@ -129,31 +151,42 @@ namespace corsika {
template <typename TProcess1, typename TProcess2, int IndexStart, int IndexProcess1,
int IndexProcess2>
template <typename TSecondaries>
- inline void ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
- IndexProcess2>::doSecondaries(TSecondaries& vS) {
- if constexpr (std::is_base_of_v<SecondariesProcess<process1_type>, process1_type> ||
- t1ProcSeq) {
-
- // interface checking on TProcess1
- static_assert(has_method_doSecondaries_v<TProcess1, void, TSecondaries&> ||
- has_method_doSecondaries_v<TProcess1, void, TSecondaries const&>,
- "TDerived has no method with correct signature \"void "
- "doSecondaries(TStackView [const]&)\" required for "
- "SecondariesProcessProcess<TDerived>. ");
-
- A_.doSecondaries(vS);
+ inline void
+ ProcessSequence<TProcess1, TProcess2, IndexStart, IndexProcess1,
+ IndexProcess2>::doSecondaries([[maybe_unused]] TSecondaries& vS) {
+
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (is_secondaries_process_v<process1_type> ||
+ process1_type::is_process_sequence) {
+
+ // interface checking on TProcess1
+ static_assert(
+ has_method_doSecondaries_v<TProcess1, void, TSecondaries&> ||
+ has_method_doSecondaries_v<TProcess1, void, TSecondaries const&>,
+ "TDerived has no method with correct signature \"void "
+ "doSecondaries(TStackView [const]&)\" required for "
+ "SecondariesProcessProcess<TDerived>. ");
+
+ A_.doSecondaries(vS);
+ }
}
- if constexpr (std::is_base_of_v<SecondariesProcess<process2_type>, process2_type> ||
- t2ProcSeq) {
- // interface checking on TProcess2
- static_assert(has_method_doSecondaries_v<TProcess2, void, TSecondaries&> ||
- has_method_doSecondaries_v<TProcess2, void, TSecondaries const&>,
- "TDerived has no method with correct signature \"void "
- "doSecondaries(TStackView [const]&)\" required for "
- "SecondariesProcessProcess<TDerived>. ");
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (is_secondaries_process_v<process2_type> ||
+ process2_type::is_process_sequence) {
- B_.doSecondaries(vS);
+ // interface checking on TProcess2
+ static_assert(
+ has_method_doSecondaries_v<TProcess2, void, TSecondaries&> ||
+ has_method_doSecondaries_v<TProcess2, void, TSecondaries const&>,
+ "TDerived has no method with correct signature \"void "
+ "doSecondaries(TStackView [const]&)\" required for "
+ "SecondariesProcessProcess<TDerived>. ");
+
+ B_.doSecondaries(vS);
+ }
}
}
@@ -162,13 +195,21 @@ namespace corsika {
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)) {
- ret |= A_.checkStep();
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (is_stack_process_v<process1_type> ||
+ (process1_type::is_process_sequence &&
+ !process1_type::is_switch_process_sequence)) {
+ ret |= A_.checkStep();
+ }
}
- if constexpr (std::is_base_of_v<StackProcess<process2_type>, process2_type> ||
- (t2ProcSeq && !t2SwitchProcSeq)) {
- ret |= B_.checkStep();
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (is_stack_process_v<process2_type> ||
+ (process2_type::is_process_sequence &&
+ !process2_type::is_switch_process_sequence)) {
+ ret |= B_.checkStep();
+ }
}
return ret;
}
@@ -178,29 +219,37 @@ namespace corsika {
template <typename TStack>
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 constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (std::is_base_of_v<StackProcess<process1_type>, process1_type> ||
+ (process1_type::is_process_sequence &&
+ !process1_type::is_switch_process_sequence)) {
- // interface checking on TProcess1
- static_assert(has_method_doStack_v<TProcess1, void, TStack&> ||
- has_method_doStack_v<TProcess1, void, TStack const&>,
- "TDerived has no method with correct signature \"void "
- "doStack(TStack [const]&)\" required for "
- "StackProcess<TDerived>. ");
+ // interface checking on TProcess1
+ static_assert(has_method_doStack_v<TProcess1, void, TStack&> ||
+ has_method_doStack_v<TProcess1, void, TStack const&>,
+ "TDerived has no method with correct signature \"void "
+ "doStack(TStack [const]&)\" required for "
+ "StackProcess<TDerived>. ");
- if (A_.checkStep()) { A_.doStack(stack); }
+ if (A_.checkStep()) { A_.doStack(stack); }
+ }
}
- if constexpr (std::is_base_of_v<StackProcess<process2_type>, process2_type> ||
- (t2ProcSeq && !t2SwitchProcSeq)) {
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (std::is_base_of_v<StackProcess<process2_type>, process2_type> ||
+ (process2_type::is_process_sequence &&
+ !process2_type::is_switch_process_sequence)) {
- // interface checking on TProcess1
- static_assert(has_method_doStack_v<TProcess2, void, TStack&> ||
- has_method_doStack_v<TProcess2, void, TStack const&>,
- "TDerived has no method with correct signature \"void "
- "doStack(TStack [const]&)\" required for "
- "StackProcess<TDerived>. ");
+ // interface checking on TProcess1
+ static_assert(has_method_doStack_v<TProcess2, void, TStack&> ||
+ has_method_doStack_v<TProcess2, void, TStack const&>,
+ "TDerived has no method with correct signature \"void "
+ "doStack(TStack [const]&)\" required for "
+ "StackProcess<TDerived>. ");
- if (B_.checkStep()) { B_.doStack(stack); }
+ if (B_.checkStep()) { B_.doStack(stack); }
+ }
}
}
@@ -214,37 +263,44 @@ namespace corsika {
ContinuousProcessStepLength max_length(std::numeric_limits<double>::infinity() *
meter);
- if constexpr (t1ProcSeq) {
- ContinuousProcessStepLength const step = A_.getMaxStepLength(particle, vTrack);
- max_length = std::min(max_length, step);
- } else if constexpr (is_continuous_process_v<process1_type>) {
-
- // interface checking on TProcess1
- static_assert(has_method_getMaxStepLength_v<TProcess1, LengthType, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"LengthType "
- "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- ContinuousProcessStepLength const step(A_.getMaxStepLength(particle, vTrack),
- ContinuousProcessIndex(IndexProcess1));
- max_length = std::min(max_length, step);
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (process1_type::is_process_sequence) {
+ ContinuousProcessStepLength const step = A_.getMaxStepLength(particle, vTrack);
+ max_length = std::min(max_length, step);
+ } else if constexpr (is_continuous_process_v<process1_type>) {
+
+ // interface checking on TProcess1
+ static_assert(has_method_getMaxStepLength_v<TProcess1, LengthType,
+ TParticle const&, TTrack const&>,
+ "TDerived has no method with correct signature \"LengthType "
+ "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ ContinuousProcessStepLength const step(A_.getMaxStepLength(particle, vTrack),
+ ContinuousProcessIndex(IndexProcess1));
+ max_length = std::min(max_length, step);
+ }
}
- if constexpr (t2ProcSeq) {
- ContinuousProcessStepLength const step = B_.getMaxStepLength(particle, vTrack);
- max_length = std::min(max_length, step);
- } else if constexpr (is_continuous_process_v<process2_type>) {
-
- // interface checking on TProcess2
- static_assert(has_method_getMaxStepLength_v<TProcess2, LengthType, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"LengthType "
- "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- ContinuousProcessStepLength const step(B_.getMaxStepLength(particle, vTrack),
- ContinuousProcessIndex(IndexProcess2));
- max_length = std::min(max_length, step);
+
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (process2_type::is_process_sequence) {
+ ContinuousProcessStepLength const step = B_.getMaxStepLength(particle, vTrack);
+ max_length = std::min(max_length, step);
+ } else if constexpr (is_continuous_process_v<process2_type>) {
+
+ // interface checking on TProcess2
+ static_assert(has_method_getMaxStepLength_v<TProcess2, LengthType,
+ TParticle const&, TTrack const&>,
+ "TDerived has no method with correct signature \"LengthType "
+ "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ ContinuousProcessStepLength const step(B_.getMaxStepLength(particle, vTrack),
+ ContinuousProcessIndex(IndexProcess2));
+ max_length = std::min(max_length, step);
+ }
}
return max_length;
}
@@ -258,13 +314,19 @@ namespace corsika {
InverseGrammageType tot = 0 * meter * meter / gram; // default value
- if constexpr (std::is_base_of_v<InteractionProcess<process1_type>, process1_type> ||
- t1ProcSeq) {
- tot += A_.getInverseInteractionLength(particle);
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (std::is_base_of_v<InteractionProcess<process1_type>, process1_type> ||
+ process1_type::is_process_sequence) {
+ tot += A_.getInverseInteractionLength(particle);
+ }
}
- if constexpr (std::is_base_of_v<InteractionProcess<process2_type>, process2_type> ||
- t2ProcSeq) {
- tot += B_.getInverseInteractionLength(particle);
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (std::is_base_of_v<InteractionProcess<process2_type>, process2_type> ||
+ process2_type::is_process_sequence) {
+ tot += B_.getInverseInteractionLength(particle);
+ }
}
return tot;
}
@@ -280,51 +342,60 @@ namespace corsika {
// TODO: add check for lambda_inv_select > lambda_inv_tot
- if constexpr (t1ProcSeq) {
- // if A is a process sequence --> check inside
- ProcessReturn const ret =
- A_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
- // if A_ did succeed, stop routine. Not checking other static branch B_.
- if (ret != ProcessReturn::Ok) { return ret; }
- } else if constexpr (std::is_base_of_v<InteractionProcess<process1_type>,
- process1_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- lambda_inv_sum += A_.getInverseInteractionLength(view.parent());
- // check if we should execute THIS process and then EXIT
- if (lambda_inv_select <= lambda_inv_sum) {
-
- // interface checking on TProcess1
- static_assert(has_method_doInteract_v<TProcess1, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doInteraction(TSecondaryView&)\" required for "
- "InteractionProcess<TDerived>. ");
-
- A_.template doInteraction(view);
- return ProcessReturn::Interacted;
- }
- } // end branch A
-
- if constexpr (t2ProcSeq) {
- // if B_ is a process sequence --> check inside
- return B_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
- } else if constexpr (std::is_base_of_v<InteractionProcess<process2_type>,
- process2_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- lambda_inv_sum += B_.getInverseInteractionLength(view.parent());
- // soon as SecondaryView::parent() is migrated!
- // check if we should execute THIS process and then EXIT
- if (lambda_inv_select <= lambda_inv_sum) {
-
- // interface checking on TProcess1
- static_assert(has_method_doInteract_v<TProcess2, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doInteraction(TSecondaryView&)\" required for "
- "InteractionProcess<TDerived>. ");
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (process1_type::is_process_sequence) {
+ // if A is a process sequence --> check inside
+ ProcessReturn const ret =
+ A_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
+ // if A_ did succeed, stop routine. Not checking other static branch B_.
+ if (ret != ProcessReturn::Ok) { return ret; }
+ } else if constexpr (is_process_v<process1_type> &&
+ std::is_base_of_v<InteractionProcess<process1_type>,
+ process1_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ lambda_inv_sum += A_.getInverseInteractionLength(view.parent());
+ // check if we should execute THIS process and then EXIT
+ if (lambda_inv_select <= lambda_inv_sum) {
+
+ // interface checking on TProcess1
+ static_assert(has_method_doInteract_v<TProcess1, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doInteraction(TSecondaryView&)\" required for "
+ "InteractionProcess<TDerived>. ");
+
+ A_.template doInteraction(view);
+ return ProcessReturn::Interacted;
+ }
+ } // end branch A
+ }
- B_.doInteraction(view);
- return ProcessReturn::Interacted;
- }
- } // end branch B_
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+
+ if constexpr (process2_type::is_process_sequence) {
+ // if B_ is a process sequence --> check inside
+ return B_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
+ } else if constexpr (is_process_v<process2_type> &&
+ std::is_base_of_v<InteractionProcess<process2_type>,
+ process2_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ lambda_inv_sum += B_.getInverseInteractionLength(view.parent());
+ // soon as SecondaryView::parent() is migrated!
+ // check if we should execute THIS process and then EXIT
+ if (lambda_inv_select <= lambda_inv_sum) {
+
+ // interface checking on TProcess1
+ static_assert(has_method_doInteract_v<TProcess2, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doInteraction(TSecondaryView&)\" required for "
+ "InteractionProcess<TDerived>. ");
+
+ B_.doInteraction(view);
+ return ProcessReturn::Interacted;
+ }
+ } // end branch B_
+ }
return ProcessReturn::Ok;
}
@@ -337,13 +408,19 @@ namespace corsika {
InverseTimeType tot = 0 / second; // default value
- if constexpr (std::is_base_of_v<DecayProcess<process1_type>, process1_type> ||
- t1ProcSeq) {
- tot += A_.getInverseLifetime(particle);
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (is_decay_process_v<process1_type> ||
+ process1_type::is_process_sequence) {
+ tot += A_.getInverseLifetime(particle);
+ }
}
- if constexpr (std::is_base_of_v<DecayProcess<process2_type>, process2_type> ||
- t2ProcSeq) {
- tot += B_.getInverseLifetime(particle);
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (is_decay_process_v<process2_type> ||
+ process2_type::is_process_sequence) {
+ tot += B_.getInverseLifetime(particle);
+ }
}
return tot;
}
@@ -360,47 +437,54 @@ namespace corsika {
// TODO: add check for decay_inv_select>decay_inv_tot
- if constexpr (t1ProcSeq) {
- // if A_ is a process sequence --> check inside
- ProcessReturn const ret = A_.selectDecay(view, decay_inv_select, decay_inv_sum);
- // if A_ did succeed, stop routine here (not checking other static branch B_)
- if (ret != ProcessReturn::Ok) { return ret; }
- } else if constexpr (std::is_base_of_v<DecayProcess<process1_type>, process1_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- decay_inv_sum += A_.getInverseLifetime(view.parent());
- // check if we should execute THIS process and then EXIT
- if (decay_inv_select <= decay_inv_sum) { // more pedagogical: rndm_select <
- // decay_inv_sum / decay_inv_tot
- // interface checking on TProcess1
- static_assert(has_method_doDecay_v<TProcess1, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doDecay(TSecondaryView&)\" required for "
- "DecayProcess<TDerived>. ");
-
- A_.doDecay(view);
- return ProcessReturn::Decayed;
- }
- } // end branch A_
-
- if constexpr (t2ProcSeq) {
- // if B_ is a process sequence --> check inside
- return B_.selectDecay(view, decay_inv_select, decay_inv_sum);
- } else if constexpr (std::is_base_of_v<DecayProcess<process2_type>, process2_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- decay_inv_sum += B_.getInverseLifetime(view.parent());
- // check if we should execute THIS process and then EXIT
- if (decay_inv_select <= decay_inv_sum) {
+ if constexpr (is_process_v<process1_type>) { // to protect from further compiler
+ // errors if process1_type is invalid
+ if constexpr (process1_type::is_process_sequence) {
+ // if A_ is a process sequence --> check inside
+ ProcessReturn const ret = A_.selectDecay(view, decay_inv_select, decay_inv_sum);
+ // if A_ did succeed, stop routine here (not checking other static branch B_)
+ if (ret != ProcessReturn::Ok) { return ret; }
+ } else if constexpr (is_decay_process_v<process1_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ decay_inv_sum += A_.getInverseLifetime(view.parent());
+ // check if we should execute THIS process and then EXIT
+ if (decay_inv_select <= decay_inv_sum) { // more pedagogical: rndm_select <
+ // decay_inv_sum / decay_inv_tot
+ // interface checking on TProcess1
+ static_assert(has_method_doDecay_v<TProcess1, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doDecay(TSecondaryView&)\" required for "
+ "DecayProcess<TDerived>. ");
+
+ A_.doDecay(view);
+ return ProcessReturn::Decayed;
+ }
+ } // end branch A_
+ }
- // interface checking on TProcess1
- static_assert(has_method_doDecay_v<TProcess2, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doDecay(TSecondaryView&)\" required for "
- "DecayProcess<TDerived>. ");
+ if constexpr (is_process_v<process2_type>) { // to protect from further compiler
+ // errors if process2_type is invalid
+ if constexpr (process2_type::is_process_sequence) {
+ // if B_ is a process sequence --> check inside
+ return B_.selectDecay(view, decay_inv_select, decay_inv_sum);
+ } else if constexpr (is_decay_process_v<process2_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ decay_inv_sum += B_.getInverseLifetime(view.parent());
+ // check if we should execute THIS process and then EXIT
+ if (decay_inv_select <= decay_inv_sum) {
+
+ // interface checking on TProcess1
+ static_assert(has_method_doDecay_v<TProcess2, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doDecay(TSecondaryView&)\" required for "
+ "DecayProcess<TDerived>. ");
+
+ B_.doDecay(view);
+ return ProcessReturn::Decayed;
+ }
+ } // end branch B_
+ }
- B_.doDecay(view);
- return ProcessReturn::Decayed;
- }
- } // end branch B_
return ProcessReturn::Ok;
}
@@ -409,15 +493,12 @@ namespace corsika {
**/
namespace detail {
// need helper alias to achieve this:
- template <typename TProcess1, typename TProcess2,
- typename = typename std::enable_if_t<
- contains_stack_process_v<TProcess1> ||
- std::is_base_of_v<StackProcess<typename std::decay_t<TProcess1>>,
- typename std::decay_t<TProcess1>> ||
- contains_stack_process_v<TProcess2> ||
- std::is_base_of_v<StackProcess<typename std::decay_t<TProcess2>>,
- typename std::decay_t<TProcess2>>,
- int>>
+ template <
+ typename TProcess1, typename TProcess2,
+ typename = typename std::enable_if_t<
+ contains_stack_process_v<TProcess1> || is_stack_process_v<TProcess1> ||
+ contains_stack_process_v<TProcess2> || is_stack_process_v<TProcess2>,
+ int>>
using enable_if_stack = ProcessSequence<TProcess1, TProcess2>;
} // namespace detail
diff --git a/corsika/detail/framework/process/SwitchProcessSequence.inl b/corsika/detail/framework/process/SwitchProcessSequence.inl
index eaa33839a78c61b127acf3ae9a266a7d3745bac5..2f87ade6d329ab249f5a61f21b79c72d07d315fd 100644
--- a/corsika/detail/framework/process/SwitchProcessSequence.inl
+++ b/corsika/detail/framework/process/SwitchProcessSequence.inl
@@ -27,198 +27,183 @@
namespace corsika {
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
- template <typename TParticle, typename TVTNType>
- inline ProcessReturn
- SwitchProcessSequence<TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
- IndexProcess2>::doBoundaryCrossing(TParticle& particle,
- TVTNType const& from,
- TVTNType const& to) {
- switch (select_(particle)) {
- case SwitchResult::First: {
+ template <typename TParticle>
+ inline ProcessReturn SwitchProcessSequence<
+ TCondition, TSequence, USequence, IndexStart, IndexProcess1,
+ IndexProcess2>::doBoundaryCrossing(TParticle& particle,
+ typename TParticle::node_type const& from,
+ typename TParticle::node_type const& to) {
+ if (select_(particle)) {
+ if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process1_type>,
+ process1_type> ||
+ process1_type::is_process_sequence) {
+
+ // interface checking on TSequence
if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process1_type>,
- process1_type> ||
- t1ProcSeq) {
-
- // interface checking on TProcess1
- if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process1_type>,
- process1_type>) {
-
- static_assert(
- has_method_doBoundaryCrossing_v<TProcess1, ProcessReturn, TParticle&>,
- "TDerived has no method with correct signature \"ProcessReturn "
- "doBoundaryCrossing(TParticle&, VolumeNode const&, VolumeNode const&)\" "
- "required for "
- "BoundaryCrossingProcess<TDerived>. ");
- }
-
- return A_.doBoundaryCrossing(particle, from, to);
+ process1_type>) {
+
+ static_assert(
+ has_method_doBoundaryCrossing_v<TSequence, ProcessReturn, TParticle&>,
+ "TDerived has no method with correct signature \"ProcessReturn "
+ "doBoundaryCrossing(TParticle&, VolumeNode const&, VolumeNode const&)\" "
+ "required for "
+ "BoundaryCrossingProcess<TDerived>. ");
}
- break;
+
+ return A_.doBoundaryCrossing(particle, from, to);
}
- case SwitchResult::Second: {
+ } else {
+
+ if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process2_type>,
+ process2_type> ||
+ process2_type::is_process_sequence) {
+
+ // interface checking on USequence
if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process2_type>,
- process2_type> ||
- t2ProcSeq) {
-
- // interface checking on TProcess2
- if constexpr (std::is_base_of_v<BoundaryCrossingProcess<process2_type>,
- process2_type>) {
-
- static_assert(
- has_method_doBoundaryCrossing_v<TProcess2, ProcessReturn, TParticle>,
- "TDerived has no method with correct signature \"ProcessReturn "
- "doBoundaryCrossing(TParticle&, VolumeNode const&, VolumeNode const&)\" "
- "required for "
- "BoundaryCrossingProcess<TDerived>. ");
- }
-
- return B_.doBoundaryCrossing(particle, from, to);
+ process2_type>) {
+
+ static_assert(
+ has_method_doBoundaryCrossing_v<USequence, ProcessReturn, TParticle>,
+ "TDerived has no method with correct signature \"ProcessReturn "
+ "doBoundaryCrossing(TParticle&, VolumeNode const&, VolumeNode const&)\" "
+ "required for "
+ "BoundaryCrossingProcess<TDerived>. ");
}
- break;
+
+ return B_.doBoundaryCrossing(particle, from, to);
}
}
return ProcessReturn::Ok;
}
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
template <typename TParticle, typename TTrack>
inline ProcessReturn SwitchProcessSequence<
- TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
+ TCondition, TSequence, USequence, IndexStart, IndexProcess1,
IndexProcess2>::doContinuous(TParticle& particle, TTrack& vT,
ContinuousProcessIndex const idLimit) {
- switch (select_(particle)) {
- case SwitchResult::First: {
- if constexpr (t1ProcSeq) { return A_.doContinuous(particle, vT, idLimit); }
- if constexpr (is_continuous_process_v<process1_type>) {
-
- static_assert(
- has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle&, TTrack&> ||
- has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle&,
- TTrack const&> ||
- has_method_doContinuous_v<TProcess1, ProcessReturn, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"ProcessReturn "
- "doContinuous(TParticle[const]&,TTrack[const]&,bool)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- return A_.doContinuous(particle, vT,
- idLimit == ContinuousProcessIndex(IndexProcess1));
- }
- break;
+ if (select_(particle)) {
+ if constexpr (process1_type::is_process_sequence) {
+ return A_.doContinuous(particle, vT, idLimit);
}
- case SwitchResult::Second: {
- if constexpr (t2ProcSeq) { return B_.doContinuous(particle, vT, idLimit); }
- if constexpr (is_continuous_process_v<process2_type>) {
-
- // interface checking on TProcess2
- static_assert(
- has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle&, TTrack&> ||
- has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle&,
- TTrack const&> ||
- has_method_doContinuous_v<TProcess2, ProcessReturn, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"ProcessReturn "
- "doContinuous(TParticle [const]&,TTrack[const]&,bool)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- return B_.doContinuous(particle, vT,
- idLimit == ContinuousProcessIndex(IndexProcess2));
- }
- break;
+ if constexpr (is_continuous_process_v<process1_type>) {
+
+ static_assert(
+ has_method_doContinuous_v<TSequence, ProcessReturn, TParticle&, TTrack&> ||
+ has_method_doContinuous_v<TSequence, ProcessReturn, TParticle&,
+ TTrack const&> ||
+ has_method_doContinuous_v<TSequence, ProcessReturn, TParticle const&,
+ TTrack const&>,
+ "TDerived has no method with correct signature \"ProcessReturn "
+ "doContinuous(TParticle[const]&,TTrack[const]&,bool)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ return A_.doContinuous(particle, vT,
+ idLimit == ContinuousProcessIndex(IndexProcess1));
+ }
+ } else {
+ if constexpr (process2_type::is_process_sequence) {
+ return B_.doContinuous(particle, vT, idLimit);
+ }
+ if constexpr (is_continuous_process_v<process2_type>) {
+
+ // interface checking on USequence
+ static_assert(
+ has_method_doContinuous_v<USequence, ProcessReturn, TParticle&, TTrack&> ||
+ has_method_doContinuous_v<USequence, ProcessReturn, TParticle&,
+ TTrack const&> ||
+ has_method_doContinuous_v<USequence, ProcessReturn, TParticle const&,
+ TTrack const&>,
+ "TDerived has no method with correct signature \"ProcessReturn "
+ "doContinuous(TParticle [const]&,TTrack[const]&,bool)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ return B_.doContinuous(particle, vT,
+ idLimit == ContinuousProcessIndex(IndexProcess2));
}
}
return ProcessReturn::Ok;
}
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
template <typename TSecondaries>
inline void
- SwitchProcessSequence<TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
+ SwitchProcessSequence<TCondition, TSequence, USequence, IndexStart, IndexProcess1,
IndexProcess2>::doSecondaries(TSecondaries& vS) {
const auto& particle = vS.parent();
- switch (select_(particle)) {
- case SwitchResult::First: {
- if constexpr (std::is_base_of_v<SecondariesProcess<process1_type>,
- process1_type> ||
- t1ProcSeq) {
-
- // interface checking on TProcess1
- static_assert(
- has_method_doSecondaries_v<TProcess1, void, TSecondaries&> ||
- has_method_doSecondaries_v<TProcess1, void, TSecondaries const&>,
- "TDerived has no method with correct signature \"void "
- "doSecondaries(TStackView [const]&)\" required for "
- "SecondariesProcessProcess<TDerived>. ");
-
- A_.doSecondaries(vS);
- }
- break;
+ if (select_(particle)) {
+ if constexpr (std::is_base_of_v<SecondariesProcess<process1_type>, process1_type> ||
+ process1_type::is_process_sequence) {
+
+ // interface checking on TSequence
+ static_assert(
+ has_method_doSecondaries_v<TSequence, void, TSecondaries&> ||
+ has_method_doSecondaries_v<TSequence, void, TSecondaries const&>,
+ "TDerived has no method with correct signature \"void "
+ "doSecondaries(TStackView [const]&)\" required for "
+ "SecondariesProcessProcess<TDerived>. ");
+
+ A_.doSecondaries(vS);
}
- case SwitchResult::Second: {
- if constexpr (std::is_base_of_v<SecondariesProcess<process2_type>,
- process2_type> ||
- t2ProcSeq) {
-
- // interface checking on TProcess2
- static_assert(
- has_method_doSecondaries_v<TProcess2, void, TSecondaries&> ||
- has_method_doSecondaries_v<TProcess2, void, TSecondaries const&>,
- "TDerived has no method with correct signature \"void "
- "doSecondaries(TStackView [const]&)\" required for "
- "SecondariesProcessProcess<TDerived>. ");
-
- B_.doSecondaries(vS);
- }
- break;
+ } else {
+ if constexpr (std::is_base_of_v<SecondariesProcess<process2_type>, process2_type> ||
+ process2_type::is_process_sequence) {
+
+ // interface checking on USequence
+ static_assert(
+ has_method_doSecondaries_v<USequence, void, TSecondaries&> ||
+ has_method_doSecondaries_v<USequence, void, TSecondaries const&>,
+ "TDerived has no method with correct signature \"void "
+ "doSecondaries(TStackView [const]&)\" required for "
+ "SecondariesProcessProcess<TDerived>. ");
+
+ B_.doSecondaries(vS);
}
}
}
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
template <typename TParticle, typename TTrack>
inline ContinuousProcessStepLength
- SwitchProcessSequence<TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
+ SwitchProcessSequence<TCondition, TSequence, USequence, IndexStart, IndexProcess1,
IndexProcess2>::getMaxStepLength(TParticle& particle,
TTrack& vTrack) {
- switch (select_(particle)) {
- case SwitchResult::First: {
- if constexpr (t1ProcSeq) { return A_.getMaxStepLength(particle, vTrack); }
- if constexpr (is_continuous_process_v<process1_type>) {
+ if (select_(particle)) {
+ if constexpr (process1_type::is_process_sequence) {
+ return A_.getMaxStepLength(particle, vTrack);
+ }
+ if constexpr (is_continuous_process_v<process1_type>) {
- // interface checking on TProcess1
- static_assert(
- has_method_getMaxStepLength_v<TProcess1, LengthType, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"LengthType "
- "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- return ContinuousProcessStepLength(A_.getMaxStepLength(particle, vTrack),
- ContinuousProcessIndex(IndexProcess1));
- }
- break;
+ // interface checking on TSequence
+ static_assert(has_method_getMaxStepLength_v<TSequence, LengthType,
+ TParticle const&, TTrack const&>,
+ "TDerived has no method with correct signature \"LengthType "
+ "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ return ContinuousProcessStepLength(A_.getMaxStepLength(particle, vTrack),
+ ContinuousProcessIndex(IndexProcess1));
}
- case SwitchResult::Second: {
- if constexpr (t2ProcSeq) { return B_.getMaxStepLength(particle, vTrack); }
- if constexpr (is_continuous_process_v<process2_type>) {
+ } else {
+ if constexpr (process2_type::is_process_sequence) {
+ return B_.getMaxStepLength(particle, vTrack);
+ }
+ if constexpr (is_continuous_process_v<process2_type>) {
- // interface checking on TProcess2
- static_assert(
- has_method_getMaxStepLength_v<TProcess2, LengthType, TParticle const&,
- TTrack const&>,
- "TDerived has no method with correct signature \"LengthType "
- "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
- "ContinuousProcess<TDerived>. ");
-
- return ContinuousProcessStepLength(B_.getMaxStepLength(particle, vTrack),
- ContinuousProcessIndex(IndexProcess2));
- }
- break;
+ // interface checking on USequence
+ static_assert(has_method_getMaxStepLength_v<USequence, LengthType,
+ TParticle const&, TTrack const&>,
+ "TDerived has no method with correct signature \"LengthType "
+ "getMaxStepLength(TParticle const&, TTrack const&)\" required for "
+ "ContinuousProcess<TDerived>. ");
+
+ return ContinuousProcessStepLength(B_.getMaxStepLength(particle, vTrack),
+ ContinuousProcessIndex(IndexProcess2));
}
}
@@ -226,202 +211,169 @@ namespace corsika {
return ContinuousProcessStepLength(std::numeric_limits<double>::infinity() * meter);
}
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
template <typename TParticle>
inline InverseGrammageType SwitchProcessSequence<
- TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
+ TCondition, TSequence, USequence, IndexStart, IndexProcess1,
IndexProcess2>::getInverseInteractionLength(TParticle&& particle) {
- switch (select_(particle)) {
- case SwitchResult::First: {
- if constexpr (std::is_base_of_v<InteractionProcess<process1_type>,
- process1_type> ||
- t1ProcSeq) {
- return A_.getInverseInteractionLength(particle);
- }
- break;
+ if (select_(particle)) {
+ if constexpr (std::is_base_of_v<InteractionProcess<process1_type>, process1_type> ||
+ process1_type::is_process_sequence) {
+ return A_.getInverseInteractionLength(particle);
}
- case SwitchResult::Second: {
- if constexpr (std::is_base_of_v<InteractionProcess<process2_type>,
- process2_type> ||
- t2ProcSeq) {
- return B_.getInverseInteractionLength(particle);
- }
- break;
+
+ } else {
+
+ if constexpr (std::is_base_of_v<InteractionProcess<process2_type>, process2_type> ||
+ process2_type::is_process_sequence) {
+ return B_.getInverseInteractionLength(particle);
}
}
return 0 * meter * meter / gram; // default value
}
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
template <typename TSecondaryView>
- inline ProcessReturn SwitchProcessSequence<TProcess1, TProcess2, TSelect, IndexStart,
+ inline ProcessReturn SwitchProcessSequence<TCondition, TSequence, USequence, IndexStart,
IndexProcess1, IndexProcess2>::
selectInteraction(TSecondaryView& view,
[[maybe_unused]] InverseGrammageType lambda_inv_select,
[[maybe_unused]] InverseGrammageType lambda_inv_sum) {
- switch (select_(view.parent())) {
- case SwitchResult::First: {
- if constexpr (t1ProcSeq) {
- // if A_ is a process sequence --> check inside
- ProcessReturn const ret =
- A_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
- // if A_ did succeed, stop routine. Not checking other static branch B_.
- if (ret != ProcessReturn::Ok) { return ret; }
- } else if constexpr (std::is_base_of_v<InteractionProcess<process1_type>,
- process1_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- lambda_inv_sum += A_.getInverseInteractionLength(view.parent());
- // check if we should execute THIS process and then EXIT
- if (lambda_inv_select < lambda_inv_sum) {
-
- // interface checking on TProcess1
- static_assert(has_method_doInteract_v<TProcess1, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doInteraction(TSecondaryView&)\" required for "
- "InteractionProcess<TDerived>. ");
-
- A_.doInteraction(view);
- return ProcessReturn::Interacted;
- }
- } // end branch A_
- break;
- }
-
- case SwitchResult::Second: {
-
- if constexpr (t2ProcSeq) {
- // if B_ is a process sequence --> check inside
- return B_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
- } else if constexpr (std::is_base_of_v<InteractionProcess<process2_type>,
- process2_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- lambda_inv_sum += B_.getInverseInteractionLength(view.parent());
- // check if we should execute THIS process and then EXIT
- if (lambda_inv_select < lambda_inv_sum) {
-
- // interface checking on TProcess1
- static_assert(has_method_doInteract_v<TProcess2, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doInteraction(TSecondaryView&)\" required for "
- "InteractionProcess<TDerived>. ");
-
- B_.doInteraction(view);
- return ProcessReturn::Interacted;
- }
- } // end branch B_
- break;
- }
+ if (select_(view.parent())) {
+ if constexpr (process1_type::is_process_sequence) {
+ // if A_ is a process sequence --> check inside
+ ProcessReturn const ret =
+ A_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
+ // if A_ did succeed, stop routine. Not checking other static branch B_.
+ if (ret != ProcessReturn::Ok) { return ret; }
+ } else if constexpr (std::is_base_of_v<InteractionProcess<process1_type>,
+ process1_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ lambda_inv_sum += A_.getInverseInteractionLength(view.parent());
+ // check if we should execute THIS process and then EXIT
+ if (lambda_inv_select < lambda_inv_sum) {
+
+ // interface checking on TSequence
+ static_assert(has_method_doInteract_v<TSequence, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doInteraction(TSecondaryView&)\" required for "
+ "InteractionProcess<TDerived>. ");
+
+ A_.doInteraction(view);
+ return ProcessReturn::Interacted;
+ }
+ } // end branch A_
+
+ } else {
+
+ if constexpr (process2_type::is_process_sequence) {
+ // if B_ is a process sequence --> check inside
+ return B_.selectInteraction(view, lambda_inv_select, lambda_inv_sum);
+ } else if constexpr (std::is_base_of_v<InteractionProcess<process2_type>,
+ process2_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ lambda_inv_sum += B_.getInverseInteractionLength(view.parent());
+ // check if we should execute THIS process and then EXIT
+ if (lambda_inv_select < lambda_inv_sum) {
+
+ // interface checking on TSequence
+ static_assert(has_method_doInteract_v<USequence, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doInteraction(TSecondaryView&)\" required for "
+ "InteractionProcess<TDerived>. ");
+
+ B_.doInteraction(view);
+ return ProcessReturn::Interacted;
+ }
+ } // end branch B_
}
return ProcessReturn::Ok;
}
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
template <typename TParticle>
inline InverseTimeType
- SwitchProcessSequence<TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
+ SwitchProcessSequence<TCondition, TSequence, USequence, IndexStart, IndexProcess1,
IndexProcess2>::getInverseLifetime(TParticle&& particle) {
- switch (select_(particle)) {
- case SwitchResult::First: {
- if constexpr (std::is_base_of_v<DecayProcess<process1_type>, process1_type> ||
- t1ProcSeq) {
- return A_.getInverseLifetime(particle);
- }
- break;
+ if (select_(particle)) {
+ if constexpr (std::is_base_of_v<DecayProcess<process1_type>, process1_type> ||
+ process1_type::is_process_sequence) {
+ return A_.getInverseLifetime(particle);
}
- case SwitchResult::Second: {
- if constexpr (std::is_base_of_v<DecayProcess<process2_type>, process2_type> ||
- t2ProcSeq) {
- return B_.getInverseLifetime(particle);
- }
- break;
+ } else {
+
+ if constexpr (std::is_base_of_v<DecayProcess<process2_type>, process2_type> ||
+ process2_type::is_process_sequence) {
+ return B_.getInverseLifetime(particle);
}
}
return 0 / second; // default value
}
- template <typename TProcess1, typename TProcess2, typename TSelect, int IndexStart,
+ template <typename TCondition, typename TSequence, typename USequence, int IndexStart,
int IndexProcess1, int IndexProcess2>
// select decay process
template <typename TSecondaryView>
inline ProcessReturn SwitchProcessSequence<
- TProcess1, TProcess2, TSelect, IndexStart, IndexProcess1,
+ TCondition, TSequence, USequence, IndexStart, IndexProcess1,
IndexProcess2>::selectDecay(TSecondaryView& view,
[[maybe_unused]] InverseTimeType decay_inv_select,
[[maybe_unused]] InverseTimeType decay_inv_sum) {
- switch (select_(view.parent())) {
- case SwitchResult::First: {
- if constexpr (t1ProcSeq) {
- // if A_ is a process sequence --> check inside
- ProcessReturn const ret = A_.selectDecay(view, decay_inv_select, decay_inv_sum);
- // if A_ did succeed, stop routine here (not checking other static branch B_)
- if (ret != ProcessReturn::Ok) { return ret; }
- } else if constexpr (std::is_base_of_v<DecayProcess<process1_type>,
- process1_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- decay_inv_sum += A_.getInverseLifetime(view.parent());
- // check if we should execute THIS process and then EXIT
- if (decay_inv_select < decay_inv_sum) {
- // more pedagogical: rndm_select < decay_inv_sum / decay_inv_tot
-
- // interface checking on TProcess1
- static_assert(has_method_doDecay_v<TProcess1, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doDecay(TSecondaryView&)\" required for "
- "DecayProcess<TDerived>. ");
-
- A_.doDecay(view);
- return ProcessReturn::Decayed;
- }
- } // end branch A_
- break;
- }
-
- case SwitchResult::Second: {
-
- if constexpr (t2ProcSeq) {
- // if B_ is a process sequence --> check inside
- return B_.selectDecay(view, decay_inv_select, decay_inv_sum);
- } else if constexpr (std::is_base_of_v<DecayProcess<process2_type>,
- process2_type>) {
- // if this is not a ContinuousProcess --> evaluate probability
- decay_inv_sum += B_.getInverseLifetime(view.parent());
- // check if we should execute THIS process and then EXIT
- if (decay_inv_select < decay_inv_sum) {
-
- // interface checking on TProcess1
- static_assert(has_method_doDecay_v<TProcess2, void, TSecondaryView&>,
- "TDerived has no method with correct signature \"void "
- "doDecay(TSecondaryView&)\" required for "
- "DecayProcess<TDerived>. ");
-
- B_.doDecay(view);
- return ProcessReturn::Decayed;
- }
- } // end branch B_
- break;
- }
+ if (select_(view.parent())) {
+ if constexpr (process1_type::is_process_sequence) {
+ // if A_ is a process sequence --> check inside
+ ProcessReturn const ret = A_.selectDecay(view, decay_inv_select, decay_inv_sum);
+ // if A_ did succeed, stop routine here (not checking other static branch B_)
+ if (ret != ProcessReturn::Ok) { return ret; }
+ } else if constexpr (std::is_base_of_v<DecayProcess<process1_type>,
+ process1_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ decay_inv_sum += A_.getInverseLifetime(view.parent());
+ // check if we should execute THIS process and then EXIT
+ if (decay_inv_select < decay_inv_sum) {
+ // more pedagogical: rndm_select < decay_inv_sum / decay_inv_tot
+
+ // interface checking on TSequence
+ static_assert(has_method_doDecay_v<TSequence, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doDecay(TSecondaryView&)\" required for "
+ "DecayProcess<TDerived>. ");
+
+ A_.doDecay(view);
+ return ProcessReturn::Decayed;
+ }
+ } // end branch A_
+
+ } else {
+
+ if constexpr (process2_type::is_process_sequence) {
+ // if B_ is a process sequence --> check inside
+ return B_.selectDecay(view, decay_inv_select, decay_inv_sum);
+ } else if constexpr (std::is_base_of_v<DecayProcess<process2_type>,
+ process2_type>) {
+ // if this is not a ContinuousProcess --> evaluate probability
+ decay_inv_sum += B_.getInverseLifetime(view.parent());
+ // check if we should execute THIS process and then EXIT
+ if (decay_inv_select < decay_inv_sum) {
+
+ // interface checking on TSequence
+ static_assert(has_method_doDecay_v<USequence, void, TSecondaryView&>,
+ "TDerived has no method with correct signature \"void "
+ "doDecay(TSecondaryView&)\" required for "
+ "DecayProcess<TDerived>. ");
+
+ B_.doDecay(view);
+ return ProcessReturn::Decayed;
+ }
+ } // end branch B_
}
return ProcessReturn::Ok;
}
- /// traits marker to identify objectas ProcessSequence
- template <typename TProcess1, typename TProcess2, typename TSelect>
- struct is_process_sequence<SwitchProcessSequence<TProcess1, TProcess2, TSelect>>
- : std::true_type {};
-
- template <typename TProcess1, typename TProcess2, typename TSelect>
- struct is_process_sequence<SwitchProcessSequence<TProcess1, TProcess2, TSelect>&>
- : std::true_type {};
-
- /// traits marker to identify objectas SwitchProcessSequence
- template <typename TProcess1, typename TProcess2, typename TSelect>
- struct is_switch_process_sequence<SwitchProcessSequence<TProcess1, TProcess2, TSelect>>
- : std::true_type {};
-
} // namespace corsika
diff --git a/corsika/framework/process/BaseProcess.hpp b/corsika/framework/process/BaseProcess.hpp
index 56b8b38f25d5b551c57ba3580f4ab6925c7c7080..23e8667b20c9b92c9200135fcfe1b107c6e6c386 100644
--- a/corsika/framework/process/BaseProcess.hpp
+++ b/corsika/framework/process/BaseProcess.hpp
@@ -16,10 +16,6 @@
namespace corsika {
- class TDerived; // fwd decl
-
- class _BaseProcess {};
-
/**
@ingroup Processes
@{
@@ -31,13 +27,10 @@ namespace corsika {
are of type BaseProcess
@todo rename BaseProcess into just Process
- @todo rename _BaseProcess, or find better alternative in FIXME
- ./Processes/AnalyticProcessors/ExecTime.h, see e.g. how this is done in
- ProcessSequence.hpp/make_sequence
*/
template <typename TDerived>
- struct BaseProcess : _BaseProcess {
+ struct BaseProcess {
protected:
friend TDerived;
@@ -53,6 +46,9 @@ namespace corsika {
//! @}
public:
+ static bool const is_process_sequence = false;
+ static bool const is_switch_process_sequence = false;
+
//! Default number of processes is just one, obviously
static unsigned int constexpr getNumberOfProcesses() { return 1; }
@@ -74,9 +70,10 @@ namespace corsika {
count_processes traits specialization to increase process count by one.
*/
template <typename TProcess, int N>
- struct count_processes<TProcess, N,
- typename std::enable_if_t<is_process_v<TProcess> &&
- !is_process_sequence_v<TProcess>>> {
+ struct count_processes<
+ TProcess, N,
+ typename std::enable_if_t<is_process_v<std::decay_t<TProcess>> &&
+ !std::decay_t<TProcess>::is_process_sequence>> {
static unsigned int constexpr count = N + 1;
};
diff --git a/corsika/framework/process/BoundaryCrossingProcess.hpp b/corsika/framework/process/BoundaryCrossingProcess.hpp
index acee3b48020a54d1bffc4a415804c7a9f19dc0db..553b617bc136e1c128ff16cbde017186cf210f59 100644
--- a/corsika/framework/process/BoundaryCrossingProcess.hpp
+++ b/corsika/framework/process/BoundaryCrossingProcess.hpp
@@ -47,6 +47,15 @@ namespace corsika {
public:
};
+ /**
+ * ProcessTraits specialization to flag BoundaryProcess objects
+ **/
+ template <typename TProcess>
+ struct is_boundary_process<TProcess,
+ std::enable_if_t<std::is_base_of_v<
+ BoundaryCrossingProcess<typename std::decay_t<TProcess>>,
+ typename std::decay_t<TProcess>>>> : std::true_type {};
+
/** @} */
} // namespace corsika
diff --git a/corsika/framework/process/ContinuousProcess.hpp b/corsika/framework/process/ContinuousProcess.hpp
index 2fa5cac743bd82e1fff850bb3e86f6c759c7c6ea..c549bc714da8e4c6b655afbb8690568a2f4c4e24 100644
--- a/corsika/framework/process/ContinuousProcess.hpp
+++ b/corsika/framework/process/ContinuousProcess.hpp
@@ -63,7 +63,9 @@ namespace corsika {
*/
template <typename TDerived>
- class ContinuousProcess : public BaseProcess<TDerived> {};
+ class ContinuousProcess : public BaseProcess<TDerived> {
+ public:
+ };
/**
* ProcessTraits specialization to flag ContinuousProcess objects
diff --git a/corsika/framework/process/DecayProcess.hpp b/corsika/framework/process/DecayProcess.hpp
index 2c66b9c6e24f27f18593624b80cc4cbd98aa20b4..dc1e9a3ed3984570787b2a6ce36f3d88a20d90b7 100644
--- a/corsika/framework/process/DecayProcess.hpp
+++ b/corsika/framework/process/DecayProcess.hpp
@@ -65,6 +65,16 @@ namespace corsika {
}
};
+ /**
+ * ProcessTraits specialization to flag DecayProcess objects
+ **/
+ template <typename TProcess>
+ struct is_decay_process<
+ TProcess,
+ std::enable_if_t<std::is_base_of_v<DecayProcess<typename std::decay_t<TProcess>>,
+ typename std::decay_t<TProcess>>>>
+ : std::true_type {};
+
/** @} */
} // namespace corsika
diff --git a/corsika/framework/process/InteractionProcess.hpp b/corsika/framework/process/InteractionProcess.hpp
index f6df9ede713c041d78506d544d5d0b8167ea4f71..6965457a7fe1a6c495e42b62943ebe87b3771702 100644
--- a/corsika/framework/process/InteractionProcess.hpp
+++ b/corsika/framework/process/InteractionProcess.hpp
@@ -68,6 +68,16 @@ namespace corsika {
}
};
+ /**
+ * ProcessTraits specialization to flag InteractionProcess objects
+ **/
+ template <typename TProcess>
+ struct is_interaction_process<
+ TProcess, std::enable_if_t<
+ std::is_base_of_v<InteractionProcess<typename std::decay_t<TProcess>>,
+ typename std::decay_t<TProcess>>>>
+ : std::true_type {};
+
/** @} */
} // namespace corsika
diff --git a/corsika/framework/process/NullModel.hpp b/corsika/framework/process/NullModel.hpp
index a28d9668a7dcf2162b9e22397a9ad754c588d15b..eb39f870e38c26796fdcc601e601f4327ee2bdb5 100644
--- a/corsika/framework/process/NullModel.hpp
+++ b/corsika/framework/process/NullModel.hpp
@@ -21,21 +21,26 @@ namespace corsika {
BaseProcess
*/
- class NullModel { // : public BaseProcess<NullModel> {
+ class NullModel {
public:
NullModel() = default;
~NullModel() = default;
+ static bool const is_process_sequence = false;
+ static bool const is_switch_process_sequence = false;
+
//! Default number of processes is just one, obviously
static unsigned int constexpr getNumberOfProcesses() { return 0; }
};
/**
- is_process traits specialization to indicate compatibility ProcessSequence
+ is_process traits specialization to indicate compatibility with BaseProcess
*/
- template <>
- struct is_process<NullModel, void> : std::true_type {};
+ template <typename TNull>
+ struct is_process<
+ TNull, std::enable_if_t<std::is_base_of_v<NullModel, typename std::decay_t<TNull>>>>
+ : std::true_type {};
/**
count_processes traits specialization to increase process count by one.
diff --git a/corsika/framework/process/ProcessSequence.hpp b/corsika/framework/process/ProcessSequence.hpp
index d4f2f12601a9fc2f4a5efcb22263393fe5b078ba..05191c248d5e1b17ceb5cfe39fc5dfe2fcabe4f6 100644
--- a/corsika/framework/process/ProcessSequence.hpp
+++ b/corsika/framework/process/ProcessSequence.hpp
@@ -31,11 +31,12 @@ namespace corsika {
/**
count_processes traits specialization to increase process count by
getNumberOfProcesses(). This is used to statically count processes in the sequence
- */
+ **/
template <typename TProcess, int N>
- struct count_processes<TProcess, N,
- typename std::enable_if_t<is_process_v<TProcess> &&
- is_process_sequence_v<TProcess>>> {
+ struct count_processes<
+ TProcess, N,
+ typename std::enable_if_t<is_process_v<std::decay_t<TProcess>> &&
+ std::decay_t<TProcess>::is_process_sequence>> {
static unsigned int constexpr count =
N + std::decay_t<TProcess>::getNumberOfProcesses();
};
@@ -144,32 +145,20 @@ namespace corsika {
process-chain. The offset is the starting value for this ProcessSequence
@tparam IndexOfProcess1 index of TProcess1 (counting of Process)
@tparam IndexOfProcess2 index of TProcess2 (counting of Process)
- */
+ **/
template <typename TProcess1, typename TProcess2 = NullModel,
int ProcessIndexOffset = 0,
- int IndexOfProcess1 = count_processes<
- TProcess1, count_processes<TProcess2, ProcessIndexOffset>::count>::count,
- int IndexOfProcess2 = count_processes<TProcess2, ProcessIndexOffset>::count>
+ int IndexOfProcess1 = corsika::count_processes<
+ TProcess1,
+ corsika::count_processes<TProcess2, ProcessIndexOffset>::count>::count,
+ int IndexOfProcess2 =
+ corsika::count_processes<TProcess2, ProcessIndexOffset>::count>
class ProcessSequence : public BaseProcess<ProcessSequence<TProcess1, TProcess2>> {
using process1_type = typename std::decay_t<TProcess1>;
using process2_type = typename std::decay_t<TProcess2>;
- static bool constexpr t1ProcSeq = is_process_sequence_v<process1_type>;
- static bool constexpr t2ProcSeq = is_process_sequence_v<process2_type>;
-
- static bool constexpr t1SwitchProcSeq = is_switch_process_sequence_v<process1_type>;
- static bool constexpr t2SwitchProcSeq = is_switch_process_sequence_v<process2_type>;
-
- // make sure only BaseProcess types TProcess1/2 are passed
- static_assert(is_process_v<process1_type>,
- "can only use process derived from BaseProcess in "
- "ProcessSequence, for Process 1");
- static_assert(is_process_v<process2_type>,
- "can only use process derived from BaseProcess in "
- "ProcessSequence, for Process 2");
-
public:
// resource management
ProcessSequence() = delete; // only initialized objects
@@ -178,19 +167,19 @@ namespace corsika {
ProcessSequence& operator=(ProcessSequence const&) = default;
~ProcessSequence() = default;
+ static bool const is_process_sequence = true;
+
/**
- * Only valid user constructor will create fully initialized object
- *
- * ProcessSequence supports and encourages move semantics. You can
- * use object, l-value references or r-value references to
- * construct sequences.
- *
- * \param in_A process/list A
- * \param in_A process/list B
+ Only valid user constructor will create fully initialized object
+
+ ProcessSequence supports and encourages move semantics. You can
+ use object, l-value references or r-value references to
+ construct sequences.
+
+ @param in_A BaseProcess or switch/process list
+ @param in_B BaseProcess or switch/process list
**/
- ProcessSequence(TProcess1 in_A, TProcess2 in_B)
- : A_(in_A)
- , B_(in_B) {}
+ ProcessSequence(TProcess1 in_A, TProcess2 in_B);
template <typename TParticle>
ProcessReturn doBoundaryCrossing(TParticle& particle,
@@ -267,6 +256,11 @@ namespace corsika {
**/
static unsigned int constexpr getNumberOfProcesses() { return numberOfProcesses_; }
+#ifdef CORSIKA_UNIT_TESTING
+ TProcess1 getProcess1() const { return A_; }
+ TProcess2 getProcess2() const { return B_; }
+#endif
+
private:
TProcess1 A_; /// process/list A, this is a reference, if possible
TProcess2 B_; /// process/list B, this is a reference, if possible
@@ -300,13 +294,11 @@ namespace corsika {
@tparam TProcesses parameter pack with objects of type BaseProcess
@tparam TProcess1 another BaseProcess
- @param vA needs to derive from BaseProcess or ProcessSequence
- @param vB paramter-pack, needs to derive BaseProcess or ProcessSequence
+ @param vA needs to derive from BaseProcess
+ @param vB paramter-pack, needs to derive BaseProcess
*/
template <typename... TProcesses, typename TProcess1>
- typename std::enable_if_t<
- is_process_v<typename std::decay_t<TProcess1>>,
- ProcessSequence<TProcess1, decltype(make_sequence(std::declval<TProcesses>()...))>>
+ ProcessSequence<TProcess1, decltype(make_sequence(std::declval<TProcesses>()...))>
make_sequence(TProcess1&& vA, TProcesses&&... vBs) {
return ProcessSequence<TProcess1,
decltype(make_sequence(std::declval<TProcesses>()...))>(
@@ -323,14 +315,11 @@ namespace corsika {
@tparam TProcess1 another BaseProcess
@tparam TProcess2 another BaseProcess
- @param vA needs to derive from BaseProcess or ProcessSequence
- @param vB needs to derive BaseProcess or ProcessSequence
- */
+ @param vA needs to derive from BaseProcess
+ @param vB needs to derive BaseProcess
+ */
template <typename TProcess1, typename 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) {
+ ProcessSequence<TProcess1, TProcess2> make_sequence(TProcess1&& vA, TProcess2&& vB) {
return ProcessSequence<TProcess1, TProcess2>(vA, vB);
}
@@ -344,31 +333,13 @@ namespace corsika {
`NullModel`
@tparam TProcess1 another BaseProcess
- @param vA needs to derive from BaseProcess or ProcessSequence
+ @param vA needs to derive from BaseProcess
*/
template <typename TProcess>
- typename std::enable_if_t<is_process_v<typename std::decay_t<TProcess>>,
- ProcessSequence<TProcess, NullModel>>
- make_sequence(TProcess&& vA) {
+ ProcessSequence<TProcess, NullModel> make_sequence(TProcess&& vA) {
return ProcessSequence<TProcess, NullModel>(vA, NullModel());
}
- /**
- @struct
- @ingroup Processes
- traits marker to identify objectas ProcessSequence
-
- @tparam TProcess1 another BaseProcess
- @tparam TProcess2 another BaseProcess
- **/
- template <typename TProcess1, typename TProcess2>
- struct is_process_sequence<ProcessSequence<TProcess1, TProcess2>> : std::true_type {
- // only switch on for BaseProcesses
- template <typename std::enable_if_t<
- is_process_v<TProcess1> && is_process_v<TProcess2>, int>>
- is_process_sequence() {}
- };
-
} // namespace corsika
#include <corsika/detail/framework/process/ProcessSequence.inl>
diff --git a/corsika/framework/process/ProcessTraits.hpp b/corsika/framework/process/ProcessTraits.hpp
index 5fe3600c09aa4a0865a480e868d5b47f74e74e2c..e675fb1717e0c848b91b78ea6b3e0730d2063cf4 100644
--- a/corsika/framework/process/ProcessTraits.hpp
+++ b/corsika/framework/process/ProcessTraits.hpp
@@ -19,7 +19,7 @@ namespace corsika {
/**
* A traits marker to identify BaseProcess, thus any type of process
*/
- template <typename TProcess, typename Enable = void>
+ template <typename TProcess, typename TEnable = void>
struct is_process : std::false_type {};
template <typename TProcess>
@@ -35,23 +35,49 @@ namespace corsika {
bool constexpr is_continuous_process_v = is_continuous_process<TProcess>::value;
/**
- * A traits marker to track which BaseProcess is also a ProcessSequence
- **/
- template <typename TClass>
- struct is_process_sequence : std::false_type {};
+ * A traits marker to identify DecayProcess
+ */
+ template <typename TProcess, typename Enable = void>
+ struct is_decay_process : std::false_type {};
- template <typename TClass>
- bool constexpr is_process_sequence_v = is_process_sequence<TClass>::value;
+ template <typename TProcess>
+ bool constexpr is_decay_process_v = is_decay_process<TProcess>::value;
/**
- * A traits marker to identiy a BaseProcess that is also SwitchProcessesSequence
- **/
+ * A traits marker to identify StackProcess
+ */
+ template <typename TProcess, typename Enable = void>
+ struct is_stack_process : std::false_type {};
- template <typename TClass>
- struct is_switch_process_sequence : std::false_type {};
+ template <typename TProcess>
+ bool constexpr is_stack_process_v = is_stack_process<TProcess>::value;
- template <typename TClass>
- bool constexpr is_switch_process_sequence_v = is_switch_process_sequence<TClass>::value;
+ /**
+ * A traits marker to identify SecondariesProcess
+ */
+ template <typename TProcess, typename Enable = void>
+ struct is_secondaries_process : std::false_type {};
+
+ template <typename TProcess>
+ bool constexpr is_secondaries_process_v = is_secondaries_process<TProcess>::value;
+
+ /**
+ * A traits marker to identify BoundaryProcess
+ */
+ template <typename TProcess, typename Enable = void>
+ struct is_boundary_process : std::false_type {};
+
+ template <typename TProcess>
+ bool constexpr is_boundary_process_v = is_boundary_process<TProcess>::value;
+
+ /**
+ * A traits marker to identify InteractionProcess
+ */
+ template <typename TProcess, typename Enable = void>
+ struct is_interaction_process : std::false_type {};
+
+ template <typename TProcess>
+ bool constexpr is_interaction_process_v = is_interaction_process<TProcess>::value;
/**
* A traits marker to identify ProcessSequence that contain a StackProcess
diff --git a/corsika/framework/process/SecondariesProcess.hpp b/corsika/framework/process/SecondariesProcess.hpp
index 8dd9c154168c678d9653d4a762c7ba5ac6fba8b5..975b1e7851174b3be25e43a99ef06c5155a2912c 100644
--- a/corsika/framework/process/SecondariesProcess.hpp
+++ b/corsika/framework/process/SecondariesProcess.hpp
@@ -41,6 +41,16 @@ namespace corsika {
public:
};
+ /**
+ * ProcessTraits specialization to flag SecondariesProcess objects
+ **/
+ template <typename TProcess>
+ struct is_secondaries_process<
+ TProcess, std::enable_if_t<
+ std::is_base_of_v<SecondariesProcess<typename std::decay_t<TProcess>>,
+ typename std::decay_t<TProcess>>>>
+ : std::true_type {};
+
//! @}
} // namespace corsika
diff --git a/corsika/framework/process/StackProcess.hpp b/corsika/framework/process/StackProcess.hpp
index b8770579e958b3d7c4a6b351c17f05804da38ef2..773265f49e102b63ca447191a25040c555179c37 100644
--- a/corsika/framework/process/StackProcess.hpp
+++ b/corsika/framework/process/StackProcess.hpp
@@ -53,6 +53,8 @@ namespace corsika {
StackProcess(const unsigned int nStep)
: nStep_(nStep) {}
+ static bool const is_stack_process = true;
+
//! return the current Cascade step counter
int getStep() const { return iStep_; }
@@ -72,6 +74,16 @@ namespace corsika {
//! @}
};
+ /**
+ * ProcessTraits specialization to flag StackProcess objects
+ **/
+ template <typename TProcess>
+ struct is_stack_process<
+ TProcess,
+ std::enable_if_t<std::is_base_of_v<StackProcess<typename std::decay_t<TProcess>>,
+ typename std::decay_t<TProcess>>>>
+ : std::true_type {};
+
//! @}
} // namespace corsika
diff --git a/corsika/framework/process/SwitchProcessSequence.hpp b/corsika/framework/process/SwitchProcessSequence.hpp
index 0e60eba5d834b116e5a2cde4dc6a39402714aa96..09edeea43e551f7f37b51e8b105c78cc92ba6f6c 100644
--- a/corsika/framework/process/SwitchProcessSequence.hpp
+++ b/corsika/framework/process/SwitchProcessSequence.hpp
@@ -30,17 +30,6 @@
namespace corsika {
- /**
- @enum
- @ingroup Processes
-
- enum for the process switch selection: identify if First or Second
- process branch should be used.
- @var SwitchResult::First Follow first branch in SwitchProcessSequence
- @var SwitchResult::Second Follow second branch in SwitchProcessSequence
- */
- enum class SwitchResult { First, Second };
-
/**
@ingroup Processes
@{
@@ -48,17 +37,18 @@ namespace corsika {
Class to switch between two process branches
A compile-time static list of processes that uses an internal
- TSelect class to switch between different versions of processes
+ TCondition class to switch between different versions of processes
(or process sequence).
- TProcess1 and TProcess2 must be derived from BaseProcess and are
+ TSequence and USequence must be derived from BaseProcess and are
both references if possible (lvalue), otherwise (rvalue) they are
just classes. This allows us to handle both, rvalue as well as
lvalue Processes in the SwitchProcessSequence.
+ Please use the `corsika::make_select(condition, sequence, alt_sequence)`
+ factory function for best results.
- TSelect has to implement a `operator()(const Particle&)` and has to
- return either SwitchResult::First or SwitchResult::Second. Note:
- TSelect may absolutely also use random numbers to sample between
+ TCondition has to implement a `bool operator()(Particle const&)`. Note:
+ TCondition may absolutely also use random numbers to sample between
its results. This can be used to achieve arbitrarily smooth
transition or mixtures of processes.
@@ -67,33 +57,30 @@ namespace corsika {
particle stack and not on indiviidual particles.
Template parameters:
- @tparam TProcess1 is of type BaseProcess, either a dedicatd process, or a
+ @tparam TCondition selector functor/function
+ @tparam TSequence is of type BaseProcess, either a dedicatd process, or a
ProcessSequence
- @tparam TProcess2 is of type BaseProcess, either a dedicatd process, or a
+ @tparam USequence is of type BaseProcess, either a dedicatd process, or a
ProcessSequence
- @tparam TSelect selector functor/function
@tparam IndexFirstProcess to count and index each Process in the entire
process-chain
- @tparam IndexOfProcess1 index of TProcess1 (counting of Process)
- @tparam IndexOfProcess2 index of TProcess2 (counting of Process)
+ @tparam IndexOfProcess1 index of TSequence (counting of Process)
+ @tparam IndexOfProcess2 index of USequence (counting of Process)
See also class ProcessSequence.
**/
- template <typename TProcess1, typename TProcess2, typename TSelect,
+ template <typename TCondition, typename TSequence, typename USequence,
int IndexFirstProcess = 0,
- int IndexOfProcess1 = count_processes<TProcess1, IndexFirstProcess>::count,
- int IndexOfProcess2 = count_processes<TProcess2, IndexOfProcess1>::count>
+ int IndexOfProcess1 = count_processes<TSequence, IndexFirstProcess>::count,
+ int IndexOfProcess2 = count_processes<USequence, IndexOfProcess1>::count>
class SwitchProcessSequence
- : public BaseProcess<SwitchProcessSequence<TProcess1, TProcess2, TSelect>> {
-
- using process1_type = typename std::decay_t<TProcess1>;
- using process2_type = typename std::decay_t<TProcess2>;
+ : public BaseProcess<SwitchProcessSequence<TCondition, TSequence, USequence>> {
- static bool constexpr t1ProcSeq = is_process_sequence_v<process1_type>;
- static bool constexpr t2ProcSeq = is_process_sequence_v<process2_type>;
+ using process1_type = typename std::decay_t<TSequence>;
+ using process2_type = typename std::decay_t<USequence>;
- // make sure only BaseProcess types TProcess1/2 are passed
+ // make sure only BaseProcess types TSequence/2 are passed
static_assert(is_process_v<process1_type>,
"can only use process derived from BaseProcess in "
"SwitchProcessSequence, for Process 1");
@@ -101,13 +88,13 @@ namespace corsika {
"can only use process derived from BaseProcess in "
"SwitchProcessSequence, for Process 2");
- // make sure none of TProcess1/2 is a StackProcess
+ // make sure none of TSequence/2 is a StackProcess
static_assert(!std::is_base_of_v<StackProcess<process1_type>, process1_type>,
"cannot use StackProcess in SwitchProcessSequence, for Process 1");
static_assert(!std::is_base_of_v<StackProcess<process2_type>, process2_type>,
"cannot use StackProcess in SwitchProcessSequence, for Process 2");
- // if TProcess1/2 are already ProcessSequences, make sure they do not contain
+ // if TSequence/2 are already ProcessSequences, make sure they do not contain
// any StackProcess
static_assert(!contains_stack_process_v<process1_type>,
"cannot use StackProcess in SwitchProcessSequence, remove from "
@@ -124,25 +111,29 @@ namespace corsika {
SwitchProcessSequence& operator=(SwitchProcessSequence const&) = default;
~SwitchProcessSequence() = default;
+ static bool const is_process_sequence = true;
+ static bool const is_switch_process_sequence = true;
+
/**
- * Only valid user constructor will create fully initialized object
- *
- * SwitchProcessSequence supports and encourages move semantics. You can
- * use object, l-value references or r-value references to
- * construct sequences.
- *
- * \param in_A process branch A
- * \param in_A process branch B
- * \param sel functor to switch between branch A and B
+ Only valid user constructor will create fully initialized object
+
+ SwitchProcessSequence supports and encourages move semantics. You can
+ use object, l-value references or r-value references to
+ construct sequences.
+
+ @param sel functor to switch between branch A and B
+ @param in_A process branch A
+ @param in_A process branch B
**/
- SwitchProcessSequence(TProcess1 in_A, TProcess2 in_B, TSelect sel)
+ SwitchProcessSequence(TCondition sel, TSequence in_A, USequence in_B)
: select_(sel)
, A_(in_A)
, B_(in_B) {}
- template <typename TParticle, typename TVTNType>
- ProcessReturn doBoundaryCrossing(TParticle& particle, TVTNType const& from,
- TVTNType const& to);
+ template <typename TParticle>
+ ProcessReturn doBoundaryCrossing(TParticle& particle,
+ typename TParticle::node_type const& from,
+ typename TParticle::node_type const& to);
template <typename TParticle, typename TTrack>
ProcessReturn doContinuous(TParticle& particle, TTrack& vT,
@@ -187,32 +178,38 @@ namespace corsika {
**/
static unsigned int constexpr getNumberOfProcesses() { return numberOfProcesses_; }
+#ifdef CORSIKA_UNIT_TESTING
+ TCondition getCondition() const { return select_; }
+ TSequence getSequence() const { return A_; }
+ USequence getAltSequence() const { return B_; }
+#endif
+
private:
- TSelect select_; /// selector functor to switch between branch a and b, this is a
- /// reference, if possible
+ TCondition select_; /// selector functor to switch between branch a and b, this is a
+ /// reference, if possible
- TProcess1 A_; /// process branch a, this is a reference, if possible
- TProcess2 B_; /// process branch b, this is a reference, if possible
+ TSequence A_; /// process branch a, this is a reference, if possible
+ USequence B_; /// process branch b, this is a reference, if possible
static unsigned int constexpr numberOfProcesses_ = IndexOfProcess2; // static counter
};
/**
- * the functin `make_select(proc1,proc1,selector)` assembles many
- * BaseProcesses, and ProcessSequences into a SwitchProcessSequence,
- * all combinatorics are allowed.
- *
- * \param vA needs to derive from BaseProcess or ProcessSequence
- * \param vB needs to derive from BaseProcess or ProcessSequence
- * \param selector must provide `SwitchResult operator()(const Particle&) const`
+ the functin `make_select(select, proc1, proc1)` assembles many
+ BaseProcesses, and ProcessSequences into a SwitchProcessSequence,
+ all combinatorics are allowed.
+
+ @param selector must provide `bool operator()(Particle const&) const`
+ @param vA needs to derive from BaseProcess or ProcessSequence
+ @param vB needs to derive from BaseProcess or ProcessSequence
**/
- template <typename TProcess1, typename TProcess2, typename 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);
+ template <typename TCondition, typename TSequence, typename USequence,
+ typename = std::enable_if_t<is_process_v<typename std::decay_t<TSequence>> &&
+ is_process_v<typename std::decay_t<USequence>>>>
+ SwitchProcessSequence<TCondition, TSequence, USequence> make_select(
+ TCondition&& selector, TSequence&& vA, USequence&& vB) {
+ return SwitchProcessSequence<TCondition, TSequence, USequence>(selector, vA, vB);
}
//! @}
diff --git a/examples/hybrid_MC.cpp b/examples/hybrid_MC.cpp
index 83ca7bd57098a6af751f430077dffc7414fa31e1..af379ca89bc2a14ccc706e653ca6e3fa25e7d49c 100644
--- a/examples/hybrid_MC.cpp
+++ b/examples/hybrid_MC.cpp
@@ -228,15 +228,12 @@ int main(int argc, char** argv) {
HEPEnergyType cutE_;
EnergySwitch(HEPEnergyType cutE)
: cutE_(cutE) {}
- SwitchResult operator()(const setup::Stack::particle_type& p) {
- if (p.getEnergy() < cutE_)
- return SwitchResult::First;
- else
- return SwitchResult::Second;
+ bool operator()(const setup::Stack::particle_type& p) {
+ return (p.getEnergy() < cutE_);
}
};
- auto hadronSequence = make_select(
- urqmdCounted, make_sequence(sibyllNucCounted, sibyllCounted), EnergySwitch(55_GeV));
+ auto hadronSequence = make_select(EnergySwitch(55_GeV), urqmdCounted,
+ make_sequence(sibyllNucCounted, sibyllCounted));
auto decaySequence = make_sequence(decayPythia, decaySibyll);
auto sequence = make_sequence(hadronSequence, reset_particle_mass, decaySequence, eLoss,
cut, conex_model, longprof, observationLevel);
diff --git a/examples/vertical_EAS.cpp b/examples/vertical_EAS.cpp
index e49030fe3fbff7e5a7ed277036a0707a81d2f359..da6fa0d58679eec3d9cc8d1d33fbbdcd01d22bb7 100644
--- a/examples/vertical_EAS.cpp
+++ b/examples/vertical_EAS.cpp
@@ -306,16 +306,10 @@ int main(int argc, char** argv) {
HEPEnergyType cutE_;
EnergySwitch(HEPEnergyType cutE)
: cutE_(cutE) {}
- SwitchResult operator()(const Particle& p) {
- if (p.getEnergy() < cutE_)
- return SwitchResult::First;
- else
- return SwitchResult::Second;
- }
+ bool operator()(const Particle& p) { return (p.getEnergy() < cutE_); }
};
- auto hadronSequence =
- make_select(urqmdCounted, make_sequence(sibyllNucCounted, sibyllCounted),
- EnergySwitch(55_GeV));
+ auto hadronSequence = make_select(EnergySwitch(55_GeV), urqmdCounted,
+ make_sequence(sibyllNucCounted, sibyllCounted));
auto decaySequence = make_sequence(decayPythia, decaySibyll);
auto sequence =
make_sequence(stackInspect, hadronSequence, reset_particle_mass, decaySequence,
diff --git a/tests/framework/testProcessSequence.cpp b/tests/framework/testProcessSequence.cpp
index e9592eebdfc563ac849587f0d6527992ec8fed23..02105eb9e343f8cf51fc034a3d708b6f88ec2b76 100644
--- a/tests/framework/testProcessSequence.cpp
+++ b/tests/framework/testProcessSequence.cpp
@@ -5,6 +5,7 @@
* Licence version 3 (GPL Version 3). See file LICENSE for a full version of
* the license.
*/
+#define CORSIKA_UNIT_TESTING
#include <corsika/framework/process/ProcessSequence.hpp>
#include <corsika/framework/process/SwitchProcessSequence.hpp>
@@ -359,7 +360,6 @@ TEST_CASE("ProcessSequence General", "ProcessSequence") {
const Process4 m4(3);
CHECK(is_process_v<Process1>);
- CHECK_FALSE(is_process_v<DummyData>);
CHECK(is_process_v<decltype(m4)>);
CHECK(is_process_v<decltype(Decay1(1))>);
CHECK(is_process_v<decltype(ContinuousProcess3{3, 3_m})>);
@@ -379,19 +379,39 @@ TEST_CASE("ProcessSequence General", "ProcessSequence") {
auto sequence1 = make_sequence(m1, m2, m3, m4);
CHECK(is_process_v<decltype(sequence1)>);
CHECK(is_process_v<decltype(m2)>);
- CHECK(is_process_sequence_v<decltype(sequence1)>);
- CHECK_FALSE(is_process_sequence_v<decltype(m2)>);
- CHECK_FALSE(is_switch_process_sequence_v<decltype(sequence1)>);
- CHECK_FALSE(is_switch_process_sequence_v<decltype(m2)>);
+ CHECK(decltype(sequence1)::is_process_sequence);
+ CHECK_FALSE(decltype(m2)::is_process_sequence);
+ CHECK_FALSE(decltype(sequence1)::is_switch_process_sequence);
+ CHECK_FALSE(decltype(m2)::is_switch_process_sequence);
- CHECK_FALSE(is_process_sequence_v<decltype(Decay1(7))>);
- CHECK_FALSE(is_switch_process_sequence_v<decltype(Decay1(7))>);
+ CHECK_FALSE(decltype(Decay1(7))::is_process_sequence);
+ CHECK_FALSE(decltype(Decay1(7))::is_switch_process_sequence);
auto sequence2 = make_sequence(m1, m2, m3);
- CHECK(is_process_sequence_v<decltype(sequence2)> == true);
+ CHECK(decltype(sequence2)::is_process_sequence == true);
auto sequence3 = make_sequence(m4);
- CHECK(is_process_sequence_v<decltype(sequence3)> == true);
+ CHECK(decltype(sequence3)::is_process_sequence == true);
+
+ CHECK(std::is_reference_v<decltype(sequence3.getProcess1())>); // Process4&
+ CHECK(!std::is_reference_v<decltype(sequence3.getProcess2())>); // NullModel
+
+ CHECK(std::is_reference_v<decltype(sequence2.getProcess1())>); // Process1&
+ CHECK(!std::is_reference_v<decltype(sequence2.getProcess2())>); // ProcessSequence
+ CHECK(std::is_reference_v<decltype(
+ sequence2.getProcess2().getProcess1())>); // Process2&
+ CHECK(std::is_reference_v<decltype(
+ sequence2.getProcess2().getProcess2())>); // Process3&
+
+ // and now with rvalue initialization
+
+ auto sequence2_rv = make_sequence(Process1(0), m2, Process3(0));
+ CHECK(!std::is_reference_v<decltype(sequence2_rv.getProcess1())>); // Process1
+ CHECK(!std::is_reference_v<decltype(sequence2_rv.getProcess2())>); // ProcessSequence
+ CHECK(std::is_reference_v<decltype(
+ sequence2_rv.getProcess2().getProcess1())>); // Process2&
+ CHECK(!std::is_reference_v<decltype(
+ sequence2_rv.getProcess2().getProcess2())>); // Process3
}
SECTION("interaction length") {
@@ -508,6 +528,9 @@ TEST_CASE("ProcessSequence General", "ProcessSequence") {
auto sequence1 = make_sequence(s1, s2);
+ std::cout << boost::typeindex::type_id<decltype(sequence1)>().pretty_name()
+ << std::endl;
+
DummyStack stack;
int const nLoop = 20;
@@ -521,8 +544,8 @@ TEST_CASE("ProcessSequence General", "ProcessSequence") {
auto sequence2 = make_sequence(cp2, m2);
auto sequence3 = make_sequence(cp2, m2, s1);
- CHECK(is_process_sequence_v<decltype(sequence2)> == true);
- CHECK(is_process_sequence_v<decltype(sequence3)> == true);
+ CHECK(decltype(sequence2)::is_process_sequence == true);
+ CHECK(decltype(sequence3)::is_process_sequence == true);
CHECK(contains_stack_process_v<decltype(sequence2)> == false);
CHECK(contains_stack_process_v<decltype(sequence3)> == true);
}
@@ -548,7 +571,7 @@ TEST_CASE("ProcessSequence General", "ProcessSequence") {
CHECK(particle.data_[i] == Approx(nLoop).margin(1e-9));
}
- CHECK(is_process_sequence_v<decltype(sequence1)> == true);
+ CHECK(decltype(sequence1)::is_process_sequence == true);
CHECK(contains_stack_process_v<decltype(sequence1)> == false);
CHECK(count_processes<decltype(sequence1)>::count == 1);
}
@@ -565,10 +588,7 @@ TEST_CASE("SwitchProcessSequence", "ProcessSequence") {
*/
struct SwitchSelect {
- SwitchResult operator()(DummyData const& p) const {
- if (p.data_[0] > 0) return SwitchResult::First;
- return SwitchResult::Second;
- }
+ bool operator()(DummyData const& p) const { return (p.data_[0] > 0); }
};
SwitchSelect select1;
@@ -580,40 +600,44 @@ TEST_CASE("SwitchProcessSequence", "ProcessSequence") {
auto sequence2 = make_sequence(cp3, Process2(0), Boundary1(-1.0), Decay2(0));
auto sequence3 = make_sequence(cp1, Process3(0),
- SwitchProcessSequence(sequence1, sequence2, select1));
+ SwitchProcessSequence(select1, sequence1, sequence2));
auto sequence4 =
make_sequence(cp1, Boundary1(2.0), Process3(0),
- SwitchProcessSequence(sequence1, Boundary1(-1.0), select1));
+ SwitchProcessSequence(select1, sequence1, Boundary1(-1.0)));
SECTION("Check construction") {
- auto sequence_alt = make_sequence(
- cp1, Process3(0),
- make_select(make_sequence(Process1(0), cp2, Decay1(0), Boundary1(1.0)),
- make_sequence(cp3, Process2(0), Boundary1(-1.0), Decay2(0)),
- select1));
+ auto switch_seq = make_select(select1, sequence1, sequence2);
+ CHECK(decltype(switch_seq)::is_process_sequence);
+ CHECK(decltype(switch_seq)::is_switch_process_sequence);
+ CHECK(decltype(SwitchProcessSequence(select1, sequence1,
+ sequence2))::is_switch_process_sequence);
+
+ CHECK(decltype(sequence3)::is_process_sequence);
+ CHECK_FALSE(decltype(sequence3)::is_switch_process_sequence);
- auto switch_seq = SwitchProcessSequence(sequence1, sequence2, select1);
- CHECK(is_process_sequence_v<decltype(switch_seq)>);
- CHECK(is_switch_process_sequence_v<decltype(switch_seq)>);
- // CHECK(is_switch_process_sequence_v<decltype(&switch_seq)>);
- CHECK(is_switch_process_sequence_v<decltype(
- SwitchProcessSequence(sequence1, sequence2, select1))>);
+ auto sps1 = SwitchProcessSequence(select1, sequence1, sequence2);
+ CHECK(decltype(sps1)::is_process_sequence);
+ CHECK(decltype(sps1)::is_switch_process_sequence);
+
+ std::cout << boost::typeindex::type_id<decltype(sequence3)>().pretty_name()
+ << std::endl;
- CHECK(is_process_sequence_v<decltype(sequence3)>);
- CHECK_FALSE(is_switch_process_sequence_v<decltype(sequence3)>);
+ CHECK(decltype(sequence3)::is_process_sequence);
+ auto sps2 = SwitchProcessSequence(select1, sequence1, sequence2);
+ CHECK(decltype(sps2)::is_process_sequence);
- CHECK(is_process_sequence_v<decltype(
- SwitchProcessSequence(sequence1, sequence2, select1))>);
- CHECK(is_switch_process_sequence_v<decltype(
- SwitchProcessSequence(sequence1, sequence2, select1))>);
+ CHECK(std::is_reference_v<decltype(switch_seq.getCondition())>); //
+ CHECK(std::is_reference_v<decltype(switch_seq.getSequence())>); //
+ CHECK(std::is_reference_v<decltype(switch_seq.getAltSequence())>); //
- // check that same process sequence can be build in different ways
- CHECK(typeid(sequence3) == typeid(sequence_alt));
- CHECK(is_process_sequence_v<decltype(sequence3)>);
- CHECK(is_process_sequence_v<decltype(
- SwitchProcessSequence(sequence1, sequence2, select1))>);
+ // check with rvalue init
+ auto switch_seq_rv =
+ make_select(SwitchSelect(), make_sequence(Process1(0)), Process3(0));
+ CHECK(!std::is_reference_v<decltype(switch_seq_rv.getCondition())>);
+ CHECK(!std::is_reference_v<decltype(switch_seq_rv.getSequence())>);
+ CHECK(!std::is_reference_v<decltype(switch_seq_rv.getAltSequence())>);
}
SECTION("Check interfaces") {
@@ -863,10 +887,9 @@ TEST_CASE("ProcessSequence Indexing", "ProcessSequence") {
std::cout << count_processes<Process3>::count << std::endl;
struct SwitchSelect {
- SwitchResult operator()(DummyData const& p) const {
+ bool operator()(DummyData const& p) const {
std::cout << "SwitchSelect data=" << p.data_[0] << std::endl;
- if (p.data_[0] > 0) return SwitchResult::First;
- return SwitchResult::Second;
+ return (p.data_[0] > 0);
}
};
@@ -875,11 +898,11 @@ TEST_CASE("ProcessSequence Indexing", "ProcessSequence") {
ContinuousProcess1(0, 1_m));
SwitchSelect select1;
- auto switch_seq = SwitchProcessSequence(sequence1, sequence2, select1);
+ auto switch_seq = SwitchProcessSequence(select1, sequence1, sequence2);
auto sequence3 = make_sequence(ContinuousProcess1(0, 1_m), Process3(0), switch_seq);
auto sequence4 = make_sequence(ContinuousProcess1(0, 1_m), Process3(0),
- SwitchProcessSequence(sequence1, sequence2, select1));
+ SwitchProcessSequence(select1, sequence1, sequence2));
int const switch_seq_n = count_processes<decltype(switch_seq)>::count;
int const sequence3_n = count_processes<decltype(sequence3)>::count;