Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Nektar::MultiRegions::AssemblyMapDG Class Reference

#include <AssemblyMapDG.h>

Inheritance diagram for Nektar::MultiRegions::AssemblyMapDG:
Inheritance graph
[legend]
Collaboration diagram for Nektar::MultiRegions::AssemblyMapDG:
Collaboration graph
[legend]

Public Member Functions

 AssemblyMapDG ()
 Default constructor.
 AssemblyMapDG (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &graph1D, const ExpListSharedPtr &trace, const ExpList &locExp, const Array< OneD, const MultiRegions::ExpListSharedPtr > &bndConstraint, const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > &bndCond, const PeriodicMap &periodicTrace, const std::string variable="DefaultVar")
 Constructor for trace map for one-dimensional expansion.
virtual ~AssemblyMapDG ()
 Destructor.
int GetNumDirichletBndPhys ()
 Return the number of boundary segments on which Dirichlet boundary conditions are imposed.
Array< OneD,
LocalRegions::ExpansionSharedPtr > & 		GetElmtToTrace (const int i)
Array< OneD, Array< OneD,
LocalRegions::ExpansionSharedPtr > > & 		GetElmtToTrace ()
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.
 AssemblyMap (const LibUtilities::SessionReaderSharedPtr &pSession, const std::string variable="DefaultVar")
 Constructor with a communicator.
 AssemblyMap (AssemblyMap *oldLevelMap, const BottomUpSubStructuredGraphSharedPtr &multiLevelGraph)
 Constructor for next level in multi-level static condensation.
virtual ~AssemblyMap ()
 Destructor.
LibUtilities::CommSharedPtr GetComm ()
 Retrieves the communicator.
size_t GetHash () const
 Retrieves the hash of this map.
int GetLocalToGlobalMap (const int i) const
int GetGlobalToUniversalMap (const int i) const
int GetGlobalToUniversalMapUnique (const int i) const
const Array< OneD, const int > & GetLocalToGlobalMap ()
const Array< OneD, const int > & GetGlobalToUniversalMap ()
const Array< OneD, const int > & GetGlobalToUniversalMapUnique ()
NekDouble GetLocalToGlobalSign (const int i) const
const Array< OneD, NekDouble > & GetLocalToGlobalSign () const
void LocalToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const
void LocalToGlobal (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) 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.
const Array< OneD, const int > & GetLocalToGlobalBndMap ()
 Retrieve the global indices of the local boundary modes.
const Array< OneD, const int > & GetGlobalToUniversalBndMap ()
const Array< OneD, const int > & GetGlobalToUniversalBndMapUnique ()
bool GetSignChange ()
 Returns true if using a modal expansion requiring a change of sign of some modes.
NekDouble GetLocalToGlobalBndSign (const int i) const
 Retrieve the sign change of a given local boundary mode.
Array< OneD, const NekDouble > GetLocalToGlobalBndSign () const
 Retrieve the sign change for all local boundary modes.
int GetBndCondCoeffsToGlobalCoeffsMap (const int i)
 Retrieves the global index corresponding to a boundary expansion mode.
const Array< OneD, const int > & GetBndCondCoeffsToGlobalCoeffsMap ()
 Retrieves the global indices corresponding to the boundary expansion modes.
NekDouble GetBndCondCoeffsToGlobalCoeffsSign (const int i)
 Returns the modal sign associated with a given boundary expansion mode.
int GetBndCondTraceToGlobalTraceMap (const int i)
 Returns the global index of the boundary trace giving the index on the boundary expansion.
const Array< OneD, const int > & GetBndCondTraceToGlobalTraceMap ()
int GetNumGlobalDirBndCoeffs () const
 Returns the number of global Dirichlet boundary coefficients.
int GetNumLocalDirBndCoeffs () const
 Returns the number of local Dirichlet boundary coefficients.
int GetNumGlobalBndCoeffs () const
 Returns the total number of global boundary coefficients.
int GetNumLocalBndCoeffs () const
 Returns the total number of local boundary coefficients.
int GetNumLocalCoeffs () const
 Returns the total number of local coefficients.
int GetNumGlobalCoeffs () const
 Returns the total number of global coefficients.
bool GetSingularSystem () const
 Retrieves if the system is singular (true) or not (false)
