PyMVP 0.2.1__tar.gz → 0.2.4__tar.gz

{pymvp-0.2.1 → pymvp-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMVP
-Version: 0.2.1
+Version: 0.2.4
 Summary: Python package for Moving Vessel Profiler correction and analysis
 Author: MaximilienWemaere
 Requires-Python: >=3.10
@@ -13,3 +13,5 @@ Requires-Dist: cartopy>=0.25.0
 Requires-Dist: scipy>=1.16.2
 Requires-Dist: xarray>=2025.9.1
 Requires-Dist: netcdf4>=1.7.2
+Requires-Dist: pandas>=2.1.0
+Requires-Dist: geopy>=2.4.0

{pymvp-0.2.1 → pymvp-0.2.4}/PyMVP/main.py

@@ -33,6 +33,10 @@ import cartopy.feature as cfeature
 import xarray as xr
 from . import mvp_routines as mvp
 from scipy.ndimage import median_filter
+from scipy.interpolate import griddata
+from scipy.ndimage import gaussian_filter
+from geopy.distance import geodesic
+import pandas as pd
 
   
 class Analyzer:
@@ -50,6 +54,10 @@ class Analyzer:
         self.ctd = False
         self.speed = False
         self.corrected = False
+        self.GPS = False
+
+    def ___version___(self):
+        return "0.2.3"
 
 
     def load_mvp_data(self,data_path, delp=[], subdirs=False,format='raw',only_new=False, output_path=None):
@@ -106,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
@@ -285,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
@@ -333,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
@@ -473,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))
 
 
 
@@ -539,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)
@@ -577,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 = []
@@ -595,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])
@@ -614,18 +622,41 @@ 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.')
         self.ctd = True
 
