Nektar::MultiRegions::LocTraceToTraceMap Class Reference

A helper class to deal with trace operations in the discontinuous Galerkin code. More...

#include <LocTraceToTraceMap.h>

Collaboration diagram for Nektar::MultiRegions::LocTraceToTraceMap:

Public Member Functions
	LocTraceToTraceMap (const ExpList &locExp, const ExpListSharedPtr &trace, const Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > &elmtToTrace, const std::vector< bool > &LeftAdjacents)
	Set up trace to trace mapping components. More...
virtual	~LocTraceToTraceMap ()
void	Setup2D (const ExpList &locExp, const ExpListSharedPtr &trace, const Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > &elmtToTrace, const std::vector< bool > &LeftAdjacents)
	Set up member variables for a two-dimensional problem. More...
void	Setup3D (const ExpList &locExp, const ExpListSharedPtr &trace, const Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > &elmtToTrace, const std::vector< bool > &LeftAdjacents)
	Set up member variables for a three-dimensional problem. More...
void	LocTracesFromField (const Array< OneD, const NekDouble > &field, Array< OneD, NekDouble > faces)
	Gather the local traces in physical space from field using m_fieldToLocTraceMap. More...
void	FwdLocTracesFromField (const Array< OneD, const NekDouble > &field, Array< OneD, NekDouble > faces)
	Gather the forwards-oriented local traces in physical space from field using m_fieldToLocTraceMap. More...
void	InterpLocEdgesToTrace (const int dir, const Array< OneD, const NekDouble > &locfaces, Array< OneD, NekDouble > edges)
	Interpolate local trace edges to global trace edge point distributions where required. More...
void	InterpLocFacesToTrace (const int dir, const Array< OneD, const NekDouble > &locfaces, Array< OneD, NekDouble > faces)
	Interpolate local faces to trace face point distributions where required. More...
void	AddTraceCoeffsToFieldCoeffs (const Array< OneD, const NekDouble > &trace, Array< OneD, NekDouble > &field)
	Add contributions from trace coefficients to the elemental field storage. More...
void	AddTraceCoeffsToFieldCoeffs (const int dir, const Array< OneD, const NekDouble > &race, Array< OneD, NekDouble > &field)
	Add contributions from backwards or forwards oriented trace coefficients to the elemental field storage. More...
int	GetNFwdLocTracePts ()
	Return the number of `forward' local trace points. More...
int	GetNLocTracePts ()
	Return the number of local trace points. More...

Private Attributes
int	m_nFwdLocTracePts
	The number of forward trace points. A local trace element is `forward' if it is the side selected for the global trace. More...
int	m_nLocTracePts
	The number of local trace points. More...
int	m_nTracePts
	The number of global trace points. More...
Array< OneD, int >	m_fieldToLocTraceMap
	A mapping from the local trace points, arranged as all forwards traces followed by backwards traces, to elemental storage. More...
Array< OneD, Array< OneD, int > >	m_LocTraceToTraceMap
	A mapping from local trace points to the global trace. Dimension 0 holds forward traces, dimension 1 backward. More...
Array< OneD, Array< OneD, InterpLocTraceToTrace > >	m_interpTrace
	A mapping holding the type of interpolation needed for each local trace. Dimension 0 holds forward traces, dimension 1 backward. More...
Array< OneD, Array< OneD, DNekMatSharedPtr > >	m_interpTraceI0
	Interpolation matrices for either 2D edges or first coordinate of 3D face. More...
Array< OneD, Array< OneD, DNekMatSharedPtr > >	m_interpTraceI1
	Interpolation matrices for the second coordinate of 3D face, not used in 2D. More...
Array< OneD, Array< OneD, TraceInterpPoints > >	m_interpPoints
	Interpolation points key distributions for each of the local to global mappings. More...
Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_interpEndPtI0
	Mapping to hold first coordinate direction endpoint interpolation, which can be more optimal if using Gauss-Radau distribution for triangles. More...
Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_interpEndPtI1
	Mapping to hold second coordinate direction endpoint interpolation, which can be more optimal if using Gauss-Radau distribution for triangles. More...
Array< OneD, Array< OneD, int > >	m_interpNfaces
	Number of edges/faces on a 2D/3D element that require interpolation. More...
int	m_nTraceCoeffs [2]
	Number of forwards/backwards trace coefficients. More...
Array< OneD, Array< OneD, int > >	m_traceCoeffsToElmtMap
	Mapping from forwards/backwards trace coefficients to elemental coefficient storage. More...
Array< OneD, Array< OneD, int > >	m_traceCoeffsToElmtTrace
	Mapping from forwards/backwards trace coefficients to the position of the trace element in global storage. More...
Array< OneD, Array< OneD, int > >	m_traceCoeffsToElmtSign
	Sign array for mapping from forwards/backwards trace coefficients to local trace storage. More...

Detailed Description

A helper class to deal with trace operations in the discontinuous Galerkin code.

This class sets up a number of mappings to deal with operations that take the "local trace" of an expansion list – i.e. the concatenation of all elemental facets – to the "global trace" – where the duplicate facets between connected elements have been removed.

Elements:      Local trace:              Global trace:
+----+----+    + +---+ +   + +---+ +     + +---+ + +---+ +
|    |    |    |       |   |       |     |       |       |
|    |    |    |       |   |       |     |       |       |
+----+----+    + +---+ +   + +---+ +     + +---+ + +---+ +

There are a number of mappings that are required that this class provides maps for:

• Extracting the local trace from the elements in physical space
• Dealing with cases that need interpolation (i.e. where the polynomial order varies between two elements)
• Adding global trace contributions back into the elements.

These are documented in the member variables and class functions.

Definition at line 154 of file LocTraceToTraceMap.h.

Constructor & Destructor Documentation

Nektar::MultiRegions::LocTraceToTraceMap::LocTraceToTraceMap	(	const ExpList &	locExp,
		const ExpListSharedPtr &	trace,
		const Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > &	elmtToTrace,
		const std::vector< bool > &	LeftAdjacents
	)

Set up trace to trace mapping components.

Parameters

locExp	Expansion list of full dimension problem.
trace	Expansion list of one dimension lower trace.
elmtToTrace	Mapping from elemental facets to trace.
leftAdjacents	Vector of bools denoting forwards-oriented traces.

Todo:

Add 1D support

Definition at line 64 of file LocTraceToTraceMap.cpp.

References ASSERTL0, and Nektar::MultiRegions::ExpList::GetExp().

{
    const LocalRegions::ExpansionVector &locExpVector = *(locExp.GetExp());

    // Assume that all the elements have same dimension
    int m_expdim = locExpVector[0]->GetShapeDimension();

    // Switch between 1D, 2D and 3D
    switch (m_expdim)
    {
        case 1:
            break;
        case 2:
            Setup2D(locExp, trace, elmtToTrace, LeftAdjacents);
            break;
        case 3:
            Setup3D(locExp, trace, elmtToTrace, LeftAdjacents);
            break;
        default:
            ASSERTL0(false, "Number of dimensions greater than 3")
            break;
    }
}

Nektar::MultiRegions::LocTraceToTraceMap::~LocTraceToTraceMap ( )

virtual

