EIC code displayed by LXR master/​include/​celeritas/​track/​ExtendFromSecondariesAction.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-02-22 10:31:31

 //----------------------------------*-C++-*----------------------------------//
 // Copyright 2023-2024 UT-Battelle, LLC, and other Celeritas developers.
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 //---------------------------------------------------------------------------//
 //! \file celeritas/track/ExtendFromSecondariesAction.hh
 //---------------------------------------------------------------------------//
 #pragma once
 
 #include "celeritas/global/ActionInterface.hh"
 
 namespace celeritas
 {
 //---------------------------------------------------------------------------//
 /*!
  * Create track initializers on device from secondary particles.
  *
  * Secondaries produced by each track are ordered arbitrarily in memory, and
  * the memory may be fragmented if not all secondaries survived cutoffs. For
  * example, after the interactions have been processed and cutoffs applied, the
  * track states and their secondaries might look like the following (where 'X'
  * indicates a track or secondary that did not survive):
  * \verbatim
 
    thread ID   | 0   1 2           3       4   5 6           7       8   9
    track ID    | 10  X 8           7       X   5 4           X       2   1
    secondaries | [X]   [X, 11, 12] [13, X] [X]   [14, X, 15] [X, 16] [X]
 
    \endverbatim
  *
  * Because the order in which threads receive a chunk of memory from the
  * secondary allocator is nondeterministic, the actual ordering of the
  * secondaries in memory is unpredictable; for instance:
  * \verbatim
 
   secondary storage | [X, 13, X, X, 11, 12, X, X, 16, 14, X, 15, X]
 
   \endverbatim
  *
  * When track initializers are created from secondaries, they are ordered by
  * thread ID to ensure reproducibility. If a track that produced secondaries
  * has died (e.g., thread ID 7 in the example above), one of its secondaries is
  * immediately used to fill that track slot:
  * \verbatim
 
    thread ID   | 0   1 2           3       4   5 6           7       8   9
    track ID    | 10  X 8           7       X   5 4           16      2   1
    secondaries | [X]   [X, 11, 12] [13, X] [X]   [14, X, 15] [X, X]  [X]
 
    \endverbatim
  *
  * This way, the geometry state is reused rather than initialized from the
  * position (which is expensive). This also prevents the geometry state from
  * being overwritten by another track's secondary, so if the track produced
  * multiple secondaries, the rest are still able to copy the parent's state.
  *
  * Track initializers are created from the remaining secondaries and are added
  * to the back of the vector. The thread ID of each secondary's parent is also
  * stored, so any new tracks initialized from secondaries produced in this
  * step can copy the geometry state from the parent. The indices of the empty
  * slots in the track vector are identified and stored as a sorted vector of
  * vacancies.
  * \verbatim
 
    track initializers | 11 12 13 14 15
    parent             | 2  2  3  6  6
    vacancies          | 1  4
 
    \endverbatim
  */
 class ExtendFromSecondariesAction final : public CoreStepActionInterface,
                                           public CoreBeginRunActionInterface
 {
   public:
     //! Construct with explicit Id
     explicit ExtendFromSecondariesAction(ActionId id) : id_(id) {}
 
     //!@{
     //! \name Action interface
     //! ID of the action
     ActionId action_id() const final { return id_; }
     //! Short name for the action
     std::string_view label() const final { return "extend-from-secondaries"; }
     // Description of the action for user interaction
     std::string_view description() const final;
     //! Dependency ordering of the action
     StepActionOrder order() const final { return StepActionOrder::end; }
     //!@}
 
     //!@{
     //! \name ExplicitAction interface
     // Launch kernel with host data
     void step(CoreParams const&, CoreStateHost&) const final;
     // Launch kernel with device data
     void step(CoreParams const&, CoreStateDevice&) const final;
     //!@}
 
     //!@{
     //! \name BeginRunAction interface
     // No action necessary for host data
     void begin_run(CoreParams const&, CoreStateHost&) final {}
     // Warm up asynchronous allocation at beginning of run
     void begin_run(CoreParams const&, CoreStateDevice&) final;
     //!@}
 
   private:
     ActionId id_;
 
     template<MemSpace M>
     void step_impl(CoreParams const&, CoreState<M>&) const;
 
     void locate_alive(CoreParams const&, CoreStateHost&) const;
     void locate_alive(CoreParams const&, CoreStateDevice&) const;
 
     void process_secondaries(CoreParams const&, CoreStateHost&) const;
     void process_secondaries(CoreParams const&, CoreStateDevice&) const;
 };
 
 //---------------------------------------------------------------------------//
 }  // namespace celeritas

This page was automatically generated by the 2.3.7 LXR engine. The LXR team