#include <AssemblyMapDG.h>

Inheritance diagram for Nektar::MultiRegions::AssemblyMapDG:

Collaboration 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 ()

int	GetTraceToUniversalMap (int i)

int	GetTraceToUniversalMapUnique (int i)

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

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

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

int	GetBndCondCoeffsToGlobalCoeffsMap (const int i)
	Retrieves the global index corresponding to a boundary expansion mode. More...

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

NekDouble	GetBndCondCoeffsToGlobalCoeffsSign (const int i)
	Returns the modal sign associated with a given boundary expansion mode. More...

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

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

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 NekVector< NekDouble > &loc, NekVector< NekDouble > &global, int offset) const

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

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

void	LocalBndToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) 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 ()

boost::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

int	GetLowestStaticCondLevel () const

Protected Member Functions
void	SetUpUniversalDGMap (const ExpList &locExp)

void	SetUpUniversalTraceMap (const ExpList &locExp, const ExpListSharedPtr trace, const PeriodicMap &perMap=NullPeriodicMap)

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) const

virtual void	v_LocalToGlobal (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global, bool useComm) 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

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

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
Gs::gs_data *	m_traceGsh

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

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

Array< OneD, int >	m_traceToUniversalMap
	Integer map of process trace space quadrature points to universal space. More...

Array< OneD, int >	m_traceToUniversalMapUnique
	Integer map of unique process trace space quadrature points to universal space (signed). 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 boundary coeffs to global space. More...

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

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

Array< OneD, NekDouble >	m_bndCondCoeffsToGlobalCoeffsSign
	Integer map of bnd cond coeffs to global coefficients. More...

Array< OneD, int >	m_bndCondTraceToGlobalTraceMap
	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...

Gs::gs_data *	m_gsh

Gs::gs_data *	m_bndGsh

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 53 of file AssemblyMapDG.h.

Constructor & Destructor Documentation

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

Default constructor.

