Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Classes | Functions | Variables
class_topology Namespace Reference

Classes

class  Topology
 

Functions

def __init__
 
def Print_Hardware
 
def Distribute_Elements
 
def Distribute_Modes
 
def Hardware_Constant
 
def Print_Elements
 
def Print_Modes
 
def CG_Iterations
 
def Data_Size
 
def Input_Communication
 
def Check_Neighbour
 
def Communication_Pairwise_Exchange
 
def Communication_Allreduce
 
def Communication_Alltoall
 
def Serial_Compute
 

Variables

 PROC_Z
 
 PROC_XY
 
 Num_Core_Per_Socket
 
 Num_Sock_Per_Node
 
 Scheme
 
 PROC_TOT
 
 Core
 
 Socket
 
 Node
 
 Elements_Disributed
 
 Modes_Disributed
 
 Data_Size_Input
 
 Data_Communication_Input
 
 Num_Elements
 
 Num_Element_Msg
 
 Num_Modes
 
 N_Z
 
 Split
 
 Modes
 
 Planes
 
 Plane_Num
 
 Num_Constants
 
 constants
 
 Pressure
 
 Velocity_1
 
 Velocity_2
 
 Velocity_3
 
 P
 
 Data_Element
 
 Data_Mode
 
 BW_Node_To_Node
 
 BW_Socket_To_Socket
 
 BW_Core_To_Core
 
 LAT_Node_To_Node
 
 LAT_Socket_To_Socket
 
 LAT_Core_To_Core
 

Function Documentation

def class_topology.__init__ (   self,
  PROC_Z,
  PROC_XY,
  Num_Core_Per_Socket,
  Num_Sock_Per_Node,
  Scheme 
)

Definition at line 29 of file class_topology.py.

29 
30  def __init__(self, PROC_Z, PROC_XY, Num_Core_Per_Socket, Num_Sock_Per_Node, Scheme):
31 
32  # Store read in data
33  self.PROC_Z = PROC_Z
34  self.PROC_XY = PROC_XY
35  self.Num_Core_Per_Socket = Num_Core_Per_Socket
36  self.Num_Sock_Per_Node = Num_Sock_Per_Node
37  self.Scheme = Scheme
38 
39  # Calculate PROC_TOT
40  self.PROC_TOT = self.PROC_XY * self.PROC_Z
41 
42  # Initialise storage lists
43  self.Core = []
44  self.Socket = []
45  self.Node = []
46 
47  # Begin counters used in for loops
48  count_core = 0
49  count_socket_old = 0
50  count_socket_new = 0
51  count_node = 0
52 
53  # Iterate over cores assigning core, socket and node number
54  for i in range(0, self.PROC_Z):
55  for j in range(0, self.PROC_XY):
56  self.Core.append(count_core)
57  self.Socket.append(count_socket_new)
58  self.Node.append(count_node)
59 
60  count_core += 1
61 
62  # Use modulo to find when to iterate socker number based on bumber of cores assigned
63  if(count_core % Num_Core_Per_Socket == 0):
64  count_socket_new = count_socket_new + 1
65 
66  # Use modulo to find when to iterate node number based on bumber of sockets assigned
67  if(count_socket_old != count_socket_new):
68  if(count_socket_new % Num_Sock_Per_Node == 0):
69  count_node = count_node + 1;
70 
71  # Update socket counter
72  count_socket_old = count_socket_new;
73 
74  # Flags to track operations that have occured, default to False
75  self.Elements_Disributed = False
76  self.Modes_Disributed = False
77  self.Data_Size_Input = False
78  self.Data_Communication_Input = False
79 
80 
81 #------------------------------------
82 # New Function
83 #------------------------------------
class_topology.__init__
def __init__
Definition: class_topology.py:29
def class_topology.CG_Iterations (   self,
  Pressure,
  Velocity_1,
  Velocity_2,
  Velocity_3 
)

Definition at line 277 of file class_topology.py.

