Nektar++
Public Member Functions | Protected Member Functions | Protected Attributes | Private Attributes | List of all members
Nektar::MultiRegions::AssemblyMap Class Reference

Base class for constructing local to global mapping of degrees of freedom. More...

#include <AssemblyMap.h>

Inheritance diagram for Nektar::MultiRegions::AssemblyMap:
[legend]

Public Member Functions

 AssemblyMap ()
 Default constructor. More...
 
 AssemblyMap (const LibUtilities::SessionReaderSharedPtr &pSession, const LibUtilities::CommSharedPtr &comm, const std::string variable="DefaultVar")
 Constructor with a communicator. More...
 
 AssemblyMap (AssemblyMap *oldLevelMap, const BottomUpSubStructuredGraphSharedPtr &multiLevelGraph)
 Constructor for next level in multi-level static condensation. More...
 
virtual ~AssemblyMap ()
 Destructor. More...
 
LibUtilities::CommSharedPtr GetComm ()
 Retrieves the communicator. More...
 
std::string GetVariable ()
 Retrieves the variable string. More...
 
size_t GetHash () const
 Retrieves the hash of this map. More...
 
int GetLocalToGlobalMap (const int i) const
 
int GetGlobalToUniversalMap (const int i) const
 
int GetGlobalToUniversalMapUnique (const int i) const
 
const Array< OneD, const int > & GetLocalToGlobalMap ()
 
const Array< OneD, const int > & GetGlobalToUniversalMap ()
 
const Array< OneD, const int > & GetGlobalToUniversalMapUnique ()
 
NekDouble GetLocalToGlobalSign (const int i) const
 
const Array< OneD, NekDouble > & GetLocalToGlobalSign () const
 
void LocalToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, bool useComm=true) const
 
void LocalToGlobal (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global, bool useComm=true) const
 
