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()();
 
    amrex::Real line_average_interpolated(amrex::Real x, int comp) const;
    amrex::Real line_average_cell(int ind, int comp) const;
 
    amrex::Real line_derivative_interpolated(amrex::Real x, int comp) const;
    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; };
 
    amrex::Real dx() const { return m_dx; };
    amrex::Real xlo() const { return m_xlo; };
 
    int axis() const { return m_axis; };
    int level() const { return m_level; };
    int ncomp() const { return m_ncomp; };
    int ncell_plane() const { return m_ncell_plane; };
    int ncell_line() const { return m_ncell_line; };
    int last_updated_index() const { return m_last_updated_index; };
 
    const amrex::Vector<amrex::Real>& line_average() const
    {
        return m_line_average;
    };
    const amrex::Vector<amrex::Real>& line_deriv() const
    {
        return m_line_deriv;
    };
    void line_average(int comp, amrex::Vector<amrex::Real>& l_vec);
    const amrex::Vector<amrex::Real>& line_centroids() const
    {
        return m_line_xcentroid;
    };
 
    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,
        const int h1_idx,
        const int h2_idx,
        const amrex::MultiFab& mfab);
 
    const amrex::Vector<amrex::Real>& line_hvelmag_average()
    {
        return m_line_hvelmag_average;
    };
 
    amrex::Real line_hvelmag_average_interpolated(amrex::Real x) const;
    amrex::Real line_hvelmag_average_cell(int ind) const;
 
    void compute_line_hvelmag_derivatives();
    amrex::Real line_hvelmag_derivative_interpolated(amrex::Real x) const;
    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 */