PyMVP 0.1.8__tar.gz → 0.2.1__tar.gz

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

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

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

@@ -36,7 +36,7 @@ from scipy.ndimage import median_filter
 
   
 class Analyzer:
-    def __init__(self, data_path, output_path=None, subdirs=False,  Yorig=1950):
+    def __init__(self, Yorig=1950):
         """
         Initialize the analyzer with the data path and reference year.
         Args:
@@ -46,14 +46,13 @@ class Analyzer:
         """
         self.Yorig = Yorig
         self.date_ref = datetime(Yorig, 1, 1)
-        self.data_path = data_path
-        self.output_path = output_path if output_path is not None else data_path
-        self.subdirs = subdirs
         self.mvp = False
         self.ctd = False
+        self.speed = False
+        self.corrected = False
 
 
-    def load_mvp_data(self,delp=[],data_path=None,format='raw',only_new=False):
+    def load_mvp_data(self,data_path, delp=[], subdirs=False,format='raw',only_new=False, output_path=None):
         """
         Load MVP data from .raw and .log files in the data_path folder.
         Fills the object attributes with data matrices and associated metadata.
@@ -61,8 +60,9 @@ class Analyzer:
             delp (list): Indices of profiles to remove from the list (optional).
             data_path (str): Path to the folder containing MVP files (optional).
         """
-        if data_path is not None:
-            self.data_path = data_path
+        self.data_path = data_path
+        self.subdirs = subdirs
+        self.output_path = output_path
 
         if format=='raw':
             if self.subdirs:
@@ -300,7 +300,7 @@ class Analyzer:
 
 
 
-    def load_mvp_data_again(self,data_path=None,format='raw',delp=[]):
+    def load_mvp_data_again(self,data_path,format='raw',delp=[]):
         """
         Load MVP data from .raw and .log files in the data_path folder.
         Fills the object attributes with data matrices and associated metadata.
@@ -308,14 +308,13 @@ class Analyzer:
             data_path (str): Path to the folder containing MVP files.
             delp (list): Indices of profiles to remove from the list (optional).
         """
-        if data_path is not None:
-            self.data_path = data_path
+
 
         if format=='raw':
-            files = sorted(filter(os.path.isfile,glob.glob(self.data_path + '*.raw', recursive=True)))
+            files = sorted(filter(os.path.isfile,glob.glob(data_path + '*.raw', recursive=True)))
         elif format=='ncdf':
-            files = sorted(filter(os.path.isfile,glob.glob(self.data_path + '**/MVP*.nc', recursive=True)))
-        print('Found ' + str(len(files)) + ' MVP files in the directory: ' + self.data_path)
+            files = sorted(filter(os.path.isfile,glob.glob(data_path + '**/MVP*.nc', recursive=True)))
+        print('Found ' + str(len(files)) + ' MVP files in the directory: ' + data_path)
 
 
 
@@ -562,12 +561,9 @@ class Analyzer:
         """
 
 
-        if format=='cnv':
-            list_of_ctd_files = sorted(filter(os.path.isfile,\
-                            glob.glob(data_path_ctd + '*.cnv')))
-        elif format=='ncdf':
-            list_of_ctd_files = sorted(filter(os.path.isfile,\
-                            glob.glob(data_path_ctd + 'CTD'+'*.nc')))
+        list_of_ctd_files = sorted(filter(os.path.isfile,\
+                        glob.glob(data_path_ctd + 'CTD'+'*.nc')))
+        
         print('Found ' + str(len(list_of_ctd_files)) + ' CTD files in the directory: ' + data_path_ctd)
 
 
@@ -629,14 +625,8 @@ class Analyzer:
         print('CTD data loaded successfully.')
         self.ctd = True
 
-            return 
             
 
-
-
-
-
-
     def compute_waterflow(self,horizontal_speed=2,corr=False):
         """
         Compute the water flow speed (u,v) from the horizontal speed and the direction of the profiles.
