.. _trackref: Track ===== Manipulation de l'objet Track ----------------------------- Ici sont présenté des exemples pour accéder aux différents éléments de la structure de l'objet Track .. topic:: Tout d'abord la création de l'objet Track >>> # Lecture d'u n fichier GDR >>> from pyctoh.track import read_product >>> track_obj = read_product("test_data/JA3_GPS_2PfP031_009_20161211_051419_20161211_061031.nc") >>> # Accès à la base de données >>> from pyctoh.db.catalogue import Catalogue >>> cat=Catalogue(filepath="/ctoh/data/db/catalogue_yml/ctoh_products_base.yml") >>> track_obj = cat.query_product("ja3_a_cnes_f_sgdr",tracks=[9],cycles=[31]) .. topic:: Numéro de trace et de cycle de l'objet Track >>> # Numéro de trace de track_obj >>> track_obj.gettracknum() 9 >>> # Numéro de cycle >>> track_obj.getcyclenum() 31 Dimensions ^^^^^^^^^^ Les dimensions de l'objet Track sont contenues dans le dictionnaire ``Track.dimension``. >>> # Les dimensions de l'objet Track >>> track_obj.dimensions {'samples': {'name': 'samples', 'size': 104, 'unlimited': False}, 'data_01/time': {'name': 'time', 'size': 33, 'unlimited': False}, 'data_20/time': {'name': 'time', 'size': 254, 'unlimited': False}} >>> # Taille de la dimension 'data_01/time' >>> track_obj.dimensions['data_01/time']['size'] 33 Variables ^^^^^^^^^ Les variables de l'objet Track: >>> # La liste des variables de l'objet Track >>> track_obj.getparams() ['samples', 'data_01/alt_state_band_seq_flag', 'data_01/alt_state_oper_flag', 'data_01/altitude', ..., 'data_20/c/sig0_ocean_compression_qual', 'data_20/c/sig0_ocog', 'data_20/c/sig0_scaling_factor', 'data_20/c/sigmac_ocean', 'data_20/c/swh_ocean', 'data_20/c/swh_ocean_compression_qual', 'data_20/c/tracker_range_calibrated'] Toutes les données des variables de l'objet Track sont rassemblées dans un dictionnaire ``Track.variables``. Par défaut, les variables de `temps` conformes à la convention-CF sont converties automatiquement en objet ``datetime``. >>> # Variable 'data_01/time' >>> track_obj.variables['data_01/time'] array(['2016-12-11T05:57:49.348', '2016-12-11T05:57:50.003', '2016-12-11T05:57:50.500', '2016-12-11T05:57:51.147', '2016-12-11T05:57:51.838', '2016-12-11T05:57:52.378', '2016-12-11T05:57:52.918', '2016-12-11T05:57:53.165', '2016-12-11T05:57:54.184', '2016-12-11T05:57:54.686', '2016-12-11T05:57:55.167', '2016-12-11T05:57:55.700', '2016-12-11T05:57:56.234', '2016-12-11T05:57:57.067', '2016-12-11T05:57:58.086', '2016-12-11T05:57:58.682', '2016-12-11T05:57:59.701', '2016-12-11T05:58:00.705', '2016-12-11T05:58:01.253', '2016-12-11T05:58:02.157', '2016-12-11T05:58:02.707', '2016-12-11T05:58:03.307', '2016-12-11T05:58:03.857', '2016-12-11T05:58:04.434', '2016-12-11T05:58:04.987', '2016-12-11T05:58:05.541', '2016-12-11T05:58:06.096', '2016-12-11T05:58:06.732', '2016-12-11T05:58:07.750', '2016-12-11T05:58:08.769', '2016-12-11T05:58:09.788', '2016-12-11T05:58:10.806', '2016-12-11T05:58:11.825'], dtype='datetime64[ms]') .. admonition:: Option `decode_times` Si à la création de l'objet Track, l'option `decode_times` est forcé à `False`, les variables de `temps` ne sont pas converties et restent dans leur type d'origine (float). Ici un autre exemple avec un paramètre de `Backscater` : ``data_20/ku/sig0_ocean_mle3``. >>> # Variable 'data_20/ku/sig0_ocean_mle3' >>> track_obj.variables['data_20/ku/sig0_ocean_mle3'] array([ nan, nan, nan, nan, nan, nan, nan, nan, nan, -9.54, -10.47, -11.28, -11.11, -12.07, nan, nan, ... nan, nan, nan, 3.47, 1.09, 0.61, 0.41, nan, nan, nan, 12.38, 7.33, 5.42, nan, 4.03, 3.82, 15.61, nan, 16.69, 16.61, 16.81, 16.9 , 17.22, 16.9 , 17.23, 17.44, 17.39, 17.12, 17.19, 17.36], dtype=float16) .. admonition:: Option `memory_optimization` Afin d'optimiser la taille de l'objet en mémoire, PyCTOH adapte le type de la variable (ici en float 16 bits). A la création de l'objet Track, cette option est ``True`` par défaut. Le choix du type de la variable est réalisé en fonction des attributs de celle-ci. .. admonition:: Option `no_maskedarray` Pour éviter qu'une variable de type `float` soit définie comme un objet ``numpy.ma.MaskedArray``. A la création de l'objet Track, cette option est ``True`` par défaut. Attributs des variables ^^^^^^^^^^^^^^^^^^^^^^^ Les attributs netCDF des variables sont récupérés dans un dictionnaire python ``Track.vars_attrs``. >>> # Attributs de la variable 'data_20/ku/sig0_ocean_mle3' >>> track_obj.vars_attrs['data_20/ku/sig0_ocean_mle3'] {'_FillValue': 32767, 'long_name': '20 Hz Ku band corrected backscatter coefficient (MLE3 retracking)', 'standard_name': 'surface_backwards_scattering_coefficient_of_radar_wave', 'units': 'dB', 'scale_factor': 0.01, 'coordinates': '/data_20/longitude /data_20/latitude', 'comment': 'Named sig0_20hz_ku_mle3 in GDR-D standard. All instrumental corrections included, excepted the system bias, i.e. AGC instrumental errors correction, internal calibration correction (/data_01/ku/sig0_cor_calibration), modeled instrumental errors correction (/data_01/ku/sig0_cor_ocean_mle3_model_instr) and atmospheric attenuation (sig0_cor_atm)', 'dimensions': ('time',), 'dtype': dtype('int16'), 'shape': (254,)} >>> >>> # Attributs de la variable ''data_01/time' >>> track_obj.vars_attrs['data_01/time'] {'long_name': 'time in UTC', 'standard_name': 'time', 'calendar': 'gregorian', 'units': 'seconds since 2000-01-01 00:00:00.0', 'comment': 'Time of measurement in seconds in the UTC time scale since 1 Jan 2000 00:00:00 UTC. [tai_utc_difference] is the difference between TAI and UTC reference time (seconds) for the first measurement of the data set. If a leap second occurs within the data set, the attribute [leap_second] is set to the UTC time at which the leap second occurs', 'tai_utc_difference': 36.0, 'leap_second': '0000-00-00 00:00:00', 'dimensions': ('time',), 'dtype': dtype('float64'), 'shape': (33,)} Métadonnées ^^^^^^^^^^^ Les métadonnées de l'objet Track sont contenues dans le dictionnaire python Track.glob_attrs >>> track_obj.global_attrs {'Conventions': 'CF-1.7', 'title': 'GDR - Expertise dataset', 'source': 'Processing Baseline F v1.01', 'contact': 'CNES aviso@altimetry.fr, EUMETSAT ops@eumetsat.int, NOAA NODC.services@noaa.gov', 'reference_document': 'Jason-3 Products Handbook, SALP-MU-M-OP-16118-CN', 'mission_name': 'Jason-3', 'altimeter_sensor_name': 'Poseidon-3B', 'radiometer_sensor_name': 'AMR', 'doris_sensor_name': 'DGXX-S', 'gpsr_sensor_name': 'GPSP', 'institution': 'CNES', 'references': 'L1 library=V5.5p1, L2 library=V6.7, Processing Pilot=V5-8p1p2', 'processing_center': 'SALP', 'acq_station_name': 'CNES', 'cycle_number': 31, 'absolute_rev_number': 4198, 'pass_number': 9, 'absolute_pass_number': 7629, 'equator_time': '2016-12-11 05:42:25.903000', 'equator_longitude': 346.54, 'first_meas_time': '2016-12-11 05:14:19.135713', 'last_meas_time': '2016-12-11 06:10:31.211729', 'xref_altimeter_characterisation': 'PJ3_CH1_AXVCNE20200113_130000_20160627_000000_20301231_235959', 'xref_altimeter_ltm': 'PJ3_FI1_AXXCNE20210128_160644_20160201_120000_20200929_202822, PJ3_IQ1_AXXCNE20210128_160645_20160201_180034_20200929_202702', 'xref_radiometer_temp': 'AJ3_ANT_AXXJPL20201124_000001_20140925_114600_20301231_235959', 'xref_doris_uso': 'JA3_OS1_AXXCNE20201122_082600_20160119_113455_20201122_034628', 'xref_orbit_data': 'JA3_VOR_AXVCNE20181113_221300_20161210_215524_20161212_002324', 'xref_pf_data': 'JA3_VPF_AXVCNE20170112_163600_20161210_215524_20161212_002324', 'xref_pole_location': 'SMM_POL_AXXCNE20201216_071500_19870101_000000_20211215_000000', 'xref_orf_data': 'JA3_ORF_AXXCNE20201119_090600_20160212_011109_20201204_081430', 'xref_meteorological_files': 'SMM_APA_AXVCNE20161211_051657_20161211_000000_20161211_000000, SMM_APA_AXVCNE20161211_151740_20161211_060000_20161211_060000, SMM_APA_AXVCNE20161211_171053_20161211_120000_20161211_120000, SMM_PMA_AXVCNE20161211_051657_20161211_000000_20161211_000000, SMM_PMA_AXVCNE20161211_151740_20161211_060000_20161211_060000, SMM_PMA_AXVCNE20161211_171053_20161211_120000_20161211_120000, SMM_PRA_AXVCNE20161211_051657_20161211_000000_20161211_000000, SMM_PRA_AXVCNE20161211_151740_20161211_060000_20161211_060000, SMM_PRA_AXVCNE20161211_171053_20161211_120000_20161211_120000, SMM_UWA_AXVCNE20161211_051657_20161211_000000_20161211_000000, SMM_UWA_AXVCNE20161211_151740_20161211_060000_20161211_060000, SMM_UWA_AXVCNE20161211_171053_20161211_120000_20161211_120000, SMM_VWA_AXVCNE20161211_051657_20161211_000000_20161211_000000, SMM_VWA_AXVCNE20161211_151740_20161211_060000_20161211_060000, SMM_VWA_AXVCNE20161211_171053_20161211_120000_20161211_120000, SMM_WEA_AXVCNE20161211_051657_20161211_000000_20161211_000000, SMM_WEA_AXVCNE20161211_151740_20161211_060000_20161211_060000, SMM_WEA_AXVCNE20161211_171053_20161211_120000_20161211_120000, SMM_ALT_AXVCNE20110430_180000_20110504_100000_20301231_235959, SMM_ALT_AXVCNE20110430_180000_20110504_100000_20301231_235959, SMM_ALT_AXVCNE20110430_180000_20110504_100000_20301231_235959, SMM_PSA_AXVCNE20161212_100009_20161211_000000_20161211_000000, SMM_PSA_AXVCNE20161212_100009_20161211_060000_20161211_060000, SMM_PSA_AXVCNE20161212_100009_20161211_120000_20161211_120000, SMM_ORA_AXVCNE20161212_110005_20161211_000000_20161211_000000, SMM_ORA_AXVCNE20161212_110005_20161211_060000_20161211_060000, SMM_ORA_AXVCNE20161212_110005_20161211_120000_20161211_120000, SMM_T3A_AXVCNE20161212_120213_20161211_000000_20161211_000000, SMM_T3A_AXVCNE20161212_120213_20161211_060000_20161211_060000, SMM_T3A_AXVCNE20161212_120213_20161211_120000_20161211_120000, SMM_Q3A_AXVCNE20161212_140147_20161211_000000_20161211_000000, SMM_Q3A_AXVCNE20161212_140147_20161211_060000_20161211_060000, SMM_Q3A_AXVCNE20161212_140147_20161211_120000_20161211_120000, SMM_L3A_AXVCNE20161212_130054_20161211_000000_20161211_000000, SMM_L3A_AXVCNE20161212_130054_20161211_060000_20161211_060000, SMM_L3A_AXVCNE20161212_130054_20161211_120000_20161211_120000', 'xref_sst_data': 'SMM_SST_AXVCNE20200529_155937_20161211_000000_20161211_235959.nc', 'xref_wave_model_data': 'SMM_WMA_AXVCNE20180704_070542_20161211_030000_20161212_000000.grb', 'xref_utc_tai_data': 'SMM_TUC_AXVCNE20161214_152427_19900101_000000_20380118_000000', 'xref_radiometer_calibration': 'AJ3_AL1_AXVJPL20200210_000000_20070809_053513_20990809_053513', 'xref_gim_data': 'JA3_ION_AXPCNE20161212_074441_20161211_000000_20161211_235959', 'xref_mog2d_data': 'SMM_MOG_AXVCNE20161231_071501_20161211_000000_20161211_000000, SMM_MOG_AXVCNE20161231_201501_20161211_060000_20161211_060000, SMM_MOG_AXVCNE20161231_201501_20161211_120000_20161211_120000', 'xref_polar_ice_data': 'SMM_ICN_AXVCNE20200202_000000_20161211_000000_20161211_235959.nc, SMM_ICS_AXVCNE20200202_000000_20161211_000000_20161211_235959.nc', 'ellipsoid_axis': 6378137.0, 'ellipsoid_flattening': 0.00335281066474748, 'comment': '', 'history': ' Fri Jan 21 09:45:09 2022 : [CTOH product ja3_a_cnes_f_sgdr] ExtractionFile JA3_GPS_2PfP031_009_20161211_051419_20161211_061031.nc; 2021-03-25 07:23:07 : Creation', 'pyctoh_version': 'g163aae1'} Création d'une nouvelle variable -------------------------------- Variables ^^^^^^^^^ On peut ajouter à un objet Track des variables supplémentaires Une variable est définie par son nom et ses dimensions. Dans le cas de la création d'une variable dans un groupe, le nom de variable est composé du nom du groupe (et sous groupe) et du nom de la variable séparés par un '/'. Par exemple, la création de la variable 'var_test' dans le groupe 'data_20' : 'data_20/var_test'. Cette variable a une dimension 'time' qui existe déjà dans le groupe 'data_20' : 'data_20/time'. >>> # Création de la variable 'data_20/var_test' de dimension ['data_20/time'] >>> track_obj.createVariable('data_20/var_test',['data_20/time'],) >>> # Attributs de la variable 'var_test' >>> track_obj.vars_attrs['var_test'] {'dimensions': ['time'], 'shape': (254,), 'dtype': None} .. _default_attrs_ref: .. Note:: A la création de la variable 'var_test' trois attributs sont créés par défault: - 'dimensions' : liste des noms des dimensions de la variable - 'shape' : liste des tailles de chaque dimension - 'dtype' : `option dtype `__ .. _dtype_option_ref: .. admonition:: Option `dtype` A la création de la variable, une option `dtype` peut être définie. Cette option permet d'affecter la type de la variable lors de la sauvegade de l'objet Track en netCDF. Seul les types `netCDF4 (data types) `__ sont acceptés. Par défaut (``dtype = None``), le type de la variable est ``numpy.dtype('float64')``. .. Important:: La création d'une variable doit être cohérente avec ses dimmenssions. Les dimmesions d'une variable doivent appartenir au même groupe de la variable ou bien à ces groupes parents. C'est à dire que la dimension 'time' doit être définie dans le même groupe que la variable `var_test` : data_20 ('data_20/var_test'), ou bien dans les groupes parent de la variable 'var_test' (dans le groupe racine dans cette exemple). Attributs ^^^^^^^^^ A la création d'une variable des `attributs par défaut sont créés `__. A chaque variable, tous types d'attributs peuvent être définit. Il convient tout de même de définir à minima les attributs suivant: - 'long_name' : Nom de la variables - 'units' : Unité de la variable - 'comment' : Informations complémentaires >>> # Création d'attributs complémentaires pour la variables 'data_20/var_test' >>> track_obj.setncattr('data_20/var_test','long_name','Variable de test') >>> track_obj.setncattr('data_20/var_test','comment',"C'est un exemple") >>> track_obj.setncattr('data_20/var_test','units','m') >>> track_obj.vars_attrs['data_20/var_test'] {'dimensions': ['time'], 'shape': (254,), 'dtype': None, 'long_name': 'Variable de test', 'comment': "C'est un exemple", 'units': 'm'} .. admonition:: Convention-CF **Dans le cas de variables de temps et de coordonnées, il faut respecter la** `convention-CF `__ **afin de définir les attibuts qui conviennent.** Ici un exemple d'attributs d'une variable time. >>> track_obj.vars_attrs['data_20/time'] {'long_name': 'time 20 Hz in UTC', 'standard_name': 'time', 'calendar': 'gregorian', 'units': 'seconds since 2000-01-01 00:00:00.0', 'comment': 'Named time_20hz in GDR-D standard. Time of measurement in seconds in the UTC time scale since 1 Jan 2000 00:00:00 UTC. [tai_utc_difference] is the difference between TAI and UTC reference time (seconds) for the first measurement of the data set. If a leap second occurs within the data set, the attribute [leap_second] is set to the UTC time at which the leap second occurs', 'tai_utc_difference': 36.0, 'leap_second': '0000-00-00 00:00:00', 'dimensions': ('time',), 'dtype': dtype('float64'), 'shape': (254,)} Ici un exemple d'attributs d'une variable de coordonnées. >>> track_obj.vars_attrs['data_20/longitude'] {'_FillValue': 2147483647, 'long_name': '20 Hz longitude', 'standard_name': 'longitude', 'units': 'degrees_east', 'scale_factor': 1e-06, 'comment': 'Named lon_20hz in GDR-D standard. East longitude relative to Greenwich meridian. See Jason-3 User Handbook', 'dimensions': ('time',), 'dtype': dtype('int32'), 'shape': (254,)} Affectation de données ^^^^^^^^^^^^^^^^^^^^^^ >>> import numpy as np # Import de la bibliothèque numpy >>> var_test = np.random.random(track_obj.dimensions['data_20/time']['size']) >>> # Affectation des valeurs à 'data_20/var_test' de l'objet Track >>> track_obj.setvalue('data_20/var_test',var_test) >>> track_obj.variables['data_20/var_test'] array([7.61010775e-01, 4.00295659e-02, 4.09593984e-01, 3.17923342e-01, 1.47558703e-01, 7.19009698e-01, 1.39792443e-01, 1.35628131e-02, 1.09843587e-01, 6.74618972e-02, 5.71073686e-01, 6.86511987e-01, 8.10696713e-01, 3.80848636e-01, 5.25682646e-01, 5.95192246e-01, 5.38506737e-01, 8.98534590e-01, 8.74800202e-01, 3.84999613e-01, ... 6.72264305e-01, 5.89121795e-01, 1.40743438e-01, 7.39217655e-01, 3.95280540e-01, 2.27549449e-01, 5.14465825e-01, 2.24662039e-01, 2.21476425e-01, 5.70114602e-01, 8.29729672e-01, 2.91512863e-01, 8.63855686e-01, 1.38363305e-01, 1.45144347e-01, 9.05141523e-05, 3.03900777e-01, 7.15562801e-02, 3.73556413e-01, 9.53210135e-01]) .. _track_validation_ref: Validation ^^^^^^^^^^ A chaque modification de l'objet Track (création d'une variable, suppression, etc), la cohérence de l'objet doit être vérifiée. Un processus de validation permet de contrôler : - l'adéquation des dimensions (noms et tailles) de l'objet Track avec ses variables, - le respect de la convention-CF pour les variables de temps et de coordonnées - que les variables de temps soit bien des objets ``datetime`` si l'option ``decode_times`` est ``True`` Le processus de validation: >>> # Validation de l'objet Track >>> track_obj.validate() >>> track_obj.certified_dataset True .. Important:: A l'issu de la validation, une variable de l'objet Track de type booléen ``Track.certified_dataset`` est affecté à ``True`` ou à ``False``. - Dans le cas d'une validation infructueuse, le détail des problèmes rencontrés est affiché. L'attribut ``certified_dataset`` de l'objet Track reste à ``False`` >>> track_obj.validate() data_20/var_test : Dimensions size not conform to the variable attribute! var = (10,) / attribute = (33,) dims data_20/var_test : time_01 dimension not found! >>> track_obj.certified_dataset False Suppression d'une variable et selection de variables ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >>> # suppression d'une variable : "data_01/longitude" >>> track_obj.rm_vars("data_01/longitude") >>> # selection de variables, les autres sont supprimées de l'objet Track. >>> track_obj.varssel([varname_0,varname_1,varname_2,varname_3,...,varname_n,]) Fusion de deux objets Track --------------------------- La fusion consiste à recopier toutes les variables de deux objets Track dans un seul objet Track. .. py:function:: Track.merge_vars(track_obj, overwrite_vars=False) :track_obj: Objet Track à fusionner avec cet objet Track :overwrite_vars: S'il y a des variables doublons entre les deux objets Track, ces variables peuvent être remplacer par celles de track_obj. Non autorisé par défaut (overwrite_vars=False). Cela est possible sous certaines conditions: - Les deux objets Track sont de la même sous class (Voir product_kind) - Les dimensions des deux objets Track doivent être identique - Les vecteurs times doivent être identiques (valeurs, noms, dimensions, tailles) >>> # Fussion de track_obj_2 dans track_obj_1 >>> track_obj_1.merge_vars(track_obj_2) Selection temporelle des données de l'objet Track ------------------------------------------------- Création d'un mask de selection d'une période temporelle. .. py:function:: temporal_mask=Track.time_range(time_interval) :time_interval: liste de deux dates définissant un intervale de temps : date de début et date de fin. Les dates sont des chaines de caractaires au format date ISO 8601 : 'YYYY-MM-DDTHH:MM:SS.ffffff'. La selection temporelle des données est réalisé en deux temps: - La création d'un masque de selection avec le choix d'un interval temporelle >>> time_interval = ['2004-10-05T04:54:43.740','2004-10-06T14:32:33.83'] >>> temporal_mask = track_obj.time_range(time_interval) La méthode `Track.time_range` renvoie un dictionnaire de masques pour chaque **coordonnées** dédinit dans la sous classe Track définissant le type de produit. Dans ce dictionnaire, on trouve communément les coordonnées suivantes avec leur masque associer: - `time_lf` : masque du vecteur temps 1hz - `time_hf` : masque du vecteur temps haute fréquence En fonction de la compléxité du produit on peut trouver également d'autres cooordonnées telles que : `time_hf_plrm` pour le produit cryosta2 GOP Baseline C ou encore `time_hf_c` pour les produits sentinel3. .. important:: Chaque produit ont plusieurs système de coordonnées. Le plus couramment, un en base fréquence (1hz) et un autre en plus haute fréquence (10hz, 18hz, 20hz, ou 40hz). Ils peuvent aussi être plus spécifique à une bande (ku, ka, s ou c) et à un mode instrumental (lrm, plrm ou sar). Les coordonnées sont défini pour chaque type de produit dans des sous classes de la classe Track. Elles servent à identifier de manière exhaustive les différents systèmes de coordonnées (lon, lat et time) existant dans le produit GDR afin d'appliquer les mêmes traitements de filtrage à chacun d'eux... (Faire une section dédiée). >>> temporal_mask {'time_lf': array([False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]), 'time_hf': array([[False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False], [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False], [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False], ... } - L'application des masques à l'objet Track Le masque obtenu précédemment peut être appliqué tel quel à l'object Track. Dans ce cas toutes les variables de l'objet seront filtrées. >>> track_obj.apply_mask(temporal_mask) .. important:: Track.apply_mask La méthode `Track.apply_mask` applique non seulement le masque de selection à toutes les variables mais également elle met à jour l'attribut "shape" des variables et les dimensions de l'objet Track. Le masque peut aussi être que partiellement appliqué. Par exemple, en choisissant un seul système de coordonnées (`time_hf`). Dans ce cas, il suffit de supprimer du masque le ou les systèmes de coordonnées non souhaitées avant d'appliquer le masque à l'objet Track. >>> del temporal_mask['time_lf'] # Suppression du système de coordonnées base fréquence >>> temporal_mask.key() ['time_hf'] >>> track_obj.apply_mask(temporal_mask) Seul les variables ayant des dimensions appartenant au système de coordonnées 'time_hf' seront filtrées. Selection spatiale des données de l'objet Track ----------------------------------------------- Création d'un mask de selection spatial. .. py:function:: area_mask=Track.area(llc_lon,llc_lat,urc_lon,urc_lat) Le rectangle de selection est défini par les coordonnées de deux de ces sommets : inférieur gauche et supérieur droit dans une représentation cartésienne. :llc_lon, llc_lat: Ces deux arguments sont respectivement les coordonnées géographiques de longitude et de latitude du sommet du rectangle inférieur gauche (lower left corner). :urc_lon, urc_lat: Ces deux arguments sont respectivement les coordonnées géographiques de longitude et de latitude du sommet du rectangle supérieur droit (upper right corner). L'étendu du rectangle de selection ne peut exceder 360. degrés en longitude et 180.0 degrés en latitude. .. _Shapely: https://shapely.readthedocs.io/en/stable/manual.html La selection spatiale des données est réalisé en deux temps: - La création d'un masque de selection >>> # Création d'un polygone de selection >>> from shapely.geometry import Polygon >>> polygon_obj = Polygon([(),]) >>> # création du masque de selection >>> area_mask = track_obj.area(polygon_obj) La méthode `Track.time_range` renvoie un dictionnaire de masques pour chaque **coordonnées** dédinit dans la sous classe Track définissant le type de produit. Dans ce dictionnaire, on trouve communément les coordonnées suivantes avec leur masque associer: - `time_lf` : masque des coordonnées 1hz - `time_hf` : masque des coordonnées haute fréquence En fonction de la compléxité du produit on peut trouver également d'autres cooordonnées telles que : `time_hf_plrm` pour le produit cryosta2 GOP Baseline C ou encore `time_hf_c` pour les produits sentinel3. >>> area_mask {'time_lf': array([False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]), 'time_hf': array([[False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False], [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False], [False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False], ... } - L'application des masques à l'objet Track >>> track_obj.apply_mask(area_mask) Sauvegarde d'un objet Track --------------------------- La sauvegarde d'un objet Track est faite dans un fichier netCDF (netCDF4). >>> # Sauvegarde de l'objet Track : track_obj >>> # Nom du fichier de sauvegarde >>> filename = "Ja3_t9_c31.nc" >>> track_obj.to_netcdf(filename) .. Important:: La sauvegarde d'un objet Track n'est possible que s'il est valide. Pour cela `l'objet Track doit être validé `__. Visualisation ------------- >>> track_obj.plot('data_20/ku/sig0_ocog',abs_x='time',filename='sig0.png') >>> track_obj.map_plot('data_20/ku/sig0_ocog',filename='sig0.png') Grid2track ---------- .. py:function:: result=Track.grid2track(ext_data, method='linear') Interpolation de l'objetTrack avec un raster. :ext_data: Données raster externe (donnée grillée) : C'est un dictionnaire générer par l'Objet :ref:`External_Data `. :method: Méthode d'interpolation à effectuer. Les méthodes prises en charge sont "linear", "nearest", "slinear", "cubic", "quintic", "pchip" et "splinef2d". .. code-block:: python from pyctoh.db.catalogue import Catalogue from pyctoh.db.stac.stac_access import External_Data cat_ext = External_Data() Number of items found: 4 > ['dist2coast_gshhg_v2.3.7_1m', 'gebco_2014', 'mdt_cnes_cls22_global', 'mss_cnes_cls2015'] ext_data_prod = 'mdt_cnes_cls22_global' ext_data = cat_ext.gridload(ext_data_prod) cycle = 1; track_num = 1 cat = Catalogue("/ctoh/data/db/catalogue_yml/ctoh_products_base.yml") tr = cat.query_product("ja2_a_cnes_d_gdr", cycles=[cycle], tracks=[track_num], decode_times=False, coord_var_only=True) Get file list... > Sorting tracks for each mission cycle ... Get parameter list... Multiprocess mode data loading > Starting loading > Ending loading tr[1][1].grid2track(ext_data) {'time_lf': array([-1.32995283e+00, -1.33134201e+00, -1.33276769e+00, ..., -2.14748365e+09, -2.14748365e+09, -2.14748365e+09]), 'time_hf': array([-1.32932788, -1.32939347, -1.32945931, ..., nan, nan, nan])}