-            
+    def load_GPS(self, gps_path):
+        """
+        Load GPS data from a .csv file in the gps_path.
+        Fills the object attributes with GPS data and associated metadata.
+        Args:
+            gps_path (str): Path to the .csv file containing GPS data.
+        """
+        self.gps_path = gps_path
+        gps_data = pd.read_csv(gps_path)
+        self.GPS_TIME = gps_data['time'].values
+        self.GPS_LAT = gps_data['latitude'].values
+        self.GPS_LON = gps_data['longitude'].values
+        print('GPS data loaded successfully.')
+        self.gps = True
+
+        self.Lon_mvp = np.zeros(( self.PRES_mvp.shape[0], self.PRES_mvp.shape[1]))
+        self.Lat_mvp = np.zeros(( self.PRES_mvp.shape[0], self.PRES_mvp.shape[1]))
+
+        for i in range(self.PRES_mvp.shape[0]):
+            self.Lon_mvp[i,:] = np.interp(self.TIME_mvp[i,:], self.GPS_TIME, self.GPS_LON.astype(float))
+            self.Lat_mvp[i,:] = np.interp(self.TIME_mvp[i,:], self.GPS_TIME, self.GPS_LAT.astype(float))     
+
+        self.GPS = True     
 
     def compute_waterflow(self,horizontal_speed=2,corr=False):
         """
@@ -657,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:')
@@ -701,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]
@@ -721,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,:]
@@ -804,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
@@ -812,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
@@ -895,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()
@@ -1043,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
@@ -1226,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:
@@ -1248,63 +1279,65 @@ 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)
 
+        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 = self.DO_mvp_corr_interp[id_mvp] - (a_estim * self.DO_ctd_interp[id_ctd] + b_estim)
 
-        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}")
 
-        DO_mvp_corr_full = self.DO_mvp - (a_estime*self.PRES_mvp + b_estime)
-
-        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]
+            print(id_mvp,id_nearest_ctd)
+            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):
 
@@ -1407,11 +1440,11 @@ 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)
-        self.PRES_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, PRES_mvp_corr_mat, pressure_grid)
+        self.PRES_mvp_corr_interp = np.tile(pressure_grid, (PRES_mvp_corr_mat.shape[0], 1))
         self.COND_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, COND_mvp_corr_mat, pressure_grid)
         self.SALT_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, SALT_mvp_corr_mat, pressure_grid)
         self.DO_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.DO_mvp, pressure_grid)
@@ -1419,6 +1452,9 @@ class Analyzer:
         self.TURB_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.TURB_mvp, pressure_grid)
         self.PH_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.PH_mvp, pressure_grid)
         self.SUNA_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.SUNA_mvp, pressure_grid)
+        if self.GPS:
+            self.Lat_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.Lat_mvp, pressure_grid)
+            self.Lon_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.Lon_mvp, pressure_grid)
 
         if self.speed:
             self.SPEED_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, SPEED_mvp_corr_mat, pressure_grid)
@@ -1468,285 +1504,417 @@ class Analyzer:
     
 
 
-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.
-    id_mvp and id_ctd must be the same length as each MVP profile will be be corrected with the corresponding CTD profile. The function returns the corrected MVP temperature and conductivity profiles.
-    This version of the correction is less restritive than the other one, does not need the CTD aand MVP profiles to be exactly similar
-    We advice to choose a min_depth that avoid to take into acount the surface layer which can introduce errors.
-    """
-
-    mean_temp_diff = []
-    mean_cond_diff = []
-    print("Calculating mean differences between MVP and CTD profiles before correction:")
-    for i in range(len(id_mvp)):
-        id_valid = self.PRES_mvp_corr_interp[id_mvp[i]] >= min_depth
-        # Calculate the mean difference in temperature between the MVP and CTD profiles
-        temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i], id_valid] - self.TEMP_ctd_interp[id_ctd[i], id_valid])
-        mean_temp_diff.append(temp_diff)
-
-        cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i], id_valid] - self.COND_ctd_interp[id_ctd[i], id_valid])
-        mean_cond_diff.append(cond_diff)
-    print("Mean temperature difference between MVP and CTD profiles:", np.mean(mean_temp_diff))
-    print("Mean conductivity difference between MVP and CTD profiles:", np.mean(mean_cond_diff))
-
-    for i in range(len(id_mvp)):
-        id_valid = self.PRES_mvp_corr_interp[id_mvp[i]] >= min_depth
-
-        # Calculate the mean difference in temperature between the MVP and CTD profiles
-        temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i], id_valid] - self.TEMP_ctd_interp[id_ctd[i], id_valid])
-        self.TEMP_mvp_corr_interp[id_mvp[i]] -= temp_diff
-
-        cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i], id_valid] - self.COND_ctd_interp[id_ctd[i], id_valid])
-        self.COND_mvp_corr_interp[id_mvp[i]] -= cond_diff
-
-
-    mean_temp_diff = []
-    mean_cond_diff = []
-    print("After correction:")
-    for i in range(len(id_mvp)):
-        id_valid = self.PRES_mvp_corr_interp[id_mvp[i]] >= min_depth
-
-        # Calculate the mean difference in temperature between the MVP and CTD profiles
-        temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i], id_valid] - self.TEMP_ctd_interp[id_ctd[i], id_valid])
-        mean_temp_diff.append(temp_diff)
-
-        cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i], id_valid] - self.COND_ctd_interp[id_ctd[i], id_valid])
-        mean_cond_diff.append(cond_diff)
-    print("Mean temperature difference between MVP and CTD profiles:", np.mean(mean_temp_diff))
-    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.
+        id_mvp and id_ctd must be the same length as each MVP profile will be be corrected with the corresponding CTD profile. The function returns the corrected MVP temperature and conductivity profiles.
+        This version of the correction is less restritive than the other one, does not need the CTD aand MVP profiles to be exactly similar
+        We advice to choose a min_depth that avoid to take into acount the surface layer which can introduce errors.
+        """
 
+        mean_temp_diff = []
+        mean_cond_diff = []
+        print("Calculating mean differences between MVP and CTD profiles before correction:")
+        for i in range(len(id_mvp)):
+            id_valid = self.PRES_mvp_corr_interp[id_mvp[i]] >= min_depth
+            # Calculate the mean difference in temperature between the MVP and CTD profiles
+            temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i], id_valid] - self.TEMP_ctd_interp[id_ctd[i], id_valid])
+            mean_temp_diff.append(temp_diff)
 
+            cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i], id_valid] - self.COND_ctd_interp[id_ctd[i], id_valid])
+            mean_cond_diff.append(cond_diff)
+        print("Mean temperature difference between MVP and CTD profiles:", np.mean(mean_temp_diff))
+        print("Mean conductivity difference between MVP and CTD profiles:", np.mean(mean_cond_diff))
 
-    def to_netcdf(self, filepath, corrected=False, compression=True, engine=None, per_profile_files=False):
-        """
-        Export MVP data to a NetCDF file using xarray.
+        for i in range(len(id_mvp)):
+            id_valid = self.PRES_mvp_corr_interp[id_mvp[i]] >= min_depth
 