void GlobalToLocal (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const
 
void GlobalToLocal (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc) const
 
void Assemble (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const
 
void Assemble (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) const
 
void UniversalAssemble (Array< OneD, NekDouble > &pGlobal) const
 
void UniversalAssemble (NekVector< NekDouble > &pGlobal) const
 
void UniversalAssemble (Array< OneD, NekDouble > &pGlobal, int offset) const
 
void UniversalAbsMaxBnd (Array< OneD, NekDouble > &bndvals)
 
int GetLocalToGlobalBndMap (const int i) const
 Retrieve the global index of a given local boundary mode. More...
 
const Array< OneD, const int > & GetLocalToGlobalBndMap ()
 Retrieve the global indices of the local boundary modes. More...
 
const Array< OneD, const int > & GetGlobalToUniversalBndMap ()
 
const Array< OneD, const int > & GetGlobalToUniversalBndMapUnique ()
 
bool GetSignChange ()
 Returns true if using a modal expansion requiring a change of sign of some modes. More...
 
NekDouble GetLocalToGlobalBndSign (const int i) const
 Retrieve the sign change of a given local boundary mode. More...
 
Array< OneD, const NekDouble > GetLocalToGlobalBndSign () const
 Retrieve the sign change for all local boundary modes. More...
 
const Array< OneD, const int > & GetBndCondCoeffsToLocalCoeffsMap ()
 Retrieves the local indices corresponding to the boundary expansion modes. More...
 
const Array< OneD, NekDouble > & GetBndCondCoeffsToLocalCoeffsSign ()
 Returns the modal sign associated with a given boundary expansion mode. More...
 
const Array< OneD, const int > & GetBndCondCoeffsToLocalTraceMap ()
 Retrieves the local indices corresponding to the boundary expansion modes to global trace. More...
 
int GetBndCondIDToGlobalTraceID (const int i)
 Returns the global index of the boundary trace giving the index on the boundary expansion. More...
 
const Array< OneD, const int > & GetBndCondIDToGlobalTraceID ()
 
int GetNumGlobalDirBndCoeffs () const
 Returns the number of global Dirichlet boundary coefficients. More...
 
int GetNumLocalDirBndCoeffs () const
 Returns the number of local Dirichlet boundary coefficients. More...
 
int GetNumGlobalBndCoeffs () const
 Returns the total number of global boundary coefficients. More...
 
int GetNumLocalBndCoeffs () const
 Returns the total number of local boundary coefficients. More...
 
int GetNumLocalCoeffs () const
 Returns the total number of local coefficients. More...
 
int GetNumGlobalCoeffs () const
 Returns the total number of global coefficients. More...
 
bool GetSingularSystem () const
 Retrieves if the system is singular (true) or not (false) More...
 
void GlobalToLocalBnd (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc, int offset) const
 
void GlobalToLocalBnd (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc) const
 
void GlobalToLocalBnd (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc, int offset) const
 
void GlobalToLocalBnd (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const
 
void LocalBndToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, int offset, bool UseComm=true) const
 
void LocalBndToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, bool UseComm=true) const
 
void LocalToLocalBnd (const Array< OneD, const NekDouble > &local, Array< OneD, NekDouble > &locbnd) const
 
void LocalToLocalInt (const Array< OneD, const NekDouble > &local, Array< OneD, NekDouble > &locint) const
 
void LocalBndToLocal (const Array< OneD, const NekDouble > &locbnd, Array< OneD, NekDouble > &local) const
 
void LocalIntToLocal (const Array< OneD, const NekDouble > &locbnd, Array< OneD, NekDouble > &local) const
 
void AssembleBnd (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global, int offset) const
 
void AssembleBnd (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) const
 
void AssembleBnd (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, int offset) const
 
void AssembleBnd (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const
 
void UniversalAssembleBnd (Array< OneD, NekDouble > &pGlobal) const
 
void UniversalAssembleBnd (NekVector< NekDouble > &pGlobal) const
 
void UniversalAssembleBnd (Array< OneD, NekDouble > &pGlobal, int offset) const
 
int GetFullSystemBandWidth () const
 
int GetNumNonDirVertexModes () const
 
int GetNumNonDirEdgeModes () const
 
int GetNumNonDirFaceModes () const
 
int GetNumDirEdges () const
 
int GetNumDirFaces () const
 
int GetNumNonDirEdges () const
 
int GetNumNonDirFaces () const
 
void PrintStats (std::ostream &out, std::string variable, bool printHeader=true) const
 
const Array< OneD, const int > & GetExtraDirEdges ()
 
std::shared_ptr< AssemblyMap > LinearSpaceMap (const ExpList &locexp, GlobalSysSolnType solnType)
 
int GetBndSystemBandWidth () const
 Returns the bandwidth of the boundary system. More...
 
int GetStaticCondLevel () const
 Returns the level of static condensation for this map. More...
 
int GetNumPatches () const
 Returns the number of patches in this static condensation level. More...
 
const Array< OneD, const unsigned int > & GetNumLocalBndCoeffsPerPatch ()
 Returns the number of local boundary coefficients in each patch. More...
 
const Array< OneD, const unsigned int > & GetNumLocalIntCoeffsPerPatch ()
 Returns the number of local interior coefficients in each patch. More...
 
const AssemblyMapSharedPtr GetNextLevelLocalToGlobalMap () const
 Returns the local to global mapping for the next level in the multi-level static condensation. More...
 
void SetNextLevelLocalToGlobalMap (AssemblyMapSharedPtr pNextLevelLocalToGlobalMap)
 
const PatchMapSharedPtr & GetPatchMapFromPrevLevel (void) const
 Returns the patch map from the previous level of the multi-level static condensation. More...
 
bool AtLastLevel () const
 Returns true if this is the last level in the multi-level static condensation. More...
 
GlobalSysSolnType GetGlobalSysSolnType () const
 Returns the method of solving global systems. More...
 
std::string GetPreconType () const
 
NekDouble GetIterativeTolerance () const
 
bool IsAbsoluteTolerance () const
 
int GetMaxIterations () const
 
int GetSuccessiveRHS () const
 
std::string GetLinSysIterSolver () const
 
int GetLowestStaticCondLevel () const
 
void PatchLocalToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const
 
void PatchGlobalToLocal (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const
 
void PatchAssemble (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const
 

Protected Member Functions

void CalculateBndSystemBandWidth ()
 Calculates the bandwidth of the boundary system. More...
 
void GlobalToLocalBndWithoutSign (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc)
 
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 const Array< OneD, NekDouble > & v_GetLocalToGlobalSign () const
 
virtual void v_LocalToGlobal (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, bool useComm) const
 
virtual void v_LocalToGlobal (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global, bool useComm) const
 
virtual void v_GlobalToLocal (const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const
 
virtual void v_GlobalToLocal (const NekVector< NekDouble > &global, NekVector< NekDouble > &loc) const
 
virtual void v_Assemble (const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const
 
virtual void v_Assemble (const NekVector< NekDouble > &loc, NekVector< NekDouble > &global) const
 
virtual void v_UniversalAssemble (Array< OneD, NekDouble > &pGlobal) const
 
virtual void v_UniversalAssemble (NekVector< NekDouble > &pGlobal) const
 
virtual void v_UniversalAssemble (Array< OneD, NekDouble > &pGlobal, int offset) const
 
virtual int v_GetFullSystemBandWidth () const
 
virtual int v_GetNumNonDirVertexModes () const
 
virtual int v_GetNumNonDirEdgeModes () const
 
virtual int v_GetNumNonDirFaceModes () const
 
virtual int v_GetNumDirEdges () const
 
virtual int v_GetNumDirFaces () const
 
virtual int v_GetNumNonDirEdges () const
 
virtual int v_GetNumNonDirFaces () const
 
virtual const Array< OneD, const int > & v_GetExtraDirEdges ()
 
virtual std::shared_ptr< AssemblyMap > v_LinearSpaceMap (const ExpList &locexp, GlobalSysSolnType solnType)
 Generate a linear space mapping from existing mapping. More...
 

Protected Attributes

LibUtilities::SessionReaderSharedPtr m_session
 Session object. More...
 
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
std::string m_variable
 Variable string identifier. More...
 
size_t m_hash
 Hash for map. More...
 
int m_numLocalBndCoeffs
 Number of local boundary coefficients. More...
 
int m_numGlobalBndCoeffs
 Total number of global boundary coefficients. More...
 
int m_numLocalDirBndCoeffs
 Number of Local Dirichlet Boundary Coefficients. More...
 
int m_numGlobalDirBndCoeffs
 Number of Global Dirichlet Boundary Coefficients. More...
 
bool m_systemSingular
 Flag indicating if the system is singular or not. More...
 
int m_numLocalCoeffs
 Total number of local coefficients. More...
 
int m_numGlobalCoeffs
 Total number of global coefficients. More...
 
bool m_signChange
 Flag indicating if modes require sign reversal. More...
 
Array< OneD, int > m_localToGlobalBndMap
 Integer map of local coeffs to global Boundary Dofs. More...
 
Array< OneD, NekDouble > m_localToGlobalBndSign
 Integer sign of local boundary coeffs to global space. More...
 
Array< OneD, int > m_localToLocalBndMap
 Integer map of local boundary coeffs to local boundary system numbering. More...
 
Array< OneD, int > m_localToLocalIntMap
 Integer map of local boundary coeffs to local interior system numbering. More...
 
Array< OneD, int > m_bndCondCoeffsToLocalCoeffsMap
 Integer map of bnd cond coeffs to local coefficients. More...
 
Array< OneD, NekDouble > m_bndCondCoeffsToLocalCoeffsSign
 Integer map of sign of bnd cond coeffs to local coefficients. More...
 
Array< OneD, int > m_bndCondCoeffsToLocalTraceMap
 Integer map of bnd cond coeff to local trace coeff. More...
 
Array< OneD, int > m_bndCondIDToGlobalTraceID
 Integer map of bnd cond trace number to global trace number. More...
 
Array< OneD, int > m_globalToUniversalBndMap
 Integer map of process coeffs to universal space. More...
 
Array< OneD, int > m_globalToUniversalBndMapUnique
 Integer map of unique process coeffs to universal space (signed) More...
 
GlobalSysSolnType m_solnType
 The solution type of the global system. More...
 
int m_bndSystemBandWidth
 The bandwith of the global bnd system. More...
 
std::string m_preconType
 Type type of preconditioner to use in iterative solver. More...
 
int m_maxIterations
 Maximum iterations for iterative solver. More...
 
NekDouble m_iterativeTolerance
 Tolerance for iterative solver. More...
 
bool m_isAbsoluteTolerance
 
int m_successiveRHS
 sucessive RHS for iterative solver More...
 
std::string m_linSysIterSolver
 Iterative solver: Conjugate Gradient, GMRES. More...
 
Gs::gs_data * m_gsh
 
Gs::gs_data * m_bndGsh
 
Gs::gs_data * m_dirBndGsh
 gs gather communication to impose Dirhichlet BCs. More...
 
int m_staticCondLevel
 The level of recursion in the case of multi-level static condensation. More...
 
int m_numPatches
 The number of patches (~elements) in the current level. More...
 
Array< OneD, unsigned int > m_numLocalBndCoeffsPerPatch
 The number of bnd dofs per patch. More...
 
Array< OneD, unsigned int > m_numLocalIntCoeffsPerPatch
 The number of int dofs per patch. More...
 
AssemblyMapSharedPtr m_nextLevelLocalToGlobalMap
 Map from the patches of the previous level to the patches of the current level. More...
 
int m_lowestStaticCondLevel
 Lowest static condensation level. More...
 

Private Attributes

PatchMapSharedPtr m_patchMapFromPrevLevel
 Mapping information for previous level in MultiLevel Solver. More...
 

Detailed Description

Base class for constructing local to global mapping of degrees of freedom.

This class acts as a base class for constructing mappings between local, global and boundary degrees of freedom. It holds the storage for the maps and provides the accessors needed to retrieve them.

There are two derived classes: AssemblyMapCG and AssemblyMapDG. These perform the actual construction of the maps within their specific contexts.

Definition at line 57 of file AssemblyMap.h.

Constructor & Destructor Documentation

◆ AssemblyMap() [1/3]

Nektar::MultiRegions::AssemblyMap::AssemblyMap ( )

Default constructor.

Initialises an empty mapping.

Definition at line 82 of file AssemblyMap.cpp.

83 : m_session(), m_comm(), m_hash(0), m_numLocalBndCoeffs(0),
84 m_numGlobalBndCoeffs(0), m_numLocalDirBndCoeffs(0),
85 m_numGlobalDirBndCoeffs(0), m_solnType(eNoSolnType),
86 m_bndSystemBandWidth(0), m_successiveRHS(0),
87 m_linSysIterSolver("ConjugateGradient"), m_gsh(0), m_bndGsh(0)
88{
89}
Nektar::MultiRegions::AssemblyMap::m_solnType
GlobalSysSolnType m_solnType
The solution type of the global system.
Definition: AssemblyMap.h:405
Nektar::MultiRegions::AssemblyMap::m_linSysIterSolver
std::string m_linSysIterSolver
Iterative solver: Conjugate Gradient, GMRES.
Definition: AssemblyMap.h:423
Nektar::MultiRegions::AssemblyMap::m_successiveRHS
int m_successiveRHS
sucessive RHS for iterative solver
Definition: AssemblyMap.h:420
Nektar::MultiRegions::AssemblyMap::m_session
LibUtilities::SessionReaderSharedPtr m_session
Session object.
Definition: AssemblyMap.h:336
Nektar::MultiRegions::AssemblyMap::m_numLocalBndCoeffs
int m_numLocalBndCoeffs
Number of local boundary coefficients.
Definition: AssemblyMap.h:348
Nektar::MultiRegions::AssemblyMap::m_bndSystemBandWidth
int m_bndSystemBandWidth
The bandwith of the global bnd system.
Definition: AssemblyMap.h:407
Nektar::MultiRegions::AssemblyMap::m_numLocalDirBndCoeffs
int m_numLocalDirBndCoeffs
Number of Local Dirichlet Boundary Coefficients.
Definition: AssemblyMap.h:352
Nektar::MultiRegions::AssemblyMap::m_numGlobalDirBndCoeffs
int m_numGlobalDirBndCoeffs
Number of Global Dirichlet Boundary Coefficients.
Definition: AssemblyMap.h:354
Nektar::MultiRegions::AssemblyMap::m_comm
LibUtilities::CommSharedPtr m_comm
Communicator.
Definition: AssemblyMap.h:339
Nektar::MultiRegions::AssemblyMap::m_numGlobalBndCoeffs
int m_numGlobalBndCoeffs
Total number of global boundary coefficients.
Definition: AssemblyMap.h:350
Nektar::MultiRegions::eNoSolnType
@ eNoSolnType
No Solution type specified.
Definition: MultiRegions.hpp:70

◆ AssemblyMap() [2/3]

Nektar::MultiRegions::AssemblyMap::AssemblyMap ( const LibUtilities::SessionReaderSharedPtr &  pSession,
const LibUtilities::CommSharedPtr &  comm,
const std::string  variable = "DefaultVar" 
)

Constructor with a communicator.

Definition at line 91 of file AssemblyMap.cpp.

94 : m_session(pSession), m_comm(comm), m_variable(variable), m_hash(0),
95 m_numLocalBndCoeffs(0), m_numGlobalBndCoeffs(0),
96 m_numLocalDirBndCoeffs(0), m_numGlobalDirBndCoeffs(0),
97 m_bndSystemBandWidth(0), m_successiveRHS(0),
98 m_linSysIterSolver("ConjugateGradient"), m_gsh(0), m_bndGsh(0)
99{
100 // Default value from Solver Info
101 m_solnType =
102 pSession->GetSolverInfoAsEnum<GlobalSysSolnType>("GlobalSysSoln");
103
104 // Override values with data from GlobalSysSolnInfo section
105 if (pSession->DefinesGlobalSysSolnInfo(variable, "GlobalSysSoln"))
106 {
107 std::string sysSoln =
108 pSession->GetGlobalSysSolnInfo(variable, "GlobalSysSoln");
109 m_solnType = pSession->GetValueAsEnum<GlobalSysSolnType>(
110 "GlobalSysSoln", sysSoln);
111 }
112
113 // Set up preconditioner with SysSoln as override then solverinfo otherwise
114 // set a default as diagonal
115 if (pSession->DefinesGlobalSysSolnInfo(variable, "Preconditioner"))
116 {
117 m_preconType =
118 pSession->GetGlobalSysSolnInfo(variable, "Preconditioner");
119 }
120 else if (pSession->DefinesSolverInfo("Preconditioner"))
121 {
122 m_preconType = pSession->GetSolverInfo("Preconditioner");
123 }
124 else
125 { // Possibly preconditioner is default registered in
126 // GlobLinSysIterative.cpp
127 m_preconType = "Diagonal";
128 }
129
130 if (pSession->DefinesGlobalSysSolnInfo(variable,
131 "IterativeSolverTolerance"))
132 {
133 m_iterativeTolerance = boost::lexical_cast<NekDouble>(
134 pSession->GetGlobalSysSolnInfo(variable, "IterativeSolverTolerance")
135 .c_str());
136 }
137 else
138 {
139 pSession->LoadParameter("IterativeSolverTolerance",
140 m_iterativeTolerance,
141 NekConstants::kNekIterativeTol);
142 }
143
144 if (pSession->DefinesGlobalSysSolnInfo(variable, "AbsoluteTolerance"))
145 {
146 std::string abstol =
147 pSession->GetGlobalSysSolnInfo(variable, "AbsoluteTolerance");
148 m_isAbsoluteTolerance =
149 boost::iequals(boost::to_upper_copy(abstol), "TRUE");
150 }
151 else
152 {
153 m_isAbsoluteTolerance = false;
154 }
155
156 if (pSession->DefinesGlobalSysSolnInfo(variable, "MaxIterations"))
157 {
158 m_maxIterations = boost::lexical_cast<int>(
159 pSession->GetGlobalSysSolnInfo(variable, "MaxIterations").c_str());
160 }
161 else
162 {
163 pSession->LoadParameter("MaxIterations", m_maxIterations, 5000);
164 }
165
166 if (pSession->DefinesGlobalSysSolnInfo(variable, "SuccessiveRHS"))
167 {
168 m_successiveRHS = boost::lexical_cast<int>(
169 pSession->GetGlobalSysSolnInfo(variable, "SuccessiveRHS").c_str());
170 }
171 else
172 {
173 pSession->LoadParameter("SuccessiveRHS", m_successiveRHS, 0);
174 }
175
176 if (pSession->DefinesGlobalSysSolnInfo(variable, "LinSysIterSolver"))
177 {
178 m_linSysIterSolver =
179 pSession->GetGlobalSysSolnInfo(variable, "LinSysIterSolver");
180 }
181 else if (pSession->DefinesSolverInfo("LinSysIterSolver"))
182 {
183 m_linSysIterSolver = pSession->GetSolverInfo("LinSysIterSolver");
184 }
185 else
186 {
187 m_linSysIterSolver = "ConjugateGradient";
188 }
189}
Nektar::MultiRegions::AssemblyMap::m_maxIterations
int m_maxIterations
Maximum iterations for iterative solver.
Definition: AssemblyMap.h:413
Nektar::MultiRegions::AssemblyMap::m_iterativeTolerance
NekDouble m_iterativeTolerance
Tolerance for iterative solver.
Definition: AssemblyMap.h:416
Nektar::MultiRegions::AssemblyMap::m_variable
std::string m_variable
Variable string identifier.
Definition: AssemblyMap.h:342
Nektar::MultiRegions::AssemblyMap::m_preconType
std::string m_preconType
Type type of preconditioner to use in iterative solver.
Definition: AssemblyMap.h:410
Nektar::NekConstants::kNekIterativeTol
static const NekDouble kNekIterativeTol
Definition: NektarUnivConsts.hpp:52

References Nektar::NekConstants::kNekIterativeTol, m_isAbsoluteTolerance, m_iterativeTolerance, m_linSysIterSolver, m_maxIterations, m_preconType, m_solnType, and m_successiveRHS.

◆ AssemblyMap() [3/3]

Nektar::MultiRegions::AssemblyMap::AssemblyMap ( AssemblyMap *  oldLevelMap,
const BottomUpSubStructuredGraphSharedPtr &  multiLevelGraph 
)

Constructor for next level in multi-level static condensation.

Create a new level of mapping using the information in multiLevelGraph and performing the following steps:

  • STEP 1: setup a mask array to determine to which patch of the new level every patch of the current level belongs. To do so we make four arrays, #gloPatchMask, #globHomPatchMask, #locPatchMask_NekDouble and #locPatchMask. These arrays are then used to check which local dofs of the old level belong to which patch of the new level
  • STEP 2: We calculate how many local bnd dofs of the old level belong to the boundaries of each patch at the new level. We need this information to set up the mapping between different levels.

Definition at line 195 of file AssemblyMap.cpp.

198 : m_session(oldLevelMap->m_session), m_comm(oldLevelMap->GetComm()),
199 m_hash(0), m_solnType(oldLevelMap->m_solnType),
200 m_preconType(oldLevelMap->m_preconType),
201 m_maxIterations(oldLevelMap->m_maxIterations),
202 m_iterativeTolerance(oldLevelMap->m_iterativeTolerance),
203 m_successiveRHS(oldLevelMap->m_successiveRHS),
204 m_linSysIterSolver(oldLevelMap->m_linSysIterSolver),
205 m_gsh(oldLevelMap->m_gsh), m_bndGsh(oldLevelMap->m_bndGsh),
206 m_lowestStaticCondLevel(oldLevelMap->m_lowestStaticCondLevel)
207{
208 int i;
209 int j;
210 int cnt;
211
212 //--------------------------------------------------------------
213 // -- Extract information from the input argument
214 int numGlobalBndCoeffsOld = oldLevelMap->GetNumGlobalBndCoeffs();
215 int numGlobalDirBndCoeffsOld = oldLevelMap->GetNumGlobalDirBndCoeffs();
216 int numLocalBndCoeffsOld = oldLevelMap->GetNumLocalBndCoeffs();
217 int numLocalDirBndCoeffsOld = oldLevelMap->GetNumLocalDirBndCoeffs();
218 bool signChangeOld = oldLevelMap->GetSignChange();
219
220 int staticCondLevelOld = oldLevelMap->GetStaticCondLevel();
221 int numPatchesOld = oldLevelMap->GetNumPatches();
222 GlobalSysSolnType solnTypeOld = oldLevelMap->GetGlobalSysSolnType();
223 const Array<OneD, const unsigned int> &numLocalBndCoeffsPerPatchOld =
224 oldLevelMap->GetNumLocalBndCoeffsPerPatch();
225 //--------------------------------------------------------------
226
227 //--------------------------------------------------------------
228 int newLevel = staticCondLevelOld + 1;
229 /** - STEP 1: setup a mask array to determine to which patch
230 * of the new level every patch of the current
231 * level belongs. To do so we make four arrays,
232 * #gloPatchMask, #globHomPatchMask,
233 * #locPatchMask_NekDouble and #locPatchMask.
234 * These arrays are then used to check which local
235 * dofs of the old level belong to which patch of
236 * the new level
237 */
238 Array<OneD, NekDouble> globPatchMask(numGlobalBndCoeffsOld, -1.0);
239 Array<OneD, NekDouble> globHomPatchMask(globPatchMask +
240 numGlobalDirBndCoeffsOld);
241 Array<OneD, NekDouble> locPatchMask_NekDouble(numLocalBndCoeffsOld, -3.0);
242 Array<OneD, int> locPatchMask(numLocalBndCoeffsOld);
243
244 // Fill the array globPatchMask as follows:
245 // - The first part (i.e. the glob bnd dofs) is filled with the
246 // value -1
247 // - The second part (i.e. the glob interior dofs) is numbered
248 // according to the patch it belongs to (i.e. dofs in first block
249 // all are numbered 0, the second block numbered are 1, etc...)
250 multiLevelGraph->MaskPatches(newLevel, globHomPatchMask);
251
252 // Map from Global Dofs to Local Dofs
253 // As a result, we know for each local dof whether
254 // it is mapped to the boundary of the next level, or to which
255 // patch. Based upon this, we can than later associate every patch
256 // of the current level with a patch in the next level.
257 oldLevelMap->GlobalToLocalBndWithoutSign(globPatchMask,
258 locPatchMask_NekDouble);
259
260 // Convert the result to an array of integers rather than doubles
261 RoundNekDoubleToInt(locPatchMask_NekDouble, locPatchMask);
262
263 /** - STEP 2: We calculate how many local bnd dofs of the
264 * old level belong to the boundaries of each patch at
265 * the new level. We need this information to set up the
266 * mapping between different levels.
267 */
268
269 // Retrieve the number of patches at the next level
270 int numPatchesWithIntNew =
271 multiLevelGraph->GetNpatchesWithInterior(newLevel);
272 int numPatchesNew = numPatchesWithIntNew;
273
274 // Allocate memory to store the number of local dofs associated to
275 // each of elemental boundaries of these patches
276 std::map<int, int> numLocalBndCoeffsPerPatchNew;
277 for (int i = 0; i < numPatchesNew; i++)
278 {
279 numLocalBndCoeffsPerPatchNew[i] = 0;
280 }
281
282 int minval;
283 int maxval;
284 int curPatch;
285 for (i = cnt = 0; i < numPatchesOld; i++)
286 {
287 // For every patch at the current level, the mask array
288 // locPatchMask should be filled with
289 // - the same (positive) number for each entry (which will
290 // correspond to the patch at the next level it belongs to)
291 // - the same (positive) number for each entry, except some
292 // entries that are -1 (the enties correspond to -1, will be
293 // mapped to the local boundary of the next level patch given
294 // by the positive number)
295 // - -1 for all entries. In this case, we will make an
296 // additional patch only consisting of boundaries at the next
297 // level
298 minval =
299 *min_element(&locPatchMask[cnt],
300 &locPatchMask[cnt] + numLocalBndCoeffsPerPatchOld[i]);
301 maxval =
302 *max_element(&locPatchMask[cnt],
303 &locPatchMask[cnt] + numLocalBndCoeffsPerPatchOld[i]);
304 ASSERTL0((minval == maxval) || (minval == -1),
305 "These values should never be the same");
306
307 if (maxval == -1)
308 {
309 curPatch = numPatchesNew;
310 numLocalBndCoeffsPerPatchNew[curPatch] = 0;
311 numPatchesNew++;
312 }
313 else
314 {
315 curPatch = maxval;
316 }
317
318 for (j = 0; j < numLocalBndCoeffsPerPatchOld[i]; j++)
319 {
320 ASSERTL0((locPatchMask[cnt] == maxval) ||
321 (locPatchMask[cnt] == minval),
322 "These values should never be the same");
323 if (locPatchMask[cnt] == -1)
324 {
325 ++numLocalBndCoeffsPerPatchNew[curPatch];
326 }
327 cnt++;
328 }
329 }
330
331 // Count how many local dofs of the old level are mapped
332 // to the local boundary dofs of the new level
333 m_numLocalCoeffs = 0;
334 m_numLocalBndCoeffs = 0;
335 m_numPatches = numLocalBndCoeffsPerPatchNew.size();
336 m_numLocalBndCoeffsPerPatch = Array<OneD, unsigned int>(m_numPatches);
337 m_numLocalIntCoeffsPerPatch = Array<OneD, unsigned int>(m_numPatches, 0u);
338 multiLevelGraph->GetNintDofsPerPatch(newLevel, m_numLocalIntCoeffsPerPatch);
339
340 for (int i = 0; i < m_numPatches; i++)
341 {
342 m_numLocalBndCoeffsPerPatch[i] =
343 (unsigned int)numLocalBndCoeffsPerPatchNew[i];
344 m_numLocalBndCoeffs += m_numLocalBndCoeffsPerPatch[i];
345 m_numLocalCoeffs +=
346 m_numLocalBndCoeffsPerPatch[i] + m_numLocalIntCoeffsPerPatch[i];
347 }
348
349 // Also initialise some more data members
350 m_solnType = solnTypeOld;
351 ASSERTL1(m_solnType == eDirectMultiLevelStaticCond ||
352 m_solnType == eIterativeMultiLevelStaticCond ||
353 m_solnType == eXxtMultiLevelStaticCond ||
354 m_solnType == ePETScMultiLevelStaticCond,
355 "This method should only be called for in "
356 "case of multi-level static condensation.");
357 m_staticCondLevel = newLevel;
358 m_signChange = signChangeOld;
359 m_numLocalDirBndCoeffs = numLocalDirBndCoeffsOld;
360 m_numGlobalDirBndCoeffs = numGlobalDirBndCoeffsOld;
361 m_numGlobalBndCoeffs =
362 multiLevelGraph->GetInteriorOffset(newLevel) + m_numGlobalDirBndCoeffs;
363 m_numGlobalCoeffs =
364 multiLevelGraph->GetNumGlobalDofs(newLevel) + m_numGlobalDirBndCoeffs;
365 m_localToGlobalBndMap = Array<OneD, int>(m_numLocalBndCoeffs);
366
367 m_localToLocalBndMap = Array<OneD, int>(m_numLocalBndCoeffs);
368 m_localToLocalIntMap =
369 Array<OneD, int>(m_numLocalCoeffs - m_numLocalBndCoeffs);
370
371 // local to bnd map is just a copy
372 for (int i = 0; i < m_numLocalBndCoeffs; ++i)
373 {
374 m_localToLocalBndMap[i] = i;
375 }
376
377 // local to int map is just a copy plus offset
378 for (int i = m_numLocalBndCoeffs; i < m_numLocalCoeffs; ++i)
379 {
380 m_localToLocalIntMap[i - m_numLocalBndCoeffs] = i;
381 }
382
383 if (m_signChange)
384 {
385 m_localToGlobalBndSign = Array<OneD, NekDouble>(m_numLocalBndCoeffs);
386 }
387
388 m_patchMapFromPrevLevel =
389 MemoryManager<PatchMap>::AllocateSharedPtr(numLocalBndCoeffsOld);
390
391 m_globalToUniversalBndMap = Array<OneD, int>(
392 m_numGlobalBndCoeffs, oldLevelMap->GetGlobalToUniversalBndMap());
393 m_globalToUniversalBndMapUnique = Array<OneD, int>(
394 m_numGlobalBndCoeffs, oldLevelMap->GetGlobalToUniversalBndMapUnique());
395
396 // Set up an offset array that denotes the offset of the local
397 // boundary degrees of freedom of the next level
398 Array<OneD, int> numLocalBndCoeffsPerPatchOffset(m_numPatches + 1, 0);
399 for (int i = 1; i < m_numPatches + 1; i++)
400 {
401 numLocalBndCoeffsPerPatchOffset[i] +=
402 numLocalBndCoeffsPerPatchOffset[i - 1] +
403 numLocalBndCoeffsPerPatchNew[i - 1];
404 }
405
406 int additionalPatchCnt = numPatchesWithIntNew;
407 int newid;
408 int blockid;
409 bool isBndDof;
410 NekDouble sign;
411 Array<OneD, int> bndDofPerPatchCnt(m_numPatches, 0);
412
413 for (i = cnt = 0; i < numPatchesOld; i++)
414 {
415 minval =
416 *min_element(&locPatchMask[cnt],
417 &locPatchMask[cnt] + numLocalBndCoeffsPerPatchOld[i]);
418 maxval =
419 *max_element(&locPatchMask[cnt],
420 &locPatchMask[cnt] + numLocalBndCoeffsPerPatchOld[i]);
421 ASSERTL0((minval == maxval) || (minval == -1),
422 "These values should never be the same");
423
424 if (maxval == -1)
425 {
426 curPatch = additionalPatchCnt;
427 additionalPatchCnt++;
428 }
429 else
430 {
431 curPatch = maxval;
432 }
433
434 for (j = 0; j < numLocalBndCoeffsPerPatchOld[i]; j++)
435 {
436 ASSERTL0((locPatchMask[cnt] == maxval) ||
437 (locPatchMask[cnt] == minval),
438 "These values should never be the same");
439
440 sign = oldLevelMap->GetLocalToGlobalBndSign(cnt);
441
442 if (locPatchMask[cnt] == -1)
443 {
444 newid = numLocalBndCoeffsPerPatchOffset[curPatch];
445
446 m_localToGlobalBndMap[newid] =
447 oldLevelMap->GetLocalToGlobalBndMap(cnt);
448
449 if (m_signChange)
450 {
451 m_localToGlobalBndSign[newid] = sign;
452 }
453
454 blockid = bndDofPerPatchCnt[curPatch];
455 isBndDof = true;
456
457 numLocalBndCoeffsPerPatchOffset[curPatch]++;
458 bndDofPerPatchCnt[curPatch]++;
459 }
460 else
461 {
462 newid = oldLevelMap->GetLocalToGlobalBndMap(cnt) -
463 m_numGlobalBndCoeffs + m_numLocalBndCoeffs;
464
465 blockid =
466 oldLevelMap->GetLocalToGlobalBndMap(cnt) -
467 m_numGlobalDirBndCoeffs -
468 multiLevelGraph->GetInteriorOffset(newLevel, curPatch);
469 isBndDof = false;
470 }
471
472 sign = isBndDof ? 1.0 : sign;
473
474 m_patchMapFromPrevLevel->SetPatchMap(cnt, curPatch, blockid,
475 isBndDof, sign);
476 cnt++;
477 }
478 }
479
480 // set up local to local mapping from previous to new level
481 m_patchMapFromPrevLevel->SetNewLevelMap(m_numLocalBndCoeffsPerPatch,
482 m_numLocalIntCoeffsPerPatch);
483
484 CalculateBndSystemBandWidth();
485
486 // Postprocess the computed information - Update the old
487 // level with the mapping to new level
488 // oldLevelMap->SetLocalBndToNextLevelMap(oldLocalBndToNewLevelMap,oldLocalBndToNewLevelSign);
489
490 // - Construct the next level mapping object
491 if (m_staticCondLevel < (multiLevelGraph->GetNlevels() - 1))
492 {
493 m_nextLevelLocalToGlobalMap =
494 MemoryManager<AssemblyMap>::AllocateSharedPtr(this,
495 multiLevelGraph);
496 }
497}
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
sign
#define sign(a, b)
return the sign(b)*a
Definition: Polylib.cpp:49
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168
Nektar::MultiRegions::AssemblyMap::m_lowestStaticCondLevel
int m_lowestStaticCondLevel
Lowest static condensation level.
Definition: AssemblyMap.h:445
Nektar::MultiRegions::AssemblyMap::m_numLocalCoeffs
int m_numLocalCoeffs
Total number of local coefficients.
Definition: AssemblyMap.h:367
Nektar::MultiRegions::AssemblyMap::m_signChange
bool m_signChange
Flag indicating if modes require sign reversal.
Definition: AssemblyMap.h:381
Nektar::MultiRegions::AssemblyMap::m_patchMapFromPrevLevel
PatchMapSharedPtr m_patchMapFromPrevLevel
Mapping information for previous level in MultiLevel Solver.
Definition: AssemblyMap.h:520
Nektar::MultiRegions::AssemblyMap::m_localToLocalIntMap
Array< OneD, int > m_localToLocalIntMap
Integer map of local boundary coeffs to local interior system numbering.
Definition: AssemblyMap.h:390
Nektar::MultiRegions::AssemblyMap::m_numGlobalCoeffs
int m_numGlobalCoeffs
Total number of global coefficients.
Definition: AssemblyMap.h:378
Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMap
Array< OneD, int > m_globalToUniversalBndMap
Integer map of process coeffs to universal space.
Definition: AssemblyMap.h:400
Nektar::MultiRegions::AssemblyMap::CalculateBndSystemBandWidth
void CalculateBndSystemBandWidth()
Calculates the bandwidth of the boundary system.
Definition: AssemblyMap.cpp:517
Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndSign
Array< OneD, NekDouble > m_localToGlobalBndSign
Integer sign of local boundary coeffs to global space.
Definition: AssemblyMap.h:386
Nektar::MultiRegions::AssemblyMap::m_numLocalBndCoeffsPerPatch
Array< OneD, unsigned int > m_numLocalBndCoeffsPerPatch
The number of bnd dofs per patch.
Definition: AssemblyMap.h:436
Nektar::MultiRegions::AssemblyMap::m_nextLevelLocalToGlobalMap
AssemblyMapSharedPtr m_nextLevelLocalToGlobalMap
Map from the patches of the previous level to the patches of the current level.
Definition: AssemblyMap.h:443
Nektar::MultiRegions::AssemblyMap::m_staticCondLevel
int m_staticCondLevel
The level of recursion in the case of multi-level static condensation.
Definition: AssemblyMap.h:432
Nektar::MultiRegions::AssemblyMap::m_numLocalIntCoeffsPerPatch
Array< OneD, unsigned int > m_numLocalIntCoeffsPerPatch
The number of int dofs per patch.
Definition: AssemblyMap.h:438
Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndMap
Array< OneD, int > m_localToGlobalBndMap
Integer map of local coeffs to global Boundary Dofs.
Definition: AssemblyMap.h:384
Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMapUnique
Array< OneD, int > m_globalToUniversalBndMapUnique
Integer map of unique process coeffs to universal space (signed)
Definition: AssemblyMap.h:402
Nektar::MultiRegions::AssemblyMap::m_localToLocalBndMap
Array< OneD, int > m_localToLocalBndMap
Integer map of local boundary coeffs to local boundary system numbering.
Definition: AssemblyMap.h:388
Nektar::MultiRegions::AssemblyMap::m_numPatches
int m_numPatches
The number of patches (~elements) in the current level.
Definition: AssemblyMap.h:434
Nektar::MultiRegions::RoundNekDoubleToInt
int RoundNekDoubleToInt(NekDouble x)
Rounds a double precision number to an integer.
Definition: AssemblyMap.cpp:59
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, CalculateBndSystemBandWidth(), Nektar::MultiRegions::eDirectMultiLevelStaticCond, Nektar::MultiRegions::eIterativeMultiLevelStaticCond, Nektar::MultiRegions::ePETScMultiLevelStaticCond, Nektar::MultiRegions::eXxtMultiLevelStaticCond, GetGlobalSysSolnType(), GetGlobalToUniversalBndMap(), GetGlobalToUniversalBndMapUnique(), GetLocalToGlobalBndMap(), GetLocalToGlobalBndSign(), GetNumGlobalBndCoeffs(), GetNumGlobalDirBndCoeffs(), GetNumLocalBndCoeffs(), GetNumLocalBndCoeffsPerPatch(), GetNumLocalDirBndCoeffs(), GetNumPatches(), GetSignChange(), GetStaticCondLevel(), GlobalToLocalBndWithoutSign(), m_globalToUniversalBndMap, m_globalToUniversalBndMapUnique, m_localToGlobalBndMap, m_localToGlobalBndSign, m_localToLocalBndMap, m_localToLocalIntMap, m_nextLevelLocalToGlobalMap, m_numGlobalBndCoeffs, m_numGlobalCoeffs, m_numGlobalDirBndCoeffs, m_numLocalBndCoeffs, m_numLocalBndCoeffsPerPatch, m_numLocalCoeffs, m_numLocalDirBndCoeffs, m_numLocalIntCoeffsPerPatch, m_numPatches, m_patchMapFromPrevLevel, m_signChange, m_solnType, m_staticCondLevel, Nektar::MultiRegions::RoundNekDoubleToInt(), and sign.

◆ ~AssemblyMap()

Nektar::MultiRegions::AssemblyMap::~AssemblyMap ( void  )
virtual

Destructor.

Definition at line 499 of file AssemblyMap.cpp.

500{
501}

Member Function Documentation

◆ Assemble() [1/2]

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

Definition at line 820 of file AssemblyMap.cpp.

822{
823 v_Assemble(loc, global);
824}
Nektar::MultiRegions::AssemblyMap::v_Assemble
virtual void v_Assemble(const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global) const
Definition: AssemblyMap.cpp:639
CG_Iterations.loc
loc
Definition: CG_Iterations.py:323

References CG_Iterations::loc, and v_Assemble().

Referenced by Nektar::MultiRegions::AssemblyMapCG::v_Assemble().

◆ Assemble() [2/2]

void Nektar::MultiRegions::AssemblyMap::Assemble ( const NekVector< NekDouble > &  loc,
NekVector< NekDouble > &  global 
) const

Definition at line 826 of file AssemblyMap.cpp.

828{
829 v_Assemble(loc, global);
830}

References CG_Iterations::loc, and v_Assemble().

◆ AssembleBnd() [1/4]

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

Definition at line 1275 of file AssemblyMap.cpp.

1277{
1278 ASSERTL1(loc.size() >= m_numLocalBndCoeffs,
1279 "Local vector is not of correct dimension");
1280 ASSERTL1(global.size() >= m_numGlobalBndCoeffs,
1281 "Global vector is not of correct dimension");
1282
1283 Vmath::Zero(m_numGlobalBndCoeffs, global.get(), 1);
1284
1285 if (m_signChange)
1286 {
1287 Vmath::Assmb(m_numLocalBndCoeffs, m_localToGlobalBndSign.get(),
1288 loc.get(), m_localToGlobalBndMap.get(), global.get());
1289 }
1290 else
1291 {
1292 Vmath::Assmb(m_numLocalBndCoeffs, loc.get(),
1293 m_localToGlobalBndMap.get(), global.get());
1294 }
1295 UniversalAssembleBnd(global);
1296}
Nektar::MultiRegions::AssemblyMap::UniversalAssembleBnd
void UniversalAssembleBnd(Array< OneD, NekDouble > &pGlobal) const
Definition: AssemblyMap.cpp:1298
Vmath::Assmb
void Assmb(int n, const T *x, const int *y, T *z)
Assemble z[y[i]] += x[i]; z should be zero'd first.
Definition: Vmath.cpp:857
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:487

References ASSERTL1, Vmath::Assmb(), CG_Iterations::loc, m_localToGlobalBndMap, m_localToGlobalBndSign, m_numGlobalBndCoeffs, m_numLocalBndCoeffs, m_signChange, UniversalAssembleBnd(), and Vmath::Zero().

◆ AssembleBnd() [2/4]

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

Definition at line 1251 of file AssemblyMap.cpp.

1253{
1254 ASSERTL1(loc.size() >= m_numLocalBndCoeffs,
1255 "Local array is not of correct dimension");
1256 ASSERTL1(global.size() >= m_numGlobalBndCoeffs - offset,
1257 "Global array is not of correct dimension");
1258 Array<OneD, NekDouble> tmp(m_numGlobalBndCoeffs, 0.0);
1259
1260 if (m_signChange)
1261 {
1262 Vmath::Assmb(m_numLocalBndCoeffs, m_localToGlobalBndSign.get(),
1263 loc.get(), m_localToGlobalBndMap.get(), tmp.get());
1264 }
1265 else
1266 {
1267 Vmath::Assmb(m_numLocalBndCoeffs, loc.get(),
1268 m_localToGlobalBndMap.get(), tmp.get());
1269 }
1270 UniversalAssembleBnd(tmp);
1271 Vmath::Vcopy(m_numGlobalBndCoeffs - offset, tmp.get() + offset, 1,
1272 global.get(), 1);
1273}
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1191

References ASSERTL1, Vmath::Assmb(), CG_Iterations::loc, m_localToGlobalBndMap, m_localToGlobalBndSign, m_numGlobalBndCoeffs, m_numLocalBndCoeffs, m_signChange, UniversalAssembleBnd(), and Vmath::Vcopy().

◆ AssembleBnd() [3/4]

void Nektar::MultiRegions::AssemblyMap::AssembleBnd ( const NekVector< NekDouble > &  loc,
NekVector< NekDouble > &  global 
) const

Definition at line 1245 of file AssemblyMap.cpp.

1247{
1248 AssembleBnd(loc.GetPtr(), global.GetPtr());
1249}
Nektar::MultiRegions::AssemblyMap::AssembleBnd
void AssembleBnd(const NekVector< NekDouble > &loc, NekVector< NekDouble > &global, int offset) const
Definition: AssemblyMap.cpp:1239
Nektar::NekVector::GetPtr
Array< OneD, DataType > & GetPtr()
Definition: NekVector.cpp:217

References AssembleBnd(), Nektar::NekVector< DataType >::GetPtr(), and CG_Iterations::loc.

◆ AssembleBnd() [4/4]

void Nektar::MultiRegions::AssemblyMap::AssembleBnd ( const NekVector< NekDouble > &  loc,
NekVector< NekDouble > &  global,
int  offset 
) const

Definition at line 1239 of file AssemblyMap.cpp.

1241{
1242 AssembleBnd(loc.GetPtr(), global.GetPtr(), offset);
1243}

References AssembleBnd(), Nektar::NekVector< DataType >::GetPtr(), and CG_Iterations::loc.

Referenced by AssembleBnd(), and Nektar::MultiRegions::AssemblyMapDG::v_Assemble().

◆ AtLastLevel()

bool Nektar::MultiRegions::AssemblyMap::AtLastLevel ( ) const

Returns true if this is the last level in the multi-level static condensation.

Definition at line 1362 of file AssemblyMap.cpp.

1363{
1364 return !(m_nextLevelLocalToGlobalMap.get());
1365}

References m_nextLevelLocalToGlobalMap.

◆ CalculateBndSystemBandWidth()

void Nektar::MultiRegions::AssemblyMap::CalculateBndSystemBandWidth ( )
protected

Calculates the bandwidth of the boundary system.

The bandwidth calculated corresponds to what is referred to as half-bandwidth. If the elements of the matrix are designated as a_ij, it corresponds to the maximum value of |i-j| for non-zero a_ij. As a result, the value also corresponds to the number of sub- or super-diagonals.

The bandwith can be calculated elementally as it corresponds to the maximal elemental bandwith (i.e. the maximal difference in global DOF index for every element).

We here calculate the bandwith of the global boundary system (as used for static condensation).

Definition at line 517 of file AssemblyMap.cpp.

518{
519 int i, j;
520 int cnt = 0;
521 int locSize;
522 int maxId;
523 int minId;
524 int bwidth = -1;
525 for (i = 0; i < m_numPatches; ++i)
526 {
527 locSize = m_numLocalBndCoeffsPerPatch[i];
528 maxId = -1;
529 minId = m_numLocalBndCoeffs + 1;
530 for (j = 0; j < locSize; j++)
531 {
532 if (m_localToGlobalBndMap[cnt + j] >= m_numGlobalDirBndCoeffs)
533 {
534 if (m_localToGlobalBndMap[cnt + j] > maxId)
535 {
536 maxId = m_localToGlobalBndMap[cnt + j];
537 }
538
539 if (m_localToGlobalBndMap[cnt + j] < minId)
540 {
541 minId = m_localToGlobalBndMap[cnt + j];
542 }
543 }
544 }
545 bwidth = (bwidth > (maxId - minId)) ? bwidth : (maxId - minId);
546
547 cnt += locSize;
548 }
549
550 m_bndSystemBandWidth = bwidth;
551}

References m_bndSystemBandWidth, m_localToGlobalBndMap, m_numGlobalDirBndCoeffs, m_numLocalBndCoeffs, m_numLocalBndCoeffsPerPatch, and m_numPatches.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), and Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG().

◆ GetBndCondCoeffsToLocalCoeffsMap()

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetBndCondCoeffsToLocalCoeffsMap ( )

Retrieves the local indices corresponding to the boundary expansion modes.

Definition at line 1005 of file AssemblyMap.cpp.

1006{
1007 return m_bndCondCoeffsToLocalCoeffsMap;
1008}
Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToLocalCoeffsMap
Array< OneD, int > m_bndCondCoeffsToLocalCoeffsMap
Integer map of bnd cond coeffs to local coefficients.
Definition: AssemblyMap.h:392

References m_bndCondCoeffsToLocalCoeffsMap.

◆ GetBndCondCoeffsToLocalCoeffsSign()

const Array< OneD, NekDouble > & Nektar::MultiRegions::AssemblyMap::GetBndCondCoeffsToLocalCoeffsSign ( )

Returns the modal sign associated with a given boundary expansion mode.

Definition at line 1010 of file AssemblyMap.cpp.

1011{
1012 return m_bndCondCoeffsToLocalCoeffsSign;
1013}
Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToLocalCoeffsSign
Array< OneD, NekDouble > m_bndCondCoeffsToLocalCoeffsSign
Integer map of sign of bnd cond coeffs to local coefficients.
Definition: AssemblyMap.h:394

References m_bndCondCoeffsToLocalCoeffsSign.

◆ GetBndCondCoeffsToLocalTraceMap()

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetBndCondCoeffsToLocalTraceMap ( )

Retrieves the local indices corresponding to the boundary expansion modes to global trace.

Definition at line 1015 of file AssemblyMap.cpp.

1016{
1017 return m_bndCondCoeffsToLocalTraceMap;
1018}
Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToLocalTraceMap
Array< OneD, int > m_bndCondCoeffsToLocalTraceMap
Integer map of bnd cond coeff to local trace coeff.
Definition: AssemblyMap.h:396

References m_bndCondCoeffsToLocalTraceMap.

◆ GetBndCondIDToGlobalTraceID() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetBndCondIDToGlobalTraceID ( )

Definition at line 1026 of file AssemblyMap.cpp.

1027{
1028 return m_bndCondIDToGlobalTraceID;
1029}
Nektar::MultiRegions::AssemblyMap::m_bndCondIDToGlobalTraceID
Array< OneD, int > m_bndCondIDToGlobalTraceID
Integer map of bnd cond trace number to global trace number.
Definition: AssemblyMap.h:398

References m_bndCondIDToGlobalTraceID.

◆ GetBndCondIDToGlobalTraceID() [2/2]

int Nektar::MultiRegions::AssemblyMap::GetBndCondIDToGlobalTraceID ( const int  i)

Returns the global index of the boundary trace giving the index on the boundary expansion.

Definition at line 1020 of file AssemblyMap.cpp.

1021{
1022 ASSERTL1(i < m_bndCondIDToGlobalTraceID.size(), "Index out of range.");
1023 return m_bndCondIDToGlobalTraceID[i];
1024}

References ASSERTL1, and m_bndCondIDToGlobalTraceID.

◆ GetBndSystemBandWidth()

int Nektar::MultiRegions::AssemblyMap::GetBndSystemBandWidth ( ) const

Returns the bandwidth of the boundary system.

Definition at line 1325 of file AssemblyMap.cpp.

1326{
1327 return m_bndSystemBandWidth;
1328}

References m_bndSystemBandWidth.

Referenced by Nektar::MultiRegions::AssemblyMapDG::v_GetFullSystemBandWidth().

◆ GetComm()

LibUtilities::CommSharedPtr Nektar::MultiRegions::AssemblyMap::GetComm ( )

Retrieves the communicator.

Definition at line 739 of file AssemblyMap.cpp.

740{
741 return m_comm;
742}

References m_comm.

◆ GetExtraDirEdges()

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetExtraDirEdges ( )

Definition at line 952 of file AssemblyMap.cpp.

953{
954 return v_GetExtraDirEdges();
955}
Nektar::MultiRegions::AssemblyMap::v_GetExtraDirEdges
virtual const Array< OneD, const int > & v_GetExtraDirEdges()
Definition: AssemblyMap.cpp:723

References v_GetExtraDirEdges().

◆ GetFullSystemBandWidth()

int Nektar::MultiRegions::AssemblyMap::GetFullSystemBandWidth ( ) const

Definition at line 912 of file AssemblyMap.cpp.

913{
914 return v_GetFullSystemBandWidth();
915}
Nektar::MultiRegions::AssemblyMap::v_GetFullSystemBandWidth
virtual int v_GetFullSystemBandWidth() const
Definition: AssemblyMap.cpp:675

References v_GetFullSystemBandWidth().

◆ GetGlobalSysSolnType()

GlobalSysSolnType Nektar::MultiRegions::AssemblyMap::GetGlobalSysSolnType ( ) const

Returns the method of solving global systems.

Definition at line 1367 of file AssemblyMap.cpp.

1368{
1369 return m_solnType;
1370}

References m_solnType.

Referenced by AssemblyMap().

◆ GetGlobalToUniversalBndMap()

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetGlobalToUniversalBndMap ( )

Definition at line 983 of file AssemblyMap.cpp.

984{
985 return m_globalToUniversalBndMap;
986}

References m_globalToUniversalBndMap.

Referenced by AssemblyMap().

◆ GetGlobalToUniversalBndMapUnique()

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetGlobalToUniversalBndMapUnique ( )

Definition at line 988 of file AssemblyMap.cpp.

989{
990 return m_globalToUniversalBndMapUnique;
991}

References m_globalToUniversalBndMapUnique.

Referenced by AssemblyMap().

◆ GetGlobalToUniversalMap() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetGlobalToUniversalMap ( )

Definition at line 774 of file AssemblyMap.cpp.

775{
776 return v_GetGlobalToUniversalMap();
777}
Nektar::MultiRegions::AssemblyMap::v_GetGlobalToUniversalMap
virtual const Array< OneD, const int > & v_GetGlobalToUniversalMap()
Definition: AssemblyMap.cpp:581

References v_GetGlobalToUniversalMap().

◆ GetGlobalToUniversalMap() [2/2]

int Nektar::MultiRegions::AssemblyMap::GetGlobalToUniversalMap ( const int  i) const

Definition at line 759 of file AssemblyMap.cpp.

760{
761 return v_GetGlobalToUniversalMap(i);
762}

References v_GetGlobalToUniversalMap().

◆ GetGlobalToUniversalMapUnique() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetGlobalToUniversalMapUnique ( )

Definition at line 779 of file AssemblyMap.cpp.

780{
781 return v_GetGlobalToUniversalMapUnique();
782}
Nektar::MultiRegions::AssemblyMap::v_GetGlobalToUniversalMapUnique
virtual const Array< OneD, const int > & v_GetGlobalToUniversalMapUnique()
Definition: AssemblyMap.cpp:588

References v_GetGlobalToUniversalMapUnique().

◆ GetGlobalToUniversalMapUnique() [2/2]

int Nektar::MultiRegions::AssemblyMap::GetGlobalToUniversalMapUnique ( const int  i) const

Definition at line 764 of file AssemblyMap.cpp.

765{
766 return v_GetGlobalToUniversalMapUnique(i);
767}

References v_GetGlobalToUniversalMapUnique().

◆ GetHash()

size_t Nektar::MultiRegions::AssemblyMap::GetHash ( ) const

Retrieves the hash of this map.

Definition at line 749 of file AssemblyMap.cpp.

750{
751 return m_hash;
752}

References m_hash.

◆ GetIterativeTolerance()

NekDouble Nektar::MultiRegions::AssemblyMap::GetIterativeTolerance ( ) const

Definition at line 1377 of file AssemblyMap.cpp.

1378{
1379 return m_iterativeTolerance;
1380}

References m_iterativeTolerance.

◆ GetLinSysIterSolver()

std::string Nektar::MultiRegions::AssemblyMap::GetLinSysIterSolver ( ) const

Definition at line 1397 of file AssemblyMap.cpp.

1398{
1399 return m_linSysIterSolver;
1400}

References m_linSysIterSolver.

◆ GetLocalToGlobalBndMap() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalBndMap ( void  )

Retrieve the global indices of the local boundary modes.

Definition at line 968 of file AssemblyMap.cpp.

969{
970 return m_localToGlobalBndMap;
971}

References m_localToGlobalBndMap.

◆ GetLocalToGlobalBndMap() [2/2]

int Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalBndMap ( const int  i) const

Retrieve the global index of a given local boundary mode.

Definition at line 963 of file AssemblyMap.cpp.

964{
965 return m_localToGlobalBndMap[i];
966}

References m_localToGlobalBndMap.

Referenced by AssemblyMap().

◆ GetLocalToGlobalBndSign() [1/2]

Array< OneD, const NekDouble > Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalBndSign ( void  ) const

Retrieve the sign change for all local boundary modes.

Definition at line 978 of file AssemblyMap.cpp.

979{
980 return m_localToGlobalBndSign;
981}

References m_localToGlobalBndSign.

Referenced by Nektar::MultiRegions::AssemblyMapDG::v_GetLocalToGlobalSign().

◆ GetLocalToGlobalBndSign() [2/2]

NekDouble Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalBndSign ( const int  i) const

Retrieve the sign change of a given local boundary mode.

Definition at line 993 of file AssemblyMap.cpp.

994{
995 if (m_signChange)
996 {
997 return m_localToGlobalBndSign[i];
998 }
999 else
1000 {
1001 return 1.0;
1002 }
1003}

References m_localToGlobalBndSign, and m_signChange.

Referenced by AssemblyMap().

◆ GetLocalToGlobalMap() [1/2]

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalMap ( )

Definition at line 769 of file AssemblyMap.cpp.

770{
771 return v_GetLocalToGlobalMap();
772}
Nektar::MultiRegions::AssemblyMap::v_GetLocalToGlobalMap
virtual const Array< OneD, const int > & v_GetLocalToGlobalMap()
Definition: AssemblyMap.cpp:574

References v_GetLocalToGlobalMap().

◆ GetLocalToGlobalMap() [2/2]

int Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalMap ( const int  i) const

Definition at line 754 of file AssemblyMap.cpp.

755{
756 return v_GetLocalToGlobalMap(i);
757}

References v_GetLocalToGlobalMap().

◆ GetLocalToGlobalSign() [1/2]

const Array< OneD, NekDouble > & Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalSign ( ) const

Definition at line 789 of file AssemblyMap.cpp.

790{
791 return v_GetLocalToGlobalSign();
792}
Nektar::MultiRegions::AssemblyMap::v_GetLocalToGlobalSign
virtual const Array< OneD, NekDouble > & v_GetLocalToGlobalSign() const
Definition: AssemblyMap.cpp:602

References v_GetLocalToGlobalSign().

◆ GetLocalToGlobalSign() [2/2]

NekDouble Nektar::MultiRegions::AssemblyMap::GetLocalToGlobalSign ( const int  i) const

Definition at line 784 of file AssemblyMap.cpp.

785{
786 return v_GetLocalToGlobalSign(i);
787}

References v_GetLocalToGlobalSign().

◆ GetLowestStaticCondLevel()

int Nektar::MultiRegions::AssemblyMap::GetLowestStaticCondLevel ( ) const
inline

Definition at line 317 of file AssemblyMap.h.

318 {
319 return m_lowestStaticCondLevel;
320 }

References m_lowestStaticCondLevel.

◆ GetMaxIterations()

int Nektar::MultiRegions::AssemblyMap::GetMaxIterations ( ) const

Definition at line 1387 of file AssemblyMap.cpp.

1388{
1389 return m_maxIterations;
1390}

References m_maxIterations.

◆ GetNextLevelLocalToGlobalMap()

const AssemblyMapSharedPtr Nektar::MultiRegions::AssemblyMap::GetNextLevelLocalToGlobalMap ( ) const

Returns the local to global mapping for the next level in the multi-level static condensation.

Definition at line 1352 of file AssemblyMap.cpp.

1353{
1354 return m_nextLevelLocalToGlobalMap;
1355}

References m_nextLevelLocalToGlobalMap.

◆ GetNumDirEdges()

int Nektar::MultiRegions::AssemblyMap::GetNumDirEdges ( ) const

Definition at line 932 of file AssemblyMap.cpp.

933{
934 return v_GetNumDirEdges();
935}
Nektar::MultiRegions::AssemblyMap::v_GetNumDirEdges
virtual int v_GetNumDirEdges() const
Definition: AssemblyMap.cpp:699

References v_GetNumDirEdges().

◆ GetNumDirFaces()

int Nektar::MultiRegions::AssemblyMap::GetNumDirFaces ( ) const

Definition at line 937 of file AssemblyMap.cpp.

938{
939 return v_GetNumDirFaces();
940}
Nektar::MultiRegions::AssemblyMap::v_GetNumDirFaces
virtual int v_GetNumDirFaces() const
Definition: AssemblyMap.cpp:705

References v_GetNumDirFaces().

◆ GetNumGlobalBndCoeffs()

int Nektar::MultiRegions::AssemblyMap::GetNumGlobalBndCoeffs ( ) const

Returns the total number of global boundary coefficients.

Definition at line 1046 of file AssemblyMap.cpp.

1047{
1048 return m_numGlobalBndCoeffs;
1049}

References m_numGlobalBndCoeffs.

Referenced by AssemblyMap().

◆ GetNumGlobalCoeffs()

int Nektar::MultiRegions::AssemblyMap::GetNumGlobalCoeffs ( ) const

Returns the total number of global coefficients.

Definition at line 1056 of file AssemblyMap.cpp.

1057{
1058 return m_numGlobalCoeffs;
1059}

References m_numGlobalCoeffs.

◆ GetNumGlobalDirBndCoeffs()

int Nektar::MultiRegions::AssemblyMap::GetNumGlobalDirBndCoeffs ( ) const

Returns the number of global Dirichlet boundary coefficients.

Definition at line 1031 of file AssemblyMap.cpp.

1032{
1033 return m_numGlobalDirBndCoeffs;
1034}

References m_numGlobalDirBndCoeffs.

Referenced by AssemblyMap().

◆ GetNumLocalBndCoeffs()

int Nektar::MultiRegions::AssemblyMap::GetNumLocalBndCoeffs ( ) const

Returns the total number of local boundary coefficients.

Definition at line 1041 of file AssemblyMap.cpp.

1042{
1043 return m_numLocalBndCoeffs;
1044}

References m_numLocalBndCoeffs.

Referenced by AssemblyMap().

◆ GetNumLocalBndCoeffsPerPatch()

const Array< OneD, const unsigned int > & Nektar::MultiRegions::AssemblyMap::GetNumLocalBndCoeffsPerPatch ( )

Returns the number of local boundary coefficients in each patch.

Definition at line 1341 of file AssemblyMap.cpp.

1342{
1343 return m_numLocalBndCoeffsPerPatch;
1344}

References m_numLocalBndCoeffsPerPatch.

Referenced by AssemblyMap().

◆ GetNumLocalCoeffs()

int Nektar::MultiRegions::AssemblyMap::GetNumLocalCoeffs ( ) const

Returns the total number of local coefficients.

Definition at line 1051 of file AssemblyMap.cpp.

1052{
1053 return m_numLocalCoeffs;
1054}

References m_numLocalCoeffs.

◆ GetNumLocalDirBndCoeffs()

int Nektar::MultiRegions::AssemblyMap::GetNumLocalDirBndCoeffs ( ) const

Returns the number of local Dirichlet boundary coefficients.

Definition at line 1036 of file AssemblyMap.cpp.

1037{
1038 return m_numLocalDirBndCoeffs;
1039}

References m_numLocalDirBndCoeffs.

Referenced by AssemblyMap().

◆ GetNumLocalIntCoeffsPerPatch()

const Array< OneD, const unsigned int > & Nektar::MultiRegions::AssemblyMap::GetNumLocalIntCoeffsPerPatch ( )

Returns the number of local interior coefficients in each patch.

Definition at line 1347 of file AssemblyMap.cpp.

1348{
1349 return m_numLocalIntCoeffsPerPatch;
1350}

References m_numLocalIntCoeffsPerPatch.

◆ GetNumNonDirEdgeModes()

int Nektar::MultiRegions::AssemblyMap::GetNumNonDirEdgeModes ( ) const

Definition at line 922 of file AssemblyMap.cpp.

923{
924 return v_GetNumNonDirEdgeModes();
925}
Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirEdgeModes
virtual int v_GetNumNonDirEdgeModes() const
Definition: AssemblyMap.cpp:687

References v_GetNumNonDirEdgeModes().

◆ GetNumNonDirEdges()

int Nektar::MultiRegions::AssemblyMap::GetNumNonDirEdges ( ) const

Definition at line 942 of file AssemblyMap.cpp.

943{
944 return v_GetNumNonDirEdges();
945}
Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirEdges
virtual int v_GetNumNonDirEdges() const
Definition: AssemblyMap.cpp:711

References v_GetNumNonDirEdges().

◆ GetNumNonDirFaceModes()

int Nektar::MultiRegions::AssemblyMap::GetNumNonDirFaceModes ( ) const

Definition at line 927 of file AssemblyMap.cpp.

928{
929 return v_GetNumNonDirFaceModes();
930}
Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirFaceModes
virtual int v_GetNumNonDirFaceModes() const
Definition: AssemblyMap.cpp:693

References v_GetNumNonDirFaceModes().

◆ GetNumNonDirFaces()

int Nektar::MultiRegions::AssemblyMap::GetNumNonDirFaces ( ) const

Definition at line 947 of file AssemblyMap.cpp.

948{
949 return v_GetNumNonDirFaces();
950}
Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirFaces
virtual int v_GetNumNonDirFaces() const
Definition: AssemblyMap.cpp:717

References v_GetNumNonDirFaces().

◆ GetNumNonDirVertexModes()

int Nektar::MultiRegions::AssemblyMap::GetNumNonDirVertexModes ( ) const

Definition at line 917 of file AssemblyMap.cpp.

918{
919 return v_GetNumNonDirVertexModes();
920}
Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirVertexModes
virtual int v_GetNumNonDirVertexModes() const
Definition: AssemblyMap.cpp:681

References v_GetNumNonDirVertexModes().

◆ GetNumPatches()

int Nektar::MultiRegions::AssemblyMap::GetNumPatches ( ) const

Returns the number of patches in this static condensation level.

Definition at line 1335 of file AssemblyMap.cpp.

1336{
1337 return m_numPatches;
1338}

References m_numPatches.

Referenced by AssemblyMap().

◆ GetPatchMapFromPrevLevel()

const PatchMapSharedPtr & Nektar::MultiRegions::AssemblyMap::GetPatchMapFromPrevLevel ( void  ) const

Returns the patch map from the previous level of the multi-level static condensation.

Definition at line 1357 of file AssemblyMap.cpp.

1358{
1359 return m_patchMapFromPrevLevel;
1360}

References m_patchMapFromPrevLevel.

◆ GetPreconType()

std::string Nektar::MultiRegions::AssemblyMap::GetPreconType ( ) const

Definition at line 1372 of file AssemblyMap.cpp.

1373{
1374 return m_preconType;
1375}

References m_preconType.

◆ GetSignChange()

bool Nektar::MultiRegions::AssemblyMap::GetSignChange ( )

Returns true if using a modal expansion requiring a change of sign of some modes.

Definition at line 973 of file AssemblyMap.cpp.

974{
975 return m_signChange;
976}

References m_signChange.

Referenced by AssemblyMap().

◆ GetSingularSystem()

bool Nektar::MultiRegions::AssemblyMap::GetSingularSystem ( ) const

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

Definition at line 1061 of file AssemblyMap.cpp.

1062{
1063 return m_systemSingular;
1064}
Nektar::MultiRegions::AssemblyMap::m_systemSingular
bool m_systemSingular
Flag indicating if the system is singular or not.
Definition: AssemblyMap.h:356

References m_systemSingular.

◆ GetStaticCondLevel()

int Nektar::MultiRegions::AssemblyMap::GetStaticCondLevel ( ) const

Returns the level of static condensation for this map.

Definition at line 1330 of file AssemblyMap.cpp.

1331{
1332 return m_staticCondLevel;
1333}

References m_staticCondLevel.

Referenced by AssemblyMap().

◆ GetSuccessiveRHS()

int Nektar::MultiRegions::AssemblyMap::GetSuccessiveRHS ( ) const

Definition at line 1392 of file AssemblyMap.cpp.

1393{
1394 return m_successiveRHS;
1395}

References m_successiveRHS.

◆ GetVariable()

std::string Nektar::MultiRegions::AssemblyMap::GetVariable ( )

Retrieves the variable string.

Definition at line 744 of file AssemblyMap.cpp.

745{
746 return m_variable;
747}

References m_variable.

◆ GlobalToLocal() [1/2]

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

Definition at line 808 of file AssemblyMap.cpp.

810{
811 v_GlobalToLocal(global, loc);
812}
Nektar::MultiRegions::AssemblyMap::v_GlobalToLocal
virtual void v_GlobalToLocal(const Array< OneD, const NekDouble > &global, Array< OneD, NekDouble > &loc) const
Definition: AssemblyMap.cpp:625

References CG_Iterations::loc, and v_GlobalToLocal().

Referenced by Nektar::MultiRegions::AssemblyMapCG::v_GlobalToLocal().

◆ GlobalToLocal() [2/2]

void Nektar::MultiRegions::AssemblyMap::GlobalToLocal ( const NekVector< NekDouble > &  global,
NekVector< NekDouble > &  loc 
) const

Definition at line 814 of file AssemblyMap.cpp.

816{
817 v_GlobalToLocal(global, loc);
818}

References CG_Iterations::loc, and v_GlobalToLocal().

◆ GlobalToLocalBnd() [1/4]

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

Definition at line 1104 of file AssemblyMap.cpp.

1106{
1107 ASSERTL1(loc.size() >= m_numLocalBndCoeffs,
1108 "Local vector is not of correct dimension");
1109 ASSERTL1(global.size() >= m_numGlobalBndCoeffs,
1110 "Global vector is not of correct dimension");
1111
1112 Array<OneD, const NekDouble> glo;
1113 if (global.data() == loc.data())
1114 {
1115 glo = Array<OneD, NekDouble>(m_numLocalBndCoeffs, global.data());
1116 }
1117 else
1118 {
1119 glo = global; // create reference
1120 }
1121
1122 if (m_signChange)
1123 {
1124 Vmath::Gathr(m_numLocalBndCoeffs, m_localToGlobalBndSign.get(),
1125 glo.get(), m_localToGlobalBndMap.get(), loc.get());
1126 }
1127 else
1128 {
1129 Vmath::Gathr(m_numLocalBndCoeffs, glo.get(),
1130 m_localToGlobalBndMap.get(), loc.get());
1131 }
1132}
Vmath::Gathr
void Gathr(int n, const T *sign, const T *x, const int *y, T *z)
Gather vector z[i] = sign[i]*x[y[i]].
Definition: Vmath.cpp:800

References ASSERTL1, Vmath::Gathr(), CG_Iterations::loc, m_localToGlobalBndMap, m_localToGlobalBndSign, m_numGlobalBndCoeffs, m_numLocalBndCoeffs, and m_signChange.

◆ GlobalToLocalBnd() [2/4]

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

Definition at line 1078 of file AssemblyMap.cpp.

1081{
1082 ASSERTL1(loc.size() >= m_numLocalBndCoeffs,
1083 "Local vector is not of correct dimension");
1084 ASSERTL1(global.size() >= m_numGlobalBndCoeffs - offset,
1085 "Global vector is not of correct dimension");
1086
1087 // offset input data by length "offset" for Dirichlet boundary conditions.
1088 Array<OneD, NekDouble> tmp(m_numGlobalBndCoeffs, 0.0);
1089 Vmath::Vcopy(m_numGlobalBndCoeffs - offset, global.get(), 1,
1090 tmp.get() + offset, 1);
1091
1092 if (m_signChange)
1093 {
1094 Vmath::Gathr(m_numLocalBndCoeffs, m_localToGlobalBndSign.get(),
1095 tmp.get(), m_localToGlobalBndMap.get(), loc.get());
1096 }
1097 else
1098 {
1099 Vmath::Gathr(m_numLocalBndCoeffs, tmp.get(),
1100 m_localToGlobalBndMap.get(), loc.get());
1101 }
1102}

References ASSERTL1, Vmath::Gathr(), CG_Iterations::loc, m_localToGlobalBndMap, m_localToGlobalBndSign, m_numGlobalBndCoeffs, m_numLocalBndCoeffs, m_signChange, and Vmath::Vcopy().

◆ GlobalToLocalBnd() [3/4]

void Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd ( const NekVector< NekDouble > &  global,
NekVector< NekDouble > &  loc 
) const

Definition at line 1072 of file AssemblyMap.cpp.

1074{
1075 GlobalToLocalBnd(global.GetPtr(), loc.GetPtr());
1076}
Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd
void GlobalToLocalBnd(const NekVector< NekDouble > &global, NekVector< NekDouble > &loc, int offset) const
Definition: AssemblyMap.cpp:1066

References Nektar::NekVector< DataType >::GetPtr(), GlobalToLocalBnd(), and CG_Iterations::loc.

◆ GlobalToLocalBnd() [4/4]

void Nektar::MultiRegions::AssemblyMap::GlobalToLocalBnd ( const NekVector< NekDouble > &  global,
NekVector< NekDouble > &  loc,
int  offset 
) const

Definition at line 1066 of file AssemblyMap.cpp.

1068{
1069 GlobalToLocalBnd(global.GetPtr(), loc.GetPtr(), offset);
1070}

References Nektar::NekVector< DataType >::GetPtr(), GlobalToLocalBnd(), and CG_Iterations::loc.

Referenced by GlobalToLocalBnd(), and Nektar::MultiRegions::AssemblyMapDG::v_GlobalToLocal().

◆ GlobalToLocalBndWithoutSign()

void Nektar::MultiRegions::AssemblyMap::GlobalToLocalBndWithoutSign ( const Array< OneD, const NekDouble > &  global,
Array< OneD, NekDouble > &  loc 
)
protected

Definition at line 1402 of file AssemblyMap.cpp.

1404{
1405 ASSERTL1(loc.size() >= m_numLocalBndCoeffs,
1406 "Local vector is not of correct dimension");
1407 ASSERTL1(global.size() >= m_numGlobalBndCoeffs,
1408 "Global vector is not of correct dimension");
1409
1410 Vmath::Gathr(m_numLocalBndCoeffs, global.get(), m_localToGlobalBndMap.get(),
1411 loc.get());
1412}

References ASSERTL1, Vmath::Gathr(), CG_Iterations::loc, m_localToGlobalBndMap, m_numGlobalBndCoeffs, and m_numLocalBndCoeffs.

Referenced by AssemblyMap().

◆ IsAbsoluteTolerance()

bool Nektar::MultiRegions::AssemblyMap::IsAbsoluteTolerance ( ) const

Definition at line 1382 of file AssemblyMap.cpp.

1383{
1384 return m_isAbsoluteTolerance;
1385}

References m_isAbsoluteTolerance.

◆ LinearSpaceMap()

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

Definition at line 957 of file AssemblyMap.cpp.

959{
960 return v_LinearSpaceMap(locexp, solnType);
961}
Nektar::MultiRegions::AssemblyMap::v_LinearSpaceMap
virtual std::shared_ptr< AssemblyMap > v_LinearSpaceMap(const ExpList &locexp, GlobalSysSolnType solnType)
Generate a linear space mapping from existing mapping.
Definition: AssemblyMap.cpp:730

References v_LinearSpaceMap().

◆ LocalBndToGlobal() [1/2]

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

Definition at line 1166 of file AssemblyMap.cpp.

1169{
1170 ASSERTL1(loc.size() >= m_numLocalBndCoeffs,
1171 "Local vector is not of correct dimension");
1172 ASSERTL1(global.size() >= m_numGlobalBndCoeffs,
1173 "Global vector is not of correct dimension");
1174
1175 if (m_signChange)
1176 {
1177 Vmath::Scatr(m_numLocalBndCoeffs, m_localToGlobalBndSign.get(),
1178 loc.get(), m_localToGlobalBndMap.get(), global.get());
1179 }
1180 else
1181 {
1182 Vmath::Scatr(m_numLocalBndCoeffs, loc.get(),
1183 m_localToGlobalBndMap.get(), global.get());
1184 }
1185 if (UseComm)
1186 {
1187 Gs::Gather(global, Gs::gs_max, m_bndGsh);
1188 }
1189}
Gs::Gather
static void Gather(Nektar::Array< OneD, NekDouble > pU, gs_op pOp, gs_data *pGsh, Nektar::Array< OneD, NekDouble > pBuffer=NullNekDouble1DArray)
Performs a gather-scatter operation of the provided values.
Definition: GsLib.hpp:270
Gs::gs_max
@ gs_max
Definition: GsLib.hpp:65
Vmath::Scatr
void Scatr(int n, const T *x, const int *y, T *z)
Scatter vector z[y[i]] = x[i].
Definition: Vmath.cpp:817

References ASSERTL1, Gs::Gather(), Gs::gs_max, CG_Iterations::loc, m_bndGsh, m_localToGlobalBndMap, m_localToGlobalBndSign, m_numGlobalBndCoeffs, m_numLocalBndCoeffs, m_signChange, and Vmath::Scatr().

◆ LocalBndToGlobal() [2/2]

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

Definition at line 1134 of file AssemblyMap.cpp.

1137{
1138 ASSERTL1(loc.size() >= m_numLocalBndCoeffs,
1139 "Local vector is not of correct dimension");
1140 ASSERTL1(global.size() >= m_numGlobalBndCoeffs - offset,
1141 "Global vector is not of correct dimension");
1142
1143 // offset input data by length "offset" for Dirichlet boundary conditions.
1144 Array<OneD, NekDouble> tmp(m_numGlobalBndCoeffs, 0.0);
1145
1146 if (m_signChange)
1147 {
1148 Vmath::Scatr(m_numLocalBndCoeffs, m_localToGlobalBndSign.get(),
1149 loc.get(), m_localToGlobalBndMap.get(), tmp.get());
1150 }
1151 else
1152 {
1153 Vmath::Scatr(m_numLocalBndCoeffs, loc.get(),
1154 m_localToGlobalBndMap.get(), tmp.get());
1155 }
1156
1157 // Ensure each processor has unique value with a max gather.
1158 if (UseComm)
1159 {
1160 Gs::Gather(tmp, Gs::gs_max, m_bndGsh);
1161 }
1162 Vmath::Vcopy(m_numGlobalBndCoeffs - offset, tmp.get() + offset, 1,
1163 global.get(), 1);
1164}

References ASSERTL1, Gs::Gather(), Gs::gs_max, CG_Iterations::loc, m_bndGsh, m_localToGlobalBndMap, m_localToGlobalBndSign, m_numGlobalBndCoeffs, m_numLocalBndCoeffs, m_signChange, Vmath::Scatr(), and Vmath::Vcopy().

Referenced by Nektar::MultiRegions::AssemblyMapDG::v_LocalToGlobal().

◆ LocalBndToLocal()

void Nektar::MultiRegions::AssemblyMap::LocalBndToLocal ( const Array< OneD, const NekDouble > &  locbnd,
Array< OneD, NekDouble > &  local 
) const

Definition at line 1215 of file AssemblyMap.cpp.

1217{
1218 ASSERTL1(locbnd.size() >= m_numLocalBndCoeffs,
1219 "LocBnd vector is not of correct dimension");
1220 ASSERTL1(local.size() >= m_numLocalCoeffs,
1221 "Local vector is not of correct dimension");
1222
1223 Vmath::Scatr(m_numLocalBndCoeffs, locbnd.get(), m_localToLocalBndMap.get(),
1224 local.get());
1225}

References ASSERTL1, m_localToLocalBndMap, m_numLocalBndCoeffs, m_numLocalCoeffs, and Vmath::Scatr().

◆ LocalIntToLocal()

void Nektar::MultiRegions::AssemblyMap::LocalIntToLocal ( const Array< OneD, const NekDouble > &  locbnd,
Array< OneD, NekDouble > &  local 
) const

Definition at line 1227 of file AssemblyMap.cpp.

1229{
1230 ASSERTL1(locint.size() >= m_numLocalCoeffs - m_numLocalBndCoeffs,
1231 "LocBnd vector is not of correct dimension");
1232 ASSERTL1(local.size() >= m_numLocalCoeffs,
1233 "Local vector is not of correct dimension");
1234
1235 Vmath::Scatr(m_numLocalCoeffs - m_numLocalBndCoeffs, locint.get(),
1236 m_localToLocalIntMap.get(), local.get());
1237}

References ASSERTL1, m_localToLocalIntMap, m_numLocalBndCoeffs, m_numLocalCoeffs, and Vmath::Scatr().

◆ LocalToGlobal() [1/2]

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

Definition at line 794 of file AssemblyMap.cpp.

797{
798 v_LocalToGlobal(loc, global, useComm);
799}
Nektar::MultiRegions::AssemblyMap::v_LocalToGlobal
virtual void v_LocalToGlobal(const Array< OneD, const NekDouble > &loc, Array< OneD, NekDouble > &global, bool useComm) const
Definition: AssemblyMap.cpp:609

References CG_Iterations::loc, and v_LocalToGlobal().

Referenced by Nektar::MultiRegions::AssemblyMapCG::v_LocalToGlobal().

◆ LocalToGlobal() [2/2]

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

Definition at line 801 of file AssemblyMap.cpp.

804{
805 v_LocalToGlobal(loc, global, useComm);
806}

References CG_Iterations::loc, and v_LocalToGlobal().

◆ LocalToLocalBnd()

void Nektar::MultiRegions::AssemblyMap::LocalToLocalBnd ( const Array< OneD, const NekDouble > &  local,
Array< OneD, NekDouble > &  locbnd 
) const

Definition at line 1191 of file AssemblyMap.cpp.

1193{
1194 ASSERTL1(locbnd.size() >= m_numLocalBndCoeffs,
1195 "LocBnd vector is not of correct dimension");
1196 ASSERTL1(local.size() >= m_numLocalCoeffs,
1197 "Local vector is not of correct dimension");
1198
1199 Vmath::Gathr(m_numLocalBndCoeffs, local.get(), m_localToLocalBndMap.get(),
1200 locbnd.get());
1201}

References ASSERTL1, Vmath::Gathr(), m_localToLocalBndMap, m_numLocalBndCoeffs, and m_numLocalCoeffs.

◆ LocalToLocalInt()

void Nektar::MultiRegions::AssemblyMap::LocalToLocalInt ( const Array< OneD, const NekDouble > &  local,
Array< OneD, NekDouble > &  locint 
) const

Definition at line 1203 of file AssemblyMap.cpp.

1205{
1206 ASSERTL1(locint.size() >= m_numLocalCoeffs - m_numLocalBndCoeffs,
1207 "Locint vector is not of correct dimension");
1208 ASSERTL1(local.size() >= m_numLocalCoeffs,
1209 "Local vector is not of correct dimension");
1210
1211 Vmath::Gathr(m_numLocalCoeffs - m_numLocalBndCoeffs, local.get(),
1212 m_localToLocalIntMap.get(), locint.get());
1213}

References ASSERTL1, Vmath::Gathr(), m_localToLocalIntMap, m_numLocalBndCoeffs, and m_numLocalCoeffs.

◆ PatchAssemble()

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

Definition at line 888 of file AssemblyMap.cpp.

890{
891 Array<OneD, const NekDouble> local;
892 Array<OneD, const int> map = m_patchMapFromPrevLevel->GetNewLevelMap();
893 Array<OneD, const NekDouble> sign = m_patchMapFromPrevLevel->GetSign();
894
895 if (global.data() == loc.data())
896 {
897 local = Array<OneD, NekDouble>(map.size(), loc.data());
898 }
899 else
900 {
901 local = loc; // create reference
902 }
903
904 // since we are calling mapping from level down from array
905 // the m_numLocaBndCoeffs represents the size of the
906 // boundary elements we need to assemble into
907 Vmath::Zero(m_numLocalCoeffs, global.get(), 1);
908
909 Vmath::Assmb(map.size(), sign.get(), local.get(), map.get(), global.get());
910}

References Vmath::Assmb(), CG_Iterations::loc, m_numLocalCoeffs, m_patchMapFromPrevLevel, sign, and Vmath::Zero().

◆ PatchGlobalToLocal()

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

Definition at line 868 of file AssemblyMap.cpp.

870{
871 Array<OneD, const NekDouble> glo;
872
873 Array<OneD, const int> map = m_patchMapFromPrevLevel->GetNewLevelMap();
874 Array<OneD, const NekDouble> sign = m_patchMapFromPrevLevel->GetSign();
875
876 if (global.data() == loc.data())
877 {
878 glo = Array<OneD, NekDouble>(global.size(), global.data());
879 }
880 else
881 {
882 glo = global; // create reference
883 }
884
885 Vmath::Gathr(map.size(), sign.get(), glo.get(), map.get(), loc.get());
886}

References Vmath::Gathr(), CG_Iterations::loc, m_patchMapFromPrevLevel, and sign.

◆ PatchLocalToGlobal()

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

Definition at line 848 of file AssemblyMap.cpp.

850{
851 Array<OneD, const NekDouble> local;
852
853 Array<OneD, const int> map = m_patchMapFromPrevLevel->GetNewLevelMap();
854 Array<OneD, const NekDouble> sign = m_patchMapFromPrevLevel->GetSign();
855
856 if (global.data() == loc.data())
857 {
858 local = Array<OneD, NekDouble>(map.size(), loc.data());
859 }
860 else
861 {
862 local = loc; // create reference
863 }
864
865 Vmath::Scatr(map.size(), sign.get(), local.get(), map.get(), global.get());
866}

References CG_Iterations::loc, m_patchMapFromPrevLevel, Vmath::Scatr(), and sign.

◆ PrintStats()

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

Definition at line 1414 of file AssemblyMap.cpp.

1416{
1417 LibUtilities::CommSharedPtr vRowComm = m_session->GetComm()->GetRowComm();
1418 bool isRoot = vRowComm->GetRank() == 0;
1419 int n = vRowComm->GetSize();
1420 int i;
1421
1422 // Determine number of global degrees of freedom.
1423 int globBndCnt = 0, globDirCnt = 0;
1424
1425 for (i = 0; i < m_numGlobalBndCoeffs; ++i)
1426 {
1427 if (m_globalToUniversalBndMapUnique[i] > 0)
1428 {
1429 globBndCnt++;
1430
1431 if (i < m_numGlobalDirBndCoeffs)
1432 {
1433 globDirCnt++;
1434 }
1435 }
1436 }
1437
1438 int globCnt = m_numGlobalCoeffs - m_numGlobalBndCoeffs + globBndCnt;
1439
1440 // Calculate maximum valency
1441 Array<OneD, NekDouble> tmpLoc(m_numLocalBndCoeffs, 1.0);
1442 Array<OneD, NekDouble> tmpGlob(m_numGlobalBndCoeffs, 0.0);
1443
1444 Vmath::Assmb(m_numLocalBndCoeffs, tmpLoc.get(), m_localToGlobalBndMap.get(),
1445 tmpGlob.get());
1446 UniversalAssembleBnd(tmpGlob);
1447
1448 int totGlobDof = globCnt;
1449 int totGlobBndDof = globBndCnt;
1450 int totGlobDirDof = globDirCnt;
1451 int totLocalDof = m_numLocalCoeffs;
1452 int totLocalBndDof = m_numLocalBndCoeffs;
1453 int totLocalDirDof = m_numLocalDirBndCoeffs;
1454
1455 int meanValence = 0;
1456 int maxValence = 0;
1457 int minValence = 10000000;
1458 for (int i = 0; i < m_numGlobalBndCoeffs; ++i)
1459 {
1460 if (!m_globalToUniversalBndMapUnique[i])
1461 {
1462 continue;
1463 }
1464
1465 if (tmpGlob[i] > maxValence)
1466 {
1467 maxValence = tmpGlob[i];
1468 }
1469 if (tmpGlob[i] < minValence)
1470 {
1471 minValence = tmpGlob[i];
1472 }
1473 meanValence += tmpGlob[i];
1474 }
1475
1476 vRowComm->AllReduce(maxValence, LibUtilities::ReduceMax);
1477 vRowComm->AllReduce(minValence, LibUtilities::ReduceMin);
1478 vRowComm->AllReduce(meanValence, LibUtilities::ReduceSum);
1479 vRowComm->AllReduce(totGlobDof, LibUtilities::ReduceSum);
1480 vRowComm->AllReduce(totGlobBndDof, LibUtilities::ReduceSum);
1481 vRowComm->AllReduce(totGlobDirDof, LibUtilities::ReduceSum);
1482 vRowComm->AllReduce(totLocalDof, LibUtilities::ReduceSum);
1483 vRowComm->AllReduce(totLocalBndDof, LibUtilities::ReduceSum);
1484 vRowComm->AllReduce(totLocalDirDof, LibUtilities::ReduceSum);
1485
1486 meanValence /= totGlobBndDof;
1487
1488 if (isRoot)
1489 {
1490 if (printHeader)
1491 {
1492 out << "Assembly map statistics for field " << variable << ":"
1493 << endl;
1494 }
1495
1496 out << " - Number of local/global dof : " << totLocalDof
1497 << " " << totGlobDof << endl;
1498 out << " - Number of local/global boundary dof : " << totLocalBndDof
1499 << " " << totGlobBndDof << endl;
1500 out << " - Number of local/global Dirichlet dof : " << totLocalDirDof
1501 << " " << totGlobDirDof << endl;
1502 out << " - dof valency (min/max/mean) : " << minValence
1503 << " " << maxValence << " " << meanValence << endl;
1504
1505 if (n > 1)
1506 {
1507 NekDouble mean = m_numLocalCoeffs, mean2 = mean * mean;
1508 NekDouble minval = mean, maxval = mean;
1509 Array<OneD, NekDouble> tmp(1);
1510
1511 for (i = 1; i < n; ++i)
1512 {
1513 vRowComm->Recv(i, tmp);
1514 mean += tmp[0];
1515 mean2 += tmp[0] * tmp[0];
1516
1517 if (tmp[0] > maxval)
1518 {
1519 maxval = tmp[0];
1520 }
1521 if (tmp[0] < minval)
1522 {
1523 minval = tmp[0];
1524 }
1525 }
1526
1527 if (maxval > 0.1)
1528 {
1529 out << " - Local dof dist. (min/max/mean/dev) : " << minval
1530 << " " << maxval << " " << (mean / n) << " "
1531 << sqrt(mean2 / n - mean * mean / n / n) << endl;
1532 }
1533
1534 vRowComm->Block();
1535
1536 mean = minval = maxval = m_numLocalBndCoeffs;
1537 mean2 = mean * mean;
1538
1539 for (i = 1; i < n; ++i)
1540 {
1541 vRowComm->Recv(i, tmp);
1542 mean += tmp[0];
1543 mean2 += tmp[0] * tmp[0];
1544
1545 if (tmp[0] > maxval)
1546 {
1547 maxval = tmp[0];
1548 }
1549 if (tmp[0] < minval)
1550 {
1551 minval = tmp[0];
1552 }
1553 }
1554
1555 out << " - Local bnd dof dist. (min/max/mean/dev) : " << minval
1556 << " " << maxval << " " << (mean / n) << " "
1557 << sqrt(mean2 / n - mean * mean / n / n) << endl;
1558 }
1559 }
1560 else
1561 {
1562 Array<OneD, NekDouble> tmp(1);
1563 tmp[0] = m_numLocalCoeffs;
1564 vRowComm->Send(0, tmp);
1565 vRowComm->Block();
1566 tmp[0] = m_numLocalBndCoeffs;
1567 vRowComm->Send(0, tmp);
1568 }
1569
1570 // Either we have no more levels in the static condensation, or we
1571 // are not multi-level.
1572 if (!m_nextLevelLocalToGlobalMap)
1573 {
1574 return;
1575 }
1576
1577 int level = 2;
1578 AssemblyMapSharedPtr tmp = m_nextLevelLocalToGlobalMap;
1579 while (tmp->m_nextLevelLocalToGlobalMap)
1580 {
1581 tmp = tmp->m_nextLevelLocalToGlobalMap;
1582 ++level;
1583 }
1584
1585 // Print out multi-level static condensation information.
1586 if (n > 1)
1587 {
1588 if (isRoot)
1589 {
1590 NekDouble mean = level, mean2 = mean * mean;
1591 int minval = level, maxval = level;
1592
1593 Array<OneD, NekDouble> tmpRecv(1);
1594 for (i = 1; i < n; ++i)
1595 {
1596 vRowComm->Recv(i, tmpRecv);
1597 mean += tmpRecv[0];
1598 mean2 += tmpRecv[0] * tmpRecv[0];
1599
1600 if (tmpRecv[0] > maxval)
1601 {
1602 maxval = (int)(tmpRecv[0] + 0.5);
1603 }
1604 if (tmpRecv[0] < minval)
1605 {
1606 minval = (int)(tmpRecv[0] + 0.5);
1607 }
1608 }
1609
1610 out << " - M-level sc. dist. (min/max/mean/dev) : " << minval
1611 << " " << maxval << " " << (mean / n) << " "
1612 << sqrt(mean2 / n - mean * mean / n / n) << endl;
1613 }
1614 else
1615 {
1616 Array<OneD, NekDouble> tmpSend(1);
1617 tmpSend[0] = level;
1618 vRowComm->Send(0, tmpSend);
1619 }
1620 }
1621 else
1622 {
1623 out << " - Number of static cond. levels : " << level << endl;
1624 }
1625
1626 if (isRoot)
1627 {
1628 out << "Stats at lowest static cond. level:" << endl;
1629 }
1630 tmp->PrintStats(out, variable, false);
1631}
Nektar::LibUtilities::CommSharedPtr
std::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:57
Nektar::MultiRegions::AssemblyMapSharedPtr
std::shared_ptr< AssemblyMap > AssemblyMapSharedPtr
Definition: AssemblyMap.h:52
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:294

References Vmath::Assmb(), CellMLToNektar.pycml::level, m_globalToUniversalBndMapUnique, m_localToGlobalBndMap, m_nextLevelLocalToGlobalMap, m_numGlobalBndCoeffs, m_numGlobalCoeffs, m_numGlobalDirBndCoeffs, m_numLocalBndCoeffs, m_numLocalCoeffs, m_numLocalDirBndCoeffs, m_session, Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceMin, Nektar::LibUtilities::ReduceSum, tinysimd::sqrt(), and UniversalAssembleBnd().

◆ SetNextLevelLocalToGlobalMap()

void Nektar::MultiRegions::AssemblyMap::SetNextLevelLocalToGlobalMap ( AssemblyMapSharedPtr  pNextLevelLocalToGlobalMap)

◆ UniversalAbsMaxBnd()

void Nektar::MultiRegions::AssemblyMap::UniversalAbsMaxBnd ( Array< OneD, NekDouble > &  bndvals)

Definition at line 1320 of file AssemblyMap.cpp.

1321{
1322 Gs::Gather(bndvals, Gs::gs_amax, m_dirBndGsh);
1323}
Nektar::MultiRegions::AssemblyMap::m_dirBndGsh
Gs::gs_data * m_dirBndGsh
gs gather communication to impose Dirhichlet BCs.
Definition: AssemblyMap.h:428
Gs::gs_amax
@ gs_amax
Definition: GsLib.hpp:66

References Gs::Gather(), Gs::gs_amax, and m_dirBndGsh.

◆ UniversalAssemble() [1/3]

void Nektar::MultiRegions::AssemblyMap::UniversalAssemble ( Array< OneD, NekDouble > &  pGlobal) const

Definition at line 832 of file AssemblyMap.cpp.

833{
834 v_UniversalAssemble(pGlobal);
835}
Nektar::MultiRegions::AssemblyMap::v_UniversalAssemble
virtual void v_UniversalAssemble(Array< OneD, NekDouble > &pGlobal) const
Definition: AssemblyMap.cpp:653

References v_UniversalAssemble().

Referenced by Nektar::MultiRegions::AssemblyMapCG::v_Assemble(), Nektar::MultiRegions::AssemblyMapCG::v_UniversalAssemble(), and Nektar::MultiRegions::AssemblyMapDG::v_UniversalAssemble().

◆ UniversalAssemble() [2/3]

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

Definition at line 842 of file AssemblyMap.cpp.

844{
845 v_UniversalAssemble(pGlobal, offset);
846}

References v_UniversalAssemble().

◆ UniversalAssemble() [3/3]

void Nektar::MultiRegions::AssemblyMap::UniversalAssemble ( NekVector< NekDouble > &  pGlobal) const

Definition at line 837 of file AssemblyMap.cpp.

838{
839 v_UniversalAssemble(pGlobal);
840}

References v_UniversalAssemble().

◆ UniversalAssembleBnd() [1/3]

void Nektar::MultiRegions::AssemblyMap::UniversalAssembleBnd ( Array< OneD, NekDouble > &  pGlobal) const

Definition at line 1298 of file AssemblyMap.cpp.

1299{
1300 ASSERTL1(pGlobal.size() >= m_numGlobalBndCoeffs, "Wrong size.");
1301 Gs::Gather(pGlobal, Gs::gs_add, m_bndGsh);
1302}
Gs::gs_add
@ gs_add
Definition: GsLib.hpp:62

References ASSERTL1, Gs::Gather(), Gs::gs_add, m_bndGsh, and m_numGlobalBndCoeffs.

Referenced by AssembleBnd(), PrintStats(), and UniversalAssembleBnd().

◆ UniversalAssembleBnd() [2/3]

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

Definition at line 1309 of file AssemblyMap.cpp.

1311{
1312 Array<OneD, NekDouble> tmp(offset);
1313 if (offset > 0)
1314 Vmath::Vcopy(offset, pGlobal, 1, tmp, 1);
1315 UniversalAssembleBnd(pGlobal);
1316 if (offset > 0)
1317 Vmath::Vcopy(offset, tmp, 1, pGlobal, 1);
1318}

References UniversalAssembleBnd(), and Vmath::Vcopy().

◆ UniversalAssembleBnd() [3/3]

void Nektar::MultiRegions::AssemblyMap::UniversalAssembleBnd ( NekVector< NekDouble > &  pGlobal) const

Definition at line 1304 of file AssemblyMap.cpp.

1305{
1306 UniversalAssembleBnd(pGlobal.GetPtr());
1307}

References Nektar::NekVector< DataType >::GetPtr(), and UniversalAssembleBnd().

◆ v_Assemble() [1/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 639 of file AssemblyMap.cpp.

641{
642 boost::ignore_unused(loc, global);
643 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
644}
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:209

References Nektar::ErrorUtil::efatal, CG_Iterations::loc, and NEKERROR.

Referenced by Assemble().

◆ v_Assemble() [2/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 646 of file AssemblyMap.cpp.

648{
649 boost::ignore_unused(loc, global);
650 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
651}

References Nektar::ErrorUtil::efatal, CG_Iterations::loc, and NEKERROR.

◆ v_GetExtraDirEdges()

const Array< OneD, const int > & Nektar::MultiRegions::AssemblyMap::v_GetExtraDirEdges ( )
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 723 of file AssemblyMap.cpp.

724{
725 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
726 static Array<OneD, const int> result;
727 return result;
728}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetExtraDirEdges().

◆ v_GetFullSystemBandWidth()

int Nektar::MultiRegions::AssemblyMap::v_GetFullSystemBandWidth ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 675 of file AssemblyMap.cpp.

676{
677 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
678 return 0;
679}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetFullSystemBandWidth().

◆ v_GetGlobalToUniversalMap() [1/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 581 of file AssemblyMap.cpp.

582{
583 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
584 static Array<OneD, const int> result;
585 return result;
586}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetGlobalToUniversalMap().

◆ v_GetGlobalToUniversalMap() [2/2]

int Nektar::MultiRegions::AssemblyMap::v_GetGlobalToUniversalMap ( const int  i) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 560 of file AssemblyMap.cpp.

561{
562 boost::ignore_unused(i);
563 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
564 return 0;
565}

References Nektar::ErrorUtil::efatal, and NEKERROR.

◆ v_GetGlobalToUniversalMapUnique() [1/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 588 of file AssemblyMap.cpp.

589{
590 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
591 static Array<OneD, const int> result;
592 return result;
593}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetGlobalToUniversalMapUnique().

◆ v_GetGlobalToUniversalMapUnique() [2/2]

int Nektar::MultiRegions::AssemblyMap::v_GetGlobalToUniversalMapUnique ( const int  i) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 567 of file AssemblyMap.cpp.

568{
569 boost::ignore_unused(i);
570 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
571 return 0;
572}

References Nektar::ErrorUtil::efatal, and NEKERROR.

◆ v_GetLocalToGlobalMap() [1/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 574 of file AssemblyMap.cpp.

575{
576 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
577 static Array<OneD, const int> result;
578 return result;
579}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetLocalToGlobalMap().

◆ v_GetLocalToGlobalMap() [2/2]

int Nektar::MultiRegions::AssemblyMap::v_GetLocalToGlobalMap ( const int  i) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 553 of file AssemblyMap.cpp.

554{
555 boost::ignore_unused(i);
556 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
557 return 0;
558}

References Nektar::ErrorUtil::efatal, and NEKERROR.

◆ v_GetLocalToGlobalSign() [1/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 602 of file AssemblyMap.cpp.

603{
604 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
605 static Array<OneD, NekDouble> result;
606 return result;
607}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetLocalToGlobalSign().

◆ v_GetLocalToGlobalSign() [2/2]

NekDouble Nektar::MultiRegions::AssemblyMap::v_GetLocalToGlobalSign ( const int  i) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 595 of file AssemblyMap.cpp.

596{
597 boost::ignore_unused(i);
598 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
599 return 0.0;
600}

References Nektar::ErrorUtil::efatal, and NEKERROR.

◆ v_GetNumDirEdges()

int Nektar::MultiRegions::AssemblyMap::v_GetNumDirEdges ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 699 of file AssemblyMap.cpp.

700{
701 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
702 return 0;
703}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetNumDirEdges().

◆ v_GetNumDirFaces()

int Nektar::MultiRegions::AssemblyMap::v_GetNumDirFaces ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 705 of file AssemblyMap.cpp.

706{
707 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
708 return 0;
709}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetNumDirFaces().

◆ v_GetNumNonDirEdgeModes()

int Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirEdgeModes ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 687 of file AssemblyMap.cpp.

688{
689 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
690 return 0;
691}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetNumNonDirEdgeModes().

◆ v_GetNumNonDirEdges()

int Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirEdges ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 711 of file AssemblyMap.cpp.

712{
713 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
714 return 0;
715}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetNumNonDirEdges().

◆ v_GetNumNonDirFaceModes()

int Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirFaceModes ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 693 of file AssemblyMap.cpp.

694{
695 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
696 return 0;
697}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetNumNonDirFaceModes().

◆ v_GetNumNonDirFaces()

int Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirFaces ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 717 of file AssemblyMap.cpp.

718{
719 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
720 return 0;
721}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetNumNonDirFaces().

◆ v_GetNumNonDirVertexModes()

int Nektar::MultiRegions::AssemblyMap::v_GetNumNonDirVertexModes ( ) const
protectedvirtual

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 681 of file AssemblyMap.cpp.

682{
683 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
684 return 0;
685}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by GetNumNonDirVertexModes().

◆ v_GlobalToLocal() [1/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 625 of file AssemblyMap.cpp.

627{
628 boost::ignore_unused(loc, global);
629 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
630}

References Nektar::ErrorUtil::efatal, CG_Iterations::loc, and NEKERROR.

Referenced by GlobalToLocal().

◆ v_GlobalToLocal() [2/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 632 of file AssemblyMap.cpp.

634{
635 boost::ignore_unused(loc, global);
636 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
637}

References Nektar::ErrorUtil::efatal, CG_Iterations::loc, and NEKERROR.

◆ v_LinearSpaceMap()

std::shared_ptr< AssemblyMap > Nektar::MultiRegions::AssemblyMap::v_LinearSpaceMap ( const ExpList &  locexp,
GlobalSysSolnType  solnType 
)
protectedvirtual

Generate a linear space mapping from existing mapping.

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 730 of file AssemblyMap.cpp.

732{
733 boost::ignore_unused(locexp, solnType);
734 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
735 static std::shared_ptr<AssemblyMap> result;
736 return result;
737}

References Nektar::ErrorUtil::efatal, and NEKERROR.

Referenced by LinearSpaceMap().

◆ v_LocalToGlobal() [1/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 609 of file AssemblyMap.cpp.

612{
613 boost::ignore_unused(loc, global, useComm);
614 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
615}

References Nektar::ErrorUtil::efatal, CG_Iterations::loc, and NEKERROR.

Referenced by LocalToGlobal().

◆ v_LocalToGlobal() [2/2]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 617 of file AssemblyMap.cpp.

620{
621 boost::ignore_unused(loc, global, useComm);
622 NEKERROR(ErrorUtil::efatal, "Not defined for this type of mapping.");
623}

References Nektar::ErrorUtil::efatal, CG_Iterations::loc, and NEKERROR.

◆ v_UniversalAssemble() [1/3]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 653 of file AssemblyMap.cpp.

654{
655 boost::ignore_unused(pGlobal);
656 // Do nothing here since multi-level static condensation uses a
657 // AssemblyMap and thus will call this routine in serial.
658}

Referenced by UniversalAssemble().

◆ v_UniversalAssemble() [2/3]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG.

Definition at line 667 of file AssemblyMap.cpp.

669{
670 boost::ignore_unused(pGlobal, offset);
671 // Do nothing here since multi-level static condensation uses a
672 // AssemblyMap and thus will call this routine in serial.
673}

◆ v_UniversalAssemble() [3/3]

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

Reimplemented in Nektar::MultiRegions::AssemblyMapCG, and Nektar::MultiRegions::AssemblyMapDG.

Definition at line 660 of file AssemblyMap.cpp.

661{
662 boost::ignore_unused(pGlobal);
663 // Do nothing here since multi-level static condensation uses a
664 // AssemblyMap and thus will call this routine in serial.
665}

Member Data Documentation

◆ m_bndCondCoeffsToLocalCoeffsMap

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToLocalCoeffsMap
protected

Integer map of bnd cond coeffs to local coefficients.

Definition at line 392 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), and GetBndCondCoeffsToLocalCoeffsMap().

◆ m_bndCondCoeffsToLocalCoeffsSign

Array<OneD, NekDouble> Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToLocalCoeffsSign
protected

Integer map of sign of bnd cond coeffs to local coefficients.

Definition at line 394 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), and GetBndCondCoeffsToLocalCoeffsSign().

◆ m_bndCondCoeffsToLocalTraceMap

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_bndCondCoeffsToLocalTraceMap
protected

Integer map of bnd cond coeff to local trace coeff.

Definition at line 396 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), and GetBndCondCoeffsToLocalTraceMap().

◆ m_bndCondIDToGlobalTraceID

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_bndCondIDToGlobalTraceID
protected

Integer map of bnd cond trace number to global trace number.

Definition at line 398 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), and GetBndCondIDToGlobalTraceID().

◆ m_bndGsh

Gs::gs_data* Nektar::MultiRegions::AssemblyMap::m_bndGsh
protected

Definition at line 426 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), LocalBndToGlobal(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap(), UniversalAssembleBnd(), and Nektar::MultiRegions::AssemblyMapCG::~AssemblyMapCG().

◆ m_bndSystemBandWidth

int Nektar::MultiRegions::AssemblyMap::m_bndSystemBandWidth
protected

The bandwith of the global bnd system.

Definition at line 407 of file AssemblyMap.h.

Referenced by CalculateBndSystemBandWidth(), and GetBndSystemBandWidth().

◆ m_comm

LibUtilities::CommSharedPtr Nektar::MultiRegions::AssemblyMap::m_comm
protected

Communicator.

Definition at line 339 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), GetComm(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap(), and Nektar::MultiRegions::AssemblyMapCG::v_LinearSpaceMap().

◆ m_dirBndGsh

Gs::gs_data* Nektar::MultiRegions::AssemblyMap::m_dirBndGsh
protected

gs gather communication to impose Dirhichlet BCs.

Definition at line 428 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), and UniversalAbsMaxBnd().

◆ m_globalToUniversalBndMap

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMap
protected

Integer map of process coeffs to universal space.

Definition at line 400 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), GetGlobalToUniversalBndMap(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap(), and Nektar::MultiRegions::AssemblyMapDG::v_GetGlobalToUniversalMap().

◆ m_globalToUniversalBndMapUnique

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_globalToUniversalBndMapUnique
protected

Integer map of unique process coeffs to universal space (signed)

Definition at line 402 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), GetGlobalToUniversalBndMapUnique(), PrintStats(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap(), and Nektar::MultiRegions::AssemblyMapDG::v_GetGlobalToUniversalMapUnique().

◆ m_gsh

Gs::gs_data* Nektar::MultiRegions::AssemblyMap::m_gsh
protected

Definition at line 425 of file AssemblyMap.h.

Referenced by Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap(), Nektar::MultiRegions::AssemblyMapCG::v_LocalToGlobal(), Nektar::MultiRegions::AssemblyMapCG::v_UniversalAssemble(), Nektar::MultiRegions::AssemblyMapDG::v_UniversalAssemble(), and Nektar::MultiRegions::AssemblyMapCG::~AssemblyMapCG().

◆ m_hash

size_t Nektar::MultiRegions::AssemblyMap::m_hash
protected

Hash for map.

Definition at line 345 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), and GetHash().

◆ m_isAbsoluteTolerance

bool Nektar::MultiRegions::AssemblyMap::m_isAbsoluteTolerance
protected

Definition at line 417 of file AssemblyMap.h.

Referenced by AssemblyMap(), and IsAbsoluteTolerance().

◆ m_iterativeTolerance

NekDouble Nektar::MultiRegions::AssemblyMap::m_iterativeTolerance
protected

Tolerance for iterative solver.

Definition at line 416 of file AssemblyMap.h.

Referenced by AssemblyMap(), and GetIterativeTolerance().

◆ m_linSysIterSolver

std::string Nektar::MultiRegions::AssemblyMap::m_linSysIterSolver
protected

Iterative solver: Conjugate Gradient, GMRES.

Definition at line 423 of file AssemblyMap.h.

Referenced by AssemblyMap(), and GetLinSysIterSolver().

◆ m_localToGlobalBndMap

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndMap
protected

Integer map of local coeffs to global Boundary Dofs.

Definition at line 384 of file AssemblyMap.h.

Referenced by AssembleBnd(), AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), CalculateBndSystemBandWidth(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetLocalToGlobalBndMap(), GlobalToLocalBnd(), GlobalToLocalBndWithoutSign(), LocalBndToGlobal(), PrintStats(), Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap(), and Nektar::MultiRegions::AssemblyMapDG::v_GetLocalToGlobalMap().

◆ m_localToGlobalBndSign

Array<OneD, NekDouble> Nektar::MultiRegions::AssemblyMap::m_localToGlobalBndSign
protected

Integer sign of local boundary coeffs to global space.

Definition at line 386 of file AssemblyMap.h.

Referenced by AssembleBnd(), AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetLocalToGlobalBndSign(), GlobalToLocalBnd(), and LocalBndToGlobal().

◆ m_localToLocalBndMap

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_localToLocalBndMap
protected

Integer map of local boundary coeffs to local boundary system numbering.

Definition at line 388 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), LocalBndToLocal(), and LocalToLocalBnd().

◆ m_localToLocalIntMap

Array<OneD, int> Nektar::MultiRegions::AssemblyMap::m_localToLocalIntMap
protected

Integer map of local boundary coeffs to local interior system numbering.

Definition at line 390 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), LocalIntToLocal(), and LocalToLocalInt().

◆ m_lowestStaticCondLevel

int Nektar::MultiRegions::AssemblyMap::m_lowestStaticCondLevel
protected

Lowest static condensation level.

Definition at line 445 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), and GetLowestStaticCondLevel().

◆ m_maxIterations

int Nektar::MultiRegions::AssemblyMap::m_maxIterations
protected

Maximum iterations for iterative solver.

Definition at line 413 of file AssemblyMap.h.

Referenced by AssemblyMap(), and GetMaxIterations().

◆ m_nextLevelLocalToGlobalMap

AssemblyMapSharedPtr Nektar::MultiRegions::AssemblyMap::m_nextLevelLocalToGlobalMap
protected

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

The local to global mapping of the next level of recursion

Definition at line 443 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), AtLastLevel(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetNextLevelLocalToGlobalMap(), and PrintStats().

◆ m_numGlobalBndCoeffs

int Nektar::MultiRegions::AssemblyMap::m_numGlobalBndCoeffs
protected

Total number of global boundary coefficients.

Definition at line 350 of file AssemblyMap.h.

Referenced by AssembleBnd(), AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetNumGlobalBndCoeffs(), GlobalToLocalBnd(), GlobalToLocalBndWithoutSign(), LocalBndToGlobal(), PrintStats(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapDG::SetUpUniversalDGMap(), and UniversalAssembleBnd().

◆ m_numGlobalCoeffs

int Nektar::MultiRegions::AssemblyMap::m_numGlobalCoeffs
protected

Total number of global coefficients.

This corresponds to the number of total number of coefficients

  • For CG this corresponds to the total of bnd + int DOFs.
  • For DG this corresponds to the number of bnd DOFs. This means that m_numGlobalCoeffs = m_numGlobalBndCoeffs This way, we can consider the trace-system solve as a statically condensed solve without interior DOFs. This allows us to use the same global system solver for both cases.

Definition at line 378 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetNumGlobalCoeffs(), PrintStats(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapCG::v_Assemble(), Nektar::MultiRegions::AssemblyMapCG::v_GlobalToLocal(), and Nektar::MultiRegions::AssemblyMapCG::v_LinearSpaceMap().

◆ m_numGlobalDirBndCoeffs

int Nektar::MultiRegions::AssemblyMap::m_numGlobalDirBndCoeffs
protected

Number of Global Dirichlet Boundary Coefficients.

Definition at line 354 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), CalculateBndSystemBandWidth(), Nektar::MultiRegions::AssemblyMapCG::CalculateFullSystemBandWidth(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetNumGlobalDirBndCoeffs(), PrintStats(), and Nektar::MultiRegions::AssemblyMapCG::v_LinearSpaceMap().

◆ m_numLocalBndCoeffs

int Nektar::MultiRegions::AssemblyMap::m_numLocalBndCoeffs
protected

Number of local boundary coefficients.

Definition at line 348 of file AssemblyMap.h.

Referenced by AssembleBnd(), AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), CalculateBndSystemBandWidth(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), GetNumLocalBndCoeffs(), GlobalToLocalBnd(), GlobalToLocalBndWithoutSign(), LocalBndToGlobal(), LocalBndToLocal(), LocalIntToLocal(), LocalToLocalBnd(), LocalToLocalInt(), and PrintStats().

◆ m_numLocalBndCoeffsPerPatch

Array<OneD, unsigned int> Nektar::MultiRegions::AssemblyMap::m_numLocalBndCoeffsPerPatch
protected

The number of bnd dofs per patch.

Definition at line 436 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), CalculateBndSystemBandWidth(), Nektar::MultiRegions::AssemblyMapCG::CalculateFullSystemBandWidth(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), and GetNumLocalBndCoeffsPerPatch().

◆ m_numLocalCoeffs

int Nektar::MultiRegions::AssemblyMap::m_numLocalCoeffs
protected

Total number of local coefficients.

This corresponds to the number of total number of coefficients

  • For CG this corresponds to the total of bnd + int DOFs
  • For DG this corresponds to the number of bnd DOFs. This means that m_numLocalCoeffs = m_numLocalBndCoeffs This way, we can consider the trace-system solve as a statically condensed solve without interior DOFs. This allows us to use the same global system solver for both cases.

Definition at line 367 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::MultiRegions::AssemblyMapCG::CalculateFullSystemBandWidth(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetNumLocalCoeffs(), LocalBndToLocal(), LocalIntToLocal(), LocalToLocalBnd(), LocalToLocalInt(), PatchAssemble(), PrintStats(), Nektar::MultiRegions::AssemblyMapCG::v_Assemble(), Nektar::MultiRegions::AssemblyMapCG::v_GlobalToLocal(), and Nektar::MultiRegions::AssemblyMapCG::v_LocalToGlobal().

◆ m_numLocalDirBndCoeffs

int Nektar::MultiRegions::AssemblyMap::m_numLocalDirBndCoeffs
protected

Number of Local Dirichlet Boundary Coefficients.

Definition at line 352 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), GetNumLocalDirBndCoeffs(), and PrintStats().

◆ m_numLocalIntCoeffsPerPatch

Array<OneD, unsigned int> Nektar::MultiRegions::AssemblyMap::m_numLocalIntCoeffsPerPatch
protected

The number of int dofs per patch.

Definition at line 438 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::MultiRegions::AssemblyMapCG::CalculateFullSystemBandWidth(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), and GetNumLocalIntCoeffsPerPatch().

◆ m_numPatches

int Nektar::MultiRegions::AssemblyMap::m_numPatches
protected

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

Definition at line 434 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), CalculateBndSystemBandWidth(), Nektar::MultiRegions::AssemblyMapCG::CalculateFullSystemBandWidth(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), and GetNumPatches().

◆ m_patchMapFromPrevLevel

PatchMapSharedPtr Nektar::MultiRegions::AssemblyMap::m_patchMapFromPrevLevel
private

Mapping information for previous level in MultiLevel Solver.

Definition at line 520 of file AssemblyMap.h.

Referenced by AssemblyMap(), GetPatchMapFromPrevLevel(), PatchAssemble(), PatchGlobalToLocal(), and PatchLocalToGlobal().

◆ m_preconType

std::string Nektar::MultiRegions::AssemblyMap::m_preconType
protected

Type type of preconditioner to use in iterative solver.

Definition at line 410 of file AssemblyMap.h.

Referenced by AssemblyMap(), and GetPreconType().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::MultiRegions::AssemblyMap::m_session
protected

Session object.

Definition at line 336 of file AssemblyMap.h.

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), PrintStats(), and Nektar::MultiRegions::AssemblyMapCG::v_LinearSpaceMap().

◆ m_signChange

bool Nektar::MultiRegions::AssemblyMap::m_signChange
protected

Flag indicating if modes require sign reversal.

Definition at line 381 of file AssemblyMap.h.

Referenced by AssembleBnd(), AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), GetLocalToGlobalBndSign(), GetSignChange(), GlobalToLocalBnd(), LocalBndToGlobal(), Nektar::MultiRegions::AssemblyMapCG::SetUpUniversalC0ContMap(), Nektar::MultiRegions::AssemblyMapCG::v_Assemble(), Nektar::MultiRegions::AssemblyMapCG::v_GetLocalToGlobalSign(), Nektar::MultiRegions::AssemblyMapCG::v_GlobalToLocal(), and Nektar::MultiRegions::AssemblyMapCG::v_LocalToGlobal().

◆ m_solnType

GlobalSysSolnType Nektar::MultiRegions::AssemblyMap::m_solnType
protected

The solution type of the global system.

Definition at line 405 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), and GetGlobalSysSolnType().

◆ m_staticCondLevel

int Nektar::MultiRegions::AssemblyMap::m_staticCondLevel
protected

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

Definition at line 432 of file AssemblyMap.h.

Referenced by AssemblyMap(), Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), and GetStaticCondLevel().

◆ m_successiveRHS

int Nektar::MultiRegions::AssemblyMap::m_successiveRHS
protected

sucessive RHS for iterative solver

Definition at line 420 of file AssemblyMap.h.

Referenced by AssemblyMap(), and GetSuccessiveRHS().

◆ m_systemSingular

bool Nektar::MultiRegions::AssemblyMap::m_systemSingular
protected

Flag indicating if the system is singular or not.

Definition at line 356 of file AssemblyMap.h.

Referenced by Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::CoupledLocalToGlobalC0ContMap::CoupledLocalToGlobalC0ContMap(), Nektar::MultiRegions::AssemblyMapCG::CreateGraph(), and GetSingularSystem().

◆ m_variable

std::string Nektar::MultiRegions::AssemblyMap::m_variable
protected

Variable string identifier.

Definition at line 342 of file AssemblyMap.h.

Referenced by GetVariable().

Generated on Wed Jan 31 2024 08:26:57 for Nektar++ by doxygen 1.9.4