#include <FilterModalEnergy.h>

Inheritance diagram for Nektar::SolverUtils::FilterModalEnergy:

Public Member Functions
SOLVER_UTILS_EXPORT	FilterModalEnergy (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const ParamMap &pParams)

SOLVER_UTILS_EXPORT	~FilterModalEnergy () 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< EquationSystem > &pEquation, const ParamMap &pParams)

Static Public Attributes
static std::string	className

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

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

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

bool	v_IsTimeDependent () override

NekDouble	L2Error (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, unsigned int field, const NekDouble &time)

void	SetUpBaseFields (SpatialDomains::MeshGraphSharedPtr &mesh)

void	ImportFldBase (std::string pInfile)

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
enum MultiRegions::ProjectionType	m_projectionType

Array< OneD, MultiRegions::ExpListSharedPtr >	m_base

LibUtilities::FieldIOSharedPtr	m_fld

std::vector< unsigned int >	m_boundaryRegionsIdList

std::vector< bool >	m_boundaryRegionIsInList

unsigned int	m_index

unsigned int	m_outputFrequency

unsigned int	m_outputPlane

bool	m_isHomogeneous1D

bool	m_isHomogeneous2D

bool	m_PertEnergy

int	m_npointsZ

int	m_nproc

std::string	m_outputFile

std::string	m_EqTypeStr

std::ofstream	m_outputStream

LibUtilities::BasisSharedPtr	m_homogeneousBasis

std::string	m_BoundaryString

int	m_nplanes

int	m_NumQuadPointsError

bool	m_SingleMode

bool	m_HalfMode

bool	m_MultipleModes

bool	m_useFFT

NekDouble	m_LhomZ

bool	m_homogen_dealiasing

Friends
class	MemoryManager< FilterModalEnergy >

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 49 of file FilterModalEnergy.h.

Constructor & Destructor Documentation

◆ FilterModalEnergy()

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

Constructor.

Definition at line 51 of file FilterModalEnergy.cpp.

    : Filter(pSession, pEquation)
{
    // 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;
    }
    if (!(m_outputFile.length() >= 4 &&
          m_outputFile.substr(m_outputFile.length() - 4) == ".mdl"))
    {
        m_outputFile += ".mdl";
    }
 
    // 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());
    }
 
    m_session->MatchSolverInfo("Homogeneous", "1D", m_isHomogeneous1D, false);
    m_session->MatchSolverInfo("Homogeneous", "2D", m_isHomogeneous2D, false);
    m_session->MatchSolverInfo("CalculatePerturbationEnergy", "True",
                               m_PertEnergy, false);
    m_session->LoadParameter("NumQuadPointsError", m_NumQuadPointsError, 0);
    m_EqTypeStr = m_session->GetSolverInfo("EQTYPE");
 
    // OutputPlane
    if (m_isHomogeneous1D || m_isHomogeneous2D)
    {
        m_session->LoadParameter("LZ", m_LhomZ);
 
        it = pParams.find("OutputPlane");
        if (it == pParams.end())
        {
            m_outputPlane = 0;
        }
        else
        {
            LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
            m_outputPlane = round(equ.Evaluate());
        }
    }
 
    m_fld = LibUtilities::FieldIO::CreateDefault(pSession);
}

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::LibUtilities::Equation::Evaluate(), m_EqTypeStr, m_fld, m_isHomogeneous1D, m_isHomogeneous2D, m_LhomZ, m_NumQuadPointsError, m_outputFile, m_outputFrequency, m_outputPlane, m_PertEnergy, and Nektar::SolverUtils::Filter::m_session.

◆ ~FilterModalEnergy()

Nektar::SolverUtils::FilterModalEnergy::~FilterModalEnergy ( )

override

Destructor.

Definition at line 115 of file FilterModalEnergy.cpp.

116{

117}

Member Function Documentation

◆ create()

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

inlinestatic

Definition at line 55 of file FilterModalEnergy.h.

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

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

◆ ImportFldBase()

void Nektar::SolverUtils::FilterModalEnergy::ImportFldBase ( std::string pInfile )

