#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 ParamMap &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
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

Detailed Description

Definition at line 45 of file FilterEnergyBase.h.

Constructor & Destructor Documentation

Nektar::SolverUtils::FilterEnergyBase::FilterEnergyBase	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const ParamMap &	pParams,
		const bool	pConstDensity = `true`
	)

Definition at line 46 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)
 {
     ParamMap::const_iterator it;
     std::string outName;
 
     // OutputFile
     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_comm = pSession->GetComm();
     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);
 
     // OutputFrequency
     it = pParams.find("OutputFrequency");
     ASSERTL0(it != pParams.end(), "Missing parameter 'OutputFrequency'.");
     LibUtilities::Equation equ(m_session, it->second);
     m_outputFrequency = floor(equ.Evaluate());
 }

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

Definition at line 94 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 247 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::FilterEnergy.

Definition at line 267 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::FilterEnergy, and Nektar::FilterEnergy.

Definition at line 259 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 99 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 254 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 138 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;
     }
 }