PhysicalParticleContainer.H

Go to the documentation of this file.

/* Copyright 2019-2020 Andrew Myers, Axel Huebl, David Grote
 * Ligia Diana Amorim, Luca Fedeli, Maxence Thevenet
 * Remi Lehe, Revathi Jambunathan, Weiqun Zhang
 * Yinjian Zhao
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef WARPX_PhysicalParticleContainer_H_
#define WARPX_PhysicalParticleContainer_H_
 
#include "Initialization/PlasmaInjector.H"
#include "Particles/ElementaryProcess/Ionization.H"
#ifdef WARPX_QED
#    include "Particles/ElementaryProcess/QEDPairGeneration.H"
#    include "Particles/ElementaryProcess/QEDPhotonEmission.H"
#    include "Particles/ElementaryProcess/QEDInternals/QuantumSyncEngineWrapper_fwd.H"
#    include "Particles/ElementaryProcess/QEDInternals/BreitWheelerEngineWrapper_fwd.H"
#endif
#include "Particles/Gather/ScaleFields.H"
#include "Particles/Resampling/Resampling.H"
#include "WarpXParticleContainer.H"
#include "Particles/Deposition/TemperatureDepositionTypes.H"
#include "Utils/WarpXAlgorithmSelection.H"
 
#include "FieldSolver/ImplicitSolvers/ImplicitOptions.H"
 
#include <AMReX_GpuContainers.H>
#include <AMReX_Particles.H>
#include <AMReX_REAL.H>
#include <AMReX_RealBox.H>
 
#include <AMReX_BaseFwd.H>
#include <AMReX_AmrCoreFwd.H>
 
#include <memory>
#include <string>

class PhysicalParticleContainer
    : public WarpXParticleContainer
{
public:
 
    PhysicalParticleContainer (amrex::AmrCore* amr_core,
                               int ispecies,
                               const std::string& name);
 
    PhysicalParticleContainer (amrex::AmrCore* amr_core);

    void BackwardCompatibility ();
 
    ~PhysicalParticleContainer () override = default;
 
    PhysicalParticleContainer (PhysicalParticleContainer const &)              = delete;
    PhysicalParticleContainer& operator= (PhysicalParticleContainer const & )  = delete;
    PhysicalParticleContainer(PhysicalParticleContainer&& )                    = default;
    PhysicalParticleContainer& operator=(PhysicalParticleContainer&& )         = default;
 
    virtual void AllocData () override;
 
    void InitData () override;
 
    void ReadHeader (std::istream& is) override;
 
    void WriteHeader (std::ostream& os) const override;
 
    void InitIonizationModule () override;
 
    /*
     * \brief Returns a pointer to the i'th plasma injector.
     */
    PlasmaInjector* GetPlasmaInjector (int i) override;

    void Evolve (ablastr::fields::MultiFabRegister& fields,
                 int lev,
                 const std::string& current_fp_string,
                 amrex::Real t,
                 amrex::Real dt,
                 SubcyclingHalf subcycling_half=SubcyclingHalf::None,
                 bool skip_deposition=false,
                 ImplicitOptions const * implicit_options = nullptr) override;
 
    virtual void PushPX (WarpXParIter& pti,
                         amrex::FArrayBox const * exfab,
                         amrex::FArrayBox const * eyfab,
                         amrex::FArrayBox const * ezfab,
                         amrex::FArrayBox const * bxfab,
                         amrex::FArrayBox const * byfab,
                         amrex::FArrayBox const * bzfab,
                         amrex::IntVect ngEB, int /*e_is_nodal*/,
                         long offset,
                         long np_to_push,
                         int lev, int gather_lev,
                         amrex::Real dt, ScaleFields scaleFields,
                         SubcyclingHalf subcycling_half=SubcyclingHalf::None);
 
    void FindSuborbitParticles (WarpXParIter& pti,
                         long offset,
                         long np_to_push,
                         long & num_unconverged_particles,
                         amrex::Gpu::DeviceVector<long> & unconverged_indices,
                         amrex::Gpu::DeviceVector<amrex::ParticleReal> & saved_weights);
 
    void SetupSuborbitParticles (WarpXParIter& pti,
                         long offset,
                         long np_to_push,
                         long num_unconverged_particles,
                         amrex::Gpu::DeviceVector<long> & unconverged_indices,
                         amrex::Gpu::DeviceVector<amrex::ParticleReal> & saved_weights);
 
    void ImplicitPushXP (WarpXParIter& pti,
                         amrex::FArrayBox const * exfab,
                         amrex::FArrayBox const * eyfab,
                         amrex::FArrayBox const * ezfab,
                         amrex::FArrayBox const * bxfab,
                         amrex::FArrayBox const * byfab,
                         amrex::FArrayBox const * bzfab,
                         ImplicitOptions const * implicit_options,
                         amrex::IntVect const & ngEB,
                         long offset,
                         long np_to_push,
                         int lev, int gather_lev,
                         amrex::Real dt,
                         long & num_unconverged_particles,
                         amrex::Gpu::DeviceVector<long> & unconverged_indices,
                         amrex::Gpu::DeviceVector<amrex::ParticleReal> & saved_weights);
 
    void ImplicitPushXPSubOrbits (WarpXParIter& pti,
                                  ablastr::fields::MultiFabRegister& fields,
                                  amrex::FArrayBox const * exfab,
                                  amrex::FArrayBox const * eyfab,
                                  amrex::FArrayBox const * ezfab,
                                  amrex::FArrayBox const * bxfab,
                                  amrex::FArrayBox const * byfab,
                                  amrex::FArrayBox const * bzfab,
                                  ImplicitOptions const * implicit_options,
                                  amrex::IntVect ngEB,
                                  amrex::MultiFab * const jx,
                                  amrex::MultiFab * const jy,
                                  amrex::MultiFab * const jz,
                                  long offset,
                                  int lev, int gather_lev,
                                  amrex::Real dt,
                                  bool skip_deposition,
                                  long num_unconverged_particles,
                                  amrex::Gpu::DeviceVector<long> & unconverged_indices,
                                  amrex::Gpu::DeviceVector<amrex::ParticleReal> & saved_weights);
 
    void PushP (int lev, amrex::Real dt,
                        const amrex::MultiFab& Ex,
                        const amrex::MultiFab& Ey,
                        const amrex::MultiFab& Ez,
                        const amrex::MultiFab& Bx,
                        const amrex::MultiFab& By,
                        const amrex::MultiFab& Bz) override;
 
    void PartitionParticlesInBuffers (
                        long& nfine_current,
                        long& nfine_gather,
                        long np,
                        WarpXParIter& pti,
                        int lev,
                        int n_field_gather_buffer,
                        int n_current_deposition_buffer,
                        amrex::iMultiFab const* current_masks,
                        amrex::iMultiFab const* gather_masks );
 
    void PostRestart () final {}
 
    void SplitParticles (int lev);
 
    IonizationFilterFunc getIonizationFunc (const WarpXParIter& pti,
                                            int lev,
                                            amrex::IntVect ngEB,
                                            const amrex::FArrayBox& Ex,
                                            const amrex::FArrayBox& Ey,
                                            const amrex::FArrayBox& Ez,
                                            const amrex::FArrayBox& Bx,
                                            const amrex::FArrayBox& By,
                                            const amrex::FArrayBox& Bz);
 
    // Inject particles in Box 'part_box'
    virtual void AddParticles (int lev);

    void AddPlasma (PlasmaInjector const& plasma_injector, int lev, amrex::RealBox part_realbox = amrex::RealBox());

    void AddPlasmaFlux (PlasmaInjector const& plasma_injector, amrex::Real dt);
 
    void MapParticletoBoostedFrame (amrex::ParticleReal& x, amrex::ParticleReal& y, amrex::ParticleReal& z,
                                    amrex::ParticleReal& ux, amrex::ParticleReal& uy, amrex::ParticleReal& uz,
                                    amrex::Real t_lab = 0.) const;
 
    void AddGaussianBeam (PlasmaInjector const& plasma_injector);

    void AddPlasmaFromFile (PlasmaInjector & plasma_injector,
                            amrex::ParticleReal q_tot,
                            amrex::ParticleReal z_shift);
 
    void CheckAndAddParticle (
        amrex::ParticleReal x, amrex::ParticleReal y, amrex::ParticleReal z,
        amrex::ParticleReal ux, amrex::ParticleReal uy, amrex::ParticleReal uz,
        amrex::ParticleReal weight,
        amrex::Gpu::HostVector<amrex::ParticleReal>& particle_x,
        amrex::Gpu::HostVector<amrex::ParticleReal>& particle_y,
        amrex::Gpu::HostVector<amrex::ParticleReal>& particle_z,
        amrex::Gpu::HostVector<amrex::ParticleReal>& particle_ux,
        amrex::Gpu::HostVector<amrex::ParticleReal>& particle_uy,
        amrex::Gpu::HostVector<amrex::ParticleReal>& particle_uz,
        amrex::Gpu::HostVector<amrex::ParticleReal>& particle_w,
        amrex::Real t_lab= 0.) const;

    void DefaultInitializeRuntimeAttributes (
        typename ContainerLike<amrex::PinnedArenaAllocator>::ParticleTileType& pinned_tile,
        int n_external_attr_real,
        int n_external_attr_int) final;

    void applyNCIFilter (
        int lev, const amrex::Box& box,
        amrex::Elixir& exeli, amrex::Elixir& eyeli, amrex::Elixir& ezeli,
        amrex::Elixir& bxeli, amrex::Elixir& byeli, amrex::Elixir& bzeli,
        amrex::FArrayBox& filtered_Ex, amrex::FArrayBox& filtered_Ey,
        amrex::FArrayBox& filtered_Ez, amrex::FArrayBox& filtered_Bx,
        amrex::FArrayBox& filtered_By, amrex::FArrayBox& filtered_Bz,
        const amrex::FArrayBox& Ex, const amrex::FArrayBox& Ey,
        const amrex::FArrayBox& Ez, const amrex::FArrayBox& Bx,
        const amrex::FArrayBox& By, const amrex::FArrayBox& Bz,
        amrex::FArrayBox const * & ex_ptr, amrex::FArrayBox const * & ey_ptr,
        amrex::FArrayBox const * & ez_ptr, amrex::FArrayBox const * & bx_ptr,
        amrex::FArrayBox const * & by_ptr, amrex::FArrayBox const * & bz_ptr);

    void resample (
        const amrex::Vector<amrex::Geometry>& geom, int timestep, bool verbose=true) final;
 
