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 ExpList0DSharedPtr &trace, const ExpList &locExp, const Array< OneD, const MultiRegions::ExpListSharedPtr > &bndConstraint, const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > &bndCond, const PeriodicMap &periodicVerts, const std::string variable="DefaultVar")
 Constructor for trace map for one-dimensional expansion.
 AssemblyMapDG (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &graph2D, const ExpList1DSharedPtr &trace, const ExpList &locExp, const Array< OneD, MultiRegions::ExpListSharedPtr > &bndContraint, const Array< OneD, SpatialDomains::BoundaryConditionShPtr > &bndCond, const PeriodicMap &periodicEdges, const std::string variable="DefaultVar")
 Constructor for trace map for two-dimensional expansion.
 AssemblyMapDG (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &graph3D, const ExpList2DSharedPtr &trace, const ExpList &locExp, const Array< OneD, MultiRegions::ExpListSharedPtr > &bndConstraint, const Array< OneD, SpatialDomains::BoundaryConditionShPtr > &bndCond, const PeriodicMap &periodicFaces, const std::string variable="DefaultVar")
 Constructor for trace map for three-dimensional expansion.
virtual ~AssemblyMapDG ()
 Destructor.
int GetNumDirichletBndPhys ()
 Return the number of boundary segments on which Dirichlet boundary conditions are imposed.
Array< OneD,
StdRegions::StdExpansionSharedPtr > & 		GetElmtToTrace (const int i)
Array< OneD, Array< OneD,
StdRegions::StdExpansionSharedPtr > > & 		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,
StdRegions::StdExpansionSharedPtr > > 		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 ExpList0DSharedPtr &  trace,
const ExpList &  locExp,
const Array< OneD, const MultiRegions::ExpListSharedPtr > &  bndConstraint,
const Array< OneD, const SpatialDomains::BoundaryConditionShPtr > &  bndCond,
const PeriodicMap &  periodicVerts,
const std::string  variable = "DefaultVar" 
)

Constructor for trace map for one-dimensional expansion.

Definition at line 73 of file AssemblyMapDG.cpp.

References ASSERTL0, Nektar::MultiRegions::AssemblyMap::CalculateBndSystemBandWidth(), Nektar::SpatialDomains::eDirichlet, Nektar::MultiRegions::ExpList::GetExp(), Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToGlobalCoeffsMap, Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToGlobalCoeffsSign, Nektar::MultiRegions::AssemblyMap::m_bndCondTraceToGlobalTraceMap, m_elmtToTrace, Nektar::MultiRegions::AssemblyMap::m_hash, Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndMap, Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndSign, 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_staticCondLevel, SetUpUniversalDGMap(), and SetUpUniversalTraceMap().

