Append Reynolds stresses to the average fields. More...

#include <FilterReynoldsStresses.h>

Inheritance diagram for Nektar::SolverUtils::FilterReynoldsStresses:

Public Member Functions
SOLVER_UTILS_EXPORT	FilterReynoldsStresses (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< SolverUtils::EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)

SOLVER_UTILS_EXPORT	~FilterReynoldsStresses () override

Public Member Functions inherited from Nektar::SolverUtils::FilterFieldConvert
SOLVER_UTILS_EXPORT	FilterFieldConvert (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const ParamMap &pParams)

SOLVER_UTILS_EXPORT	~FilterFieldConvert () override

Public Member Functions inherited from Nektar::SolverUtils::Filter
SOLVER_UTILS_EXPORT	Filter (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation)

virtual SOLVER_UTILS_EXPORT	~Filter ()

SOLVER_UTILS_EXPORT void	Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT void	Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

SOLVER_UTILS_EXPORT bool	IsTimeDependent ()

Static Public Member Functions
static FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< SolverUtils::EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)
	Creates an instance of this class. More...

Static Public Member Functions inherited from Nektar::SolverUtils::FilterFieldConvert
static FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)
	Creates an instance of this class. More...

Static Public Attributes
static std::string	className
	Name of the class. More...

Static Public Attributes inherited from Nektar::SolverUtils::FilterFieldConvert
static std::string	className
	Name of the class. More...

Protected Member Functions
void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

void	v_FillVariablesName (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields) override

void	v_ProcessSample (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, const NekDouble &time) override

void	v_PrepareOutput (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

NekDouble	v_GetScale () override

std::string	v_GetFileSuffix () override

Protected Member Functions inherited from Nektar::SolverUtils::FilterFieldConvert
SOLVER_UTILS_EXPORT void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

virtual SOLVER_UTILS_EXPORT void	v_FillVariablesName (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields)

SOLVER_UTILS_EXPORT void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

SOLVER_UTILS_EXPORT void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

virtual SOLVER_UTILS_EXPORT void	v_ProcessSample (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT void	v_PrepareOutput (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

virtual SOLVER_UTILS_EXPORT NekDouble	v_GetScale ()

virtual SOLVER_UTILS_EXPORT std::string	v_GetFileSuffix ()

void	OutputField (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, int dump=-1)

SOLVER_UTILS_EXPORT bool	v_IsTimeDependent () override

void	CreateModules (std::vector< std::string > &modcmds)

void	CreateFields (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields)

void	CheckModules (std::vector< ModuleSharedPtr > &modules)

virtual void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)=0

virtual bool	v_IsTimeDependent ()=0

Protected Attributes
std::vector< Array< OneD, NekDouble > >	m_fields

std::vector< Array< OneD, NekDouble > >	m_delta

NekDouble	m_alpha

bool	m_movAvg

Protected Attributes inherited from Nektar::SolverUtils::FilterFieldConvert
unsigned int	m_numSamples

unsigned int	m_outputFrequency

unsigned int	m_sampleFrequency

std::string	m_outputFile

std::string	m_restartFile

unsigned int	m_index

unsigned int	m_outputIndex

bool	m_phaseSample

NekDouble	m_phaseSamplePeriod

NekDouble	m_phaseSamplePhase

NekDouble	m_phaseTolerance

NekDouble	m_dt

std::vector< ModuleSharedPtr >	m_modules

LibUtilities::FieldMetaDataMap	m_fieldMetaData

std::vector< Array< OneD, NekDouble > >	m_outFields

std::vector< std::string >	m_variables

FieldSharedPtr	m_f

po::variables_map	m_vm

Protected Attributes inherited from Nektar::SolverUtils::Filter
LibUtilities::SessionReaderSharedPtr	m_session

const std::weak_ptr< EquationSystem >	m_equ

Friends
class	MemoryManager< FilterReynoldsStresses >

Additional Inherited Members
Public Types inherited from Nektar::SolverUtils::Filter
typedef std::map< std::string, std::string >	ParamMap

Detailed Description

Append Reynolds stresses to the average fields.

This class appends the average fields with the Reynolds stresses of the form \( \overline{u' v'} \).

For the default case, this is achieved by calculating \( C_{n} = \Sigma_{i=1}^{n} (u_i - \bar{u}_n)(v_i - \bar{v}_n)\) using the recursive relation:

\[ C_{n} = C_{n-1} + \frac{n}{n-1} (u_n - \bar{u}_n)(v_n - \bar{v}_n) \]

The FilterSampler base class then divides the result by n, leading to the Reynolds stress.

It is also possible to perform the averages using an exponential moving average, in which case either the moving average parameter \( \alpha \) or the time constant \( \tau \) must be prescribed.

Definition at line 42 of file FilterReynoldsStresses.h.

Constructor & Destructor Documentation

◆ FilterReynoldsStresses()

Nektar::SolverUtils::FilterReynoldsStresses::FilterReynoldsStresses	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< SolverUtils::EquationSystem > &	pEquation,
		const std::map< std::string, std::string > &	pParams
	)

Definition at line 64 of file FilterReynoldsStresses.cpp.

    : FilterFieldConvert(pSession, pEquation, pParams)
{
    // Load sampling frequency
    auto it = pParams.find("SampleFrequency");
    if (it == pParams.end())
    {
        m_sampleFrequency = 1;
    }
    else
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        m_sampleFrequency = round(equ.Evaluate());
    }
 
    // Check if should use moving average
    it = pParams.find("MovingAverage");
    if (it == pParams.end())
    {
        m_movAvg = false;
    }
    else
    {
        std::string sOption = it->second.c_str();
        m_movAvg            = (boost::iequals(sOption, "true")) ||
                   (boost::iequals(sOption, "yes"));
    }
 
    if (!m_movAvg)
    {
        return;
    }
 
    // Load alpha parameter for moving average
    it = pParams.find("alpha");
    if (it == pParams.end())
    {
        it = pParams.find("tau");
        if (it == pParams.end())
        {
            ASSERTL0(false, "MovingAverage needs either alpha or tau.");
        }
        else
        {
            // Load time constant
            LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
            NekDouble tau = equ.Evaluate();
            // Load delta T between samples
            NekDouble dT;
            m_session->LoadParameter("TimeStep", dT);
            dT = dT * m_sampleFrequency;
            // Calculate alpha
            m_alpha = dT / (tau + dT);
        }
    }
    else
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        m_alpha = equ.Evaluate();
        // Check if tau was also defined
        it = pParams.find("tau");
        if (it != pParams.end())
        {
            ASSERTL0(false,
                     "Cannot define both alpha and tau in MovingAverage.");
        }
    }
    // Check bounds of m_alpha
    ASSERTL0(m_alpha > 0 && m_alpha < 1, "Alpha out of bounds.");
}

