BackTransformedDiagnostic.H

Go to the documentation of this file.

/* Copyright 2019 Andrew Myers, Axel Huebl, Maxence Thevenet
 * Revathi Jambunathan, Weiqun Zhang
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef WARPX_BackTransformedDiagnostic_H_
#define WARPX_BackTransformedDiagnostic_H_

#include "BackTransformedDiagnostic_fwd.H"

#include "Particles/MultiParticleContainer.H"
#include "Particles/WarpXParticleContainer.H"

#include <AMReX_Box.H>
#include <AMReX_IntVect.H>
#include <AMReX_MultiFab.H>
#include <AMReX_REAL.H>
#include <AMReX_RealBox.H>
#include <AMReX_Vector.H>

#include <AMReX_BaseFwd.H>

#include <map>
#include <memory>
#include <string>
#include <vector>

class LabFrameDiag {
    public:
    std::string m_file_name;
    amrex::Real m_t_lab;
    amrex::RealBox m_prob_domain_lab_;
    amrex::IntVect m_prob_ncells_lab_;
    amrex::RealBox m_diag_domain_lab_;
    amrex::Box m_buff_box_;

    amrex::Real m_current_z_lab;
    amrex::Real m_current_z_boost;
    amrex::Real m_inv_gamma_boost_;
    amrex::Real m_inv_beta_boost_;
    amrex::Real m_dz_lab_;
    amrex::Real m_particle_slice_dx_lab_;

    int m_ncomp_to_dump_;
    std::vector<std::string> m_mesh_field_names_;

    int m_file_num;

    // For back-transformed diagnostics of grid fields, data_buffer_
    // stores a buffer of the fields in the lab frame (in a MultiFab, i.e.
    // with all box data etc.). When the buffer if full, dump to file.
    std::unique_ptr<amrex::MultiFab> m_data_buffer_;
    // particles_buffer_ is currently blind to refinement level.
    // particles_buffer_[j] is a WarpXParticleContainer::DiagnosticParticleData
    //  where - j is the species number for the current diag
    amrex::Vector<WarpXParticleContainer::DiagnosticParticleData> m_particles_buffer_;
    // buff_counter_ is the number of z slices in data_buffer_
    int m_buff_counter_;
    int m_num_buffer_ = 256;
    int m_max_box_size = 256;
    void updateCurrentZPositions(amrex::Real t_boost, amrex::Real inv_gamma,
                                 amrex::Real inv_beta);

    void createLabFrameDirectories();

    void writeLabFrameHeader();

    virtual void AddDataToBuffer(amrex::MultiFab& /*tmp_slice_ptr*/, int /*i_lab*/,
                 amrex::Vector<int> const& /*map_actual_fields_to_dump*/){}

    virtual void AddPartDataToParticleBuffer(
                 amrex::Vector<WarpXParticleContainer::DiagnosticParticleData> const& /*tmp_particle_buffer*/,
                 int /*nSpeciesBoostedFrame*/) {}

    // The destructor should also be a virtual function, so that
    // a pointer to subclass of `LabFrameDiag` actually calls the subclass's destructor.
    virtual ~LabFrameDiag() = default;
};

class LabFrameSnapShot : public LabFrameDiag {
    public:
    LabFrameSnapShot(amrex::Real t_lab_in, amrex::Real t_boost,
                     amrex::Real inv_gamma_boost_in, amrex::Real inv_beta_boost_in,
                     amrex::Real dz_lab_in, amrex::RealBox prob_domain_lab,
                     amrex::IntVect prob_ncells_lab, int ncomp_to_dump,
                     std::vector<std::string> mesh_field_names,
                     amrex::RealBox diag_domain_lab,
                     amrex::Box diag_box, int file_num_in, const int max_box_size,
                     const int buffer_size);
    void AddDataToBuffer( amrex::MultiFab& tmp_slice, int k_lab,
         amrex::Vector<int> const& map_actual_fields_to_dump) override;
    void AddPartDataToParticleBuffer(
         amrex::Vector<WarpXParticleContainer::DiagnosticParticleData> const& tmp_particle_buffer,
         int nSpeciesBoostedFrame) override;
};