277 
278  def CG_Iterations(self, Pressure, Velocity_1, Velocity_2, Velocity_3):
279  self.Pressure = Pressure
280  self.Velocity_1 = Velocity_1
281  self.Velocity_2 = Velocity_2
282  self.Velocity_3 = Velocity_3
283 
284 #------------------------------------
285 # New Function
286 #------------------------------------
class_topology.CG_Iterations
def CG_Iterations
Definition: class_topology.py:277
def class_topology.Check_Neighbour (   self,
  core_1,
  core_2 
)

Definition at line 318 of file class_topology.py.

318 
319  def Check_Neighbour(self, core_1, core_2):
320  if(core_1 == core_2):
321  return 0
322 
323  if(self.Socket[core_1] == self.Socket[core_2]):
324  return 1
325 
326  if(self.Node[core_1] == self.Node[core_2]):
327  return 2;
328 
329  else:
330  return 3;
331 
332 #------------------------------------
333 # New Function
334 #------------------------------------
class_topology.Check_Neighbour
def Check_Neighbour
Definition: class_topology.py:318
def class_topology.Communication_Allreduce (   self)

Definition at line 385 of file class_topology.py.

385 
386  def Communication_Allreduce(self):
387 
388  # We count the number of
389  comm_max = 0.0
390 
391  # Set max relation size tracking to False
392  relation_1 = False
393  relation_2 = False
394  relation_3 = False
395 
396  for i in range(0, self.PROC_Z):
397  current = self.Core[i * self.PROC_XY]
398 
399  current_row = i
400 
401  CG_Iter = 0
402  for j in range(0, len(self.Plane_Num[current_row])):
403  try:
404  Plane = self.Plane_Num[current_row][j] + 1
405  CG_Iter += self.Pressure[str(Plane)][0]
406  CG_Iter += self.Velocity_1[str(Plane)][0]
407  CG_Iter += self.Velocity_2[str(Plane)][0]
408  CG_Iter += self.Velocity_3[str(Plane)][0]
409  except:
410  continue
411 
412  comm_count = 0.0
413 
414  for j in range(0, self.PROC_XY - 1):
415  current_right = current + 1
416 
417  relation = self.Check_Neighbour(current, current_right)
418 
419  if (relation == 1):
420  comm_count += self.LAT_Core_To_Core + (3 * 8)/(self.BW_Core_To_Core)
421  relation_1 = True
422 
423  if (relation == 2):
424  comm_count += self.LAT_Socket_To_Socket + (3 * 8)/(self.BW_Socket_To_Socket)
425  relation_2 = True
426 
427  if (relation == 3):
428  comm_count += self.LAT_Node_To_Node + (3 * 8)/(self.BW_Node_To_Node)
429  relation_3 = True
430 
431  current += 1
432 
433  comm_count = comm_count * CG_Iter
434  if (comm_count >= comm_max):
435  comm_max = comm_count
436  CG_MAX = CG_Iter
437 
438  if (relation_1 is True and relation_2 is False and relation_3 is False):
439  comm_max += (self.LAT_Core_To_Core + (3 * 8)/(self.BW_Core_To_Core)) * CG_MAX
440 
441  if (relation_1 is True and relation_2 is True and relation_3 is False):
442  comm_max += (self.LAT_Socket_To_Socket + (3 * 8)/(self.BW_Socket_To_Socket)) * CG_MAX
443 
444  if (relation_1 is True and relation_2 is True and relation_3 is True):
445  comm_max += (self.LAT_Node_To_Node + (3 * 8)/(self.BW_Node_To_Node)) * CG_MAX
446 
447  return(comm_max)
448 
449 #------------------------------------
450 # New Function
451 #------------------------------------
class_topology.Communication_Allreduce
def Communication_Allreduce
Definition: class_topology.py:385
def class_topology.Communication_Alltoall (   self)

Definition at line 453 of file class_topology.py.