References ASSERTL0, Nektar::LibUtilities::Equation::Evaluate(), m_alpha, m_movAvg, Nektar::SolverUtils::FilterFieldConvert::m_sampleFrequency, and Nektar::SolverUtils::Filter::m_session.

◆ ~FilterReynoldsStresses()

Nektar::SolverUtils::FilterReynoldsStresses::~FilterReynoldsStresses ( )

override

Definition at line 138 of file FilterReynoldsStresses.cpp.

139{

140}

Member Function Documentation

◆ create()

static FilterSharedPtr Nektar::SolverUtils::FilterReynoldsStresses::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< SolverUtils::EquationSystem > &	pEquation,
		const std::map< std::string, std::string > &	pParams
	)

inlinestatic

Creates an instance of this class.

Definition at line 48 of file FilterReynoldsStresses.h.

    {
        FilterSharedPtr p =
            MemoryManager<FilterReynoldsStresses>::AllocateSharedPtr(
                pSession, pEquation, pParams);
        return p;
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

◆ v_FillVariablesName()

void Nektar::SolverUtils::FilterReynoldsStresses::v_FillVariablesName ( const Array< OneD, const MultiRegions::ExpListSharedPtr > & pFields )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 182 of file FilterReynoldsStresses.cpp.

{
    size_t dim        = pFields.size() - 1;
    size_t origFields = pFields.size();
 
    // Fill name of variables
    for (size_t n = 0; n < origFields; ++n)
    {
        m_variables.push_back(pFields[n]->GetSession()->GetVariable(n));
    }
    for (int i = 0; i < dim; ++i)
    {
        for (int j = i; j < dim; ++j)
        {
            std::string var = pFields[i]->GetSession()->GetVariable(i) +
                              pFields[j]->GetSession()->GetVariable(j);
            m_variables.push_back(var);
        }
    }
}

References Nektar::SolverUtils::FilterFieldConvert::m_variables.

◆ v_GetFileSuffix()

std::string Nektar::SolverUtils::FilterReynoldsStresses::v_GetFileSuffix ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 84 of file FilterReynoldsStresses.h.

    {
        return "_stress";
    }

◆ v_GetScale()

NekDouble Nektar::SolverUtils::FilterReynoldsStresses::v_GetScale ( )

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 304 of file FilterReynoldsStresses.cpp.

{
    if (m_movAvg)
    {
        return 1.0;
    }
    else
    {
        return 1.0 / m_numSamples;
    }
}

References m_movAvg, and Nektar::SolverUtils::FilterFieldConvert::m_numSamples.

◆ v_Initialise()

void Nektar::SolverUtils::FilterReynoldsStresses::v_Initialise	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 142 of file FilterReynoldsStresses.cpp.

{
    size_t dim          = pFields.size() - 1;
    size_t nExtraFields = (dim + 1) * dim / 2;
    size_t origFields   = pFields.size();
    size_t nqtot        = pFields[0]->GetTotPoints();
 
    // Allocate storage
    m_fields.resize(origFields + nExtraFields);
    m_delta.resize(dim);
 
    for (size_t n = 0; n < m_fields.size(); ++n)
    {
        m_fields[n] = Array<OneD, NekDouble>(nqtot, 0.0);
    }
    for (size_t n = 0; n < m_delta.size(); ++n)
    {
        m_delta[n] = Array<OneD, NekDouble>(nqtot, 0.0);
    }
 
    // Initialise output arrays
    FilterFieldConvert::v_Initialise(pFields, time);
 
    // Update m_fields if using restart file
    if (m_numSamples)
    {
        for (size_t j = 0; j < m_fields.size(); ++j)
        {
            pFields[0]->BwdTrans(m_outFields[j], m_fields[j]);
            if (pFields[0]->GetWaveSpace())
            {
                pFields[0]->HomogeneousBwdTrans(nqtot, m_fields[j],
                                                m_fields[j]);
            }
        }
    }
}

References m_delta, m_fields, Nektar::SolverUtils::FilterFieldConvert::m_numSamples, Nektar::SolverUtils::FilterFieldConvert::m_outFields, and Nektar::SolverUtils::FilterFieldConvert::v_Initialise().

◆ v_PrepareOutput()

void Nektar::SolverUtils::FilterReynoldsStresses::v_PrepareOutput	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		const NekDouble &	time
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 279 of file FilterReynoldsStresses.cpp.

{
    size_t dim = pFields.size() - 1;
 
    m_fieldMetaData["NumberOfFieldDumps"] = std::to_string(m_numSamples);
 
    // Set wavespace to false, as calculations were performed in physical space
    bool waveSpace = pFields[0]->GetWaveSpace();
    pFields[0]->SetWaveSpace(false);
 
    // Forward transform and put into m_outFields (except pressure)
    for (size_t i = 0; i < m_fields.size(); ++i)
    {
        if (i != dim)
        {
            pFields[0]->FwdTransLocalElmt(m_fields[i], m_outFields[i]);
        }
    }
 
    // Restore waveSpace
    pFields[0]->SetWaveSpace(waveSpace);
}

References Nektar::SolverUtils::FilterFieldConvert::m_fieldMetaData, m_fields, Nektar::SolverUtils::FilterFieldConvert::m_numSamples, and Nektar::SolverUtils::FilterFieldConvert::m_outFields.

◆ v_ProcessSample()

void Nektar::SolverUtils::FilterReynoldsStresses::v_ProcessSample	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		std::vector< Array< OneD, NekDouble > > &	fieldcoeffs,
		const NekDouble &	time
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 204 of file FilterReynoldsStresses.cpp.

{
    size_t i, j, n;
    size_t nq          = pFields[0]->GetTotPoints();
    size_t dim         = pFields.size() - 1;
    bool waveSpace     = pFields[0]->GetWaveSpace();
    NekDouble nSamples = (NekDouble)m_numSamples;
 
    // For moving average, take first sample as initial vector
    NekDouble alpha = m_alpha;
    if (m_numSamples == 1)
    {
        alpha = 1.0;
    }
 
    // Define auxiliary constants for averages
    NekDouble facOld, facAvg, facStress, facDelta;
    if (m_movAvg)
    {
        facOld    = 1.0 - alpha;
        facAvg    = alpha;
        facStress = alpha;
        facDelta  = 1.0;
    }
    else
    {
        facOld    = 1.0;
        facAvg    = 1.0;
        facStress = nSamples / (nSamples - 1);
        facDelta  = 1.0 / nSamples;
    }
 
    Array<OneD, NekDouble> vel(nq);
    Array<OneD, NekDouble> tmp(nq);
 
    // Update original velocities in phys space and calculate (\bar{u} - u_n)
    for (n = 0; n < dim; ++n)
    {
        if (waveSpace)
        {
            pFields[n]->HomogeneousBwdTrans(nq, pFields[n]->GetPhys(), vel);
        }
        else
        {
            vel = pFields[n]->GetPhys();
        }
        Vmath::Svtsvtp(nq, facAvg, vel, 1, facOld, m_fields[n], 1, m_fields[n],
                       1);
        Vmath::Svtvm(nq, facDelta, m_fields[n], 1, vel, 1, m_delta[n], 1);
    }
    // Update pressure (directly to outFields)
    Vmath::Svtsvtp(m_outFields[dim].size(), facAvg, pFields[dim]->GetCoeffs(),
                   1, facOld, m_outFields[dim], 1, m_outFields[dim], 1);
 
    // Ignore Reynolds stress for first sample (its contribution is zero)
    if (m_numSamples == 1)
    {
        return;
    }
 
    // Calculate C_{n} = facOld * C_{n-1} + facStress * deltaI * deltaJ
    for (i = 0, n = dim + 1; i < dim; ++i)
    {
        for (j = i; j < dim; ++j, ++n)
        {
            Vmath::Vmul(nq, m_delta[i], 1, m_delta[j], 1, tmp, 1);
            Vmath::Svtsvtp(nq, facStress, tmp, 1, facOld, m_fields[n], 1,
                           m_fields[n], 1);
        }
    }
}

References m_alpha, m_delta, m_fields, m_movAvg, Nektar::SolverUtils::FilterFieldConvert::m_numSamples, Nektar::SolverUtils::FilterFieldConvert::m_outFields, Vmath::Svtsvtp(), Vmath::Svtvm(), and Vmath::Vmul().

Friends And Related Function Documentation

◆ MemoryManager< FilterReynoldsStresses >

friend class MemoryManager< FilterReynoldsStresses >

friend

Definition at line 1 of file FilterReynoldsStresses.h.

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::FilterReynoldsStresses::className

static

Initial value:

=
    GetFilterFactory().RegisterCreatorFunction("ReynoldsStresses",
                                               FilterReynoldsStresses::create)

Name of the class.

Definition at line 60 of file FilterReynoldsStresses.h.

◆ m_alpha

NekDouble Nektar::SolverUtils::FilterReynoldsStresses::m_alpha

protected

Definition at line 91 of file FilterReynoldsStresses.h.

Referenced by FilterReynoldsStresses(), and v_ProcessSample().

◆ m_delta

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterReynoldsStresses::m_delta

protected

Definition at line 90 of file FilterReynoldsStresses.h.

Referenced by v_Initialise(), and v_ProcessSample().

◆ m_fields

std::vector<Array<OneD, NekDouble> > Nektar::SolverUtils::FilterReynoldsStresses::m_fields

protected

Definition at line 89 of file FilterReynoldsStresses.h.

Referenced by v_Initialise(), v_PrepareOutput(), and v_ProcessSample().

◆ m_movAvg

bool Nektar::SolverUtils::FilterReynoldsStresses::m_movAvg

protected

Definition at line 92 of file FilterReynoldsStresses.h.

Referenced by FilterReynoldsStresses(), v_GetScale(), and v_ProcessSample().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FilterReynoldsStresses()

◆ ~FilterReynoldsStresses()

Member Function Documentation

◆ create()

◆ v_FillVariablesName()

◆ v_GetFileSuffix()

◆ v_GetScale()

◆ v_Initialise()

◆ v_PrepareOutput()

◆ v_ProcessSample()

Friends And Related Function Documentation

◆ MemoryManager< FilterReynoldsStresses >

Member Data Documentation

◆ className

◆ m_alpha

◆ m_delta

◆ m_fields

◆ m_movAvg