#include <InterfaceMapDG.h>

Public Member Functions
	InterfaceTrace (const ExpListSharedPtr &trace, const SpatialDomains::InterfaceShPtr &interfaceShPtr, SpatialDomains::MovementSharedPtr movementShPtr)
	Constructor.

virtual	~InterfaceTrace ()=default
	Default destructor.

void	SetCheckLocal (bool flag)

std::vector< Array< OneD, NekDouble > >	GetMissingCoords ()
	Returns the missing coordinates vector.

std::map< int, std::pair< int, Array< OneD, NekDouble > > >	GetLocalCoords ()

std::map< int, std::pair< int, NekDouble > >	GetRotAngle ()

SpatialDomains::InterfaceShPtr	GetInterface ()
	Returns the interface object.

void	CalcLocalMissing ()
	Calculates what coordinates on the interface are missing locally.

void	FillLocalBwdTrace (Array< OneD, NekDouble > &Fwd, Array< OneD, NekDouble > &Bwd)
	Fills the Bwd trace by interpolating from the Fwd for local interfaces.

void	RotLocalBwdTrace (Array< OneD, Array< OneD, NekDouble > > &Bwd, const int &dim)
	Rotates the interface velocity for sector rotation.

void	RotLocalBwdDeriveTrace (TensorOfArray3D< NekDouble > &Bwd, const int &dim)
	Rotates the interface derivative velocity for sector rotation.

void	DeriveRotate (TensorOfArray3D< NekDouble > &Bwd, const int dir, const NekDouble angle)
	Rotate the 3D vector field in Bwd around the axis 'dir' by 'angle'.

void	FillRankBwdTrace (Array< OneD, NekDouble > &trace, Array< OneD, NekDouble > &Bwd)
	Fills the Bwd trace from partitioned trace.

void	DomainCheck (Array< OneD, NekDouble > &gloCoord, NekDouble &angle)
	Update the coordiniates after movement.

Private Attributes
ExpListSharedPtr	m_trace
	Trace expansion list.

SpatialDomains::InterfaceShPtr	m_interface
	Local interface object.

SpatialDomains::MovementSharedPtr	m_movement
	Movement object associated with the non-conformal interfaces.

bool	m_checkLocal = false
	Flag whether the opposite side of the interface is present locally.

std::vector< Array< OneD, NekDouble > >	m_missingCoords
	Vector of coordinates on interface missing from the other side locally.

std::map< int, std::pair< int, Array< OneD, NekDouble > > >	m_foundLocalCoords
	Map of found coordinates present locally.

std::map< int, std::pair< int, NekDouble > >	m_phyRotAngle
	Map of phy rotate angle for sector rotate interfaces.

std::vector< int >	m_mapMissingCoordToTrace
	Vector of indices corresponding to m_missingCoord locations in trace.

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,
		SpatialDomains::MovementSharedPtr	movementShPtr
	)

Constructor.

Definition at line 41 of file InterfaceMapDG.cpp.

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

◆ ~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 263 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();
    // Zone id
    int id          = m_interface->GetId();
    NekDouble angle = 0.0;
 
    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 mesh has moved, need to update corresponding points on
                // interface
                if (m_movement->GetMovedFlag())
                {
                    DomainCheck(xs, angle);
 
                    // Record the rotation angle for sector rotation
                    if (m_movement->GetSectorRotateFlag())
                    {
                        m_phyRotAngle[offset + i] = std::make_pair(id, angle);
                    }
                }
 
                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 mesh has moved, need to update corresponding points on
                // interface
                if (m_movement->GetMovedFlag())
                {
                    DomainCheck(xs, angle);
 
                    // Record the rotation angle for sector rotation
                    if (m_movement->GetSectorRotateFlag())
                    {
                        m_phyRotAngle[offset + i] = std::make_pair(id, angle);
                    }
                }
 
                // 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, m_movement, m_phyRotAngle, and m_trace.

◆ DeriveRotate()

void Nektar::MultiRegions::InterfaceTrace::DeriveRotate	(	TensorOfArray3D< NekDouble > &	Bwd,
		const int	dir,
		const NekDouble	angle
	)

Rotate the 3D vector field in Bwd around the axis 'dir' by 'angle'.

Definition at line 993 of file InterfaceMapDG.cpp.

