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

    void InitializeBufferData ( int i_buffer , int lev) 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) ;
    }

    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();

};
#endif // WARPX_BTDIAGNOSTICS_H_