Nektar::MultiRegions::InterfaceTrace Class Reference

#include <InterfaceMapDG.h>

Public Member Functions
	InterfaceTrace (const ExpListSharedPtr &trace, const SpatialDomains::InterfaceShPtr &interfaceShPtr)
	Constructor. More...
virtual	~InterfaceTrace ()=default
	Default destructor. More...
void	SetCheckLocal (bool flag)
std::vector< Array< OneD, NekDouble > >	GetMissingCoords ()
	Returns the missing coordinates vector. More...
SpatialDomains::InterfaceShPtr	GetInterface ()
	Returns the interface object. More...
void	CalcLocalMissing ()
	Calculates what coordinates on the interface are missing locally. More...
void	FillLocalBwdTrace (Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
	Fills the Bwd trace by interpolating from the Fwd for local interfaces. More...
void	FillRankBwdTrace (Array< OneD, NekDouble > &trace, Array< OneD, NekDouble > &Bwd)
	Fills the Bwd trace from partitioned trace. More...

Private Attributes
ExpListSharedPtr	m_trace
	Trace expansion list. More...
SpatialDomains::InterfaceShPtr	m_interface
	Local interface object. More...
bool	m_checkLocal = false
	Flag whether the opposite side of the interface is present locally. More...
std::vector< Array< OneD, NekDouble > >	m_missingCoords
	Vector of coordinates on interface missing from the other side locally. More...
std::map< int, std::pair< int, Array< OneD, NekDouble > > >	m_foundLocalCoords
	Map of found coordinates present locally. More...
std::vector< int >	m_mapMissingCoordToTrace
	Vector of indices corresponding to m_missingCoord locations in trace. More...

Detailed Description

Object for each interface present between two ranks, which are held in the InterfaceExchange object.

Definition at line 49 of file InterfaceMapDG.h.

Constructor & Destructor Documentation

InterfaceTrace()

Nektar::MultiRegions::InterfaceTrace::InterfaceTrace	(	const ExpListSharedPtr &	trace,
		const SpatialDomains::InterfaceShPtr &	interfaceShPtr
	)

Constructor.

Definition at line 40 of file InterfaceMapDG.cpp.

    : m_trace(trace), m_interface(interfaceShPtr)
{
}

~InterfaceTrace()

virtual Nektar::MultiRegions::InterfaceTrace::~InterfaceTrace ( )

virtualdefault

Default destructor.

Member Function Documentation

CalcLocalMissing()

void Nektar::MultiRegions::InterfaceTrace::CalcLocalMissing

(

)

Calculates what coordinates on the interface are missing locally.

Calculates what coordinates on the interface are missing; i.e. aren't located in an edge from the other side of the interface on this partition. These are stored in the vector m_missingCoords, and another vector of the same index layout contains the location of that coordinate in the trace i.e. the 'offset + i' value. It checks first if the interface is flagged local, which denotes whether the opposite side is also present on this rank, if not then all coordinates are missing. If local then the same structure as CalcRankDistances is used to minimise computational cost.

Definition at line 243 of file InterfaceMapDG.cpp.

{
    auto childEdge = m_interface->GetEdge();
    // If not flagged 'check local' then all points are missing
    if (!m_checkLocal)
    {
        int cnt = 0;
        for (auto &childId : childEdge)
        {
            auto childElmt = m_trace->GetExpFromGeomId(childId.first);
            size_t nq      = childElmt->GetTotPoints();
            Array<OneD, NekDouble> xc(nq, 0.0), yc(nq, 0.0), zc(nq, 0.0);
            childElmt->GetCoords(xc, yc, zc);
            int offset =
                m_trace->GetPhys_Offset(m_trace->GetElmtToExpId(childId.first));
 
            for (int i = 0; i < nq; ++i, ++cnt)
            {
                Array<OneD, NekDouble> xs(3);
                xs[0] = xc[i];
                xs[1] = yc[i];
                xs[2] = zc[i];
 
                m_missingCoords.emplace_back(xs);
                m_mapMissingCoordToTrace.emplace_back(offset + i);
            }
        }
    }
    // Otherwise we need to check to see what points the other side of the
    // interface on this rank contains. This is done by looping over each
    // quadrature point in all the edges on this side of the interface, then
    // check if this quadrature point is also in any edges on the other side
    // of the interface. First use MinMaxCheck as a cheap method to eliminate
    // far away edges. If it passes MinMaxCheck perform the FindDistance search
    // which numerically searches for the closest local coordinate on the other
    // interface side edge and returns the cartesian distance from the search
    // coordinate to the found local coordinate. If determined to be close
    // enough then add to found local coordinates.
    else
    {
        for (auto &childId : childEdge)
        {
            auto childElmt = m_trace->GetExpFromGeomId(childId.first);
            size_t nq      = childElmt->GetTotPoints();
            Array<OneD, NekDouble> xc(nq, 0.0), yc(nq, 0.0), zc(nq, 0.0);
            childElmt->GetCoords(xc, yc, zc);
            int offset =
                m_trace->GetPhys_Offset(m_trace->GetElmtToExpId(childId.first));
 
            for (int i = 0; i < nq; ++i)
            {
                bool found = false;
                Array<OneD, NekDouble> foundLocCoord;
                Array<OneD, NekDouble> xs(3);
                xs[0] = xc[i];
                xs[1] = yc[i];
                xs[2] = zc[i];
 
                auto parentEdge = m_interface->GetOppInterface()->GetEdge();
                for (auto &edge : parentEdge)
                {
                    // First check if inside the edge bounding box
                    if (!edge.second->MinMaxCheck(xs))
                    {
                        continue;
                    }
 
                    NekDouble dist =
                        edge.second->FindDistance(xs, foundLocCoord);
                    if (dist < NekConstants::kFindDistanceMin)
                    {
                        found                          = true;
                        m_foundLocalCoords[offset + i] = std::make_pair(
                            edge.second->GetGlobalID(), foundLocCoord);
                        break;
                    }
                }
 
                if (!found)
                {
                    m_missingCoords.emplace_back(xs);
                    m_mapMissingCoordToTrace.emplace_back(offset + i);
                }
            }
        }
    }
 
    // If running in serial there shouldn't be any missing coordinates.
    if (m_trace->GetComm()->IsSerial())
    {
        ASSERTL0(m_missingCoords.empty(),
                 "Missing " + std::to_string(m_missingCoords.size()) +
                     " coordinates on interface ID " +
                     std::to_string(m_interface->GetId()) +
                     " linked to interface ID " +
                     std::to_string(m_interface->GetOppInterface()->GetId()) +
                     ". Check both sides of the interface line up.");
    }
}

References ASSERTL0, Nektar::NekConstants::kFindDistanceMin, m_checkLocal, m_foundLocalCoords, m_interface, m_mapMissingCoordToTrace, m_missingCoords, and m_trace.

FillLocalBwdTrace()

void Nektar::MultiRegions::InterfaceTrace::FillLocalBwdTrace	(	Array< OneD, NekDouble > &	Fwd,
		Array< OneD, NekDouble > &	Bwd
	)

Fills the Bwd trace by interpolating from the Fwd for local interfaces.

Definition at line 470 of file InterfaceMapDG.cpp.

{
    // If flagged then fill trace from local coords
    if (m_checkLocal)
    {
        for (auto &foundLocCoord : m_foundLocalCoords)
        {
            int traceId = m_trace->GetElmtToExpId(foundLocCoord.second.first);
            Array<OneD, NekDouble> locCoord = foundLocCoord.second.second;
 
            Array<OneD, NekDouble> edgePhys =
                Fwd + m_trace->GetPhys_Offset(traceId);
 
            Bwd[foundLocCoord.first] =
                m_trace->GetExp(traceId)->StdPhysEvaluate(locCoord, edgePhys);
        }
    }
}

References m_checkLocal, m_foundLocalCoords, and m_trace.

FillRankBwdTrace()

void Nektar::MultiRegions::InterfaceTrace::FillRankBwdTrace	(	Array< OneD, NekDouble > &	trace,
		Array< OneD, NekDouble > &	Bwd
	)

Fills the Bwd trace from partitioned trace.

Definition at line 505 of file InterfaceMapDG.cpp.

{
    for (int i = 0; i < m_mapMissingCoordToTrace.size(); ++i)
    {
        if (!std::isnan(trace[i]))
        {
            Bwd[m_mapMissingCoordToTrace[i]] = trace[i];
        }
    }
}

References m_mapMissingCoordToTrace.

GetInterface()

SpatialDomains::InterfaceShPtr Nektar::MultiRegions::InterfaceTrace::GetInterface ( )

inline

Returns the interface object.

Definition at line 72 of file InterfaceMapDG.h.

    {
        return m_interface;
    }

References m_interface.

GetMissingCoords()

std::vector< Array< OneD, NekDouble > > Nektar::MultiRegions::InterfaceTrace::GetMissingCoords ( )

inline

Returns the missing coordinates vector.

Definition at line 66 of file InterfaceMapDG.h.

    {
        return m_missingCoords;
    }

References m_missingCoords.

SetCheckLocal()

void Nektar::MultiRegions::InterfaceTrace::SetCheckLocal ( bool  flag )

inline

Definition at line 60 of file InterfaceMapDG.h.

    {
        m_checkLocal = flag;
    }

References m_checkLocal.

Member Data Documentation

m_checkLocal

bool Nektar::MultiRegions::InterfaceTrace::m_checkLocal = false

private

Flag whether the opposite side of the interface is present locally.

Definition at line 92 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), FillLocalBwdTrace(), and SetCheckLocal().

m_foundLocalCoords

std::map<int, std::pair<int, Array<OneD, NekDouble> > > Nektar::MultiRegions::InterfaceTrace::m_foundLocalCoords

private

Map of found coordinates present locally.

Definition at line 96 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and FillLocalBwdTrace().

m_interface

SpatialDomains::InterfaceShPtr Nektar::MultiRegions::InterfaceTrace::m_interface

private

Local interface object.

Definition at line 90 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and GetInterface().

m_mapMissingCoordToTrace

std::vector<int> Nektar::MultiRegions::InterfaceTrace::m_mapMissingCoordToTrace

private

Vector of indices corresponding to m_missingCoord locations in trace.

Definition at line 98 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and FillRankBwdTrace().

m_missingCoords

std::vector<Array<OneD, NekDouble> > Nektar::MultiRegions::InterfaceTrace::m_missingCoords

private

Vector of coordinates on interface missing from the other side locally.

Definition at line 94 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and GetMissingCoords().

m_trace

ExpListSharedPtr Nektar::MultiRegions::InterfaceTrace::m_trace

private

Trace expansion list.

Definition at line 88 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and FillLocalBwdTrace().