{
    // Precompute trigonometric values using correct angle input
    const NekDouble cosA = cos(angle);
    const NekDouble sinA = sin(angle);
 
    // Define rotation matrix R (3x3) using Array<OneD, NekDouble> in
    // **column-major order**
    Array<OneD, NekDouble> R(9, 0.0);
 
    if (dir == 0) // Rotation around X-axis
    {
        R[0] = 1.0;
        R[3] = 0.0;
        R[6] = 0.0;
        R[1] = 0.0;
        R[4] = cosA;
        R[7] = -sinA;
        R[2] = 0.0;
        R[5] = sinA;
        R[8] = cosA;
    }
    else if (dir == 1) // Rotation around Y-axis
    {
        R[0] = cosA;
        R[3] = 0.0;
        R[6] = sinA;
        R[1] = 0.0;
        R[4] = 1.0;
        R[7] = 0.0;
        R[2] = -sinA;
        R[5] = 0.0;
        R[8] = cosA;
    }
    else if (dir == 2) // Rotation around Z-axis
    {
        R[0] = cosA;
        R[3] = -sinA;
        R[6] = 0.0;
        R[1] = sinA;
        R[4] = cosA;
        R[7] = 0.0;
        R[2] = 0.0;
        R[5] = 0.0;
        R[8] = 1.0;
    }
    else
    {
        NEKERROR(
            ErrorUtil::efatal,
            "Invalid rotation axis for first-order derivative transformation.");
    }
 
    // Allocate gradient tensor (3x3) in **column-major order**
    Array<OneD, NekDouble> gradU(9, 0.0);
 
    // Load original velocity gradient tensor into **column-major** format
    gradU[0] = Bwd[0][1][0]; // ∂u_x/∂x
    gradU[3] = Bwd[1][1][0]; // ∂u_x/∂y
    gradU[6] = Bwd[2][1][0]; // ∂u_x/∂z
 
    gradU[1] = Bwd[0][2][0]; // ∂u_y/∂x
    gradU[4] = Bwd[1][2][0]; // ∂u_y/∂y
    gradU[7] = Bwd[2][2][0]; // ∂u_y/∂z
 
    gradU[2] = Bwd[0][3][0]; // ∂u_z/∂x
    gradU[5] = Bwd[1][3][0]; // ∂u_z/∂y
    gradU[8] = Bwd[2][3][0]; // ∂u_z/∂z
 
    // Allocate intermediate matrix R * gradU in **column-major order**
    Array<OneD, NekDouble> R_gradU(9, 0.0);
 
    // Perform matrix multiplication R * gradU using Blas::Dgemm in
    // **column-major order**
    Blas::Dgemm('N', 'N', 3, 3, 3, 1.0, R.data(), 3, gradU.data(), 3, 0.0,
                R_gradU.data(), 3);
 
    // Allocate final rotated gradient (R * gradU) * R^T in **column-major
    // order**
    Array<OneD, NekDouble> gradU_rotated(9, 0.0);
 
    // Perform matrix multiplication (R * gradU) * R^T using Blas::Dgemm in
    // **column-major order**
    Blas::Dgemm('N', 'T', 3, 3, 3, 1.0, R_gradU.data(), 3, R.data(), 3, 0.0,
                gradU_rotated.data(), 3);
 
    // Store rotated gradients back in Bwd in **column-major order**
    Bwd[0][1][0] = gradU_rotated[0]; // ∂u_x'/∂x'
    Bwd[1][1][0] = gradU_rotated[3]; // ∂u_x'/∂y'
    Bwd[2][1][0] = gradU_rotated[6]; // ∂u_x'/∂z'
 
    Bwd[0][2][0] = gradU_rotated[1]; // ∂u_y'/∂x'
    Bwd[1][2][0] = gradU_rotated[4]; // ∂u_y'/∂y'
    Bwd[2][2][0] = gradU_rotated[7]; // ∂u_y'/∂z'
 
    Bwd[0][3][0] = gradU_rotated[2]; // ∂u_z'/∂x'
    Bwd[1][3][0] = gradU_rotated[5]; // ∂u_z'/∂y'
    Bwd[2][3][0] = gradU_rotated[8]; // ∂u_z'/∂z'
}

References Blas::Dgemm(), Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by RotLocalBwdDeriveTrace().

