#include <FilterEnergyBase.h>

Inheritance diagram for Nektar::SolverUtils::FilterEnergyBase:

Collaboration diagram for Nektar::SolverUtils::FilterEnergyBase:

Public Member Functions
SOLVER_UTILS_EXPORT	FilterEnergyBase (const LibUtilities::SessionReaderSharedPtr &pSession, const std::map< std::string, std::string > &pParams, const bool pConstDensity=true)
SOLVER_UTILS_EXPORT	~FilterEnergyBase ()
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 ()

Protected Member Functions
virtual SOLVER_UTILS_EXPORT void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time)
virtual SOLVER_UTILS_EXPORT void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time)
virtual SOLVER_UTILS_EXPORT void	v_Finalise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const NekDouble &time)
virtual SOLVER_UTILS_EXPORT bool	v_IsTimeDependent ()
virtual SOLVER_UTILS_EXPORT void	v_GetVelocity (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pField, const int i, Array< OneD, NekDouble > &velocity)
virtual SOLVER_UTILS_EXPORT Array< OneD, NekDouble >	v_GetDensity (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFld)

Private Attributes
unsigned int	m_index
unsigned int	m_outputFrequency
std::ofstream	m_outFile
bool	m_homogeneous
NekDouble	m_homogeneousLength
NekDouble	m_area
LibUtilities::CommSharedPtr	m_comm
Array< OneD, unsigned int >	m_planes
bool	m_constDensity

Additional Inherited Members
Protected Attributes inherited from Nektar::SolverUtils::Filter
LibUtilities::SessionReaderSharedPtr	m_session

Detailed Description

Definition at line 45 of file FilterEnergyBase.h.

Constructor & Destructor Documentation

Nektar::SolverUtils::FilterEnergyBase::FilterEnergyBase	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::map< std::string, std::string > &	pParams,
		const bool	pConstDensity = `true`
	)

Definition at line 44 of file FilterEnergyBase.cpp.

References ASSERTL0, m_comm, m_homogeneousLength, m_outFile, m_outputFrequency, and Nektar::SolverUtils::Filter::m_session.

            : Filter        (pSession),
              m_index       (-1),
              m_homogeneous (false),
              m_planes      (),
              m_constDensity(pConstDensity)
        {
            std::string outName;
            if (pParams.find("OutputFile") == pParams.end())
            {
                outName = m_session->GetSessionName();
            }
            else
            {
                ASSERTL0(!(pParams.find("OutputFile")->second.empty()),
                         "Missing parameter 'OutputFile'.");
                outName = pParams.find("OutputFile")->second;
            }
            m_comm = pSession->GetComm();
            outName += ".eny";
            if (m_comm->GetRank() == 0)
            {
                m_outFile.open(outName.c_str());
                ASSERTL0(m_outFile.good(), "Unable to open: '" + outName + "'");
                m_outFile.setf(ios::scientific, ios::floatfield);
                m_outFile << "# Time                Kinetic energy        "
                          << "Enstrophy"
                          << endl
                          << "# ---------------------------------------------"
                          << "--------------"
                          << endl;
            }
            pSession->LoadParameter("LZ", m_homogeneousLength, 0.0);
            ASSERTL0(pParams.find("OutputFrequency") != pParams.end(),
                     "Missing parameter 'OutputFrequency'.");
            m_outputFrequency = atoi(
                pParams.find("OutputFrequency")->second.c_str());
        }

Nektar::SolverUtils::FilterEnergyBase::~FilterEnergyBase ( )

Definition at line 88 of file FilterEnergyBase.cpp.

        {
        }

Member Function Documentation

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

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 241 of file FilterEnergyBase.cpp.

References m_outFile.

        {
            m_outFile.close();
        }

Array< OneD, NekDouble > Nektar::SolverUtils::FilterEnergyBase::v_GetDensity ( const Array< OneD, const MultiRegions::ExpListSharedPtr > & pFld )

protectedvirtual

Reimplemented in Nektar::SolverUtils::FilterEnergy.

Definition at line 261 of file FilterEnergyBase.cpp.

References ASSERTL0.

Referenced by v_Update().

        {
            ASSERTL0(false, "Needs to implemented by subclass");
            return Array<OneD, NekDouble>();
        }

void Nektar::SolverUtils::FilterEnergyBase::v_GetVelocity	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pField,
		const int	i,
		Array< OneD, NekDouble > &	velocity
	)

protectedvirtual

Reimplemented in Nektar::SolverUtils::FilterEnergy, and Nektar::SolverUtils::FilterEnergy.

Definition at line 253 of file FilterEnergyBase.cpp.

References ASSERTL0.

