-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathprocessing.py
247 lines (188 loc) · 8.95 KB
/
processing.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
"""
MEC6616 Aérodynamique Numérique
@author: Audrey Collard-Daigneault
Matricule: 1920374
@author: Mohamad Karim ZAYNI
Matricule: 2167132
"""
# ----------------------------------------------------------------------------#
# MEC6616 #
# LAP4 Équations du momentum #
# Collard-Daigneault Audrey, ZAYNI Mohamad Karim #
# ----------------------------------------------------------------------------#
# %% IMPORT
import numpy as np
from meshConnectivity import MeshConnectivity
from meshGenerator import MeshGenerator
from solver import FVM
from postProcessing import PostProcessing
import gradientLS as GLS
# %% CLASSE
class Processing:
"""
Exécute les simulations demandées selon le cas et le post-traitement
Parameters
----------
case: case
Cas traité qui a les informations sur la physique du problème
bcdata: tuple
Ensemble de donnée sur les conditions limites aux parois
Attributes
-------
case: Case
Cas traité qui a les informations sur la physique du problème
bcdata: Tuple
Ensemble de donnée sur les conditions limites aux parois
simulations_parameters: List[Dict[str, str]]
Liste de dictionnaires ayant le nom des paramètres de simulation et leurs valeurs
postprocessing_parameters: Dict[str, Dict[str, float]]]
Dictionnaire ayant le nom des paramètres de post-traitement et les arguments nécessaires
"""
def __init__(self, case, bcdata):
self.case = case
self.bcdata = bcdata
self.simulations_parameters = None
self.postprocessing_parameters = None
self.test = True
def set_analytical_function(self, analytical_function) -> None:
"""
Ajoute une solution analytique au problème simulé lorsque disponible et/ou nécessaire
Parameters
----------
analytical_function: Tuple[function, function]
Fonction analytique du problème (u(x,y) et v(x,y))
"""
self.analytical_function = analytical_function
def set_simulations_and_postprocessing_parameters(self, simulations_parameters, postprocessing_parameters) -> None:
"""
Paramétrise les simulations à exécuter et les post-traitement à réaliser
Parameters
----------
simulations_parameters: List[Dict[str, str]
Liste de dictionnaires ayant le nom des paramètres de simulation et leurs valeurs
postprocessing_parameters: Dict[str, Dict[str, float]]]
Dictionnaire ayant le nom des paramètres de post-traitement et les arguments nécessaires
Returns
-------
None
"""
self.simulations_parameters = simulations_parameters
self.postprocessing_parameters = postprocessing_parameters
def execute_simulations(self, sim_name):
"""
Exécute les simulations demandées
Parameters
----------
sim_name: str
Titre de la simulation effectuée
Returns
-------
None
"""
postprocessing = PostProcessing(sim_name)
# Excécute plusieurs simulations selon l'ensemble de parametres de simulation
for sim_param in self.simulations_parameters:
# Crée le mesh et calcule les informations extraites à partir du maillage
mesh_obj = self.compute_mesh_and_connectivity(sim_param)
preprocessing_data = self.execute_preprocessing(mesh_obj)
# Initialise le solver et paramétrise la solution analytique et execute la solution selon la méthode
solver = FVM(self.case, mesh_obj, self.bcdata, preprocessing_data)
solver.set_analytical_function(self.analytical_function)
solver.set_P(sim_param['P'])
solutions = solver.solve(sim_param['method'])
# Store les résultats de la simulation et des infos pertinentes pour le post-traitement
postprocessing.set_data(mesh_obj, solutions, preprocessing_data, sim_param)
# S'ils y a du post-traitement, il appelle la fonction qui les exécutes
if self.postprocessing_parameters is not None:
self.execute_postprocessing(postprocessing)
def execute_postprocessing(self, postprocessing) -> None:
"""
Exécute le post-traitement demandé
Parameters
----------
postprocessing: postProcessing.PostProcessing
Object de post-traitement qui a storé les données pendant la simulation
Returns
-------
None
"""
# Itére sur les keys du dictionnaire pour déterminer les post-traitement à faire
pp_params = self.postprocessing_parameters
for param_name in pp_params:
# Affiche les solutions avec la fonction tricontourf() de matplotlib
if param_name == 'solutions':
for sim in pp_params[param_name]['simulation']:
postprocessing.show_solutions(i_sim=sim,only_num=pp_params[param_name]['Only_Num'])
# Affiche la solution selon un plan en x et un en y
elif param_name == 'plans':
for sim in pp_params[param_name]['simulation']:
postprocessing.show_plan_solutions(i_sim=sim,
x_coupe=pp_params[param_name]['x'],
y_coupe=pp_params[param_name]['y'],
only_num=pp_params[param_name]['Only_Num'],
plan_sortie=pp_params[param_name]['Exit'])
# Calcule l'ordre de convergence et montre l'erreur L2 selon la longueur caractéristique l2
elif param_name == 'error':
postprocessing.show_error(method=pp_params[param_name]['Method'])
# Montre les résultats numériques et analytique par PyVista avec le maillage
elif param_name == 'pyvista':
for sim in pp_params[param_name]['simulation']:
postprocessing.show_pyvista(sim,only_num=pp_params[param_name]['Only_Num'],isovalues=pp_params[param_name]['Iso_lines'])
else:
print(f'Demande de post traitement {param_name} invalide.')
def compute_mesh_and_connectivity(self, mesh_parameters):
"""
Exécute la connectivité avec le maillage généré.
Parameters
----------
mesh_parameters: Dict[str, str]
Dictionnaire des paramètres pour mesh à générer
Returns
-------
mesh_obj: Mesh
Maillage de la simulation
"""
mesher = MeshGenerator()
domain = self.case.get_domain()
# Construit le maillage selon la géométrie du domain
if domain['type'] == 'rectangle':
mesh_obj = mesher.rectangle_points(domain['points'], mesh_parameters)
elif domain['type'] == 'cercle':
mesh_obj = mesher.circle_points(domain['points'], domain['radius'], mesh_parameters)
conec = MeshConnectivity(mesh_obj, verbose=False)
conec.compute_connectivity()
return mesh_obj
def execute_preprocessing(self, mesh_obj):
"""
Effectue les calculs relatifs au maillage préalablement à l'utilisation du solver
Parameters
----------
mesh_obj: Mesh
Maillage de la simulation
Returns
-------
(volumes, centroids): Tuple[numpy.ndarray, numpy.ndarray]
Arrays storant les volumes des éléments et la position du centroide
"""
n_elem = mesh_obj.get_number_of_elements() # Nombre d'éléments dans notre maillage
volumes = np.zeros(n_elem) # surface des éléments
centroids = np.zeros((n_elem, 2)) # coordonnees des centroides
# Détermine les centroides et l'aire de l'élément par les déterminants
for i_elem in range(n_elem):
nodes = mesh_obj.get_element_to_nodes(i_elem)
area_matrices = [np.zeros([2, 2]) for i in range(len(nodes))]
for i in range(len(nodes)):
x, y = mesh_obj.get_node_to_xycoord(nodes[i])[0], mesh_obj.get_node_to_xycoord(nodes[i])[1]
area_matrices[i][:, 0] = [x, y]
area_matrices[i - 1][:, 1] = [x, y]
# Calcule l'aire de l'élément
volumes[i_elem] = np.sum([np.linalg.det(area_matrices[i]) for i in range(len(nodes))]) / 2
# Calcule du position des centroides
cx = (np.sum(
[np.sum(area_matrices[i][0, :]) * np.linalg.det(area_matrices[i]) for i in range(len(nodes))]) /
(6 * volumes[i_elem]))
cy = (np.sum(
[np.sum(area_matrices[i][1, :]) * np.linalg.det(area_matrices[i]) for i in range(len(nodes))]) /
(6 * volumes[i_elem]))
centroids[i_elem] = [cx, cy]
return volumes, centroids