#include <FilterLagrangianPoints.h>

Inheritance diagram for Nektar::SolverUtils::FilterLagrangianPoints:

Classes
struct	MovingFrame

Public Member Functions
SOLVER_UTILS_EXPORT	FilterLagrangianPoints (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)

SOLVER_UTILS_EXPORT	~FilterLagrangianPoints () override

Public Member Functions inherited from Nektar::SolverUtils::EvaluatePoints
SOLVER_UTILS_EXPORT	EvaluatePoints ()

virtual	~EvaluatePoints ()

SOLVER_UTILS_EXPORT void	PartitionMobilePts (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields)

SOLVER_UTILS_EXPORT void	EvaluateMobilePhys (const MultiRegions::ExpListSharedPtr &pField, std::vector< Array< OneD, NekDouble > > &PhysicsData, NekDouble time)

SOLVER_UTILS_EXPORT void	PassMobilePhysToStatic (std::map< int, std::set< int > > &callbackUpdateMobCoords)

SOLVER_UTILS_EXPORT void	PassStaticCoordsToMobile (std::map< int, std::set< int > > &callbackUpdateMobCoords)

SOLVER_UTILS_EXPORT void	CopyStaticPtsToMobile ()

SOLVER_UTILS_EXPORT void	CopyMobilePtsToStatic ()

SOLVER_UTILS_EXPORT void	Initialise (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, const NekDouble &time, std::vector< std::string > &defaultValues)

SOLVER_UTILS_EXPORT void	SetUpCommInfo ()

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 FilterSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const std::map< std::string, std::string > &pParams)

Static Public Attributes
static std::string	className

Protected Member Functions
void	ExtraPhysicsVars (std::vector< std::string > &extraVars)

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

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

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

bool	v_IsTimeDependent () override

void	v_ModifyVelocity (Array< OneD, NekDouble > gcoords, NekDouble time, Array< OneD, NekDouble > vel) override

void	GetPhysicsData (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, std::vector< Array< OneD, NekDouble > > &PhysicsData)

void	OutputSamplePoints (NekDouble time)

void	OutputStatPoints (NekDouble time)

Protected Member Functions inherited from Nektar::SolverUtils::EvaluatePoints
void	UpdateMobileCoords (std::map< int, Array< OneD, NekDouble > > &globalCoords)

void	GatherMobilePhysics (std::map< int, Array< OneD, NekDouble > > &revData)

void	PartitionLocalPoints (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, std::set< int > &notfound)

void	PartitionExchangeNonlocalPoints (const Array< OneD, const MultiRegions::ExpListSharedPtr > &pFields, std::set< int > &notfound)

void	SyncColumnComm ()

NekDouble	GetDefaultValue (const int i, const Array< OneD, const NekDouble > x, const NekDouble time)

void	Pack2Int (const int &a, const int &b, double &d)

void	unPack2Int (int &a, int &b, const double &d)

void	Pack3Int (const int &a, const int &b, const int &c, double &d)

void	unPack3Int (int &a, int &b, int &c, const double &d)

void	Pack2Short (const int &a, const int &b, int &c)

void	unPack2Short (int &a, int &b, const int &c)

virtual void	v_ModifyVelocity (Array< OneD, NekDouble > gcoords, NekDouble time, Array< OneD, NekDouble > vel)

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

Protected Attributes
std::vector< std::string >	m_defaultValues

struct Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame	m_frame

std::vector< NekDouble >	m_box

std::map< std::string, std::string >	v_params

unsigned int	m_index = 0

unsigned int	m_outputFrequency

std::string	m_outputFile

bool	m_outputL2Norm

bool	m_isMovablePoints

unsigned int	m_outputSampleFrequency

std::set< int >	m_samplePointIDs

std::ofstream	m_ofstreamSamplePoints

Protected Attributes inherited from Nektar::SolverUtils::EvaluatePoints
int	m_spacedim

int	m_rank

int	m_rowRank