Definition at line 93 of file LocTraceToTraceMap.cpp.

{
}

Member Function Documentation

void Nektar::MultiRegions::LocTraceToTraceMap::AddTraceCoeffsToFieldCoeffs	(	const Array< OneD, const NekDouble > &	trace,
		Array< OneD, NekDouble > &	field
	)

Add contributions from trace coefficients to the elemental field storage.

Parameters

trace	Array of global trace coefficients.
field	Array containing field coefficients storage.

Definition at line 1213 of file LocTraceToTraceMap.cpp.

{
    int nvals = m_nTraceCoeffs[0] + m_nTraceCoeffs[1];
    for (int i = 0; i < nvals; ++i)
    {
        field[m_traceCoeffsToElmtMap[0][i]] +=
            m_traceCoeffsToElmtSign[0][i] *
            trace[m_traceCoeffsToElmtTrace[0][i]];
    }
}

void Nektar::MultiRegions::LocTraceToTraceMap::AddTraceCoeffsToFieldCoeffs	(	const int	dir,
		const Array< OneD, const NekDouble > &	trace,
		Array< OneD, NekDouble > &	field
	)

Add contributions from backwards or forwards oriented trace coefficients to the elemental field storage.

Parameters

dir	Selects forwards (0) or backwards (1) direction
trace	Array of global trace coefficients.
field	Array containing field coefficients storage.

Definition at line 1233 of file LocTraceToTraceMap.cpp.

{
    int nvals = m_nTraceCoeffs[dir];
    for (int i = 0; i < nvals; ++i)
    {
        field[m_traceCoeffsToElmtMap[dir][i]] +=
            m_traceCoeffsToElmtSign[dir][i] *
            trace[m_traceCoeffsToElmtTrace[dir][i]];
    }
}

void Nektar::MultiRegions::LocTraceToTraceMap::FwdLocTracesFromField	(	const Array< OneD, const NekDouble > &	field,
		Array< OneD, NekDouble >	faces
	)

Gather the forwards-oriented local traces in physical space from field using m_fieldToLocTraceMap.

Parameters

field	Solution field in physical space
faces	Resulting local forwards-oriented traces.

Definition at line 866 of file LocTraceToTraceMap.cpp.

References Vmath::Gathr().

{
    Vmath::Gathr(m_nFwdLocTracePts, field, m_fieldToLocTraceMap, faces);
}

int Nektar::MultiRegions::LocTraceToTraceMap::GetNFwdLocTracePts ( )

inline

