Kicker.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: Chad Mitchell, Axel Huebl
 * License: BSD-3-Clause-LBNL
 */
#ifndef IMPACTX_KICKER_H
#define IMPACTX_KICKER_H
 
#include "particles/ImpactXParticleContainer.H"
#include "mixin/alignment.H"
#include "mixin/beamoptic.H"
#include "mixin/thin.H"
#include "mixin/lineartransport.H"
#include "mixin/named.H"
#include "mixin/nofinalize.H"
 
#include <AMReX_Enum.H>
#include <AMReX_Extension.H>
#include <AMReX_REAL.H>
#include <AMReX_SIMD.H>
 
#include <cmath>
#include <stdexcept>
#include <string>
 
namespace impactx::elements
{
    struct Kicker
    : public mixin::Named,
      public mixin::BeamOptic<Kicker>,
      public mixin::LinearTransport<Kicker>,
      public mixin::Thin,
      public mixin::Alignment,
      public mixin::NoFinalize
      // At least on Intel AVX512, there is a small overhead to vectorize this element, see
      // https://github.com/BLAST-ImpactX/impactx/pull/1002
      // public amrex::simd::Vectorized<amrex::simd::native_simd_size_particlereal>
    {
        static constexpr auto type = "Kicker";
        using PType = ImpactXParticleContainer::ParticleType;
 
        AMREX_ENUM_IN_CLASS(UnitSystem,
            dimensionless = 0,  
            Tm = 1,             
        );
 
        static std::string
        unit_name (UnitSystem const & unit)
        {
            return unit == UnitSystem::Tm ? "T-m" : amrex::getEnumNameString(unit);
        }
 
        static UnitSystem
        unit_from_name (std::string const & unit)
        {
            return unit == "T-m" ? UnitSystem::Tm : amrex::getEnum<UnitSystem>(unit);
        }
 
        static constexpr UnitSystem DEFAULT_unit = UnitSystem::dimensionless;

        Kicker (
            amrex::ParticleReal xkick,
            amrex::ParticleReal ykick,
            UnitSystem unit = DEFAULT_unit,
            amrex::ParticleReal dx = DEFAULT_dx,
            amrex::ParticleReal dy = DEFAULT_dy,
            amrex::ParticleReal rotation_degree = DEFAULT_rotation_degree,
            std::optional<std::string> name = DEFAULT_name
        )
        : Named(std::move(name)),
          Alignment(dx, dy, rotation_degree),
          m_xkick(xkick), m_ykick(ykick), m_unit(unit)
        {
        }

        void reverse () { m_xkick = -m_xkick; m_ykick = -m_ykick; }

        using BeamOptic::operator();

        void compute_constants (RefPart const & refpart)
        {
            using namespace amrex::literals; // for _rt and _prt
 
            Alignment::compute_constants(refpart);
 
            // normalize quad units to MAD-X convention if needed
            m_p_scale = m_unit == UnitSystem::Tm ? 1.0_prt / refpart.rigidity_Tm() : 1.0_prt;
        }

        template<typename T_Real=amrex::ParticleReal, typename T_IdCpu=uint64_t>
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        void operator() (
            [[maybe_unused]] T_Real const & AMREX_RESTRICT x,
            [[maybe_unused]] T_Real const & AMREX_RESTRICT y,
            [[maybe_unused]] T_Real const & AMREX_RESTRICT t,
            T_Real & AMREX_RESTRICT px,
            T_Real & AMREX_RESTRICT py,
            [[maybe_unused]] T_Real const & AMREX_RESTRICT pt,
            [[maybe_unused]] T_IdCpu const & AMREX_RESTRICT idcpu,
            [[maybe_unused]] RefPart const & AMREX_RESTRICT refpart
        ) const
        {
            using namespace amrex::literals; // for _rt and _prt
 
            // access position data
            // T_Real const xout = x;
            // T_Real const yout = y;
            // T_Real const tout = t;
 
            // normalize quad units to MAD-X convention if needed
            amrex::ParticleReal const dpx = m_xkick * m_p_scale;
            amrex::ParticleReal const dpy = m_ykick * m_p_scale;
 
            // initialize output values of momenta
            T_Real pxout = px;
            T_Real pyout = py;
            // T_Real ptout = pt;
 
            // advance position and momentum
            // x = xout;
            pxout = px + dpx;
 
            // y = yout;
            pyout = py + dpy;
 
            // t = tout;
            // ptout = pt;
 
            // assign updated momenta
            px = pxout;
            py = pyout;
            // pt = ptout;
        }

        using Thin::operator();

        using LinearTransport::operator();

        AMREX_GPU_HOST AMREX_FORCE_INLINE
        Map6x6
        transport_map ([[maybe_unused]] RefPart const & AMREX_RESTRICT refpart) const
        {
            // an ideal kick does not affect the linear map
            Map6x6 R = Map6x6::Identity();
 
            // apply the transverse rotation (roll) alignment error
            return rotate_aligned_map(R);
        }
 
        amrex::ParticleReal m_xkick; 
        amrex::ParticleReal m_ykick; 
        UnitSystem m_unit; 
 
      private:
        // constants that are independent of the individually tracked particle,
        // see: compute_constants() to refresh
        amrex::ParticleReal m_p_scale;  // either 1 or the inverse rigidity
    };
 
} // namespace impactx
 
IMPACTX_PUSH_EXTERN_TEMPLATE(impactx::elements::Kicker)
 
#endif // IMPACTX_KICKER_H