FieldPlaneAveraging.H

Go to the documentation of this file.

#ifndef FIELDPLANEAVERAGING_H
#define FIELDPLANEAVERAGING_H
 
#include "src/utilities/DirectionSelector.H"
#include "src/CFDSim.H"
#include "src/core/Field.H"
#include "src/core/SimTime.H"

 
namespace kynema_sgf {

template <typename FType>
class FPlaneAveraging
{
public:
    FPlaneAveraging(
        const FType& field_in,
        const kynema_sgf::SimTime& time,
        int axis_in,
        int max_level,
        bool compute_deriv = false);
 
    virtual ~FPlaneAveraging() = default;
 
    virtual void operator()();
 
    void convert_x_to_ind(amrex::Real x, int& ind, amrex::Real& c) const;

    [[nodiscard]] amrex::Real
    line_average_interpolated(amrex::Real x, int comp) const;
    [[nodiscard]] amrex::Real line_average_cell(int ind, int comp) const;

    [[nodiscard]] amrex::Real
    line_derivative_interpolated(amrex::Real x, int comp) const;
    [[nodiscard]] amrex::Real
    line_derivative_of_average_cell(int ind, int comp) const;
 
    void output_line_average_ascii(
        const std::string& filename, int step, amrex::Real time);
    void output_line_average_ascii(int step, amrex::Real time);

    void set_precision(int p) { m_precision = p; };
 
    [[nodiscard]] amrex::Real dx() const { return m_dx; };
    [[nodiscard]] amrex::Real xlo() const { return m_xlo; };
 
    [[nodiscard]] int axis() const { return m_axis; };
    [[nodiscard]] int level() const { return m_max_level; };
    [[nodiscard]] int ncomp() const { return m_ncomp; };
    [[nodiscard]] int ncell_plane() const { return m_ncell_plane; };
    [[nodiscard]] int ncell_line() const { return m_ncell_line; };
    [[nodiscard]] int last_updated_index() const
    {
        return m_last_updated_index;
    };
 
    [[nodiscard]] const amrex::Vector<amrex::Real>& line_average() const
    {
        return m_line_average;
    };
    [[nodiscard]] const amrex::Vector<amrex::Real>& line_deriv() const
    {
        return m_line_deriv;
    };
    void line_average(int comp, amrex::Vector<amrex::Real>& l_vec);
    [[nodiscard]] const amrex::Vector<amrex::Real>& line_centroids() const
    {
        return m_line_xcentroid;
    };
 
    [[nodiscard]] const FType& field() const { return m_field; };
 
protected:
    int m_ncomp; 
 
    amrex::Vector<amrex::Real>
        m_line_average; 
    amrex::Vector<amrex::Real> m_line_deriv;
 
    amrex::Vector<amrex::Real> m_line_xcentroid; 
 
    amrex::Real m_dx;  
    amrex::Real m_xlo; 
    amrex::Real m_xhi; 
 
    int m_ncell_plane; 
    int m_ncell_line;  
 
    int m_precision = 4;           
    int m_last_updated_index = -1; 
 
    const FType& m_field;
    const SimTime& m_time;
    const int m_axis;
    int m_max_level;
    const bool m_comp_deriv;
 
public: // public for GPU
    template <typename IndexSelector>
    void compute_averages(const IndexSelector& idxOp);

    void compute_line_derivatives();
};
 
using FieldPlaneAveraging = FPlaneAveraging<Field>;
using ScratchFieldPlaneAveraging = FPlaneAveraging<ScratchField>;

class VelPlaneAveraging : public FieldPlaneAveraging
{
public:
    VelPlaneAveraging(CFDSim& sim, int axis_in, int max_level);
 
    ~VelPlaneAveraging() override = default;
 
    void operator()() override;
 
private:
    amrex::Vector<amrex::Real>
        m_line_hvelmag_average; 
 
    amrex::Vector<amrex::Real>
        m_line_Su_average; 
 
    amrex::Vector<amrex::Real>
        m_line_Sv_average; 
 
public: // public for GPU
    template <typename IndexSelector>
    void compute_hvelmag_averages(const IndexSelector& idxOp);

    const amrex::Vector<amrex::Real>& line_hvelmag_average()
    {
        return m_line_hvelmag_average;
    };

    [[nodiscard]] amrex::Real
    line_hvelmag_average_interpolated(amrex::Real x) const;
    [[nodiscard]] amrex::Real line_su_average_interpolated(amrex::Real x) const;
    [[nodiscard]] amrex::Real line_sv_average_interpolated(amrex::Real x) const;
};
 
} // namespace kynema_sgf
 
#endif /* FieldPlaneAveraging_H */