Definition at line 61 of file AssemblyMapDG.cpp.

                                     :
             m_numDirichletBndPhys(0)
         {
         }

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 70 of file AssemblyMapDG.cpp.

                                      :
             AssemblyMap(pSession,variable)
         {
             int i, j, k, cnt, eid, id, id1, gid;
             int order_e   = 0;
             int nTraceExp = trace->GetExpSize();
             int nbnd      = bndCondExp.num_elements();
 
             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]->GetNtrace();
             }
 
             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;
 
                 for(j = 0; j < expList[i]->GetNtrace(); ++j)
                 {
                     id = expList[i]->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 += expList[i]->GetNtrace();
             }
 
             // Set up boundary mapping
             cnt = 0;
             for(i = 0; i < nbnd; ++i)
             {
                 cnt += bndCondExp[i]->GetExpSize();
             }
 
             set<int> dirTrace;
 
             m_numLocalDirBndCoeffs = 0;
             m_numDirichletBndPhys  = 0;
 
             cnt = 0;
             for(i = 0; i < bndCondExp.num_elements(); ++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);
                     }
                 }
 
                 cnt += j;
             }
 
             // 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
             {
                 eid     = i;
                 nbndry += expList[eid]->NumDGBndryCoeffs();
                 m_numLocalIntCoeffsPerPatch[i] = 0;
                 m_numLocalBndCoeffsPerPatch[i] =
                     (unsigned int) expList[eid]->NumDGBndryCoeffs();
             }
 
             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 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)
             {
                 eid = i;
 
                 for(j = 0; j < expList[eid]->GetNtrace(); ++j)
                 {
                     // Add trace to boost graph for non-Dirichlet Boundary
                     traceGeom = m_elmtToTrace[eid][j]->GetGeom();
                     id        = traceGeom->GetGlobalID();
                     trace_id  = meshTraceId.find(id)->second;
 
                     if(dirTrace.count(id) == 0)
                     {
                         for(k = j+1; k < expList[eid]->GetNtrace(); ++k)
                         {
                             traceGeom = m_elmtToTrace[eid][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)
             {
                 eid = i;
                 exp = expList[eid];
 
                 for(j = 0; j < exp->GetNtrace(); ++j)
                 {
                     traceGeom = m_elmtToTrace[eid][j]->GetGeom();
                     id        = traceGeom->GetGlobalID();
                     gid       = traceElmtGid[meshTraceId.find(id)->second];
 
                     const int nDim = expList[eid]->GetNumBases();
 
                     if (nDim == 1)
                     {
                         order_e = 1;
                         m_localToGlobalBndMap[cnt] = gid;
                     }
                     else if (nDim == 2)
                     {
                         order_e = expList[eid]->GetEdgeNcoeffs(j);
                     
                         if(expList[eid]->GetEorient(j) == StdRegions::eForwards)
                         {
                             for(k = 0; k < order_e; ++k)
                             {
                                 m_localToGlobalBndMap[k+cnt] = gid + k;
                             }
                         }
                         else
                         {
                             switch(m_elmtToTrace[eid][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 = expList[eid]->GetFaceNcoeffs(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 = expList[eid]->GetForient(j);
 
                         // Construct mapping which will permute global IDs
                         // according to face orientations.
                         expList[eid]->GetFaceToElementMap(j,fo,elmMap1,elmSign1);
                         expList[eid]->GetFaceToElementMap(
                             j,StdRegions::eDir1FwdDir1_Dir2FwdDir2,elmMap2,elmSign2);
 
                         for (k = 0; k < elmMap1.num_elements(); ++k)
                         {
                             // Find the elemental co-efficient in the original
                             // mapping.
                             int idx = -1;
                             for (int l = 0; l < elmMap2.num_elements(); ++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 m_bndCondCoeffsToGlobalCoeffsMap to align with map
             cnt = 0;
             for(i = 0; i < nbnd; ++i)
             {
                 cnt += bndCondExp[i]->GetNcoeffs();
             }
 
             m_bndCondCoeffsToGlobalCoeffsMap = Array<OneD, int>(cnt);
 
             // Number of boundary expansions
             int nbndexp = 0, bndOffset, bndTotal = 0;
             for(cnt = i = 0; i < nbnd; ++i)
             {
                 for(j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
                 {
                     bndExp    = bndCondExp[i]->GetExp(j);
                     id        = bndExp->GetGeom()->GetGlobalID();
                     gid       = traceElmtGid[meshTraceId.find(id)->second];
                     bndOffset = bndCondExp[i]->GetCoeff_Offset(j) + bndTotal;
 
                     // Since boundary information is defined to be aligned with
                     // the geometry just use forward/forward (both coordinate
                     // directions) defintiion for gid's
                     for(k = 0; k < bndExp->GetNcoeffs(); ++k)
                     {
                         m_bndCondCoeffsToGlobalCoeffsMap[bndOffset+k] = gid + k;
                     }
                 }
 
                 nbndexp  += bndCondExp[i]->GetExpSize();
                 bndTotal += bndCondExp[i]->GetNcoeffs();
             }
 
             m_numGlobalBndCoeffs = trace->GetNcoeffs();
             m_numGlobalCoeffs    = m_numGlobalBndCoeffs;
 
             CalculateBndSystemBandWidth();
 
             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);
                 }
             }
 
             cnt = 0;
             m_bndCondTraceToGlobalTraceMap = Array<OneD, int>(nbndexp);
             for(i = 0; i < bndCondExp.num_elements(); ++i)
             {
                 for(j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
                 {
                     bndExp    = bndCondExp[i]->GetExp(j);
                     traceGeom = bndExp->GetGeom();
                     id        = traceGeom->GetGlobalID();
                     m_bndCondTraceToGlobalTraceMap[cnt++] =
                         meshTraceId.find(id)->second;
                 }
             }
 
             // Now set up mapping from global coefficients to universal.
             ExpListSharedPtr tr = boost::dynamic_pointer_cast<ExpList>(trace);
             SetUpUniversalDGMap   (locExp);
             SetUpUniversalTraceMap(locExp, tr, periodicTrace);
 
             m_hash = boost::hash_range(m_localToGlobalBndMap.begin(),
                                        m_localToGlobalBndMap.end());
         }

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

virtual

Destructor.

Definition at line 66 of file AssemblyMapDG.cpp.

67 {

68 }

Member Function Documentation

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

Definition at line 1035 of file AssemblyMapDG.cpp.

References ASSERTL1, and m_elmtToTrace.

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

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

Definition at line 1043 of file AssemblyMapDG.cpp.

References m_elmtToTrace.

         {
             return m_elmtToTrace;
         }

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

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

Definition at line 1029 of file AssemblyMapDG.cpp.

References m_numDirichletBndPhys.

         {
             return m_numDirichletBndPhys;
         }

int Nektar::MultiRegions::AssemblyMapDG::GetTraceToUniversalMap ( int i )

Definition at line 1019 of file AssemblyMapDG.cpp.

References m_traceToUniversalMap.

         {
             return m_traceToUniversalMap[i];
         }

int Nektar::MultiRegions::AssemblyMapDG::GetTraceToUniversalMapUnique ( int i )

Definition at line 1024 of file AssemblyMapDG.cpp.

References m_traceToUniversalMapUnique.

         {
             return m_traceToUniversalMapUnique[i];
         }

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

protected

Definition at line 836 of file AssemblyMapDG.cpp.

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 SetUpUniversalTraceMap().

         {
             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);
             }
         }

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 533 of file AssemblyMapDG.cpp.

Referenced by AssemblyMapDG().

         {
             LocalRegions::ExpansionSharedPtr locExpansion;
             int eid       = 0;
             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 if (nDim == 2)
                 {
                     for (j = 0; j < locExpansion->GetNedges(); ++j)
                     {
                         dof    = locExpansion->GetEdgeNcoeffs(j);
                         maxDof = (dof > maxDof ? dof : maxDof);
                     }
                 }
                 else if (nDim == 3)
                 {
                     for (j = 0; j < locExpansion->GetNfaces(); ++j)
                     {
                         dof    = locExpansion->GetFaceNcoeffs(j);
                         maxDof = (dof > maxDof ? dof : maxDof);
                     }
                 }
             }
             m_comm->AllReduce(maxDof, LibUtilities::ReduceMax);
 
             // Now have trace edges Gid position
             cnt = 0;
             for(i = 0; i < locExpVector.size(); ++i)
             {
                 eid = i;
                 locExpansion = locExpVector[eid];
                 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[eid][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->GetNedges(); ++j)
                     {
                         LocalRegions::SegExpSharedPtr locSegExp =
                             m_elmtToTrace[eid][j]->as<LocalRegions::SegExp>();
 
                         id  = locSegExp->GetGeom1D()->GetEid();
                         order_e = locExpansion->GetEdgeNcoeffs(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->GetEdgeToElementMap(j, StdRegions::eForwards, map1, sign1);
                         locExpansion->GetEdgeToElementMap(j, locExpansion->GetEorient(j), map2, sign2);
 
                         for (k = 0; k < map1.num_elements(); ++k)
                         {
                             // Find the elemental co-efficient in the original
                             // mapping.
                             int idx = -1;
                             for (int l = 0; l < map2.num_elements(); ++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)
                 {
                     for(j = 0; j < locExpansion->GetNfaces(); ++j)
                     {
                         LocalRegions::Expansion2DSharedPtr locFaceExp =
                                 m_elmtToTrace[eid][j]
                                            ->as<LocalRegions::Expansion2D>();
 
                         id  = locFaceExp->GetGeom2D()->GetFid();
                         order_e = locExpansion->GetFaceNcoeffs(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->GetFaceToElementMap(j, StdRegions::eDir1FwdDir1_Dir2FwdDir2, map1, sign1);
                         locExpansion->GetFaceToElementMap(j, locExpansion->GetForient(j), map2, sign2);
 
                         for (k = 0; k < map1.num_elements(); ++k)
                         {
                             // Find the elemental co-efficient in the original
                             // mapping.
                             int idx = -1;
                             for (int l = 0; l < map2.num_elements(); ++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.num_elements());
             for (i = 0; i < m_globalToUniversalBndMap.num_elements(); ++i)
             {
                 tmp[i] = m_globalToUniversalBndMap[i];
             }
             m_bndGsh = m_gsh = Gs::Init(tmp, m_comm);
             Gs::Unique(tmp, m_comm);
             for (i = 0; i < m_globalToUniversalBndMap.num_elements(); ++i)
             {
                 m_globalToUniversalBndMapUnique[i] = (tmp[i] >= 0 ? 1 : 0);
             }
         }

void Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalTraceMap	(	const ExpList &	locExp,
		const ExpListSharedPtr	trace,
		const PeriodicMap &	perMap = `NullPeriodicMap`
	)

protected

Definition at line 711 of file AssemblyMapDG.cpp.

References Nektar::MultiRegions::ExpList::GetExp(), Nektar::MultiRegions::_PeriodicEntity::id, Gs::Init(), Nektar::MultiRegions::_PeriodicEntity::isLocal, Nektar::MultiRegions::AssemblyMap::m_comm, m_traceGsh, m_traceToUniversalMap, m_traceToUniversalMapUnique, RealignTraceElement(), Nektar::LibUtilities::ReduceMax, and Gs::Unique().

Referenced by AssemblyMapDG().

         {
             Array<OneD, int> tmp;
             LocalRegions::ExpansionSharedPtr locExpansion;
             int i;
             int maxQuad = 0, quad = 0, nDim = 0, eid = 0, offset = 0;
 
             const LocalRegions::ExpansionVector &locExpVector = *(locExp.GetExp());
 
             int nTracePhys = trace->GetTotPoints();
 
             // Initialise the trace to universal maps.
             m_traceToUniversalMap       =
                 Nektar::Array<OneD, int>(nTracePhys, -1);
             m_traceToUniversalMapUnique =
                 Nektar::Array<OneD, int>(nTracePhys, -1);
 
             // Assume that each element of the expansion is of the same
             // dimension.
             nDim = locExpVector[0]->GetShapeDimension();
 
             if (nDim == 1)
             {
                 maxQuad = (1 > maxQuad ? 1 : maxQuad);
             }
             else
             {
                 for (i = 0; i < trace->GetExpSize(); ++i)
                 {
                     quad = trace->GetExp(i)->GetTotPoints();
                     if (quad > maxQuad)
                     {
                         maxQuad = quad;
                     }
                 }
             }
             m_comm->AllReduce(maxQuad, LibUtilities::ReduceMax);
 
             if (nDim == 1)
             {
                 for (int i = 0; i < trace->GetExpSize(); ++i)
                 {
                     eid = trace->GetExp(i)->GetGeom()->GetGlobalID();
                     offset = trace->GetPhys_Offset(i);
 
                     // Check to see if this vert is periodic. If it is, then we
                     // need use the unique eid of the two points
                     PeriodicMap::const_iterator it = perMap.find(eid);
                     if (perMap.count(eid) > 0)
                     {
                         PeriodicEntity ent = it->second[0];
                         if (ent.isLocal == false) // Not sure if true in 1D
                         {
                             eid = min(eid, ent.id);
                         }
                     }
 
                     m_traceToUniversalMap[offset] = eid*maxQuad+1;
                 }
             }
             else
             {
                 for (int i = 0; i < trace->GetExpSize(); ++i)
                 {
                     eid    = trace->GetExp(i)->GetGeom()->GetGlobalID();
                     offset = trace->GetPhys_Offset(i);
                     quad   = trace->GetExp(i)->GetTotPoints();
 
                     // Check to see if this edge is periodic. If it is, then we
                     // need to reverse the trace order of one edge only in the
                     // universal map so that the data are reversed w.r.t each
                     // other. We do this by using the minimum of the two IDs.
                     PeriodicMap::const_iterator it = perMap.find(eid);
                     bool realign = false;
                     if (perMap.count(eid) > 0)
                     {
                         PeriodicEntity ent = it->second[0];
                         if (ent.isLocal == false)
                         {
                             realign = eid == min(eid, ent.id);
                             eid = min(eid, ent.id);
                         }
                     }
 
                     for (int j = 0; j < quad; ++j)
                     {
                         m_traceToUniversalMap[j+offset] = eid*maxQuad+j+1;
                     }
 
                     if (realign)
                     {
                         if (nDim == 2)
                         {
                             RealignTraceElement(
                                 tmp = m_traceToUniversalMap+offset,
                                 it->second[0].orient, quad);
                         }
                         else
                         {
                             RealignTraceElement(
                                 tmp = m_traceToUniversalMap+offset,
                                 it->second[0].orient,
                                 trace->GetExp(i)->GetNumPoints(0),
                                 trace->GetExp(i)->GetNumPoints(1));
                         }
                     }
                 }
             }
 
             Array<OneD, long> tmp2(nTracePhys);
             for (int i = 0; i < nTracePhys; ++i)
             {
                 tmp2[i] = m_traceToUniversalMap[i];
             }
             m_traceGsh = Gs::Init(tmp2, m_comm);
             Gs::Unique(tmp2, m_comm);
             for (int i = 0; i < nTracePhys; ++i)
             {
                 m_traceToUniversalMapUnique[i] = tmp2[i];
             }
         }

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

Definition at line 916 of file AssemblyMapDG.cpp.

References Gs::Gather(), Gs::gs_add, and m_traceGsh.

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

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 988 of file AssemblyMapDG.cpp.

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

         {
             AssembleBnd(loc,global);
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 995 of file AssemblyMapDG.cpp.

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

         {
             AssembleBnd(loc,global);
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 1014 of file AssemblyMapDG.cpp.

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

         {
             return GetBndSystemBandWidth();
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 927 of file AssemblyMapDG.cpp.

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

         {
             return m_globalToUniversalBndMap[i];
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 942 of file AssemblyMapDG.cpp.

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

         {
             return m_globalToUniversalBndMap;
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 932 of file AssemblyMapDG.cpp.

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

         {
             return m_globalToUniversalBndMapUnique[i];
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 947 of file AssemblyMapDG.cpp.

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

         {
             return m_globalToUniversalBndMapUnique;
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 922 of file AssemblyMapDG.cpp.

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

         {
             return m_localToGlobalBndMap[i];
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 937 of file AssemblyMapDG.cpp.

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

         {
             return m_localToGlobalBndMap;
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 952 of file AssemblyMapDG.cpp.

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

         {
             return GetLocalToGlobalBndSign(i);
         }

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 974 of file AssemblyMapDG.cpp.

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

         {
             GlobalToLocalBnd(global,loc);
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 981 of file AssemblyMapDG.cpp.

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

         {
             GlobalToLocalBnd(global,loc);
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 958 of file AssemblyMapDG.cpp.

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

         {
             AssembleBnd(loc,global);
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 966 of file AssemblyMapDG.cpp.

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

         {
             AssembleBnd(loc,global);
         }

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

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 1002 of file AssemblyMapDG.cpp.

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

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

void Nektar::MultiRegions::AssemblyMapDG::v_UniversalAssemble ( NekVector< NekDouble > & pGlobal ) const

protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 1008 of file AssemblyMapDG.cpp.

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

         {
             UniversalAssemble(pGlobal.GetPtr());
         }

Member Data Documentation

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

protected

list of edge expansions for a given element

Definition at line 100 of file AssemblyMapDG.h.

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

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().

Gs::gs_data* Nektar::MultiRegions::AssemblyMapDG::m_traceGsh

protected

Definition at line 94 of file AssemblyMapDG.h.

Referenced by SetUpUniversalTraceMap(), and UniversalTraceAssemble().

Array<OneD,int> Nektar::MultiRegions::AssemblyMapDG::m_traceToUniversalMap

protected

Integer map of process trace space quadrature points to universal space.

Definition at line 103 of file AssemblyMapDG.h.

Referenced by GetTraceToUniversalMap(), and SetUpUniversalTraceMap().

Array<OneD,int> Nektar::MultiRegions::AssemblyMapDG::m_traceToUniversalMapUnique

protected

Integer map of unique process trace space quadrature points to universal space (signed).

Definition at line 106 of file AssemblyMapDG.h.

Referenced by GetTraceToUniversalMapUnique(), and SetUpUniversalTraceMap().

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation