#include <AssemblyMapDG.h>

Inheritance diagram for Nektar::MultiRegions::AssemblyMapDG:

Public Member Functions
	AssemblyMapDG ()
	Default constructor.

	AssemblyMapDG (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &graph1D, const ExpListSharedPtr &trace, const ExpList &locExp, const Array< OneD, const MultiRegions::ExpListSharedPtr > &bndConstraint, const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > &bndCond, const PeriodicMap &periodicTrace, const std::string variable="DefaultVar")
	Constructor for trace map for one-dimensional expansion.

	~AssemblyMapDG () override
	Destructor.

int	GetNumDirichletBndPhys ()
	Return the number of boundary segments on which Dirichlet boundary conditions are imposed.

Array< OneD, LocalRegions::ExpansionSharedPtr > &	GetElmtToTrace (const int i)

Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > &	GetElmtToTrace ()

AssemblyCommDGSharedPtr	GetAssemblyCommDG ()

Public Member Functions inherited from Nektar::MultiRegions::AssemblyMap
	AssemblyMap ()
	Default constructor.

	AssemblyMap (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &comm, const std::string variable="DefaultVar")
	Constructor with a communicator.

	AssemblyMap (AssemblyMap *oldLevelMap, const BottomUpSubStructuredGraphSharedPtr &multiLevelGraph)
	Constructor for next level in multi-level static condensation.

virtual	~AssemblyMap ()
	Destructor.

LibUtilities::CommSharedPtr	GetComm ()
	Retrieves the communicator.

std::string	GetVariable ()
	Retrieves the variable string.

size_t	GetHash () const
	Retrieves the hash of this map.

int	GetLocalToGlobalMap (const int i) const

int	GetGlobalToUniversalMap (const int i) const

int	GetGlobalToUniversalMapUnique (const int i) const

const Array< OneD, const int > &	GetLocalToGlobalMap ()

const Array< OneD, const int > &	GetGlobalToUniversalMap ()

const Array< OneD, const int > &	GetGlobalToUniversalMapUnique ()

NekDouble	GetLocalToGlobalSign (const int i) const

const Array< OneD, NekDouble > &	GetLocalToGlobalSign () const

void	LocalToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, bool useComm=true) const

void	LocalToGlobal (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global, bool useComm=true) const