453 
454  def Communication_Alltoall(self):
455 
456  # Find how long each core requires to send its information to each level, core, socker or node.
457  MSG_Node_Mode = []
458  MSG_Socket_Mode = []
459  MSG_Core_Mode = []
460 
461  # Divide by PROC_Z as Alltoall involves this data size
462  for i in range(0, self.PROC_Z):
463  for j in range(0, self.PROC_XY):
464  MSG_Node_Mode.append(self.LAT_Node_To_Node + (self.Planes[i] * self.Num_Elements[i][j] * self.Data_Mode)/((self.BW_Node_To_Node) * self.PROC_Z))
465  MSG_Socket_Mode.append(self.LAT_Socket_To_Socket + (self.Planes[i] * self.Num_Elements[i][j] * self.Data_Mode)/((self.BW_Socket_To_Socket) * self.PROC_Z))
466  MSG_Core_Mode.append(self.LAT_Core_To_Core + (self.Planes[i] * self.Num_Elements[i][j] * self.Data_Mode)/((self.BW_Core_To_Core) * self.PROC_Z))
467 
468  # We are looking for the core that has the most communication to do in this Alltoall set up.
469  # Each core performs PROC_Z - 1 sends (A send contains the recieve in this model)
470  comm_max = 0.0
471 
472  for i in range(0, self.PROC_Z):
473  for j in range(0, self.PROC_XY):
474 
475  # Counter for the communication for this the current core
476  comm_count = 0.0
477 
478  # Current column and core
479  current = self.Core[i*self.PROC_XY + j]
480  current_column = current % self.PROC_XY
481 
482  # Loop looking for neighbours and counting the communication
483  for k in range(0, self.PROC_TOT):
484  if (k % self.PROC_XY == current_column):
485  relation = self.Check_Neighbour(current, k)
486 
487  if (relation == 0):
488  continue
489 
490  if (relation == 1):
491  comm_count += MSG_Core_Mode[current]
492  continue
493 
494  if (relation == 2):
495  comm_count += MSG_Socket_Mode[current]
496  continue
497 
498  if (relation == 3):
499  comm_count += MSG_Node_Mode[current]
500  continue
501 
502  # Update the largest communication cost
503  if (comm_count >= comm_max):
504  comm_max = comm_count
505 
506  # Return the result
507  return(18 * comm_max)
508 
509 #------------------------------------
510 # New Function
511 #------------------------------------
class_topology.Communication_Alltoall
def Communication_Alltoall
Definition: class_topology.py:453
def class_topology.Communication_Pairwise_Exchange (   self)

Definition at line 336 of file class_topology.py.

336 
337  def Communication_Pairwise_Exchange(self):
338  comm_max = 0.0
339 
340  for i in range(0, self.PROC_Z):
341 
342  current_row = i
343 
344  CG_Iter = 0
345 
346  for j in range(0, len(self.Plane_Num[current_row])):
347  try:
348  Plane = self.Plane_Num[current_row][j] + 1
349  CG_Iter += self.Pressure[str(Plane)][0]
350  CG_Iter += self.Velocity_1[str(Plane)][0]
351  CG_Iter += self.Velocity_2[str(Plane)][0]
352  CG_Iter += self.Velocity_3[str(Plane)][0]
353  except:
354  continue
355 
356  for j in range(0, self.PROC_XY):
357  comm_count = 0.0
358  current = i * self.PROC_XY + j
359 
360  for k in range(0, self.PROC_XY):
361  send_loc = i * self.PROC_XY + k
362 
363  relation = self.Check_Neighbour(current, send_loc)
364 
365  if (relation == 1):
366  comm_count += self.LAT_Core_To_Core + (self.Num_Element_Msg[j][k] * self.Data_Element)/(self.BW_Core_To_Core)
367 
368  if (relation == 2):
369  comm_count += self.LAT_Socket_To_Socket + (self.Num_Element_Msg[j][k] * self.Data_Element)/(self.BW_Socket_To_Socket)
370 
371  if (relation == 3):
372  comm_count += self.LAT_Node_To_Node + (self.Num_Element_Msg[j][k] * self.Data_Element)/(self.BW_Node_To_Node)
373 
374  comm_count = comm_count * CG_Iter
375 
376  if (comm_count >= comm_max):
377  comm_max = comm_count
378 
379  return(comm_max)
380 
381 #------------------------------------
382 # New Function
383 #------------------------------------
class_topology.Communication_Pairwise_Exchange
def Communication_Pairwise_Exchange
Definition: class_topology.py:336
def class_topology.Data_Size (   self,
  P 
)