@@ -656,6 +646,7 @@ class Analyzer:
 
             self.SPEED_mvp = SPEED_MVP
         print('Water flow speed computed successfully.')
+        self.speed = True
 
     def print_profile_metadata(self):
         """
@@ -939,7 +930,7 @@ class Analyzer:
         plt.xlabel('Fluorescence, ug/L')
         plt.ylabel('Pressure, dbar')
 
-    def plot_diagramTS_raw(self,id_mvp=None,id_ctd=None,correction=False):
+    def plot_diagramTS(self,id_mvp=None,id_ctd=None,correction=False):
         """
         Plot the TS diagram (Salinity vs Temperature) for one or more profiles, with isopycnals.
         Args:
@@ -1235,7 +1226,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,correction=False):
+    def correct_oxygen(self,id_mvp=None,id_ctd=None,num_sample=500,plotting=False,):
         """
         Apply oxygen correction to MVP dissolved oxygen profiles thanks to CTD data.
         Args:
@@ -1296,9 +1287,9 @@ class Analyzer:
         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
 
-        if correction:
-            self.DO_mvp = DO_mvp_corr_full
 
         if plotting:
 
@@ -1315,7 +1306,6 @@ class Analyzer:
             plt.show()
 
 
-
     def mvp_correction(self,high_cutoff=1,dp=0.1):
 
         T_MVP_corr = []
@@ -1369,7 +1359,7 @@ class Analyzer:
         self.COND_mvp_corr = {i: sublist for i, sublist in enumerate(C_MVP_corr)}
         self.SALT_mvp_corr = {i: sublist for i, sublist in enumerate(S_MVP_corr)}
         self.TIME_mvp_corr = {i: sublist for i, sublist in enumerate(Time_MVP_corr)}
-
+        self.corrected = True
 
         print("MVP profiles corrected.")
 
@@ -1381,6 +1371,11 @@ class Analyzer:
         """
         if not self.ctd:
             raise ValueError("CTD data not loaded.")
+    
+        if not self.corrected:
+            raise ValueError("MVP data not corrected. Apply corrections first.")
+        
+
 
         if not hasattr(self, 'PRES_mvp_corr'):
             raise ValueError("Corrected MVP data not available. Apply corrections first.")
@@ -1398,8 +1393,9 @@ class Analyzer:
         max_lensalt = max([len(p) for p in self.SALT_mvp_corr.values()])
         SALT_mvp_corr_mat =  np.array([list(row) + [np.nan] * (max_lensalt - len(row)) for row in self.SALT_mvp_corr.values()])
 
-        max_lenvspd = max([len(p) for p in self.SPEED_mvp_corr.values()])
-        SPEED_mvp_corr_mat =  np.array([list(row) + [np.nan] * (max_lenvspd - len(row)) for row in self.SPEED_mvp_corr.values()])
+        if self.speed:
+            max_lenvspd = max([len(p) for p in self.SPEED_mvp_corr.values()])
+            SPEED_mvp_corr_mat =  np.array([list(row) + [np.nan] * (max_lenvspd - len(row)) for row in self.SPEED_mvp_corr.values()])
 
         max_lentime = max([len(p) for p in self.TIME_mvp_corr.values()])
         TIME_mvp_corr_mat =  np.array([list(row) + [np.nan] * (max_lentime - len(row)) for row in self.TIME_mvp_corr.values()])
@@ -1407,22 +1403,123 @@ class Analyzer:
 
         pressure_grid = np.linspace(np.nanmin(PRES_mvp_corr_mat), np.nanmax(PRES_mvp_corr_mat), length)
 
