Diagnostics.H

Go to the documentation of this file.

#ifndef WARPX_DIAGNOSTICS_H_
#define WARPX_DIAGNOSTICS_H_
 
#include "ParticleDiag/ParticleDiag.H"
 
#include "ComputeDiagFunctors/ComputeDiagFunctor_fwd.H"
#include "ComputeDiagFunctors/ComputeParticleDiagFunctor.H"
#include "FlushFormats/FlushFormat_fwd.H"
#include "Particles/WarpXParticleContainer.H"
#include "Particles/PinnedMemoryParticleContainer.H"
 
#include <AMReX_IntVect.H>
#include <AMReX_REAL.H>
#include <AMReX_Vector.H>
#include <AMReX_AmrParticles.H>
 
#include <AMReX_BaseFwd.H>
 
#include <map>
#include <memory>
#include <string>
#include <vector>

enum struct DiagTypes {Full, BackTransformed, BoundaryScraping, TimeAveraged};
class Diagnostics
{
public:
    Diagnostics (int i, std::string name, DiagTypes diag_type);

    virtual ~Diagnostics ();
 
    Diagnostics (Diagnostics const &)              = delete;
    Diagnostics& operator= (Diagnostics const & )  = delete;
    Diagnostics(Diagnostics&& )                    = default;
    Diagnostics& operator=(Diagnostics&& )         = default;

    DiagTypes m_diag_type;
    void ComputeAndPack ();

    virtual void Flush (int i_buffer, bool force_flush) = 0;

    void InitData (const MultiParticleContainer& mpc);
    void InitDataBeforeRestart ();
    void InitDataAfterRestart (const MultiParticleContainer& mpc);

    virtual void InitializeFieldFunctors (int lev) = 0;
    virtual void InitializeFieldFunctorsRZopenPMD ([[maybe_unused]] int lev) { }
    virtual void InitializeParticleFunctors () {}
    virtual bool DoComputeAndPack(int step, bool force_flush=false) = 0;
    virtual bool DoDump (int step, int i_buffer, bool force_flush=false) = 0;
    void NewIteration () {m_already_done = false;}
    void FilterComputePackFlush (int step, bool force_flush=false);
    [[nodiscard]] bool DoDumpLastTimestep () const {return  m_dump_last_timestep;}
    [[nodiscard]] int getnumbuffers() const {return m_num_buffers;}
    virtual amrex::Real gettlab ( [[maybe_unused]] int i_buffer) {return 0.;}
    virtual void settlab ( [[maybe_unused]] int i_buffer, [[maybe_unused]] amrex::Real tlab) { }
    virtual int get_buffer_k_index_hi ( [[maybe_unused]] int i_buffer) {return 0; }
    virtual void set_buffer_k_index_hi ( [[maybe_unused]] int i_buffer, [[maybe_unused]] int kindex) { }
    virtual amrex::Real get_snapshot_domain_lo ([[maybe_unused]] int i_buffer, [[maybe_unused]] int idim) {return 0.; }
    virtual amrex::Real get_snapshot_domain_hi ([[maybe_unused]] int i_buffer, [[maybe_unused]] int idim) {return 0.; }
    void setSnapshotDomainLo(int i_buffer, int idim,  amrex::Real domain_lab_lo) {m_snapshot_domain_lab[i_buffer].setLo(idim, domain_lab_lo); }
    void setSnapshotDomainHi(int i_buffer, int idim,  amrex::Real domain_lab_hi) {m_snapshot_domain_lab[i_buffer].setHi(idim, domain_lab_hi); }
    virtual int get_flush_counter ( [[maybe_unused]] int i_buffer) { return 0; }
    virtual void set_flush_counter ( [[maybe_unused]] int i_buffer, [[maybe_unused]] int flush_counter) { }
    virtual int get_last_valid_Zslice ( [[maybe_unused]] int i_buffer) { return 0; }
    virtual void set_last_valid_Zslice ( [[maybe_unused]] int i_buffer, [[maybe_unused]] int last_valid_Zslice) { }
    virtual int get_snapshot_full_flag ( [[maybe_unused]] int i_buffer) { return 0; }
    virtual void set_snapshot_full ( [[maybe_unused]] int i_buffer, [[maybe_unused]] int snapshot_full) { }
 
protected:
    bool BaseReadParameters ();
    int m_verbose = 2;
    void InitBaseData ();
    virtual void InitializeBufferData (int i_buffer, int lev, bool restart=false) = 0;
    virtual void DerivedInitData () {}

    virtual void InitializeParticleBuffer (const MultiParticleContainer& mpc) = 0;

    virtual void PrepareBufferData () {}
    virtual void UpdateBufferData () {}
    virtual void PrepareFieldDataForOutput () {}
    virtual void PrepareParticleDataForOutput () {}
    virtual void MovingWindowAndGalileanDomainShift (int step) { amrex::ignore_unused(step); }
    std::string m_diag_name;
    std::string m_file_prefix;
    int m_file_min_digits = 6;
    int m_diag_index;
    amrex::Vector< std::string > m_varnames;
    amrex::Vector< std::string > m_varnames_fields;

    amrex::Vector< std::string > m_pfield_varnames;
    std::vector< std::string > m_pfield_species;
    std::vector< bool > m_pfield_do_average;
    std::vector< int > m_pfield_species_index;
    std::vector< std::string > m_pfield_strings;
    std::vector< bool> m_pfield_dofilter;
    std::vector< std::string > m_pfield_filter_strings;

    bool m_dump_last_timestep = true;
    std::string m_format = "plotfile";
    int m_already_done = false;
    std::unique_ptr<FlushFormat> m_flush_format;
    amrex::Vector< amrex::Vector< amrex::MultiFab > >  m_mf_output;
    amrex::Vector< amrex::Vector <amrex::MultiFab > > m_sum_mf_output;

    amrex::Vector< amrex::Vector <amrex::Geometry> > m_geom_output;
    // a particle buffer here?
    int nlev; 
    int nmax_lev; 
    int nlev_output;
    std::vector< std::string > m_output_species_names;
    std::vector< std::string > m_all_species_names;
    amrex::Vector< amrex::Vector< ParticleDiag> > m_output_species;
    amrex::Vector< amrex::Vector <std::unique_ptr<ComputeDiagFunctor > > > m_all_field_functors;
    amrex::IntVect m_crse_ratio = amrex::IntVect(1);
    amrex::Vector< amrex::Real> m_lo;
    amrex::Vector< amrex::Real> m_hi;
    int m_num_buffers;
    amrex::Vector<int> m_rho_per_species_index;
    amrex::Vector<int> m_T_per_species_index;
    amrex::Vector< amrex::Vector<std::unique_ptr<PinnedMemoryParticleContainer> > > m_particles_buffer;
    amrex::Vector< std::unique_ptr<ComputeParticleDiagFunctor> > m_all_particle_functors;

    amrex::Vector< amrex::Vector <int> > m_totalParticles_in_buffer;
    amrex::Vector<amrex::RealBox> m_snapshot_domain_lab;
 
};
 
#endif // WARPX_DIAGNOSTICS_H_