int	m_columnRank

bool	m_isHomogeneous1D

int	m_nPhysics

LibUtilities::CommSharedPtr	m_comm

StationaryPointsSharedPtr	m_staticPts

std::map< int, MobilePointSharedPtr >	m_mobilePts

std::map< int, LibUtilities::EquationSharedPtr >	m_defaultValueFunction

std::map< int, int >	m_recvMobInfo

std::map< int, int >	m_recvStatInfo

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

const std::weak_ptr< EquationSystem >	m_equ

Friends
class	MemoryManager< FilterLagrangianPoints >

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

Detailed Description

Definition at line 97 of file FilterLagrangianPoints.h.

Constructor & Destructor Documentation

◆ FilterLagrangianPoints()

Nektar::SolverUtils::FilterLagrangianPoints::FilterLagrangianPoints	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< EquationSystem > &	pEquation,
		const std::map< std::string, std::string > &	pParams
	)

Definition at line 447 of file FilterLagrangianPoints.cpp.

    : Filter(pSession, pEquation), v_params(pParams)
{
}

◆ ~FilterLagrangianPoints()

Nektar::SolverUtils::FilterLagrangianPoints::~FilterLagrangianPoints ( )

override

Definition at line 458 of file FilterLagrangianPoints.cpp.

{
    m_ofstreamSamplePoints.close();
}

References m_ofstreamSamplePoints.

Member Function Documentation

◆ create()

static FilterSharedPtr Nektar::SolverUtils::FilterLagrangianPoints::create	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const std::weak_ptr< EquationSystem > &	pEquation,
		const std::map< std::string, std::string > &	pParams
	)

inlinestatic

Definition at line 102 of file FilterLagrangianPoints.h.

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

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

◆ ExtraPhysicsVars()

void Nektar::SolverUtils::FilterLagrangianPoints::ExtraPhysicsVars ( std::vector< std::string > & extraVars )

protected

Definition at line 678 of file FilterLagrangianPoints.cpp.

{
    if (m_spacedim == 2)
    {
        extraVars.push_back("u_x");
        extraVars.push_back("u_y");
        extraVars.push_back("v_x");
        extraVars.push_back("v_y");
        extraVars.push_back("LW_z");
    }
    else if (m_spacedim == 3)
    {
        extraVars.push_back("u_x");
        extraVars.push_back("u_y");
        extraVars.push_back("u_z");
        extraVars.push_back("v_x");
        extraVars.push_back("v_y");
        extraVars.push_back("v_z");
        extraVars.push_back("w_x");
        extraVars.push_back("w_y");
        extraVars.push_back("w_z");
        extraVars.push_back("LW_x");
        extraVars.push_back("LW_y");
        extraVars.push_back("LW_z");
    }
}

References Nektar::SolverUtils::EvaluatePoints::m_spacedim.

Referenced by v_Initialise().

◆ GetPhysicsData()

void Nektar::SolverUtils::FilterLagrangianPoints::GetPhysicsData	(	const Array< OneD, const MultiRegions::ExpListSharedPtr > &	pFields,
		std::vector< Array< OneD, NekDouble > > &	PhysicsData
	)

protected

Definition at line 706 of file FilterLagrangianPoints.cpp.

{
    int npts = pFields[0]->GetTotPoints();
    for (int i = 0; i < m_spacedim; ++i)
    {
        PhysicsData.push_back(pFields[i]->UpdatePhys());
    }
    int offset = PhysicsData.size();
    for (int d = 0; d < m_spacedim; ++d)
    {
        Array<OneD, Array<OneD, NekDouble>> data(m_spacedim);
        for (int i = 0; i < m_spacedim; ++i)
        {
            data[i] = Array<OneD, NekDouble>(npts, 0.);
        }
        if (m_spacedim == 2)
        {
            pFields[d]->PhysDeriv(pFields[d]->UpdatePhys(), data[0], data[1]);
        }
        else if (m_spacedim == 3)
        {
            pFields[d]->PhysDeriv(pFields[d]->UpdatePhys(), data[0], data[1],
                                  data[2]);
        }
        for (int i = 0; i < m_spacedim; ++i)
        {
            PhysicsData.push_back(data[i]);
        }
    }
    int vortexdim = m_spacedim == 3 ? 3 : 1;
    Array<OneD, Array<OneD, NekDouble>> vorticity(vortexdim);
    Array<OneD, Array<OneD, NekDouble>> Ldata(vortexdim);
    Array<OneD, Array<OneD, NekDouble>> temp(m_spacedim);
    Array<OneD, NekDouble> temps(npts, 0.);
    for (int d = 0; d < vortexdim; ++d)
    {
        Ldata[d]     = Array<OneD, NekDouble>(npts, 0.);
        vorticity[d] = Array<OneD, NekDouble>(npts, 0.);
    }
    for (int d = 0; d < m_spacedim; ++d)
    {
        temp[d] = Array<OneD, NekDouble>(npts, 0.);
    }
    if (m_spacedim == 2)
    {
        // 0 ux, 1 uy, 2 vx, 3 vy
        Vmath::Vsub(npts, PhysicsData[offset + 2], 1, PhysicsData[offset + 1],
                    1, vorticity[0], 1); // vx-uy
    }
    else if (m_spacedim == 3)
    {
        // 0 ux, 1 uy, 2 uz, 3 vx, 4 vy, 5 vz, 6 wx, 7 wy, 8 wz
        Vmath::Vsub(npts, PhysicsData[offset + 7], 1, PhysicsData[offset + 5],
                    1, vorticity[0], 1); // wy-vz
        Vmath::Vsub(npts, PhysicsData[offset + 2], 1, PhysicsData[offset + 6],
                    1, vorticity[1], 1); // uz-wx
        Vmath::Vsub(npts, PhysicsData[offset + 3], 1, PhysicsData[offset + 1],
                    1, vorticity[2], 1); // vx-uy
    }
    for (int d = 0; d < vortexdim; ++d)
    {
        if (m_spacedim == 2)
        {
            pFields[0]->PhysDeriv(vorticity[d], temp[0], temp[1]);
        }
        else if (m_spacedim == 3)
        {
            pFields[0]->PhysDeriv(vorticity[d], temp[0], temp[1], temp[2]);
        }
        for (int j = 0; j < m_spacedim; ++j)
        {
            pFields[0]->PhysDeriv(j, temp[j], temps);
            Vmath::Vadd(npts, temps, 1, Ldata[d], 1, Ldata[d], 1);
        }
        PhysicsData.push_back(Ldata[d]);
    }
}

References Nektar::UnitTests::d(), Nektar::SolverUtils::EvaluatePoints::m_spacedim, Vmath::Vadd(), and Vmath::Vsub().

Referenced by v_Update().

◆ OutputSamplePoints()

void Nektar::SolverUtils::FilterLagrangianPoints::OutputSamplePoints ( NekDouble time )

protected

Definition at line 823 of file FilterLagrangianPoints.cpp.

{
    m_ofstreamSamplePoints << "ZONE T=\"" << time
                           << "\", I=" << m_samplePointIDs.size() << endl;
    for (auto &pid : m_samplePointIDs)
    {
        m_ofstreamSamplePoints << pid << " " << time << " ";
        Array<OneD, NekDouble> data(m_spacedim, 0.);
        m_staticPts->GetCoordsByPID(pid, data);
        for (int d = 0; d < m_spacedim; ++d)
        {
            m_ofstreamSamplePoints << data[d] + m_frame.m_frameDisp[d] << " ";
        }
        m_staticPts->GetPhysicsByPID(pid, data);
        for (int d = 0; d < m_spacedim; ++d)
        {
            m_ofstreamSamplePoints << data[d] + m_frame.m_frameVel[d] << " ";
        }
        m_ofstreamSamplePoints << endl;
    }
}

