ProcessSequence.hpp

Go to the documentation of this file.

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

#pragma once

#include <corsika/framework/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/CascadeEquationsProcess.hpp>
#include <corsika/framework/process/ProcessReturn.hpp>
#include <corsika/framework/process/SecondariesProcess.hpp>
#include <corsika/framework/process/StackProcess.hpp>
#include <corsika/framework/process/NullModel.hpp>
#include <corsika/framework/core/Step.hpp>
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/core/ParticleProperties.hpp>

#include <corsika/framework/geometry/FourVector.hpp>

namespace corsika {

  class COMBoost;           // fwd-decl
  class NuclearComposition; // fwd-decl

  template <typename TProcess, int N>
  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 size_t constexpr count = N + std::decay_t<TProcess>::getNumberOfProcesses();
  };

  template <typename TProcess1, typename TProcess2 = NullModel,
            int ProcessIndexOffset = 0,
            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>;

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

    static bool const is_process_sequence = true;

    ProcessSequence(TProcess1 in_A, TProcess2 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>& step,
                               ContinuousProcessIndex const limitID);

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

    bool checkStep();

    template <typename TStack>
    void doStack(TStack& stack);

    template <typename TStack>
    void doCascadeEquations(TStack& stack);

    void initCascadeEquations();

    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 TParticle>
    TimeType getLifetime(TParticle& particle) {
      return 1. / getInverseLifetime(particle);
    }

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

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

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

    static size_t constexpr getNumberOfProcesses() { return numberOfProcesses_; }

#ifdef CORSIKA_UNIT_TESTING
    TProcess1 getProcess1() const { return A_; }
    TProcess2 getProcess2() const { return B_; }
#endif

  private:
    TProcess1 A_; 
    TProcess2 B_; 

    static size_t constexpr numberOfProcesses_ = IndexOfProcess1; // static counter
  };

  template <typename... TProcesses, typename TProcess1>
  ProcessSequence<TProcess1, decltype(make_sequence(std::declval<TProcesses>()...))>
  make_sequence(TProcess1&& vA, TProcesses&&... vBs) {
    return ProcessSequence<TProcess1,
                           decltype(make_sequence(std::declval<TProcesses>()...))>(
        vA, make_sequence(std::forward<TProcesses>(vBs)...));
  }

  template <typename TProcess1, typename TProcess2>
  ProcessSequence<TProcess1, TProcess2> make_sequence(TProcess1&& vA, TProcess2&& vB) {
    return ProcessSequence<TProcess1, TProcess2>(vA, vB);
  }

  template <typename TProcess>
  ProcessSequence<TProcess, NullModel> make_sequence(TProcess&& vA) {
    return ProcessSequence<TProcess, NullModel>(vA, NullModel());
  }

} // namespace corsika

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