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 "WarpXParticleContainer.H"
#include "Filter/NCIGodfreyFilter.H"
#include "Particles/ElementaryProcess/Ionization.H"
#include "Particles/Gather/ScaleFields.H"

#ifdef WARPX_QED
#    include "Particles/ElementaryProcess/QEDInternals/QuantumSyncEngineWrapper.H"
#    include "Particles/ElementaryProcess/QEDInternals/BreitWheelerEngineWrapper.H"
#    include "Particles/ElementaryProcess/QEDInternals/QedChiFunctions.H"

#    include "Particles/ElementaryProcess/QEDPairGeneration.H"
#    include "Particles/ElementaryProcess/QEDPhotonEmission.H"
#endif

#include <AMReX_IArrayBox.H>

#include <map>

class PhysicalParticleContainer
    : public WarpXParticleContainer
{
public:

    enum PhysicalParticleType{
        electron,
        positron,
        photon,
        other
    };

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

    PhysicalParticleContainer (amrex::AmrCore* amr_core);

    void BackwardCompatibility ();

    virtual ~PhysicalParticleContainer () {}

    virtual void InitData () override;

    void InitIonizationModule ();

    virtual void Evolve (int lev,
                         const amrex::MultiFab& Ex,
                         const amrex::MultiFab& Ey,
                         const amrex::MultiFab& Ez,
                         const amrex::MultiFab& Bx,
                         const amrex::MultiFab& By,
                         const amrex::MultiFab& Bz,
                         const amrex::MultiFab& Ex_avg,
                         const amrex::MultiFab& Ey_avg,
                         const amrex::MultiFab& Ez_avg,
                         const amrex::MultiFab& Bx_avg,
                         const amrex::MultiFab& By_avg,
                         const amrex::MultiFab& Bz_avg,
                         amrex::MultiFab& jx,
                         amrex::MultiFab& jy,
                         amrex::MultiFab& jz,
                         amrex::MultiFab* cjx,
                         amrex::MultiFab* cjy,
                         amrex::MultiFab* cjz,
                         amrex::MultiFab* rho,
                         amrex::MultiFab* crho,
                         const amrex::MultiFab* cEx,
                         const amrex::MultiFab* cEy,
                         const amrex::MultiFab* cEz,
                         const amrex::MultiFab* cBx,
                         const amrex::MultiFab* cBy,
                         const amrex::MultiFab* cBz,
                         amrex::Real t,
                         amrex::Real dt,
                         DtType a_dt_type=DtType::Full) 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,
                         const int ngE, const int /*e_is_nodal*/,
                         const long offset,
                         const long np_to_push,
                         int lev, int gather_lev,
                         amrex::Real dt, ScaleFields scaleFields,
                         DtType a_dt_type=DtType::Full);

    virtual 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 const np,
                        WarpXParIter& pti,
                        int const lev,
                        amrex::iMultiFab const* current_masks,
                        amrex::iMultiFab const* gather_masks,
                        RealVector& uxp,
                        RealVector& uyp,
                        RealVector& uzp,
                        RealVector& wp );

    virtual void PostRestart () final {}

    void SplitParticles (int lev);

    IonizationFilterFunc getIonizationFunc (const WarpXParIter& pti,
                                            int lev,
                                            int ngE,
                                            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 (int lev, amrex::RealBox part_realbox = amrex::RealBox());

    void MapParticletoBoostedFrame (amrex::Real& x, amrex::Real& y, amrex::Real& z, std::array<amrex::Real, 3>& u);

    void AddGaussianBeam (
        const amrex::Real x_m, const amrex::Real y_m, const amrex::Real z_m,
        const amrex::Real x_rms, const amrex::Real y_rms, const amrex::Real z_rms,
        const amrex::Real x_cut, const amrex::Real y_cut, const amrex::Real z_cut,
        const amrex::Real q_tot, long npart, const int do_symmetrize);

    void AddPlasmaFromFile (amrex::ParticleReal q_tot,
                            amrex::ParticleReal z_shift);

    void CheckAndAddParticle (
        amrex::Real x, amrex::Real y, amrex::Real z,
        std::array<amrex::Real, 3> u,
        amrex::Real 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);

    virtual void GetParticleSlice (
        const int direction, const amrex::Real z_old,
        const amrex::Real z_new, const amrex::Real t_boost,
        const amrex::Real t_lab, const amrex::Real dt,
        DiagnosticParticles& diagnostic_particles) final;

    virtual void ConvertUnits (ConvertDirection convert_dir) override;

    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 * & exfab, amrex::FArrayBox const * & eyfab,
        amrex::FArrayBox const * & ezfab, amrex::FArrayBox const * & bxfab,
        amrex::FArrayBox const * & byfab, amrex::FArrayBox const * & bzfab);

    void resample (const int timestep) override 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
        (std::shared_ptr<BreitWheelerEngine> ptr) override;

    void set_quantum_sync_engine_ptr
        (std::shared_ptr<QuantumSynchrotronEngine> ptr) override;
    //__________

    PhotonEmissionFilterFunc getPhotonEmissionFilterFunc ();

    PairGenerationFilterFunc getPairGenerationFilterFunc ();
#endif

protected:
    std::string species_name;
    std::unique_ptr<PlasmaInjector> plasma_injector;

    // 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;

    Resampling m_resampler;

    // Inject particles during the whole simulation
    void ContinuousInjection (const amrex::RealBox& injection_box) 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;

#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

};

#endif