-        self.TEMP_ctd_on_mvp = mvp.vertical_interp(self.PRES_ctd, self.TEMP_ctd, pressure_grid)
-        self.PRES_ctd_on_mvp = mvp.vertical_interp(self.PRES_ctd, self.PRES_ctd, pressure_grid)
-        self.COND_ctd_on_mvp = mvp.vertical_interp(self.PRES_ctd, self.COND_ctd, pressure_grid)
-        self.SALT_ctd_on_mvp = mvp.vertical_interp(self.PRES_ctd, self.SALT_ctd, pressure_grid)
-        self.OXY_ctd_on_mvp = mvp.vertical_interp(self.PRES_ctd, self.OXY_ctd, pressure_grid)
+        self.TEMP_ctd_interp = mvp.vertical_interp(self.PRES_ctd, self.TEMP_ctd, pressure_grid)
+        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.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.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.SPEED_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, SPEED_mvp_corr_mat, pressure_grid)
+        self.DO_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.DO_mvp, pressure_grid)
+        self.FLUO_mvp_corr_interp = mvp.vertical_interp(self.PRES_mvp, self.FLUO_mvp, pressure_grid)
+        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.speed:
+            self.SPEED_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, SPEED_mvp_corr_mat, pressure_grid)
         self.TIME_mvp_corr_interp = mvp.vertical_interp(PRES_mvp_corr_mat, TIME_mvp_corr_mat, pressure_grid)
 
         print('CTD data interpolated onto corrected MVP pressure levels.')
 
 
