#include <FilterCellHistoryPoints.h>

Inheritance diagram for Nektar::FilterCellHistoryPoints:

Public Member Functions
	FilterCellHistoryPoints (const LibUtilities::SessionReaderSharedPtr &pSession, const std::shared_ptr< SolverUtils::EquationSystem > &pEquation, const ParamMap &pParams)

	~FilterCellHistoryPoints () override

void	SetCellModel (CellModelSharedPtr &pCellModel)

Public Member Functions inherited from Nektar::SolverUtils::FilterHistoryPoints
SOLVER_UTILS_EXPORT	FilterHistoryPoints (const LibUtilities::SessionReaderSharedPtr &pSession, const std::shared_ptr< EquationSystem > &pEquation, const ParamMap &pParams)

SOLVER_UTILS_EXPORT	~FilterHistoryPoints () override

Public Member Functions inherited from Nektar::SolverUtils::Filter
SOLVER_UTILS_EXPORT	Filter (const LibUtilities::SessionReaderSharedPtr &pSession, const std::shared_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 ()

SOLVER_UTILS_EXPORT std::string	SetupOutput (const std::string ext, const ParamMap &pParams)

SOLVER_UTILS_EXPORT std::string	SetupOutput (const std::string ext, const std::string inname)

SOLVER_UTILS_EXPORT void	SetUpdateOnInitialise (bool flag)

Static Public Member Functions
static SolverUtils::FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::shared_ptr< SolverUtils::EquationSystem > &pEquation, const ParamMap &pParams)
	Creates an instance of this class. More...

Static Public Member Functions inherited from Nektar::SolverUtils::FilterHistoryPoints
static FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::shared_ptr< EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)
	Creates an instance of this class. More...

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

Static Public Attributes inherited from Nektar::SolverUtils::FilterHistoryPoints
static std::string	className
	Name of the class. More...

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

virtual void	v_WriteData (const int &rank, const Array< OneD, NekDouble > &data, const int &numFields, const NekDouble &time)

Protected Member Functions inherited from Nektar::SolverUtils::FilterHistoryPoints
SOLVER_UTILS_EXPORT void	v_Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time) override

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

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

SOLVER_UTILS_EXPORT bool	v_IsTimeDependent () override

bool	GetPoint (Array< OneD, NekDouble > gloCoord, int I)

SOLVER_UTILS_EXPORT void	v_WriteData (const int &rank, const Array< OneD, NekDouble > &data, const int &numFields, const NekDouble &time)

Protected Member Functions inherited from Nektar::SolverUtils::Filter
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

virtual SOLVER_UTILS_EXPORT std::string	v_SetupOutput (const std::string ext, const ParamMap &pParams)

virtual SOLVER_UTILS_EXPORT std::string	v_SetupOutput (const std::string ext, const std::string inname)

Protected Attributes
CellModelSharedPtr	m_cell

Protected Attributes inherited from Nektar::SolverUtils::FilterHistoryPoints
Array< OneD, Array< OneD, const NekDouble > >	m_historyPoints

size_t	m_historyPointsSize = 0

unsigned int	m_index = 0

unsigned int	m_outputFrequency

int	m_outputPlane
	plane to take history point from if using a homogeneous1D expansion More...

std::vector< int >	m_planeIDs

bool	m_isHomogeneous1D

bool	m_waveSpace

std::string	m_outputFile

std::ofstream	m_outputStream

std::stringstream	m_historyPointStream

std::list< std::tuple< Array< OneD, const NekDouble >, Array< OneD, const NekDouble >, int, int > >	m_historyList

std::map< LibUtilities::PtsType, Array< OneD, NekDouble > >	m_pointDatMap

std::map< LibUtilities::PtsType, Array< OneD, int > >	m_pointNumMap

unsigned int	m_outputIndex = 0

bool	m_outputOneFile

bool	m_adaptive

Protected Attributes inherited from Nektar::SolverUtils::Filter
LibUtilities::SessionReaderSharedPtr	m_session

const std::weak_ptr< EquationSystem >	m_equ

bool	m_updateOnInitialise = true

Friends
class	MemoryManager< FilterCellHistoryPoints >

Additional Inherited Members
Public Types inherited from Nektar::SolverUtils::Filter
typedef std::map< std::string, std::string >	ParamMap

Detailed Description

Definition at line 44 of file FilterCellHistoryPoints.h.

Constructor & Destructor Documentation

◆ FilterCellHistoryPoints()

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

Definition at line 52 of file FilterCellHistoryPoints.cpp.

    : FilterHistoryPoints(pSession, pEquation, pParams)
{
}

◆ ~FilterCellHistoryPoints()

Nektar::FilterCellHistoryPoints::~FilterCellHistoryPoints ( )

override

Definition at line 63 of file FilterCellHistoryPoints.cpp.

64{

65}

Member Function Documentation

◆ create()

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

inlinestatic

Creates an instance of this class.

Definition at line 50 of file FilterCellHistoryPoints.h.

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

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

◆ SetCellModel()

void Nektar::FilterCellHistoryPoints::SetCellModel ( CellModelSharedPtr & pCellModel )

inline

Definition at line 70 of file FilterCellHistoryPoints.h.

    {
        m_cell = pCellModel;
    }

References m_cell.

◆ v_Update()

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

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::FilterHistoryPoints.

Definition at line 70 of file FilterCellHistoryPoints.cpp.