◆ DomainCheck()

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

Update the coordiniates after movement.

Definition at line 810 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 = m_movement->GetZones();
 
    if (m_movement->GetTranslateFlag())
    {
        auto disp    = zones[id]->v_GetDisp();
        auto oppdisp = zones[oppid]->v_GetDisp();
        Array<OneD, NekDouble> box(6);
        Array<OneD, NekDouble> length(3);
 
        // Get zone length and domian box from the translate zone
        if (zones[id]->GetMovementType() ==
            SpatialDomains::MovementType::eTranslate)
        {
            auto zone = std::static_pointer_cast<SpatialDomains::ZoneTranslate>(
                zones[id]);
            box    = zone->GetZoneBox();
            length = zone->GetZoneLength();
        }
        else if (zones[oppid]->GetMovementType() ==
                 SpatialDomains::MovementType::eTranslate)
        {
            auto zone = std::static_pointer_cast<SpatialDomains::ZoneTranslate>(
                zones[oppid]);
            box    = zone->GetZoneBox();
            length = zone->GetZoneLength();
        }
 
        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 + 1e-8)
                {
                    gloCoord[i] = gloCoord[i] - length[i] + tmp * length[i];
                }
                else
                {
                    gloCoord[i] = gloCoord[i] + tmp * length[i];
                }
            }
            else
            {
                if (gloCoord[i] < box[i] + ExactOppMove - 1e-8)
                {
                    gloCoord[i] = gloCoord[i] + length[i] + tmp * length[i];
                }
                else
                {
                    gloCoord[i] = gloCoord[i] + tmp * length[i];
                }
            }
        }
    }
 
    if (m_movement->GetSectorRotateFlag())
    {
        // Using rotation zone information to update the coordinates
        auto zone =
            std::static_pointer_cast<SpatialDomains::ZoneRotate>(zones[id]);
        auto zone2 =
            std::static_pointer_cast<SpatialDomains::ZoneRotate>(zones[oppid]);
 
        // Get the rotation angle of the current interface and the opposite
        // interface
        auto angle    = zone->v_GetAngle();
        auto oppAngle = zone2->v_GetAngle();
 
        // Get the sector angle
        NekDouble SectorAngle = zone->GetSectorAngle();
 
        NekDouble ExactOppMove = 0.0;
        RotateAngle            = 0.0;
 
        int tmp1 = 0;
        int tmp2 = 0;
        int tmp3 = 0;
 
        // Get the base coordinate of the sector
        Array<OneD, NekDouble> base = zone->GetSectorBase();
 
        // Normalize angles to [0, 2*PI)
        angle = std::fmod(angle, 2 * M_PI);
        if (angle < 0)
        {
            angle += 2 * M_PI;
        }
        oppAngle = std::fmod(oppAngle, 2 * M_PI);
        if (oppAngle < 0)
        {
            oppAngle += 2 * M_PI;
        }
 
        // Map coordinate back to the original mesh
        ExactOppMove = std::fmod(oppAngle, SectorAngle);
        tmp1         = static_cast<int>(std::floor(angle / SectorAngle));
        tmp2         = static_cast<int>(std::floor(oppAngle / SectorAngle));
 
        // Compute the angle between the current coordinate and the base
        // coordinate
        auto axis      = zone->GetAxis();
        NekDouble diff = 0.0;
        if (axis[0] == 0 && axis[1] == 0 && axis[2] == 1)
        {
            diff = atan2(gloCoord[1], gloCoord[0]) - atan2(base[1], base[0]);
        }
        else if (axis[0] == 1 && axis[1] == 0 && axis[2] == 0)
        {
            diff = atan2(gloCoord[2], gloCoord[1]) - atan2(base[2], base[1]);
        }
        else if (axis[0] == 0 && axis[1] == 1 && axis[2] == 0)
        {
            diff = atan2(gloCoord[0], gloCoord[2]) - atan2(base[0], base[2]);
        }
        else
        {
            NEKERROR(ErrorUtil::efatal, "Invalid rotation axis.");
        }
 
        // Normalize angles to [0, 2*PI)
        if (diff < 0)
        {
            diff += 2 * M_PI;
        }
        tmp3 = static_cast<int>(std::floor(diff / SectorAngle));
 
        // Compute the exact difference after mapping the angle back to the
        // original mesh
        NekDouble Exactdiff = std::fmod(diff, SectorAngle);
 
        // update coordinates for perioidic interface
        if (oppAngle - angle < 0)
        {
            if (ExactOppMove < Exactdiff && tmp3 != tmp1)
            {
                RotateAngle =
                    -SectorAngle + tmp2 * SectorAngle - tmp1 * SectorAngle;
 
                zone->Rotate(gloCoord, RotateAngle);
            }
            else
            {
                RotateAngle = -tmp1 * SectorAngle + tmp2 * SectorAngle;
                zone->Rotate(gloCoord, RotateAngle);
            }
        }
        else
        {
            if (Exactdiff < ExactOppMove && tmp3 == tmp1)
            {
                RotateAngle =
                    SectorAngle + tmp2 * SectorAngle - tmp1 * SectorAngle;
                zone->Rotate(gloCoord, RotateAngle);
            }
            else
            {
                RotateAngle = -tmp1 * SectorAngle + tmp2 * SectorAngle;
                zone->Rotate(gloCoord, RotateAngle);
            }
        }
    }
}