Definition at line 289 of file class_topology.py.

289 
290  def Data_Size(self, P):
291  self.P = P
292  self.Data_Element = (P + 1) * 8
293  self.Data_Mode = 8 * ((P+1) ** 2)
294 
295  # Update tracker flag
296  self.Data_Size_Input = True
297 
298 #------------------------------------
299 # New Function
300 #------------------------------------
class_topology.Data_Size
def Data_Size
Definition: class_topology.py:289
def class_topology.Distribute_Elements (   self,
  Num_Element_Msg,
  Num_Elements 
)

Definition at line 133 of file class_topology.py.

133 
134  def Distribute_Elements(self, Num_Element_Msg, Num_Elements):
135  self.Num_Elements = []
136  for i in range(0, self.PROC_Z):
137  self.Num_Elements.append([])
138  for j in range(0, self.PROC_XY):
139  self.Num_Elements[i].append(Num_Elements[j])
140 
141  self.Num_Element_Msg = Num_Element_Msg
142 
143  self.Elements_Disributed = True
144 
145 #------------------------------------
146 # New Function
147 #------------------------------------
class_topology.Distribute_Elements
def Distribute_Elements
Definition: class_topology.py:133
def class_topology.Distribute_Modes (   self,
  Num_Modes 
)

Definition at line 149 of file class_topology.py.

149 
150  def Distribute_Modes(self, Num_Modes):
151  self.Num_Modes = Num_Modes
152  self.N_Z = Num_Modes * 2
153  self.Split = self.Num_Modes / self.PROC_Z
154  self.Modes = []
155  self.Planes = []
156  self.Plane_Num = []
157  for i in range(0, self.PROC_TOT):
158  self.Modes.append(self.Split)
159  self.Planes.append(self.Split * 2)
160 
161  for i in range(0, self.PROC_Z):
162  self.Plane_Num.append([])
163  for j in range(0, self.Split * 2):
164  self.Plane_Num[i].append(i * (self.Split * 2) + j)
165 
166  self.Modes_Disributed = True
167 
168 #------------------------------------
169 # New Function
170 #------------------------------------
class_topology.Distribute_Modes
def Distribute_Modes
Definition: class_topology.py:149
def class_topology.Hardware_Constant (   self,
  Num_Constants,
  constants 
)

Definition at line 172 of file class_topology.py.

172 
173  def Hardware_Constant(self, Num_Constants, constants):
174  self.Num_Constants = Num_Constants
175  self.constants = constants
176 
177 
178 #------------------------------------
179 # New Function
180 #------------------------------------
class_topology.Hardware_Constant
def Hardware_Constant
Definition: class_topology.py:172
def class_topology.Input_Communication (   self,
  BW_Node_To_Node,
  LAT_Node_To_Node,
  BW_Socket_To_Socket,
  LAT_Socket_To_Socket,
  BW_Core_To_Core,
  LAT_Core_To_Core 
)

Definition at line 302 of file class_topology.py.

302 
303  def Input_Communication(self, BW_Node_To_Node, LAT_Node_To_Node, BW_Socket_To_Socket, LAT_Socket_To_Socket, BW_Core_To_Core, LAT_Core_To_Core):
304  self.BW_Node_To_Node = BW_Node_To_Node
305  self.BW_Socket_To_Socket = BW_Socket_To_Socket
306  self.BW_Core_To_Core = BW_Core_To_Core
307  self.LAT_Node_To_Node = LAT_Node_To_Node
308  self.LAT_Socket_To_Socket = LAT_Socket_To_Socket
309  self.LAT_Core_To_Core = LAT_Core_To_Core
310 
311  # Update tracker flag
312  self.Data_Communication_Input = True
313 
314 #------------------------------------
315 # New Function
316 #------------------------------------
class_topology.Input_Communication
def Input_Communication
Definition: class_topology.py:302
def class_topology.Print_Elements (   self,
  Index 
)

