FieldPlaneAveragingFine.H

Go to the documentation of this file.

#ifndef FieldPlaneAveragingFine_H
#define FieldPlaneAveragingFine_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 FPlaneAveragingFine
{
public:
    FPlaneAveragingFine(
        const FType& field_in,
        const amr_wind::SimTime& time,
        int axis_in,
        bool compute_deriv = false);
 
    virtual ~FPlaneAveragingFine() = default;
 
    virtual void operator()();
 
    void convert_x_to_ind(amrex::Real x, int& ind, amrex::Real& c) const;

    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 ncomp() const { return m_ncomp; };
    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; 
    amrex::Real m_xhi; 
 
    int m_ncell_line; 
 
    int m_precision = 6;           
    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);

    void compute_line_derivatives();
};
 
using FieldPlaneAveragingFine = FPlaneAveragingFine<Field>;
using ScratchFieldPlaneAveragingFine = FPlaneAveragingFine<ScratchField>;

class VelPlaneAveragingFine : public FieldPlaneAveragingFine
{
public:
    VelPlaneAveragingFine(CFDSim& sim, int axis_in);
 
    ~VelPlaneAveragingFine() 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);

    amrex::Real line_hvelmag_average_interpolated(amrex::Real x) const;
    amrex::Real line_su_average_interpolated(amrex::Real x) const;
    amrex::Real line_sv_average_interpolated(amrex::Real x) const;
};
 
} // namespace amr_wind
 
#endif /* FieldPlaneAveraging_H */