: AssemblyMap(pSession,variable)
{
int i,j;
int cnt, vid, gid;
int ntrace_exp = trace->GetExpSize();
int nbnd = bndCondExp.num_elements();
int nel = locExp.GetExp()->size();
map<int, int> MeshVertId;
// determine mapping from geometry edges to trace
for(i = 0; i < ntrace_exp; ++i)
{
int id = trace->GetExp(i)->GetGeom()->GetVid(0);
MeshVertId[id] = i;
}
Array<OneD, StdRegions::StdExpansionSharedPtr> vertmap(2*nel);
m_elmtToTrace = Array<OneD, Array<OneD,StdRegions::StdExpansionSharedPtr> >(nel);
// set up vert expansions links;
cnt = 0;
for(i = 0; i < nel; ++i)
{
m_elmtToTrace[i] = vertmap + cnt;
for(j = 0; j < locExp.GetExp(i)->GetNverts(); ++j)
{
int id = ((locExp.GetExp(i)->GetGeom())->GetVertex(j))->GetVid();
if(MeshVertId.count(id) > 0)
{
m_elmtToTrace[i][j] = (*trace).GetExp(MeshVertId.find(id)->second)->as<LocalRegions::PointExp>();
}
else
{
ASSERTL0(false,"Failed to find edge map");
}
}
cnt += 2;
}
// set up Local to Continuous mapping
Array<OneD,unsigned int> vmap;
LocalRegions::SegExpSharedPtr locSegExp;
const boost::shared_ptr<LocalRegions::ExpansionVector> exp1D = locExp.GetExp();
m_numGlobalBndCoeffs = exp1D->size()+1;
m_numGlobalCoeffs = m_numGlobalBndCoeffs;
m_numLocalBndCoeffs = 2*exp1D->size();
m_numLocalCoeffs = m_numLocalBndCoeffs;
m_localToGlobalBndMap = Array<OneD, int>(m_numLocalBndCoeffs,-1);
m_localToGlobalBndSign = Array<OneD, NekDouble>(m_numLocalBndCoeffs,1.0);
m_signChange = true;
m_staticCondLevel = 0;
m_numPatches = exp1D->size();
m_numLocalBndCoeffsPerPatch = Array<OneD, unsigned int>(m_numPatches);
m_numLocalIntCoeffsPerPatch = Array<OneD, unsigned int>(m_numPatches);
for(i = 0; i < m_numPatches; ++i)
{
m_numLocalBndCoeffsPerPatch[i] = (unsigned int) (*exp1D)[i]->NumDGBndryCoeffs();
m_numLocalIntCoeffsPerPatch[i] = (unsigned int) 0;
}
map<int, int> MeshVertToLocalVert;
// Order the Dirichlet vertices first.
gid = 0;
for(i = 0; i < nbnd; i++)
{
if(bndCond[i]->GetBoundaryConditionType() == SpatialDomains::eDirichlet)
{
m_numDirichletBndPhys++;
vid = bndCondExp[i]->GetExp(0)->GetGeom()->GetVertex(0)->GetVid();
MeshVertToLocalVert[vid] = gid++;
}
}
// set up simple map based on vertex and edge id's
cnt = 0;
for(i = 0; i < exp1D->size(); ++i)
{
if((locSegExp = (*exp1D)[i]->as<LocalRegions::SegExp>()))
{
locSegExp->GetBoundaryMap(vmap);
for(j = 0; j < locSegExp->GetNverts(); ++j)
{
vid = (locSegExp->GetGeom1D())->GetVid(j);
if(MeshVertToLocalVert.count(vid) == 0)
{
MeshVertToLocalVert[vid] = gid++;
}
m_localToGlobalBndMap[cnt+j] =
MeshVertToLocalVert.find(vid)->second;
}
cnt += locSegExp->NumBndryCoeffs();
}
else
{
ASSERTL0(false,"dynamic cast to a segment expansion failed");
}
}
// Set up boundary mapping
m_bndCondCoeffsToGlobalCoeffsMap = Array<OneD, int >(nbnd);
m_bndCondCoeffsToGlobalCoeffsSign = Array<OneD, NekDouble >(nbnd,1.0);
m_numLocalDirBndCoeffs = 0;
m_numDirichletBndPhys = 0;
for(i = 0; i < nbnd; ++i)
{
vid = bndCondExp[i]->GetExp(0)->GetGeom()->GetVertex(0)->GetVid();
m_bndCondCoeffsToGlobalCoeffsMap[i] = MeshVertToLocalVert.find(vid)->second;
if(bndCond[i]->GetBoundaryConditionType() == SpatialDomains::eDirichlet)
{
m_numLocalDirBndCoeffs += 1;
m_numDirichletBndPhys += 1;
}
}
m_numGlobalDirBndCoeffs = m_numLocalDirBndCoeffs;
CalculateBndSystemBandWidth();
m_bndCondTraceToGlobalTraceMap = Array<OneD, int>(nbnd);
for(i = 0; i < bndCondExp.num_elements(); ++i)
{
int id = bndCondExp[i]->GetExp(0)->GetGeom()->GetVid(0);
m_bndCondTraceToGlobalTraceMap[i] =
MeshVertId.find(id)->second;
}
// Now set up mapping from global coefficients to universal.
#if 1 // Routines need debugging -> Currently causing crash when turned on
ExpListSharedPtr tr = boost::dynamic_pointer_cast<ExpList>(trace);
SetUpUniversalDGMap (locExp);
SetUpUniversalTraceMap(locExp, tr, periodicVerts);
#endif
m_hash = boost::hash_range(m_localToGlobalBndMap.begin(),
m_localToGlobalBndMap.end());
}
Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG ( const LibUtilities::SessionReaderSharedPtr &  pSession,
const SpatialDomains::MeshGraphSharedPtr &  graph2D,
const ExpList1DSharedPtr &  trace,
const ExpList &  locExp,
const Array< OneD, MultiRegions::ExpListSharedPtr > &  bndContraint,
const Array< OneD, SpatialDomains::BoundaryConditionShPtr > &  bndCond,
const PeriodicMap &  periodicEdges,
const std::string  variable = "DefaultVar" 
)