Referenced by v_Update().

        {
            ASSERTL0(false, "Needs to implemented by subclass");
        }

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

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 93 of file FilterEnergyBase.cpp.

References ASSERTL0, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, m_area, m_homogeneous, m_homogeneousLength, m_index, m_planes, and v_Update().

        {
            m_index = -1;
            MultiRegions::ExpListSharedPtr areaField;
            ASSERTL0(pFields[0]->GetExpType() != MultiRegions::e3DH2D,
                     "Homogeneous 2D expansion not supported"
                     "for energy filter");
            if (pFields[0]->GetExpType() == MultiRegions::e3DH1D)
            {
                m_homogeneous = true;
            }
            // 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;
            }
            // Output values at initial time.
            v_Update(pFields, time);
        }

bool Nektar::SolverUtils::FilterEnergyBase::v_IsTimeDependent ( )

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 248 of file FilterEnergyBase.cpp.

        {
            return true;
        }

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

protectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 132 of file FilterEnergyBase.cpp.

References m_area, m_comm, m_constDensity, m_homogeneous, m_index, m_outFile, m_outputFrequency, v_GetDensity(), v_GetVelocity(), Vmath::Vmul(), Vmath::Vsub(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by v_Initialise().

        {
            int i, nPoints = pFields[0]->GetNpoints();
            m_index++;
            if (m_index % m_outputFrequency > 0)
            {
                return;
            }
            // Calculate kinetic energy.
            NekDouble Ek = 0.0;
            Array<OneD, NekDouble> tmp(nPoints, 0.0);
            Array<OneD, Array<OneD, NekDouble> > u(3);
            for (i = 0; i < 3; ++i)
            {
                u[i] = Array<OneD, NekDouble>(nPoints);
                v_GetVelocity(pFields, i, u[i]);
                if (m_homogeneous && pFields[i]->GetWaveSpace())
                {
                    pFields[i]->HomogeneousBwdTrans(u[i], u[i]);
                }
                Vmath::Vvtvp(nPoints, u[i], 1, u[i], 1, tmp, 1, tmp, 1);
            }
            if (!m_constDensity)
            {
                Vmath::Vmul(nPoints, v_GetDensity(pFields), 1, tmp, 1, tmp, 1);
            }
            if (m_homogeneous)
            {
                Array<OneD, NekDouble> tmp2(nPoints, 0.0);
                pFields[0]->HomogeneousFwdTrans(tmp, tmp2);
                Ek = pFields[0]->GetPlane(0)->Integral(tmp2) * 2.0 * M_PI;
            }
            else
            {
                Ek = pFields[0]->Integral(tmp);
            }
            Ek /= 2.0 * m_area;
            if (m_comm->GetRank() == 0)
            {
                m_outFile << setw(17) << setprecision(8) << time
                          << setw(22) << setprecision(11) << Ek;
            }
            bool waveSpace[3] = {
                pFields[0]->GetWaveSpace(),
                pFields[1]->GetWaveSpace(),
                pFields[2]->GetWaveSpace()
            };
            if (m_homogeneous)
            {
                for (i = 0; i < 3; ++i)
                {
                    pFields[i]->SetWaveSpace(false);
                }
            }
            // First calculate vorticity field.
            Array<OneD, NekDouble> tmp2(nPoints), tmp3(nPoints);
            Vmath::Zero(nPoints, tmp, 1);
            for (i = 0; i < 3; ++i)
            {
                int f1 = (i+2) % 3, c2 = f1;
                int c1 = (i+1) % 3, f2 = c1;
                pFields[f1]->PhysDeriv(c1, u[f1], tmp2);
                pFields[f2]->PhysDeriv(c2, u[f2], tmp3);
                Vmath::Vsub (nPoints, tmp2, 1, tmp3, 1, tmp2, 1);
                Vmath::Vvtvp(nPoints, tmp2, 1, tmp2, 1, tmp, 1, tmp, 1);
            }
            if (!m_constDensity)
            {
                Vmath::Vmul(nPoints, v_GetDensity(pFields), 1, tmp, 1, tmp, 1);
            }
            if (m_homogeneous)
            {
                for (i = 0; i < 3; ++i)
                {
                    pFields[i]->SetWaveSpace(waveSpace[i]);
                }
                pFields[0]->HomogeneousFwdTrans(tmp, tmp);
                Ek = pFields[0]->GetPlane(0)->Integral(tmp) * 2 * M_PI;
            }
            else
            {
                Ek = pFields[0]->Integral(tmp);
            }
            Ek /= 2.0*m_area;
            if (m_comm->GetRank() == 0)
            {
                m_outFile << setw(22) << setprecision(11) << Ek << endl;
            }
        }