Return the number of `forward' local trace points.

Definition at line 212 of file LocTraceToTraceMap.h.

References m_nFwdLocTracePts.

    {
        return m_nFwdLocTracePts;
    }

int Nektar::MultiRegions::LocTraceToTraceMap::GetNLocTracePts ( )

inline

Return the number of local trace points.

Definition at line 220 of file LocTraceToTraceMap.h.

References m_nLocTracePts.

    {
        return m_nLocTracePts;
    }

void Nektar::MultiRegions::LocTraceToTraceMap::InterpLocEdgesToTrace	(	const int	dir,
		const Array< OneD, const NekDouble > &	locedges,
		Array< OneD, NekDouble >	edges
	)

Interpolate local trace edges to global trace edge point distributions where required.

Parameters

dir	Selects forwards (0) or backwards (1) direction.
locfaces	Local trace edge storage.
faces	Global trace edge storage

Definition at line 880 of file LocTraceToTraceMap.cpp.

References ASSERTL0, ASSERTL1, Vmath::Ddot(), Nektar::MultiRegions::eInterpDir0, Nektar::MultiRegions::eInterpEndPtDir0, Nektar::MultiRegions::eNoInterp, Nektar::LibUtilities::PointsKey::GetNumPoints(), Vmath::Scatr(), and Vmath::Vcopy().

{
    ASSERTL1(dir < 2,
             "option dir out of range, "
             " dir=0 is fwd, dir=1 is bwd");

    int cnt  = 0;
    int cnt1 = 0;

    // tmp space assuming forward map is of size of trace
    Array<OneD, NekDouble> tmp(m_nTracePts);

    for (int i = 0; i < m_interpTrace[dir].num_elements(); ++i)
    {
        // Check if there are edges to interpolate
        if (m_interpNfaces[dir][i])
        {
            // Get to/from points
            LibUtilities::PointsKey fromPointsKey0 =
                m_interpPoints[dir][i].get<0>();
            LibUtilities::PointsKey toPointsKey0 =
                m_interpPoints[dir][i].get<2>();

            int fnp    = fromPointsKey0.GetNumPoints();
            int tnp    = toPointsKey0.GetNumPoints();
            int nedges = m_interpNfaces[dir][i];

            // Do interpolation here if required
            switch (m_interpTrace[dir][i])
            {
                case eNoInterp: // Just copy
                {
                    Vmath::Vcopy(nedges * fnp,
                                 locedges.get() + cnt,
                                 1,
                                 tmp.get() + cnt1,
                                 1);
                }
                break;
                case eInterpDir0:
                {
                    DNekMatSharedPtr I0 = m_interpTraceI0[dir][i];
                    Blas::Dgemm('N',
                                'N',
                                tnp,
                                nedges,
                                fnp,
                                1.0,
                                I0->GetPtr().get(),
                                tnp,
                                locedges.get() + cnt,
                                fnp,
                                0.0,
                                tmp.get() + cnt1,
                                tnp);
                }
                break;
                case eInterpEndPtDir0:
                {
                    Array<OneD, NekDouble> I0 = m_interpEndPtI0[dir][i];

                    for (int k = 0; k < nedges; ++k)
                    {
                        Vmath::Vcopy(fnp,
                                     &locedges[cnt + k * fnp],
                                     1,
                                     &tmp[cnt1 + k * tnp],
                                     1);

                        tmp[cnt1 + k * tnp + tnp - 1] = Blas::Ddot(
                            fnp, locedges.get() + cnt + k * fnp, 1, &I0[0], 1);
                    }
                }
                break;
                default:
                    ASSERTL0(false,
                             "Invalid interpolation type for 2D elements");
                    break;
            }

            cnt += nedges * fnp;
            cnt1 += nedges * tnp;
        }
    }

    Vmath::Scatr(m_LocTraceToTraceMap[dir].num_elements(),
                 tmp.get(),
                 m_LocTraceToTraceMap[dir].get(),
                 edges.get());
}

void Nektar::MultiRegions::LocTraceToTraceMap::InterpLocFacesToTrace	(	const int	dir,
		const Array< OneD, const NekDouble > &	locfaces,
		Array< OneD, NekDouble >	faces
	)

Interpolate local faces to trace face point distributions where required.

Parameters

dir	Selects forwards (0) or backwards (1) direction.
locfaces	Local trace face storage.
faces	Global trace face storage

Definition at line 982 of file LocTraceToTraceMap.cpp.

References ASSERTL1, Vmath::Ddot(), Nektar::MultiRegions::eInterpBothDirs, Nektar::MultiRegions::eInterpDir0, Nektar::MultiRegions::eInterpDir1, Nektar::MultiRegions::eInterpEndPtDir0, Nektar::MultiRegions::eInterpEndPtDir0InterpDir1, Nektar::MultiRegions::eInterpEndPtDir1, Nektar::MultiRegions::eNoInterp, Nektar::LibUtilities::PointsKey::GetNumPoints(), Vmath::Scatr(), and Vmath::Vcopy().

{
    ASSERTL1(dir < 2,
             "option dir out of range, "
             " dir=0 is fwd, dir=1 is bwd");

    int cnt1 = 0;
    int cnt  = 0;

    // tmp space assuming forward map is of size of trace
    Array<OneD, NekDouble> tmp(m_nTracePts);

    for (int i = 0; i < m_interpTrace[dir].num_elements(); ++i)
    {
        // Check if there are faces to interpolate
        if (m_interpNfaces[dir][i])
        {
            // Get to/from points
            LibUtilities::PointsKey fromPointsKey0 =
                m_interpPoints[dir][i].get<0>();
            LibUtilities::PointsKey fromPointsKey1 =
                m_interpPoints[dir][i].get<1>();
            LibUtilities::PointsKey toPointsKey0 =
                m_interpPoints[dir][i].get<2>();
            LibUtilities::PointsKey toPointsKey1 =
                m_interpPoints[dir][i].get<3>();

            int fnp0         = fromPointsKey0.GetNumPoints();
            int fnp1         = fromPointsKey1.GetNumPoints();
            int tnp0         = toPointsKey0.GetNumPoints();
            int tnp1         = toPointsKey1.GetNumPoints();
            int nfromfacepts = m_interpNfaces[dir][i] * fnp0 * fnp1;
            ;

            // Do interpolation here if required
            switch (m_interpTrace[dir][i])
            {
                case eNoInterp: // Just copy
                {
                    Vmath::Vcopy(nfromfacepts,
                                 locfaces.get() + cnt,
                                 1,
                                 tmp.get() + cnt1,
                                 1);
                }
                break;
                case eInterpDir0:
                {
                    DNekMatSharedPtr I0 = m_interpTraceI0[dir][i];
                    Blas::Dgemm('N',
                                'N',
                                tnp0,
                                tnp1,
                                fnp0,
                                1.0,
                                I0->GetPtr().get(),
                                tnp0,
                                locfaces.get() + cnt,
                                fnp0,
                                0.0,
                                tmp.get() + cnt1,
                                tnp0);
                }
                break;
                case eInterpEndPtDir0:
                {
                    int nfaces = m_interpNfaces[dir][i];
                    for (int k = 0; k < fnp0; ++k)
                    {
                        Vmath::Vcopy(nfaces * fnp1,
                                     locfaces.get() + cnt + k,
                                     fnp0,
                                     tmp.get() + cnt1 + k,
                                     tnp0);
                    }
                    Array<OneD, NekDouble> I0 = m_interpEndPtI0[dir][i];
                    Blas::Dgemv('T',
                                fnp0,
                                tnp1 * m_interpNfaces[dir][i],
                                1.0,
                                tmp.get() + cnt1,
                                tnp0,
                                I0.get(),
                                1,
                                0.0,
                                tmp.get() + cnt1 + tnp0 - 1,
                                tnp0);
                }
                break;
                case eInterpDir1:
                {
                    DNekMatSharedPtr I1 = m_interpTraceI1[dir][i];
                    for (int j = 0; j < m_interpNfaces[dir][i]; ++j)
                    {
                        Blas::Dgemm('N',
                                    'T',
                                    tnp0,
                                    tnp1,
                                    fnp1,
                                    1.0,
                                    locfaces.get() + cnt + j * fnp0 * fnp1,
                                    tnp0,
                                    I1->GetPtr().get(),
                                    tnp1,
                                    0.0,
                                    tmp.get() + cnt1 + j * tnp0 * tnp1,
                                    tnp0);
                    }
                }
                break;
                case eInterpEndPtDir1:
                {
                    Array<OneD, NekDouble> I1 = m_interpEndPtI1[dir][i];
                    for (int j = 0; j < m_interpNfaces[dir][i]; ++j)
                    {
                        // copy all points
                        Vmath::Vcopy(fnp0 * fnp1,
                                     locfaces.get() + cnt + j * fnp0 * fnp1,
                                     1,
                                     tmp.get() + cnt1 + j * tnp0 * tnp1,
                                     1);

                        // interpolate end points
                        for (int k = 0; k < tnp0; ++k)
                        {
                            tmp[cnt1 + k + (j + 1) * tnp0 * tnp1 - tnp0] =
                                Blas::Ddot(fnp1,
                                           locfaces.get() + cnt +
                                               j * fnp0 * fnp1 + k,
                                           fnp0,
                                           &I1[0],
                                           1);
                        }
                    }
                }
                break;
                case eInterpBothDirs:
                {
                    DNekMatSharedPtr I0 = m_interpTraceI0[dir][i];
                    DNekMatSharedPtr I1 = m_interpTraceI1[dir][i];
                    Array<OneD, NekDouble> wsp(m_interpNfaces[dir][i] * fnp0 *
                                               tnp1 * fnp0);

                    for (int j = 0; j < m_interpNfaces[dir][i]; ++j)
                    {
                        Blas::Dgemm('N',
                                    'T',
                                    fnp0,
                                    tnp1,
                                    fnp1,
                                    1.0,
                                    locfaces.get() + cnt + j * fnp0 * fnp1,
                                    fnp0,
                                    I1->GetPtr().get(),
                                    tnp1,
                                    0.0,
                                    wsp.get() + j * fnp0 * tnp1,
                                    fnp0);
                    }
                    Blas::Dgemm('N',
                                'N',
                                tnp0,
                                tnp1 * m_interpNfaces[dir][i],
                                fnp0,
                                1.0,
                                I0->GetPtr().get(),
                                tnp0,
                                wsp.get(),
                                fnp0,
                                0.0,
                                tmp.get() + cnt1,
                                tnp0);
                }
                break;
                case eInterpEndPtDir0InterpDir1:
                {
                    DNekMatSharedPtr I1 = m_interpTraceI1[dir][i];

                    for (int j = 0; j < m_interpNfaces[dir][i]; ++j)
                    {
                        Blas::Dgemm('N',
                                    'T',
                                    fnp0,
                                    tnp1,
                                    fnp1,
                                    1.0,
                                    locfaces.get() + cnt + j * fnp0 * fnp1,
                                    fnp0,
                                    I1->GetPtr().get(),
                                    tnp1,
                                    0.0,
                                    tmp.get() + cnt1 + j * tnp0 * tnp1,
                                    tnp0);
                    }

                    Array<OneD, NekDouble> I0 = m_interpEndPtI0[dir][i];
                    Blas::Dgemv('T',
                                fnp0,
                                tnp1 * m_interpNfaces[dir][i],
                                1.0,
                                tmp.get() + cnt1,
                                tnp0,
                                I0.get(),
                                1,
                                0.0,
                                tmp.get() + cnt1 + tnp0 - 1,
                                tnp0);
                }
                break;
            }
            cnt += nfromfacepts;
            cnt1 += m_interpNfaces[dir][i] * tnp0 * tnp1;
        }
    }

    Vmath::Scatr(m_LocTraceToTraceMap[dir].num_elements(),
                 tmp.get(),
                 m_LocTraceToTraceMap[dir].get(),
                 faces.get());
}

void Nektar::MultiRegions::LocTraceToTraceMap::LocTracesFromField	(	const Array< OneD, const NekDouble > &	field,
		Array< OneD, NekDouble >	faces
	)

Gather the local traces in physical space from field using m_fieldToLocTraceMap.

Parameters

field	Solution field in physical space
faces	Resulting local traces.

Definition at line 850 of file LocTraceToTraceMap.cpp.

References Vmath::Gathr().

{
    Vmath::Gathr(m_fieldToLocTraceMap.num_elements(),
                 field,
                 m_fieldToLocTraceMap,
                 faces);
}

void Nektar::MultiRegions::LocTraceToTraceMap::Setup2D	(	const ExpList &	locExp,
		const ExpListSharedPtr &	trace,
		const Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > &	elmtToTrace,
		const std::vector< bool > &	LeftAdjacents
	)

Set up member variables for a two-dimensional problem.

Parameters

locExp	Expansion list of 2D elements
trace	Expansion list of the one-dimensional trace.
elmtToTrace	Mapping from elemental edges to trace.
leftAdjacents	Vector of bools denoting forwards-oriented traces.

Definition at line 105 of file LocTraceToTraceMap.cpp.

References Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::MultiRegions::eInterpDir0, Nektar::MultiRegions::eInterpEndPtDir0, Nektar::MultiRegions::eNoInterp, Nektar::LibUtilities::eNoPointsType, Nektar::LibUtilities::eTriangle, Nektar::MultiRegions::ExpList::GetCoeff_Offset(), Nektar::MultiRegions::ExpList::GetExp(), Nektar::LibUtilities::PointsKey::GetNumPoints(), Nektar::MultiRegions::ExpList::GetPhys_Offset(), Nektar::LibUtilities::PointsKey::GetPointsType(), Nektar::iterator, Nektar::LibUtilities::PointsManager(), sign, and Vmath::Vcopy().

{
    m_LocTraceToTraceMap = Array<OneD, Array<OneD, int> >(2);
    m_interpTrace        = Array<OneD, Array<OneD, InterpLocTraceToTrace> >(2);
    m_interpTraceI0      = Array<OneD, Array<OneD, DNekMatSharedPtr> >(2);
    m_interpEndPtI0      = Array<OneD, Array<OneD, Array<OneD, NekDouble> > >(2);
    m_interpPoints       = Array<OneD, Array<OneD, TraceInterpPoints> >(2);
    m_interpNfaces       = Array<OneD, Array<OneD, int> >(2);

    m_traceCoeffsToElmtMap   = Array<OneD, Array<OneD, int> >(2);
    m_traceCoeffsToElmtTrace = Array<OneD, Array<OneD, int> >(2);
    m_traceCoeffsToElmtSign  = Array<OneD, Array<OneD, int> >(2);

    LocalRegions::Expansion2DSharedPtr exp2d;
    const boost::shared_ptr<LocalRegions::ExpansionVector> exp =
        locExp.GetExp();

    int cnt, n, e, phys_offset;

    int nexp    = exp->size();
    m_nTracePts = trace->GetTotPoints();

    // Count number of edges and points required for maps
    int nFwdPts       = 0;
    int nBwdPts       = 0;
    int nFwdCoeffs    = 0;
    int nBwdCoeffs    = 0;
    m_nFwdLocTracePts = 0;
    m_nLocTracePts    = 0;

    for (cnt = n = 0; n < nexp; ++n)
    {
        exp2d = (*exp)[n]->as<LocalRegions::Expansion2D>();

        for (int i = 0; i < exp2d->GetNedges(); ++i, ++cnt)
        {
            int nLocPts = exp2d->GetEdgeNumPoints(i);
            m_nLocTracePts += nLocPts;

            if (LeftAdjacents[cnt])
            {
                nFwdPts += elmtToTrace[n][i]->GetTotPoints();
                nFwdCoeffs += elmtToTrace[n][i]->GetNcoeffs();
                m_nFwdLocTracePts += nLocPts;
            }
            else
            {
                nBwdPts += elmtToTrace[n][i]->GetTotPoints();
                nBwdCoeffs += elmtToTrace[n][i]->GetNcoeffs();
            }
        }
    }

    m_fieldToLocTraceMap = Array<OneD, int>(m_nLocTracePts);

    m_LocTraceToTraceMap[0] = Array<OneD, int>(nFwdPts);
    m_LocTraceToTraceMap[1] = Array<OneD, int>(nBwdPts);

    m_nTraceCoeffs[0] = nFwdCoeffs;
    m_nTraceCoeffs[1] = nBwdCoeffs;

    m_traceCoeffsToElmtMap[0]   = Array<OneD, int>(nFwdCoeffs + nBwdCoeffs);
    m_traceCoeffsToElmtMap[1]   = m_traceCoeffsToElmtMap[0] + nFwdCoeffs;
    m_traceCoeffsToElmtTrace[0] = Array<OneD, int>(nFwdCoeffs + nBwdCoeffs);
    m_traceCoeffsToElmtTrace[1] = m_traceCoeffsToElmtTrace[0] + nFwdCoeffs;
    m_traceCoeffsToElmtSign[0]  = Array<OneD, int>(nFwdCoeffs + nBwdCoeffs);
    m_traceCoeffsToElmtSign[1]  = m_traceCoeffsToElmtSign[0] + nFwdCoeffs;

    // Gather information about trace interpolations
    map<TraceInterpPoints, vector<pair<int, int> >, cmpop> TraceInterpMap;
    map<TraceInterpPoints, vector<pair<int, int> >, cmpop>::iterator it;

    vector<vector<int> > TraceOrder;
    TraceOrder.resize(nexp);
    int nedge;
    int fwdcnt = 0;
    int bwdcnt = 0;

    // Generate a map of similar traces with the same
    // interpolation requirements
    for (cnt = n = 0; n < nexp; ++n)
    {
        exp2d = (*exp)[n]->as<LocalRegions::Expansion2D>();
        nedge = exp2d->GetNedges();
        TraceOrder[n].resize(nedge);

        int coeffoffset = locExp.GetCoeff_Offset(n);
        for (e = 0; e < nedge; ++e, ++cnt)
        {
            StdRegions::StdExpansionSharedPtr edge = elmtToTrace[n][e];
            StdRegions::Orientation orient         = exp2d->GetEorient(e);

            LibUtilities::PointsKey fromPointsKey0, fromPointsKey1;
            LibUtilities::PointsKey toPointsKey0, toPointsKey1;

            // For Spencer's data structure
            int basisDir = 0;
            if (exp2d->DetShapeType() == LibUtilities::eTriangle)
            {
                basisDir = e == 0 ? 0 : 1;
            }
            else
            {
                basisDir = e % 2;
            }

            fromPointsKey0 = exp2d->GetBasis(basisDir)->GetPointsKey();
            fromPointsKey1 =
                LibUtilities::PointsKey(0, LibUtilities::eNoPointsType);
            toPointsKey0 = edge->GetBasis(0)->GetPointsKey();
            toPointsKey1 =
                LibUtilities::PointsKey(0, LibUtilities::eNoPointsType);

            // Spencer's data structure
            TraceInterpPoints fpoint(
                fromPointsKey0, fromPointsKey1, toPointsKey0, toPointsKey1);

            pair<int, int> epf(n, e);
            TraceInterpMap[fpoint].push_back(epf);
            TraceOrder[n][e] = cnt;

            // Setup for coefficient mapping from trace normal flux
            // to elements
            Array<OneD, unsigned int> map;
            Array<OneD, int> sign;
            // Not sure about the call GetBasisNumModes passing (0)!
            exp2d->GetEdgeToElementMap(
                e, orient, map, sign, edge->GetBasisNumModes(0));

            int order_f = edge->GetNcoeffs();
            int foffset = trace->GetCoeff_Offset(edge->GetElmtId());

            double fac = (*exp)[n]->EdgeNormalNegated(e) ? -1.0 : 1.0;

            LocalRegions::Expansion1DSharedPtr locExp1d =
                elmtToTrace[n][e]->as<LocalRegions::Expansion1D>();

            if (exp2d->GetEdgeExp(e)->GetRightAdjacentElementExp())
            {
                if (locExp1d->GetRightAdjacentElementExp()
                        ->GetGeom()
                        ->GetGlobalID() == exp2d->GetGeom()->GetGlobalID())
                {
                    fac = -1.0;
                }
            }

            if (LeftAdjacents[cnt])
            {
                for (int i = 0; i < order_f; ++i)
                {
                    m_traceCoeffsToElmtMap[0][fwdcnt]    = coeffoffset + map[i];
                    m_traceCoeffsToElmtTrace[0][fwdcnt]  = foffset + i;
                    m_traceCoeffsToElmtSign[0][fwdcnt++] = fac * sign[i];
                }
            }
            else
            {
                for (int i = 0; i < order_f; ++i)
                {
                    m_traceCoeffsToElmtMap[1][bwdcnt]    = coeffoffset + map[i];
                    m_traceCoeffsToElmtTrace[1][bwdcnt]  = foffset + i;
                    m_traceCoeffsToElmtSign[1][bwdcnt++] = fac * sign[i];
                }
            }
        }
    }

    int nInterpType = TraceInterpMap.size();

    for (int i = 0; i < 2; ++i)
    {
        m_interpTrace[i]   = Array<OneD, InterpLocTraceToTrace>(nInterpType);
        m_interpTraceI0[i] = Array<OneD, DNekMatSharedPtr>(nInterpType);
        m_interpEndPtI0[i] = Array<OneD, Array<OneD, NekDouble> >(nInterpType);
        m_interpPoints[i]  = Array<OneD, TraceInterpPoints>(nInterpType);
        m_interpNfaces[i]  = Array<OneD, int>(nInterpType, 0);
    }

    int nedgepts, nedgepts1;
    int cnt1    = 0;
    int cnt2    = 0;
    int cntFwd  = 0;
    int cntBwd  = 0;
    int cntFwd1 = 0;
    int cntBwd1 = 0;
    int set;
    Array<OneD, int> edgeids;
    Array<OneD, int> locTraceToTraceMap;
    cnt = 0;

    for (it = TraceInterpMap.begin(); it != TraceInterpMap.end(); ++it, ++cnt1)
    {
        LibUtilities::PointsKey fromPointsKey0 = it->first.get<0>();
        LibUtilities::PointsKey toPointsKey0   = it->first.get<2>();

        bool fwdSet = false;
        bool bwdSet = false;

        for (int f = 0; f < it->second.size(); ++f, ++cnt2)
        {
            n = it->second[f].first;
            e = it->second[f].second;

            StdRegions::StdExpansionSharedPtr edge = elmtToTrace[n][e];

            exp2d       = (*exp)[n]->as<LocalRegions::Expansion2D>();
            phys_offset = locExp.GetPhys_Offset(n);

            // Mapping of new edge order to one that loops over elmts
            // then set up mapping of faces in standard cartesian order
            exp2d->GetEdgePhysMap(e, edgeids);

            nedgepts  = exp2d->GetEdgeNumPoints(e);
            nedgepts1 = edge->GetTotPoints();

            StdRegions::Orientation orient = exp2d->GetCartesianEorient(e);

            // Account for eBackwards orientation
            exp2d->ReOrientEdgePhysMap(elmtToTrace[n][e]->GetNverts(),
                                       orient,
                                       toPointsKey0.GetNumPoints(),
                                       locTraceToTraceMap);

            int offset = trace->GetPhys_Offset(elmtToTrace[n][e]->GetElmtId());

            if (LeftAdjacents[TraceOrder[n][e]])
            {
                for (int i = 0; i < nedgepts; ++i)
                {
                    m_fieldToLocTraceMap[cntFwd + i] = phys_offset + edgeids[i];
                }

                for (int i = 0; i < nedgepts1; ++i)
                {
                    m_LocTraceToTraceMap[0][cntFwd1 + i] =
                        offset + locTraceToTraceMap[i];
                }

                cntFwd += nedgepts;
                cntFwd1 += nedgepts1;
                set = 0;
            }
            else
            {
                for (int i = 0; i < nedgepts; ++i)
                {
                    m_fieldToLocTraceMap[m_nFwdLocTracePts + cntBwd + i] =
                        phys_offset + edgeids[i];
                }

                for (int i = 0; i < nedgepts1; ++i)
                {
                    m_LocTraceToTraceMap[1][cntBwd1 + i] =
                        offset + locTraceToTraceMap[i];
                }

                cntBwd += nedgepts;
                cntBwd1 += nedgepts1;
                set = 1;
            }

            m_interpNfaces[set][cnt1] += 1;

            if ((fwdSet == false && set == 0) || (bwdSet == false && set == 1))
            {
                m_interpPoints[set][cnt1] = it->first;

                if (fromPointsKey0 == toPointsKey0)
                {
                    m_interpTrace[set][cnt1] = eNoInterp;
                }
                else
                {
                    m_interpTrace[set][cnt1] = eInterpDir0;
                    m_interpTraceI0[set][cnt1] =
                        LibUtilities::PointsManager()[fromPointsKey0]->GetI(
                            toPointsKey0);

                    // Check to see if we can
                    // just interpolate endpoint
                    if ((fromPointsKey0.GetPointsType() ==
                         LibUtilities::eGaussRadauMAlpha1Beta0) &&
                        (toPointsKey0.GetPointsType() ==
                         LibUtilities::eGaussLobattoLegendre))
                    {
                        if (fromPointsKey0.GetNumPoints() + 1 ==
                            toPointsKey0.GetNumPoints())
                        {
                            m_interpTrace[set][cnt1] = eInterpEndPtDir0;

                            int fnp0 = fromPointsKey0.GetNumPoints();

                            int tnp0 = toPointsKey0.GetNumPoints();

                            m_interpEndPtI0[set][cnt1] =
                                Array<OneD, NekDouble>(fnp0);

                            Vmath::Vcopy(
                                fnp0,
                                m_interpTraceI0[set][cnt1]->GetPtr().get() +
                                    tnp0 - 1,
                                tnp0,
                                &m_interpEndPtI0[set][cnt1][0],
                                1);
                        }
                    }
                }

                if (set == 0)
                {
                    fwdSet = true;
                }
                else
                {
                    bwdSet = true;
                }
            }
        }
    }
}

void Nektar::MultiRegions::LocTraceToTraceMap::Setup3D	(	const ExpList &	locExp,
		const ExpListSharedPtr &	trace,
		const Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > &	elmtToTrace,
		const std::vector< bool > &	LeftAdjacents
	)

Set up member variables for a three-dimensional problem.

Parameters

locExp	Expansion list of 3D elements
trace	Expansion list of the two-dimensional trace.
elmtToTrace	Mapping from elemental faces to trace.
leftAdjacents	Vector of bools denoting forwards-oriented traces.

Definition at line 440 of file LocTraceToTraceMap.cpp.

References Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::MultiRegions::eInterpBothDirs, Nektar::MultiRegions::eInterpDir0, Nektar::MultiRegions::eInterpDir1, Nektar::MultiRegions::eInterpEndPtDir0, Nektar::MultiRegions::eInterpEndPtDir0InterpDir1, Nektar::MultiRegions::eInterpEndPtDir1, Nektar::MultiRegions::eNoInterp, Nektar::MultiRegions::ExpList::GetCoeff_Offset(), Nektar::MultiRegions::ExpList::GetExp(), Nektar::LibUtilities::PointsKey::GetNumPoints(), Nektar::MultiRegions::ExpList::GetPhys_Offset(), Nektar::LibUtilities::PointsKey::GetPointsType(), Nektar::iterator, Nektar::LibUtilities::PointsManager(), sign, and Vmath::Vcopy().

{
    m_LocTraceToTraceMap = Array<OneD, Array<OneD, int> >(2);

    m_interpTrace   = Array<OneD, Array<OneD, InterpLocTraceToTrace> >(2);
    m_interpTraceI0 = Array<OneD, Array<OneD, DNekMatSharedPtr> >(2);
    m_interpTraceI1 = Array<OneD, Array<OneD, DNekMatSharedPtr> >(2);
    m_interpEndPtI0 = Array<OneD, Array<OneD, Array<OneD, NekDouble> > >(2);
    m_interpEndPtI1 = Array<OneD, Array<OneD, Array<OneD, NekDouble> > >(2);
    m_interpPoints  = Array<OneD, Array<OneD, TraceInterpPoints> >(2);
    m_interpNfaces  = Array<OneD, Array<OneD, int> >(2);

    m_traceCoeffsToElmtMap   = Array<OneD, Array<OneD, int> >(2);
    m_traceCoeffsToElmtTrace = Array<OneD, Array<OneD, int> >(2);
    m_traceCoeffsToElmtSign  = Array<OneD, Array<OneD, int> >(2);

    LocalRegions::Expansion3DSharedPtr exp3d;
    const boost::shared_ptr<LocalRegions::ExpansionVector> exp =
        locExp.GetExp();

    int cnt, n, e, phys_offset;

    int nexp    = exp->size();
    m_nTracePts = trace->GetTotPoints();

    // Count number of faces and points required for maps
    int nFwdPts       = 0;
    int nBwdPts       = 0;
    int nFwdCoeffs    = 0;
    int nBwdCoeffs    = 0;
    m_nFwdLocTracePts = 0;
    m_nLocTracePts    = 0;

    for (cnt = n = 0; n < nexp; ++n)
    {
        exp3d = (*exp)[n]->as<LocalRegions::Expansion3D>();

        for (int i = 0; i < exp3d->GetNfaces(); ++i, ++cnt)
        {
            int nLocPts = exp3d->GetFaceNumPoints(i);
            m_nLocTracePts += nLocPts;

            if (LeftAdjacents[cnt])
            {
                nFwdPts += elmtToTrace[n][i]->GetTotPoints();
                nFwdCoeffs += elmtToTrace[n][i]->GetNcoeffs();
                m_nFwdLocTracePts += nLocPts;
            }
            else
            {
                nBwdPts += elmtToTrace[n][i]->GetTotPoints();
                nBwdCoeffs += elmtToTrace[n][i]->GetNcoeffs();
            }
        }
    }

    m_fieldToLocTraceMap = Array<OneD, int>(m_nLocTracePts);

    m_LocTraceToTraceMap[0] = Array<OneD, int>(nFwdPts);
    m_LocTraceToTraceMap[1] = Array<OneD, int>(nBwdPts);

    m_nTraceCoeffs[0] = nFwdCoeffs;
    m_nTraceCoeffs[1] = nBwdCoeffs;

    m_traceCoeffsToElmtMap[0]   = Array<OneD, int>(nFwdCoeffs + nBwdCoeffs);
    m_traceCoeffsToElmtMap[1]   = m_traceCoeffsToElmtMap[0] + nFwdCoeffs;
    m_traceCoeffsToElmtTrace[0] = Array<OneD, int>(nFwdCoeffs + nBwdCoeffs);
    m_traceCoeffsToElmtTrace[1] = m_traceCoeffsToElmtTrace[0] + nFwdCoeffs;
    m_traceCoeffsToElmtSign[0]  = Array<OneD, int>(nFwdCoeffs + nBwdCoeffs);
    m_traceCoeffsToElmtSign[1]  = m_traceCoeffsToElmtSign[0] + nFwdCoeffs;

    // Gather information about trace interpolations
    map<TraceInterpPoints, vector<pair<int, int> >, cmpop> TraceInterpMap;
    map<TraceInterpPoints, vector<pair<int, int> >, cmpop>::iterator it;

    vector<vector<int> > TraceOrder;
    TraceOrder.resize(nexp);
    int nface;
    int fwdcnt = 0;
    int bwdcnt = 0;

    // Generate a map of similar traces with the same
    // interpolation or projection requirements
    for (cnt = n = 0; n < nexp; ++n)
    {
        exp3d = (*exp)[n]->as<LocalRegions::Expansion3D>();
        nface = exp3d->GetNfaces();
        TraceOrder[n].resize(nface);

        int coeffoffset = locExp.GetCoeff_Offset(n);
        for (e = 0; e < nface; ++e, ++cnt)
        {
            StdRegions::StdExpansionSharedPtr face = elmtToTrace[n][e];
            StdRegions::Orientation orient         = exp3d->GetForient(e);

            LibUtilities::PointsKey fromPointsKey0, fromPointsKey1;
            LibUtilities::PointsKey toPointsKey0, toPointsKey1;

            // 3D specific
            int dir0 = exp3d->GetGeom3D()->GetDir(e, 0);
            int dir1 = exp3d->GetGeom3D()->GetDir(e, 1);

            fromPointsKey0 = exp3d->GetBasis(dir0)->GetPointsKey();
            fromPointsKey1 = exp3d->GetBasis(dir1)->GetPointsKey();

            if (orient < StdRegions::eDir1FwdDir2_Dir2FwdDir1)
            {
                toPointsKey0 = face->GetBasis(0)->GetPointsKey();
                toPointsKey1 = face->GetBasis(1)->GetPointsKey();
            }
            else // transpose points key evaluation
            {
                toPointsKey0 = face->GetBasis(1)->GetPointsKey();
                toPointsKey1 = face->GetBasis(0)->GetPointsKey();
            }

            TraceInterpPoints fpoint(
                fromPointsKey0, fromPointsKey1, toPointsKey0, toPointsKey1);

            pair<int, int> epf(n, e);
            TraceInterpMap[fpoint].push_back(epf);
            TraceOrder[n][e] = cnt;

            // Setup for coefficient mapping from trace normal
            // flux to elements
            Array<OneD, unsigned int> map;
            Array<OneD, int> sign;
            exp3d->GetFaceToElementMap(e,
                                       orient,
                                       map,
                                       sign,
                                       face->GetBasisNumModes(0),
                                       face->GetBasisNumModes(1));

            int order_f = face->GetNcoeffs();
            int foffset = trace->GetCoeff_Offset(face->GetElmtId());

            int fac = (*exp)[n]->FaceNormalNegated(e) ? -1.0 : 1.0;

            if (exp3d->GetFaceExp(e)->GetRightAdjacentElementExp())
            {
                if (exp3d->GetFaceExp(e)
                        ->GetRightAdjacentElementExp()
                        ->GetGeom3D()
                        ->GetGlobalID() == exp3d->GetGeom3D()->GetGlobalID())
                {
                    fac = -1.0;
                }
            }

            if (LeftAdjacents[cnt])
            {
                for (int i = 0; i < order_f; ++i)
                {
                    m_traceCoeffsToElmtMap[0][fwdcnt]    = coeffoffset + map[i];
                    m_traceCoeffsToElmtTrace[0][fwdcnt]  = foffset + i;
                    m_traceCoeffsToElmtSign[0][fwdcnt++] = fac * sign[i];
                }
            }
            else
            {
                for (int i = 0; i < order_f; ++i)
                {
                    m_traceCoeffsToElmtMap[1][bwdcnt]    = coeffoffset + map[i];
                    m_traceCoeffsToElmtTrace[1][bwdcnt]  = foffset + i;
                    m_traceCoeffsToElmtSign[1][bwdcnt++] = fac * sign[i];
                }
            }
        }
    }

    int nInterpType = TraceInterpMap.size();
    for (int i = 0; i < 2; ++i)
    {
        m_interpTrace[i]   = Array<OneD, InterpLocTraceToTrace>(nInterpType);
        m_interpTraceI0[i] = Array<OneD, DNekMatSharedPtr>(nInterpType);
        m_interpTraceI1[i] = Array<OneD, DNekMatSharedPtr>(nInterpType);
        m_interpEndPtI0[i] = Array<OneD, Array<OneD, NekDouble> >(nInterpType);
        m_interpEndPtI1[i] = Array<OneD, Array<OneD, NekDouble> >(nInterpType);
        m_interpPoints[i]  = Array<OneD, TraceInterpPoints>(nInterpType);
        m_interpNfaces[i]  = Array<OneD, int>(nInterpType, 0);
    }

    int nfacepts, nfacepts1;
    int cnt1    = 0;
    int cnt2    = 0;
    int cntFwd  = 0;
    int cntBwd  = 0;
    int cntFwd1 = 0;
    int cntBwd1 = 0;
    int set;
    Array<OneD, int> faceids;
    Array<OneD, int> locTraceToTraceMap;
    cnt = 0;
    for (it = TraceInterpMap.begin(); it != TraceInterpMap.end(); ++it, ++cnt1)
    {
        LibUtilities::PointsKey fromPointsKey0 = it->first.get<0>();
        LibUtilities::PointsKey fromPointsKey1 = it->first.get<1>();
        LibUtilities::PointsKey toPointsKey0   = it->first.get<2>();
        LibUtilities::PointsKey toPointsKey1   = it->first.get<3>();

        bool fwdSet = false;
        bool bwdSet = false;

        for (int f = 0; f < it->second.size(); ++f, ++cnt2)
        {
            n = it->second[f].first;
            e = it->second[f].second;

            StdRegions::StdExpansionSharedPtr face = elmtToTrace[n][e];

            exp3d       = (*exp)[n]->as<LocalRegions::Expansion3D>();
            phys_offset = locExp.GetPhys_Offset(n);

            // mapping of new face order to one that loops over elmts
            // then faces set up mapping of faces in standard cartesian
            // order
            exp3d->GetFacePhysMap(e, faceids);
            nfacepts  = exp3d->GetFaceNumPoints(e);
            nfacepts1 = face->GetTotPoints();

            StdRegions::Orientation orient = exp3d->GetForient(e);

            exp3d->ReOrientFacePhysMap(elmtToTrace[n][e]->GetNverts(),
                                       orient,
                                       toPointsKey0.GetNumPoints(),
                                       toPointsKey1.GetNumPoints(),
                                       locTraceToTraceMap);

            int offset = trace->GetPhys_Offset(elmtToTrace[n][e]->GetElmtId());

            if (LeftAdjacents[TraceOrder[n][e]])
            {
                for (int i = 0; i < nfacepts; ++i)
                {
                    m_fieldToLocTraceMap[cntFwd + i] = phys_offset + faceids[i];
                }

                for (int i = 0; i < nfacepts1; ++i)
                {
                    m_LocTraceToTraceMap[0][cntFwd1 + i] =
                        offset + locTraceToTraceMap[i];
                }

                cntFwd += nfacepts;
                cntFwd1 += nfacepts1;
                set = 0;
            }
            else
            {
                for (int i = 0; i < nfacepts; ++i)
                {
                    m_fieldToLocTraceMap[m_nFwdLocTracePts + cntBwd + i] =
                        phys_offset + faceids[i];
                }

                for (int i = 0; i < nfacepts1; ++i)
                {
                    m_LocTraceToTraceMap[1][cntBwd1 + i] =
                        offset + locTraceToTraceMap[i];
                }

                cntBwd += nfacepts;
                cntBwd1 += nfacepts1;
                set = 1;
            }

            m_interpNfaces[set][cnt1] += 1;

            if (((fwdSet == false) && (set == 0)) ||
                ((bwdSet == false) && (set == 1)))
            {
                m_interpPoints[set][cnt1] = it->first;

                if (fromPointsKey0 == toPointsKey0)
                {
                    if (fromPointsKey1 == toPointsKey1)
                    {
                        m_interpTrace[set][cnt1] = eNoInterp;
                    }
                    else
                    {
                        m_interpTrace[set][cnt1] = eInterpDir1;
                        m_interpTraceI1[set][cnt1] =
                            LibUtilities::PointsManager()[fromPointsKey1]->GetI(
                                toPointsKey1);

                        // Check to see if we can just
                        // interpolate endpoint
                        if ((fromPointsKey1.GetPointsType() ==
                             LibUtilities::eGaussRadauMAlpha1Beta0) &&
                            (toPointsKey1.GetPointsType() ==
                             LibUtilities::eGaussLobattoLegendre))
                        {
                            if (fromPointsKey1.GetNumPoints() + 1 ==
                                toPointsKey1.GetNumPoints())
                            {
                                m_interpTrace[set][cnt1] = eInterpEndPtDir1;
                                int fnp1                 = fromPointsKey1.GetNumPoints();
                                int tnp1 = toPointsKey1.GetNumPoints();
                                m_interpEndPtI1[set][cnt1] =
                                    Array<OneD, NekDouble>(fnp1);
                                Vmath::Vcopy(
                                    fnp1,
                                    m_interpTraceI1[set][cnt1]->GetPtr().get() +
                                        tnp1 - 1,
                                    tnp1,
                                    &m_interpEndPtI1[set][cnt1][0],
                                    1);
                            }
                        }
                    }
                }
                else
                {
                    if (fromPointsKey1 == toPointsKey1)
                    {
                        m_interpTrace[set][cnt1] = eInterpDir0;
                        m_interpTraceI0[set][cnt1] =
                            LibUtilities::PointsManager()[fromPointsKey0]->GetI(
                                toPointsKey0);

                        // Check to see if we can just
                        // interpolate endpoint
                        if ((fromPointsKey0.GetPointsType() ==
                             LibUtilities::eGaussRadauMAlpha1Beta0) &&
                            (toPointsKey0.GetPointsType() ==
                             LibUtilities::eGaussLobattoLegendre))
                        {
                            if (fromPointsKey0.GetNumPoints() + 1 ==
                                toPointsKey0.GetNumPoints())
                            {
                                m_interpTrace[set][cnt1] = eInterpEndPtDir0;
                                int fnp0                 = fromPointsKey0.GetNumPoints();
                                int tnp0 = toPointsKey0.GetNumPoints();
                                m_interpEndPtI0[set][cnt1] =
                                    Array<OneD, NekDouble>(fnp0);
                                Vmath::Vcopy(
                                    fnp0,
                                    m_interpTraceI0[set][cnt1]->GetPtr().get() +
                                        tnp0 - 1,
                                    tnp0,
                                    &m_interpEndPtI0[set][cnt1][0],
                                    1);
                            }
                        }
                    }
                    else
                    {
                        m_interpTrace[set][cnt1] = eInterpBothDirs;
                        m_interpTraceI0[set][cnt1] =
                            LibUtilities::PointsManager()[fromPointsKey0]->GetI(
                                toPointsKey0);
                        m_interpTraceI1[set][cnt1] =
                            LibUtilities::PointsManager()[fromPointsKey1]->GetI(
                                toPointsKey1);

                        // check to see if we can just
                        // interpolate endpoint
                        if ((fromPointsKey0.GetPointsType() ==
                             LibUtilities::eGaussRadauMAlpha1Beta0) &&
                            (toPointsKey0.GetPointsType() ==
                             LibUtilities::eGaussLobattoLegendre))
                        {
                            if (fromPointsKey0.GetNumPoints() + 1 ==
                                toPointsKey0.GetNumPoints())
                            {
                                m_interpTrace[set][cnt1] =
                                    eInterpEndPtDir0InterpDir1;
                                int fnp0 = fromPointsKey0.GetNumPoints();
                                int tnp0 = toPointsKey0.GetNumPoints();
                                m_interpEndPtI0[set][cnt1] =
                                    Array<OneD, NekDouble>(fnp0);
                                Vmath::Vcopy(
                                    fnp0,
                                    m_interpTraceI0[set][cnt1]->GetPtr().get() +
                                        tnp0 - 1,
                                    tnp0,
                                    &m_interpEndPtI0[set][cnt1][0],
                                    1);
                            }
                        }
                    }
                }

                if (set == 0)
                {
                    fwdSet = true;
                }
                else
                {
                    bwdSet = true;
                }
            }
        }
    }
}

Member Data Documentation

Array<OneD, int> Nektar::MultiRegions::LocTraceToTraceMap::m_fieldToLocTraceMap

private

A mapping from the local trace points, arranged as all forwards traces followed by backwards traces, to elemental storage.

Definition at line 235 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::MultiRegions::LocTraceToTraceMap::m_interpEndPtI0

private

Mapping to hold first coordinate direction endpoint interpolation, which can be more optimal if using Gauss-Radau distribution for triangles.

Definition at line 253 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::MultiRegions::LocTraceToTraceMap::m_interpEndPtI1

private

Mapping to hold second coordinate direction endpoint interpolation, which can be more optimal if using Gauss-Radau distribution for triangles.

Definition at line 257 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, int> > Nektar::MultiRegions::LocTraceToTraceMap::m_interpNfaces

private

Number of edges/faces on a 2D/3D element that require interpolation.

Definition at line 259 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, TraceInterpPoints> > Nektar::MultiRegions::LocTraceToTraceMap::m_interpPoints

private

Interpolation points key distributions for each of the local to global mappings.

Definition at line 250 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, InterpLocTraceToTrace> > Nektar::MultiRegions::LocTraceToTraceMap::m_interpTrace

private

A mapping holding the type of interpolation needed for each local trace. Dimension 0 holds forward traces, dimension 1 backward.

Definition at line 241 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, DNekMatSharedPtr> > Nektar::MultiRegions::LocTraceToTraceMap::m_interpTraceI0

private

Interpolation matrices for either 2D edges or first coordinate of 3D face.

Definition at line 244 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, DNekMatSharedPtr> > Nektar::MultiRegions::LocTraceToTraceMap::m_interpTraceI1

private

Interpolation matrices for the second coordinate of 3D face, not used in 2D.

Definition at line 247 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, int> > Nektar::MultiRegions::LocTraceToTraceMap::m_LocTraceToTraceMap

private

A mapping from local trace points to the global trace. Dimension 0 holds forward traces, dimension 1 backward.

Definition at line 238 of file LocTraceToTraceMap.h.

int Nektar::MultiRegions::LocTraceToTraceMap::m_nFwdLocTracePts

private

The number of forward trace points. A local trace element is `forward' if it is the side selected for the global trace.