-        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.")
+            # Calculate the mean difference in temperature between the MVP and CTD profiles
+            temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i], id_valid] - self.TEMP_ctd_interp[id_ctd[i], id_valid])
+            self.TEMP_mvp_corr_interp[id_mvp[i]] -= temp_diff
 
-        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
+            cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i], id_valid] - self.COND_ctd_interp[id_ctd[i], id_valid])
+            self.COND_mvp_corr_interp[id_mvp[i]] -= cond_diff
 
-        # Dimensions
-        n_prof, n_samp = self.PRES_mvp.shape
 
-        # Coordinates
-        profile_idx = np.arange(n_prof, dtype=np.int32)
-        sample_idx = np.arange(n_samp, dtype=np.int32)
+        mean_temp_diff = []
+        mean_cond_diff = []
+        print("After correction:")
+        for i in range(len(id_mvp)):
+            id_valid = self.PRES_mvp_corr_interp[id_mvp[i]] >= min_depth
 
-        # 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]')
+            # Calculate the mean difference in temperature between the MVP and CTD profiles
+            temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i], id_valid] - self.TEMP_ctd_interp[id_ctd[i], id_valid])
+            mean_temp_diff.append(temp_diff)
 
-        # Build dataset variables safely
-        data_vars = {}
+            cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i], id_valid] - self.COND_ctd_interp[id_ctd[i], id_valid])
+            mean_cond_diff.append(cond_diff)
+        print("Mean temperature difference between MVP and CTD profiles:", np.mean(mean_temp_diff))
+        print("Mean conductivity difference between MVP and CTD profiles:", np.mean(mean_cond_diff))
+    
 
-        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}
+
+
+        def to_netcdf(self, filepath, corrected=False, compression=True, engine=None, per_profile_files=False):
+            """
+            Export MVP data to a NetCDF file using xarray.
+
+            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.")
+
+            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
+
+            # Dimensions
+            n_prof, n_samp = self.PRES_mvp.shape
+
+            # 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 = {}
+
+            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'
+                }
             )
-        
-        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'
-            }
-        )
 
-        # 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}
+            # 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'
+                        }
                     )
-            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'}
                 )
-            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'}
-            )
 
-        # 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'}
-            )
+            # 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'}
+                )
 
-        # 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}")
+            # 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()}
 
-    def help(self):
+
+            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 plot_MVP_transect(self,var='TEMP',l_id=None,depth_max=None,depth_min=None,vmax=None,vmin=None,cmap=None):
         """