Definition at line 182 of file class_topology.py.

182 
183  def Print_Elements(self, Index):
184 
185  if (self.Elements_Disributed is True):
186 
187  # Check that there is a file to put outputs into, if not make one
188  output_path = 'Output'
189  if not os.path.exists(output_path):
190  os.mkdir(output_path)
191 
192  # Open new file and write out configurations
193  f = open('Output/Element_Distribution_' + str(Index) + '.txt', "w")
194 
195  f.write("Core Distribution")
196  f.write("\n")
197 
198  for i in range(0, self.PROC_Z):
199  for j in range(0, self.PROC_XY):
200  f.write(repr(self.Core[i * self.PROC_XY + j]).rjust(5))
201  f.write("\n")
202 
203  f.write("\n")
204 
205  f.write("Element Distribution")
206  f.write("\n")
207 
208  for i in range(0, self.PROC_Z):
209  for j in range(0, self.PROC_XY):
210  f.write(repr(self.Num_Elements[i][j]).rjust(5))
211  f.write("\n")
212 
213  else:
214  # Check that there is a file to put outputs into, if not make one
215  output_path = 'Output'
216  if not os.path.exists(output_path):
217  os.mkdir(output_path)
218 
219  # Open new file and write out configurations
220  f = open('Output/Element_Distribution_' + str(Index) + '.txt', "w")
221 
222  f.write('Elements have no yet been distributed by the program.')
223 
224  f.close()
225 
226 
227 #------------------------------------
228 # New Function
229 #------------------------------------
class_topology.Print_Elements
def Print_Elements
Definition: class_topology.py:182
def class_topology.Print_Hardware (   self)

Definition at line 85 of file class_topology.py.

85 
86  def Print_Hardware(self):
87 
88  # Check that there is a file to put outputs into, if not make one
89  output_path = 'Output'
90  if not os.path.exists(output_path):
91  os.mkdir(output_path)
92 
93  # Open new file and write out configurations
94  f = open('Output/Hardware_Topology.txt', "w")
95 
96  f.write("Core Distribution")
97  f.write("\n")
98 
99  for i in range(0, self.PROC_Z):
100  for j in range(0, self.PROC_XY):
101  f.write(repr(self.Core[i*self.PROC_XY + j]).rjust(5))
102  f.write("\n")
103 
104 
105  f.write("\n")
106 
107 
108  f.write("Socket Distribution")
109  f.write("\n")
110  for i in range(0, self.PROC_Z):
111  for j in range(0, self.PROC_XY):
112  f.write(repr(self.Socket[i*self.PROC_XY + j]).rjust(5))
113  f.write("\n")
114 
115 
116  f.write("\n")
117 
118 
119  f.write("Node Distribution")
120  f.write("\n")
121  for i in range(0, self.PROC_Z):
122  for j in range(0, self.PROC_XY):
123  f.write(repr(self.Node[i*self.PROC_XY + j]).rjust(5))
124  f.write("\n")
125 
126  # Close the file
127  f.close()
128 
129 #------------------------------------
130 # New Function
131 #------------------------------------
class_topology.Print_Hardware
def Print_Hardware
Definition: class_topology.py:85
def class_topology.Print_Modes (   self,
  Index 
)

Definition at line 231 of file class_topology.py.

