BTDiagnostics.H

Go to the documentation of this file.

/* Copyright 2021 Revathi Jambunathan
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef WARPX_BTDIAGNOSTICS_H_
#define WARPX_BTDIAGNOSTICS_H_
 
#include "Diagnostics.H"
#include "Diagnostics/ComputeDiagFunctors/ComputeDiagFunctor.H"
#include "Utils/WarpXConst.H"
#include "Utils/Parser/IntervalsParser.H"
 
#include <AMReX_Box.H>
#include <AMReX_Geometry.H>
#include <AMReX_IntVect.H>
#include <AMReX_MultiFab.H>
#include <AMReX_REAL.H>
#include <AMReX_RealBox.H>
#include <AMReX_Vector.H>
 
#include <limits>
#include <memory>
#include <string>
 
class
BTDiagnostics final : public Diagnostics
{
public:
 
    BTDiagnostics (int i, std::string name);
 
private:
    bool m_plot_raw_fields = false;
    bool m_plot_raw_fields_guards = false;
    void ReadParameters ();
    utils::parser::BTDIntervalsParser m_intervals;
    void Flush (int i_buffer) override;
    bool DoDump (int step, int i_buffer, bool force_flush=false) override;
    bool DoComputeAndPack (int step, bool force_flush=false) override;
    void DerivedInitData () override;
    void InitializeFieldFunctors (int lev) override;
    void InitializeFieldFunctorsRZopenPMD (int lev) override;
    void AddRZModesToOutputNames (const std::string& field, const int ncomp, bool cellcenter_data);
    void InitializeParticleBuffer () override;
    void PrepareBufferData () override;
    void UpdateBufferData () override;
    void PrepareFieldDataForOutput () override;
    void PrepareParticleDataForOutput() override;
 
    bool GetZSliceInDomainFlag (const int i_buffer, const int lev);
 
    bool GetKIndexInSnapshotBoxFlag (const int i_buffer, const int lev);
 
    void InitializeBufferData ( int i_buffer , int lev, bool restart=false) override;
    bool m_do_back_transformed_fields = true;
    bool m_do_back_transformed_particles = true;
 
    amrex::Real m_gamma_boost;
    amrex::Real m_beta_boost;
    int m_moving_window_dir;
 
    int m_num_snapshots_lab = std::numeric_limits<int>::lowest();
    amrex::Real m_dt_snapshots_lab = std::numeric_limits<amrex::Real>::lowest();
    amrex::Real m_dz_snapshots_lab = 0.0;
 
    int m_buffer_size = 256;
    int m_max_box_size = 256;
 
    amrex::Vector<amrex::Real> m_t_lab;
    amrex::Vector<amrex::RealBox> m_snapshot_domain_lab;
    amrex::Vector<amrex::RealBox> m_buffer_domain_lab;
    amrex::Vector<amrex::IntVect> m_snapshot_ncells_lab;
    amrex::Vector<amrex::Box> m_snapshot_box;
    amrex::Vector<amrex::Box> m_buffer_box;
    amrex::Vector<amrex::Real> m_current_z_lab;
    amrex::Vector<amrex::Real> m_current_z_boost;
    amrex::Vector<amrex::Real> m_old_z_boost;
    amrex::Vector< amrex::Vector <amrex::Geometry> > m_geom_snapshot;
    amrex::Vector<int> m_buffer_counter;
    amrex::Vector<int> m_max_buffer_multifabs;
    amrex::Vector<int> m_snapshot_full;
    amrex::Vector<int> m_lastValidZSlice;
    amrex::Vector<int> m_buffer_flush_counter;
    amrex::Vector<int> m_buffer_k_index_hi;
    amrex::Vector<std::unique_ptr<amrex::MultiFab> > m_cell_centered_data;
    amrex::Vector< amrex::Vector <std::unique_ptr<ComputeDiagFunctor const> > > m_cell_center_functors;
    void DefineCellCenteredMultiFab(int lev);
    void DefineFieldBufferMultiFab (const int i_buffer, const int lev);
 
    void DefineSnapshotGeometry (const int i_buffer, const int lev);
 
    amrex::Real UpdateCurrentZBoostCoordinate(amrex::Real t_lab, amrex::Real t_boost)
    {
        amrex::Real current_z_boost = (t_lab / m_gamma_boost - t_boost) * PhysConst::c / m_beta_boost;
        return current_z_boost;
    }
    amrex::Real UpdateCurrentZLabCoordinate(amrex::Real t_lab, amrex::Real t_boost)
    {
        amrex::Real current_z_lab = (t_lab - t_boost / m_gamma_boost ) * PhysConst::c / m_beta_boost;
        return current_z_lab;
    }
    amrex::Real dz_lab (amrex::Real dt, amrex::Real ref_ratio);
    int k_index_zlab (int i_buffer, int lev);
    bool buffer_full (int i_buffer) {
        return (k_index_zlab(i_buffer,0) == m_buffer_box[i_buffer].smallEnd(m_moving_window_dir));
    }
 
    bool buffer_empty (int i_buffer) {
        return ( m_buffer_counter[i_buffer] == 0) ;
    }
 
    amrex::Vector<int> m_first_flush_after_restart;
 
    void NullifyFirstFlush(int i_buffer) {m_first_flush_after_restart[i_buffer] = 0;}
 
    amrex::Vector<int> m_snapshot_geometry_defined;
    amrex::Vector<int> m_field_buffer_multifab_defined;
 
    void ResetBufferCounter(int i_buffer) {
        m_buffer_counter[i_buffer] = 0;
    }
    void IncrementBufferFlushCounter(int i_buffer) {
        m_buffer_flush_counter[i_buffer]++;
    }
    void SetSnapshotFullStatus (const int i_buffer);
#ifdef WARPX_DIM_RZ
    amrex::Vector< std::string > m_cellcenter_varnames = {"Er", "Et", "Ez",
                                                          "Br", "Bt", "Bz",
                                                          "jr", "jt", "jz", "rho"};
    amrex::Vector< std::string > m_cellcenter_varnames_fields = {"Er", "Et", "Ez",
                                                                 "Br", "Bt", "Bz",
                                                                 "jr", "jt", "jz",
                                                                 "rho"};
#else
    amrex::Vector< std::string > m_cellcenter_varnames = {"Ex", "Ey", "Ez",
                                                          "Bx", "By", "Bz",
                                                          "jx", "jy", "jz", "rho"};
#endif
 
 
    void MergeBuffersForPlotfile (int i_snapshot);
    void InterleaveBufferAndSnapshotHeader ( std::string buffer_Header,
                                             std::string snapshot_Header);
    void InterleaveFabArrayHeader( std::string Buffer_FabHeaderFilename,
                                   std::string snapshot_FabHeaderFilename,
                                   std::string newsnapshot_FabFilename);
    void InterleaveSpeciesHeader(std::string buffer_species_Header_path,
                                 std::string snapshot_species_Header_path,
                                 std::string species_name, const int new_data_index);
 
    void InterleaveParticleDataHeader( std::string buffer_ParticleHdrFilename,
                                       std::string snapshot_ParticleHdrFilename);
    void InitializeParticleFunctors () override;
 
    void UpdateTotalParticlesFlushed(int i_buffer);
    void ResetTotalParticlesInBuffer(int i_buffer);
    void ClearParticleBuffer(int i_buffer);
    void RedistributeParticleBuffer (const int i_buffer);
    void UpdateVarnamesForRZopenPMD();
 
    amrex::Real gettlab (int i_buffer) override {return m_t_lab[i_buffer];}
    void settlab (int i_buffer, amrex::Real tlab) override {m_t_lab[i_buffer] = tlab; }
    int get_buffer_k_index_hi (int i_buffer) override {return m_buffer_k_index_hi[i_buffer]; }
    void set_buffer_k_index_hi (int i_buffer, int kindex) override {m_buffer_k_index_hi[i_buffer] = kindex;}
    amrex::Real get_snapshot_domain_lo (int i_buffer, int idim) override {return m_snapshot_domain_lab[i_buffer].lo(idim); }
    amrex::Real get_snapshot_domain_hi (int i_buffer, int idim) override {return m_snapshot_domain_lab[i_buffer].hi(idim); }
    int get_flush_counter (int i_buffer) override {return m_buffer_flush_counter[i_buffer]; }
    void set_flush_counter ([[maybe_unused]] int i_buffer, int flush_counter) override { m_buffer_flush_counter[i_buffer] = flush_counter; }
    int get_last_valid_Zslice ( int i_buffer) override { return m_lastValidZSlice[i_buffer]; }
    void set_last_valid_Zslice ( int i_buffer, int last_valid_Zslice) override { m_lastValidZSlice[i_buffer] = last_valid_Zslice; }
    int get_snapshot_full_flag ( int i_buffer) override { return m_snapshot_full[i_buffer]; }
    void set_snapshot_full ( int i_buffer, int snapshot_full) override { m_snapshot_full[i_buffer] = snapshot_full; }
};
#endif // WARPX_BTDIAGNOSTICS_H_