Nektar++
Functions
serial Namespace Reference

Functions

def Serial_Computation (P, Num_Elements, Num_Modes, N_P, N_V_1, N_V_2, N_V_3, Num_Constants, constants, Scheme)
 
def Operation_Count (P, Num_Elements, Num_Modes, N_P, N_V_1, N_V_2, N_V_3, Scheme)
 
def compare_data (constants, Num_Constants, Data, T_A, T_E)
 
def Fit_Model (Num_Constants, Data, T_A, T_E)
 
def Run_Serial_Fit (Compare_Serial, Consider_Modes, Num_Constants, P, Num_Elements, Nektar_Modes, Timings, Pressure, Velocity_1, Velocity_2, Velocity_3, Scheme)
 

Function Documentation

◆ compare_data()

def serial.compare_data (   constants,
  Num_Constants,
  Data,
  T_A,
  T_E 
)

Definition at line 107 of file serial.py.

107def compare_data(constants, Num_Constants, Data, T_A, T_E):
108
109 # Lemons make nice Lemonade (Needed a list to hold results)
110 lemons = []
111
112 # Loop over data calculating difference between data and model, this will be minimised by the constants.
113 for i in range(0, len(Data)):
114
115 if (Num_Constants == 1):
116 lemons.append(Data[i] - (T_A[i] + T_E[i])/constants)
117
118 if (Num_Constants == 2):
119 lemons.append(Data[i] - (T_A[i] / constants[0] + T_E[i] / constants[1]))
120
121 # Calculate the L_2 norm of the difference, this is the quantity to be minimised by the optimisation step
122 L_2_norm = np.linalg.norm(lemons, 2)
123
124 return(L_2_norm)
125
126#------------------------------------
127# New Function
128#------------------------------------
129
130# Function to run the fmin optimisation algorithm to fit the model to the data.
serial.compare_data
def compare_data(constants, Num_Constants, Data, T_A, T_E)
Definition: serial.py:107

◆ Fit_Model()

def serial.Fit_Model (   Num_Constants,
  Data,
  T_A,
  T_E 
)

Definition at line 131 of file serial.py.

131def Fit_Model(Num_Constants, Data, T_A, T_E):
132
133 # Numpy arrays to hold the results and data.
134 Data = np.array(Data)
135 T_A = np.array(T_A)
136 T_E = np.array(T_E)
137
138 # Set the initial values depending on how many constants are required
139 if (Num_Constants == 1):
140 inital = 1e6
141
142 if (Num_Constants == 2):
143 inital = np.array([1e6, 1e06])
144
145 # Run the optimisation algorithm
146 Fit = fmin(compare_data, inital, args=(Num_Constants, Data, T_A, T_E), xtol=0.0001, ftol=1, maxiter=1e04, maxfun=1e09)
147
148 # Return the fitted constants.
149 return(Fit)
150
151#------------------------------------
152# New Function
153#------------------------------------
154
155# Function to run all the steps in order to fit the serial model to serially produced data.
serial.Fit_Model
def Fit_Model(Num_Constants, Data, T_A, T_E)
Definition: serial.py:131

Referenced by Run_Serial_Fit().

◆ Operation_Count()

def serial.Operation_Count (   P,
  Num_Elements,
  Num_Modes,
  N_P,
  N_V_1,
  N_V_2,
  N_V_3,
  Scheme 
)

Definition at line 72 of file serial.py.

72def Operation_Count(P, Num_Elements, Num_Modes, N_P, N_V_1, N_V_2, N_V_3, Scheme):
73
74# Operation Counts as per the thesis
75 O_A_1 = 9 * Num_Elements * (P + 1) ** 2 * Num_Modes * m.log(Num_Modes, 2)
76 O_A_2 = Num_Elements * Num_Modes * (P + 1) ** 2
77 O_A_3 = 6 * Num_Elements * (P + 1) ** 4 * Num_Modes
78 O_A_4 = 15 * Num_Elements * (P + 1) ** 2 * Num_Modes
79
80 T_A = O_A_1 + O_A_2 + O_A_3 + O_A_4
81
82 if (Scheme == 'IterativeFull'):
83 O_E_1 = 8 * Num_Elements * (P + 1) ** 2
84 O_E_2 = Num_Elements * (P + 1) ** 2
85 O_E_3 = Num_Elements * ((4 * P ** 3) + (18 * P ** 2) + (26 * P) + 12)
86 O_E_4 = 6 * Num_Elements * (P + 1) ** 2
87
88 t_e = O_E_1 + O_E_2 + O_E_3 + O_E_4
89
90 T_E = (N_P + N_V_1 + N_V_2 + N_V_3) * t_e
91
92 if (Scheme == 'IterativeStaticCond'):
93 O_E_1 = 8 * ((P - 1) ** 2) * 4 * P * Num_Elements * Num_Modes
94 O_E_2 = (N_P + N_V_1 + N_V_2 + N_V_3) * 2 * 16 * (P ** 2) * Num_Elements
95 O_E_3 = (8 * 4 * ((P - 1) ** 2)) + (4 * ((P - 1) ** 2)) * Num_Elements * Num_Modes
96 O_E_4 = 8 * ((((P - 1) ** 2)) ** 2) * Num_Elements * Num_Modes
97
98 T_E = O_E_1 + O_E_2 + O_E_3 + O_E_4
99
100 return(T_A, T_E)
101
102#------------------------------------
103# New Function
104#------------------------------------
105
106# Find the L_2 norm of the difference between the data and model, used for fitting.
serial.Operation_Count
def Operation_Count(P, Num_Elements, Num_Modes, N_P, N_V_1, N_V_2, N_V_3, Scheme)
Definition: serial.py:72

Referenced by Run_Serial_Fit().

◆ Run_Serial_Fit()

def serial.Run_Serial_Fit (   Compare_Serial,
  Consider_Modes,
  Num_Constants,
  P,
  Num_Elements,
  Nektar_Modes,
  Timings,
  Pressure,
  Velocity_1,
  Velocity_2,
  Velocity_3,
  Scheme 
)

Definition at line 156 of file serial.py.

156def Run_Serial_Fit(Compare_Serial, Consider_Modes, Num_Constants, P, Num_Elements, Nektar_Modes, Timings, Pressure, Velocity_1, Velocity_2, Velocity_3, Scheme):
157
158 # List to hold data from Nektar simulation
159 Data = []
160
161 # Loop over modes to be considered in calibrating the model
162 for i in range(0, len(Consider_Modes)):
163 Data.append(np.mean(Timings[str(Consider_Modes[i])])/10)
164
165 # Lists to hold the operation counts to be fed into the optimisation
166 T_A = []
167 T_E = []
168
169 # Loop over modes to be used in the model
170 for i in range(0, len(Consider_Modes)):
171
172 # Initialise CG counters to 0
173 N_P = 0
174 N_V_1 = 0
175 N_V_2 = 0
176 N_V_3 = 0
177
178 # Loop over all the modes up to the mode being considered adding the CG iterations from each mode to the counter
179 for j in range(1, Consider_Modes[i] + 1):
180
181 # Skip the 2nd mode as we do not get any data about it from Nektar
182 if (j == 2):
183 continue
184
185 # We don't necessarily have data for all the CG iterations hence we use try
186 # The except case has to be included to keep python happy hence we pay homage to Alan Turing
187 try:
188 N_P += Pressure[str(j)][0]
189 except:
190 Turing = 'King of Computers'
191
192 try:
193 N_V_1 += Velocity_1[str(j)][0]
194 except:
195 Turing = 'King of Computers'
196
197 try:
198 N_V_2 += Velocity_2[str(j)][0]
199 except:
200 Turing = 'King of Computers'
201
202 try:
203 N_V_3 += Velocity_3[str(j)][0]
204 except:
205 Turing = 'King of Computers'
206
207 # Perform the operation counts for each mode and store these to be fed into the optimisation step
208 (t_a, t_e) = Operation_Count(P, Num_Elements, Consider_Modes[i], N_P, N_V_1, N_V_2, N_V_3, Scheme)
209 T_A.append(t_a)
210 T_E.append(t_e)
211
212 # Now fit the model to the data
213 Fit = Fit_Model(Num_Constants, Data, T_A, T_E)
214
215 # Print the fitted FLOPs
216 print(Fit)
217
218 # Output the comparison the results if the user desires
219 if Compare_Serial is True:
220
221 # Pharse the Nektar data as before
222 Data = []
223
224 for i in range(1, len(Nektar_Modes)):
225 Data.append(np.mean(Timings[str(Nektar_Modes[i])])/10)
226
227 Time = []
228
229 for i in range(1, len(Nektar_Modes)):
230 N_P = 0
231 N_V_1 = 0
232 N_V_2 = 0
233 N_V_3 = 0
234
235 for j in range(1, Nektar_Modes[i] + 1):
236
237 if (j == 2):
238 continue
239
240 try:
241 N_P += Pressure[str(j)][0]
242 except:
243 Turing = 'King of Computers'
244
245 try:
246 N_V_1 += Velocity_1[str(j)][0]
247 except:
248 Turing = 'King of Computers'
249
250 try:
251 N_V_2 += Velocity_2[str(j)][0]
252 except:
253 Turing = 'King of Computers'
254
255 try:
256 N_V_3 += Velocity_3[str(j)][0]
257 except:
258 Turing = 'King of Computers'
259
260 Time.append(Serial_Computation(P, Num_Elements, Nektar_Modes[i], N_P, N_V_1, N_V_2, N_V_3, Num_Constants, Fit, Scheme))
261
262 Nektar_Modes = list(Nektar_Modes)
263 Nektar_Modes.pop(0)
264
265 # Calculate the mean, standard deviation and variance of the difference between the data and the fitted model
266 difference = []
267
268 for i in range(0, len(Nektar_Modes)):
269 difference.append(abs(Data[i] - Time[i]))
270
271 mean_diff = np.mean(difference)
272 std_dev_diff = np.std(difference)
273 var_diff = np.var(difference)
274
275 # Print these results for the user to see
276 print('The mean of the differences between the Data and the Model is ' + str(mean_diff))
277 print('The standard deviation of the differences between the Data and the Model is ' + str(std_dev_diff))
278 print('The variance of the differences between the Data and the Model is ' + str(var_diff))
279
280 # Plot the two data sets together for a visual comparison
281 fig, ax = plt.subplots()
282 ax.plot(Nektar_Modes, Data, label = 'Data')
283 ax.errorbar(Nektar_Modes, Time, label = 'Model')
284 ax.set_xlabel('$ N_Z $')
285 ax.set_ylabel('Timestep (s)')
286 ax.set_title('Length of Single Timestep: Model vs Data')
287 plt.legend(loc=4)
288 fig.savefig("Output/Figures/Model_vs_Data.png")
289
290 return(Fit)
291
292#------------------------------------
293# End of Functions
294#------------------------------------
serial.Run_Serial_Fit
def Run_Serial_Fit(Compare_Serial, Consider_Modes, Num_Constants, P, Num_Elements, Nektar_Modes, Timings, Pressure, Velocity_1, Velocity_2, Velocity_3, Scheme)
Definition: serial.py:156
serial.Serial_Computation
def Serial_Computation(P, Num_Elements, Num_Modes, N_P, N_V_1, N_V_2, N_V_3, Num_Constants, constants, Scheme)
Definition: serial.py:26
tinysimd::abs
scalarT< T > abs(scalarT< T > in)
Definition: scalar.hpp:298

