#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;
             }
         }