References Nektar::ErrorUtil::efatal, Nektar::SpatialDomains::eTranslate, m_interface, m_movement, and NEKERROR.

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 547 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 686 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 84 of file InterfaceMapDG.h.

    {
        return m_interface;
    }

References m_interface.

◆ GetLocalCoords()

std::map< int, std::pair< int, Array< OneD, NekDouble > > > Nektar::MultiRegions::InterfaceTrace::GetLocalCoords ( )

inline

Definition at line 73 of file InterfaceMapDG.h.

    {
        return m_foundLocalCoords;
    }

References m_foundLocalCoords.

◆ GetMissingCoords()

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

inline

Returns the missing coordinates vector.

Definition at line 67 of file InterfaceMapDG.h.

    {
        return m_missingCoords;
    }

References m_missingCoords.

◆ GetRotAngle()

std::map< int, std::pair< int, NekDouble > > Nektar::MultiRegions::InterfaceTrace::GetRotAngle ( )

inline

Definition at line 78 of file InterfaceMapDG.h.

    {
        return m_phyRotAngle;
    }

References m_phyRotAngle.

◆ RotLocalBwdDeriveTrace()

void Nektar::MultiRegions::InterfaceTrace::RotLocalBwdDeriveTrace	(	TensorOfArray3D< NekDouble > &	Bwd,
		const int &	dim
	)

Rotates the interface derivative velocity for sector rotation.

Definition at line 603 of file InterfaceMapDG.cpp.

{
 
    // Get rotating information from zones
    size_t nVariables = Bwd[0].size();
    int id            = m_interface->GetId();
    auto zones        = m_movement->GetZones();
    auto zone = std::static_pointer_cast<SpatialDomains::ZoneRotate>(zones[id]);
    Array<OneD, NekDouble> tmpVelocity(dim);
    auto axis = zone->GetAxis();
    int dir   = 0;
    if (axis[0] == 0 && axis[1] == 0 && axis[2] == 1)
    {
        dir = 2;
    }
    else if (axis[0] == 1 && axis[1] == 0 && axis[2] == 0)
    {
        dir = 0;
    }
    else if (axis[0] == 0 && axis[1] == 1 && axis[2] == 0)
    {
        dir = 1;
    }
    else
    {
        NEKERROR(ErrorUtil::efatal, "Invalid rotation axis.");
    }
 
    // Rotates the derivative velocity for sector rotation
    for (auto &phyRotAngle : m_phyRotAngle)
    {
        int traceId     = phyRotAngle.first;
        NekDouble angle = m_phyRotAngle[traceId].second;
        if (angle != 0)
        {
            TensorOfArray3D<NekDouble> tmpBwd(dim);
 
            for (int j = 0; j < dim; ++j)
            {
                tmpBwd[j] = Array<OneD, Array<OneD, NekDouble>>{nVariables};
                for (int i = 0; i < nVariables; ++i)
                {
                    tmpBwd[j][i] = Array<OneD, NekDouble>{1, 0.0};
                }
            }
 
            for (int j = 0; j < dim; ++j)
            {
                for (int i = 0; i < nVariables; ++i)
                {
                    tmpBwd[j][i][0] = Bwd[j][i][traceId];
                }
            }
 
            DeriveRotate(tmpBwd, dir, -angle);
 
            for (int j = 0; j < dim; ++j)
            {
                for (int i = 0; i < dim; ++i)
                {
                    Bwd[j][i][traceId] = tmpBwd[j][i][0];
                }
            }
        }
    }
}

