FieldPlaneAveraging.H

Go to the documentation of this file.

#ifndef FIELDPLANEAVERAGING_H
#define FIELDPLANEAVERAGING_H
 
#include "amr-wind/utilities/DirectionSelector.H"
#include "amr-wind/CFDSim.H"
#include "amr-wind/core/Field.H"
#include "amr-wind/core/SimTime.H"

 
namespace amr_wind {

template <typename FType>
class FPlaneAveraging
{
public:
    FPlaneAveraging(
        const FType& field_in,
        const amr_wind::SimTime& time,
        int axis_in,
        bool compute_deriv = false);
 
    virtual ~FPlaneAveraging() = default;
 
    virtual void operator()();

    [[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_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; 
 
    int m_ncell_plane; 
    int m_ncell_line;  
 
    int m_precision = 4; 
    const int m_level =
        0; 
    int m_last_updated_index = -1; 
 
    const FType& m_field;
    const SimTime& m_time;
    const int m_axis;
    const bool m_comp_deriv;
 
public: // public for GPU
    template <typename IndexSelector>
    void
    compute_averages(const IndexSelector& idxOp, const amrex::MultiFab& mfab);

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

class VelPlaneAveraging : public FieldPlaneAveraging
{
public:
    VelPlaneAveraging(CFDSim& sim, int axis_in);
 
    ~VelPlaneAveraging() override = default;
 
    void operator()() override;
 
private:
    amrex::Vector<amrex::Real>
        m_line_hvelmag_average; 
    amrex::Vector<amrex::Real> m_line_hvelmag_deriv;
 
public: // public for GPU
    template <typename IndexSelector>
    void compute_hvelmag_averages(
        const IndexSelector& idx_op,
        int h1_idx,
        int h2_idx,
        const amrex::MultiFab& mfab);

    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_hvelmag_average_cell(int ind) const;

    void compute_line_hvelmag_derivatives();
    [[nodiscard]] amrex::Real
    line_hvelmag_derivative_interpolated(amrex::Real x) const;
    [[nodiscard]] amrex::Real
    line_hvelmag_derivative_of_average_cell(int ind) 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);
};
 
} // namespace amr_wind
 
#endif /* FieldPlaneAveraging_H */