References tinysimd.abs(), Fit_Model(), Operation_Count(), and Serial_Computation().

◆ Serial_Computation()

def serial.Serial_Computation (   P,
  Num_Elements,
  Num_Modes,
  N_P,
  N_V_1,
  N_V_2,
  N_V_3,
  Num_Constants,
  constants,
  Scheme 
)

Definition at line 26 of file serial.py.

26def Serial_Computation(P, Num_Elements, Num_Modes, N_P, N_V_1, N_V_2, N_V_3, Num_Constants, constants, Scheme):
27
28# Operation Counts as per the thesis
29 O_A_1 = 9 * Num_Elements * (P + 1) ** 2 * Num_Modes * m.log(Num_Modes, 2)
30 O_A_2 = Num_Elements * Num_Modes * (P + 1) ** 2
31 O_A_3 = 6 * Num_Elements * (P + 1) ** 4 * Num_Modes
32 O_A_4 = 15 * Num_Elements * (P + 1) ** 2 * Num_Modes
33
34 T_A = O_A_1 + O_A_2 + O_A_3 + O_A_4
35
36 if (Scheme == 'IterativeFull'):
37 O_E_1 = 8 * Num_Elements * (P + 1) ** 2
38 O_E_2 = Num_Elements * (P + 1) ** 2
39 O_E_3 = Num_Elements * ((4 * P ** 3) + (18 * P ** 2) + (26 * P) + 12)
40 O_E_4 = 6 * Num_Elements * (P + 1) ** 2
41
42 t_e = O_E_1 + O_E_2 + O_E_3 + O_E_4
43
44 T_E = (N_P + N_V_1 + N_V_2 + N_V_3) * t_e
45
46 if (Scheme == 'IterativeStaticCond'):
47 O_E_1 = 8 * ((P - 1) ** 2) * 4 * P * Num_Elements * Num_Modes
48 O_E_2 = (N_P + N_V_1 + N_V_2 + N_V_3) * 2 * 16 * (P ** 2) * Num_Elements
49 O_E_3 = (8 * 4 * ((P - 1) ** 2)) + (4 * ((P - 1) ** 2)) * Num_Elements * Num_Modes
50 O_E_4 = 8 * ((((P - 1) ** 2)) ** 2) * Num_Elements * Num_Modes
51
52 T_E = O_E_1 + O_E_2 + O_E_3 + O_E_4
53
54# Divide by operations per second.
55
56 if (Num_Constants == 1):
57 T_A = T_A / constants
58 T_E = T_E / constants
59
60 if (Num_Constants == 2):
61 T_A = T_A / constants[0]
62 T_E = T_E / constants[1]
63
64 Time = T_A + T_E
65
66 return(Time)
67
68#------------------------------------
69# New Function
70#------------------------------------
71

Referenced by Run_Serial_Fit(), and class_topology.Topology.Serial_Compute().

Generated on Wed Oct 30 2024 16:07:46 for Nektar++ by doxygen 1.9.4