231 
232  def Print_Modes(self, Index):
233 
234  if (self.Modes_Disributed is True):
235 
236  # Check that there is a file to put outputs into, if not make one
237  output_path = 'Output'
238  if not os.path.exists(output_path):
239  os.mkdir(output_path)
240 
241  # Open new file and write out configurations
242  f = open('Output/Mode_Distribution.txt', "w")
243 
244  f.write("Core Distribution")
245  f.write("\n")
246 
247  for i in range(0, self.PROC_Z):
248  for j in range(0, self.PROC_XY):
249  f.write(repr(self.Core[i*self.PROC_XY + j]).rjust(5))
250  f.write("\n")
251 
252  f.write("\n")
253 
254  f.write("Mode Distribution")
255  f.write("\n")
256  for i in range(0, self.PROC_Z):
257  for j in range(0, self.PROC_XY):
258  f.write(repr(self.Modes[i*self.PROC_XY + j]).rjust(5))
259  f.write("\n")
260 
261  else:
262  # Check that there is a file to put outputs into, if not make one
263  output_path = 'Output'
264  if not os.path.exists(output_path):
265  os.mkdir(output_path)
266 
267  # Open new file and write out configurations
268  f = open('Output/Mode_Distribution_' + str(Index) + '.txt', "w")
269 
270  f.write('Modes have no yet been distributed by the program.')
271 
272  f.close()
273 #------------------------------------
274 # New Function
275 #------------------------------------
class_topology.Print_Modes
def Print_Modes
Definition: class_topology.py:231
def class_topology.Serial_Compute (   self)

Definition at line 512 of file class_topology.py.

References serial.Serial_Computation().

512 
513  def Serial_Compute(self):
514 
515  serial_max = 0.0
516 
517  for i in range(0, self.PROC_Z):
518  for j in range(0, self.PROC_XY):
519 
520  serial_count = 0.0
521 
522  current = self.PROC_XY * i + j
523 
524  N_P = 0
525  N_V_1 = 0
526  N_V_2 = 0
527  N_V_3 = 0
528 
529  try:
530  length = len(self.Plane_Num[i])
531  except:
532  length = 1
533 
534  for k in range(0, length):
535 
536  Current_Plane = str(1 + self.Plane_Num[i][k])
537 
538  try:
539  N_P += self.Pressure[Current_Plane][0]
540  except:
541  Turing = 'King of Computers'
542 
543  try:
544  N_V_1 += self.Velocity_1[Current_Plane][0]
545  except:
546  Turing = 'King of Computers'
547 
548  try:
549  N_V_2 += self.Velocity_2[Current_Plane][0]
550  except:
551  Turing = 'King of Computers'
552 
553  try:
554  N_V_3 += self.Velocity_3[Current_Plane][0]
555  except:
556  Turing = 'King of Computers'
557 
558  serial_count = Serial_Computation(self.P, self.Num_Elements[i][j], self.Planes[current], N_P, N_V_1, N_V_2, N_V_3, self.Num_Constants, self.constants, self.Scheme)
559 
560  if (serial_count >= serial_max):
561  serial_max = serial_count
562 
563  return(serial_max)
564 
565 
566 #------------------------------------
567 # End of Class File
568 #------------------------------------
serial.Serial_Computation
def Serial_Computation
Definition: serial.py:26
class_topology.Serial_Compute
def Serial_Compute
Definition: class_topology.py:512

Variable Documentation

class_topology.BW_Core_To_Core

Definition at line 305 of file class_topology.py.

class_topology.BW_Node_To_Node

Definition at line 303 of file class_topology.py.

class_topology.BW_Socket_To_Socket

Definition at line 304 of file class_topology.py.

class_topology.constants

Definition at line 174 of file class_topology.py.

class_topology.Core

Definition at line 42 of file class_topology.py.

class_topology.Data_Communication_Input

Definition at line 77 of file class_topology.py.

class_topology.Data_Element

Definition at line 291 of file class_topology.py.

class_topology.Data_Mode

Definition at line 292 of file class_topology.py.

class_topology.Data_Size_Input

Definition at line 76 of file class_topology.py.

class_topology.Elements_Disributed

Definition at line 74 of file class_topology.py.

class_topology.LAT_Core_To_Core

Definition at line 308 of file class_topology.py.

class_topology.LAT_Node_To_Node

Definition at line 306 of file class_topology.py.