{
    // Only output every m_outputFrequency.
    if ((m_index++) % m_outputFrequency)
    {
        return;
    }
 
    const size_t numPoints            = m_historyPoints.size();
    const size_t numFields            = m_cell->GetNumCellVariables();
    LibUtilities::CommSharedPtr vComm = pFields[0]->GetComm();
    Array<OneD, NekDouble> data(numPoints * numFields, 0.0);
    Array<OneD, NekDouble> gloCoord(3, 0.0);
    Array<OneD, NekDouble> physvals;
    Array<OneD, NekDouble> locCoord;
 
    // Pull out data values field by field
    for (size_t j = 0; j < numFields; ++j)
    {
        if (m_isHomogeneous1D)
        {
            // Number of points per plane
            const int nppp = pFields[0]->GetPlane(0)->GetTotPoints();
 
            for (auto &x : m_historyList)
            {
                locCoord        = std::get<1>(x);
                const int indx  = std::get<2>(x);
                const int expId = std::get<3>(x);
 
                physvals = m_cell->GetCellSolution(j) + m_outputPlane * nppp +
                           pFields[j]->GetPhys_Offset(expId);
 
                // interpolate point
                data[indx * numFields + j] =
                    pFields[0]->GetExp(expId)->StdPhysEvaluate(locCoord,
                                                               physvals);
            }
        }
        else
        {
            for (auto &x : m_historyList)
            {
                locCoord        = std::get<1>(x);
                const int indx  = std::get<2>(x);
                const int expId = std::get<3>(x);
 
                physvals = m_cell->GetCellSolution(j) +
                           pFields[0]->GetPhys_Offset(expId);
 
                // interpolate point
                data[indx * numFields + j] =
                    pFields[0]->GetExp(expId)->StdPhysEvaluate(locCoord,
                                                               physvals);
            }
        }
    }
 
    // Exchange history data
    // This could be improved to reduce communication but works for now
    vComm->AllReduce(data, LibUtilities::ReduceSum);
    v_WriteData(vComm->GetRank(), data, numFields, time);
}

References m_cell, Nektar::SolverUtils::FilterHistoryPoints::m_historyList, Nektar::SolverUtils::FilterHistoryPoints::m_historyPoints, Nektar::SolverUtils::FilterHistoryPoints::m_index, Nektar::SolverUtils::FilterHistoryPoints::m_isHomogeneous1D, Nektar::SolverUtils::FilterHistoryPoints::m_outputFrequency, Nektar::SolverUtils::FilterHistoryPoints::m_outputPlane, Nektar::LibUtilities::ReduceSum, and v_WriteData().

◆ v_WriteData()

void Nektar::FilterCellHistoryPoints::v_WriteData	(	const int &	rank,
		const Array< OneD, NekDouble > &	data,
		const int &	numFields,
		const NekDouble &	time
	)

protectedvirtual

Definition at line 136 of file FilterCellHistoryPoints.cpp.

{
    // Only the root process writes out history data
    if (rank > 0)
    {
        return;
    }
 
    Array<OneD, NekDouble> gloCoord(3, 0.0);
    if (!m_outputOneFile || m_index == 1)
    {
        std::stringstream vTmpFilename;
        std::string vOutputFilename;
        // get the file extension
        std::string ext = fs::path(m_outputFile).extension().string();
        ext             = (ext == "") ? ".his" : ext;
        if (m_outputOneFile)
        {
            vTmpFilename << fs::path(m_outputFile).replace_extension(ext);
        }
        else
        {
            vTmpFilename
                << fs::path(m_outputFile).replace_extension("").string() << "_"
                << m_outputIndex << ext;
        }
        // back up the file if already exists and backup switch is turned on
        vOutputFilename = Filter::SetupOutput(ext, vTmpFilename.str());
 
        ++m_outputIndex;
        if (m_adaptive)
        {
            m_outputStream.open(vOutputFilename.c_str(), ofstream::app);
        }
        else
        {
            m_outputStream.open(vOutputFilename.c_str());
        }
 
        if (m_isHomogeneous1D)
        {
            m_outputStream << ") at points:" << endl;
        }
        else
        {
            m_outputStream << ") at points:" << endl;
        }
 
        for (int i = 0; i < m_historyPoints.size(); ++i)
        {
            gloCoord = m_historyPoints[i];
 
            m_outputStream << "# " << boost::format("%6.0f") % i;
            m_outputStream << " " << boost::format("%15.9e") % gloCoord[0];
            m_outputStream << " " << boost::format("%15.9e") % gloCoord[1];
            m_outputStream << " " << boost::format("%15.9e") % gloCoord[2];
            m_outputStream << endl;
        }
 
        if (m_isHomogeneous1D)
        {
            if (m_waveSpace)
            {
                m_outputStream << "# (in Wavespace)" << endl;
            }
        }
    }
 
    // Write data values point by point
    for (int k = 0; k < m_historyPoints.size(); ++k)
    {
        m_outputStream << boost::format("%15.9e") % time;
        for (int j = 0; j < numFields; ++j)
        {
            m_outputStream << " "
                           << boost::format("%15.9e") % data[k * numFields + j];
        }
        m_outputStream << endl;
    }
 
    if (!m_outputOneFile)
    {
        m_outputStream.close();
    }
}

Referenced by v_Update().

Friends And Related Function Documentation

◆ MemoryManager< FilterCellHistoryPoints >

friend class MemoryManager< FilterCellHistoryPoints >

friend

Definition at line 1 of file FilterCellHistoryPoints.h.

Member Data Documentation

◆ className

std::string Nektar::FilterCellHistoryPoints::className

static

Initial value:

=
    SolverUtils::GetFilterFactory().RegisterCreatorFunction(
        "CellHistoryPoints", FilterCellHistoryPoints::create)

Name of the class.

Definition at line 62 of file FilterCellHistoryPoints.h.

◆ m_cell

CellModelSharedPtr Nektar::FilterCellHistoryPoints::m_cell

protected

Definition at line 83 of file FilterCellHistoryPoints.h.

Referenced by SetCellModel(), and v_Update().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members