Nektar::SolverUtils::FilterMean Class Reference

#include <FilterMean.h>

Inheritance diagram for Nektar::SolverUtils::FilterMean:

Public Member Functions
SOLVER_UTILS_EXPORT	FilterMean (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const ParamMap &pParams)
SOLVER_UTILS_EXPORT	~FilterMean () 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 SolverUtils::FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< SolverUtils::EquationSystem > &pEquation, const ParamMap &pParams)
	Creates an instance of this class. More...

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

Protected Member Functions
SOLVER_UTILS_EXPORT void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time) override
SOLVER_UTILS_EXPORT void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time) override
SOLVER_UTILS_EXPORT void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time) override
SOLVER_UTILS_EXPORT 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
unsigned int	m_index
unsigned int	m_outputFrequency
std::string	m_outputFile
std::ofstream	m_outputStream
bool	m_homogeneous
NekDouble	m_homogeneousLength
NekDouble	m_area
Array< OneD, unsigned int >	m_planes

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

Definition at line 42 of file FilterMean.h.

Constructor & Destructor Documentation

FilterMean()

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

Definition at line 48 of file FilterMean.cpp.

    : Filter(pSession, pEquation), m_index(-1), m_homogeneous(false), m_planes()
{
    // OutputFile
    auto it = pParams.find("OutputFile");
    if (it == pParams.end())
    {
        m_outputFile = m_session->GetSessionName();
    }
    else
    {
        ASSERTL0(it->second.length() > 0, "Missing parameter 'OutputFile'.");
        m_outputFile = it->second;
    }
    m_outputFile += ".avg";
 
    // OutputFrequency
    it = pParams.find("OutputFrequency");
    ASSERTL0(it != pParams.end(), "Missing parameter 'OutputFrequency'.");
    LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
    m_outputFrequency = round(equ.Evaluate());
 
    pSession->LoadParameter("LZ", m_homogeneousLength, 0.0);
}

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

~FilterMean()

Nektar::SolverUtils::FilterMean::~FilterMean ( )

override

Definition at line 75 of file FilterMean.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 46 of file FilterMean.h.

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

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

v_Finalise()

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

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 199 of file FilterMean.cpp.

{
    if (pFields[0]->GetComm()->GetRank() == 0)
    {
        m_outputStream.close();
    }
}

References m_outputStream.

v_Initialise()

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

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 79 of file FilterMean.cpp.

{
    MultiRegions::ExpListSharedPtr areaField;
    int spacedim = 2;
 
    ASSERTL0(pFields[0]->GetExpType() != MultiRegions::e1D,
             "1D expansion not supported for mean filter");
 
    ASSERTL0(pFields[0]->GetExpType() != MultiRegions::e3DH2D,
             "Homogeneous 2D expansion not supported for mean filter");
 
    // Lock equation system pointer
    auto equ = m_equ.lock();
    ASSERTL0(equ, "Weak pointer expired");
 
    auto fluidEqu = std::dynamic_pointer_cast<FluidInterface>(equ);
    ASSERTL0(fluidEqu, "Mean filter is incompatible with this solver.");
 
    if (pFields[0]->GetExpType() == MultiRegions::e3DH1D)
    {
        m_homogeneous = true;
        spacedim      = 3;
    }
 
    // Calculate area/volume of domain.
    if (m_homogeneous)
    {
        m_planes  = pFields[0]->GetZIDs();
        areaField = pFields[0]->GetPlane(0);
    }
    else
    {
        areaField = pFields[0];
    }
 
    Array<OneD, NekDouble> inarray(areaField->GetNpoints(), 1.0);
    m_area = areaField->Integral(inarray);
 
    if (m_homogeneous)
    {
        m_area *= m_homogeneousLength;
    }
 
    // Open OutputFile
    std::string volname[3]            = {"length", "area", "volume"};
    LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
    if (vComm->GetRank() == 0)
    {
        m_outputStream.open(m_outputFile.c_str());
        ASSERTL0(m_outputStream.good(),
                 "Unable to open: '" + m_outputFile + "'");
        m_outputStream.setf(ios::scientific, ios::floatfield);
        m_outputStream << "# Time";
        for (int i = 0; i < pFields.size(); ++i)
        {
            m_outputStream << setw(22) << equ->GetVariable(i);
        }
        m_outputStream << setw(22) << volname[spacedim - 1] << " " << m_area;
        m_outputStream << endl;
    }
 
    // Output values at initial time.
    m_index = 0;
    v_Update(pFields, time);
}

