Project

General

Profile

Wiki » History » Revision 9

Revision 8 (Theo Stassen, 14/03/2023 06:04 PM) → Revision 9/24 (Theo Stassen, 15/03/2023 04:36 PM)

h1. En bref 



 h1. Infos en vrac (à réarranger) 

 h2. Site Web JUICE officiel 

 https://www.cosmos.esa.int/web/juice 

 h2. JUICE Livelink 

 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) 

 h2. JUICE/RPWI Ground segment piipeline  

 Le traitement des données SCM (spectres et formes d'ondes) sera intégré au pipeline du consortium RPWI (lead. Uppsala).  

 Voir le plan de développement ici : https://hephaistos.lpp.polytechnique.fr/redmine/documents/182 (à mettre à jour -> demander à D. Andrews) 
 Gitlab: https://spis.irfu.se/rpwi/rpwi_pipeline/ (compte personnel avec adresse e-mail LPP) 
 Documentation: https://www.space.irfu.se/juice/rpwi_pipeline/index.html (demander les identifiants à Laurent si besoin) 

 Lien pour tutoriel pratique "Python Documentation Using Sphinx Autosummary" : https://medium.datadriveninvestor.com/python-documentation-using-sphinx-f6dc87e1286b 

 h2. Avancées code 

 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). 
 Je copie une version ici : 

 Documentation FR de l'avancé du portage IDL -> Python. 

 Actuellement on se concentre sur le portage de la fonction mms_scm_deconvo_vec 

 Cette fonction prend en entrée une waveform et des metadatas. L'object est d'effectuer la calibration continue de la waveform en convolvant le signal par un kernel que l'on construit au préalable. 

 Les différentes étapes de mms_scm_deconvo_vec sont Note : 

     (on précentre la waveform d'entrée) 
     On souhaite créer un kernel de taille n_k, on commence donc par former un "complex spectrum" s de base (un array de complexes 1+0j, de taille n_k) 
     On applique je dois mettre à s la fonction mms_scm_corgain (même fichier) 
     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 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 (le format nécessaire pour la fft) 
     On calcule la réponse c renvoyée par mms_corgain 
         La fonction récupère jour les données dans le fichier de référence des antennes (dont on a donné le path), qui contient, pour chaque antenne, un array de fréquence et pour chaque fréquence la réponse complexe référence correspondante. 
         Si f contient des fréquences en dehors tâches effectuées au propre (semaine du range 6 : création complète du fichier de référence, on considère que la réponse de l'antenne va être calculée pour la fréquence référence la plus proche 
         On obtient la réponse de l'antenne, calculée pour chaque valeur de f par interpolation des données de référence. 
         On multiplie cette réponse par la valeur absolue de la réponse du filtre kernel (ant, bessel, dfb, implémenté dans mms_scm_dfb_dig_filter_resp (qui renvoie une réponse pour chaque fréquence de f) 
         On multiplie cette réponse par la réponse du filtre bessel, implémenté dans bessel_filter_resp (qui renvoie une réponse pour chaque fréquence de f) 
         On renvoie cette réponse 
     Maintenant que l'on a c, on divise s par c (on applique la correction au spectre d'entrée en somme) 
     La phase du terme de fréquence 0 de la réponse doit valoir 0 pour pouvoir appliquer la FFT, on set ce terme à la valeur absolue de sa valeur complexe 
     On a maintenant un s qui a subit la correction de l'antenne fft) et unit tests correspondants + dfb + bessel 
     On applique un filtre passe bande par mms_scm_filtspe entre f_min et f_max donnés en entrée 
     On applique une transformée documentation de fourier inverse, non encore normalisée, à s, on obtient alors ce que tout le code appelle le kernel (qui n'est pas encore le kernel final) 
     Maintenant on prend seulement la partie réelle (sachant que l'imaginaire doit être négligeable si les calculs sont corrects) 
     On shift le kernel 
     On lui applique la fenetre + début de convolution (Hanning, coscub, trapezoid, etc) 
     On normalise le kernel 
     On peut maintenant effectuer la convolution (mms_scm_fastconvol) pour la waveform d'entrée et le kernel calculé 

 Dans le code python, nous aurons une fonction deconvo_vec correspondant à mms_scm_deconvo_vec , semaine du 13 : 

     (on précentre la waveform d'entrée) 
     On crée l'array fenêtres de fréquence f en premier (-> étape 3.i) 
     On crée convolutions et unit tests correspondants, deconvo_vec contenant tout ce qui concerne le kernel non normalisé (-> étapes 2 à 6 sauf 3.i), en utilisant la fonction kernel_creation 
     On crée le complex spectrum de base spectrum équivalent à s (-> étape 2) 
     On applique la fonction corr_gain_ant à spectrum avec f comme argument (-> étape 3.ii:iv) 
         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) : 
             La fonction récupère les données du fichier de référence (->3.ii.a) 
             Elle règle le problème de valeur hors range (->3.ii.b) 
             On effectue l'interpolation pour obtenir la réponse de l'antenne (->3.ii.c) 
         On multiplie gain_array par la valeur absolue de la réponse du filter dfb, implémenté dans dfb_filter (->3.ii.d) 
         On multiplie gain_array par la réponse du filter bessel, implémenté dans bessel_filter (->3.ii.e) 
         On divise spectrum par gain_array (->3.iii) 
         On modifie le terme de fréquence 0 (->3.iv) 
     On applique une filtre passe bande à spectrum (bandpass_filter) (->5) 
     On applique la transformée de fourier inverse à spectrum (fft) (kernel_creation, shift, window, normalize) et obtient kernel (->6) 
     On vérifie que unit test correspondant. 
 Quand ce sera fait, l'étape suivante sera la partie réelle est bien négligeable et on prend uniquement la partie réelle. (->7) 
     On shift le kernel (->8)) 
     On applique la fenêtre de convolution choisie à kernel déconvolution en utilisant la fonction conv_window (->9) 
     On normalise le kernel (->10) 


 elle même.