#ifdef WARPX_QED
    //Functions decleared in WarpXParticleContainer.H
    //containers for which QED processes could be relevant
    //are expected to override these functions

    bool has_quantum_sync () const override;

    bool has_breit_wheeler () const override;

    void set_breit_wheeler_engine_ptr
        (const std::shared_ptr<BreitWheelerEngine>& ptr) override;

    void set_quantum_sync_engine_ptr
        (const std::shared_ptr<QuantumSynchrotronEngine>& ptr) override;
    //__________
 
    BreitWheelerEngine* get_breit_wheeler_engine_ptr () const override {
        return m_shr_p_bw_engine.get();
    }
 
    QuantumSynchrotronEngine* get_quantum_sync_engine_ptr () const override {
        return m_shr_p_qs_engine.get();
    }
 
    PhotonEmissionFilterFunc getPhotonEmissionFilterFunc ();
 
    PairGenerationFilterFunc getPairGenerationFilterFunc ();
#endif
 
    std::vector<std::string> getUserIntAttribs () const override {
        return m_user_int_attribs;
    }
 
    std::vector<std::string> getUserRealAttribs () const override {
        return m_user_real_attribs;
    }
 
    amrex::Vector< amrex::Parser* > getUserIntAttribParser () const override {
        return GetVecOfPtrs(m_user_int_attrib_parser);
    }
 
    amrex::Vector< amrex::Parser* > getUserRealAttribParser () const override {
        return GetVecOfPtrs(m_user_real_attrib_parser);
    }
 
    // By default this returns false; overridden here to return runtime value
    virtual bool getTemperatureDepositionFlag () const noexcept override {return m_do_temperature_deposition;}
 
    virtual void AccumulateVelocitiesAndComputeTemperature (
        ablastr::fields::MultiLevelVectorField const & T_vf,
        amrex::Real relative_time) override;
 
    virtual void DepositTemperature (
        WarpXParIter& pti,
        RealVector const & wp, RealVector const & uxp,
        RealVector const & uyp, RealVector const & uzp,
        amrex::MultiFab * const Tx, amrex::MultiFab * const Ty, amrex::MultiFab * const Tz,
        long const offset, long const np_to_deposit,
        int const thread_num, const int lev, int const depos_lev,
        amrex::Real const relative_time, PushType push_type,
        const warpx::particles::deposition::TemperatureDepositionType type,
        const warpx::particles::deposition::TemperatureDepositionPass pass) override;
 
