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

namespace corsika {

  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 unsigned int 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, typename TTrack>
    ProcessReturn doContinuous(TParticle& particle, TTrack& vT,
                               ContinuousProcessIndex const limitID);

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

    bool checkStep();

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

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

    template <typename TParticle>
    GrammageType getInteractionLength(TParticle&& particle) {
      return 1. / getInverseInteractionLength(particle);
    }

    template <typename TParticle>
    InverseGrammageType getInverseInteractionLength(TParticle&& particle);

    template <typename TSecondaryView>
    ProcessReturn selectInteraction(
        TSecondaryView& view, [[maybe_unused]] InverseGrammageType lambda_inv_select,
        [[maybe_unused]] InverseGrammageType lambda_inv_sum =
            InverseGrammageType::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 unsigned int 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 unsigned int 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>