ParticleCut.hpp

/*
 * (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 <unordered_map>

#include <corsika/framework/core/ParticleProperties.hpp>
#include <corsika/framework/core/PhysicalUnits.hpp>
#include <corsika/framework/process/SecondariesProcess.hpp>
#include <corsika/framework/process/ContinuousProcess.hpp>

namespace corsika {
  class ParticleCut : public SecondariesProcess<ParticleCut>,
                      public ContinuousProcess<ParticleCut> {

  public:
    ParticleCut(HEPEnergyType const eEleCut, HEPEnergyType const ePhoCut,
                HEPEnergyType const eHadCut, HEPEnergyType const eMuCut, bool const inv);

    ParticleCut(HEPEnergyType const eHadCut, HEPEnergyType const euCut, bool const inv);

    ParticleCut(HEPEnergyType const eCut, bool const em, bool const inv);

    ParticleCut(std::unordered_map<Code const, HEPEnergyType const> const& eCuts,
                bool const em, bool const inv);

    template <typename TStackView>
    void doSecondaries(TStackView&);

    template <typename TParticle, typename TTrajectory>
    ProcessReturn doContinuous(
        TParticle& vParticle, TTrajectory const& vTrajectory,
        const bool limitFlag = false); // this is not used for ParticleCut

    template <typename TParticle, typename TTrajectory>
    LengthType getMaxStepLength(TParticle const&, TTrajectory const&) {
      return meter * std::numeric_limits<double>::infinity();
    }

    void printThresholds();
    void showResults(); // LCOV_EXCL_LINE
    void reset();

    HEPEnergyType getElectronKineticECut() const {
      return get_kinetic_energy_threshold(Code::Electron);
    }
    HEPEnergyType getPhotonKineticECut() const {
      return get_kinetic_energy_threshold(Code::Photon);
    }
    HEPEnergyType getMuonKineticECut() const {
      return get_kinetic_energy_threshold(Code::MuPlus);
    }
    HEPEnergyType getHadronKineticECut() const {
      return get_kinetic_energy_threshold(Code::Proton);
    }
    HEPEnergyType getInvEnergy() const { return energy_invcut_; }
    HEPEnergyType getTimeCutEnergy() const { return energy_timecut_; }
    HEPEnergyType getCutEnergy() const { return energy_cut_; }
    HEPEnergyType getEmEnergy() const { return energy_emcut_; }
    unsigned int getNumberEmParticles() const { return em_count_; }
    unsigned int getNumberInvParticles() const { return inv_count_; }

  private:
    template <typename TParticle>
    bool checkCutParticle(TParticle const& p);

    template <typename TParticle>
    bool isBelowEnergyCut(TParticle const&) const;

    bool isInvisible(Code const&) const;

  private:
    bool doCutEm_;
    bool doCutInv_;
    HEPEnergyType energy_cut_ = 0 * electronvolt;
    HEPEnergyType energy_timecut_ = 0 * electronvolt;
    HEPEnergyType energy_emcut_ = 0 * electronvolt;
    HEPEnergyType energy_invcut_ = 0 * electronvolt;
    unsigned int em_count_ = 0;
    unsigned int inv_count_ = 0;
    unsigned int energy_count_ = 0;

    HEPEnergyType energy_event_; // per event sum
  };

} // namespace corsika

#include <corsika/detail/modules/ParticleCut.inl>