#include <FilterCellHistoryPoints.h>

Inheritance diagram for Nektar::FilterCellHistoryPoints:

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

	~FilterCellHistoryPoints ()

void	SetCellModel (CellModelSharedPtr &pCellModel)

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

SOLVER_UTILS_EXPORT	~FilterHistoryPoints ()

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 SolverUtils::FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_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::weak_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
virtual void	v_Update (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time)

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

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

virtual SOLVER_UTILS_EXPORT bool	v_IsTimeDependent ()

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

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

Protected Attributes
CellModelSharedPtr	m_cell

Protected Attributes inherited from Nektar::SolverUtils::FilterHistoryPoints
SpatialDomains::PointGeomVector	m_historyPoints

unsigned int	m_index

unsigned int	m_outputFrequency

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

Array< OneD, int >	m_planeIDs

bool	m_isHomogeneous1D

bool	m_waveSpace

std::string	m_outputFile

std::ofstream	m_outputStream

std::stringstream	m_historyPointStream

std::list< std::pair< SpatialDomains::PointGeomSharedPtr, Array< OneD, NekDouble > > >	m_historyList

std::map< int, int >	m_historyLocalPointMap

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

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

unsigned int	m_outputIndex

bool	m_outputOneFile

bool	m_adaptive

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

const std::weak_ptr< EquationSystem >	m_equ

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::weak_ptr< SolverUtils::EquationSystem > &	pEquation,
		const ParamMap &	pParams
	)

Definition at line 51 of file FilterCellHistoryPoints.cpp.

     : FilterHistoryPoints(pSession, pEquation, pParams)
 {
 }

◆ ~FilterCellHistoryPoints()

Nektar::FilterCellHistoryPoints::~FilterCellHistoryPoints ( )

Definition at line 62 of file FilterCellHistoryPoints.cpp.

63 {

64 }

Member Function Documentation

◆ create()

static SolverUtils::FilterSharedPtr Nektar::FilterCellHistoryPoints::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_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
	)

protectedvirtual

Reimplemented from Nektar::SolverUtils::FilterHistoryPoints.

Definition at line 69 of file FilterCellHistoryPoints.cpp.

 {
     // Only output every m_outputFrequency.
     if ((m_index++) % m_outputFrequency)
     {
         return;
     }
  
     int j                             = 0;
     int k                             = 0;
     int numPoints                     = m_historyPoints.size();
     int 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;
     int expId;
     int nppp = 0; // Number of points per plane
  
     // Pull out data values field by field
     for (j = 0; j < numFields; ++j)
     {
         k = 0;
         if (m_isHomogeneous1D)
         {
             for (auto &x : m_historyList)
             {
                 locCoord = x.second;
                 expId    = x.first->GetVid();
                 nppp     = pFields[0]->GetPlane(0)->GetTotPoints();
  
                 physvals = m_cell->GetCellSolution(j) + m_outputPlane * nppp +
                            pFields[j]->GetPhys_Offset(expId);
  
                 // interpolate point can do with zero plane methods
                 data[m_historyLocalPointMap[k++] * numFields + j] =
                     pFields[0]->GetExp(expId)->StdPhysEvaluate(locCoord,
                                                                physvals);
             }
         }
         else
         {
             for (auto &x : m_historyList)
             {
                 locCoord = x.second;
                 expId    = x.first->GetVid();
  
                 physvals = m_cell->GetCellSolution(j) +
                            pFields[0]->GetPhys_Offset(expId);
  
                 // interpolate point
                 data[m_historyLocalPointMap[k++] * 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);
  
     // Only the root process writes out history data
     if (vComm->GetRank() == 0)
     {
  
         // Write data values point by point
         for (k = 0; k < m_historyPoints.size(); ++k)
         {
             m_outputStream.width(8);
             m_outputStream << setprecision(6) << time;
             for (int j = 0; j < numFields; ++j)
             {
                 m_outputStream.width(25);
                 m_outputStream << setprecision(16) << data[k * numFields + j];
             }
             m_outputStream << endl;
         }
     }
 }

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 80 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