Nektar::SolverUtils::FilterEnergy1D Class Reference

Filter for one-dimensional energy spectrum. More...

#include <FilterEnergy1D.h>

Inheritance diagram for Nektar::SolverUtils::FilterEnergy1D:

Public Member Functions
SOLVER_UTILS_EXPORT	FilterEnergy1D (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const ParamMap &pParams)
	Set up filter with output file and frequency parameters. More...
SOLVER_UTILS_EXPORT	~FilterEnergy1D () override
	Destructor. More...
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< 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...

Protected Member Functions
void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time) override
	Initialize filter. More...
void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time) override
	Update filter output with the current timestep's orthogonal coefficients. More...
void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time) override
bool	v_IsTimeDependent () override
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

Private Attributes
std::ofstream	m_out
	Output file. More...
unsigned int	m_outputFrequency
	Output frequency. More...
unsigned int	m_index
	Current index counter. More...

Friends
class	MemoryManager< FilterEnergy1D >

Additional Inherited Members
Public Types inherited from Nektar::SolverUtils::Filter
typedef std::map< std::string, std::string >	ParamMap
Protected Attributes inherited from Nektar::SolverUtils::Filter
LibUtilities::SessionReaderSharedPtr	m_session
const std::weak_ptr< EquationSystem >	m_equ

Detailed Description

Filter for one-dimensional energy spectrum.

This filter transforms the coefficients of each element into an orthogonal basis and outputs these coefficients at each timestep. It can be used to, for example, detect high-order oscillations in the solution field.

Definition at line 50 of file FilterEnergy1D.h.

Constructor & Destructor Documentation

FilterEnergy1D()

Nektar::SolverUtils::FilterEnergy1D::FilterEnergy1D	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< EquationSystem > &	pEquation,
		const ParamMap &	pParams
	)

Set up filter with output file and frequency parameters.

Parameters

pSession	Current session.
pParams	Map of parameters defined in XML file.

Definition at line 52 of file FilterEnergy1D.cpp.

    : Filter(pSession, pEquation), m_index(0)
{
    ASSERTL0(pSession->GetComm()->GetSize() == 1,
             "The 1D energy filter currently only works in serial.");
 
    std::string outName;
 
    // OutputFile
    auto it = pParams.find("OutputFile");
    if (it == pParams.end())
    {
        outName = m_session->GetSessionName();
    }
    else
    {
        ASSERTL0(it->second.length() > 0, "Missing parameter 'OutputFile'.");
        outName = it->second;
    }
    outName += ".eny";
    m_out.open(outName.c_str());
 
    // OutputFrequency
    it = pParams.find("OutputFrequency");
    if (it == pParams.end())
    {
        m_outputFrequency = 1;
    }
    else
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        m_outputFrequency = round(equ.Evaluate());
    }
}

References ASSERTL0, Nektar::LibUtilities::Equation::Evaluate(), m_out, m_outputFrequency, and Nektar::SolverUtils::Filter::m_session.

~FilterEnergy1D()

Nektar::SolverUtils::FilterEnergy1D::~FilterEnergy1D ( )

override

Destructor.

Definition at line 92 of file FilterEnergy1D.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 56 of file FilterEnergy1D.h.

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

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

v_Finalise()

void Nektar::SolverUtils::FilterEnergy1D::v_Finalise ( const Array< OneD, const MultiRegions::ExpListSharedPtr > &  pField, const NekDouble &  time  )

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 165 of file FilterEnergy1D.cpp.

{
    m_out.close();
}

References m_out.

v_Initialise()

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

overrideprotectedvirtual

Initialize filter.

Implements Nektar::SolverUtils::Filter.

Definition at line 99 of file FilterEnergy1D.cpp.

{
    ASSERTL0(pFields[0]->GetExp(0)->GetNumBases() == 1,
             "The Energy 1D filter is only valid in 1D.");
}

References ASSERTL0.

v_IsTimeDependent()

bool Nektar::SolverUtils::FilterEnergy1D::v_IsTimeDependent ( )

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 173 of file FilterEnergy1D.cpp.

{
    return true;
}

v_Update()

void Nektar::SolverUtils::FilterEnergy1D::v_Update ( const Array< OneD, const MultiRegions::ExpListSharedPtr > &  pField, const NekDouble &  time  )

overrideprotectedvirtual

Update filter output with the current timestep's orthogonal coefficients.

Implements Nektar::SolverUtils::Filter.

Definition at line 111 of file FilterEnergy1D.cpp.

{
    // Only output every m_outputFrequency
    if ((m_index++) % m_outputFrequency)
    {
        return;
    }
 
    int nElmt = pFields[0]->GetExpSize();
 
    // Loop over all elements
    m_out << "##" << endl;
    m_out << "## Time = " << time << endl;
    m_out << "##" << endl;
 
    for (int i = 0; i < nElmt; ++i)
    {
        // Figure out number of modes in this expansion.
        LocalRegions::ExpansionSharedPtr exp = pFields[0]->GetExp(i);
        int nModes                           = exp->GetBasis(0)->GetNumModes();
 
        // Set uo basis key for orthogonal basis
        LibUtilities::BasisType btype = LibUtilities::eOrtho_A;
        LibUtilities::BasisKey bkeyOrth(btype, nModes,
                                        exp->GetBasis(0)->GetPointsKey());
 
        // Get basis key for existing expansion
        LibUtilities::BasisKey bkey(exp->GetBasis(0)->GetBasisType(),
                                    exp->GetBasis(0)->GetNumModes(),
                                    exp->GetBasis(0)->GetPointsKey());
 
        // Find coeffs for this element in the list of all coefficients
        Array<OneD, NekDouble> coeffs =
            pFields[0]->GetCoeffs() + pFields[0]->GetCoeff_Offset(i);
 
        // Storage for orthogonal coefficients
        Array<OneD, NekDouble> coeffsOrth(nModes);
 
        // Project from coeffs -> orthogonal coeffs
        LibUtilities::InterpCoeff1D(bkey, coeffs, bkeyOrth, coeffsOrth);
 
        // Write coeffs to file
        m_out << "# Element " << i << " (ID " << exp->GetGeom()->GetGlobalID()
              << ")" << endl;
        for (int j = 0; j < nModes; ++j)
        {
            m_out << coeffsOrth[j] << endl;
        }
    }
    m_out << endl;
}

References Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::InterpCoeff1D(), m_index, m_out, and m_outputFrequency.

Friends And Related Function Documentation

MemoryManager< FilterEnergy1D >

friend class MemoryManager< FilterEnergy1D >

friend

Definition at line 1 of file FilterEnergy1D.h.

Member Data Documentation

className

std::string Nektar::SolverUtils::FilterEnergy1D::className

static

Initial value:

=
    GetFilterFactory().RegisterCreatorFunction("Energy1D",
                                               FilterEnergy1D::create)

Name of the class.

Definition at line 67 of file FilterEnergy1D.h.

m_index

unsigned int Nektar::SolverUtils::FilterEnergy1D::m_index

private

Current index counter.

Definition at line 93 of file FilterEnergy1D.h.

Referenced by v_Update().

m_out

std::ofstream Nektar::SolverUtils::FilterEnergy1D::m_out

private

Output file.

Definition at line 89 of file FilterEnergy1D.h.

Referenced by FilterEnergy1D(), v_Finalise(), and v_Update().

m_outputFrequency

unsigned int Nektar::SolverUtils::FilterEnergy1D::m_outputFrequency

private

Output frequency.

Definition at line 91 of file FilterEnergy1D.h.

Referenced by FilterEnergy1D(), and v_Update().