void GlobalToLocalBnd (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc, int offset) const
void GlobalToLocalBnd (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc) const
void GlobalToLocalBnd (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc, int offset) const
void GlobalToLocalBnd (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const
void LocalBndToGlobal (const 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) 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.
int GetStaticCondLevel () const
 Returns the level of static condensation for this map.
int GetNumPatches () const
 Returns the number of patches in this static condensation level.
const Array< OneD, const
unsigned int > & 		GetNumLocalBndCoeffsPerPatch ()
 Returns the number of local boundary coefficients in each patch.
const Array< OneD, const
unsigned int > & 		GetNumLocalIntCoeffsPerPatch ()
 Returns the number of local interior coefficients in each patch.
const AssemblyMapSharedPtr GetNextLevelLocalToGlobalMap () const
 Returns the local to global mapping for the next level in the multi-level static condensation.
void SetNextLevelLocalToGlobalMap (AssemblyMapSharedPtr pNextLevelLocalToGlobalMap)
const PatchMapSharedPtr & GetPatchMapFromPrevLevel (void) const
 Returns the patch map from the previous level of the multi-level static condensation.
bool AtLastLevel () const
 Returns true if this is the last level in the multi-level static condensation.
GlobalSysSolnType GetGlobalSysSolnType () const
 Returns the method of solving global systems.
PreconditionerType GetPreconType () const
NekDouble GetIterativeTolerance () 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) const
virtual void v_LocalToGlobal (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) 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.
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.
Array< OneD, Array< OneD,
LocalRegions::ExpansionSharedPtr > > 		m_elmtToTrace
 list of edge expansions for a given element
Array< OneD, int > m_traceToUniversalMap
 Integer map of process trace space quadrature points to universal space.
Array< OneD, int > m_traceToUniversalMapUnique
 Integer map of unique process trace space quadrature points to universal space (signed).
- Protected Attributes inherited from Nektar::MultiRegions::AssemblyMap
LibUtilities::SessionReaderSharedPtr m_session
 Session object.
LibUtilities::CommSharedPtr m_comm
 Communicator.
size_t m_hash
 Hash for map.
int m_numLocalBndCoeffs
 Number of local boundary coefficients.
int m_numGlobalBndCoeffs
 Total number of global boundary coefficients.
int m_numLocalDirBndCoeffs
 Number of Local Dirichlet Boundary Coefficients.
int m_numGlobalDirBndCoeffs
 Number of Global Dirichlet Boundary Coefficients.
bool m_systemSingular
 Flag indicating if the system is singular or not.
int m_numLocalCoeffs
 Total number of local coefficients.
int m_numGlobalCoeffs
 Total number of global coefficients.
bool m_signChange
 Flag indicating if modes require sign reversal.
Array< OneD, int > m_localToGlobalBndMap
 Integer map of local boundary coeffs to global space.
Array< OneD, NekDouble > m_localToGlobalBndSign
 Integer sign of local boundary coeffs to global space.
Array< OneD, int > m_bndCondCoeffsToGlobalCoeffsMap
 Integer map of bnd cond coeffs to global coefficients.
Array< OneD, NekDouble > m_bndCondCoeffsToGlobalCoeffsSign
 Integer map of bnd cond coeffs to global coefficients.
Array< OneD, int > m_bndCondTraceToGlobalTraceMap
 Integer map of bnd cond trace number to global trace number.
Array< OneD, int > m_globalToUniversalBndMap
 Integer map of process coeffs to universal space.
Array< OneD, int > m_globalToUniversalBndMapUnique
 Integer map of unique process coeffs to universal space (signed)
GlobalSysSolnType m_solnType
 The solution type of the global system.
int m_bndSystemBandWidth
 The bandwith of the global bnd system.
PreconditionerType m_preconType
 Type type of preconditioner to use in iterative solver.
NekDouble m_iterativeTolerance
 Tolerance for iterative solver.
int m_successiveRHS
 sucessive RHS for iterative solver
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.
int m_numPatches
 The number of patches (~elements) in the current level.
Array< OneD, unsigned int > m_numLocalBndCoeffsPerPatch
 The number of bnd dofs per patch.
Array< OneD, unsigned int > m_numLocalIntCoeffsPerPatch
 The number of int dofs per patch.
AssemblyMapSharedPtr m_nextLevelLocalToGlobalMap
 Map from the patches of the previous level to the patches of the current level.
int m_lowestStaticCondLevel
 Lowest static condensation level.

Detailed Description

Definition at line 53 of file AssemblyMapDG.h.

Constructor & Destructor Documentation

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

Default constructor.

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