References Nektar::UnitTests::d(), m_frame, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameDisp, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameVel, m_ofstreamSamplePoints, m_samplePointIDs, Nektar::SolverUtils::EvaluatePoints::m_spacedim, and Nektar::SolverUtils::EvaluatePoints::m_staticPts.

Referenced by v_Update().

◆ OutputStatPoints()

void Nektar::SolverUtils::FilterLagrangianPoints::OutputStatPoints ( NekDouble time )

protected

Definition at line 845 of file FilterLagrangianPoints.cpp.

{
    boost::format filename(m_outputFile);
    filename % m_rank % time;
    std::map<std::string, NekDouble> params;
    if (m_frame.m_frameVelFunction.size())
    {
        std::vector<std::string> COORDS = {"x", "y", "z"};
        std::vector<std::string> VELOCI = {"u", "v", "w"};
        for (auto it : m_frame.m_frameVelFunction)
        {
            params[VELOCI[it.first]] = m_frame.m_frameVel[it.first];
        }
        for (auto it : m_frame.m_frameDispFunction)
        {
            params[COORDS[it.first]] = m_frame.m_frameDisp[it.first];
        }
    }
    m_staticPts->OutputData(filename.str(), m_outputL2Norm, params);
}

References CellMLToNektar.pycml::format, m_frame, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameDisp, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameDispFunction, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameVel, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameVelFunction, m_outputFile, m_outputL2Norm, Nektar::SolverUtils::EvaluatePoints::m_rank, and Nektar::SolverUtils::EvaluatePoints::m_staticPts.

Referenced by v_Update().

◆ v_Finalise()

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

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 866 of file FilterLagrangianPoints.cpp.

870{

871}

◆ v_Initialise()

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

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 466 of file FilterLagrangianPoints.cpp.

{
    auto it = v_params.find("DefaultValues");
    if (it != v_params.end())
    {
        ParseUtils::GenerateVector(it->second, m_defaultValues);
    }
    EvaluatePoints::Initialise(pFields, time, m_defaultValues);
    NekDouble dt;
    m_session->LoadParameter("TimeStep", dt);
 
    it = v_params.find("FrameVelocity");
    if (it != v_params.end())
    {
        std::vector<std::string> strs;
        ParseUtils::GenerateVector(it->second, strs);
        for (int i = strs.size(); i < m_spacedim; ++i)
        {
            strs.push_back("0");
        }
        for (int i = 0; i < m_spacedim; ++i)
        {
            m_frame.m_frameVelFunction[i] =
                MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
                    pFields[0]->GetSession()->GetInterpreter(), strs[i]);
        }
    }
 
    it = v_params.find("FrameDisplacement");
    if (it != v_params.end())
    {
        std::vector<std::string> strs;
        ParseUtils::GenerateVector(it->second, strs);
        for (int i = strs.size(); i < m_spacedim; ++i)
        {
            strs.push_back("0");
        }
        for (int i = 0; i < m_spacedim; ++i)
        {
            m_frame.m_frameDispFunction[i] =
                MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
                    pFields[0]->GetSession()->GetInterpreter(), strs[i]);
        }
    }
 
    int intOrder = 1;
    it           = v_params.find("IntOrder");
    if (it != v_params.end())
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        intOrder = round(equ.Evaluate());
    }
    if (intOrder == 0)
    {
        intOrder          = 1;
        m_isMovablePoints = false;
    }
    else
    {
        m_isMovablePoints = true;
    }
 
    it = v_params.find("RootOutputL2Norm");
    if (it != v_params.end())
    {
        std::string value = it->second;
        m_outputL2Norm    = m_rank == 0 && (value == "1" || value == "Yes");
    }
    else
    {
        m_outputL2Norm = false;
    }
 
    it = v_params.find("OutputFile");
    std::string outputFilename;
    if (it == v_params.end())
    {
        outputFilename = m_session->GetSessionName();
    }
    else
    {
        ASSERTL0(it->second.length() > 0, "Missing parameter 'OutputFile'.");
        outputFilename = it->second;
    }
    m_outputFile = outputFilename + "_R%05d_T%010.6lf.plt";
 
    // OutputFrequency
    it = v_params.find("OutputFrequency");
    if (it == v_params.end())
    {
        m_outputFrequency = 1;
    }
    else
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        m_outputFrequency = round(equ.Evaluate());
    }
 
    it = v_params.find("OutputSampleFrequency");
    if (it == v_params.end())
    {
        m_outputSampleFrequency = 1;
    }
    else
    {
        LibUtilities::Equation equ(m_session->GetInterpreter(), it->second);
        m_outputSampleFrequency = round(equ.Evaluate());
    }
 
    it = v_params.find("Box_" + std::to_string(m_rank));
    if (it != v_params.end())
    {
        std::vector<NekDouble> values;
        ParseUtils::GenerateVector(it->second, values);
        if (values.size() < m_spacedim * 3 + 1)
        {
            throw ErrorUtil::NekError(
                "Box formate error "
                "(offset,Nx,Ny,Nx,xmin,xmax,ymin,ymax,zmin,zmax): " +
                it->second);
        }
        m_frame.Update(time);
        std::vector<int> Np(m_spacedim, 1);
        m_box.resize(2 * m_spacedim, 0.);
        int idOffset = std::round(values[0]);
        for (int d = 0; d < m_spacedim; ++d)
        {
            Np[d] = std::round(values[d + 1]);
        }
        for (int d = 0; d < 2 * m_spacedim; ++d)
        {
            m_box[d] = values[1 + d + m_spacedim] - m_frame.m_frameDisp[d / 2];
        }
        std::vector<std::string> extraVars;
        ExtraPhysicsVars(extraVars);
        m_staticPts = MemoryManager<StatLagrangianPoints>::AllocateSharedPtr(
            m_rank, m_spacedim, intOrder, idOffset, dt, Np, m_box, extraVars);
        CopyStaticPtsToMobile();
 
        it = v_params.find("OutputSamplePoints");
        std::vector<unsigned int> samplepts;
        if (it != v_params.end())
        {
            ParseUtils::GenerateSeqVector(it->second, samplepts);
        }
        std::set<int> sampleIds(samplepts.begin(), samplepts.end());
        it = v_params.find("OutputSamplePointsCondition");
        LibUtilities::EquationSharedPtr sampleCondition;
        if (it != v_params.end())
        {
            sampleCondition =
                MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
                    pFields[0]->GetSession()->GetInterpreter(), it->second);
        }
 
        for (int p = 0; p < m_staticPts->GetTotPoints(); ++p)
        {
            Array<OneD, NekDouble> data(m_spacedim, 0.);
            m_staticPts->GetCoords(p, data);
            int globalId = m_staticPts->LocalToGlobal(p);
            NekDouble x  = data[0] + m_frame.m_frameDisp[0],
                      y  = data[1] + m_frame.m_frameDisp[1];
            NekDouble z =
                m_spacedim > 2 ? data[2] : 0. + m_frame.m_frameDisp[2];
            bool issample =
                (sampleCondition == nullptr)
                    ? false
                    : (sampleCondition->Evaluate(x, y, z, time) > 0);
            if (sampleIds.find(globalId) != sampleIds.end() || issample)
            {
                m_samplePointIDs.insert(globalId);
            }
        }
    }
    if (!m_samplePointIDs.empty())
    {
        std::string sampleFilename = outputFilename + "_Sample_R%05d.dat";
        boost::format filename(sampleFilename);
        filename % m_rank;
        m_ofstreamSamplePoints.open(filename.str(), std::ofstream::out);
        std::vector<std::string> COORDS = {"x", "y", "z"};
        std::vector<std::string> VELOCI = {"u", "v", "w"};
        m_ofstreamSamplePoints << "variables = pid, time ";
        for (int d = 0; d < m_spacedim; ++d)
        {
            m_ofstreamSamplePoints << COORDS[d] << " ";
        }
        for (int d = 0; d < m_spacedim; ++d)
        {
            m_ofstreamSamplePoints << VELOCI[d] << " ";
        }
        m_ofstreamSamplePoints << endl;
    }
    SetUpCommInfo();
    v_Update(pFields, time);
}

◆ v_IsTimeDependent()

bool Nektar::SolverUtils::FilterLagrangianPoints::v_IsTimeDependent ( )

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 873 of file FilterLagrangianPoints.cpp.

{
    return true;
}

◆ v_ModifyVelocity()

void Nektar::SolverUtils::FilterLagrangianPoints::v_ModifyVelocity	(	Array< OneD, NekDouble >	gcoords,
		NekDouble	time,
		Array< OneD, NekDouble >	vel
	)

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::EvaluatePoints.

Definition at line 665 of file FilterLagrangianPoints.cpp.

{
    if (m_frame.m_frameVelFunction.size() > 0)
    {
        for (int i = 0; i < m_spacedim; ++i)
        {
            vel[i] -= m_frame.m_frameVel[i];
        }
    }
}

References m_frame, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameVel, Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::m_frameVelFunction, and Nektar::SolverUtils::EvaluatePoints::m_spacedim.

◆ v_Update()

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

overrideprotectedvirtual

Implements Nektar::SolverUtils::Filter.

Definition at line 786 of file FilterLagrangianPoints.cpp.

{
    if (m_isMovablePoints || m_index == 0)
    {
        PartitionMobilePts(pFields);
    }
    std::vector<Array<OneD, NekDouble>> PhysicsData;
    GetPhysicsData(pFields, PhysicsData);
    m_frame.Update(time);
    EvaluateMobilePhys(pFields[0], PhysicsData, time);
    std::map<int, std::set<int>> callbackUpdateMobCoords;
    PassMobilePhysToStatic(callbackUpdateMobCoords);
    // output Lagrangian coordinates
    if (m_index % m_outputFrequency == 0 && m_staticPts != nullptr)
    {
        OutputStatPoints(time);
    }
    // output sample points
    if (m_index % m_outputSampleFrequency == 0 && !m_samplePointIDs.empty())
    {
        OutputSamplePoints(time);
    }
    // update Lagrangian coordinates
    if (m_isMovablePoints)
    {
        if (m_staticPts != nullptr)
        {
            m_staticPts->TimeAdvance(m_index + 1);
        }
        // return the updated global coordinates to mobile points
        PassStaticCoordsToMobile(callbackUpdateMobCoords);
    }
    ++m_index;
}

References Nektar::SolverUtils::EvaluatePoints::EvaluateMobilePhys(), GetPhysicsData(), m_frame, m_index, m_isMovablePoints, m_outputFrequency, m_outputSampleFrequency, m_samplePointIDs, Nektar::SolverUtils::EvaluatePoints::m_staticPts, OutputSamplePoints(), OutputStatPoints(), Nektar::SolverUtils::EvaluatePoints::PartitionMobilePts(), Nektar::SolverUtils::EvaluatePoints::PassMobilePhysToStatic(), Nektar::SolverUtils::EvaluatePoints::PassStaticCoordsToMobile(), and Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame::Update().

Referenced by v_Initialise().

Friends And Related Function Documentation

◆ MemoryManager< FilterLagrangianPoints >

friend class MemoryManager< FilterLagrangianPoints >

friend

Definition at line 94 of file FilterLagrangianPoints.h.

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::FilterLagrangianPoints::className

static

Initial value:

=
    GetFilterFactory().RegisterCreatorFunction("LagrangianPoints",
                                               FilterLagrangianPoints::create)

Definition at line 113 of file FilterLagrangianPoints.h.

