Thèse : imagerie micro-ondes

Étude du problème direct : on fait varier les paramètres de la perturbation et on étudie leur influence sur les mesures.

Pour chaque perturbation, on fixe ses paramètres, on lance le solveur (à distance la plupart du temps), on récupère les résultats.

Tout est manuel, c'est long, et la gestion des doublons n'est pas simple.

C'est (très) dépendant de ces travaux en particulier, avec un code un peu moche.

Un outil plus générique : Hateno, développement débuté en décembre 2019.

Utilisation du format JSON pour une description plus naturelle d'une simulation.

							{
								"folder": "simulations/example",
								"settings": {
									"perturbation": {
										"x": 0,
										"y": 0.2,
										"z": 0.1,
										"r": 1
									}
								}
							}
						

Toute simulation est identifiée par une chaîne de caractères unique (sérialisation de la représentation JSON).

Ajouter une simulation à la base revient à faire le lien entre cet identifiant et les fichiers compressés.

Par la suite, ce même identifiant permet de déterminer si une simulation existe déjà, pour extraire ses fichiers ou pour la supprimer de la base.

La description de simulations peut être stockée dans un fichier JSON, ou générée via un script Python.

							def generate():
								return [
									{
										'folder': f'simulations/x_{x}',
										'settings': {
											'perturbation': {
												'x': x,
												'y': 0
											}
										}
									}
									for x in (0.8 * k / 9 for k in range(0, 10))
								]
						

L'identification des paramètres est stricte : '0.0' != '0' !

Les valeurs peuvent être altérées avant d'être utilisées via les fixers (arrondis, conversions, …).

								{
									"folder": "simulation",
									"settings": {
										"perturbation": {
											"x": 0.0,
											"y": 0.00000000012
										}
									}
								}
							

								{
									"folder": "simulation",
									"settings": {
										"perturbation": {
											"x": 0,
											"y": 0
										}
									}
								}
							

Le manager seul ne permet pas de générer des simulations : une étape (manuelle) d'identification reste nécessaire et peut mener à des erreurs.

Un second module, le générateur, permet de générer une ligne de commande à partir de la description d'une simulation.

								{
									"folder": "simulation",
									"settings": {
										"interval": {
											"a": -1,
											"b": 1
										},
										"function": {
											"name": "cos"
										}
									}
								}
							

								a-useless-program -a -1 -b 1 -name cos
							

Comment les générer en parallèle ?

Pour générer $N$ simulations sur $p$ processus parallèles, on peut découper la liste des simulations en $p$ groupes de $\frac{N}{p}$.

Intérêt : plusieurs jobs peuvent tourner en parallèle, avec ajout dynamique possible.

Un nouveau module fait le lien entre tous : le Maker.

Le Maker boucle jusqu'à avoir toutes les simulations en utilisant les autres modules.

Le Maker est utile pour tester des paramètres fixés à l'avance : comment l'utiliser pour déterminer un paramètre optimal ?

Exemple : un script admet pour paramètre un nombre $L$ et stocke les valeurs de la fonction $x \mapsto \cos(Lx)$ pour $x \in [-1,1]$.

On évalue une simulation en sommant les valeurs obtenues (jusqu'à l'avant-dernière) et on recherche le zéro de cette fonction d'évaluation.

Calculer cette somme revient à approcher l'intégrale de $\cos(L\cdot)$ sur $[-1,1]$ (à une constante multiplicative près). Les zéros de cette intégrale sont les multiples de $\pi$.

Une première idée est d'utiliser le Maker : on teste plusieurs valeurs de $L$, on évalue chaque simulation et on affine l'intervalle de recherche manuellement.

C'est manuel, un peu (beaucoup) ennuyeux, et on stocke des simulations qui ne sont pas forcément nécessaires.

Un autre module permet d'automatiser cette tâche : le Mapper.

Une fonction d'évaluation est définie par l'utilisateur : elle associe une simulation ou un groupe de simulations à une valeur (généralement un nombre).

Le Mapper permet d'associer des simulations à ces valeurs sans nécessairement les stocker.

								{
									"setting": {
										"set": "function",
										"name": "coef"
									},
									"values": {
										"from": 3,
										"to": 4,
										"n": 11
									},
									"evaluation": "sum",
									"test": 0
								}
							

								3	=> 4.65553472407729
								3.1	=> 1.327464539195628
								3.2	=> -1.8053210714786265
								3.3	=> -4.7306179645169415
								3.4	=> -7.437830001433772
								3.5	=> -9.918020001078782
								3.6	=> -12.163947833538455
								3.7	=> -14.170095476233925
								3.8	=> -15.932678957570847
								3.9	=> -17.449647218138928
								4	=> -18.720668023211
							

Le Mapper utilise le Maker pour générer les simulations décrites, puis appelle la fonction d'évaluation et enfin teste le passage en 0.

Le Mapper peut aussi être utilisé pour affiner l'intervalle de recherche automatiquement.

Hateno est utilisable, pour générer des simulations ou rechercher des paramètres optimaux.

Le code est instable et le restera jusqu'à la version 1.0 : des ajustements sont parfois nécessaires entre deux versions (exemple : la future version 0.17 qui va encore tout casser).