class LabFrameSlice : public LabFrameDiag {
    public:
    LabFrameSlice(amrex::Real t_lab_in, amrex::Real t_boost,
                     amrex::Real inv_gamma_boost_in, amrex::Real inv_beta_boost_in,
                     amrex::Real dz_lab_in, amrex::RealBox prob_domain_lab,
                     amrex::IntVect prob_ncells_lab, int ncomp_to_dump,
                     std::vector<std::string> mesh_field_names,
                     amrex::RealBox diag_domain_lab,
                     amrex::Box diag_box, int file_num_in,
                     amrex::Real particle_slice_dx_lab,
                     const int max_box_size,
                     const int buffer_size);
    void AddDataToBuffer( amrex::MultiFab& tmp_slice_ptr, int i_lab,
         amrex::Vector<int> const& map_actual_fields_to_dump) override;
    void AddPartDataToParticleBuffer(
         amrex::Vector<WarpXParticleContainer::DiagnosticParticleData> const& tmp_particle_buffer,
         int nSpeciesBoostedFrame) override;
};

class BackTransformedDiagnostic {

public:

    BackTransformedDiagnostic (amrex::Real zmin_lab, amrex::Real zmax_lab,
                               amrex::Real v_window_lab, amrex::Real dt_snapshots_lab,
                               int N_snapshots, amrex::Real dt_slice_snapshots_lab,
                               int N_slice_snapshots, amrex::Real gamma_boost,
                               amrex::Real t_boost, amrex::Real dt_boost,
                               int boost_direction, const amrex::Geometry& geom,
                               amrex::RealBox& slice_realbox,
                               amrex::Real particle_slice_width_lab);

    void Flush (const amrex::Geometry& geom);

    void writeLabFrameData (const amrex::MultiFab* cell_centered_data,
                            const MultiParticleContainer& mypc,
                            const amrex::Geometry& geom,
                            const amrex::Real t_boost, const amrex::Real dt);
    void writeMetaData ();

private:
    amrex::Real m_gamma_boost_;
    amrex::Real m_inv_gamma_boost_;
    amrex::Real m_beta_boost_;
    amrex::Real m_inv_beta_boost_;
    amrex::Real m_dz_lab_;
    amrex::Real m_inv_dz_lab_;
    amrex::Real m_dt_snapshots_lab_;
    amrex::Real m_dt_boost_;
    int m_N_snapshots_;
    int m_boost_direction_;
    int m_N_slice_snapshots_;
    amrex::Real m_dt_slice_snapshots_lab_;
    amrex::Real m_particle_slice_width_lab_;

    int m_num_buffer_ = 256;
    int m_max_box_size_ = 256;

    std::vector<std::unique_ptr<LabFrameDiag> > m_LabFrameDiags_;

    void writeParticleData (
         const WarpXParticleContainer::DiagnosticParticleData& pdata,
         const std::string& name, const int i_lab);

#ifdef WARPX_USE_HDF5
    void writeParticleDataHDF5(
         const WarpXParticleContainer::DiagnosticParticleData& pdata,
         const std::string& name, const std::string& species_name);
#endif
    // Map field names and component number in cell_centered_data
    std::map<std::string, int> m_possible_fields_to_dump = {
        {"Ex" , 0},
        {"Ey" , 1},
        {"Ez" , 2},
        {"Bx" , 3},
        {"By" , 4},
        {"Bz" , 5},
        {"jx" , 6},
        {"jy" , 7},
        {"jz" , 8},
        {"rho", 9} };

    // maps field index in data_buffer_[i] -> cell_centered_data for
    // snapshots i. By default, all fields in cell_centered_data are dumped.
    // Needs to be amrex::Vector because used in a ParallelFor kernel.
    amrex::Vector<int> map_actual_fields_to_dump;
    // Name of fields to dump. By default, all fields in cell_centered_data.
    // Needed for file headers only.
    std::vector<std::string> m_mesh_field_names = {"Ex", "Ey", "Ez",
                                                   "Bx", "By", "Bz",
                                                   "jx", "jy", "jz", "rho"};
    int m_ncomp_to_dump = 10;


};

#endif