◆ m_box

std::vector<NekDouble> Nektar::SolverUtils::FilterLagrangianPoints::m_box

protected

Definition at line 161 of file FilterLagrangianPoints.h.

Referenced by v_Initialise().

◆ m_defaultValues

std::vector<std::string> Nektar::SolverUtils::FilterLagrangianPoints::m_defaultValues

protected

Definition at line 142 of file FilterLagrangianPoints.h.

Referenced by v_Initialise().

◆ m_frame

struct Nektar::SolverUtils::FilterLagrangianPoints::MovingFrame Nektar::SolverUtils::FilterLagrangianPoints::m_frame

protected

Referenced by OutputSamplePoints(), OutputStatPoints(), v_Initialise(), v_ModifyVelocity(), and v_Update().

◆ m_index

unsigned int Nektar::SolverUtils::FilterLagrangianPoints::m_index = 0

protected

Definition at line 163 of file FilterLagrangianPoints.h.

Referenced by v_Update().

◆ m_isMovablePoints

bool Nektar::SolverUtils::FilterLagrangianPoints::m_isMovablePoints

protected

Definition at line 167 of file FilterLagrangianPoints.h.

Referenced by v_Initialise(), and v_Update().

◆ m_ofstreamSamplePoints

std::ofstream Nektar::SolverUtils::FilterLagrangianPoints::m_ofstreamSamplePoints

protected

Definition at line 170 of file FilterLagrangianPoints.h.

Referenced by OutputSamplePoints(), v_Initialise(), and ~FilterLagrangianPoints().

◆ m_outputFile

std::string Nektar::SolverUtils::FilterLagrangianPoints::m_outputFile

protected

Definition at line 165 of file FilterLagrangianPoints.h.

Referenced by OutputStatPoints(), and v_Initialise().

◆ m_outputFrequency

unsigned int Nektar::SolverUtils::FilterLagrangianPoints::m_outputFrequency

protected

Definition at line 164 of file FilterLagrangianPoints.h.

Referenced by v_Initialise(), and v_Update().

◆ m_outputL2Norm

bool Nektar::SolverUtils::FilterLagrangianPoints::m_outputL2Norm

protected

Definition at line 166 of file FilterLagrangianPoints.h.

Referenced by OutputStatPoints(), and v_Initialise().

◆ m_outputSampleFrequency

unsigned int Nektar::SolverUtils::FilterLagrangianPoints::m_outputSampleFrequency

protected

Definition at line 168 of file FilterLagrangianPoints.h.

Referenced by v_Initialise(), and v_Update().

◆ m_samplePointIDs

std::set<int> Nektar::SolverUtils::FilterLagrangianPoints::m_samplePointIDs

protected

Definition at line 169 of file FilterLagrangianPoints.h.

Referenced by OutputSamplePoints(), v_Initialise(), and v_Update().

◆ v_params

std::map<std::string, std::string> Nektar::SolverUtils::FilterLagrangianPoints::v_params

protected

Definition at line 162 of file FilterLagrangianPoints.h.

Referenced by v_Initialise().

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FilterLagrangianPoints()

◆ ~FilterLagrangianPoints()

Member Function Documentation

◆ create()

◆ ExtraPhysicsVars()

◆ GetPhysicsData()

◆ OutputSamplePoints()

◆ OutputStatPoints()

◆ v_Finalise()

◆ v_Initialise()

◆ v_IsTimeDependent()

◆ v_ModifyVelocity()

◆ v_Update()

Friends And Related Function Documentation

◆ MemoryManager< FilterLagrangianPoints >

Member Data Documentation

◆ className

◆ m_box

◆ m_defaultValues

◆ m_frame

◆ m_index

◆ m_isMovablePoints

◆ m_ofstreamSamplePoints

◆ m_outputFile

◆ m_outputFrequency

◆ m_outputL2Norm

◆ m_outputSampleFrequency

◆ m_samplePointIDs

◆ v_params