#include <AssemblyMapDG.h>

Inheritance diagram for Nektar::MultiRegions::AssemblyMapDG:

Public Member Functions
	AssemblyMapDG ()
	Default constructor. More...

	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. More...

virtual	~AssemblyMapDG ()
	Destructor. More...

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

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. More...

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

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

virtual	~AssemblyMap ()
	Destructor. More...

LibUtilities::CommSharedPtr	GetComm ()
	Retrieves the communicator. More...

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

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. More...

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

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. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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. More...

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

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

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

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

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

void	SetNextLevelLocalToGlobalMap (AssemblyMapSharedPtr pNextLevelLocalToGlobalMap)

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

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

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

PreconditionerType	GetPreconType () const

NekDouble	GetIterativeTolerance () const

int	GetMaxIterations () 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)

virtual int	v_GetLocalToGlobalMap (const int i) const

virtual int	v_GetGlobalToUniversalMap (const int i) const

virtual int	v_GetGlobalToUniversalMapUnique (const int i) const

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

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

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

virtual NekDouble	v_GetLocalToGlobalSign (const int i) const

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

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

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

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

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

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

virtual void	v_UniversalAssemble (NekVector< NekDouble > &pGlobal) const

virtual int	v_GetFullSystemBandWidth () const

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

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

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

AssemblyCommDGSharedPtr	m_assemblyComm

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

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

LibUtilities::CommSharedPtr	m_comm
	Communicator. More...

size_t	m_hash
	Hash for map. More...

int	m_numLocalBndCoeffs
	Number of local boundary coefficients. More...

int	m_numGlobalBndCoeffs
	Total number of global boundary coefficients. More...

int	m_numLocalDirBndCoeffs
	Number of Local Dirichlet Boundary Coefficients. More...

int	m_numGlobalDirBndCoeffs
	Number of Global Dirichlet Boundary Coefficients. More...

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

int	m_numLocalCoeffs
	Total number of local coefficients. More...

int	m_numGlobalCoeffs
	Total number of global coefficients. More...

bool	m_signChange
	Flag indicating if modes require sign reversal. More...

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

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

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

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

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

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

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

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

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

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

GlobalSysSolnType	m_solnType
	The solution type of the global system. More...

int	m_bndSystemBandWidth
	The bandwith of the global bnd system. More...

PreconditionerType	m_preconType
	Type type of preconditioner to use in iterative solver. More...

int	m_maxIterations
	Maximum iterations for iterative solver. More...

NekDouble	m_iterativeTolerance
	Tolerance for iterative solver. More...

int	m_successiveRHS
	sucessive RHS for iterative solver More...

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

Gs::gs_data *	m_gsh

Gs::gs_data *	m_bndGsh

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

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

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

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

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

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

int	m_lowestStaticCondLevel
	Lowest static condensation level. More...

Detailed Description

Definition at line 51 of file AssemblyMapDG.h.

Constructor & Destructor Documentation

◆ AssemblyMapDG() [1/2]

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

Default constructor.

Definition at line 54 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 63 of file AssemblyMapDG.cpp.

                                      :
             AssemblyMap(pSession,variable)
         {
             boost::ignore_unused(graph);
  
             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::GeometrySharedPtr 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 bndTotal = 0;
             int bndOffset;
             int traceOffset;
  
             cnt = 0; 
             for(i = 0; i < nbnd; ++i)
             {
                 if (bndCond[i]->GetBoundaryConditionType() ==
                     SpatialDomains::ePeriodic)
                 {
                     continue;
                 }
                 cnt += bndCondExp[i]->GetNcoeffs();
                 nbndexp  += bndCondExp[i]->GetExpSize();
             }
             
             m_bndCondCoeffsToLocalTraceMap = Array<OneD, int>(cnt); 
             m_bndCondIDToGlobalTraceID = Array<OneD, int>(nbndexp);
  
             cnt = 0;
             for(i = 0; i < bndCondExp.size(); ++i)
             {
                 if (bndCond[i]->GetBoundaryConditionType() ==
                     SpatialDomains::ePeriodic)
                 {
                     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 ( )

virtual

Destructor.

Definition at line 59 of file AssemblyMapDG.cpp.

60 {

61 }

Member Function Documentation

◆ GetAssemblyCommDG()

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

Definition at line 926 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 921 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 913 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 907 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 738 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 564 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];
             }
             m_bndGsh = m_gsh = Gs::Init(tmp, m_comm->GetRowComm());
             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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 876 of file AssemblyMapDG.cpp.

         {
             AssembleBnd(loc,global);
         }

References Nektar::MultiRegions::AssemblyMap::AssembleBnd(), and CG_Iterations::loc.

◆ v_Assemble() [2/2]

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 883 of file AssemblyMapDG.cpp.

         {
             AssembleBnd(loc,global);
         }

References Nektar::MultiRegions::AssemblyMap::AssembleBnd(), and CG_Iterations::loc.

◆ v_GetFullSystemBandWidth()

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 902 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 )

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 838 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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 823 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 )

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 843 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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 828 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 )

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 833 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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 818 of file AssemblyMapDG.cpp.

         {
             return m_localToGlobalBndMap[i];
         }

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

◆ v_GetLocalToGlobalSign()

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 848 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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 862 of file AssemblyMapDG.cpp.

         {
             GlobalToLocalBnd(global,loc);
         }

References Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd(), and CG_Iterations::loc.

◆ v_GlobalToLocal() [2/2]

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 869 of file AssemblyMapDG.cpp.

         {
             GlobalToLocalBnd(global,loc);
         }

References Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd(), and CG_Iterations::loc.

◆ v_LocalToGlobal()

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 854 of file AssemblyMapDG.cpp.

         {
             LocalBndToGlobal(loc,global,useComm);
         }

References CG_Iterations::loc, and Nektar::MultiRegions::AssemblyMap::LocalBndToGlobal().

◆ v_UniversalAssemble() [1/2]

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 890 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 ( NekVector< NekDouble > & pGlobal ) const

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 896 of file AssemblyMapDG.cpp.

         {
             UniversalAssemble(pGlobal.GetPtr());
         }

References Nektar::NekVector< DataType >::GetPtr(), and Nektar::MultiRegions::AssemblyMap::UniversalAssemble().

Member Data Documentation

◆ m_assemblyComm

AssemblyCommDGSharedPtr Nektar::MultiRegions::AssemblyMapDG::m_assemblyComm

protected

Definition at line 106 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 109 of file AssemblyMapDG.h.

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

◆ m_numDirichletBndPhys

int Nektar::MultiRegions::AssemblyMapDG::m_numDirichletBndPhys

protected

Number of physical dirichlet boundary values in trace.

Definition at line 104 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()

◆ 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