References DeriveRotate(), Nektar::ErrorUtil::efatal, m_interface, m_movement, m_phyRotAngle, and NEKERROR.

◆ RotLocalBwdTrace()

void Nektar::MultiRegions::InterfaceTrace::RotLocalBwdTrace	(	Array< OneD, Array< OneD, NekDouble > > &	Bwd,
		const int &	dim
	)

Rotates the interface velocity for sector rotation.

Definition at line 567 of file InterfaceMapDG.cpp.

{
 
    Array<OneD, Array<OneD, NekDouble>> vecLocs(1);
    vecLocs[0] = Array<OneD, NekDouble>(dim);
    for (int i = 0; i < dim; ++i)
    {
        vecLocs[0][i] = 1 + i;
    }
    int id     = m_interface->GetId();
    auto zones = m_movement->GetZones();
    auto zone = std::static_pointer_cast<SpatialDomains::ZoneRotate>(zones[id]);
    Array<OneD, NekDouble> tmpVelocity(dim);
 
    // Rotates the interface velocity for sector rotation
    // Loop over rotated search coordinates
    for (auto &phyRotAngle : m_phyRotAngle)
    {
        int traceId     = phyRotAngle.first;
        NekDouble angle = m_phyRotAngle[traceId].second;
        if (angle != 0)
        {
            for (int i = 0; i < dim; ++i)
            {
                tmpVelocity[i] = Bwd[vecLocs[0][i]][traceId];
            }
            zone->Rotate(tmpVelocity, -angle);
            for (int i = 0; i < dim; ++i)
            {
                Bwd[vecLocs[0][i]][traceId] = tmpVelocity[i];
            }
        }
    }
}

References m_interface, m_movement, and m_phyRotAngle.

◆ SetCheckLocal()

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

inline

Definition at line 61 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 117 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 121 of file InterfaceMapDG.h.

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

◆ m_interface

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

private

Local interface object.

Definition at line 113 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), DomainCheck(), GetInterface(), RotLocalBwdDeriveTrace(), and RotLocalBwdTrace().

◆ m_mapMissingCoordToTrace

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

private

Vector of indices corresponding to m_missingCoord locations in trace.

Definition at line 125 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 119 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and GetMissingCoords().

◆ m_movement

SpatialDomains::MovementSharedPtr Nektar::MultiRegions::InterfaceTrace::m_movement

private

Movement object associated with the non-conformal interfaces.

Definition at line 115 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), DomainCheck(), RotLocalBwdDeriveTrace(), and RotLocalBwdTrace().

◆ m_phyRotAngle

std::map<int, std::pair<int, NekDouble> > Nektar::MultiRegions::InterfaceTrace::m_phyRotAngle

private

Map of phy rotate angle for sector rotate interfaces.

Definition at line 123 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), GetRotAngle(), RotLocalBwdDeriveTrace(), and RotLocalBwdTrace().

◆ m_trace

ExpListSharedPtr Nektar::MultiRegions::InterfaceTrace::m_trace

private

Trace expansion list.

Definition at line 111 of file InterfaceMapDG.h.

Referenced by CalcLocalMissing(), and FillLocalBwdTrace().

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ InterfaceTrace()

◆ ~InterfaceTrace()

Member Function Documentation

◆ CalcLocalMissing()

◆ DeriveRotate()

◆ DomainCheck()

◆ FillLocalBwdTrace()

◆ FillRankBwdTrace()

◆ GetInterface()

◆ GetLocalCoords()

◆ GetMissingCoords()

◆ GetRotAngle()

◆ RotLocalBwdDeriveTrace()

◆ RotLocalBwdTrace()

◆ SetCheckLocal()

Member Data Documentation

◆ m_checkLocal

◆ m_foundLocalCoords

◆ m_interface

◆ m_mapMissingCoordToTrace

◆ m_missingCoords

◆ m_movement

◆ m_phyRotAngle

◆ m_trace