-        Print all methods of the class with their docstring (header).
+        Plot a section of 2D inteprolated MVP data
+        Args:
+            var (str): Variable to plot. Choose from 'TEMP', 'COND', 'SAL', 'DO', 'FLUO', 'TURB', 'PH', 'SUNA', 'SPEED'.
+            l_id (list of int): List of profile indices to include in the transect. If None, use all profiles.
+            depth_max (float): Maximum depth to display in the plot. If None, use max depth in data.
+            depth_min (float): Minimum depth to display in the plot. If None, use 0.
+            vmax (float): Maximum value for color scale. If None, use max value in data.
+            vmin (float): Minimum value for color scale. If None, use min value in data.
+            cmap: Matplotlib colormap to use. If None, use default colormap.
+
+        
         """
-        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}")      
 
+        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:
+            l_id = list(range(self.PRES_mvp_corr_interp.shape[0]))
+
+        match var:
+            case 'TEMP':
+                var = self.TEMP_mvp_corr_interp
+            case 'COND':
+                var = self.COND_mvp_corr_interp
+            case 'SAL':
+                var = self.SALT_mvp_corr_interp
+            case 'DO':
+                var = self.DO_mvp_corr_interp
+            case 'FLUO':
+                var = self.FLUO_mvp_corr_interp
+            case 'TURB':
+                var = self.TURB_mvp_corr_interp
+            case 'PH':
+                var = self.PH_mvp_corr_interp
+            case 'SUNA':
+                var = self.SUNA_mvp_corr_interp
+            case 'SPEED':
+                var = self.SPEED_mvp_corr_interp
+            case _: 
+                raise ValueError(f"Variable {var} not recognized. Choose from 'TEMP', 'COND', 'SAL', 'DO', 'FLUO', 'TURB', 'PH', 'SUNA', 'SPEED'.")
+
+
+
+        P = self.PRES_mvp_corr_interp[l_id]
+        lat = self.Lat_mvp_corr_interp[l_id]
+        lon = self.Lon_mvp_corr_interp[l_id]
+        T = var[l_id]
+
+        if depth_max is None:
+            depth_max = np.nanmax(P)
+        if depth_min is None:
+            depth_min = 0
+
+
+        n_profiles, n_points = T.shape
+
+        # compute distance
+        dist_cum = 0
+        dist_all = np.zeros_like(T)
+
+        for i in range(n_profiles):
+            dist_i = np.zeros(n_points)
+            last_valid = None
+            for j in range(n_points):
+                if np.isnan(lat[i,j]) or np.isnan(lon[i,j]):
+                    dist_i[j] = np.nan
+                else:
+                    if last_valid is None:
+                        dist_i[j] = 0
+                    else:
+                        dist_i[j] = dist_i[last_valid] + geodesic(
+                            (lat[i,last_valid], lon[i,last_valid]),
+                            (lat[i,j], lon[i,j])
+                        ).km
+                    last_valid = j
+
+            dist_i += dist_cum
+            if np.any(~np.isnan(dist_i)):
+                dist_cum = np.nanmax(dist_i)
+            dist_all[i,:] = dist_i
+
+        # interpolation
+        dist_flat = dist_all.flatten()
+        T_flat = T.flatten()
+        P_flat = P.flatten()
+
+        # del nan
+        mask = ~np.isnan(dist_flat) & ~np.isnan(T_flat)
+        dist_flat = dist_flat[mask]
+        P_flat = P_flat[mask]
+        T_flat = T_flat[mask]
+
+        # create regular grid
+        dist_grid = np.linspace(dist_flat.min(), dist_flat.max(), 500)
+        P_grid = np.linspace(depth_min, depth_max, 1200)
+        DIST, PRES = np.meshgrid(dist_grid, P_grid)
+
+        # 2D interp
+        T_grid = griddata(
+            (dist_flat, P_flat),
+            T_flat,
+            (DIST, PRES),
+            method='linear'
+        )
+
+        # -----------------------------
+        # 5. Lissage pour adoucir les frontières
+        # -----------------------------
+        T_grid_smooth = gaussian_filter(T_grid, sigma=2)
+
+
+        if vmax is None:
+            vmax = np.nanmax(T_grid_smooth)
+        if vmin is None:
+            vmin = np.nanmin(T_grid_smooth)
+        # -----------------------------
+        # 6. Plot
+        # -----------------------------
+        if cmap is None:
+            cmap = plt.get_cmap('viridis')
+        fig, ax = plt.subplots(figsize=(12,6))
+        pcm = ax.pcolormesh(DIST, PRES, T_grid_smooth, shading='auto', cmap=cmap, vmin=vmin, vmax=vmax)
+        ax.invert_yaxis()
+        ax.set_xlabel("Distance le long du transect [km]")
+        ax.set_ylabel("Profondeur [m]")
+        ax.set_title(f"{var} transect (interpolated)")
+        cbar = plt.colorbar(pcm, ax=ax)
+        cbar.set_label(f"{var} (units)")
+        plt.show()
 
 
 def split_ctd(pres, array):

{pymvp-0.2.1 → pymvp-0.2.4}/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.1 → pymvp-0.2.4}/PyMVP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyMVP
-Version: 0.2.1
+Version: 0.2.4
 Summary: Python package for Moving Vessel Profiler correction and analysis
 Author: MaximilienWemaere
 Requires-Python: >=3.10
@@ -13,3 +13,5 @@ Requires-Dist: cartopy>=0.25.0
 Requires-Dist: scipy>=1.16.2
 Requires-Dist: xarray>=2025.9.1
 Requires-Dist: netcdf4>=1.7.2
+Requires-Dist: pandas>=2.1.0
+Requires-Dist: geopy>=2.4.0

{pymvp-0.2.1 → pymvp-0.2.4}/PyMVP.egg-info/requires.txt

@@ -6,3 +6,5 @@ cartopy>=0.25.0
 scipy>=1.16.2
 xarray>=2025.9.1
 netcdf4>=1.7.2
+pandas>=2.1.0
+geopy>=2.4.0

{pymvp-0.2.1 → pymvp-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PyMVP"
-version = "0.2.1"
+version = "0.2.4"
 description = "Python package for Moving Vessel Profiler correction and analysis"
 authors = [{name="MaximilienWemaere"}]
 readme = "README.md"
@@ -14,6 +14,9 @@ dependencies = [
     "scipy>=1.16.2",
     "xarray>=2025.9.1",
     "netcdf4>=1.7.2",
+    "pandas>=2.1.0",
+    "geopy>=2.4.0"
 ]
 
-
+[tool.setuptools.packages.find]
+include = ["PyMVP*"]