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

#include <FilterReynoldsStresses.h>

Inheritance diagram for Nektar::SolverUtils::FilterReynoldsStresses:

Collaboration diagram for Nektar::SolverUtils::FilterReynoldsStresses:

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

SOLVER_UTILS_EXPORT	~FilterReynoldsStresses ()

Public Member Functions inherited from Nektar::SolverUtils::FilterFieldConvert
SOLVER_UTILS_EXPORT	FilterFieldConvert (const LibUtilities::SessionReaderSharedPtr &pSession, const ParamMap &pParams)

virtual SOLVER_UTILS_EXPORT	~FilterFieldConvert ()

Public Member Functions inherited from Nektar::SolverUtils::Filter
SOLVER_UTILS_EXPORT	Filter (const LibUtilities::SessionReaderSharedPtr &pSession)

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::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::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
virtual void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

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

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

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

virtual NekDouble	v_GetScale ()

virtual std::string	v_GetFileSuffix ()

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

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

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

virtual SOLVER_UTILS_EXPORT bool	v_IsTimeDependent ()

void	CreateModules (vector< string > &modcmds)

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

void	ClearFields ()

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

vector< ModuleSharedPtr >	m_modules

LibUtilities::FieldMetaDataMap	m_fieldMetaData

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

std::vector< std::string >	m_variables

FieldSharedPtr	m_f

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

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 45 of file FilterReynoldsStresses.h.

Constructor & Destructor Documentation

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

Definition at line 67 of file FilterReynoldsStresses.cpp.

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

     : FilterFieldConvert(pSession, pParams)
 {
     ParamMap::const_iterator it;
 
     // 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, 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, 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.");
 }

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

Definition at line 130 of file FilterReynoldsStresses.cpp.

131 {

132 }

Member Function Documentation

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

inlinestatic

Creates an instance of this class.

Definition at line 51 of file FilterReynoldsStresses.h.

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

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

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

protectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 172 of file FilterReynoldsStresses.cpp.

References ASSERTL0, and Nektar::SolverUtils::FilterFieldConvert::m_variables.

 {
     int dim          = pFields.num_elements() - 1;
     int origFields   = pFields.num_elements();
 
     // Fill name of variables
     for (int n = 0; n < origFields; ++n)
     {
         m_variables.push_back(pFields[n]->GetSession()->GetVariable(n));
     }
     if (dim == 2)
     {
         m_variables.push_back("uu");
         m_variables.push_back("uv");
         m_variables.push_back("vv");
     }
     else if (dim == 3)
     {
         m_variables.push_back("uu");
         m_variables.push_back("uv");
         m_variables.push_back("uw");
         m_variables.push_back("vv");
         m_variables.push_back("vw");
         m_variables.push_back("ww");
     }
     else
     {
         ASSERTL0(false, "Unsupported dimension");
     }
 }

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

inlineprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 82 of file FilterReynoldsStresses.h.

     {
         return "_stress";
     }

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

protectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 311 of file FilterReynoldsStresses.cpp.

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

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

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

protectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 134 of file FilterReynoldsStresses.cpp.

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

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

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

protectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 285 of file FilterReynoldsStresses.cpp.

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

 {
     int dim = pFields.num_elements() - 1;
 
     m_fieldMetaData["NumberOfFieldDumps"] =
         boost::lexical_cast<std::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 (int i = 0; i < m_fields.size(); ++i)
     {
         if (i != dim)
         {
             pFields[0]->FwdTrans_IterPerExp(m_fields[i], m_outFields[i]);
         }
     }
 
     // Restore waveSpace
     pFields[0]->SetWaveSpace(waveSpace);
 }

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

protectedvirtual

Reimplemented from Nektar::SolverUtils::FilterFieldConvert.

Definition at line 204 of file FilterReynoldsStresses.cpp.

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().

 {
     int i, j, n;
     int nq             = pFields[0]->GetTotPoints();
     int dim            = pFields.num_elements() - 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(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].num_elements(),
                    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);
         }
     }
 }

Friends And Related Function Documentation

friend class MemoryManager< FilterReynoldsStresses >

friend

Definition at line 48 of file FilterReynoldsStresses.h.

Member Data Documentation

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

static

Initial value:

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

Name of the class.

Definition at line 62 of file FilterReynoldsStresses.h.

NekDouble Nektar::SolverUtils::FilterReynoldsStresses::m_alpha

protected

Definition at line 89 of file FilterReynoldsStresses.h.

Referenced by FilterReynoldsStresses(), and v_ProcessSample().

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

protected

Definition at line 88 of file FilterReynoldsStresses.h.

Referenced by v_Initialise(), and v_ProcessSample().

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

protected

Definition at line 87 of file FilterReynoldsStresses.h.

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

bool Nektar::SolverUtils::FilterReynoldsStresses::m_movAvg

protected

Definition at line 90 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

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation