#include <EvaluatePoints.h>

Inheritance diagram for Nektar::SolverUtils::EvaluatePoints:

Public Member Functions
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 ()

Protected Member Functions
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)

Protected Attributes
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

Detailed Description

Definition at line 210 of file EvaluatePoints.h.

Constructor & Destructor Documentation

◆ EvaluatePoints()

Nektar::SolverUtils::EvaluatePoints::EvaluatePoints ( )

Definition at line 104 of file EvaluatePoints.cpp.

105{

106}

◆ ~EvaluatePoints()

Nektar::SolverUtils::EvaluatePoints::~EvaluatePoints ( )

virtual

Definition at line 111 of file EvaluatePoints.cpp.

112{

113}

Member Function Documentation

◆ CopyMobilePtsToStatic()

void Nektar::SolverUtils::EvaluatePoints::CopyMobilePtsToStatic ( )

Definition at line 737 of file EvaluatePoints.cpp.

{
    ASSERTL0(m_columnRank == 0 || !m_isHomogeneous1D,
             "CopyStaticPtsToMobile shoule only be called by ColumnRank zero");
    m_staticPts->ReSize(m_mobilePts.size());
    int id = 0;
    for (const auto &p : m_mobilePts)
    {
        m_staticPts->AssignPoint(id, p.first, p.second->GetGlobalCoords());
    }
}

References ASSERTL0, m_columnRank, m_isHomogeneous1D, m_mobilePts, m_staticPts, and CellMLToNektar.cellml_metadata::p.

◆ CopyStaticPtsToMobile()

void Nektar::SolverUtils::EvaluatePoints::CopyStaticPtsToMobile ( )

Definition at line 722 of file EvaluatePoints.cpp.