References ASSERTL0, Nektar::MultiRegions::e1D, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, m_area, Nektar::SolverUtils::Filter::m_equ, m_homogeneous, m_homogeneousLength, m_index, m_outputFile, m_outputStream, m_planes, and v_Update().

v_IsTimeDependent()

bool Nektar::SolverUtils::FilterMean::v_IsTimeDependent ( )

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 210 of file FilterMean.cpp.

{
    return true;
}

v_Update()

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

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 147 of file FilterMean.cpp.

{
    // Only output every m_outputFrequency
    if ((m_index++) % m_outputFrequency)
    {
        return;
    }
 
    int i;
    LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
 
    // Calculate average values.
    Array<OneD, NekDouble> avg(pFields.size());
    for (i = 0; i < pFields.size(); ++i)
    {
        avg[i] = 0.0;
    }
 
    if (m_homogeneous)
    {
        for (i = 0; i < pFields.size(); ++i)
        {
            avg[i] = pFields[0]->GetPlane(0)->Integral(pFields[i]->GetPhys()) *
                     m_homogeneousLength;
        }
    }
    else
    {
        for (i = 0; i < pFields.size(); ++i)
        {
            avg[i] = pFields[0]->Integral(pFields[i]->GetPhys());
        }
    }
 
    for (i = 0; i < pFields.size(); ++i)
    {
        avg[i] /= m_area;
    }
 
    if (vComm->GetRank() == 0)
    {
        m_outputStream << setw(17) << setprecision(8) << time;
        for (int i = 0; i < pFields.size(); ++i)
        {
            m_outputStream << setw(22) << setprecision(11) << avg[i];
        }
        m_outputStream << endl;
    }
}

References m_area, m_homogeneous, m_homogeneousLength, m_index, m_outputFrequency, and m_outputStream.

Referenced by v_Initialise().

Member Data Documentation

className

std::string Nektar::SolverUtils::FilterMean::className

static

Initial value:

=
    SolverUtils::GetFilterFactory().RegisterCreatorFunction("Mean",
                                                            FilterMean::create)

Name of the class.

Definition at line 58 of file FilterMean.h.

m_area

NekDouble Nektar::SolverUtils::FilterMean::m_area

private

Definition at line 85 of file FilterMean.h.

Referenced by v_Initialise(), and v_Update().

m_homogeneous

bool Nektar::SolverUtils::FilterMean::m_homogeneous

private

Definition at line 83 of file FilterMean.h.

Referenced by v_Initialise(), and v_Update().

m_homogeneousLength

NekDouble Nektar::SolverUtils::FilterMean::m_homogeneousLength

private

Definition at line 84 of file FilterMean.h.

Referenced by FilterMean(), v_Initialise(), and v_Update().

m_index

unsigned int Nektar::SolverUtils::FilterMean::m_index

private

Definition at line 79 of file FilterMean.h.

Referenced by v_Initialise(), and v_Update().

m_outputFile

std::string Nektar::SolverUtils::FilterMean::m_outputFile

private

Definition at line 81 of file FilterMean.h.

Referenced by FilterMean(), and v_Initialise().

m_outputFrequency

unsigned int Nektar::SolverUtils::FilterMean::m_outputFrequency

private

Definition at line 80 of file FilterMean.h.

Referenced by FilterMean(), and v_Update().

m_outputStream

std::ofstream Nektar::SolverUtils::FilterMean::m_outputStream

private

Definition at line 82 of file FilterMean.h.

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

m_planes

Array<OneD, unsigned int> Nektar::SolverUtils::FilterMean::m_planes

private

Definition at line 86 of file FilterMean.h.

Referenced by v_Initialise().