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 <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 (
        const int np,
        amrex::Real const * AMREX_RESTRICT const Xp,
        amrex::Real const * AMREX_RESTRICT const Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT const amplitude) const = 0;
 
    virtual ~ILaserProfile(){}
};
 
class GaussianLaserProfile : public ILaserProfile
{
 
public:
    void
    init (
        const amrex::ParmParse& ppl,
        CommonLaserParameters params) override final;
 
    //No update needed
    void
    update (amrex::Real /*t */) override final {}
 
    void
    fill_amplitude (
        const int np,
        amrex::Real const * AMREX_RESTRICT const Xp,
        amrex::Real const * AMREX_RESTRICT const Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT const amplitude) const override 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) override final;
 
    //No update needed
    void
    update (amrex::Real /*t */) override final {}
 
    void
    fill_amplitude (
        const int np,
        amrex::Real const * AMREX_RESTRICT const Xp,
        amrex::Real const * AMREX_RESTRICT const Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT const amplitude) const override 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) override final;
 
    void
    update (amrex::Real t) override final;
 
    void
    fill_amplitude (
        const int np,
        amrex::Real const * AMREX_RESTRICT const Xp,
        amrex::Real const * AMREX_RESTRICT const Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT const amplitude) const override final;
 
    void internal_fill_amplitude_uniform(
        const int idx_t_left,
        const int np,
        amrex::Real const * AMREX_RESTRICT const Xp,
        amrex::Real const * AMREX_RESTRICT const Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT const amplitude) const;
 
        void internal_fill_amplitude_uniform_binary(
        const int idx_t_left,
        const int np,
        amrex::Real const * AMREX_RESTRICT const Xp,
        amrex::Real const * AMREX_RESTRICT const Yp,
        amrex::Real t,
        amrex::Real * AMREX_RESTRICT const amplitude) const;
 
private:
    void parse_lasy_file(std::string lasy_file_name);
 
    void parse_binary_file(std::string binary_file_name);
 
    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 nt, nx, ny;
        amrex::Real t_min;
        amrex::Real t_max;
        amrex::Real x_min;
        amrex::Real x_max;
        amrex::Real y_min;
        amrex::Real y_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_