class_topology.LAT_Socket_To_Socket

Definition at line 307 of file class_topology.py.

class_topology.Modes

Definition at line 153 of file class_topology.py.

class_topology.Modes_Disributed

Definition at line 75 of file class_topology.py.

class_topology.N_Z

Definition at line 151 of file class_topology.py.

class_topology.Node

Definition at line 44 of file class_topology.py.

Referenced by Nektar::NekMeshUtils::FaceMesh.AddNewPoint(), Nektar::Utilities::ProcessBL.BoundaryLayer2D(), Nektar::Utilities::ProcessBL.BoundaryLayer3D(), Nektar::NekMeshUtils::CADVertOCE.Initialise(), Nektar::Utilities::InputNek.LoadHOSurfaces(), Nektar::NekMeshUtils::Generator2D.MakeBL(), Nektar::NekMeshUtils::Line.MakeOrder(), Nektar::NekMeshUtils::Quadrilateral.MakeOrder(), Nektar::NekMeshUtils::Tetrahedron.MakeOrder(), Nektar::NekMeshUtils::Prism.MakeOrder(), Nektar::NekMeshUtils::Triangle.MakeOrder(), Nektar::NekMeshUtils::Hexahedron.MakeOrder(), Nektar::NekMeshUtils::Edge.MakeOrder(), Nektar::NekMeshUtils::Face.MakeOrder(), Nektar::NekMeshUtils::TetMesh.Mesh(), Nektar::NekMeshUtils::CurveMesh.Mesh(), Nektar::Utilities::InputNekpp.Process(), Nektar::Utilities::InputGmsh.Process(), Nektar::Utilities::InputSem.Process(), Nektar::NekMeshUtils::HOSurfaceMesh.Process(), Nektar::Utilities::InputNek5000.Process(), Nektar::Utilities::ProcessExtrude.Process(), Nektar::Utilities::InputSwan.Process(), Nektar::Utilities::InputVtk.Process(), Nektar::Utilities::ProcessSpherigon.Process(), Nektar::Utilities::InputNek.Process(), Nektar::Utilities::ProcessTetSplit.Process(), Nektar::Utilities::ProcessScalar.Process(), Nektar::NekMeshUtils::BLMesh.Proximity(), Nektar::Utilities::InputStar.ReadNodes(), Nektar::Utilities::InputPly.ReadPly(), Nektar::Utilities::InputTec.ReadZone(), Nektar::NekMeshUtils::BLMesh.Setup(), Nektar::NekMeshUtils::FaceMesh.Smoothing(), Nektar::Utilities::ProcessCyl.v_GenerateEdgeNodes(), Nektar::Utilities::ProcessCurve.v_GenerateEdgeNodes(), and Nektar::NekMeshUtils::Octree.WriteOctree().

class_topology.Num_Constants

Definition at line 173 of file class_topology.py.

class_topology.Num_Core_Per_Socket

Definition at line 34 of file class_topology.py.

class_topology.Num_Element_Msg

Definition at line 140 of file class_topology.py.

class_topology.Num_Elements

Definition at line 134 of file class_topology.py.

class_topology.Num_Modes

Definition at line 150 of file class_topology.py.

class_topology.Num_Sock_Per_Node

Definition at line 35 of file class_topology.py.

class_topology.P

Definition at line 290 of file class_topology.py.

