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 (SpatialDomains::MovementSharedPtr movement)
	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...
void	DomainCheck (Array< OneD, NekDouble > &gloCoord, SpatialDomains::MovementSharedPtr movement)
	Check whether the coordiniates in the original domain. 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 41 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

(

SpatialDomains::MovementSharedPtr

movement

)

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 262 of file InterfaceMapDG.cpp.

{
    // Nuke old missing/found
    m_missingCoords.clear();
    m_mapMissingCoordToTrace.clear();
 
    // Store copy of found coords to optimise search before clearing
    auto foundLocalCoordsCopy = m_foundLocalCoords;
    m_foundLocalCoords.clear();
 
    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];
 
                if (movement->GetMovedFlag() && movement->GetTranslateFlag())
                {
                    DomainCheck(xs, movement);
                }
 
                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];
 
                if (movement->GetMovedFlag() && movement->GetTranslateFlag())
                {
                    DomainCheck(xs, movement);
                }
 
                // First search the edge the point was found in last timestep
                if (foundLocalCoordsCopy.find(offset + i) !=
                    foundLocalCoordsCopy.end())
                {
                    auto edge = m_interface->GetOppInterface()->GetEdge(
                        foundLocalCoordsCopy[offset + i].first);
                    NekDouble dist = edge->FindDistance(xs, foundLocCoord);
 
                    if (dist < NekConstants::kFindDistanceMin)
                    {
                        m_foundLocalCoords[offset + i] =
                            std::make_pair(edge->GetGlobalID(), foundLocCoord);
                        continue;
                    }
                }
 
                // If not in last timestep edge then loop over all interface
                // edges
                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.
    // Unless we flag to ignore this check for this specific interface.
    if (m_trace->GetComm()->IsSerial() && !m_interface->GetSkipCoordCheck())
    {
        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, DomainCheck(), Nektar::NekConstants::kFindDistanceMin, m_checkLocal, m_foundLocalCoords, m_interface, m_mapMissingCoordToTrace, m_missingCoords, and m_trace.

DomainCheck()

void Nektar::MultiRegions::InterfaceTrace::DomainCheck	(	Array< OneD, NekDouble > &	gloCoord,
		SpatialDomains::MovementSharedPtr	movement
	)

Check whether the coordiniates in the original domain.

Definition at line 690 of file InterfaceMapDG.cpp.

{
    // Get current interface id and opposite interface id
    int id    = m_interface->GetId();
    int oppid = m_interface->GetOppInterface()->GetId();
 
    // Get displacement of the current interface and the opposite interface
    auto zones   = movement->GetZones();
    auto disp    = zones[id]->v_GetDisp();
    auto oppdisp = zones[oppid]->v_GetDisp();
 
    // Get domain length and domian box
    auto box    = movement->GetDomainBox();
    auto length = movement->GetDomainLength();
 
    NekDouble ExactMove    = 0.0;
    NekDouble ExactOppMove = 0.0;
    int tmp                = 0;
 
    // update coordinates by add or minus domian length
    for (int i = 0; i < disp.size(); ++i)
    {
        // map coordinate back to the original mesh
        ExactMove    = std::fmod(disp[i], length[i]);
        ExactOppMove = std::fmod(oppdisp[i], length[i]);
        tmp          = oppdisp[i] / length[i];
        gloCoord[i]  = gloCoord[i] - disp[i] + ExactMove;
 
        // update coordinates for perioidic interface
        if (oppdisp[i] - disp[i] < 0)
        {
            if (gloCoord[i] > box[i + 3] + ExactOppMove)
            {
                gloCoord[i] = gloCoord[i] - length[i] + tmp * length[i];
            }
            else
            {
                gloCoord[i] = gloCoord[i] + tmp * length[i];
            }
        }
        else
        {
            if (gloCoord[i] < box[i] + ExactOppMove)
            {
                gloCoord[i] = gloCoord[i] + length[i] + tmp * length[i];
            }
            else
            {
                gloCoord[i] = gloCoord[i] + tmp * length[i];
            }
        }
    }
}

References m_interface.

Referenced by CalcLocalMissing().

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 531 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 566 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 95 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 99 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 93 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), DomainCheck(), 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 101 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 97 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and GetMissingCoords().

m_trace

ExpListSharedPtr Nektar::MultiRegions::InterfaceTrace::m_trace

private

Trace expansion list.

Definition at line 91 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and FillLocalBwdTrace().