Programmable.H

Go to the documentation of this file.

/* Copyright 2022-2026 The Regents of the University of California, through Lawrence
 *           Berkeley National Laboratory (subject to receipt of any required
 *           approvals from the U.S. Dept. of Energy). All rights reserved.
 *
 * This file is part of ImpactX.
 *
 * Authors: Axel Huebl
 * License: BSD-3-Clause-LBNL
 */
#ifndef IMPACTX_ELEMENTS_PROGRAMMABLE_H
#define IMPACTX_ELEMENTS_PROGRAMMABLE_H
 
#include "particles/ImpactXParticleContainer.H"
#include "particles/CovarianceMatrix.H"
#include "mixin/lineartransport.H"
#include "mixin/named.H"
#include "mixin/thick.H"
 
#include <AMReX_Extension.H>
#include <AMReX_REAL.H>
// TODO: #include <AMReX_SIMD.H>
//   SIMD will require better complex math support in vir-simd / C++26
//   https://github.com/mattkretz/vir-simd/issues/42
 
#include <functional>
#include <stdexcept>
 
namespace impactx::elements
{
    struct Programmable
    : public mixin::Named,
      public mixin::LinearTransport<Programmable, false>
      // TODO: public amrex::simd::Vectorized<amrex::simd::native_simd_size_particlereal>
    {
        static constexpr auto type = "Programmable";
        using PType = ImpactXParticleContainer::ParticleType;
 
        static constexpr amrex::ParticleReal DEFAULT_ds = 0;
        static constexpr int DEFAULT_nslice = mixin::Thick::DEFAULT_nslice;

        Programmable (
            amrex::ParticleReal ds = DEFAULT_ds,
            int nslice = DEFAULT_nslice,
            std::optional<std::string> name = DEFAULT_name
        )
          : Named(std::move(name)), m_ds(ds), m_nslice(nslice)
        {}

        void reverse ()
        {
            throw std::runtime_error("Programmable: reverse() is not supported.");
        }

        void operator() (
            ImpactXParticleContainer & pc,
            int step,
            int period
        ) const;

        void operator() (
            ImpactXParticleContainer::iterator & pti,
            RefPart & ref_part,
            [[maybe_unused]] bool spin
        ) const;

        void operator() (
            RefPart & refpart
        ) const;

        using LinearTransport::operator();

        AMREX_GPU_HOST AMREX_FORCE_INLINE
        Map6x6
        transport_map ([[maybe_unused]] RefPart const & AMREX_RESTRICT refpart) const
        {
            // TODO: can/should we fuse the two elements?
            throw std::runtime_error("The Programmable element cannot be used for linear transport maps. Use the LinearMap element instead.");
 
            return Map6x6::Identity();
        }

        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        int nslice () const
        {
            return m_nslice;
        }

        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        amrex::ParticleReal ds () const
        {
            return m_ds;
        }

        void
        finalize ();
 
        amrex::ParticleReal m_ds = 0.0;  
        int m_nslice = DEFAULT_nslice;  

        bool m_threadsafe = false;
 
        std::function<void(ImpactXParticleContainer *, int, int)> m_push;  
        std::function<void(ImpactXParticleContainer::iterator *, RefPart &)> m_beam_particles;  
        std::function<void(RefPart &)> m_ref_particle;  
        std::function<void()> m_finalize;  
    };
 
} // namespace impactx
 
#endif // IMPACTX_ELEMENTS_PROGRAMMABLE_H