protected

Import the base flow fld file.

Definition at line 596 of file FilterModalEnergy.cpp.

{
    std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
    std::vector<std::vector<NekDouble>> FieldData;
 
    // Get Homogeneous
    m_fld->Import(pInfile, FieldDef, FieldData);
 
    int nvar = m_session->GetVariables().size();
    if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
    {
        std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
    }
    // Copy FieldData into m_fields
    for (int j = 0; j < nvar; ++j)
    {
        for (int i = 0; i < FieldDef.size(); ++i)
        {
            bool flag = FieldDef[i]->m_fields[j] == m_session->GetVariable(j);
 
            ASSERTL0(flag, (std::string("Order of ") + pInfile +
                            std::string(" data and that defined in "
                                        "m_boundaryconditions differs"))
                               .c_str());
 
            m_base[j]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                           FieldDef[i]->m_fields[j],
                                           m_base[j]->UpdateCoeffs());
        }
    }
}

References ASSERTL0, m_base, m_fld, and Nektar::SolverUtils::Filter::m_session.

Referenced by v_Update().

◆ L2Error()

NekDouble Nektar::SolverUtils::FilterModalEnergy::L2Error	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		unsigned int	field,
		const NekDouble &	time
	)

protected

Calculate the L2 norm of a given field for calculating the modal energy.

Definition at line 339 of file FilterModalEnergy.cpp.

{
    NekDouble L2error                 = -1.0;
    LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
 
    if (m_NumQuadPointsError == 0)
    {
        if (pFields[field]->GetPhysState() == false)
        {
            pFields[field]->BwdTrans(pFields[field]->GetCoeffs(),
                                     pFields[field]->UpdatePhys());
        }
    }
 
    L2error = pFields[field]->L2(pFields[field]->GetPhys());
    return L2error;
}

References m_NumQuadPointsError.

Referenced by v_Update().

◆ SetUpBaseFields()

void Nektar::SolverUtils::FilterModalEnergy::SetUpBaseFields ( SpatialDomains::MeshGraphSharedPtr & graphShrPtr )

protected

Setup the base fields in case of stability analyses.

Definition at line 362 of file FilterModalEnergy.cpp.