References ASSERTL0, ASSERTL2, Nektar::MultiRegions::AssemblyMap::CalculateBndSystemBandWidth(), Nektar::MultiRegions::CuthillMckeeReordering(), Nektar::StdRegions::eDir1FwdDir1_Dir2FwdDir2, Nektar::MultiRegions::eDirectFullMatrix, Nektar::MultiRegions::eDirectMultiLevelStaticCond, Nektar::MultiRegions::eDirectStaticCond, Nektar::SpatialDomains::eDirichlet, Nektar::StdRegions::eForwards, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::MultiRegions::eIterativeFull, Nektar::MultiRegions::eIterativeMultiLevelStaticCond, Nektar::MultiRegions::eIterativeStaticCond, Nektar::LibUtilities::eModified_A, Nektar::MultiRegions::ePETScFullMatrix, Nektar::MultiRegions::ePETScMultiLevelStaticCond, Nektar::MultiRegions::ePETScStaticCond, Nektar::MultiRegions::eXxtFullMatrix, Nektar::MultiRegions::eXxtMultiLevelStaticCond, Nektar::MultiRegions::eXxtStaticCond, Nektar::MultiRegions::ExpList::GetExp(), Nektar::MultiRegions::ExpList::GetOffset_Elmt_Id(), Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToGlobalCoeffsMap, Nektar::MultiRegions::AssemblyMap::m_bndCondTraceToGlobalTraceMap, m_elmtToTrace, Nektar::MultiRegions::AssemblyMap::m_hash, Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndMap, Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndSign, Nektar::MultiRegions::AssemblyMap::m_lowestStaticCondLevel, Nektar::MultiRegions::AssemblyMap::m_nextLevelLocalToGlobalMap, m_numDirichletBndPhys, Nektar::MultiRegions::AssemblyMap::m_numGlobalBndCoeffs, Nektar::MultiRegions::AssemblyMap::m_numGlobalCoeffs, Nektar::MultiRegions::AssemblyMap::m_numGlobalDirBndCoeffs, Nektar::MultiRegions::AssemblyMap::m_numLocalBndCoeffs, Nektar::MultiRegions::AssemblyMap::m_numLocalBndCoeffsPerPatch, Nektar::MultiRegions::AssemblyMap::m_numLocalCoeffs, Nektar::MultiRegions::AssemblyMap::m_numLocalDirBndCoeffs, Nektar::MultiRegions::AssemblyMap::m_numLocalIntCoeffsPerPatch, Nektar::MultiRegions::AssemblyMap::m_numPatches, Nektar::MultiRegions::AssemblyMap::m_signChange, Nektar::MultiRegions::AssemblyMap::m_solnType, Nektar::MultiRegions::AssemblyMap::m_staticCondLevel, Nektar::MultiRegions::MultiLevelBisectionReordering(), Nektar::MultiRegions::NoReordering(), SetUpUniversalDGMap(), and SetUpUniversalTraceMap().

:
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 = locExp.GetOffset_Elmt_Id(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 = locExp.GetOffset_Elmt_Id(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)
{
// order list according to m_offset_elmt_id details in expList
eid = locExp.GetOffset_Elmt_Id(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 65 of file AssemblyMapDG.cpp.

{
}

Member Function Documentation

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

Definition at line 1036 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 1044 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 1030 of file AssemblyMapDG.cpp.

References m_numDirichletBndPhys.

{
return m_numDirichletBndPhys;
}
int Nektar::MultiRegions::AssemblyMapDG::GetTraceToUniversalMap ( int  i)

Definition at line 1020 of file AssemblyMapDG.cpp.

References m_traceToUniversalMap.

{
return m_traceToUniversalMap[i];
}
int Nektar::MultiRegions::AssemblyMapDG::GetTraceToUniversalMapUnique ( int  i)

Definition at line 1025 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 839 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
locExpList of local elemental expansions.

Definition at line 533 of file AssemblyMapDG.cpp.

References ASSERTL2, Nektar::StdRegions::eDir1FwdDir1_Dir2FwdDir2, Nektar::StdRegions::eForwards, Nektar::MultiRegions::ExpList::GetExp(), Nektar::LocalRegions::PointExp::GetGeom(), Nektar::LocalRegions::Expansion1D::GetGeom1D(), Nektar::LocalRegions::Expansion2D::GetGeom2D(), Nektar::MultiRegions::ExpList::GetOffset_Elmt_Id(), Gs::Init(), Nektar::MultiRegions::AssemblyMap::m_bndGsh, Nektar::MultiRegions::AssemblyMap::m_comm, m_elmtToTrace, Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMap, Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMapUnique, Nektar::MultiRegions::AssemblyMap::m_gsh, Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndMap, Nektar::MultiRegions::AssemblyMap::m_numGlobalBndCoeffs, Nektar::LibUtilities::ReduceMax, and Gs::Unique().

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)
{
locExpansion = locExpVector[i];
nDim = locExpansion->GetShapeDimension();
// Order list according to m_offset_elmt_id details in Exp
// so that triangules are listed first and then quads
eid = locExp.GetOffset_Elmt_Id(i);
// 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 = locExpVector[eid]->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);
locExpVector[eid]->GetEdgeToElementMap(j, StdRegions::eForwards, map1, sign1);
locExpVector[eid]->GetEdgeToElementMap(j, locExpVector[eid]->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 = locExpVector[eid]->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);
locExpVector[eid]->GetFaceToElementMap(j, StdRegions::eDir1FwdDir1_Dir2FwdDir2, map1, sign1);
locExpVector[eid]->GetFaceToElementMap(j, locExpVector[eid]->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 714 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 919 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 989 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 996 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 1015 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 930 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 945 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 935 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 950 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 925 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 940 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 955 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 975 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 982 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 
) const
protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 961 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 
) const
protectedvirtual

Reimplemented from Nektar::MultiRegions::AssemblyMap.

Definition at line 968 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 1003 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 1009 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().

Generated on Wed Mar 4 2015 16:33:39 for Nektar++ by   doxygen 1.8.1.2