Project

General

Profile

Wiki » History » Version 17

Theo Stassen, 26/04/2023 12:47 PM

1 3 Laurent Mirioni
h1. En bref
2
3 5 Laurent Mirioni
4 6 Laurent Mirioni
5 1 Laurent Mirioni
h1. Infos en vrac (à réarranger)
6
7 2 Laurent Mirioni
h2. Site Web JUICE officiel
8
9
https://www.cosmos.esa.int/web/juice
10
11 1 Laurent Mirioni
h2. JUICE Livelink
12
13
Les présentations des différents SWT sont disponibles sur le livelink de JUCE : https://dms.cosmos.esa.int/cs/cs?func=ll&objId=3169397&objAction=browse&viewType=1 (demander les identifiants à Laurent si besoin)
14
15 6 Laurent Mirioni
h2. JUICE/RPWI Ground segment piipeline 
16 1 Laurent Mirioni
17 6 Laurent Mirioni
Le traitement des données SCM (spectres et formes d'ondes) sera intégré au pipeline du consortium RPWI (lead. Uppsala). 
18
19
Voir le plan de développement ici : https://hephaistos.lpp.polytechnique.fr/redmine/documents/182 (à mettre à jour -> demander à D. Andrews)
20 3 Laurent Mirioni
Gitlab: https://spis.irfu.se/rpwi/rpwi_pipeline/ (compte personnel avec adresse e-mail LPP)
21
Documentation: https://www.space.irfu.se/juice/rpwi_pipeline/index.html (demander les identifiants à Laurent si besoin)
22 7 Theo Stassen
23
Lien pour tutoriel pratique "Python Documentation Using Sphinx Autosummary" : https://medium.datadriveninvestor.com/python-documentation-using-sphinx-f6dc87e1286b
24 8 Theo Stassen
25 12 Theo Stassen
h2. Notes sur l'avancée du code
26
27
- actuellement, les tests de comparaison sont effectués pour un fs = 31.995 comme idl le fait de base, on obtient des résultats où la phase du kernel résultant vaut +/- 40, et on obtient pareil (à epsilon prêt) en python.
28
Si on force le code à utiliser fs = 32 à la place, les résultats changent, la phase dans le kernel IDL vaut +/- 1e-11 , et 0 en python (donc très proche)
29
30 13 Theo Stassen
-Note d'un problème en cours (qui n'est pas trop problématique mais ennuyeux quand même) : Problème d'arrondi qui provque différences entre IDL et python :
31
32
les résultats des tests de deconvo vec varient en fonction de fs, df et surtout la manière différente dont idl et python arrondissent df et f_i lors de leur creéation/manipulation Dépendant de comment on déclare df et f (f_i) en idl et de comment on le write dans le log, les résultat du test python en utilisant comme f_i celui du log vont être positifs par epsilon 1e-4 ou non. 
33
Et je n'arrive juste pas à faire en sorte que prendre f_i de generate_freq_array en python donne des résultats positif, parceque les valeurs sont toujours différentes du f_i extrait du log.
34
35
Examples de situation :
36
fe = 31.9995, df = fe/float(nk), frq = findgen * df, write %23.16e (setting classique), python utilise ref_table -> fonctionne
37
fe = 32 -> fonctionne (logique, vu que pas besoin d'arrondi)
38
fe = 31.9995, df = fe/float(nk), frq = dindgen * df, write %23.16e , python utilise ref_table -> echec
39
(setting classique) + python utilise generate_freq_array (que ce soit round on pas) -> echec
40
fe = 31.9995, df = fe/float(nk) puis round, frq = findgen * df, write %23.16e (setting classique), python utilise generate_freq_array (round au même niveau) -> echec
41
42 12 Theo Stassen
43
h2. Documentation code
44 8 Theo Stassen
45
Le readme.md contenu dans le code uploadé sur le github possède une explication complète de la structure du fichier IDL deconvo_vec qui contient tout ce que l'on traduit en python actuellement, et la structure du fichier python deconvo_vec équivalent et de toutes les fonctions qui en découle (en cours de construction).
46 11 Theo Stassen
Je copie une version ici (visuellement plus agréable dans github:
47 1 Laurent Mirioni
48 10 Theo Stassen
**Documentation FR de l'avancé du portage IDL -> Python.**
49 9 Theo Stassen
50 10 Theo Stassen
Actuellement on se concentre sur le portage de la fonction _mms_scm_deconvo_vec_
51 1 Laurent Mirioni
52 10 Theo Stassen
Cette fonction prend en entrée une waveform et des metadatas.
53
L'object est d'effectuer la calibration continue de la waveform en convolvant 
54
le signal par un kernel que l'on construit au préalable.
55 1 Laurent Mirioni
56 10 Theo Stassen
Les différentes étapes de _mms_scm_deconvo_vec_ sont :
57 1 Laurent Mirioni
58 10 Theo Stassen
1. (on précentre la waveform d'entrée)
59
2. On souhaite créer un kernel de taille n_k, on commence donc par former un "complex spectrum" **s** de base
60
  (un array de complexes 1+0j, de taille n_k) 
61
3. On applique à **s** la fonction _mms_scm_corgain_ (même fichier)
62
   1. On crée un array de fréquence **f** linéairement croissant de pas df = f_e / n_k (f_e = fréquence d'échantillonnage), de longueur n_k
63
     auquel on soustrait f_e la seconde moitié, on a donc un array de fréquence allant de 0 -> fe/2 puis -fe/2 -> 0
64
       (le format nécessaire pour la fft)
65
   2. On calcule la réponse **c** renvoyée par _mms_corgain_
66
      1. La fonction récupère les données dans le fichier de référence des antennes (dont on a donné le path),
67
       qui contient, pour chaque antenne, un array de fréquence et pour chaque fréquence la réponse complexe référence 
68
       correspondante.
69
      2. Si **f** contient des fréquences en dehors du range du fichier de référence, 
70
       on considère que la réponse de l'antenne va être calculée pour la fréquence référence la plus proche
71
      3. On obtient la réponse de l'antenne, calculée pour chaque valeur de **f** par interpolation 
72
       des données de référence.
73
      4. On multiplie cette réponse par la valeur absolue de la réponse du filtre dfb,
74
       implémenté dans _mms_scm_dfb_dig_filter_resp_ (qui renvoie une réponse pour chaque fréquence de **f**)
75
      5. On multiplie cette réponse par la réponse du filtre bessel, implémenté dans _bessel_filter_resp_ 
76
       (qui renvoie une réponse pour chaque fréquence de **f**)
77
      6. On renvoie cette réponse
78
   3. Maintenant que l'on a **c**, on divise **s** par **c** (on applique la correction au spectre d'entrée en somme)
79
   4. La phase du terme de fréquence 0 de la réponse doit valoir 0 pour pouvoir appliquer la FFT,
80
     on set ce terme à la valeur absolue de sa valeur complexe
81
4. On a maintenant un **s** qui a subit la correction de l'antenne + dfb + bessel
82
5. On applique un filtre passe bande par _mms_scm_filtspe_ entre f_min et f_max donnés en entrée
83
6. On applique une transformée de fourier inverse, non encore normalisée, à **s**,
84
on obtient alors ce que le code appelle le kernel (qui n'est pas encore le kernel final)
85
7. Maintenant on prend seulement la partie réelle (sachant que l'imaginaire doit être négligeable si les calculs sont corrects)
86
8. On shift le kernel 
87
9. On lui applique la fenetre de convolution (Hanning, coscub, trapezoid, etc)
88
10. On normalise le kernel
89
11. On peut maintenant effectuer la convolution (_mms_scm_fastconvol_) pour la waveform d'entrée et le kernel calculé
90 9 Theo Stassen
91 10 Theo Stassen
Dans le code python, nous avons une fonction **_deconvo_vec_** correspondant à _mms_scm_deconvo_vec_ : 
92 9 Theo Stassen
93 10 Theo Stassen
1. (on précentre la waveform d'entrée)
94
2. On crée l'array de fréquence **f** en premier ( étape 3.i)
95
2. On crée le kernel non normalisé (-> étapes 2 à 6 sauf 3.i), en utilisant la fonction _**kernel_creation**_
96
   1. On crée le complex spectrum de base **spectrum** équivalent à **s** ( étape 2)
97
   2. On applique la fonction _**corr_gain_ant**_ à **spectrum** avec **f** comme argument (étape 3.ii:iv)
98
      1. On obtient **gain_array** (équivalent de **c**), initialement la réponse de l'antenne calculée par la fonction _**ant_resp**_ (3.ii.a:c) :
99
         1. La fonction récupère les données du fichier de référence (3.ii.a)
100
         2. Elle règle le problème de valeur hors range (3.ii.b)
101
         3. On effectue l'interpolation pour obtenir la réponse de l'antenne (3.ii.c) 
102
      2. On multiplie **gain_array** par la valeur absolue de la réponse du filter dfb, implémenté dans _**dfb_filter**_ (3.ii.d)
103
      3. On multiplie **gain_array** par la réponse du filter bessel, implémenté dans _**bessel_filter**_ (3.ii.e)
104
      4. On divise **spectrum** par **gain_array** (3.iii)
105
      5. On modifie le terme de fréquence 0 (3.iv)
106
   3. On applique une filtre passe bande à **spectrum** (_**bandpass_filter**_) (5)
107
   4. On applique la transformée de fourier inverse à **spectrum** (_**fft**_) et obtient **kernel** (6)
108
3. On vérifie que la partie réelle est bien négligeable et on prend uniquement la partie réelle. (7)
109
4. On shift le kernel (8))
110
5. On applique la fenêtre de convolution choisie à **kernel** en utilisant les fonction _**conv_windows**_ (9)
111
6. On normalise le kernel (10)
112 14 Theo Stassen
113
114
h2. Notice Installation
115 15 Theo Stassen
116 14 Theo Stassen
1. Installer Pycharm (J'utilise la version professional 2022.3.2 mais ça devrait fonctionner sans problème quelque soit la version https://www.jetbrains.com/fr-fr/pycharm/download/ )
117
2. Faire un git clone du code dans le répertoire de son choix (il faut donc avoir git installé) : git clone https://stassen@hephaistos.lpp.polytechnique.fr/rhodecode/GIT_REPOSITORIES/LPP/DATA-PROCESSING/SCM-Waveforms-Calibration
118
3. Ouvrir Pycharm, Aller dans File -> Open -> Chercher le répertoire où se trouve le code -> Ouvrir
119
4. Il faut maintenant créer un virtual environment. La manière la plus simple c'est d'aller dans File -> Settings -> Project : project name -> Python Interpreter -> Cliquer sur Add Interpeter -> Add Local Interpreter 
120
Dans virtualenv environment, cliquer sur New, laisser la location de base, base Interpreter : le path de python3 -> Ok. Puis fermer les settings. En principe maintenant le projet possède un virualenv local, quasi vide.
121
5. Il faut télécharger les requirements. Première possiblilté, en ouvrant n'importe quel fichier du projet, Pycharm met un message indiquant qu'il faut installer les requirements. Valider, installer tout les modules. En principe quand le téléchargement est fini on est bon. Deuxième possibilité, Ouvrir un nouveau terminal en bas dans pycharm. Rentrer la commande : 'pip install -r requirements.txt' 
122 1 Laurent Mirioni
6. Pour tester que tout fonctionne, ouvrir le fichier main.py, clic droit -> run main.py. Si affiche 
123 15 Theo Stassen
124 14 Theo Stassen
Ran 13 tests in xxxxs
125
126
OK
127
128
On est bon.
129
On peut run de la même façon tests/calibrate_and_compare.py qui est un script qui calibrate un fichier l1a, et compare le résultat avec le fichier l1b de référence et le l1b généré par IDL. On peut run src/evaluation/compare_cdfs pour la comparaison de différents spectrums. 
130 16 Theo Stassen
131
Note : Ensuite quand on veut push/pull le répertoire distant on peut le faire simplement dans pycharm -> Git
132 17 Theo Stassen
133
h3. Installation Pylint (Pour PEP8) :
134
1. Pour installer le module pylint de pycharm : File -> Settings -> Plugins : chercher pylint dans la liste, et l'installer. 
135
2. Pylint apparaît en bas du menu de gauche dans File -> Settings (si non, relancer pycharm) 
136
3. Dans le terminal de pycharm, en étant bien avec le venv activé, taper 'pip install pylint'
137
4. Dans File -> Settings -> Pylint, pour le "Path to Pylint executable", normalement cela affiche Auto-detected : path/pylint -> Appuyer sur test, si test validé -> Appuyer sur Ok. Si le path n'est pas trouvé directement il faut trouver le path du pylint dans le venv du projet, et le copier là. 
138
5. Une fois que c'est fait, en bas à côté des icônes terminal etc se trouve Pylint, le module qui permet d'analyser le PEP8 de ce que l'on souhaite. 
139
6. Pycharm affichera également les PEP8 warnings dans le code directement.