{
    int i;
    int m_expdim = graphShrPtr->GetMeshDimension();
 
    // definition of the projection tipe:
    if (m_session->DefinesSolverInfo("PROJECTION"))
    {
        std::string ProjectStr = m_session->GetSolverInfo("PROJECTION");
 
        if ((ProjectStr == "Continuous") || (ProjectStr == "Galerkin") ||
            (ProjectStr == "CONTINUOUS") || (ProjectStr == "GALERKIN"))
        {
            m_projectionType = MultiRegions::eGalerkin;
        }
        else if ((ProjectStr == "MixedCGDG") ||
                 (ProjectStr == "Mixed_CG_Discontinuous"))
        {
            m_projectionType = MultiRegions::eMixed_CG_Discontinuous;
        }
        else if (ProjectStr == "DisContinuous")
        {
            m_projectionType = MultiRegions::eDiscontinuous;
        }
        else
        {
            ASSERTL0(false, "PROJECTION value not recognised");
        }
    }
    else
    {
        cerr << "Projection type not specified in SOLVERINFO,"
                "defaulting to continuous Galerkin"
             << endl;
        m_projectionType = MultiRegions::eGalerkin;
    }
 
    if (m_session->DefinesSolverInfo("ModeType"))
    {
        m_session->MatchSolverInfo("ModeType", "SingleMode", m_SingleMode,
                                   false);
        m_session->MatchSolverInfo("ModeType", "HalfMode", m_HalfMode, false);
        m_session->MatchSolverInfo("ModeType", "MultipleModes", m_MultipleModes,
                                   false);
    }
 
    m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
    m_session->MatchSolverInfo("DEALIASING", "True", m_homogen_dealiasing,
                               false);
 
    // Stability Analysis flags
    if (m_session->DefinesSolverInfo("ModeType"))
    {
        if (m_SingleMode)
        {
            m_npointsZ = 2;
        }
        else if (m_HalfMode)
        {
            m_npointsZ = 1;
        }
        else if (m_MultipleModes)
        {
            m_npointsZ = m_session->GetParameter("HomModesZ");
        }
        else
        {
            ASSERTL0(false, "SolverInfo ModeType not valid");
        }
    }
    else
    {
        m_npointsZ = m_session->GetParameter("HomModesZ");
    }
 
    if (m_projectionType == MultiRegions::eGalerkin ||
        m_projectionType == MultiRegions::eMixed_CG_Discontinuous)
    {
        switch (m_expdim)
        {
            case 1:
            {
                for (i = 0; i < m_base.size(); i++)
                {
                    m_base[i] = MemoryManager<MultiRegions::ContField>::
                        AllocateSharedPtr(m_session, graphShrPtr,
                                          m_session->GetVariable(0));
                }
            }
            break;
            case 2:
            {
                if (m_isHomogeneous1D)
                {
                    if (m_SingleMode)
                    {
                        const LibUtilities::PointsKey PkeyZ(
                            m_npointsZ, LibUtilities::eFourierSingleModeSpaced);
                        const LibUtilities::BasisKey BkeyZ(
                            LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                        for (i = 0; i < m_base.size(); i++)
                        {
                            m_base[i] = MemoryManager<
                                MultiRegions::ContField3DHomogeneous1D>::
                                AllocateSharedPtr(
                                    m_session, BkeyZ, m_LhomZ, m_useFFT,
                                    m_homogen_dealiasing, graphShrPtr,
                                    m_session->GetVariable(i));
 
                            m_base[i]->SetWaveSpace(true);
                        }
                    }
                    else if (m_HalfMode)
                    {
                        // 1 plane field (half mode expansion)
                        const LibUtilities::PointsKey PkeyZ(
                            m_npointsZ, LibUtilities::eFourierSingleModeSpaced);
                        const LibUtilities::BasisKey BkeyZ(
                            LibUtilities::eFourierHalfModeRe, m_npointsZ,
                            PkeyZ);
 
                        for (i = 0; i < m_base.size(); i++)
                        {
                            m_base[i] = MemoryManager<
                                MultiRegions::ContField3DHomogeneous1D>::
                                AllocateSharedPtr(
                                    m_session, BkeyZ, m_LhomZ, m_useFFT,
                                    m_homogen_dealiasing, graphShrPtr,
                                    m_session->GetVariable(i));
 
                            m_base[i]->SetWaveSpace(true);
                        }
                    }
                    else
                    {
                        const LibUtilities::PointsKey PkeyZ(
                            m_npointsZ, LibUtilities::eFourierEvenlySpaced);
                        const LibUtilities::BasisKey BkeyZ(
                            LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                        for (i = 0; i < m_base.size(); i++)
                        {
                            m_base[i] = MemoryManager<
                                MultiRegions::ContField3DHomogeneous1D>::
                                AllocateSharedPtr(
                                    m_session, BkeyZ, m_LhomZ, m_useFFT,
                                    m_homogen_dealiasing, graphShrPtr,
                                    m_session->GetVariable(i));
 
                            m_base[i]->SetWaveSpace(false);
                        }
                    }
                }
                else
                {
                    i = 0;
                    MultiRegions::ContFieldSharedPtr firstbase =
                        MemoryManager<MultiRegions::ContField>::
                            AllocateSharedPtr(m_session, graphShrPtr,
                                              m_session->GetVariable(i));
 
                    m_base[0] = firstbase;
 
                    for (i = 1; i < m_base.size(); i++)
                    {
                        m_base[i] = MemoryManager<MultiRegions::ContField>::
                            AllocateSharedPtr(*firstbase, graphShrPtr,
                                              m_session->GetVariable(i));
                    }
                }
            }
            break;
            case 3:
            {
                MultiRegions::ContFieldSharedPtr firstbase =
                    MemoryManager<MultiRegions::ContField>::AllocateSharedPtr(
                        m_session, graphShrPtr, m_session->GetVariable(0));
                m_base[0] = firstbase;
                for (i = 1; i < m_base.size(); i++)
                {
                    m_base[i] = MemoryManager<MultiRegions::ContField>::
                        AllocateSharedPtr(*firstbase, graphShrPtr,
                                          m_session->GetVariable(0));
                }
            }
            break;
            default:
                NEKERROR(ErrorUtil::efatal,
                         "Expansion dimension not recognised");
                break;
        }
    }
    else
    {
        switch (m_expdim)
        {
            case 1:
            {
                // need to use zero for variable as may be more base
                // flows than variables
                for (i = 0; i < m_base.size(); i++)
                {
                    m_base[i] = MemoryManager<MultiRegions::DisContField>::
                        AllocateSharedPtr(m_session, graphShrPtr,
                                          m_session->GetVariable(0));
                }
                break;
            }
            case 2:
            {
                for (i = 0; i < m_base.size(); i++)
                {
                    m_base[i] = MemoryManager<MultiRegions::DisContField>::
                        AllocateSharedPtr(m_session, graphShrPtr,
                                          m_session->GetVariable(0));
                }
                break;
            }
            case 3:
                NEKERROR(ErrorUtil::efatal, "3D not set up");
                break;
            default:
                NEKERROR(ErrorUtil::efatal,
                         "Expansion dimension not recognised");
                break;
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleModeSpaced, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, m_base, m_HalfMode, m_homogen_dealiasing, m_isHomogeneous1D, m_LhomZ, m_MultipleModes, m_npointsZ, m_projectionType, Nektar::SolverUtils::Filter::m_session, m_SingleMode, m_useFFT, and NEKERROR.

Referenced by v_Update().

◆ v_Finalise()

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

overrideprotectedvirtual

Close the output stream.

Implements Nektar::SolverUtils::Filter.

Definition at line 325 of file FilterModalEnergy.cpp.

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

References m_outputStream.

◆ v_Initialise()

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

overrideprotectedvirtual

Initialize the parallel communication and the output stream.

Implements Nektar::SolverUtils::Filter.

Definition at line 122 of file FilterModalEnergy.cpp.

{
    LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
 
    if (vComm->GetRank() == 0)
    {
        // Open output stream
        bool adaptive;
        m_session->MatchSolverInfo("Driver", "Adaptive", adaptive, false);
        if (adaptive)
        {
            m_outputStream.open(m_outputFile.c_str(), ofstream::app);
        }
        else
        {
            m_outputStream.open(m_outputFile.c_str());
        }
        if (m_isHomogeneous1D)
        {
            m_outputStream << "# Time,  Fourier Mode, Energy ";
            m_outputStream << endl;
        }
        else
        {
            m_outputStream << "# Time, Energy ";
            m_outputStream << endl;
        }
    }
 
    m_index = 0;
    v_Update(pFields, time);
}

References m_index, m_isHomogeneous1D, m_outputFile, m_outputStream, Nektar::SolverUtils::Filter::m_session, and v_Update().

◆ v_IsTimeDependent()

bool Nektar::SolverUtils::FilterModalEnergy::v_IsTimeDependent ( )

overrideprotectedvirtual

Flag for time-dependent flows.

Implements Nektar::SolverUtils::Filter.

Definition at line 631 of file FilterModalEnergy.cpp.

{
    return true;
}

◆ v_Update()

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

overrideprotectedvirtual

Update the modal energy every m_outputFrequency.

Implements Nektar::SolverUtils::Filter.

Definition at line 160 of file FilterModalEnergy.cpp.

{
    // Only output every m_outputFrequency
    if ((m_index++) % m_outputFrequency)
    {
        return;
    }
 
    LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
 
    // Homogeneous 1D implementation
    if (m_isHomogeneous1D)
    {
        int colrank = vComm->GetColumnComm()->GetRank();
        int nproc   = vComm->GetColumnComm()->GetSize();
        m_npointsZ  = (m_session->GetParameter("HomModesZ"));
        int locsize = m_npointsZ / nproc / 2;
 
        Array<OneD, NekDouble> energy(locsize, 0.0);
        Array<OneD, NekDouble> energy_tmp(locsize, 0.0);
        Array<OneD, NekDouble> tmp;
 
        // Calculate the energy of the perturbation for stability
        // analysis
        if (m_PertEnergy)
        {
            // Compressible Flow Solver
            if (m_EqTypeStr == "EulerCFE" || m_EqTypeStr == "EulerADCFE" ||
                m_EqTypeStr == "NavierStokesCFE")
            {
                ASSERTL0(false, "Stability analysis module not "
                                "implemented for the Compressible Flow "
                                "Solver. Please remove the function BaseFlow "
                                "from your .xml file");
            }
            // Incompressible Navier-Stokes Solver
            else
            {
                SpatialDomains::MeshGraphSharedPtr graphShrPtr =
                    SpatialDomains::MeshGraph::Read(m_session);
                SetUpBaseFields(graphShrPtr);
                string file = m_session->GetFunctionFilename("BaseFlow", 0);
                ImportFldBase(file);
 
                for (int i = 0; i < pFields.size() - 1; ++i)
                {
                    Vmath::Vsub(pFields[i]->GetNcoeffs(),
                                pFields[i]->GetCoeffs(), 1,
                                m_base[i]->GetCoeffs(), 1,
                                pFields[i]->UpdateCoeffs(), 1);
 
                    energy_tmp = pFields[i]->HomogeneousEnergy();
                    Vmath::Vadd(locsize, energy_tmp, 1, energy, 1, energy, 1);
 
                    Vmath::Vadd(pFields[i]->GetNcoeffs(),
                                pFields[i]->GetCoeffs(), 1,
                                m_base[i]->GetCoeffs(), 1,
                                pFields[i]->UpdateCoeffs(), 1);
                }
            }
        }
        // Calculate the modal energy for general simulation
        else
        {
            // Compressible Flow Solver
            if (m_EqTypeStr == "EulerCFE" || m_EqTypeStr == "EulerADCFE" ||
                m_EqTypeStr == "NavierStokesCFE")
            {
                // Extracting kinetic energy
                for (int i = 1; i < pFields.size() - 1; ++i)
                {
                    energy_tmp = pFields[i]->HomogeneousEnergy();
                    Vmath::Vadd(locsize, energy_tmp, 1, energy, 1, energy, 1);
                }
            }
            // Incompressible Navier-Stokes Solver
            else
            {
                // Extracting kinetic energy
                for (int i = 0; i < pFields.size() - 1; ++i)
                {
                    energy_tmp = pFields[i]->HomogeneousEnergy();
                    Vmath::Vadd(locsize, energy_tmp, 1, energy, 1, energy, 1);
                }
            }
        }
 
        // Send to root process
        if (colrank == 0)
        {
            int j, m = 0;
 
            for (j = 0; j < energy.size(); ++j, ++m)
            {
                m_outputStream << setw(10) << time << setw(5) << m << setw(18)
                               << energy[j] << endl;
            }
 
            for (int i = 1; i < nproc; ++i)
            {
                vComm->GetColumnComm()->Recv(i, energy);
 
                for (j = 0; j < energy.size(); ++j, ++m)
                {
                    m_outputStream << setw(10) << time << setw(5) << m
                                   << setw(18) << energy[j] << endl;
                }
            }
        }
        else
        {
            vComm->GetColumnComm()->Send(0, energy);
        }
    }
    // Homogeneous 2D implementation
    else if (m_isHomogeneous2D)
    {
        ASSERTL0(false, "3D Homogeneous 2D energy "
                        "dumping not implemented yet");
    }
    // General implementation
    else
    {
        // Compressible Flow Solver
        if (m_EqTypeStr == "EulerCFE" || m_EqTypeStr == "EulerADCFE" ||
            m_EqTypeStr == "NavierStokesCFE")
        {
            // Total energy
            NekDouble energy = 0.0;
            for (int i = 1; i < pFields.size() - 1; ++i)
            {
                pFields[i]->SetPhysState(true);
                NekDouble norm = L2Error(pFields, i, time);
                energy += norm * norm;
            }
 
            m_outputStream << setprecision(6) << time;
            m_outputStream.width(25);
            m_outputStream << setprecision(8) << 0.5 * energy;
            m_outputStream << endl;
        }
        // Incompressible Navier-Stokes Solver
        else
        {
            // Kinetic energy
            NekDouble energy = 0.0;
            for (int i = 0; i < pFields.size() - 1; ++i)
            {
                pFields[i]->SetPhysState(true);
                NekDouble norm = L2Error(pFields, i, time);
                energy += norm * norm;
            }
            m_outputStream << setprecision(6) << time;
            m_outputStream.width(25);
            m_outputStream << setprecision(8) << 0.5 * energy;
            m_outputStream << endl;
        }
    }
}

References ASSERTL0, ImportFldBase(), L2Error(), m_base, m_EqTypeStr, m_index, m_isHomogeneous1D, m_isHomogeneous2D, m_npointsZ, m_outputFrequency, m_outputStream, m_PertEnergy, Nektar::SolverUtils::Filter::m_session, Nektar::SpatialDomains::MeshGraph::Read(), SetUpBaseFields(), Vmath::Vadd(), and Vmath::Vsub().

Referenced by v_Initialise().

Friends And Related Function Documentation

◆ MemoryManager< FilterModalEnergy >

friend class MemoryManager< FilterModalEnergy >

friend

Definition at line 1 of file FilterModalEnergy.h.

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::FilterModalEnergy::className

static

Initial value:

=
    GetFilterFactory().RegisterCreatorFunction("ModalEnergy",
                                               FilterModalEnergy::create)

Definition at line 65 of file FilterModalEnergy.h.

◆ m_base

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::FilterModalEnergy::m_base

private

Definition at line 92 of file FilterModalEnergy.h.

Referenced by ImportFldBase(), SetUpBaseFields(), and v_Update().

◆ m_boundaryRegionIsInList

std::vector<bool> Nektar::SolverUtils::FilterModalEnergy::m_boundaryRegionIsInList

private

Definition at line 99 of file FilterModalEnergy.h.

◆ m_boundaryRegionsIdList

std::vector<unsigned int> Nektar::SolverUtils::FilterModalEnergy::m_boundaryRegionsIdList

private

Definition at line 96 of file FilterModalEnergy.h.

◆ m_BoundaryString

std::string Nektar::SolverUtils::FilterModalEnergy::m_BoundaryString

private

Definition at line 114 of file FilterModalEnergy.h.

◆ m_EqTypeStr

std::string Nektar::SolverUtils::FilterModalEnergy::m_EqTypeStr

private

Definition at line 111 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and v_Update().

◆ m_fld

LibUtilities::FieldIOSharedPtr Nektar::SolverUtils::FilterModalEnergy::m_fld

private

Definition at line 93 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and ImportFldBase().

◆ m_HalfMode

bool Nektar::SolverUtils::FilterModalEnergy::m_HalfMode

private

Definition at line 118 of file FilterModalEnergy.h.

Referenced by SetUpBaseFields().

◆ m_homogen_dealiasing

bool Nektar::SolverUtils::FilterModalEnergy::m_homogen_dealiasing

private

Definition at line 122 of file FilterModalEnergy.h.

Referenced by SetUpBaseFields().

◆ m_homogeneousBasis

LibUtilities::BasisSharedPtr Nektar::SolverUtils::FilterModalEnergy::m_homogeneousBasis

private

Definition at line 113 of file FilterModalEnergy.h.

◆ m_index

unsigned int Nektar::SolverUtils::FilterModalEnergy::m_index

private

Definition at line 100 of file FilterModalEnergy.h.

Referenced by v_Initialise(), and v_Update().

◆ m_isHomogeneous1D

bool Nektar::SolverUtils::FilterModalEnergy::m_isHomogeneous1D

private

Definition at line 105 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), SetUpBaseFields(), v_Initialise(), and v_Update().

◆ m_isHomogeneous2D

bool Nektar::SolverUtils::FilterModalEnergy::m_isHomogeneous2D

private

Definition at line 106 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and v_Update().

◆ m_LhomZ

NekDouble Nektar::SolverUtils::FilterModalEnergy::m_LhomZ

private

Definition at line 121 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and SetUpBaseFields().

◆ m_MultipleModes

bool Nektar::SolverUtils::FilterModalEnergy::m_MultipleModes

private

Definition at line 119 of file FilterModalEnergy.h.

Referenced by SetUpBaseFields().

◆ m_nplanes

int Nektar::SolverUtils::FilterModalEnergy::m_nplanes

private

Definition at line 115 of file FilterModalEnergy.h.

◆ m_npointsZ

int Nektar::SolverUtils::FilterModalEnergy::m_npointsZ

private

Definition at line 108 of file FilterModalEnergy.h.

Referenced by SetUpBaseFields(), and v_Update().

◆ m_nproc

int Nektar::SolverUtils::FilterModalEnergy::m_nproc

private

Definition at line 109 of file FilterModalEnergy.h.

◆ m_NumQuadPointsError

int Nektar::SolverUtils::FilterModalEnergy::m_NumQuadPointsError

private

Definition at line 116 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and L2Error().

◆ m_outputFile

std::string Nektar::SolverUtils::FilterModalEnergy::m_outputFile

private

Definition at line 110 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and v_Initialise().

◆ m_outputFrequency

unsigned int Nektar::SolverUtils::FilterModalEnergy::m_outputFrequency

private

Definition at line 101 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and v_Update().

◆ m_outputPlane

unsigned int Nektar::SolverUtils::FilterModalEnergy::m_outputPlane

private

Definition at line 104 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy().

◆ m_outputStream

std::ofstream Nektar::SolverUtils::FilterModalEnergy::m_outputStream

private

Definition at line 112 of file FilterModalEnergy.h.

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

◆ m_PertEnergy

bool Nektar::SolverUtils::FilterModalEnergy::m_PertEnergy

private

Definition at line 107 of file FilterModalEnergy.h.

Referenced by FilterModalEnergy(), and v_Update().

◆ m_projectionType

enum MultiRegions::ProjectionType Nektar::SolverUtils::FilterModalEnergy::m_projectionType

private

Definition at line 91 of file FilterModalEnergy.h.

Referenced by SetUpBaseFields().

◆ m_SingleMode

bool Nektar::SolverUtils::FilterModalEnergy::m_SingleMode

private

Definition at line 117 of file FilterModalEnergy.h.

Referenced by SetUpBaseFields().

◆ m_useFFT

bool Nektar::SolverUtils::FilterModalEnergy::m_useFFT

private

Definition at line 120 of file FilterModalEnergy.h.

Referenced by SetUpBaseFields().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FilterModalEnergy()

◆ ~FilterModalEnergy()

Member Function Documentation

◆ create()

◆ ImportFldBase()

◆ L2Error()

◆ SetUpBaseFields()

◆ v_Finalise()

◆ v_Initialise()

◆ v_IsTimeDependent()

◆ v_Update()

Friends And Related Function Documentation

◆ MemoryManager< FilterModalEnergy >

Member Data Documentation

◆ className

◆ m_base

◆ m_boundaryRegionIsInList

◆ m_boundaryRegionsIdList

◆ m_BoundaryString

◆ m_EqTypeStr

◆ m_fld

◆ m_HalfMode

◆ m_homogen_dealiasing

◆ m_homogeneousBasis

◆ m_index

◆ m_isHomogeneous1D

◆ m_isHomogeneous2D

◆ m_LhomZ

◆ m_MultipleModes

◆ m_nplanes

◆ m_npointsZ

◆ m_nproc

◆ m_NumQuadPointsError

◆ m_outputFile

◆ m_outputFrequency

◆ m_outputPlane

◆ m_outputStream

◆ m_PertEnergy

◆ m_projectionType

◆ m_SingleMode

◆ m_useFFT