Project

General

Profile

Wiki » History » Version 10

Theo Stassen, 15/03/2023 04:50 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
h2. Avancées code
26
27
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).
28 9 Theo Stassen
Je copie une version ici :
29 1 Laurent Mirioni
30 10 Theo Stassen
**Documentation FR de l'avancé du portage IDL -> Python.**
31 9 Theo Stassen
32 10 Theo Stassen
Actuellement on se concentre sur le portage de la fonction _mms_scm_deconvo_vec_
33 1 Laurent Mirioni
34 10 Theo Stassen
Cette fonction prend en entrée une waveform et des metadatas.
35
L'object est d'effectuer la calibration continue de la waveform en convolvant 
36
le signal par un kernel que l'on construit au préalable.
37 1 Laurent Mirioni
38 10 Theo Stassen
Les différentes étapes de _mms_scm_deconvo_vec_ sont :
39 1 Laurent Mirioni
40 10 Theo Stassen
1. (on précentre la waveform d'entrée)
41
2. On souhaite créer un kernel de taille n_k, on commence donc par former un "complex spectrum" **s** de base
42
  (un array de complexes 1+0j, de taille n_k) 
43
3. On applique à **s** la fonction _mms_scm_corgain_ (même fichier)
44
   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
45
     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
46
       (le format nécessaire pour la fft)
47
   2. On calcule la réponse **c** renvoyée par _mms_corgain_
48
      1. La fonction récupère les données dans le fichier de référence des antennes (dont on a donné le path),
49
       qui contient, pour chaque antenne, un array de fréquence et pour chaque fréquence la réponse complexe référence 
50
       correspondante.
51
      2. Si **f** contient des fréquences en dehors du range du fichier de référence, 
52
       on considère que la réponse de l'antenne va être calculée pour la fréquence référence la plus proche
53
      3. On obtient la réponse de l'antenne, calculée pour chaque valeur de **f** par interpolation 
54
       des données de référence.
55
      4. On multiplie cette réponse par la valeur absolue de la réponse du filtre dfb,
56
       implémenté dans _mms_scm_dfb_dig_filter_resp_ (qui renvoie une réponse pour chaque fréquence de **f**)
57
      5. On multiplie cette réponse par la réponse du filtre bessel, implémenté dans _bessel_filter_resp_ 
58
       (qui renvoie une réponse pour chaque fréquence de **f**)
59
      6. On renvoie cette réponse
60
   3. Maintenant que l'on a **c**, on divise **s** par **c** (on applique la correction au spectre d'entrée en somme)
61
   4. La phase du terme de fréquence 0 de la réponse doit valoir 0 pour pouvoir appliquer la FFT,
62
     on set ce terme à la valeur absolue de sa valeur complexe
63
4. On a maintenant un **s** qui a subit la correction de l'antenne + dfb + bessel
64
5. On applique un filtre passe bande par _mms_scm_filtspe_ entre f_min et f_max donnés en entrée
65
6. On applique une transformée de fourier inverse, non encore normalisée, à **s**,
66
on obtient alors ce que le code appelle le kernel (qui n'est pas encore le kernel final)
67
7. Maintenant on prend seulement la partie réelle (sachant que l'imaginaire doit être négligeable si les calculs sont corrects)
68
8. On shift le kernel 
69
9. On lui applique la fenetre de convolution (Hanning, coscub, trapezoid, etc)
70
10. On normalise le kernel
71
11. On peut maintenant effectuer la convolution (_mms_scm_fastconvol_) pour la waveform d'entrée et le kernel calculé
72 9 Theo Stassen
73 10 Theo Stassen
Dans le code python, nous avons une fonction **_deconvo_vec_** correspondant à _mms_scm_deconvo_vec_ : 
74 9 Theo Stassen
75 10 Theo Stassen
1. (on précentre la waveform d'entrée)
76
2. On crée l'array de fréquence **f** en premier ( étape 3.i)
77
2. On crée le kernel non normalisé (-> étapes 2 à 6 sauf 3.i), en utilisant la fonction _**kernel_creation**_
78
   1. On crée le complex spectrum de base **spectrum** équivalent à **s** ( étape 2)
79
   2. On applique la fonction _**corr_gain_ant**_ à **spectrum** avec **f** comme argument (étape 3.ii:iv)
80
      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) :
81
         1. La fonction récupère les données du fichier de référence (3.ii.a)
82
         2. Elle règle le problème de valeur hors range (3.ii.b)
83
         3. On effectue l'interpolation pour obtenir la réponse de l'antenne (3.ii.c) 
84
      2. On multiplie **gain_array** par la valeur absolue de la réponse du filter dfb, implémenté dans _**dfb_filter**_ (3.ii.d)
85
      3. On multiplie **gain_array** par la réponse du filter bessel, implémenté dans _**bessel_filter**_ (3.ii.e)
86
      4. On divise **spectrum** par **gain_array** (3.iii)
87
      5. On modifie le terme de fréquence 0 (3.iv)
88
   3. On applique une filtre passe bande à **spectrum** (_**bandpass_filter**_) (5)
89
   4. On applique la transformée de fourier inverse à **spectrum** (_**fft**_) et obtient **kernel** (6)
90
3. On vérifie que la partie réelle est bien négligeable et on prend uniquement la partie réelle. (7)
91
4. On shift le kernel (8))
92
5. On applique la fenêtre de convolution choisie à **kernel** en utilisant les fonction _**conv_windows**_ (9)
93
6. On normalise le kernel (10)