-    def to_netcdf(self, filepath=None, corrected=False, compression=True, engine=None, per_profile_files=False):
+    def corrige_MVP_offset_on_ctd_exact(self,id_mvp,id_ctd,min_depth=-1):
+        """
+        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 suppose that CTD and MVP should be exactly the same profile (same location, same time). If it not the case, you shouldf use the other function _imple
+        """
+
+        mean_temp_diff = []
+        mean_cond_diff = []
+
+        print("Calculating mean differences between MVP and CTD profiles before correction:")
+        for i in range(len(id_mvp)):
+            # Calculate the mean difference in temperature between the MVP and CTD profiles
+            temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i]] - self.TEMP_ctd_interp[id_ctd[i]])
+            mean_temp_diff.append(temp_diff)
+
+            cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i]] - self.COND_ctd_interp[id_ctd[i]])
+            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)):
+            self.TEMP_mvp_corr_interp[id_mvp[i]] = mvp.align_profiles(self.PRES_mvp_corr_interp[id_mvp[i]], self.TEMP_ctd_interp[id_ctd[i]], self.TEMP_mvp_corr_interp[id_mvp[i]],min_depth)[0]
+            self.COND_mvp_corr_interp[id_mvp[i]] = mvp.align_profiles(self.PRES_mvp_corr_interp[id_mvp[i]], self.COND_ctd_interp[id_ctd[i]], self.COND_mvp_corr_interp[id_mvp[i]],min_depth)[0]
+
+
+        mean_temp_diff = []
+        mean_cond_diff = []
+        print("After correction:")
+        for i in range(len(id_mvp)):
+            # Calculate the mean difference in temperature between the MVP and CTD profiles
+            temp_diff = np.nanmean(self.TEMP_mvp_corr_interp[id_mvp[i]] - self.TEMP_ctd_interp[id_ctd[i]])
+            mean_temp_diff.append(temp_diff)
+
+            cond_diff = np.nanmean(self.COND_mvp_corr_interp[id_mvp[i]] - self.COND_ctd_interp[id_ctd[i]])
+            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))
+
+    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 to_netcdf(self, filepath, corrected=False, compression=True, engine=None, per_profile_files=False):
         """
         Export MVP data to a NetCDF file using xarray.
 
@@ -1592,7 +1689,7 @@ class Analyzer:
             'title': 'MVP profile data',
             'Conventions': 'CF-1.8',
             'institution': 'LMD/CNRS',
-            'source': 'MVPAnalyzer',
+            'source': 'PyMVP',
             'history': f"Created on {datetime.now().isoformat()}",
             'mvp_Yorig': int(self.Yorig)
         }
@@ -1607,17 +1704,13 @@ class Analyzer:
             elif engine == 'h5netcdf':
                 encoding = {name: {'compression': 'gzip', 'compression_opts': 4} for name in data_vars.keys()}
 
-        # Determine output base directory
-        if filepath is None:
-            base_dir = self.output_path if hasattr(self, 'output_path') else os.getcwd() + os.sep
-        else:
-            # If a full file path was provided and not per_profile_files, honor it
-            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 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

{pymvp-0.1.8 → pymvp-0.2.1}/PyMVP/mvp_routines.py

@@ -36,12 +36,11 @@ import scipy.stats as st
 from datetime import date
 from datetime import datetime
 from scipy import interpolate
-from scipy.signal import butter, freqz
 from scipy import signal
 import gsw
-from scipy.interpolate import pchip_interpolate
+from scipy.interpolate import interp1d
 from netCDF4 import Dataset
-from scipy.signal import butter, filtfilt, correlate, correlation_lags
+from scipy.signal import butter, filtfilt, correlate, correlation_lags,savgol_filter
 
 #
 ################################################################################
@@ -993,3 +992,85 @@ def bin_average_v2(P,T,C,S,time,dp=0.05):
             np.array(C_bin),
             np.array(S_bin),
             np.array(time_bin))
+
+
+
+
+
+
+
+def align_profiles(P, T_ref, T_to_align_raw, min_depth=0,max_shift=20):
+    """
+    Pipeline complet :
+    - estime ΔP
+    - recale
+    - estime ΔT
+    - corrige
+    """
+
+    ### 1. calcul delta de pression
+
+    # Masque pour exclure les valeurs non finies
+    mask_nan = (
+    np.isfinite(P) &
+    np.isfinite(T_ref) &
+    np.isfinite(T_to_align_raw)
+    )
+
+    P = P[mask_nan]
+    T_ref = T_ref[mask_nan]
+    T_to_align = T_to_align_raw[mask_nan]
+
+    # Masque pour exclure la surface
+    mask = P >= min_depth
+
+    P = P[mask]
+    T_ref = T_ref[mask]
+    T_to_align = T_to_align[mask]
+
+    # Lissage léger
+    T1s = savgol_filter(T_ref, 11, 2)
+    T2s = savgol_filter(T_to_align, 11, 2)
+
+    # Gradients
+    dT1 = np.gradient(T1s, P)
+    dT2 = np.gradient(T2s, P)
+
+    # Normalisation (important pour corrélation)
+    dT1 = (dT1 - np.mean(dT1)) / np.std(dT1)
+    dT2 = (dT2 - np.mean(dT2)) / np.std(dT2)
+
+    # Corrélation
+    corr = correlate(dT2, dT1, mode='full')
+    lags = np.arange(-len(dT1)+1, len(dT1))
+
+    # Convertir en décalage en pression
+    dP = np.mean(np.diff(P))
+    shifts = lags * dP
+
+    # Limiter les shifts plausibles
+    valid = np.abs(shifts) <= max_shift
+
+    deltaP = shifts[valid][np.argmax(corr[valid])]
+
+    ### 2. recalage pression
+    f = interp1d(P + deltaP, T_to_align, bounds_error=False, fill_value=np.nan)
+    T_shifted = f(P)
+
+    ### 3. calcul delta de température
+    mask = (P >= min_depth) & np.isfinite(T_ref) & np.isfinite(T_shifted)
+    deltaT = np.median(T_shifted[mask] - T_ref[mask])
+
+    ### 4. recalage thermique
+    T_corrected = T_shifted - deltaT
+
+    mask_corrected = np.isfinite(T_corrected)
+
+    # copie pour ne pas modifier l'original directement
+    T_out = T_to_align_raw.copy()
+
+    # injection uniquement là où c’est valide
+    T_out_indices = np.where(mask_nan)[0]
+    T_out[T_out_indices[mask_corrected]] = T_corrected[mask_corrected]
+
+    return T_out, deltaP, deltaT

{pymvp-0.1.8 → pymvp-0.2.1}/PyMVP.egg-info/PKG-INFO

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

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

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