{
    ASSERTL0(m_columnRank == 0 || !m_isHomogeneous1D,
             "CopyStaticPtsToMobile shoule only be called by ColumnRank zero");
    m_mobilePts.clear();
    for (int p = 0; p < m_staticPts->GetTotPoints(); ++p)
    {
        Array<OneD, NekDouble> data(m_spacedim, 0.);
        m_staticPts->GetCoords(p, data);
        m_mobilePts[m_staticPts->LocalToGlobal(p)] =
            MemoryManager<MobilePoint>::AllocateSharedPtr(m_spacedim, m_rank,
                                                          data);
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, m_columnRank, m_isHomogeneous1D, m_mobilePts, m_rank, m_spacedim, m_staticPts, and CellMLToNektar.cellml_metadata::p.

Referenced by Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise().

◆ EvaluateMobilePhys()

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

Definition at line 154 of file EvaluatePoints.cpp.

{
    m_nPhysics  = PhysicsData.size();
    int coordim = pField->GetGraph()->GetSpaceDimension();
    Array<OneD, NekDouble> data(m_mobilePts.size() * m_nPhysics, 0.0);
    Array<OneD, NekDouble> physvals;
    Array<OneD, NekDouble> locCoord;
    if (m_isHomogeneous1D)
    {
        Array<OneD, const unsigned int> planes = pField->GetZIDs();
        int nPlanes    = pField->GetHomogeneousBasis()->GetZ().size();
        NekDouble lHom = pField->GetHomoLen();
        int nelmts     = pField->GetPlane(0)->GetExpSize();
        int indx       = -1;
        for (auto &x : m_mobilePts)
        {
            ++indx;
            locCoord  = x.second->GetLocalCoords();
            int expId = x.second->m_eId;
            if (expId < 0)
            {
                continue;
            }
            NekDouble BetaT = 2. * M_PI * fmod(locCoord[coordim], lHom) / lHom;
            std::vector<NekDouble> basis(planes.size(), 0.);
            for (size_t n = 0; n < planes.size(); ++n)
            {
                if (planes[n] == 0)
                {
                    basis[n] = 1.;
                }
                else if (planes[n] == 1)
                {
                    basis[n] = cos(0.5 * nPlanes * BetaT);
                }
                else if (planes[n] % 2 == 0)
                {
                    NekDouble phase = (planes[n] >> 1) * BetaT;
                    basis[n]        = cos(phase);
                }
                else
                {
                    NekDouble phase = (planes[n] >> 1) * BetaT;
                    basis[n]        = -sin(phase);
                }
            }
            LocalRegions::ExpansionSharedPtr elmt =
                pField->GetPlane(0)->GetExp(expId);
            for (int j = 0; j < m_nPhysics; ++j)
            {
                NekDouble value = 0.0;
                for (size_t n = 0; n < planes.size(); ++n)
                {
                    physvals = PhysicsData[j] +
                               pField->GetPhys_Offset(expId + n * nelmts);
                    NekDouble coeff = elmt->StdPhysEvaluate(locCoord, physvals);
                    value += basis[n] * coeff;
                }
                data[indx * m_nPhysics + j] = value;
            }
        }
        m_comm->GetColumnComm()->AllReduce(data, LibUtilities::ReduceSum);
    }
    else
    {
        for (int j = 0; j < m_nPhysics; ++j)
        {
            int indx = -1;
            for (auto &x : m_mobilePts)
            {
                ++indx;
                locCoord  = x.second->GetLocalCoords();
                int expId = x.second->m_eId;
                if (expId < 0)
                {
                    continue;
                }
                physvals = PhysicsData[j] + pField->GetPhys_Offset(expId);
                data[indx * m_nPhysics + j] =
                    pField->GetExp(expId)->StdPhysEvaluate(locCoord, physvals);
            }
        }
    }
    // copy data
    int count = 0;
    for (auto &x : m_mobilePts)
    {
        Array<OneD, NekDouble> datum;
        if (x.second->m_eId >= 0)
        {
            datum = data + count * m_nPhysics;
        }
        else
        {
            datum = Array<OneD, NekDouble>(m_nPhysics, 0.);
            if (m_columnRank == 0)
            {
                for (int j = 0; j < m_nPhysics; ++j)
                {
                    datum[j] =
                        GetDefaultValue(j, x.second->GetGlobalCoords(), time);
                }
            }
        }
        v_ModifyVelocity(x.second->GetGlobalCoords(), time, datum);
        x.second->SetData(m_nPhysics, datum);
        ++count;
    }
}

References GetDefaultValue(), m_columnRank, m_comm, m_isHomogeneous1D, m_mobilePts, m_nPhysics, Nektar::LibUtilities::ReduceSum, and v_ModifyVelocity().

Referenced by Nektar::SolverUtils::FilterLagrangianPoints::v_Update().

◆ GatherMobilePhysics()

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

protected

Definition at line 274 of file EvaluatePoints.cpp.

{
    revData.clear();
    // send/receive data
    int nPackageSize = m_nPhysics + 1;
    if (m_columnRank == 0)
    {
        std::map<int, std::set<int>> threadToSend;
        for (const auto &p : m_mobilePts)
        {
            threadToSend[p.second->m_sRank].insert(p.first);
        }
        for (const auto &thread : threadToSend)
        {
            Array<OneD, NekDouble> dataToSend(
                thread.second.size() * nPackageSize, 0.);
            Array<OneD, NekDouble> tmp;
            int offset = 0;
            for (const int p : thread.second)
            {
                Pack3Int(p, m_rank, thread.first, dataToSend[offset]);
                Vmath::Vcopy(m_nPhysics, m_mobilePts[p]->GetData(), 1,
                             tmp = dataToSend + offset + 1, 1);
                offset += nPackageSize;
            }
            if (thread.first != m_rank)
            {
                m_comm->Send(thread.first, dataToSend);
            }
            else
            {
                revData[thread.first] = dataToSend;
            }
        }
    }
    for (const auto &p : m_recvMobInfo)
    {
        if (p.first != m_rank)
        {
            Array<OneD, NekDouble> dataToRecv(p.second * nPackageSize, 0.);
            m_comm->Recv(p.first, dataToRecv);
            revData[p.first] = dataToRecv;
        }
    }
}

References m_columnRank, m_comm, m_mobilePts, m_nPhysics, m_rank, m_recvMobInfo, CellMLToNektar.cellml_metadata::p, Pack3Int(), and Vmath::Vcopy().

Referenced by PassMobilePhysToStatic().

◆ GetDefaultValue()

NekDouble Nektar::SolverUtils::EvaluatePoints::GetDefaultValue	(	const int	i,
		const Array< OneD, const NekDouble >	x,
		const NekDouble	time
	)

protected

Definition at line 673 of file EvaluatePoints.cpp.

{
    NekDouble z = m_spacedim == 2 ? 0 : x[2];
    if (m_defaultValueFunction.find(i) == m_defaultValueFunction.end())
    {
        return 0.;
    }
    else
    {
        return m_defaultValueFunction[i]->Evaluate(x[0], x[1], z, time);
    }
}

References m_defaultValueFunction, m_spacedim, and Nektar::UnitTests::z().

Referenced by EvaluateMobilePhys().

◆ Initialise()

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

Definition at line 118 of file EvaluatePoints.cpp.

{
    m_comm       = pFields[0]->GetComm();
    m_rank       = m_comm->GetRank();
    m_columnRank = m_comm->GetColumnComm()->GetRank();
    m_rowRank    = m_comm->GetRowComm()->GetRank();
    LibUtilities::SessionReaderSharedPtr session = pFields[0]->GetSession();
    session->MatchSolverInfo("Homogeneous", "1D", m_isHomogeneous1D, false);
    int coordim    = pFields[0]->GetGraph()->GetSpaceDimension();
    int numHomoDir = m_isHomogeneous1D ? 1 : 0;
    m_spacedim     = coordim + numHomoDir;
    ASSERTL0(m_rank <= 65535,
             "EvaluatePoints does not support more than 65536 threads.")
 
    for (size_t i = 0; i < defaultValues.size(); ++i)
    {
        try
        {
            m_defaultValueFunction[i] =
                MemoryManager<LibUtilities::Equation>::AllocateSharedPtr(
                    session->GetInterpreter(), defaultValues[i]);
        }
        catch (const std::runtime_error &)
        {
            NEKERROR(ErrorUtil::efatal,
                     "Error parsering expression" + defaultValues[i]);
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::ErrorUtil::efatal, m_columnRank, m_comm, m_defaultValueFunction, m_isHomogeneous1D, m_rank, m_rowRank, m_spacedim, and NEKERROR.

Referenced by Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise().

◆ Pack2Int()

void Nektar::SolverUtils::EvaluatePoints::Pack2Int	(	const int &	a,
		const int &	b,
		double &	d
	)

protected

Definition at line 55 of file EvaluatePoints.cpp.

{
    int *p = (int *)&d;
    p[0]   = a;
    p[1]   = b;
}

References Nektar::UnitTests::d(), and CellMLToNektar.cellml_metadata::p.

Referenced by PartitionExchangeNonlocalPoints(), and SyncColumnComm().

◆ Pack2Short()

void Nektar::SolverUtils::EvaluatePoints::Pack2Short	(	const int &	a,
		const int &	b,
		int &	c
	)

protected

Definition at line 88 of file EvaluatePoints.cpp.

{
    short int *p = (short int *)&c;
    p[0]         = (short int)a;
    p[1]         = (short int)b;
}

References CellMLToNektar.cellml_metadata::p.

Referenced by SetUpCommInfo().

◆ Pack3Int()

void Nektar::SolverUtils::EvaluatePoints::Pack3Int	(	const int &	a,
		const int &	b,
		const int &	c,
		double &	d
	)

protected

Definition at line 69 of file EvaluatePoints.cpp.

{
    int *p                = (int *)&d;
    unsigned short int *q = (unsigned short int *)&d;
    p[0]                  = a;
    q[2]                  = (unsigned short int)b;
    q[3]                  = (unsigned short int)c;
}

References Nektar::UnitTests::d(), CellMLToNektar.cellml_metadata::p, and Nektar::UnitTests::q().

Referenced by GatherMobilePhysics(), PartitionExchangeNonlocalPoints(), and PassStaticCoordsToMobile().

◆ PartitionExchangeNonlocalPoints()

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

protected

Definition at line 464 of file EvaluatePoints.cpp.

{
    // Determine the unique process responsible for each history point
    // For points on a partition boundary, must select a single process
    int nExchange = 0, nTot = 0;
    Array<OneD, NekDouble> exchangeInfo;
    std::vector<int> npts(m_comm->GetRowComm()->GetSize(), 0);
    if (m_columnRank == 0 || !m_isHomogeneous1D)
    {
        npts[m_rowRank] = notfound.size();
        m_comm->GetRowComm()->AllReduce(npts, LibUtilities::ReduceMax);
        for (auto v : npts)
        {
            nTot += v;
        }
    }
    m_comm->AllReduce(nTot, LibUtilities::ReduceMax);
    if (nTot == 0)
    {
        return;
    }
    if (m_columnRank == 0 || !m_isHomogeneous1D)
    {
        // spread unfound points to all Row threads
        int nOffset = 0;
        for (int i = 0; i < m_rowRank; ++i)
        {
            nOffset += npts[i];
        }
        int nDataPackage = 1 + m_spacedim;
        int count        = nOffset * nDataPackage;
        Array<OneD, NekDouble> data(nTot * nDataPackage, 0.);
        for (auto &p : notfound)
        {
            Pack2Int(p, m_mobilePts[p]->m_sRank, data[count++]);
            for (int i = 0; i < m_spacedim; ++i)
            {
                data[count++] = m_mobilePts[p]->GetGlobalCoords()[i];
            }
        }
        m_comm->GetRowComm()->AllReduce(data, LibUtilities::ReduceSum);
        // global search
        std::vector<int> eIds(nTot, -1);
        std::vector<int> procIds(nTot, -1);
        Array<OneD, NekDouble> localCoords(nTot * m_spacedim, 0.);
        for (int p = 0; p < nTot; ++p)
        {
            if (nOffset <= p && p < nOffset + npts[m_rowRank])
            {
                continue;
            }
            Array<OneD, NekDouble> gloCoords = data + p * nDataPackage + 1;
            Array<OneD, NekDouble> locCoords = localCoords + p * m_spacedim;
            // Determine the expansion and local coordinates
            if (m_isHomogeneous1D && m_columnRank == 0)
            {
                eIds[p] =
                    pFields[0]->GetPlane(0)->GetExpIndex(gloCoords, locCoords);
            }
            else
            {
                eIds[p] = pFields[0]->GetExpIndex(gloCoords, locCoords);
            }
            if (eIds[p] >= 0)
            {
                procIds[p] = m_rowRank;
            }
        }
        m_comm->GetRowComm()->AllReduce(procIds, LibUtilities::ReduceMax);
        for (int p = 0; p < nTot; ++p)
        {
            if (procIds[p] >= 0)
            {
                ++nExchange;
                if (procIds[p] == m_rowRank)
                {
                    int pId, sRank;
                    unPack2Int(pId, sRank, data[p * nDataPackage]);
                    m_mobilePts[pId] =
                        MemoryManager<MobilePoint>::AllocateSharedPtr(
                            m_spacedim, sRank, data + p * nDataPackage + 1);
                    m_mobilePts[pId]->SetLocalCoords(
                        eIds[p], localCoords + p * m_spacedim);
                    m_recvStatInfo[sRank] += 1;
                }
            }
        }
        for (int p = nOffset; p < nOffset + npts[m_rowRank]; ++p)
        {
            if (procIds[p] >= 0)
            {
                int pId, sRank;
                unPack2Int(pId, sRank, data[p * nDataPackage]);
                m_mobilePts.erase(pId);
                if (m_recvStatInfo[sRank] == 1)
                {
                    m_recvStatInfo.erase(sRank);
                }
                else
                {
                    m_recvStatInfo[sRank] -= 1;
                }
            }
        }
        // build exchangeInfo [pid, from thread rank, to thread rank]
        int accumulate = 0;
        exchangeInfo   = Array<OneD, NekDouble>(nExchange, 0.);
        for (int t = 0, p = 0; t < npts.size(); ++t)
        {
            for (int i = 0; i < npts[t]; ++i, ++p)
            {
                if (procIds[p] >= 0)
                {
                    int pId, sRank;
                    unPack2Int(pId, sRank, data[p * nDataPackage]);
                    Pack3Int(sRank, t, procIds[p], exchangeInfo[accumulate++]);
                }
            }
        }
    }
    m_comm->AllReduce(nExchange, LibUtilities::ReduceMax);
    if (nExchange == 0)
    {
        return;
    }
    // sync column communication
    if (m_comm->GetColumnComm()->GetSize() > 1)
    {
        if (m_columnRank > 0)
        {
            exchangeInfo = Array<OneD, NekDouble>(nExchange, 0.);
        }
        m_comm->GetColumnComm()->AllReduce(exchangeInfo,
                                           LibUtilities::ReduceSum);
    }
    // update m_recvMobInfo
    for (int p = 0; p < nExchange; ++p)
    {
        int sRank, fromRank, toRank;
        unPack3Int(sRank, fromRank, toRank, exchangeInfo[p]);
        if (sRank == m_rank)
        {
            if (m_recvMobInfo[fromRank] == 1)
            {
                m_recvMobInfo.erase(fromRank);
            }
            else
            {
                m_recvMobInfo[fromRank] -= 1;
            }
            m_recvMobInfo[toRank] += 1;
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), m_columnRank, m_comm, m_isHomogeneous1D, m_mobilePts, m_rank, m_recvMobInfo, m_recvStatInfo, m_rowRank, m_spacedim, CellMLToNektar.cellml_metadata::p, Pack2Int(), Pack3Int(), Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceSum, unPack2Int(), and unPack3Int().

Referenced by PartitionMobilePts().

◆ PartitionLocalPoints()

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

protected

Definition at line 429 of file EvaluatePoints.cpp.

{
    if (m_isHomogeneous1D && m_columnRank != 0)
    {
        return;
    }
    // not repeat in local points
    for (auto &p : m_mobilePts)
    {
        Array<OneD, NekDouble> locCoords = p.second->GetLocalCoords();
        Array<OneD, NekDouble> gloCoords = p.second->GetGlobalCoords();
        // Determine the expansion and local coordinates
        if (m_isHomogeneous1D)
        {
            p.second->m_eId = pFields[0]->GetPlane(0)->GetExpIndex(
                gloCoords, locCoords, 0., false, p.second->m_eId);
        }
        else
        {
            p.second->m_eId = pFields[0]->GetExpIndex(gloCoords, locCoords, 0.,
                                                      false, p.second->m_eId);
        }
        if (p.second->m_eId < 0)
        {
            notfound.insert(p.first);
        }
    }
}

References m_columnRank, m_isHomogeneous1D, m_mobilePts, and CellMLToNektar.cellml_metadata::p.

Referenced by PartitionMobilePts().

◆ PartitionMobilePts()

void Nektar::SolverUtils::EvaluatePoints::PartitionMobilePts ( const Array< OneD, const MultiRegions::ExpListSharedPtr > & pFields )

Definition at line 381 of file EvaluatePoints.cpp.

{
    std::set<int> notfound;
    PartitionLocalPoints(pFields, notfound);
    PartitionExchangeNonlocalPoints(pFields, notfound);
    SyncColumnComm();
}

References PartitionExchangeNonlocalPoints(), PartitionLocalPoints(), and SyncColumnComm().

Referenced by Nektar::SolverUtils::FilterLagrangianPoints::v_Update().

◆ PassMobilePhysToStatic()

void Nektar::SolverUtils::EvaluatePoints::PassMobilePhysToStatic ( std::map< int, std::set< int > > & callbackUpdateMobCoords )

Definition at line 390 of file EvaluatePoints.cpp.

{
    std::map<int, Array<OneD, NekDouble>> recvData;
    GatherMobilePhysics(recvData);
    //   unpack data
    for (auto const &data : recvData)
    {
        int offset = 0;
        while (offset < data.second.size())
        {
            int pid, mobt, statt;
            unPack3Int(pid, mobt, statt, data.second[offset++]);
            m_staticPts->SetPhysicsByPID(pid, data.second + offset);
            callbackUpdateMobCoords[data.first].insert(pid);
            offset += m_nPhysics;
        }
    }
}

References GatherMobilePhysics(), m_nPhysics, m_staticPts, and unPack3Int().

Referenced by Nektar::SolverUtils::FilterLagrangianPoints::v_Update().

◆ PassStaticCoordsToMobile()

void Nektar::SolverUtils::EvaluatePoints::PassStaticCoordsToMobile ( std::map< int, std::set< int > > & callbackUpdateMobCoords )

Definition at line 410 of file EvaluatePoints.cpp.

{
    std::map<int, Array<OneD, NekDouble>> globalCoords;
    for (auto const &thread : callbackUpdateMobCoords)
    {
        int nDataSize = m_spacedim + 1, offset = 0;
        Array<OneD, NekDouble> data(thread.second.size() * nDataSize), tmp;
        for (const auto &p : thread.second)
        {
            Pack3Int(p, thread.first, m_rank, data[offset++]);
            m_staticPts->GetCoordsByPID(p, tmp = data + offset);
            offset += m_spacedim;
        }
        globalCoords[thread.first] = data;
    }
    UpdateMobileCoords(globalCoords);
}

References m_rank, m_spacedim, m_staticPts, CellMLToNektar.cellml_metadata::p, Pack3Int(), and UpdateMobileCoords().

Referenced by Nektar::SolverUtils::FilterLagrangianPoints::v_Update().

◆ SetUpCommInfo()

void Nektar::SolverUtils::EvaluatePoints::SetUpCommInfo ( )

Definition at line 321 of file EvaluatePoints.cpp.

{
    // setup communication pair;
    int nRows   = m_comm->GetRowComm()->GetSize();
    int nColumn = m_comm->GetColumnComm()->GetSize();
    //(from short/int, to short/int, size/int)
    m_recvStatInfo.clear();
    int totPairs = 0;
    Array<OneD, int> data;
    if (m_columnRank == 0)
    {
        for (const auto &p : m_mobilePts)
        {
            m_recvStatInfo[p.second->m_sRank] += 1;
        }
        Array<OneD, int> npairs(nRows, 0);
        npairs[m_rowRank] = m_recvStatInfo.size();
        m_comm->GetRowComm()->AllReduce(npairs, LibUtilities::ReduceMax);
        int offset = 0;
        for (int t = 0; t < m_rowRank; ++t)
        {
            offset += npairs[t];
        }
        totPairs = offset;
        for (int t = m_rowRank; t < nRows; ++t)
        {
            totPairs += npairs[t];
        }
        data = Array<OneD, int>(totPairs * 2, 0);
        offset *= 2;
        for (const auto &p : m_recvStatInfo)
        {
            Pack2Short((short int)m_rowRank, (short int)p.first,
                       data[offset++]);
            data[offset++] = p.second;
        }
        m_comm->GetRowComm()->AllReduce(data, LibUtilities::ReduceSum);
    }
    // set up to-receive mobile points
    if (nColumn > 1)
    {
        m_comm->GetColumnComm()->AllReduce(totPairs, LibUtilities::ReduceMax);
        if (m_columnRank > 0)
        {
            data = Array<OneD, int>(totPairs * 2, 0);
        }
        m_comm->GetColumnComm()->AllReduce(data, LibUtilities::ReduceSum);
    }
    m_recvMobInfo.clear();
    for (int t = 0; t < totPairs; ++t)
    {
        int from, to;
        unPack2Short(from, to, data[2 * t]);
        if (to == m_rank)
        {
            m_recvMobInfo[(int)from] = data[2 * t + 1];
        }
    }
}

References m_columnRank, m_comm, m_mobilePts, m_rank, m_recvMobInfo, m_recvStatInfo, m_rowRank, CellMLToNektar.cellml_metadata::p, Pack2Short(), Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceSum, and unPack2Short().

Referenced by Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise().

◆ SyncColumnComm()

void Nektar::SolverUtils::EvaluatePoints::SyncColumnComm ( )

protected

Definition at line 621 of file EvaluatePoints.cpp.

{
    if (!m_isHomogeneous1D)
    {
        return;
    }
    if (m_columnRank == 0)
    {
        for (const auto &p : m_mobilePts)
        {
            p.second->m_local[2] = p.second->m_global[2];
        }
    }
    else
    {
        m_mobilePts.clear();
    }
    if (m_comm->GetColumnComm()->GetSize() == 1)
    {
        return;
    }
    int nPts = m_mobilePts.size();
    m_comm->GetColumnComm()->AllReduce(nPts, LibUtilities::ReduceMax);
    int nPackageSize = 1 + m_spacedim;
    Array<OneD, NekDouble> data(nPts * nPackageSize, 0.), tmp;
    if (m_columnRank == 0)
    {
        int count = 0;
        for (const auto &p : m_mobilePts)
        {
            Pack2Int(p.first, p.second->m_eId, data[count++]);
            Vmath::Vcopy(3, p.second->m_local, 1, tmp = data + count, 1);
            count += 3;
        }
    }
    m_comm->GetColumnComm()->AllReduce(data, LibUtilities::ReduceSum);
    if (m_columnRank != 0)
    {
        int offset = 0;
        for (int p = 0; p < nPts; ++p)
        {
            int pId, eId;
            Array<OneD, NekDouble> globalCoords(m_spacedim, 0.);
            unPack2Int(pId, eId, data[offset++]);
            m_mobilePts[pId] = MemoryManager<MobilePoint>::AllocateSharedPtr(
                m_spacedim, 0, globalCoords);
            m_mobilePts[pId]->SetLocalCoords(eId, data + offset);
            offset += m_spacedim;
        }
    }
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), m_columnRank, m_comm, m_isHomogeneous1D, m_mobilePts, m_spacedim, CellMLToNektar.cellml_metadata::p, Pack2Int(), Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceSum, unPack2Int(), and Vmath::Vcopy().

Referenced by PartitionMobilePts().

◆ unPack2Int()

void Nektar::SolverUtils::EvaluatePoints::unPack2Int	(	int &	a,
		int &	b,
		const double &	d
	)

protected

Definition at line 62 of file EvaluatePoints.cpp.

{
    int *p = (int *)&d;
    a      = p[0];
    b      = p[1];
}

References Nektar::UnitTests::d(), and CellMLToNektar.cellml_metadata::p.

Referenced by PartitionExchangeNonlocalPoints(), and SyncColumnComm().

◆ unPack2Short()

void Nektar::SolverUtils::EvaluatePoints::unPack2Short	(	int &	a,
		int &	b,
		const int &	c
	)

protected

Definition at line 95 of file EvaluatePoints.cpp.

{
    short int *p = (short int *)&c;
    a            = (int)p[0];
    b            = (int)p[1];
}

References CellMLToNektar.cellml_metadata::p.

Referenced by SetUpCommInfo().

◆ unPack3Int()

void Nektar::SolverUtils::EvaluatePoints::unPack3Int	(	int &	a,
		int &	b,
		int &	c,
		const double &	d
	)

protected

Definition at line 79 of file EvaluatePoints.cpp.

{
    int *p                = (int *)&d;
    unsigned short int *q = (unsigned short int *)&d;
    a                     = p[0];
    b                     = q[2];
    c                     = q[3];
}

References Nektar::UnitTests::d(), CellMLToNektar.cellml_metadata::p, and Nektar::UnitTests::q().

Referenced by PartitionExchangeNonlocalPoints(), PassMobilePhysToStatic(), and UpdateMobileCoords().

◆ UpdateMobileCoords()

void Nektar::SolverUtils::EvaluatePoints::UpdateMobileCoords ( std::map< int, Array< OneD, NekDouble > > & globalCoords )

protected

Definition at line 688 of file EvaluatePoints.cpp.

{
    if (m_columnRank == 0 || !m_isHomogeneous1D)
    {
        for (auto &iter : globalCoords)
        {
            if (iter.first != m_rank)
            {
                m_comm->Send(iter.first, iter.second);
            }
        }
        for (const auto &iter : m_recvStatInfo)
        {
            Array<OneD, NekDouble> data;
            if (iter.first != m_rank)
            {
                data = Array<OneD, NekDouble>(iter.second * (m_spacedim + 1));
                m_comm->Recv(iter.first, data);
            }
            else
            {
                data = globalCoords[iter.first];
            }
            for (int offset = 0; offset < data.size(); offset += m_spacedim)
            {
                int pid, mobt, stat;
                unPack3Int(pid, mobt, stat, data[offset++]);
                m_mobilePts[pid]->SetGlobalCoords(data + offset);
            }
        }
    }
}

References m_columnRank, m_comm, m_isHomogeneous1D, m_mobilePts, m_rank, m_recvStatInfo, m_spacedim, and unPack3Int().

Referenced by PassStaticCoordsToMobile().

◆ v_ModifyVelocity()

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

protectedvirtual

Reimplemented in Nektar::SolverUtils::FilterLagrangianPoints.

Definition at line 266 of file EvaluatePoints.cpp.

270{

271}

Referenced by EvaluateMobilePhys().

Member Data Documentation

◆ m_columnRank

int Nektar::SolverUtils::EvaluatePoints::m_columnRank

protected

Definition at line 255 of file EvaluatePoints.h.

Referenced by CopyMobilePtsToStatic(), CopyStaticPtsToMobile(), EvaluateMobilePhys(), GatherMobilePhysics(), Initialise(), PartitionExchangeNonlocalPoints(), PartitionLocalPoints(), SetUpCommInfo(), SyncColumnComm(), and UpdateMobileCoords().

◆ m_comm

LibUtilities::CommSharedPtr Nektar::SolverUtils::EvaluatePoints::m_comm

protected

Definition at line 258 of file EvaluatePoints.h.

Referenced by EvaluateMobilePhys(), GatherMobilePhysics(), Initialise(), PartitionExchangeNonlocalPoints(), SetUpCommInfo(), SyncColumnComm(), and UpdateMobileCoords().

◆ m_defaultValueFunction

std::map<int, LibUtilities::EquationSharedPtr> Nektar::SolverUtils::EvaluatePoints::m_defaultValueFunction

protected

Definition at line 261 of file EvaluatePoints.h.

Referenced by GetDefaultValue(), and Initialise().

◆ m_isHomogeneous1D

bool Nektar::SolverUtils::EvaluatePoints::m_isHomogeneous1D

protected

Definition at line 256 of file EvaluatePoints.h.

Referenced by CopyMobilePtsToStatic(), CopyStaticPtsToMobile(), EvaluateMobilePhys(), Initialise(), PartitionExchangeNonlocalPoints(), PartitionLocalPoints(), SyncColumnComm(), and UpdateMobileCoords().

◆ m_mobilePts

std::map<int, MobilePointSharedPtr> Nektar::SolverUtils::EvaluatePoints::m_mobilePts

protected

Definition at line 260 of file EvaluatePoints.h.

Referenced by CopyMobilePtsToStatic(), CopyStaticPtsToMobile(), EvaluateMobilePhys(), GatherMobilePhysics(), PartitionExchangeNonlocalPoints(), PartitionLocalPoints(), SetUpCommInfo(), SyncColumnComm(), and UpdateMobileCoords().

◆ m_nPhysics

int Nektar::SolverUtils::EvaluatePoints::m_nPhysics

protected

Definition at line 257 of file EvaluatePoints.h.

Referenced by EvaluateMobilePhys(), GatherMobilePhysics(), and PassMobilePhysToStatic().

◆ m_rank

int Nektar::SolverUtils::EvaluatePoints::m_rank

protected

Definition at line 253 of file EvaluatePoints.h.

Referenced by CopyStaticPtsToMobile(), GatherMobilePhysics(), Initialise(), Nektar::SolverUtils::FilterLagrangianPoints::OutputStatPoints(), PartitionExchangeNonlocalPoints(), PassStaticCoordsToMobile(), SetUpCommInfo(), UpdateMobileCoords(), and Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise().

◆ m_recvMobInfo

std::map<int, int> Nektar::SolverUtils::EvaluatePoints::m_recvMobInfo

protected

Definition at line 267 of file EvaluatePoints.h.

Referenced by GatherMobilePhysics(), PartitionExchangeNonlocalPoints(), and SetUpCommInfo().

◆ m_recvStatInfo

std::map<int, int> Nektar::SolverUtils::EvaluatePoints::m_recvStatInfo

protected

Definition at line 268 of file EvaluatePoints.h.

Referenced by PartitionExchangeNonlocalPoints(), SetUpCommInfo(), and UpdateMobileCoords().

◆ m_rowRank

int Nektar::SolverUtils::EvaluatePoints::m_rowRank

protected

Definition at line 254 of file EvaluatePoints.h.

Referenced by Initialise(), PartitionExchangeNonlocalPoints(), and SetUpCommInfo().

◆ m_spacedim

int Nektar::SolverUtils::EvaluatePoints::m_spacedim

protected

Definition at line 252 of file EvaluatePoints.h.

Referenced by CopyStaticPtsToMobile(), Nektar::SolverUtils::FilterLagrangianPoints::ExtraPhysicsVars(), GetDefaultValue(), Nektar::SolverUtils::FilterLagrangianPoints::GetPhysicsData(), Initialise(), Nektar::SolverUtils::FilterLagrangianPoints::OutputSamplePoints(), PartitionExchangeNonlocalPoints(), PassStaticCoordsToMobile(), SyncColumnComm(), UpdateMobileCoords(), Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise(), and Nektar::SolverUtils::FilterLagrangianPoints::v_ModifyVelocity().

◆ m_staticPts

StationaryPointsSharedPtr Nektar::SolverUtils::EvaluatePoints::m_staticPts

protected

Definition at line 259 of file EvaluatePoints.h.

Referenced by CopyMobilePtsToStatic(), CopyStaticPtsToMobile(), Nektar::SolverUtils::FilterLagrangianPoints::OutputSamplePoints(), Nektar::SolverUtils::FilterLagrangianPoints::OutputStatPoints(), PassMobilePhysToStatic(), PassStaticCoordsToMobile(), Nektar::SolverUtils::FilterLagrangianPoints::v_Initialise(), and Nektar::SolverUtils::FilterLagrangianPoints::v_Update().

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ EvaluatePoints()

◆ ~EvaluatePoints()

Member Function Documentation

◆ CopyMobilePtsToStatic()

◆ CopyStaticPtsToMobile()

◆ EvaluateMobilePhys()

◆ GatherMobilePhysics()

◆ GetDefaultValue()

◆ Initialise()

◆ Pack2Int()

◆ Pack2Short()

◆ Pack3Int()

◆ PartitionExchangeNonlocalPoints()

◆ PartitionLocalPoints()

◆ PartitionMobilePts()

◆ PassMobilePhysToStatic()

◆ PassStaticCoordsToMobile()

◆ SetUpCommInfo()

◆ SyncColumnComm()

◆ unPack2Int()

◆ unPack2Short()

◆ unPack3Int()

◆ UpdateMobileCoords()

◆ v_ModifyVelocity()

Member Data Documentation

◆ m_columnRank

◆ m_comm

◆ m_defaultValueFunction

◆ m_isHomogeneous1D

◆ m_mobilePts

◆ m_nPhysics

◆ m_rank

◆ m_recvMobInfo

◆ m_recvStatInfo

◆ m_rowRank

◆ m_spacedim

◆ m_staticPts