protected:
 
    /*
       Finds the box defining the region where refine injection should be used, if that
       option is enabled. Currently this only works for numLevels() == 2 and static mesh
       refinement.
    */
    bool findRefinedInjectionBox (amrex::Box& fine_injection_box, amrex::IntVect& rrfac);
 
    std::string species_name;
    std::vector<std::unique_ptr<PlasmaInjector>> plasma_injectors;
 
    // When true, adjust the transverse particle positions accounting
    // for the difference between the Lorentz transformed time of the
    // particle and the time of the boosted frame.
    bool boost_adjust_transverse_positions = false;
    bool do_backward_propagation = false;
    bool m_rz_random_theta = true;
 
    // Impose t_lab from the openPMD file for externally loaded species
    bool impose_t_lab_from_file = false;
 
    Resampling m_resampler;
 
    // Inject particles during the whole simulation
    void ContinuousInjection (const amrex::RealBox& injection_box) override;
 
    // Continuously inject a flux of particles from a defined surface
    void ContinuousFluxInjection (amrex::Real t, amrex::Real dt) override;
 
    //This function return true if the PhysicalParticleContainer contains electrons
    //or positrons, false otherwise
 
    //When true PhysicalParticleContainer tries to use a pusher including
    //radiation reaction
    bool do_classical_radiation_reaction = false;
 
    // A flag to enable saving of the previous timestep positions
    bool m_save_previous_position = false;
 
    // Flag controlling whether or not variance and then temperatures are computed per species
    bool m_do_temperature_deposition = false;
 
    std::unique_ptr<warpx::particles::deposition::VarianceAccumulationBuffer> local_temperature_arrays;
 
#ifdef WARPX_QED
    // A flag to enable quantum_synchrotron process for leptons
    bool m_do_qed_quantum_sync = false;
 
    // A flag to enable breit_wheeler process [photons only!!]
    bool m_do_qed_breit_wheeler = false;
 
    // A smart pointer to an instance of a Quantum Synchrotron engine
    std::shared_ptr<QuantumSynchrotronEngine> m_shr_p_qs_engine;
 
    // A smart pointer to an instance of a Breit Wheeler engine [photons only!]
    std::shared_ptr<BreitWheelerEngine> m_shr_p_bw_engine;
#endif
    /* Vector of user-defined integer attributes for species, species_name */
    std::vector<std::string> m_user_int_attribs;
    /* Vector of user-defined real attributes for species, species_name */
    std::vector<std::string> m_user_real_attribs;
    /* Vector of user-defined parser for initializing user-defined integer attributes */
    amrex::Vector< std::unique_ptr<amrex::Parser> > m_user_int_attrib_parser;
    /* Vector of user-defined parser for initializing user-defined real attributes */
    amrex::Vector< std::unique_ptr<amrex::Parser> > m_user_real_attrib_parser;
 
};
 
#endif