Definition at line 228 of file LocTraceToTraceMap.h.

Referenced by GetNFwdLocTracePts().

int Nektar::MultiRegions::LocTraceToTraceMap::m_nLocTracePts

private

The number of local trace points.

Definition at line 230 of file LocTraceToTraceMap.h.

Referenced by GetNLocTracePts().

int Nektar::MultiRegions::LocTraceToTraceMap::m_nTraceCoeffs[2]

private

Number of forwards/backwards trace coefficients.

Definition at line 261 of file LocTraceToTraceMap.h.

int Nektar::MultiRegions::LocTraceToTraceMap::m_nTracePts

private

The number of global trace points.

Definition at line 232 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, int> > Nektar::MultiRegions::LocTraceToTraceMap::m_traceCoeffsToElmtMap

private

Mapping from forwards/backwards trace coefficients to elemental coefficient storage.

Definition at line 264 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, int> > Nektar::MultiRegions::LocTraceToTraceMap::m_traceCoeffsToElmtSign

private

Sign array for mapping from forwards/backwards trace coefficients to local trace storage.

Definition at line 270 of file LocTraceToTraceMap.h.

Array<OneD, Array<OneD, int> > Nektar::MultiRegions::LocTraceToTraceMap::m_traceCoeffsToElmtTrace

private

Mapping from forwards/backwards trace coefficients to the position of the trace element in global storage.

Definition at line 267 of file LocTraceToTraceMap.h.