Referenced by Nektar::MultiRegions::AssemblyMapCG.AssemblyMapCG(), Nektar::NekMeshUtils::CADSystemOCE.BuildNACA(), Nektar::SolverUtils::FilterAeroForces.CalculateForces(), Nektar::SolverUtils::FilterAeroForces.CalculateForcesMapping(), Nektar::LibUtilities::Basis.GenBasis(), Nektar::StdRegions::StdExpansion.GetEdgeToElementMap(), Nektar::RinglebFlow.GetExactRinglebFlow(), Nektar::NekMeshUtils::CADCurveOCE.NormalWRT(), Nektar::NekMeshUtils::CADSurf.OrientateEdges(), Nektar::Utilities::InputMCF.ParseFile(), Nektar::Utilities::ProcessSpherigon.Process(), Nektar::FieldUtils::ProcessNumModes.Process(), Nektar::NekMeshUtils::BLMesh.Proximity(), Nektar::StdRegions::StdPyrExp.StdPyrExp(), Nektar::Utilities::ProcessSpherigon.SuperBlend(), Nektar::FilterMovingBody.UpdateForce(), Nektar::RinglebFlowBC.v_Apply(), Nektar::SolverUtils::DriverAdaptive.v_Execute(), Nektar::StdRegions::StdPrismExp.v_GetBoundaryMap(), Nektar::StdRegions::StdTetExp.v_GetBoundaryMap(), Nektar::StdRegions::StdPrismExp.v_GetEdgeInteriorMap(), Nektar::StdRegions::StdTetExp.v_GetEdgeInteriorMap(), Nektar::StdRegions::StdPyrExp.v_GetEdgeInteriorMap(), Nektar::StdRegions::StdTetExp.v_GetEdgeNcoeffs(), Nektar::StdRegions::StdTriExp.v_GetEdgeToElementMap(), Nektar::StdRegions::StdQuadExp.v_GetEdgeToElementMap(), Nektar::StdRegions::StdPrismExp.v_GetFaceInteriorMap(), Nektar::StdRegions::StdTetExp.v_GetFaceInteriorMap(), Nektar::StdRegions::StdPyrExp.v_GetFaceInteriorMap(), Nektar::StdRegions::StdPyrExp.v_GetFaceIntNcoeffs(), Nektar::StdRegions::StdPrismExp.v_GetFaceNcoeffs(), Nektar::StdRegions::StdTetExp.v_GetFaceNcoeffs(), Nektar::StdRegions::StdPyrExp.v_GetFaceNcoeffs(), Nektar::StdRegions::StdPrismExp.v_GetFaceToElementMap(), Nektar::StdRegions::StdHexExp.v_GetFaceToElementMap(), Nektar::StdRegions::StdTetExp.v_GetFaceToElementMap(), Nektar::StdRegions::StdPyrExp.v_GetFaceToElementMap(), Nektar::StdRegions::StdPrismExp.v_GetInteriorMap(), Nektar::StdRegions::StdTetExp.v_GetInteriorMap(), Nektar::CFLtester.v_GetTimeStep(), Nektar::StdRegions::StdPrismExp.v_GetTotalEdgeIntNcoeffs(), Nektar::StdRegions::StdTetExp.v_GetTotalEdgeIntNcoeffs(), Nektar::StdRegions::StdPrismExp.v_NumBndryCoeffs(), Nektar::StdRegions::StdTetExp.v_NumBndryCoeffs(), Nektar::StdRegions::StdPyrExp.v_NumBndryCoeffs(), Nektar::StdRegions::StdPrismExp.v_NumDGBndryCoeffs(), and Nektar::StdRegions::StdTetExp.v_NumDGBndryCoeffs().

class_topology.Plane_Num

Definition at line 155 of file class_topology.py.

class_topology.Planes

Definition at line 154 of file class_topology.py.

class_topology.Pressure

Definition at line 278 of file class_topology.py.

class_topology.PROC_TOT

Definition at line 39 of file class_topology.py.

class_topology.PROC_XY

Definition at line 33 of file class_topology.py.

class_topology.PROC_Z

Definition at line 32 of file class_topology.py.

class_topology.Scheme

Definition at line 36 of file class_topology.py.

class_topology.Socket

Definition at line 43 of file class_topology.py.

class_topology.Split

Definition at line 152 of file class_topology.py.

class_topology.Velocity_1

Definition at line 279 of file class_topology.py.

class_topology.Velocity_2

Definition at line 280 of file class_topology.py.

class_topology.Velocity_3

Definition at line 281 of file class_topology.py.

Generated on Wed Mar 8 2017 12:29:24 for Nektar++ by   doxygen 1.8.8