ImageChargeScatterController.h

Go to the documentation of this file.

#ifndef OPALX_IMAGE_CHARGE_SCATTER_CONTROLLER_H
#define OPALX_IMAGE_CHARGE_SCATTER_CONTROLLER_H
 
#include "Interpolation/CIC.h"
#include "Ippl.h"
#include "PartBunch/Binning/AdaptBins.h"
#include "PartBunch/ParticleContainer.hpp"
 
#include <utility>
#include <vector>
 
template <typename T, unsigned Dim>
class ImageChargeScatterController {
    static_assert(Dim == 3, "ImageChargeScatterController currently supports Dim == 3 only.");
 
public:
    using ParticleCtr_t  = ParticleContainer<T, Dim>;
    using PositionAttr_t = typename ippl::ParticleBase<
            ippl::ParticleSpatialLayout<T, Dim>,
            Kokkos::DefaultExecutionSpace::memory_space>::particle_position_type;
    using RhoField_t  = Field_t<Dim>;
    using BinPolicy_t = Kokkos::RangePolicy<>;
    using Hash_t      = typename ParticleBinning::AdaptBinsBase<ParticleCtr_t>::hash_type;
 
public:
    ImageChargeScatterController() = default;
 
    ImageChargeScatterController(bool enabled, double zPlane)
        : enabled_m(enabled), zPlane_m(zPlane) {}
 
    void configure(bool enabled, double zPlane) {
        enabled_m = enabled;
        zPlane_m  = zPlane;
    }
 
    bool isEnabled() const { return enabled_m; }
    double getZPlane() const { return zPlane_m; }
 
    void scatterPrimaryAndImage(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho) const;
 
    void scatterPrimaryAndImage(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho,
            const BinPolicy_t& policy, const Hash_t& hash) const;
 
    void scatterPrimaryOnly(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho) const;
 
    void scatterPrimaryOnly(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho,
            const BinPolicy_t& policy, const Hash_t& hash) const;
 
    void scatterImageOnly(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho) const;
 
    void scatterImageOnly(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho,
            const BinPolicy_t& policy, const Hash_t& hash) const;
 
    // ==== All of the following functions could be private, but need to be public for device
    // compilation ====
 
    void scatterScaledDtAll(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho) const;
 
    void scatterScaledDtSubset(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, RhoField_t& rho,
            const BinPolicy_t& policy, const Hash_t& hash) const;
 
    void accumulateScalarHaloHostStaged(RhoField_t& rho) const;
 
    void applyMirrorTransformAll(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions) const;
 
    void restoreMirrorTransformAll(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions) const;
 
    void applyMirrorTransformSubset(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, const BinPolicy_t& policy,
            const Hash_t& hash) const;
 
    void restoreMirrorTransformSubset(
            std::shared_ptr<ParticleCtr_t> pc, PositionAttr_t& positions, const BinPolicy_t& policy,
            const Hash_t& hash) const;
 
    void flipChargeSignAll(std::shared_ptr<ParticleCtr_t> pc) const;
 
    void flipChargeSignSubset(
            std::shared_ptr<ParticleCtr_t> pc, const BinPolicy_t& policy, const Hash_t& hash) const;
 
private:
    bool enabled_m  = false;
    double zPlane_m = 0.0;
};
 
#include "PartBunch/ImageChargeScatterController.tpp"
 
#endif