PyMVP 0.2.3__tar.gz → 0.2.5__tar.gz

{pymvp-0.2.3 → pymvp-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMVP
-Version: 0.2.3
+Version: 0.2.5
 Summary: Python package for Moving Vessel Profiler correction and analysis
 Author: MaximilienWemaere
 Requires-Python: >=3.10

{pymvp-0.2.3 → pymvp-0.2.5}/PyMVP/main.py

@@ -114,8 +114,8 @@ class Analyzer:
                 self.PH_mvp = nc['PH'].values
                 self.SALT_mvp = nc['SAL'].values
                 self.TIME_mvp = nc['TIME_s'].values
-                self.LAT_mvp = nc['LATITUDE'].values
-                self.LON_mvp = nc['LONGITUDE'].values
+                self.Lat_mvp = nc['LATITUDE'].values
+                self.Lon_mvp = nc['LONGITUDE'].values
                 self.DATETIME_mvp = nc['profile_time'].values
                 self.DIR = nc['direction'].values
                 self.label_mvp = nc['profile'].values
@@ -293,8 +293,8 @@ class Analyzer:
         self.PH_mvp = PH_mvp
         self.SALT_mvp = SALT_mvp
         self.TIME_mvp = TIME_mvp
-        self.LAT_mvp = LAT_mvp
-        self.LON_mvp = LON_mvp
+        self.Lat_mvp = LAT_mvp
+        self.Lon_mvp = LON_mvp
         self.DATETIME_mvp = DATETIME_mvp
         self.DIR = DIR
         self.label_mvp = Label_mvp
@@ -341,8 +341,8 @@ class Analyzer:
                 self.PH_mvp = nc['PH'].values
                 self.SALT_mvp = nc['SAL'].values
                 self.TIME_mvp = nc['TIME'].values
-                self.LAT_mvp = nc['LATITUDE'].values
-                self.LON_mvp = nc['LONGITUDE'].values
+                self.Lat_mvp = nc['LATITUDE'].values
+                self.Lon_mvp = nc['LONGITUDE'].values
                 self.DATETIME_mvp = nc['profile_time'].values
                 self.DIR = nc['direction'].values
                 self.Label_mvp = nc['profile'].values
@@ -481,8 +481,8 @@ class Analyzer:
             self.PH_mvp = np.hstack((self.PH_mvp, nan_cols))
             self.SALT_mvp = np.hstack((self.SALT_mvp, nan_cols))
             self.TIME_mvp = np.hstack((self.TIME_mvp, nan_cols))
-            self.LAT_mvp = np.hstack((self.LAT_mvp, nan_cols))
-            self.LON_mvp = np.hstack((self.LON_mvp, nan_cols))
+            self.Lat_mvp = np.hstack((self.Lat_mvp, nan_cols))
+            self.Lon_mvp = np.hstack((self.Lon_mvp, nan_cols))
 
 
 
@@ -547,8 +547,8 @@ class Analyzer:
         self.PH_mvp = np.concatenate((self.PH_mvp, PH_mvp), axis=0)
         self.SALT_mvp = np.concatenate((self.SALT_mvp, SALT_mvp), axis=0)
         self.TIME_mvp = np.concatenate((self.TIME_mvp, TIME_mvp), axis=0)
-        self.LAT_mvp = np.concatenate((self.LAT_mvp, LAT_mvp), axis=0)
-        self.LON_mvp = np.concatenate((self.LON_mvp, LON_mvp), axis=0)
+        self.Lat_mvp = np.concatenate((self.Lat_mvp, LAT_mvp), axis=0)
+        self.Lon_mvp = np.concatenate((self.Lon_mvp, LON_mvp), axis=0)
 
         self.DATETIME_mvp.extend(DATETIME_mvp)
         self.DIR.extend(DIR)
@@ -585,7 +585,7 @@ class Analyzer:
         TEMP_ctd_temp = []
         COND_ctd_temp = []
         TURB_ctd_temp = []
-        OXY_ctd_temp = []
+        DO_ctd_temp = []
         FLUO_ctd_temp = []
         CDOM_ctd_temp = []
         DATETIME_ctd = []
@@ -603,8 +603,8 @@ class Analyzer:
             SALT_ctd_temp.append(nc['SAL'].values[1])
             TURB_ctd_temp.append(nc['TURB'].values[0])
             TURB_ctd_temp.append(nc['TURB'].values[1])
-            OXY_ctd_temp.append(nc['OXY'].values[0])
-            OXY_ctd_temp.append(nc['OXY'].values[1])
+            DO_ctd_temp.append(nc['OXY'].values[0])
+            DO_ctd_temp.append(nc['OXY'].values[1])
             FLUO_ctd_temp.append(nc['FLUO'].values[0])
             FLUO_ctd_temp.append(nc['FLUO'].values[1])
             CDOM_ctd_temp.append(nc['CDOM'].values[0])
@@ -622,12 +622,13 @@ class Analyzer:
         self.COND_ctd = np.array(COND_ctd_temp)
         self.SALT_ctd = np.array(SALT_ctd_temp)
         self.TURB_ctd = np.array(TURB_ctd_temp)
-        self.OXY_ctd = np.array(OXY_ctd_temp)
+        self.DO_ctd = np.array(DO_ctd_temp)
         self.FLUO_ctd = np.array(FLUO_ctd_temp)
         self.CDOM_ctd = np.array(CDOM_ctd_temp)
         self.LAT_ctd = np.array(LAT_ctd_temp)
         self.LON_ctd = np.array(LON_ctd_temp)
         self.DATETIME_ctd = np.array(DATETIME_ctd)
+        self.TIME_ctd = np.array([(np.datetime64(dt) - np.datetime64(self.date_ref)) / np.timedelta64(1, 'D') for dt in self.DATETIME_ctd])
 
 
         print('CTD data loaded successfully.')
@@ -687,7 +688,7 @@ class Analyzer:
             print('MVP data:')
             print('Number of profiles: ' + str(len(self.DATETIME_mvp)))
             for i in range(0,len(self.DATETIME_mvp)):
-                print(f"  Profil down {2*i} - Profil up {2*i+1} - Latitude: {self.LAT_mvp[2*i,0]:.5f}, Longitude: {self.LON_mvp[2*i,0]:.5f}, Date/Heure: {self.DATETIME_mvp[i]}")
+                print(f"  Profil down {2*i} - Profil up {2*i+1} - Latitude: {self.Lat_mvp[2*i,0]:.5f}, Longitude: {self.Lon_mvp[2*i,0]:.5f}, Date/Heure: {self.DATETIME_mvp[i]}")
 
         if self.ctd:
             print('CTD data:')
@@ -731,8 +732,8 @@ class Analyzer:
             self.PH_mvp = self.PH_mvp[l_id,:]
             self.SALT_mvp = self.SALT_mvp[l_id,:]
             self.TIME_mvp = self.TIME_mvp[l_id,:]
-            self.LAT_mvp = self.LAT_mvp[l_id,:]
-            self.LON_mvp = self.LON_mvp[l_id,:]
+            self.Lat_mvp = self.Lat_mvp[l_id,:]
+            self.Lon_mvp = self.Lon_mvp[l_id,:]
             self.DATETIME_mvp = np.array(self.DATETIME_mvp)[l_id2]
             self.DIR = np.array(self.DIR)[l_id]
             self.label_mvp = np.array(self.label_mvp)[l_id]
@@ -751,7 +752,7 @@ class Analyzer:
             self.SALT_ctd = self.SALT_ctd[l_id,:]
             self.COND_ctd = self.COND_ctd[l_id,:]
             self.TURB_ctd = self.TURB_ctd[l_id,:]
-            self.OXY_ctd = self.OXY_ctd[l_id,:]
+            self.DO_ctd = self.DO_ctd[l_id,:]
             self.FLUO_ctd = self.FLUO_ctd[l_id,:]
             self.CDOM_ctd = self.CDOM_ctd[l_id,:]
             self.LAT_ctd = self.LAT_ctd[l_id,:]
@@ -834,7 +835,7 @@ class Analyzer:
 
             put_label = True
             c = 0
-            for i in range(0,self.LAT_mvp.shape[0],2):
+            for i in range(0,self.Lat_mvp.shape[0],2):
                 if i>0:
                     if self.label_mvp[i] == self.label_mvp[i-1]:
                         put_label = False
@@ -842,8 +843,8 @@ class Analyzer:
                         put_label = True
                         c+=1
 
-                lat = self.LAT_mvp[i,0] if self.LAT_mvp.ndim == 2 else  self.LAT_mvp[i]
-                lon = self.LON_mvp[i,0] if self.LON_mvp.ndim == 2 else  self.LON_mvp[i]
+                lat = self.Lat_mvp[i,0] if self.Lat_mvp.ndim == 2 else  self.Lat_mvp[i]
+                lon = self.Lon_mvp[i,0] if self.Lon_mvp.ndim == 2 else  self.Lon_mvp[i]
                 ax.scatter(lon, lat, color=colors[c], marker='o', label='MVP '+self.label_mvp[i] if put_label else "", transform=ccrs.PlateCarree())
 
         # CTD
@@ -925,8 +926,8 @@ class Analyzer:
             plt.plot(self.DO_mvp[id_mvp],self.PRES_mvp[id_mvp],label='MVP down')
             plt.plot(self.DO_mvp[id_mvp+1],self.PRES_mvp[id_mvp+1],label='MVP up')
         if self.ctd:
-            plt.plot(self.OXY_ctd[id_ctd],self.PRES_ctd[id_ctd],label='CTD down')
-            plt.plot(self.OXY_ctd[id_ctd+1],self.PRES_ctd[id_ctd+1],label='CTD up')
+            plt.plot(self.DO_ctd[id_ctd],self.PRES_ctd[id_ctd],label='CTD down')
+            plt.plot(self.DO_ctd[id_ctd+1],self.PRES_ctd[id_ctd+1],label='CTD up')
         plt.legend()    
         plt.gca().invert_yaxis()
         plt.grid()
@@ -1073,7 +1074,7 @@ class Analyzer:
  
         TEMP_ctd_interp = mvp.vertical_interp(self.PRES_ctd[id_ctd1,:],self.TEMP_ctd[id_ctd1,:], pressure_grid)
         SALT_ctd_interp = mvp.vertical_interp(self.PRES_ctd[id_ctd1,:],self.SALT_ctd[id_ctd1,:], pressure_grid)
-        DO_ctd_interp = mvp.vertical_interp(self.PRES_ctd[id_ctd1,:],self.OXY_ctd[id_ctd1,:], pressure_grid)
+        DO_ctd_interp = mvp.vertical_interp(self.PRES_ctd[id_ctd1,:],self.DO_ctd[id_ctd1,:], pressure_grid)
         COND_ctd_interp = mvp.vertical_interp(self.PRES_ctd[id_ctd1,:],self.COND_ctd[id_ctd1,:], pressure_grid)
 
         # differences study between MVP down and CTD profiles
@@ -1256,7 +1257,7 @@ class Analyzer:
             print(f"  MVP down: {rmse_cond_down:.4f} S/m (deep: {rmse_cond_down_deep:.4f} S/m)")
             print(f"  MVP up:   {rmse_cond_up:.4f} S/m (deep: {rmse_cond_up_deep:.4f} S/m)")
 
-    def correct_oxygen(self,id_mvp=None,id_ctd=None,num_sample=500,plotting=False,):
+    def correct_oxygen(self,id_mvp=None,id_ctd=None,plotting=False,):
         """
         Apply oxygen correction to MVP dissolved oxygen profiles thanks to CTD data.
         Args:
@@ -1278,63 +1279,64 @@ class Analyzer:
             id_ctd = id_mvp
         
 
-        # Interpolate MVP and CTD data to match pressure levels
-        pmin = np.nanmin(self.PRES_mvp)
-        pmax = np.nanmax(self.PRES_mvp)
-        pressure_grid = np.linspace(pmin, pmax, num_sample)
-
+        if hasattr(self,'DO_mvp_corr_interp') == False:
+            raise ValueError("Please run the interpolation method first to create the DO_mvp_corr_interp attribute.")
+        
 
-        DO_mvp_interp = mvp.vertical_interp(self.PRES_mvp[id_mvp,:], self.DO_mvp[id_mvp,:], pressure_grid)
-        DO_ctd_interp = mvp.vertical_interp(self.PRES_ctd[id_ctd,:],self.OXY_ctd[id_ctd,:], pressure_grid)
+        oxy_mvp = self.DO_mvp_corr_interp[id_mvp]
+        oxy_ctd = self.DO_ctd_interp[id_ctd]
+        pres = self.PRES_mvp_corr_interp[id_mvp]
 
-        mask = ~np.isnan(DO_mvp_interp) & ~np.isnan(DO_ctd_interp)
-        pressure_grid = pressure_grid[mask[0]]
-        DO_mvp_interp = DO_mvp_interp[mask]
-        DO_ctd_interp = DO_ctd_interp[mask]
+        mask = ~np.isnan(oxy_mvp) & ~np.isnan(oxy_ctd)
+        oxy_mvp = oxy_mvp[mask]
+        oxy_ctd = oxy_ctd[mask]
+        pres = pres[mask]
 
-        diff = DO_mvp_interp-DO_ctd_interp
+        diff = oxy_mvp - oxy_ctd
 
-        A = np.vstack([pressure_grid, np.ones_like(pressure_grid)]).T
-        print(A.shape, diff.shape)
+        A = np.vstack([oxy_ctd, np.ones(len(oxy_ctd))]).T
         diff = diff.flatten()
-        a_estime, b_estime = np.linalg.lstsq(A, diff, rcond=None)[0]
-
-        print(f"Pente estimée (a) : {a_estime:.6f} ")
-        print(f"Biais estimé (b) : {b_estime:.6f} ")
-
-        DO_mvp_corr = DO_mvp_interp - (a_estime*pressure_grid + b_estime)
-
-
 
-        rmse_before = np.sqrt(np.nanmean((DO_mvp_interp - DO_ctd_interp)**2))
-        rmse_after = np.sqrt(np.nanmean((DO_mvp_corr - DO_ctd_interp)**2))
-        print(f"RMSE before correction: {rmse_before:.4f}")
-        print(f"RMSE after correction: {rmse_after:.4f}")
+        a_estim, b_estim = np.linalg.lstsq(A, diff, rcond=None)[0]
+        print(f"Estimated linear relationship: diff = {a_estim:.4f} * oxy_ctd + {b_estim:.4f}")
 
-        DO_mvp_corr_full = self.DO_mvp - (a_estime*self.PRES_mvp + b_estime)
+        Do_mvp_corr = self.DO_mvp_corr_interp[id_mvp] - (a_estim * self.DO_ctd_interp[id_ctd] + b_estim)
 
-        DO_mvp_corr_full_interp = mvp.vertical_interp(self.PRES_mvp, DO_mvp_corr_full, pressure_grid)
-        rmse_after_full = np.mean(np.sqrt(np.nanmean((DO_mvp_corr_full_interp - DO_ctd_interp)**2,axis=1)))
-        print(f"RMSE after correction (full profile): {rmse_after_full:.4f}")
 
-        self.DO_mvp_raw = self.DO_mvp.copy()
-        self.DO_mvp = DO_mvp_corr_full
+        rmse_before = np.sqrt(np.nanmean((self.DO_mvp_corr_interp[id_mvp] - self.DO_ctd_interp[id_ctd])**2))
+        rmse_after = np.sqrt(np.nanmean((Do_mvp_corr - self.DO_ctd_interp[id_ctd])**2))
+        if plotting:
+            print(f"RMSE before correction: {rmse_before:.4f}")
+            print(f"RMSE after correction: {rmse_after:.4f}")
 
 
         if plotting:
 
-            plt.figure()
-            plt.plot(DO_mvp_interp,pressure_grid,label='MVP')
-            plt.plot(DO_ctd_interp,pressure_grid,label='CTD')
-            plt.plot(DO_mvp_corr,pressure_grid,label='MVP corrected')
+            plt.figure(figsize=(6,8))
+            plt.plot(oxy_mvp, pres, label='MVP DO')
+            plt.plot(Do_mvp_corr[mask],pres,label='MVP DO corrigé')
+            plt.plot(oxy_ctd, pres, label='CTD DO')
             plt.gca().invert_yaxis()
-            plt.xlabel('Dissolved Oxygen, %')
-            plt.ylabel('Pressure, dbar')
-            plt.title('Oxygen correction')
+            plt.xlabel('Oxygène dissous [µmol/kg]')
+            plt.ylabel('Profondeur [m]')
+            plt.title(f'Profil de DO - Profil {id_mvp} MVP vs Profil {id_ctd} CTD')
             plt.legend()
-            plt.grid()
             plt.show()
 
+        self.DO_mvp_corr_interp[id_mvp] = Do_mvp_corr
+
+
+    def correct_oxygen_all(self,mode):
+
+
+        
+        for id_mvp in range(0,self.PRES_mvp.shape[0]):
+
+            id_nearest_ctd = mvp.find_nearest_profile(self.TIME_mvp_corr_interp[id_mvp],self.Lat_mvp_corr_interp[id_mvp], self.Lon_mvp_corr_interp[id_mvp],self.TIME_ctd ,self.LAT_ctd, self.LON_ctd,mode)[0]
+            self.correct_oxygen(id_mvp=id_mvp, id_ctd=id_nearest_ctd, plotting=False)
+
+        print("Oxygen correction applied to all MVP profiles using nearest CTD profiles.")
+
 
     def mvp_correction(self,high_cutoff=1,dp=0.1):
 
@@ -1437,7 +1439,7 @@ class Analyzer:
         self.PRES_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.PRES_ctd, pressure_grid)
         self.COND_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.COND_ctd, pressure_grid)
         self.SALT_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.SALT_ctd, pressure_grid)
-        self.DO_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.OXY_ctd, pressure_grid)
+        self.DO_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.DO_ctd, pressure_grid)
         self.FLUO_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.FLUO_ctd, pressure_grid)
         self.TURB_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.TURB_ctd, pressure_grid)
         self.TEMP_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, TEMP_mvp_corr_mat, pressure_grid)
@@ -1500,7 +1502,6 @@ class Analyzer:
         print("Mean conductivity difference between MVP and CTD profiles:", np.mean(mean_cond_diff))
     
 
-
     def corrige_MVP_offset_on_ctd_simple(self,id_mvp,id_ctd,min_depth):
         """
         This function corrects the offset between the MVP and CTD profiles by aligning the temperature, conductivity profiles. It calculates the mean difference in temperature between the two profiles and applies this correction to the CTD temperature data.
@@ -1550,235 +1551,241 @@ class Analyzer:
         print("Mean conductivity difference between MVP and CTD profiles:", np.mean(mean_cond_diff))
     
 
+    def corrige_MVP_offset_on_ctd_all(self,min_depth,mode):
 
+        for id_mvp in range(self.PRES_mvp.shape[0]):
+            id_nearest_ctd = mvp.find_nearest_profile(self.TIME_mvp_corr_interp[id_mvp],self.Lat_mvp_corr_interp[id_mvp], self.Lon_mvp_corr_interp[id_mvp],self.TIME_ctd ,self.LAT_ctd, self.LON_ctd,mode)[0]
+            self.corrige_MVP_offset_on_ctd_simple(id_mvp=id_mvp, id_ctd=id_nearest_ctd, min_depth=min_depth)
 
-        def to_netcdf(self, filepath, corrected=False, compression=True, engine=None, per_profile_files=False):
-            """
-            Export MVP data to a NetCDF file using xarray.
+        print("MVP profiles corrected for offset against CTD profiles using nearest CTD profiles.")
 
-            Args:
-                filepath (str): Output NetCDF file path.
-                corrected (bool): Also write corrected arrays if present (*_mvp_corr). Default False.
-                compression (bool): Enable compression (engine dependent). Default True.
-                engine (str|None): One of 'netcdf4', 'h5netcdf', 'scipy'. If None, choose netcdf4.
-                per_profile_files (bool): If True, write one .nc per MVP cycle (two rows: down and up).
-            """
-            if not getattr(self, 'mvp', False):
-                raise RuntimeError("No MVP data loaded. Call load_mvp_data() first.")
+    def to_netcdf(self, filepath, corrected=False, compression=True, engine=None, per_profile_files=False):
+        """
+        Export MVP data to a NetCDF file using xarray.
 
-            engine = 'netcdf4' if engine is None else engine
-            if engine == 'scipy' and compression:
-                print('Warning: scipy backend does not support compression; writing without compression.')
-                compression = False
+        Args:
+            filepath (str): Output NetCDF file path.
+            corrected (bool): Also write corrected arrays if present (*_mvp_corr). Default False.
+            compression (bool): Enable compression (engine dependent). Default True.
+            engine (str|None): One of 'netcdf4', 'h5netcdf', 'scipy'. If None, choose netcdf4.
+            per_profile_files (bool): If True, write one .nc per MVP cycle (two rows: down and up).
+        """
+        if not getattr(self, 'mvp', False):
+            raise RuntimeError("No MVP data loaded. Call load_mvp_data() first.")
 
-            # Dimensions
-            n_prof, n_samp = self.PRES_mvp.shape
+        engine = 'netcdf4' if engine is None else engine
+        if engine == 'scipy' and compression:
+            print('Warning: scipy backend does not support compression; writing without compression.')
+            compression = False
 
-            # Coordinates
-            profile_idx = np.arange(n_prof, dtype=np.int32)
-            sample_idx = np.arange(n_samp, dtype=np.int32)
+        # Dimensions
+        n_prof, n_samp = self.PRES_mvp.shape
 
-            # Direction per profile (down/up)
-            direction = None
-            if hasattr(self, 'DIR') and len(self.DIR) == n_prof:
-                direction = np.array(self.DIR, dtype=object)
-            else:
-                # Fallback based on even/odd
-                direction = np.array(['down' if i % 2 == 0 else 'up' for i in range(n_prof)], dtype=object)
-
-            # Per-sample time as seconds since reference origin
-            # TIME_mvp is in days relative to self.date_ref
-            time_seconds = None
-            if hasattr(self, 'TIME_mvp'):
-                time_seconds = self.TIME_mvp * 24.0 * 3600.0
-            else:
-                time_seconds = np.full((n_prof, n_samp), np.nan)
-
-            # Per-profile datetime (one timestamp per cast pair); map using i//2
-            profile_time = None
-            if hasattr(self, 'DATETIME_mvp') and len(getattr(self, 'DATETIME_mvp', [])) > 0:
-                prof_times = []
-                for i in range(n_prof):
-                    j = i // 2
-                    if j < len(self.DATETIME_mvp) and self.DATETIME_mvp[j] is not None:
-                        prof_times.append(np.datetime64(self.DATETIME_mvp[j]))
-                    else:
-                        prof_times.append(np.datetime64('NaT'))
-                profile_time = np.array(prof_times, dtype='datetime64[ns]')
-            else:
-                profile_time = np.array([np.datetime64('NaT')] * n_prof, dtype='datetime64[ns]')
+        # Coordinates
+        profile_idx = np.arange(n_prof, dtype=np.int32)
+        sample_idx = np.arange(n_samp, dtype=np.int32)
+
+        # Direction per profile (down/up)
+        direction = None
+        if hasattr(self, 'DIR') and len(self.DIR) == n_prof:
+            direction = np.array(self.DIR, dtype=object)
+        else:
+            # Fallback based on even/odd
+            direction = np.array(['down' if i % 2 == 0 else 'up' for i in range(n_prof)], dtype=object)
+
+        # Per-sample time as seconds since reference origin
+        # TIME_mvp is in days relative to self.date_ref
+        time_seconds = None
+        if hasattr(self, 'TIME_mvp'):
+            time_seconds = self.TIME_mvp * 24.0 * 3600.0
+        else:
+            time_seconds = np.full((n_prof, n_samp), np.nan)
+
+        # Per-profile datetime (one timestamp per cast pair); map using i//2
+        profile_time = None
+        if hasattr(self, 'DATETIME_mvp') and len(getattr(self, 'DATETIME_mvp', [])) > 0:
+            prof_times = []
+            for i in range(n_prof):
+                j = i // 2
+                if j < len(self.DATETIME_mvp) and self.DATETIME_mvp[j] is not None:
+                    prof_times.append(np.datetime64(self.DATETIME_mvp[j]))
+                else:
+                    prof_times.append(np.datetime64('NaT'))
+            profile_time = np.array(prof_times, dtype='datetime64[ns]')
+        else:
+            profile_time = np.array([np.datetime64('NaT')] * n_prof, dtype='datetime64[ns]')
 
-            # Build dataset variables safely
-            data_vars = {}
+        # Build dataset variables safely
+        data_vars = {}
 
-            def add_var(var_name, arr, units=None, long_name=None):
-                if arr is None:
-                    return
-                data_vars[var_name] = (
-                    ('profile', 'sample'), arr,
-                    {k: v for k, v in [('units', units), ('long_name', long_name)] if v is not None}
-                )
-            
-            add_var('PRES', getattr(self, 'PRES_mvp', None), units='dbar', long_name='Sea water pressure')
-            add_var('TEMP', getattr(self, 'TEMP_mvp', None), units='degC', long_name='In-situ temperature')
-            add_var('COND', getattr(self, 'COND_mvp', None), units='mS/cm', long_name='Conductivity')
-            add_var('SAL', getattr(self, 'SALT_mvp', None), units='psu', long_name='Practical salinity')
-            add_var('SOUNDVEL', getattr(self, 'SOUNDVEL_mvp', None), units='m s-1', long_name='Sound speed')
-            add_var('DO', getattr(self, 'DO_mvp', None), units='ml/L', long_name='Dissolved oxygen')
-            add_var('TEMP2', getattr(self, 'TEMP2_mvp', None), units='degC', long_name='Oxygen sensor temperature')
-            add_var('SUNA', getattr(self, 'SUNA_mvp', None), long_name='SUNA raw/derived')
-            add_var('FLUO', getattr(self, 'FLUO_mvp', None), units='ug/L', long_name='Chl fluorescence')
-            add_var('TURB', getattr(self, 'TURB_mvp', None), units='NTU', long_name='Turbidity')
-            add_var('PH', getattr(self, 'PH_mvp', None), units='1', long_name='pH')
-
-            # Position and time arrays (2D)
-            if hasattr(self, 'LAT_mvp'):
-                add_var('LATITUDE', self.LAT_mvp, units='degrees_north', long_name='Latitude at sample')
-            if hasattr(self, 'LON_mvp'):
-                add_var('LONGITUDE', self.LON_mvp, units='degrees_east', long_name='Longitude at sample')
-            # Time seconds since reference
-            data_vars['TIME'] = (
-                ('profile', 'sample'), time_seconds,
-                {
-                    'units': f'seconds since {self.date_ref.strftime("%Y-%m-%d %H:%M:%S")}',
-                    'long_name': 'Time at sample'
-                }
+        def add_var(var_name, arr, units=None, long_name=None):
+            if arr is None:
+                return
+            data_vars[var_name] = (
+                ('profile', 'sample'), arr,
+                {k: v for k, v in [('units', units), ('long_name', long_name)] if v is not None}
             )
-
-            # Include corrected arrays if requested and present
-            if corrected:
-                def add_corr(name, attr, units=None, long_name=None):
-                    if hasattr(self, attr):
-                        data_vars[name] = (
-                            ('profile', 'sample'), getattr(self, attr),
-                            {k: v for k, v in [('units', units), ('long_name', long_name)] if v is not None}
-                        )
-                add_corr('pressure_corrected', 'PRES_mvp_corr', units='dbar', long_name='Corrected pressure')
-                add_corr('temperature_corrected', 'TEMP_mvp_corr', units='degC', long_name='Corrected temperature')
-                add_corr('conductivity_corrected', 'COND_mvp_corr', units='mS/cm', long_name='Corrected conductivity')
-                add_corr('salinity_corrected', 'SALT_mvp_corr', units='psu', long_name='Corrected salinity')
-                if hasattr(self, 'TIME_mvp_corr'):
-                    data_vars['time_corrected'] = (
-                        ('profile', 'sample'), self.TIME_mvp_corr * 24.0 * 3600.0,
-                        {
-                            'units': f'seconds since {self.date_ref.strftime("%Y-%m-%d %H:%M:%S")}',
-                            'long_name': 'Corrected time at sample'
-                        }
-                    )
-                if hasattr(self, 'LAT_mvp_corr'):
-                    add_corr('latitude_corrected', 'LAT_mvp_corr', units='degrees_north', long_name='Corrected latitude at sample')
-                if hasattr(self, 'LON_mvp_corr'):
-                    add_corr('longitude_corrected', 'LON_mvp_corr', units='degrees_east', long_name='Corrected longitude at sample')
-
-            # Coordinates and auxiliary per-profile variables
-            coords = {
-                'profile': ('profile', profile_idx),
-                'sample': ('sample', sample_idx)
+        
+        add_var('PRES', getattr(self, 'PRES_mvp', None), units='dbar', long_name='Sea water pressure')
+        add_var('TEMP', getattr(self, 'TEMP_mvp', None), units='degC', long_name='In-situ temperature')
+        add_var('COND', getattr(self, 'COND_mvp', None), units='mS/cm', long_name='Conductivity')
+        add_var('SAL', getattr(self, 'SALT_mvp', None), units='psu', long_name='Practical salinity')
+        add_var('SOUNDVEL', getattr(self, 'SOUNDVEL_mvp', None), units='m s-1', long_name='Sound speed')
+        add_var('DO', getattr(self, 'DO_mvp', None), units='ml/L', long_name='Dissolved oxygen')
+        add_var('TEMP2', getattr(self, 'TEMP2_mvp', None), units='degC', long_name='Oxygen sensor temperature')
+        add_var('SUNA', getattr(self, 'SUNA_mvp', None), long_name='SUNA raw/derived')
+        add_var('FLUO', getattr(self, 'FLUO_mvp', None), units='ug/L', long_name='Chl fluorescence')
+        add_var('TURB', getattr(self, 'TURB_mvp', None), units='NTU', long_name='Turbidity')
+        add_var('PH', getattr(self, 'PH_mvp', None), units='1', long_name='pH')
+
+        # Position and time arrays (2D)
+        if hasattr(self, 'LAT_mvp'):
+            add_var('LATITUDE', self.Lat_mvp, units='degrees_north', long_name='Latitude at sample')
+        if hasattr(self, 'LON_mvp'):
+            add_var('LONGITUDE', self.Lon_mvp, units='degrees_east', long_name='Longitude at sample')
+        # Time seconds since reference
+        data_vars['TIME'] = (
+            ('profile', 'sample'), time_seconds,
+            {
+                'units': f'seconds since {self.date_ref.strftime("%Y-%m-%d %H:%M:%S")}',
+                'long_name': 'Time at sample'
             }
+        )
 
-            # Encode direction/time according to engine capabilities
-            if engine in ('netcdf4', 'h5netcdf'):
-                coords['direction'] = ('profile', direction.astype('U'), {'long_name': 'Profile direction'})
-                coords['profile_time'] = ('profile', profile_time, {'long_name': 'Profile nominal time'})
-            else:
-                # scipy backend: avoid object strings and datetime; use numeric fallbacks
-                dir_flag = np.where(direction.astype('U') == 'down', 0, 1).astype('int8')
-                coords['direction_flag'] = (
-                    'profile', dir_flag, {'long_name': 'Profile direction (0=down,1=up)'}
-                )
-                ref = np.datetime64(self.date_ref)
-                pt = profile_time.astype('datetime64[s]')
-                mask = (pt == np.datetime64('NaT'))
-                secs = (pt - ref).astype('timedelta64[s]').astype('float64')
-                secs[mask] = np.nan
-                coords['profile_time_sec'] = (
-                    'profile', secs,
-                    {'units': f'seconds since {self.date_ref.strftime("%Y-%m-%d %H:%M:%S")}',
-                    'long_name': 'Profile nominal time'}
-                )
-
-            # Optional per-profile lat/lon (first valid sample)
-            def first_valid(vec):
-                # vec shape (n_prof, n_samp)
-                out = np.full((vec.shape[0],), np.nan)
-                for i in range(vec.shape[0]):
-                    row = vec[i]
-                    j = np.where(~np.isnan(row))[0]
-                    if j.size:
-                        out[i] = row[j[0]]
-                return out
-
-            if hasattr(self, 'LAT_mvp'):
-                coords['profile_lat'] = (
-                    'profile', first_valid(self.LAT_mvp), {'units': 'degrees_north', 'long_name': 'Profile latitude'}
-                )
-            if hasattr(self, 'LON_mvp'):
-                coords['profile_lon'] = (
-                    'profile', first_valid(self.LON_mvp), {'units': 'degrees_east', 'long_name': 'Profile longitude'}
+        # Include corrected arrays if requested and present
+        if corrected:
+            def add_corr(name, attr, units=None, long_name=None):
+                if hasattr(self, attr):
+                    data_vars[name] = (
+                        ('profile', 'sample'), getattr(self, attr),
+                        {k: v for k, v in [('units', units), ('long_name', long_name)] if v is not None}
+                    )
+            add_corr('pressure_corrected', 'PRES_mvp_corr', units='dbar', long_name='Corrected pressure')
+            add_corr('temperature_corrected', 'TEMP_mvp_corr', units='degC', long_name='Corrected temperature')
+            add_corr('conductivity_corrected', 'COND_mvp_corr', units='mS/cm', long_name='Corrected conductivity')
+            add_corr('salinity_corrected', 'SALT_mvp_corr', units='psu', long_name='Corrected salinity')
+            if hasattr(self, 'TIME_mvp_corr'):
+                data_vars['time_corrected'] = (
+                    ('profile', 'sample'), self.TIME_mvp_corr * 24.0 * 3600.0,
+                    {
+                        'units': f'seconds since {self.date_ref.strftime("%Y-%m-%d %H:%M:%S")}',
+                        'long_name': 'Corrected time at sample'
+                    }
                 )
+            if hasattr(self, 'LAT_mvp_corr'):
+                add_corr('latitude_corrected', 'LAT_mvp_corr', units='degrees_north', long_name='Corrected latitude at sample')
+            if hasattr(self, 'LON_mvp_corr'):
+                add_corr('longitude_corrected', 'LON_mvp_corr', units='degrees_east', long_name='Corrected longitude at sample')
+
+        # Coordinates and auxiliary per-profile variables
+        coords = {
+            'profile': ('profile', profile_idx),
+            'sample': ('sample', sample_idx)
+        }
+
+        # Encode direction/time according to engine capabilities
+        if engine in ('netcdf4', 'h5netcdf'):
+            coords['direction'] = ('profile', direction.astype('U'), {'long_name': 'Profile direction'})
+            coords['profile_time'] = ('profile', profile_time, {'long_name': 'Profile nominal time'})
+        else:
+            # scipy backend: avoid object strings and datetime; use numeric fallbacks
+            dir_flag = np.where(direction.astype('U') == 'down', 0, 1).astype('int8')
+            coords['direction_flag'] = (
+                'profile', dir_flag, {'long_name': 'Profile direction (0=down,1=up)'}
+            )
+            ref = np.datetime64(self.date_ref)
+            pt = profile_time.astype('datetime64[s]')
+            mask = (pt == np.datetime64('NaT'))
+            secs = (pt - ref).astype('timedelta64[s]').astype('float64')
+            secs[mask] = np.nan
+            coords['profile_time_sec'] = (
+                'profile', secs,
+                {'units': f'seconds since {self.date_ref.strftime("%Y-%m-%d %H:%M:%S")}',
+                'long_name': 'Profile nominal time'}
+            )
 
-            # Global attributes
-            attrs = {
-                'title': 'MVP profile data',
-                'Conventions': 'CF-1.8',
-                'institution': 'LMD/CNRS',
-                'source': 'PyMVP',
-                'history': f"Created on {datetime.now().isoformat()}",
-                'mvp_Yorig': int(self.Yorig)
-            }
-
-            ds = xr.Dataset(data_vars=data_vars, coords=coords, attrs=attrs)
-
-            # Compression encoding per engine
-            encoding = None
-            if compression:
-                if engine == 'netcdf4':
-                    encoding = {name: {'zlib': True, 'complevel': 4} for name in data_vars.keys()}
-                elif engine == 'h5netcdf':
-                    encoding = {name: {'compression': 'gzip', 'compression_opts': 4} for name in data_vars.keys()}
-
+        # Optional per-profile lat/lon (first valid sample)
+        def first_valid(vec):
+            # vec shape (n_prof, n_samp)
+            out = np.full((vec.shape[0],), np.nan)
+            for i in range(vec.shape[0]):
+                row = vec[i]
+                j = np.where(~np.isnan(row))[0]
+                if j.size:
+                    out[i] = row[j[0]]
+            return out
+
+        if hasattr(self, 'LAT_mvp'):
+            coords['profile_lat'] = (
+                'profile', first_valid(self.Lat_mvp), {'units': 'degrees_north', 'long_name': 'Profile latitude'}
+            )
+        if hasattr(self, 'LON_mvp'):
+            coords['profile_lon'] = (
+                'profile', first_valid(self.Lon_mvp), {'units': 'degrees_east', 'long_name': 'Profile longitude'}
+            )
 
-            if (not per_profile_files) and filepath.lower().endswith('.nc'):
-                out_path = filepath
-                ds.to_netcdf(out_path, encoding=encoding, engine=engine)
-                print(f"NetCDF written: {out_path} using engine={engine}")
-                return
-            base_dir = filepath
-
-            if not base_dir.endswith(os.sep):
-                base_dir = base_dir + os.sep
-
-            base_name = "MVP_" + os.path.basename(self.data_path).rstrip(os.sep)
-            if per_profile_files:
-                # Write one file per pair (down/up)
-                total_pairs = (n_prof + 1) // 2
-                for i in range(total_pairs):
-                    idxs = [k for k in (2*i, 2*i+1) if k < n_prof]
-                    if not idxs:
-                        continue
-                    ds_i = ds.isel(profile=idxs)
-
-                    #add i to filename
-                    fname = f"{base_name}_profile_{i:03d}.nc"
-                    out_path = os.path.join(base_dir, fname)
-                    ds_i.to_netcdf(out_path, encoding=encoding, engine=engine)
-                print(f"NetCDF written per profile into: {base_dir} using engine={engine}")
-            else:
-                file_name = f"{base_name}.nc"
-                out_path = os.path.join(base_dir, file_name)
-                ds.to_netcdf(out_path, encoding=encoding, engine=engine)
-                print(f"NetCDF written: {out_path} using engine={engine}")
+        # Global attributes
+        attrs = {
+            'title': 'MVP profile data',
+            'Conventions': 'CF-1.8',
+            'institution': 'LMD/CNRS',
+            'source': 'PyMVP',
+            'history': f"Created on {datetime.now().isoformat()}",
+            'mvp_Yorig': int(self.Yorig)
+        }
+
+        ds = xr.Dataset(data_vars=data_vars, coords=coords, attrs=attrs)
+
+        # Compression encoding per engine
+        encoding = None
+        if compression:
+            if engine == 'netcdf4':
+                encoding = {name: {'zlib': True, 'complevel': 4} for name in data_vars.keys()}
+            elif engine == 'h5netcdf':
+                encoding = {name: {'compression': 'gzip', 'compression_opts': 4} for name in data_vars.keys()}
+
+
+        if (not per_profile_files) and filepath.lower().endswith('.nc'):
+            out_path = filepath
+            ds.to_netcdf(out_path, encoding=encoding, engine=engine)
+            print(f"NetCDF written: {out_path} using engine={engine}")
+            return
+        base_dir = filepath
+
+        if not base_dir.endswith(os.sep):
+            base_dir = base_dir + os.sep
+
+        base_name = "MVP_" + os.path.basename(self.data_path).rstrip(os.sep)
+        if per_profile_files:
+            # Write one file per pair (down/up)
+            total_pairs = (n_prof + 1) // 2
+            for i in range(total_pairs):
+                idxs = [k for k in (2*i, 2*i+1) if k < n_prof]
+                if not idxs:
+                    continue
+                ds_i = ds.isel(profile=idxs)
+
+                #add i to filename
+                fname = f"{base_name}_profile_{i:03d}.nc"
+                out_path = os.path.join(base_dir, fname)
+                ds_i.to_netcdf(out_path, encoding=encoding, engine=engine)
+            print(f"NetCDF written per profile into: {base_dir} using engine={engine}")
+        else:
+            file_name = f"{base_name}.nc"
+            out_path = os.path.join(base_dir, file_name)
+            ds.to_netcdf(out_path, encoding=encoding, engine=engine)
+            print(f"NetCDF written: {out_path} using engine={engine}")
 
 
-        def help(self):
-            """
-            Print all methods of the class with their docstring (header).
-            """
-            for attr in dir(self):
-                if callable(getattr(self, attr)) and not attr.startswith("__"):
-                    method = getattr(self, attr)
-                    doc = method.__doc__
-                    print(f"{attr}:\n{doc}\n{'-'*40}")      
+    def help(self):
+        """
+        Print all methods of the class with their docstring (header).
+        """
+        for attr in dir(self):
+            if callable(getattr(self, attr)) and not attr.startswith("__"):
+                method = getattr(self, attr)
+                doc = method.__doc__
+                print(f"{attr}:\n{doc}\n{'-'*40}")      
 
 
     def plot_MVP_transect(self,var='TEMP',l_id=None,depth_max=None,depth_min=None,vmax=None,vmin=None,cmap=None):
@@ -1796,7 +1803,7 @@ class Analyzer:
         
         """
 
-        if self.hasattr('PRES_mvp_corr_interp') == False:
+        if hasattr(self, 'PRES_mvp_corr_interp') == False:
             raise ValueError("Corrected and interpolated MVP data not available. Apply corrections and interpolation first.")
         
         if l_id is None:
@@ -1908,9 +1915,9 @@ class Analyzer:
         ax.invert_yaxis()
         ax.set_xlabel("Distance le long du transect [km]")
         ax.set_ylabel("Profondeur [m]")
-        ax.set_title("Transect de température (interpolé)")
+        ax.set_title(f"{var} transect (interpolated)")
         cbar = plt.colorbar(pcm, ax=ax)
-        cbar.set_label("Température [°C]")
+        cbar.set_label(f"{var} (units)")
         plt.show()
 
 

{pymvp-0.2.3 → pymvp-0.2.5}/PyMVP/mvp_routines.py

@@ -1074,3 +1074,55 @@ def align_profiles(P, T_ref, T_to_align_raw, min_depth=0,max_shift=20):
     T_out[T_out_indices[mask_corrected]] = T_corrected[mask_corrected]
 
     return T_out, deltaP, deltaT
+
+
+
+
+def find_nearest_profile(time_mvp,Lat_mvp,Lon_mvp,time_ctd,Lat_ctd,Lon_ctd,mode):
+
+    if mode=='Dist':
+        idx = len(Lat_mvp)//2
+        Lat_mvp = np.radians(Lat_mvp[idx])
+        Lon_mvp = np.radians(Lon_mvp[idx])
+
+        R = 6371.0
+
+        min_dist = np.inf
+        nearest_index = -1
+
+        for i in range(len(Lat_ctd)):
+
+            lat,lon = np.radians(Lat_ctd[i]), np.radians(Lon_ctd[i]) 
+            mask = np.isfinite(lat) & np.isfinite(lon)
+            lat,lon = lat[mask], lon[mask]
+            lat,lon = lat[0],lon[0]
+
+            dlon = lon - Lon_mvp 
+            dlat = lat - Lat_mvp
+            a = np.sin(dlat / 2)**2 + np.cos(Lat_mvp) * np.cos(lat) * np.sin(dlon / 2)**2
+            c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1 - a))
+            dist = R * c * 1e3  # Convert to meters
+            if dist < min_dist:
+                min_dist = dist
+                nearest_index = i
+
+
+        return nearest_index, min_dist
+    
+    elif mode=='Time':
+        time_mvp = time_mvp[len(time_mvp)//2]  # Take the middle time of the MVP cycle as reference
+
+        min_time_diff = np.inf
+        nearest_index = -1
+        for i in range(len(time_ctd)):
+            time_diff = np.abs(time_ctd[i,-1] - time_mvp)
+            if time_diff < min_time_diff:
+                min_time_diff = time_diff
+                nearest_index = i
+        return nearest_index, min_time_diff
+    
+    else:
+        raise ValueError("Mode should be 'Dist' or 'Time'")
+
+
+

{pymvp-0.2.3 → pymvp-0.2.5}/PyMVP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMVP
-Version: 0.2.3
+Version: 0.2.5
 Summary: Python package for Moving Vessel Profiler correction and analysis
 Author: MaximilienWemaere
 Requires-Python: >=3.10

{pymvp-0.2.3 → pymvp-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PyMVP"
-version = "0.2.3"
+version = "0.2.5"
 description = "Python package for Moving Vessel Profiler correction and analysis"
 authors = [{name="MaximilienWemaere"}]
 readme = "README.md"