void	GlobalToLocal (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const

void	GlobalToLocal (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc) const

void	Assemble (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const

void	Assemble (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) const

void	UniversalAssemble (Array< OneD, NekDouble > &pGlobal) const

void	UniversalAssemble (NekVector< NekDouble > &pGlobal) const

void	UniversalAssemble (Array< OneD, NekDouble > &pGlobal, int offset) const

void	UniversalAbsMaxBnd (Array< OneD, NekDouble > &bndvals)

int	GetLocalToGlobalBndMap (const int i) const
	Retrieve the global index of a given local boundary mode.

const Array< OneD, const int > &	GetLocalToGlobalBndMap ()
	Retrieve the global indices of the local boundary modes.

const Array< OneD, const int > &	GetGlobalToUniversalBndMap ()

const Array< OneD, const int > &	GetGlobalToUniversalBndMapUnique ()

bool	GetSignChange ()
	Returns true if using a modal expansion requiring a change of sign of some modes.

NekDouble	GetLocalToGlobalBndSign (const int i) const
	Retrieve the sign change of a given local boundary mode.

Array< OneD, const NekDouble >	GetLocalToGlobalBndSign () const
	Retrieve the sign change for all local boundary modes.

const Array< OneD, const int > &	GetBndCondCoeffsToLocalCoeffsMap ()
	Retrieves the local indices corresponding to the boundary expansion modes.

const Array< OneD, NekDouble > &	GetBndCondCoeffsToLocalCoeffsSign ()
	Returns the modal sign associated with a given boundary expansion mode.

const Array< OneD, const int > &	GetBndCondCoeffsToLocalTraceMap ()
	Retrieves the local indices corresponding to the boundary expansion modes to global trace.

int	GetBndCondIDToGlobalTraceID (const int i)
	Returns the global index of the boundary trace giving the index on the boundary expansion.

const Array< OneD, const int > &	GetBndCondIDToGlobalTraceID ()

int	GetPerBndCondIDToGlobalTraceID (const int i)
	Returns the global index of the rotational periodic boundary trace giving the index on the rotational periodic boundary condition.

const Array< OneD, const int > &	GetPerBndCondIDToGlobalTraceID ()

int	GetNumGlobalDirBndCoeffs () const
	Returns the number of global Dirichlet boundary coefficients.

int	GetNumLocalDirBndCoeffs () const
	Returns the number of local Dirichlet boundary coefficients.

int	GetNumGlobalBndCoeffs () const
	Returns the total number of global boundary coefficients.

int	GetNumLocalBndCoeffs () const
	Returns the total number of local boundary coefficients.

int	GetNumLocalCoeffs () const
	Returns the total number of local coefficients.

int	GetNumGlobalCoeffs () const
	Returns the total number of global coefficients.

bool	GetSingularSystem () const
	Retrieves if the system is singular (true) or not (false)

void	GlobalToLocalBnd (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc, int offset) const

void	GlobalToLocalBnd (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc) const

void	GlobalToLocalBnd (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc, int offset) const

void	GlobalToLocalBnd (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const

void	LocalBndToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, int offset, bool UseComm=true) const

void	LocalBndToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, bool UseComm=true) const

void	LocalToLocalBnd (const Array< OneD, const NekDouble > &local, Array< OneD, NekDouble > &locbnd) const

void	LocalToLocalInt (const Array< OneD, const NekDouble > &local, Array< OneD, NekDouble > &locint) const

void	LocalBndToLocal (const Array< OneD, const NekDouble > &locbnd, Array< OneD, NekDouble > &local) const

void	LocalIntToLocal (const Array< OneD, const NekDouble > &locbnd, Array< OneD, NekDouble > &local) const

void	AssembleBnd (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global, int offset) const

void	AssembleBnd (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) const

void	AssembleBnd (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, int offset) const

void	AssembleBnd (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const

void	UniversalAssembleBnd (Array< OneD, NekDouble > &pGlobal) const

void	UniversalAssembleBnd (NekVector< NekDouble > &pGlobal) const

void	UniversalAssembleBnd (Array< OneD, NekDouble > &pGlobal, int offset) const

int	GetFullSystemBandWidth () const

int	GetNumNonDirVertexModes () const

int	GetNumNonDirEdgeModes () const

int	GetNumNonDirFaceModes () const

int	GetNumDirEdges () const

int	GetNumDirFaces () const

int	GetNumNonDirEdges () const

int	GetNumNonDirFaces () const

void	PrintStats (std::ostream &out, std::string variable, bool printHeader=true) const

const Array< OneD, const int > &	GetExtraDirEdges ()

std::shared_ptr< AssemblyMap >	LinearSpaceMap (const ExpList &locexp, GlobalSysSolnType solnType)

int	GetBndSystemBandWidth () const
	Returns the bandwidth of the boundary system.

int	GetStaticCondLevel () const
	Returns the level of static condensation for this map.

int	GetNumPatches () const
	Returns the number of patches in this static condensation level.

const Array< OneD, const unsigned int > &	GetNumLocalBndCoeffsPerPatch ()
	Returns the number of local boundary coefficients in each patch.

const Array< OneD, const unsigned int > &	GetNumLocalIntCoeffsPerPatch ()
	Returns the number of local interior coefficients in each patch.

const AssemblyMapSharedPtr	GetNextLevelLocalToGlobalMap () const
	Returns the local to global mapping for the next level in the multi-level static condensation.

void	SetNextLevelLocalToGlobalMap (AssemblyMapSharedPtr pNextLevelLocalToGlobalMap)

const PatchMapSharedPtr &	GetPatchMapFromPrevLevel (void) const
	Returns the patch map from the previous level of the multi-level static condensation.

bool	AtLastLevel () const
	Returns true if this is the last level in the multi-level static condensation.

GlobalSysSolnType	GetGlobalSysSolnType () const
	Returns the method of solving global systems.

std::string	GetPreconType () const

bool	IsAbsoluteTolerance () const

int	GetSuccessiveRHS () const

std::string	GetLinSysIterSolver () const

int	GetLowestStaticCondLevel () const

void	PatchLocalToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const

void	PatchGlobalToLocal (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const

void	PatchAssemble (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const

Static Public Member Functions
static void	RealignTraceElement (Array< OneD, int > &toAlign, StdRegions::Orientation orient, int nquad1, int nquad2=0)

Protected Member Functions
void	SetUpUniversalDGMap (const ExpList &locExp)

int	v_GetLocalToGlobalMap (const int i) const override

int	v_GetGlobalToUniversalMap (const int i) const override

int	v_GetGlobalToUniversalMapUnique (const int i) const override

const Array< OneD, const int > &	v_GetLocalToGlobalMap () override

const Array< OneD, const int > &	v_GetGlobalToUniversalMap () override

const Array< OneD, const int > &	v_GetGlobalToUniversalMapUnique () override

NekDouble	v_GetLocalToGlobalSign (const int i) const override

const Array< OneD, NekDouble > &	v_GetLocalToGlobalSign () const override

void	v_LocalToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, bool useComm=false) const override

void	v_GlobalToLocal (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const override

void	v_GlobalToLocal (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc) const override

void	v_Assemble (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const override

void	v_Assemble (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) const override

void	v_UniversalAssemble (Array< OneD, NekDouble > &pGlobal) const override

void	v_UniversalAssemble (Array< OneD, NekDouble > &pGlobal, int offset) const override

int	v_GetFullSystemBandWidth () const override

Protected Member Functions inherited from Nektar::MultiRegions::AssemblyMap
void	CalculateBndSystemBandWidth ()
	Calculates the bandwidth of the boundary system.

void	GlobalToLocalBndWithoutSign (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc)

virtual int	v_GetNumNonDirVertexModes () const

virtual int	v_GetNumNonDirEdgeModes () const

virtual int	v_GetNumNonDirFaceModes () const

virtual int	v_GetNumDirEdges () const

virtual int	v_GetNumDirFaces () const

virtual int	v_GetNumNonDirEdges () const

virtual int	v_GetNumNonDirFaces () const

virtual const Array< OneD, const int > &	v_GetExtraDirEdges ()

virtual std::shared_ptr< AssemblyMap >	v_LinearSpaceMap (const ExpList &locexp, GlobalSysSolnType solnType)
	Generate a linear space mapping from existing mapping.

Protected Attributes
int	m_numDirichletBndPhys
	Number of physical dirichlet boundary values in trace.

AssemblyCommDGSharedPtr	m_assemblyComm

Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > >	m_elmtToTrace
	list of edge expansions for a given element

Protected Attributes inherited from Nektar::MultiRegions::AssemblyMap
LibUtilities::SessionReaderSharedPtr	m_session
	Session object.

LibUtilities::CommSharedPtr	m_comm
	Communicator.

std::string	m_variable
	Variable string identifier.

size_t	m_hash
	Hash for map.

int	m_numLocalBndCoeffs
	Number of local boundary coefficients.

int	m_numGlobalBndCoeffs
	Total number of global boundary coefficients.

int	m_numLocalDirBndCoeffs
	Number of Local Dirichlet Boundary Coefficients.

int	m_numGlobalDirBndCoeffs
	Number of Global Dirichlet Boundary Coefficients.

bool	m_systemSingular
	Flag indicating if the system is singular or not.

int	m_numLocalCoeffs
	Total number of local coefficients.

int	m_numGlobalCoeffs
	Total number of global coefficients.

bool	m_signChange
	Flag indicating if modes require sign reversal.

Array< OneD, int >	m_localToGlobalBndMap
	Integer map of local coeffs to global Boundary Dofs.

Array< OneD, NekDouble >	m_localToGlobalBndSign
	Integer sign of local boundary coeffs to global space.

Array< OneD, int >	m_localToLocalBndMap
	Integer map of local boundary coeffs to local boundary system numbering.

Array< OneD, int >	m_localToLocalIntMap
	Integer map of local boundary coeffs to local interior system numbering.

Array< OneD, int >	m_bndCondCoeffsToLocalCoeffsMap
	Integer map of bnd cond coeffs to local coefficients.

Array< OneD, NekDouble >	m_bndCondCoeffsToLocalCoeffsSign
	Integer map of sign of bnd cond coeffs to local coefficients.

Array< OneD, int >	m_bndCondCoeffsToLocalTraceMap
	Integer map of bnd cond coeff to local trace coeff.

Array< OneD, int >	m_bndCondIDToGlobalTraceID
	Integer map of bnd cond trace number to global trace number.

Array< OneD, int >	m_perbndCondIDToGlobalTraceID
	Integer map of rotational periodic bnd cond trace number to global trace number.

Array< OneD, int >	m_globalToUniversalBndMap
	Integer map of process coeffs to universal space.

Array< OneD, int >	m_globalToUniversalBndMapUnique
	Integer map of unique process coeffs to universal space (signed)

GlobalSysSolnType	m_solnType
	The solution type of the global system.

int	m_bndSystemBandWidth
	The bandwith of the global bnd system.

std::string	m_preconType
	Type type of preconditioner to use in iterative solver.

NekDouble	m_iterativeTolerance
	Tolerance for iterative solver.

bool	m_isAbsoluteTolerance

int	m_successiveRHS
	sucessive RHS for iterative solver

std::string	m_linSysIterSolver
	Iterative solver: Conjugate Gradient, GMRES.

Gs::gs_data *	m_gsh

Gs::gs_data *	m_bndGsh

Gs::gs_data *	m_dirBndGsh
	gs gather communication to impose Dirhichlet BCs.

int	m_staticCondLevel
	The level of recursion in the case of multi-level static condensation.

int	m_numPatches
	The number of patches (~elements) in the current level.

Array< OneD, unsigned int >	m_numLocalBndCoeffsPerPatch
	The number of bnd dofs per patch.

Array< OneD, unsigned int >	m_numLocalIntCoeffsPerPatch
	The number of int dofs per patch.

AssemblyMapSharedPtr	m_nextLevelLocalToGlobalMap
	Map from the patches of the previous level to the patches of the current level.

int	m_lowestStaticCondLevel
	Lowest static condensation level.

Detailed Description

Definition at line 49 of file AssemblyMapDG.h.

Constructor & Destructor Documentation

◆ AssemblyMapDG() [1/2]

Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG ( )

Default constructor.

Definition at line 52 of file AssemblyMapDG.cpp.

                             : m_numDirichletBndPhys(0)
{
}

◆ AssemblyMapDG() [2/2]

Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const SpatialDomains::MeshGraphSharedPtr &	graph1D,
		const ExpListSharedPtr &	trace,
		const ExpList &	locExp,
		const Array< OneD, const MultiRegions::ExpListSharedPtr > &	bndConstraint,
		const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > &	bndCond,
		const PeriodicMap &	periodicTrace,
		const std::string	variable = `"DefaultVar"`
	)

Constructor for trace map for one-dimensional expansion.

Definition at line 60 of file AssemblyMapDG.cpp.

    : AssemblyMap(pSession, locExp.GetComm(), variable)
{
    int i, j, k, cnt, id, id1, gid;
    int order_e   = 0;
    int nTraceExp = trace->GetExpSize();
    int nbnd      = bndCondExp.size();
 
    LocalRegions::ExpansionSharedPtr exp;
    LocalRegions::ExpansionSharedPtr bndExp;
    SpatialDomains::Geometry *traceGeom;
 
    const LocalRegions::ExpansionVector expList = *(locExp.GetExp());
    int nel                                     = expList.size();
 
    map<int, int> meshTraceId;
 
    m_signChange = true;
 
    // determine mapping from geometry edges to trace
    for (i = 0; i < nTraceExp; ++i)
    {
        meshTraceId[trace->GetExp(i)->GetGeom()->GetGlobalID()] = i;
    }
 
    // Count total number of trace elements
    cnt = 0;
    for (i = 0; i < nel; ++i)
    {
        cnt += expList[i]->GetNtraces();
    }
 
    Array<OneD, LocalRegions::ExpansionSharedPtr> tracemap(cnt);
    m_elmtToTrace =
        Array<OneD, Array<OneD, LocalRegions::ExpansionSharedPtr>>(nel);
 
    // set up trace expansions links;
    for (cnt = i = 0; i < nel; ++i)
    {
        m_elmtToTrace[i] = tracemap + cnt;
        exp              = expList[i];
 
        for (j = 0; j < exp->GetNtraces(); ++j)
        {
            id = exp->GetGeom()->GetTid(j);
 
            if (meshTraceId.count(id) > 0)
            {
                m_elmtToTrace[i][j] =
                    trace->GetExp(meshTraceId.find(id)->second);
            }
            else
            {
                ASSERTL0(false, "Failed to find trace map");
            }
        }
 
        cnt += exp->GetNtraces();
    }
 
    // Set up boundary mapping
    cnt = 0;
    for (i = 0; i < nbnd; ++i)
    {
        if (bndCond[i]->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
        {
            continue;
        }
        cnt += bndCondExp[i]->GetExpSize();
    }
 
    set<int> dirTrace;
 
    m_numLocalDirBndCoeffs = 0;
    m_numDirichletBndPhys  = 0;
 
    for (i = 0; i < bndCondExp.size(); ++i)
    {
        for (j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
        {
            bndExp    = bndCondExp[i]->GetExp(j);
            traceGeom = bndExp->GetGeom();
            id        = traceGeom->GetGlobalID();
 
            if (bndCond[i]->GetBoundaryConditionType() ==
                SpatialDomains::eDirichlet)
            {
                m_numLocalDirBndCoeffs += bndExp->GetNcoeffs();
                m_numDirichletBndPhys += bndExp->GetTotPoints();
                dirTrace.insert(id);
            }
        }
    }
 
    // Set up integer mapping array and sign change for each degree of
    // freedom + initialise some more data members.
    m_staticCondLevel           = 0;
    m_lowestStaticCondLevel     = 0;
    m_numPatches                = nel;
    m_numLocalBndCoeffsPerPatch = Array<OneD, unsigned int>(nel);
    m_numLocalIntCoeffsPerPatch = Array<OneD, unsigned int>(nel);
 
    int nbndry = 0;
    for (i = 0; i < nel; ++i) // count number of elements in array
    {
        int BndCoeffs = expList[i]->NumDGBndryCoeffs();
        nbndry += BndCoeffs;
        m_numLocalIntCoeffsPerPatch[i] = 0;
        m_numLocalBndCoeffsPerPatch[i] = (unsigned int)BndCoeffs;
    }
 
    m_numGlobalDirBndCoeffs = m_numLocalDirBndCoeffs;
    m_numLocalBndCoeffs     = nbndry;
    m_numLocalCoeffs        = nbndry;
    m_localToGlobalBndMap   = Array<OneD, int>(nbndry);
    m_localToGlobalBndSign  = Array<OneD, NekDouble>(nbndry, 1);
 
    // Set up array for potential mesh optimsation
    Array<OneD, int> traceElmtGid(nTraceExp, -1);
    int nDir = 0;
    cnt      = 0;
 
    // We are now going to construct a graph of the mesh which can be
    // reordered depending on the type of solver we would like to use.
    typedef boost::adjacency_list<boost::setS, boost::vecS, boost::undirectedS>
        BoostGraph;
 
    BoostGraph boostGraphObj;
    int trace_id, trace_id1;
    int dirOffset = 0;
 
    // make trace renumbering map where first solved trace starts
    // at 0 so we can set up graph.
    for (i = 0; i < nTraceExp; ++i)
    {
        id = trace->GetExp(i)->GetGeom()->GetGlobalID();
 
        if (dirTrace.count(id) == 0)
        {
            // Initial put in element ordering (starting from zero) into
            // traceElmtGid
            boost::add_vertex(boostGraphObj);
            traceElmtGid[i] = cnt++;
        }
        else
        {
            // Use existing offset for Dirichlet edges
            traceElmtGid[i] = dirOffset;
            dirOffset += trace->GetExp(i)->GetNcoeffs();
            nDir++;
        }
    }
 
    // Set up boost Graph
    for (i = 0; i < nel; ++i)
    {
        exp = expList[i];
 
        for (j = 0; j < exp->GetNtraces(); ++j)
        {
            // Add trace to boost graph for non-Dirichlet Boundary
            traceGeom = m_elmtToTrace[i][j]->GetGeom();
            id        = traceGeom->GetGlobalID();
            trace_id  = meshTraceId.find(id)->second;
 
            if (dirTrace.count(id) == 0)
            {
                for (k = j + 1; k < exp->GetNtraces(); ++k)
                {
                    traceGeom = m_elmtToTrace[i][k]->GetGeom();
                    id1       = traceGeom->GetGlobalID();
                    trace_id1 = meshTraceId.find(id1)->second;
 
                    if (dirTrace.count(id1) == 0)
                    {
                        boost::add_edge((size_t)traceElmtGid[trace_id],
                                        (size_t)traceElmtGid[trace_id1],
                                        boostGraphObj);
                    }
                }
            }
        }
    }
 
    int nGraphVerts = nTraceExp - nDir;
    Array<OneD, int> perm(nGraphVerts);
    Array<OneD, int> iperm(nGraphVerts);
    Array<OneD, int> vwgts(nGraphVerts);
    BottomUpSubStructuredGraphSharedPtr bottomUpGraph;
 
    for (i = 0; i < nGraphVerts; ++i)
    {
        vwgts[i] = trace->GetExp(i + nDir)->GetNcoeffs();
    }
 
    if (nGraphVerts)
    {
        switch (m_solnType)
        {
            case eDirectFullMatrix:
            case eIterativeFull:
            case eIterativeStaticCond:
            case eXxtFullMatrix:
            case eXxtStaticCond:
            case ePETScFullMatrix:
            case ePETScStaticCond:
            {
                NoReordering(boostGraphObj, perm, iperm);
                break;
            }
            case eDirectStaticCond:
            {
                CuthillMckeeReordering(boostGraphObj, perm, iperm);
                break;
            }
            case eDirectMultiLevelStaticCond:
            case eIterativeMultiLevelStaticCond:
            case eXxtMultiLevelStaticCond:
            case ePETScMultiLevelStaticCond:
            {
                MultiLevelBisectionReordering(boostGraphObj, perm, iperm,
                                              bottomUpGraph);
                break;
            }
            default:
            {
                ASSERTL0(false, "Unrecognised solution type");
            }
        }
    }
 
    // Recast the permutation so that it can be used as a map from old
    // trace ID to new trace ID
    cnt = m_numLocalDirBndCoeffs;
    for (i = 0; i < nTraceExp - nDir; ++i)
    {
        traceElmtGid[perm[i] + nDir] = cnt;
        cnt += trace->GetExp(perm[i] + nDir)->GetNcoeffs();
    }
 
    // Now have trace edges Gid position
    cnt = 0;
    for (i = 0; i < nel; ++i)
    {
        exp = expList[i];
 
        for (j = 0; j < exp->GetNtraces(); ++j)
        {
            traceGeom = m_elmtToTrace[i][j]->GetGeom();
            id        = traceGeom->GetGlobalID();
            gid       = traceElmtGid[meshTraceId.find(id)->second];
 
            const int nDim = exp->GetNumBases();
 
            if (nDim == 1)
            {
                order_e                    = 1;
                m_localToGlobalBndMap[cnt] = gid;
            }
            else if (nDim == 2)
            {
                order_e = exp->GetTraceNcoeffs(j);
 
                if (exp->GetTraceOrient(j) == StdRegions::eForwards)
                {
                    for (k = 0; k < order_e; ++k)
                    {
                        m_localToGlobalBndMap[k + cnt] = gid + k;
                    }
                }
                else
                {
                    switch (m_elmtToTrace[i][j]->GetBasisType(0))
                    {
                        case LibUtilities::eModified_A:
                        {
                            // reverse vertex order
                            m_localToGlobalBndMap[cnt]     = gid + 1;
                            m_localToGlobalBndMap[cnt + 1] = gid;
                            for (k = 2; k < order_e; ++k)
                            {
                                m_localToGlobalBndMap[k + cnt] = gid + k;
                            }
 
                            // negate odd modes
                            for (k = 3; k < order_e; k += 2)
                            {
                                m_localToGlobalBndSign[cnt + k] = -1.0;
                            }
                            break;
                        }
                        case LibUtilities::eGLL_Lagrange:
                        {
                            // reverse  order
                            for (k = 0; k < order_e; ++k)
                            {
                                m_localToGlobalBndMap[cnt + order_e - k - 1] =
                                    gid + k;
                            }
                            break;
                        }
                        case LibUtilities::eGauss_Lagrange:
                        {
                            // reverse  order
                            for (k = 0; k < order_e; ++k)
                            {
                                m_localToGlobalBndMap[cnt + order_e - k - 1] =
                                    gid + k;
                            }
                            break;
                        }
                        default:
                        {
                            ASSERTL0(false, "Boundary type not permitted");
                        }
                    }
                }
            }
            else if (nDim == 3)
            {
                order_e = exp->GetTraceNcoeffs(j);
 
                std::map<int, int> orientMap;
 
                Array<OneD, unsigned int> elmMap1(order_e);
                Array<OneD, int> elmSign1(order_e);
                Array<OneD, unsigned int> elmMap2(order_e);
                Array<OneD, int> elmSign2(order_e);
 
                StdRegions::Orientation fo = exp->GetTraceOrient(j);
 
                // Construct mapping which will permute global IDs
                // according to face orientations.
                exp->GetTraceToElementMap(j, elmMap1, elmSign1, fo);
                exp->GetTraceToElementMap(j, elmMap2, elmSign2,
                                          StdRegions::eDir1FwdDir1_Dir2FwdDir2);
 
                for (k = 0; k < elmMap1.size(); ++k)
                {
                    // Find the elemental co-efficient in the original
                    // mapping.
                    int idx = -1;
                    for (int l = 0; l < elmMap2.size(); ++l)
                    {
                        if (elmMap1[k] == elmMap2[l])
                        {
                            idx = l;
                            break;
                        }
                    }
 
                    ASSERTL2(idx != -1, "Problem with face to element map!");
                    orientMap[k] = idx;
                }
 
                for (k = 0; k < order_e; ++k)
                {
                    m_localToGlobalBndMap[k + cnt]  = gid + orientMap[k];
                    m_localToGlobalBndSign[k + cnt] = elmSign2[orientMap[k]];
                }
            }
 
            cnt += order_e;
        }
    }
 
    // set up identify map for lcoal to lcoal
    m_localToLocalBndMap = Array<OneD, int>(m_numLocalBndCoeffs);
 
    // local to bnd map is just a copy
    for (i = 0; i < m_numLocalBndCoeffs; ++i)
    {
        m_localToLocalBndMap[i] = i;
    }
 
    m_numGlobalBndCoeffs = trace->GetNcoeffs();
    m_numGlobalCoeffs    = m_numGlobalBndCoeffs;
 
    CalculateBndSystemBandWidth();
 
    // set up m_bndCondCoeffsToLocalTraceMap
    // Number of boundary expansions
    int nbndexp       = 0;
    int nrotperbndexp = 0;
    int bndTotal      = 0;
    int bndOffset;
    int traceOffset;
 
    cnt = 0;
    for (i = 0; i < nbnd; ++i)
    {
        if (bndCond[i]->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
        {
            if (boost::icontains(bndCond[i]->GetUserDefined(), "Rotated"))
            {
                nrotperbndexp += bndCondExp[i]->GetExpSize();
            }
 
            continue;
        }
        cnt += bndCondExp[i]->GetNcoeffs();
        nbndexp += bndCondExp[i]->GetExpSize();
    }
 
    m_bndCondCoeffsToLocalTraceMap = Array<OneD, int>(cnt);
    m_bndCondIDToGlobalTraceID     = Array<OneD, int>(nbndexp);
    m_perbndCondIDToGlobalTraceID  = Array<OneD, int>(nrotperbndexp);
 
    cnt        = 0;
    int percnt = 0;
    for (i = 0; i < bndCondExp.size(); ++i)
    {
        if (bndCond[i]->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
        {
            if (boost::icontains(bndCond[i]->GetUserDefined(), "Rotated"))
            {
 
                for (j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
                {
                    bndExp = bndCondExp[i]->GetExp(j);
                    id     = bndExp->GetGeom()->GetGlobalID();
 
                    int meshId = meshTraceId.find(id)->second;
                    m_perbndCondIDToGlobalTraceID[percnt++] = meshId;
                }
            }
            continue;
        }
 
        for (j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
        {
            bndExp = bndCondExp[i]->GetExp(j);
            id     = bndExp->GetGeom()->GetGlobalID();
 
            int meshId                        = meshTraceId.find(id)->second;
            m_bndCondIDToGlobalTraceID[cnt++] = meshId;
 
            // initialy set up map with global bnd location
            // and then use the localToGlobalBndMap to invert
            // since this is a one to one mapping on boundaries
            traceOffset = traceElmtGid[meshId];
            bndOffset   = bndCondExp[i]->GetCoeff_Offset(j) + bndTotal;
 
            for (k = 0; k < bndExp->GetNcoeffs(); ++k)
            {
                m_bndCondCoeffsToLocalTraceMap[bndOffset + k] = traceOffset + k;
            }
        }
        bndTotal += bndCondExp[i]->GetNcoeffs();
    }
 
    // generate an inverse local to global bnd map;
    map<int, int> invLocToGloMap;
    for (i = 0; i < nbndry; ++i)
    {
        invLocToGloMap[m_localToGlobalBndMap[i]] = i;
    }
 
    // reset bndCondCoeffToLocalTraceMap to hold local rather
    // than global reference
    for (i = 0; i < m_bndCondCoeffsToLocalTraceMap.size(); ++i)
    {
        m_bndCondCoeffsToLocalTraceMap[i] =
            invLocToGloMap[m_bndCondCoeffsToLocalTraceMap[i]];
    }
 
    // Now set up mapping from global coefficients to universal.
    ExpListSharedPtr tr = std::dynamic_pointer_cast<ExpList>(trace);
    SetUpUniversalDGMap(locExp);
 
    m_assemblyComm = AssemblyCommDGSharedPtr(
        MemoryManager<AssemblyCommDG>::AllocateSharedPtr(
            locExp, tr, m_elmtToTrace, bndCondExp, bndCond, periodicTrace));
 
    if ((m_solnType == eDirectMultiLevelStaticCond ||
         m_solnType == eIterativeMultiLevelStaticCond ||
         m_solnType == eXxtMultiLevelStaticCond ||
         m_solnType == ePETScMultiLevelStaticCond) &&
        nGraphVerts)
    {
        if (m_staticCondLevel < (bottomUpGraph->GetNlevels() - 1))
        {
            Array<OneD, int> vwgts_perm(nGraphVerts);
 
            for (int i = 0; i < nGraphVerts; i++)
            {
                vwgts_perm[i] = vwgts[perm[i]];
            }
 
            bottomUpGraph->ExpandGraphWithVertexWeights(vwgts_perm);
            m_nextLevelLocalToGlobalMap =
                MemoryManager<AssemblyMap>::AllocateSharedPtr(this,
                                                              bottomUpGraph);
        }
    }
 
    m_hash =
        hash_range(m_localToGlobalBndMap.begin(), m_localToGlobalBndMap.end());
}

◆ ~AssemblyMapDG()

Nektar::MultiRegions::AssemblyMapDG::~AssemblyMapDG ( )

override

Destructor.

Definition at line 56 of file AssemblyMapDG.cpp.

57{

58}

Member Function Documentation

◆ GetAssemblyCommDG()

AssemblyCommDGSharedPtr Nektar::MultiRegions::AssemblyMapDG::GetAssemblyCommDG ( )

Definition at line 935 of file AssemblyMapDG.cpp.

{
    return m_assemblyComm;
}

References m_assemblyComm.

◆ GetElmtToTrace() [1/2]

Array< OneD, Array< OneD, LocalRegions::ExpansionSharedPtr > > & Nektar::MultiRegions::AssemblyMapDG::GetElmtToTrace ( )

Definition at line 929 of file AssemblyMapDG.cpp.

{
    return m_elmtToTrace;
}

References m_elmtToTrace.

◆ GetElmtToTrace() [2/2]

Array< OneD, LocalRegions::ExpansionSharedPtr > & Nektar::MultiRegions::AssemblyMapDG::GetElmtToTrace ( const int i )

Definition at line 922 of file AssemblyMapDG.cpp.

{
    ASSERTL1(i >= 0 && i < m_elmtToTrace.size(), "i is out of range");
    return m_elmtToTrace[i];
}

References ASSERTL1, and m_elmtToTrace.

◆ GetNumDirichletBndPhys()

int Nektar::MultiRegions::AssemblyMapDG::GetNumDirichletBndPhys ( )

Return the number of boundary segments on which Dirichlet boundary conditions are imposed.

Definition at line 917 of file AssemblyMapDG.cpp.

{
    return m_numDirichletBndPhys;
}

References m_numDirichletBndPhys.

◆ RealignTraceElement()

void Nektar::MultiRegions::AssemblyMapDG::RealignTraceElement	(	Array< OneD, int > &	toAlign,
		StdRegions::Orientation	orient,
		int	nquad1,
		int	nquad2 = `0`
	)

static

Changes toAlign quadrature point order, where the realignment is given by orient, which defines the mapping needed to go between the original ordering and the new desired ordering.

Parameters

[in,out]	toAlign	Data to reorder
[in]	orient	The transformation to perform
[in]	nquad1	Quadrature points in direction 1
[in]	nquad2	Quadrature points in direction 2

Definition at line 753 of file AssemblyMapDG.cpp.

{
    if (orient == StdRegions::eBackwards)
    {
        ASSERTL1(nquad2 == 0, "nquad2 != 0 for reorienation");
        for (int i = 0; i < nquad1 / 2; ++i)
        {
            swap(toAlign[i], toAlign[nquad1 - 1 - i]);
        }
    }
    else if (orient != StdRegions::eForwards)
    {
        ASSERTL1(nquad2 != 0, "nquad2 == 0 for reorienation");
 
        Array<OneD, int> tmp(nquad1 * nquad2);
 
        // Copy transpose.
        if (orient == StdRegions::eDir1FwdDir2_Dir2FwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
            orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
        {
            for (int i = 0; i < nquad2; ++i)
            {
                for (int j = 0; j < nquad1; ++j)
                {
                    tmp[i * nquad1 + j] = toAlign[j * nquad2 + i];
                }
            }
        }
        else
        {
            for (int i = 0; i < nquad2; ++i)
            {
                for (int j = 0; j < nquad1; ++j)
                {
                    tmp[i * nquad1 + j] = toAlign[i * nquad1 + j];
                }
            }
        }
 
        if (orient == StdRegions::eDir1BwdDir1_Dir2FwdDir2 ||
            orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
            orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
        {
            // Reverse x direction
            for (int i = 0; i < nquad2; ++i)
            {
                for (int j = 0; j < nquad1 / 2; ++j)
                {
                    swap(tmp[i * nquad1 + j], tmp[i * nquad1 + nquad1 - j - 1]);
                }
            }
        }
 
        if (orient == StdRegions::eDir1FwdDir1_Dir2BwdDir2 ||
            orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
            orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
        {
            // Reverse y direction
            for (int j = 0; j < nquad1; ++j)
            {
                for (int i = 0; i < nquad2 / 2; ++i)
                {
                    swap(tmp[i * nquad1 + j],
                         tmp[(nquad2 - i - 1) * nquad1 + j]);
                }
            }
        }
        Vmath::Vcopy(nquad1 * nquad2, tmp, 1, toAlign, 1);
    }
}

References ASSERTL1, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1BwdDir2_Dir2FwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::StdRegions::eForwards, and Vmath::Vcopy().

Referenced by Nektar::MultiRegions::AssemblyCommDG::InitialiseStructure().

◆ SetUpUniversalDGMap()

void Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap ( const ExpList & locExp )

protected

Constructs a mapping between the process-local global numbering and a universal numbering of the trace space expansion. The universal numbering is defined by the mesh edge IDs to enforce consistency across processes.

Parameters

locExp List of local elemental expansions.

Definition at line 574 of file AssemblyMapDG.cpp.

{
    LocalRegions::ExpansionSharedPtr locExpansion;
    int cnt       = 0;
    int id        = 0;
    int order_e   = 0;
    int vGlobalId = 0;
    int maxDof    = 0;
    int dof       = 0;
    int nDim      = 0;
    int i, j, k;
 
    const LocalRegions::ExpansionVector &locExpVector = *(locExp.GetExp());
 
    // Initialise the global to universal maps.
    m_globalToUniversalBndMap =
        Nektar::Array<OneD, int>(m_numGlobalBndCoeffs, -1);
    m_globalToUniversalBndMapUnique =
        Nektar::Array<OneD, int>(m_numGlobalBndCoeffs, -1);
 
    // Loop over all the elements in the domain and compute max
    // DOF. Reduce across all processes to get universal maximum.
    for (i = 0; i < locExpVector.size(); ++i)
    {
        locExpansion = locExpVector[i];
        nDim         = locExpansion->GetShapeDimension();
 
        // Loop over all edges of element i
        if (nDim == 1)
        {
            maxDof = (1 > maxDof ? 1 : maxDof);
        }
        else
        {
            for (j = 0; j < locExpansion->GetNtraces(); ++j)
            {
                dof    = locExpansion->GetTraceNcoeffs(j);
                maxDof = (dof > maxDof ? dof : maxDof);
            }
        }
    }
    m_comm->GetRowComm()->AllReduce(maxDof, LibUtilities::ReduceMax);
 
    // Now have trace edges Gid position
    cnt = 0;
    for (i = 0; i < locExpVector.size(); ++i)
    {
        locExpansion = locExpVector[i];
        nDim         = locExpansion->GetShapeDimension();
 
        // Populate mapping for each edge of the element.
        if (nDim == 1)
        {
            int nverts = locExpansion->GetNverts();
            for (j = 0; j < nverts; ++j)
            {
                LocalRegions::PointExpSharedPtr locPointExp =
                    m_elmtToTrace[i][j]->as<LocalRegions::PointExp>();
                id        = locPointExp->GetGeom()->GetGlobalID();
                vGlobalId = m_localToGlobalBndMap[cnt + j];
                m_globalToUniversalBndMap[vGlobalId] = id * maxDof + j + 1;
            }
            cnt += nverts;
        }
        else if (nDim == 2)
        {
            for (j = 0; j < locExpansion->GetNtraces(); ++j)
            {
                LocalRegions::SegExpSharedPtr locSegExp =
                    m_elmtToTrace[i][j]->as<LocalRegions::SegExp>();
 
                id      = locSegExp->GetGeom()->GetGlobalID();
                order_e = locExpansion->GetTraceNcoeffs(j);
 
                map<int, int> orientMap;
                Array<OneD, unsigned int> map1(order_e), map2(order_e);
                Array<OneD, int> sign1(order_e), sign2(order_e);
 
                locExpansion->GetTraceToElementMap(j, map1, sign1,
                                                   StdRegions::eForwards);
                locExpansion->GetTraceToElementMap(
                    j, map2, sign2, locExpansion->GetTraceOrient(j));
 
                for (k = 0; k < map1.size(); ++k)
                {
                    // Find the elemental co-efficient in the original
                    // mapping.
                    int idx = -1;
                    for (int l = 0; l < map2.size(); ++l)
                    {
                        if (map1[k] == map2[l])
                        {
                            idx = l;
                            break;
                        }
                    }
 
                    ASSERTL2(idx != -1, "Problem with face to"
                                        " element map!");
                    orientMap[k] = idx;
                }
 
                for (k = 0; k < order_e; ++k)
                {
                    vGlobalId = m_localToGlobalBndMap[k + cnt];
                    m_globalToUniversalBndMap[vGlobalId] =
                        id * maxDof + orientMap[k] + 1;
                }
                cnt += order_e;
            }
        }
        else if (nDim == 3) // This could likely be combined with nDim == 2
        {
            for (j = 0; j < locExpansion->GetNtraces(); ++j)
            {
                LocalRegions::Expansion2DSharedPtr locFaceExp =
                    m_elmtToTrace[i][j]->as<LocalRegions::Expansion2D>();
 
                id      = locFaceExp->GetGeom()->GetGlobalID();
                order_e = locExpansion->GetTraceNcoeffs(j);
 
                map<int, int> orientMap;
                Array<OneD, unsigned int> map1(order_e), map2(order_e);
                Array<OneD, int> sign1(order_e), sign2(order_e);
 
                locExpansion->GetTraceToElementMap(
                    j, map1, sign1, StdRegions::eDir1FwdDir1_Dir2FwdDir2);
                locExpansion->GetTraceToElementMap(
                    j, map2, sign2, locExpansion->GetTraceOrient(j));
 
                for (k = 0; k < map1.size(); ++k)
                {
                    // Find the elemental co-efficient in the original
                    // mapping.
                    int idx = -1;
                    for (int l = 0; l < map2.size(); ++l)
                    {
                        if (map1[k] == map2[l])
                        {
                            idx = l;
                            break;
                        }
                    }
 
                    ASSERTL2(idx != -1, "Problem with face to "
                                        "element map!");
                    orientMap[k] = idx;
                }
 
                for (k = 0; k < order_e; ++k)
                {
                    vGlobalId = m_localToGlobalBndMap[k + cnt];
                    m_globalToUniversalBndMap[vGlobalId] =
                        id * maxDof + orientMap[k] + 1;
                }
                cnt += order_e;
            }
        }
    }
 
    // Initialise GSlib and populate the unique map.
    Array<OneD, long> tmp(m_globalToUniversalBndMap.size());
    for (i = 0; i < m_globalToUniversalBndMap.size(); ++i)
    {
        tmp[i] = m_globalToUniversalBndMap[i];
    }
 
    bool verbose = m_comm->IsParallelInTime()
                       ? m_comm->GetTimeComm()->GetRank() == 0
                       : true;
 
    m_bndGsh = m_gsh = Gs::Init(tmp, m_comm->GetRowComm(), verbose);
    Gs::Unique(tmp, m_comm->GetRowComm());
    for (i = 0; i < m_globalToUniversalBndMap.size(); ++i)
    {
        m_globalToUniversalBndMapUnique[i] = (tmp[i] >= 0 ? 1 : 0);
    }
}

Referenced by AssemblyMapDG().

◆ v_Assemble() [1/2]

void Nektar::MultiRegions::AssemblyMapDG::v_Assemble	(	const Array< OneD, const NekDouble > &	loc,
		Array< OneD, NekDouble > &	global
	)		const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 889 of file AssemblyMapDG.cpp.

{
    AssembleBnd(loc, global);
}

References Nektar::MultiRegions::AssemblyMap::AssembleBnd().

◆ v_Assemble() [2/2]

void Nektar::MultiRegions::AssemblyMapDG::v_Assemble	(	const NekVector< NekDouble > &	loc,
		NekVector< NekDouble > &	global
	)		const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 895 of file AssemblyMapDG.cpp.

{
    AssembleBnd(loc, global);
}

References Nektar::MultiRegions::AssemblyMap::AssembleBnd().

◆ v_GetFullSystemBandWidth()

int Nektar::MultiRegions::AssemblyMapDG::v_GetFullSystemBandWidth ( ) const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 912 of file AssemblyMapDG.cpp.

{
    return GetBndSystemBandWidth();
}

References Nektar::MultiRegions::AssemblyMap::GetBndSystemBandWidth().

◆ v_GetGlobalToUniversalMap() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMapDG::v_GetGlobalToUniversalMap ( void )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 850 of file AssemblyMapDG.cpp.

{
    return m_globalToUniversalBndMap;
}

References Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMap.

◆ v_GetGlobalToUniversalMap() [2/2]

int Nektar::MultiRegions::AssemblyMapDG::v_GetGlobalToUniversalMap ( const int i ) const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 835 of file AssemblyMapDG.cpp.

{
    return m_globalToUniversalBndMap[i];
}

References Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMap.

◆ v_GetGlobalToUniversalMapUnique() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMapDG::v_GetGlobalToUniversalMapUnique ( void )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 855 of file AssemblyMapDG.cpp.

{
    return m_globalToUniversalBndMapUnique;
}

References Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMapUnique.

◆ v_GetGlobalToUniversalMapUnique() [2/2]

int Nektar::MultiRegions::AssemblyMapDG::v_GetGlobalToUniversalMapUnique ( const int i ) const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 840 of file AssemblyMapDG.cpp.

{
    return m_globalToUniversalBndMapUnique[i];
}

References Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMapUnique.

◆ v_GetLocalToGlobalMap() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMapDG::v_GetLocalToGlobalMap ( void )

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 845 of file AssemblyMapDG.cpp.

{
    return m_localToGlobalBndMap;
}

References Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndMap.

◆ v_GetLocalToGlobalMap() [2/2]

int Nektar::MultiRegions::AssemblyMapDG::v_GetLocalToGlobalMap ( const int i ) const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 830 of file AssemblyMapDG.cpp.

{
    return m_localToGlobalBndMap[i];
}

References Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndMap.

◆ v_GetLocalToGlobalSign() [1/2]

const Array< OneD, NekDouble > & Nektar::MultiRegions::AssemblyMapDG::v_GetLocalToGlobalSign ( ) const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 865 of file AssemblyMapDG.cpp.

{
    return AssemblyMap::v_GetLocalToGlobalSign();
}

References Nektar::MultiRegions::AssemblyMap::v_GetLocalToGlobalSign().

◆ v_GetLocalToGlobalSign() [2/2]

NekDouble Nektar::MultiRegions::AssemblyMapDG::v_GetLocalToGlobalSign ( const int i ) const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 860 of file AssemblyMapDG.cpp.

{
    return GetLocalToGlobalBndSign(i);
}

References Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalBndSign().

◆ v_GlobalToLocal() [1/2]

void Nektar::MultiRegions::AssemblyMapDG::v_GlobalToLocal	(	const Array< OneD, const NekDouble > &	global,
		Array< OneD, NekDouble > &	loc
	)		const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 877 of file AssemblyMapDG.cpp.

{
    GlobalToLocalBnd(global, loc);
}

References Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd().

◆ v_GlobalToLocal() [2/2]

void Nektar::MultiRegions::AssemblyMapDG::v_GlobalToLocal	(	const NekVector< NekDouble > &	global,
		NekVector< NekDouble > &	loc
	)		const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 883 of file AssemblyMapDG.cpp.

{
    GlobalToLocalBnd(global, loc);
}

References Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd().

◆ v_LocalToGlobal()

void Nektar::MultiRegions::AssemblyMapDG::v_LocalToGlobal	(	const Array< OneD, const NekDouble > &	loc,
		Array< OneD, NekDouble > &	global,
		bool	useComm = `false`
	)		const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 870 of file AssemblyMapDG.cpp.

{
    LocalBndToGlobal(loc, global, useComm);
}

References Nektar::MultiRegions::AssemblyMap::LocalBndToGlobal().

◆ v_UniversalAssemble() [1/2]

void Nektar::MultiRegions::AssemblyMapDG::v_UniversalAssemble ( Array< OneD, NekDouble > & pGlobal ) const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 901 of file AssemblyMapDG.cpp.

{
    Gs::Gather(pGlobal, Gs::gs_add, m_gsh);
}

References Gs::Gather(), Gs::gs_add, and Nektar::MultiRegions::AssemblyMap::m_gsh.

◆ v_UniversalAssemble() [2/2]

void Nektar::MultiRegions::AssemblyMapDG::v_UniversalAssemble	(	Array< OneD, NekDouble > &	pGlobal,
		int	offset
	)		const

overrideprotectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 906 of file AssemblyMapDG.cpp.

{
    AssemblyMap::v_UniversalAssemble(pGlobal, offset);
}

References Nektar::MultiRegions::AssemblyMap::v_UniversalAssemble().

Member Data Documentation

◆ m_assemblyComm

AssemblyCommDGSharedPtr Nektar::MultiRegions::AssemblyMapDG::m_assemblyComm

protected

Definition at line 99 of file AssemblyMapDG.h.

Referenced by AssemblyMapDG(), and GetAssemblyCommDG().

◆ m_elmtToTrace

Array<OneD, Array<OneD, LocalRegions::ExpansionSharedPtr> > Nektar::MultiRegions::AssemblyMapDG::m_elmtToTrace

protected

list of edge expansions for a given element

Definition at line 102 of file AssemblyMapDG.h.

Referenced by AssemblyMapDG(), GetElmtToTrace(), GetElmtToTrace(), and SetUpUniversalDGMap().

◆ m_numDirichletBndPhys

int Nektar::MultiRegions::AssemblyMapDG::m_numDirichletBndPhys

protected

Number of physical dirichlet boundary values in trace.

Definition at line 97 of file AssemblyMapDG.h.

Referenced by AssemblyMapDG(), and GetNumDirichletBndPhys().

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AssemblyMapDG() [1/2]

◆ AssemblyMapDG() [2/2]

◆ ~AssemblyMapDG()

Member Function Documentation

◆ GetAssemblyCommDG()

◆ GetElmtToTrace() [1/2]

◆ GetElmtToTrace() [2/2]

◆ GetNumDirichletBndPhys()

◆ RealignTraceElement()

◆ SetUpUniversalDGMap()

◆ v_Assemble() [1/2]

◆ v_Assemble() [2/2]

◆ v_GetFullSystemBandWidth()

◆ v_GetGlobalToUniversalMap() [1/2]

◆ v_GetGlobalToUniversalMap() [2/2]

◆ v_GetGlobalToUniversalMapUnique() [1/2]

◆ v_GetGlobalToUniversalMapUnique() [2/2]

◆ v_GetLocalToGlobalMap() [1/2]

◆ v_GetLocalToGlobalMap() [2/2]

◆ v_GetLocalToGlobalSign() [1/2]

◆ v_GetLocalToGlobalSign() [2/2]

◆ v_GlobalToLocal() [1/2]

◆ v_GlobalToLocal() [2/2]

◆ v_LocalToGlobal()

◆ v_UniversalAssemble() [1/2]

◆ v_UniversalAssemble() [2/2]

Member Data Documentation

◆ m_assemblyComm

◆ m_elmtToTrace

◆ m_numDirichletBndPhys