LaserProfiles.H

Go to the documentation of this file.

/* Copyright 2019-2020 Luca Fedeli, Maxence Thevenet
 * Ilian Kara-Mostefa
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef WARPX_LaserProfiles_H_
#define WARPX_LaserProfiles_H_
 
#include <AMReX_Gpu.H>
#include <AMReX_ParmParse.H>
#include <AMReX_Parser.H>
#include <AMReX_REAL.H>
#include <AMReX_Vector.H>
#include <AMReX_Box.H>
#include <AMReX_FArrayBox.H>
 
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <string>
#include <utility>
 
#include "Utils/WarpX_Complex.H"
 
namespace WarpXLaserProfiles {

struct CommonLaserParameters
{
    amrex::Real wavelength; 
    amrex::Real e_max;  
    amrex::Vector<amrex::Real> p_X;// ! Polarization
    amrex::Vector<amrex::Real> nvec; 
};
 

class ILaserProfile
{
public:
    virtual void
    init (
        const amrex::ParmParse& ppl,
        CommonLaserParameters params) = 0;

    virtual void
    update (
        amrex::Real t) = 0;

    virtual void
    fill_amplitude (
        int np,
        amrex::Real const * AMREX_RESTRICT Xp,
        amrex::Real const * AMREX_RESTRICT Yp,
        amrex::Real t,
        amrex::Real* AMREX_RESTRICT amplitude) const = 0;
 
    ILaserProfile () = default;
    virtual ~ILaserProfile() = default;
 
    ILaserProfile ( ILaserProfile const &)             = default;
    ILaserProfile& operator= ( ILaserProfile const & ) = default;
    ILaserProfile ( ILaserProfile&& )                  = default;
    ILaserProfile& operator= ( ILaserProfile&& )       = default;
};

class GaussianLaserProfile : public ILaserProfile
{
 
public:
    void
    init (
        const amrex::ParmParse& ppl,
        CommonLaserParameters params) final;
 
    //No update needed
    void
    update (amrex::Real /*t */) final {}
 
    void
    fill_amplitude (
        int np,
        amrex::Real const * AMREX_RESTRICT Xp,
        amrex::Real const * AMREX_RESTRICT Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT amplitude) const final;
 
private:
    struct {
        amrex::Real waist          = std::numeric_limits<amrex::Real>::quiet_NaN();
        amrex::Real duration       = std::numeric_limits<amrex::Real>::quiet_NaN();
        amrex::Real t_peak         = std::numeric_limits<amrex::Real>::quiet_NaN();
        amrex::Real focal_distance = std::numeric_limits<amrex::Real>::quiet_NaN();
        amrex::Real zeta           = 0;
        amrex::Real beta           = 0;
        amrex::Real phi2           = 0;
        amrex::Real phi0           = 0;
 
        amrex::Vector<amrex::Real> stc_direction; 
        amrex::Real theta_stc; 
    } m_params;
 
    CommonLaserParameters m_common_params;
};

class FieldFunctionLaserProfile : public ILaserProfile
{
 
public:
    void
    init (
        const amrex::ParmParse& ppl,
        CommonLaserParameters params) final;
 
    //No update needed
    void
    update (amrex::Real /*t */) final {}
 
    void
    fill_amplitude (
        int np,
        amrex::Real const * AMREX_RESTRICT Xp,
        amrex::Real const * AMREX_RESTRICT Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT amplitude) const final;
 
private:
    struct{
        std::string field_function;
    } m_params;
 
    amrex::Parser m_parser;
};

class FromFileLaserProfile : public ILaserProfile
{
 
public:
    void
    init (
        const amrex::ParmParse& ppl,
        CommonLaserParameters params) final;

    void
    update (amrex::Real t) final;

    void
    fill_amplitude (
        int np,
        amrex::Real const * AMREX_RESTRICT Xp,
        amrex::Real const * AMREX_RESTRICT Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT amplitude) const final;

    void internal_fill_amplitude_uniform_cartesian(
        int idx_t_left,
        int np,
        amrex::Real const * AMREX_RESTRICT Xp,
        amrex::Real const * AMREX_RESTRICT Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT amplitude) const;

    void internal_fill_amplitude_uniform_cylindrical(
        int idx_t_left,
        int np,
        amrex::Real const * AMREX_RESTRICT Xp,
        amrex::Real const * AMREX_RESTRICT Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT amplitude) const;
 
 

        void internal_fill_amplitude_uniform_binary(
        int idx_t_left,
        int np,
        amrex::Real const * AMREX_RESTRICT Xp,
        amrex::Real const * AMREX_RESTRICT Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT amplitude) const;
 
private:
    void parse_lasy_file(const std::string& lasy_file_name);

    void parse_binary_file(const std::string& binary_file_name);

    [[nodiscard]] std::pair<int,int> find_left_right_time_indices(amrex::Real t) const;

    void read_data_t_chunk(int t_begin, int t_end);

    void read_binary_data_t_chunk(int t_begin, int t_end);

    struct{

        std::string binary_file_name;
        std::string lasy_file_name;
        bool file_in_lasy_format;
        int file_in_cartesian_geom;
        int nt, nx, ny;
        int nr;
        int n_rz_azimuthal_components;
        amrex::Real t_min;
        amrex::Real t_max;
        amrex::Real x_min;
        amrex::Real x_max;
        amrex::Real y_min;
        amrex::Real y_max;
        amrex::Real r_min;
        amrex::Real r_max;
        int time_chunk_size;
        int first_time_index;
        int last_time_index;
        amrex::Gpu::DeviceVector<Complex> E_lasy_data;
        amrex::Gpu::DeviceVector<amrex::Real> E_binary_data;
        amrex::Real t_delay = amrex::Real(0.0);
 
    } m_params;
 
    CommonLaserParameters m_common_params;
};

const
std::map<
std::string,
std::function<std::unique_ptr<ILaserProfile>()>
>
laser_profiles_dictionary =
{
    {"gaussian",
        [] () {return std::make_unique<GaussianLaserProfile>();} },
    {"parse_field_function",
        [] () {return std::make_unique<FieldFunctionLaserProfile>();} },
    {"from_file",
        [] () {return std::make_unique<FromFileLaserProfile>();} }
};
 
} //WarpXLaserProfiles
 
#endif //WARPX_LaserProfiles_H_