Constructor for trace map for two-dimensional expansion.

Definition at line 238 of file AssemblyMapDG.cpp.

References ASSERTL0, Nektar::MultiRegions::AssemblyMap::CalculateBndSystemBandWidth(), Nektar::MultiRegions::CuthillMckeeReordering(), 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::ePETScStaticCond, Nektar::StdRegions::find(), GetEdge(), Nektar::StdRegions::StdExpansion::GetEdgeNcoeffs(), Nektar::MultiRegions::ExpList::GetExp(), Nektar::LocalRegions::Expansion1D::GetGeom1D(), 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, order_e,gid;
int ntrace_exp = trace->GetExpSize();
int nbnd = bndCondExp.num_elements();
LocalRegions::SegExpSharedPtr locSegExp,locSegExp1;
LocalRegions::QuadExpSharedPtr locQuadExp;
LocalRegions::TriExpSharedPtr locTriExp;
SpatialDomains::Geometry1DSharedPtr SegGeom;
const boost::shared_ptr<LocalRegions::ExpansionVector> exp2D = locExp.GetExp();
int nel = exp2D->size();
map<int, int> MeshEdgeId;
m_signChange = true;
// determine mapping from geometry edges to trace
for(i = 0; i < ntrace_exp; ++i)
{
if((locSegExp = trace->GetExp(i)->as<LocalRegions::SegExp>()))
{
id = (locSegExp->GetGeom1D())->GetEid();
MeshEdgeId[id] = i;
}
else
{
ASSERTL0(false,"Dynamics cast to segment expansion failed");
}
}
// Count total number of edges
cnt = 0;
for(i = 0; i < nel; ++i)
{
cnt += (*exp2D)[i]->GetNedges();
}
Array<OneD, StdRegions::StdExpansionSharedPtr> edgemap(cnt);
m_elmtToTrace = Array<OneD, Array<OneD,StdRegions::StdExpansionSharedPtr> >(nel);
// set up edge expansions links;
cnt = 0;
for(i = 0; i < nel; ++i)
{
m_elmtToTrace[i] = edgemap + cnt;
if((locQuadExp = (*exp2D)[i]->as<LocalRegions::QuadExp>()))
{
for(j = 0; j < locQuadExp->GetNedges(); ++j)
{
SegGeom = (locQuadExp->GetGeom2D())->GetEdge(j);
id = SegGeom->GetEid();
if(MeshEdgeId.count(id) > 0)
{
m_elmtToTrace[i][j] = (*trace).GetExp(MeshEdgeId
.find(id)->second)->as<LocalRegions::SegExp>();
}
else
{
ASSERTL0(false,"Failed to find edge map");
}
}
}
else if((locTriExp = (*exp2D)[i]->as<LocalRegions::TriExp>()))
{
for(j = 0; j < locTriExp->GetNedges(); ++j)
{
SegGeom = (locTriExp->GetGeom2D())->GetEdge(j);
id = SegGeom->GetEid();
if(MeshEdgeId.count(id) > 0)
{
m_elmtToTrace[i][j] = (*trace).GetExp((MeshEdgeId
.find(id))->second)->as<LocalRegions::SegExp>();
}
else
{
ASSERTL0(false,"Failed to find edge map");
}
}
}
else
{
ASSERTL0(false,"dynamic cast to a local 2D expansion failed");
}
cnt += (*exp2D)[i]->GetNedges();
}
// Set up boundary mapping
cnt = 0;
for(i = 0; i < nbnd; ++i)
{
cnt += bndCondExp[i]->GetExpSize();
}
m_numLocalDirBndCoeffs = 0;
m_numDirichletBndPhys = 0;
cnt = 0;
for(i = 0; i < bndCondExp.num_elements(); ++i)
{
for(j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
{
if((locSegExp = bndCondExp[i]->GetExp(j)
->as<LocalRegions::SegExp>()))
{
SegGeom = locSegExp->GetGeom1D();
id = SegGeom->GetEid();
}
else
{
ASSERTL0(false,"dynamic cast to a local Segment expansion failed");
}
if(bndCond[i]->GetBoundaryConditionType() == SpatialDomains::eDirichlet)
{
m_numLocalDirBndCoeffs += locSegExp->GetNcoeffs();
m_numDirichletBndPhys += locSegExp->GetTotPoints();
}
}
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 += (*exp2D)[eid]->NumDGBndryCoeffs();
m_numLocalBndCoeffsPerPatch[i] = (unsigned int) (*exp2D)[eid]->NumDGBndryCoeffs();
m_numLocalIntCoeffsPerPatch[i] = (unsigned int) 0;
}
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(ntrace_exp,-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;
// make trace edge renumbering map where first solved
// edge starts at 0 so we can set up graph.
for(i = 0; i < ntrace_exp; ++i)
{
if(trace->GetCoeff_Offset(i) >= m_numLocalDirBndCoeffs)
{
// 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] = trace->GetCoeff_Offset(i);
nDir++;
}
}
// Set up boost Graph
for(i = 0; i < nel; ++i)
{
eid = locExp.GetOffset_Elmt_Id(i);
nbndry += (*exp2D)[eid]->NumDGBndryCoeffs();
for(j = 0; j < (*exp2D)[eid]->GetNedges(); ++j)
{
locSegExp = m_elmtToTrace[eid][j]->as<LocalRegions::SegExp>();
SegGeom = locSegExp->GetGeom1D();
// Add edge to boost graph for non-Dirichlet Boundary
id = SegGeom->GetEid();
trace_id = MeshEdgeId.find(id)->second;
if(trace->GetCoeff_Offset(trace_id) >= m_numLocalDirBndCoeffs)
{
for(k = j+1; k < (*exp2D)[eid]->GetNedges(); ++k)
{
locSegExp1 = m_elmtToTrace[eid][k]->as<LocalRegions::SegExp>();
SegGeom = locSegExp1->GetGeom1D();
id1 = SegGeom->GetEid();
trace_id1 = MeshEdgeId.find(id1)->second;
if(trace->GetCoeff_Offset(trace_id1)
>= m_numLocalDirBndCoeffs)
{
boost::add_edge( (size_t) TraceElmtGid[trace_id], (size_t) TraceElmtGid[trace_id1], boostGraphObj);
}
}
}
}
}
int nGraphVerts = ntrace_exp-nDir;
Array<OneD, int> perm(nGraphVerts);
Array<OneD, int> iperm(nGraphVerts);
BottomUpSubStructuredGraphSharedPtr bottomUpGraph;
Array<OneD, int> vwgts(nGraphVerts);
for(i = 0; i < nGraphVerts; ++i)
{
vwgts[i] = trace->GetExp(i+nDir)->GetNcoeffs();
}
if(nGraphVerts)
{
switch(m_solnType)
{
case eDirectFullMatrix:
case eIterativeFull:
case ePETScFullMatrix:
case ePETScStaticCond:
case eIterativeStaticCond:
{
NoReordering(boostGraphObj,perm,iperm);
break;
}
case eDirectStaticCond:
{
CuthillMckeeReordering(boostGraphObj,perm,iperm);
break;
}
case eDirectMultiLevelStaticCond:
case eIterativeMultiLevelStaticCond:
{
MultiLevelBisectionReordering(boostGraphObj,perm,iperm,bottomUpGraph);
break;
}
default:
{
ASSERTL0(false,"Unrecognised solution type");
}
}
}
// Recast the permutation so that it can be
// used as a map Form old trace edge ID to new trace
// edge ID
cnt = m_numLocalDirBndCoeffs;
for(i = 0; i < ntrace_exp-nDir; ++i)
{
TraceElmtGid[perm[i]+nDir]=cnt;
cnt += trace->GetExp(perm[i]+nDir)->GetNcoeffs();
}
// Now have trace edges Gid position
nbndry = cnt = 0;
for(i = 0; i < nel; ++i)
{
// order list according to m_offset_elmt_id details in
// Exp2D so that triangules are listed first and then
// quads
eid = locExp.GetOffset_Elmt_Id(i);
nbndry += (*exp2D)[eid]->NumDGBndryCoeffs();
for(j = 0; j < (*exp2D)[eid]->GetNedges(); ++j)
{
locSegExp = m_elmtToTrace[eid][j]->as<LocalRegions::SegExp>();
SegGeom = locSegExp->GetGeom1D();
id = SegGeom->GetEid();
gid = TraceElmtGid[MeshEdgeId.find(id)->second];
//Peter order_e = locSegExp->GetNcoeffs();
order_e = (*exp2D)[eid]->GetEdgeNcoeffs(j);
if((*exp2D)[eid]->GetEorient(j) == StdRegions::eForwards)
{
for(k = 0; k < order_e; ++k)
{
m_localToGlobalBndMap[k+cnt] = gid + k;
}
}
else // backwards orientated
{
switch(locSegExp->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");
}
}
}
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;
for(cnt = i = 0; i < nbnd; ++i)
{
for(j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
{
if((locSegExp = bndCondExp[i]->GetExp(j)
->as<LocalRegions::SegExp>()))
{
nbndexp++;
SegGeom = locSegExp->GetGeom1D();
id = SegGeom->GetEid();
gid = TraceElmtGid[MeshEdgeId.find(id)->second];
order_e = locSegExp->GetNcoeffs();
// Since boundary information is defined to be
// aligned with the geometry just use forward
// defintiion for gid's
for(k = 0; k < order_e; ++k)
{
m_bndCondCoeffsToGlobalCoeffsMap[cnt++] = gid + k;
}
}
}
}
m_numGlobalBndCoeffs = trace->GetNcoeffs();
m_numGlobalCoeffs = m_numGlobalBndCoeffs;
CalculateBndSystemBandWidth();
if( m_solnType == eDirectMultiLevelStaticCond && 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)
{
if((locSegExp = bndCondExp[i]->GetExp(j)
->as<LocalRegions::SegExp>()))
{
SegGeom = locSegExp->GetGeom1D();
id = SegGeom->GetEid();
m_bndCondTraceToGlobalTraceMap[cnt++] = MeshEdgeId.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, periodicEdges);
m_hash = boost::hash_range(m_localToGlobalBndMap.begin(),
m_localToGlobalBndMap.end());
}
Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG ( const LibUtilities::SessionReaderSharedPtr &  pSession,
const SpatialDomains::MeshGraphSharedPtr &  graph3D,
const ExpList2DSharedPtr &  trace,
const ExpList &  locExp,
const Array< OneD, MultiRegions::ExpListSharedPtr > &  bndCondExp,
const Array< OneD, SpatialDomains::BoundaryConditionShPtr > &  bndCond,
const PeriodicMap &  periodicFaces,
const std::string  variable = "DefaultVar" 
)

Constructor for trace map for three-dimensional expansion.

Definition at line 685 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::MultiRegions::eIterativeFull, Nektar::MultiRegions::eIterativeMultiLevelStaticCond, Nektar::MultiRegions::eIterativeStaticCond, Nektar::MultiRegions::ePETScFullMatrix, Nektar::MultiRegions::ePETScStaticCond, 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, order_e,gid;
int ntrace_exp = trace->GetExpSize();
int nbnd = bndCondExp.num_elements();
LocalRegions::QuadExpSharedPtr locQuadExp, locQuadExp1;
LocalRegions::TriExpSharedPtr locTriExp, locTriExp1;
LocalRegions::HexExpSharedPtr locHexExp;
LocalRegions::PrismExpSharedPtr locPrismExp;
LocalRegions::PyrExpSharedPtr locPyrExp;
LocalRegions::TetExpSharedPtr locTetExp;
SpatialDomains::Geometry2DSharedPtr FaceGeom;
StdRegions::StdExpansionSharedPtr locBndExp;
const boost::shared_ptr<LocalRegions::ExpansionVector> exp3D =
locExp.GetExp();
int nel = exp3D->size();
map<int, int> MeshFaceId;
m_signChange = true;
// determine mapping from geometry edges to trace
for(i = 0; i < ntrace_exp; ++i)
{
id = trace->GetExp(i)->as<LocalRegions::Expansion2D>()
->GetGeom2D()->GetFid();
MeshFaceId[id] = i;
}
// Count total number of faces
cnt = 0;
for(i = 0; i < nel; ++i)
{
cnt += (*exp3D)[i]->GetNfaces();
}
Array<OneD, StdRegions::StdExpansionSharedPtr> facemap(cnt);
m_elmtToTrace = Array<OneD,
Array<OneD, StdRegions::StdExpansionSharedPtr> >(nel);
// set up face expansions links;
cnt = 0;
for(i = 0; i < nel; ++i)
{
m_elmtToTrace[i] = facemap + cnt;
for(j = 0; j < (*exp3D)[i]->GetNfaces(); ++j)
{
id = (*exp3D)[i]->as<LocalRegions::Expansion3D>()
->GetGeom3D()->GetFid(j);
if(MeshFaceId.count(id) > 0)
{
m_elmtToTrace[i][j] =
trace->GetExp(MeshFaceId.find(id)->second);
}
else
{
ASSERTL0(false,"Failed to find face map");
}
}
cnt += (*exp3D)[i]->GetNfaces();
}
// Set up boundary mapping
cnt = 0;
for(i = 0; i < nbnd; ++i)
{
cnt += bndCondExp[i]->GetExpSize();
}
set<int> dirFaces;
m_numLocalDirBndCoeffs = 0;
m_numDirichletBndPhys = 0;
cnt = 0;
for(i = 0; i < bndCondExp.num_elements(); ++i)
{
for(j = 0; j < bndCondExp[i]->GetExpSize(); ++j)
{
locBndExp = bndCondExp[i]->GetExp(j);
FaceGeom = locBndExp->as<LocalRegions::Expansion2D>()
->GetGeom2D();
id = FaceGeom->GetFid();
if(bndCond[i]->GetBoundaryConditionType() ==
SpatialDomains::eDirichlet)
{
m_numLocalDirBndCoeffs += locBndExp->GetNcoeffs();
m_numDirichletBndPhys += locBndExp->GetTotPoints();
dirFaces.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 += (*exp3D)[eid]->NumDGBndryCoeffs();
m_numLocalBndCoeffsPerPatch[i] = (unsigned int) (*exp3D)[eid]->NumDGBndryCoeffs();
m_numLocalIntCoeffsPerPatch[i] = (unsigned int) 0;
}
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> FaceElmtGid(ntrace_exp,-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 face_id, face_id1;
int dirOffset = 0;
// make trace face renumbering map where first solved
// face starts at 0 so we can set up graph.
for(i = 0; i < ntrace_exp; ++i)
{
id = trace->GetExp(i)->as<LocalRegions::Expansion2D>()
->GetGeom2D()->GetFid();
if (dirFaces.count(id) == 0)
{
// Initial put in element ordering (starting
// from zero) into FaceElmtGid
boost::add_vertex(boostGraphObj);
FaceElmtGid[i] = cnt++;
}
else
{
// Use existing offset for Dirichlet edges
FaceElmtGid[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 < (*exp3D)[eid]->GetNfaces(); ++j)
{
// Add face to boost graph for non-Dirichlet Boundary
FaceGeom = m_elmtToTrace[eid][j]
->as<LocalRegions::Expansion2D>()->GetGeom2D();
id = FaceGeom->GetFid();
face_id = MeshFaceId.find(id)->second;
if(dirFaces.count(id) == 0)
{
for(k = j+1; k < (*exp3D)[eid]->GetNfaces(); ++k)
{
FaceGeom = m_elmtToTrace[eid][k]
->as<LocalRegions::Expansion2D>()->GetGeom2D();
id1 = FaceGeom->GetFid();
face_id1 = MeshFaceId.find(id1)->second;
if(dirFaces.count(id1) == 0)
{
boost::add_edge((size_t) FaceElmtGid[face_id],
(size_t) FaceElmtGid[face_id1],
boostGraphObj);
}
}
}
}
}
int nGraphVerts = ntrace_exp - 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 ePETScFullMatrix:
case ePETScStaticCond:
{
NoReordering(boostGraphObj,perm,iperm);
break;
}
case eDirectStaticCond:
{
CuthillMckeeReordering(boostGraphObj,perm,iperm);
break;
}
case eDirectMultiLevelStaticCond:
case eIterativeMultiLevelStaticCond:
{
MultiLevelBisectionReordering(boostGraphObj,perm,iperm,
bottomUpGraph);
break;
}
default:
{
ASSERTL0(false,"Unrecognised solution type");
}
}
}
// Recast the permutation so that it can be used as a map Form old
// trace face ID to new trace face ID
cnt = m_numLocalDirBndCoeffs;
for(i = 0; i < ntrace_exp - nDir; ++i)
{
FaceElmtGid[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 Exp3D
eid = locExp.GetOffset_Elmt_Id(i);
for(j = 0; j < (*exp3D)[eid]->GetNfaces(); ++j)
{
FaceGeom = m_elmtToTrace[eid][j]
->as<LocalRegions::Expansion2D>()->GetGeom2D();
id = FaceGeom->GetFid();
gid = FaceElmtGid[MeshFaceId.find(id)->second];
order_e = (*exp3D)[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 = (*exp3D)[eid]->GetFaceOrient(j);
// Construct mapping which will permute global IDs
// according to face orientations.
(*exp3D)[eid]->GetFaceToElementMap(j,fo,elmMap1,elmSign1);
(*exp3D)[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)
{
locBndExp = bndCondExp[i]->GetExp(j);
id = locBndExp->as<LocalRegions::Expansion2D>()
->GetGeom2D()->GetFid();
gid = FaceElmtGid[MeshFaceId.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 < locBndExp->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 && 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)
{
locBndExp = bndCondExp[i]->GetExp(j);
FaceGeom = locBndExp->as<LocalRegions::Expansion2D>()
->GetGeom2D();
id = FaceGeom->GetFid();
m_bndCondTraceToGlobalTraceMap[cnt++] =
MeshFaceId.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, periodicFaces);
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, StdRegions::StdExpansionSharedPtr > & Nektar::MultiRegions::AssemblyMapDG::GetElmtToTrace ( const int  i)

Definition at line 1593 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, StdRegions::StdExpansionSharedPtr > > & Nektar::MultiRegions::AssemblyMapDG::GetElmtToTrace ( )

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

References m_numDirichletBndPhys.

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

Definition at line 1577 of file AssemblyMapDG.cpp.

References m_traceToUniversalMap.

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

Definition at line 1582 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 1396 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 1086 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(), Nektar::StdRegions::StdExpansion::GetShapeDimension(), 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().

{
StdRegions::StdExpansionSharedPtr 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 = boost::dynamic_pointer_cast<
StdRegions::StdExpansion>(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 = boost::dynamic_pointer_cast<
StdRegions::StdExpansion>(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]->GetFaceOrient(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 1269 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;
StdRegions::StdExpansionSharedPtr 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);
#if 1
// 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);
}
}
#endif
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 1476 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 1546 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 1553 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 1572 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 1487 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 1502 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 1492 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 1507 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 1482 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 1497 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 1512 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 1532 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 1539 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 1518 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 1525 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 1560 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 1566 of file AssemblyMapDG.cpp.

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

{
UniversalAssemble(pGlobal.GetPtr());
}

Member Data Documentation

Array<OneD, Array<OneD, StdRegions::StdExpansionSharedPtr> > Nektar::MultiRegions::AssemblyMapDG::m_elmtToTrace
protected

list of edge expansions for a given element

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

Referenced by AssemblyMapDG(), and GetNumDirichletBndPhys().

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

Definition at line 120 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 129 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 132 of file AssemblyMapDG.h.

Referenced by GetTraceToUniversalMapUnique(), and SetUpUniversalTraceMap().

Generated on Sun Mar 15 2015 00:11:58 for Nektar++ by   doxygen 1.8.1.2