SwitchProcessSequence.hpp

Go to the documentation of this file.

/*
 * (c) Copyright 2018 CORSIKA Project, corsika-project@lists.kit.edu
 *
 * This software is distributed under the terms of the GNU General Public
 * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
 * the license.
 */

#pragma once

#include <corsika/framework/process/BaseProcess.hpp>
#include <corsika/framework/process/ProcessTraits.hpp>
#include <corsika/framework/process/BoundaryCrossingProcess.hpp>
#include <corsika/framework/process/ContinuousProcess.hpp>
#include <corsika/framework/process/ContinuousProcessIndex.hpp>
#include <corsika/framework/process/ContinuousProcessStepLength.hpp>
#include <corsika/framework/process/DecayProcess.hpp>
#include <corsika/framework/process/InteractionProcess.hpp>
#include <corsika/framework/process/ProcessReturn.hpp>
#include <corsika/framework/process/SecondariesProcess.hpp>
#include <corsika/framework/process/StackProcess.hpp>
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/core/Step.hpp>
#include <corsika/framework/geometry/FourVector.hpp>

#include <cmath>
#include <limits>
#include <type_traits>

namespace corsika {

  template <typename TCondition, typename TSequence, typename USequence,
            int IndexFirstProcess = 0,
            int IndexOfProcess1 = count_processes<TSequence, IndexFirstProcess>::count,
            int IndexOfProcess2 = count_processes<USequence, IndexOfProcess1>::count>
  class SwitchProcessSequence
      : public BaseProcess<SwitchProcessSequence<TCondition, TSequence, USequence>> {

    using process1_type = typename std::decay_t<TSequence>;
    using process2_type = typename std::decay_t<USequence>;

    // 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");
    static_assert(is_process_v<process2_type>,
                  "can only use process derived from BaseProcess in "
                  "SwitchProcessSequence, for Process 2");

    // 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 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 "
                  "ProcessSequence 1");
    static_assert(!contains_stack_process_v<process2_type>,
                  "cannot use StackProcess in SwitchProcessSequence, remove from "
                  "ProcessSequence 2");

  public:
    // resource management
    SwitchProcessSequence() = delete; // only initialized objects
    SwitchProcessSequence(SwitchProcessSequence const&) = default;
    SwitchProcessSequence(SwitchProcessSequence&&) = default;
    SwitchProcessSequence& operator=(SwitchProcessSequence const&) = default;
    ~SwitchProcessSequence() = default;

    static bool const is_process_sequence = true;
    static bool const is_switch_process_sequence = true;

    SwitchProcessSequence(TCondition sel, TSequence in_A, USequence in_B)
        : select_(sel)
        , A_(in_A)
        , B_(in_B) {}

    template <typename TParticle>
    ProcessReturn doBoundaryCrossing(TParticle& particle,
                                     typename TParticle::node_type const& from,
                                     typename TParticle::node_type const& to);

    template <typename TParticle>
    ProcessReturn doContinuous(Step<TParticle>& particle,
                               ContinuousProcessIndex const limitId);

    template <typename TSecondaries>
    void doSecondaries(TSecondaries& vS);

    template <typename TParticle, typename TTrack>
    ContinuousProcessStepLength getMaxStepLength(TParticle& particle, TTrack& vTrack);

    template <typename TParticle>
    CrossSectionType getCrossSection(TParticle const& projectile, Code const targetId,
                                     FourMomentum const& targetP4) const;

    template <typename TSecondaryView, typename TRNG>
    ProcessReturn selectInteraction(TSecondaryView& view,
                                    FourMomentum const& projectileP4,
                                    NuclearComposition const& composition, TRNG& rng,
                                    CrossSectionType const cx_select,
                                    CrossSectionType cx_sum = CrossSectionType::zero());

    template <typename TParticle>
    TimeType getLifetime(TParticle&& particle) {
      return 1. / getInverseLifetime(particle);
    }

    template <typename TParticle>
    InverseTimeType getInverseLifetime(TParticle&& particle);

    // select decay process
    template <typename TSecondaryView>
    ProcessReturn selectDecay(
        TSecondaryView& view, [[maybe_unused]] InverseTimeType decay_inv_select,
        [[maybe_unused]] InverseTimeType decay_inv_sum = InverseTimeType::zero());

    static size_t 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:
    TCondition select_; 

    TSequence A_; 
    USequence B_; 

    static unsigned int constexpr numberOfProcesses_ = IndexOfProcess2; // static counter
  };

  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);
  }


} // namespace corsika

#include <corsika/detail/framework/process/SwitchProcessSequence.inl>