pypromice 1.5.1__py3-none-any.whl → 1.5.3__py3-none-any.whl

pypromice/process/L0toL1.py

@@ -7,6 +7,7 @@ import pandas as pd
 import xarray as xr
 import re, logging
 from pypromice.process.value_clipping import clip_values
+from pypromice.process import wind
 logger = logging.getLogger(__name__)
 
 
@@ -23,12 +24,12 @@ def toL1(L0, vars_df, T_0=273.15, tilt_threshold=-100):
         Air temperature for sonic ranger adjustment
     tilt_threshold : int
         Tilt-o-meter threshold for valid measurements
-        
+
     Returns
     -------
     ds : xarray.Dataset
         Level 1 dataset
-    '''    
+    '''
     assert(type(L0) == xr.Dataset)
     ds = L0
     ds.attrs['level'] = 'L1'
@@ -48,7 +49,7 @@ def toL1(L0, vars_df, T_0=273.15, tilt_threshold=-100):
     # If we do not want to shift hourly average values back -1 hr, then comment the following line.
     ds = addTimeShift(ds, vars_df)
 
-    if hasattr(ds, 'dsr_eng_coef'): 
+    if hasattr(ds, 'dsr_eng_coef'):
         ds['dsr'] = (ds['dsr'] * 10) / ds.attrs['dsr_eng_coef']                # Convert radiation from engineering to physical units
     if hasattr(ds, 'usr_eng_coef'):                                            # TODO add metadata to indicate whether radiometer values are corrected with calibration values or not
         ds['usr'] = (ds['usr'] * 10) / ds.attrs['usr_eng_coef']
@@ -58,10 +59,10 @@ def toL1(L0, vars_df, T_0=273.15, tilt_threshold=-100):
         ds['ulr'] = ((ds['ulr'] * 10) / ds.attrs['ulr_eng_coef']) + 5.67E-8*(ds['t_rad'] + T_0)**4
 
     ds['z_boom_u'] = _reformatArray(ds['z_boom_u'])                            # Reformat boom height
-    
+
     ds['t_u_interp'] = interpTemp(ds['t_u'], vars_df)
-    ds['z_boom_u'] = ds['z_boom_u'] * ((ds['t_u_interp'] + T_0)/T_0)**0.5      # Adjust sonic ranger readings for sensitivity to air temperature       
-    
+    ds['z_boom_u'] = ds['z_boom_u'] * ((ds['t_u_interp'] + T_0)/T_0)**0.5      # Adjust sonic ranger readings for sensitivity to air temperature
+
     if ds['gps_lat'].dtype.kind == 'O':                                        # Decode and reformat GPS information
         if 'NH' in ds['gps_lat'].dropna(dim='time').values[1]:
             ds = decodeGPS(ds, ['gps_lat','gps_lon','gps_time'])
@@ -73,22 +74,22 @@ def toL1(L0, vars_df, T_0=273.15, tilt_threshold=-100):
         else:
             try:
                 ds = decodeGPS(ds, ['gps_lat','gps_lon','gps_time'])          # TODO this is a work around specifically for L0 RAW processing for THU_U. Find a way to make this slicker
-            
+
             except:
                 print('Invalid GPS type {ds["gps_lat"].dtype} for decoding')
-            
+
     for l in ['gps_lat', 'gps_lon', 'gps_alt','gps_time']:
-        ds[l] = _reformatArray(ds[l])  
+        ds[l] = _reformatArray(ds[l])
 
     if hasattr(ds, 'latitude') and hasattr(ds, 'longitude'):
         ds['gps_lat'] = reformatGPS(ds['gps_lat'], ds.attrs['latitude'])
         ds['gps_lon'] = reformatGPS(ds['gps_lon'], ds.attrs['longitude'])
 
     if hasattr(ds, 'logger_type'):                                             # Convert tilt voltage to degrees
-        if ds.attrs['logger_type'].upper() == 'CR1000':                    
-            ds['tilt_x']  = getTiltDegrees(ds['tilt_x'], tilt_threshold) 
-            ds['tilt_y'] = getTiltDegrees(ds['tilt_y'], tilt_threshold)  
-            
+        if ds.attrs['logger_type'].upper() == 'CR1000':
+            ds['tilt_x']  = getTiltDegrees(ds['tilt_x'], tilt_threshold)
+            ds['tilt_y'] = getTiltDegrees(ds['tilt_y'], tilt_threshold)
+
     if hasattr(ds, 'tilt_y_factor'):                                           # Apply tilt factor (e.g. -1 will invert tilt angle)
         ds['tilt_y'] = ds['tilt_y']*ds.attrs['tilt_y_factor']
 
@@ -97,39 +98,66 @@ def toL1(L0, vars_df, T_0=273.15, tilt_threshold=-100):
     # since we interpolate above in _getTiltDegrees. PJW
     ds['tilt_x']  = smoothTilt(ds['tilt_x'], 7)                                # Smooth tilt
     ds['tilt_y']  = smoothTilt(ds['tilt_y'], 7)                               
-    
-    if hasattr(ds, 'bedrock'):                                                 # Fix tilt to zero if station is on bedrock
-        if ds.attrs['bedrock']==True or ds.attrs['bedrock'].lower() in 'true':
-            ds.attrs['bedrock'] = True                                         # ensures all AWS objects have a 'bedrock' attribute
-            ds['tilt_x'] = (('time'), np.arange(ds['time'].size)*0)
-            ds['tilt_y'] = (('time'), np.arange(ds['time'].size)*0)
-        else:
-            ds.attrs['bedrock'] = False                                        # ensures all AWS objects have a 'bedrock' attribute
-    else:
-        ds.attrs['bedrock'] = False                                            # ensures all AWS objects have a 'bedrock' attribute
-    
+
+    # Apply wind factor if provided
+    # This is in the case of an anemometer rotations improperly translated to wind speed by the logger program
+    if hasattr(ds, 'wind_u_coef'):
+        logger.info(f'Wind speed correction applied to wspd_u based on factor of {ds.attrs["wind_u_coef"]}')
+        ds['wspd_u'] = wind.correct_wind_speed(ds['wspd_u'],
+                                               ds.attrs['wind_u_coef'])
+    if hasattr(ds, 'wind_l_coef'):
+        logger.info(f'Wind speed correction applied to wspd_u based on factor of {ds.attrs["wind_l_coef"]}')
+        ds['wspd_l'] = wind.correct_wind_speed(ds['wspd_l'],
+                                               ds.attrs['wind_l_coef'])
+    if hasattr(ds, 'wind_i_coef'):
+        logger.info(f'Wind speed correction applied to wspd_u based on factor of {ds.attrs["wind_i_coef"]}')
+        ds['wspd_i'] = wind.correct_wind_speed(ds['wspd_i'],
+                                               ds.attrs['wind_i_coef'])
+
+    # Handle cases where the bedrock attribute is incorrectly set
+    if not 'bedrock' in ds.attrs:
+        logger.warning('bedrock attribute is not set')
+        ds.attrs['bedrock'] = False
+    elif not isinstance(ds.attrs['bedrock'], bool):
+        logger.warning(f'bedrock attribute is not boolean: {ds.attrs["bedrock"]}')
+        ds.attrs['bedrock'] =  str(ds.attrs['bedrock']).lower() == 'true'
+
+    is_bedrock = ds.attrs['bedrock']
+
+    if is_bedrock:
+        # some bedrock stations (e.g. KAN_B) do not have tilt in L0 files
+        # we need to create them manually
+        for var in ['tilt_x','tilt_y']:
+            if var not in ds.data_vars:
+                ds[var] = (('time'), np.full(ds['time'].size, np.nan))
+
+        # WEG_B has a non-null z_pt even though it is a berock station
+        if ~ds['z_pt'].isnull().all():                                         # Calculate pressure transducer fluid density
+            ds['z_pt'] = (('time'), np.full(ds['time'].size, np.nan))
+            logger.info('Warning: Non-null data for z_pt at a bedrock site')
+
     if ds.attrs['number_of_booms']==1:                                         # 1-boom processing
-        if ~ds['z_pt'].isnull().all():                                         # Calculate pressure transducer fluid density                                           
+        if ~ds['z_pt'].isnull().all():                                         # Calculate pressure transducer fluid density
             if hasattr(ds, 'pt_z_offset'):                                     # Apply SR50 stake offset
-                ds['z_pt'] = ds['z_pt'] + int(ds.attrs['pt_z_offset'])              
-            ds['z_pt_cor'],ds['z_pt']=getPressDepth(ds['z_pt'], ds['p_u'], 
-                                                    ds.attrs['pt_antifreeze'], 
-                                                    ds.attrs['pt_z_factor'], 
-                                                    ds.attrs['pt_z_coef'], 
-                                                    ds.attrs['pt_z_p_coef'])       
-        ds['z_stake'] = _reformatArray(ds['z_stake'])                          # Reformat boom height    
+                ds['z_pt'] = ds['z_pt'] + int(ds.attrs['pt_z_offset'])
+            ds['z_pt_cor'],ds['z_pt']=getPressDepth(ds['z_pt'], ds['p_u'],
+                                                    ds.attrs['pt_antifreeze'],
+                                                    ds.attrs['pt_z_factor'],
+                                                    ds.attrs['pt_z_coef'],
+                                                    ds.attrs['pt_z_p_coef'])
+        ds['z_stake'] = _reformatArray(ds['z_stake'])                          # Reformat boom height
         ds['z_stake'] = ds['z_stake'] * ((ds['t_u'] + T_0)/T_0)**0.5           # Adjust sonic ranger readings for sensitivity to air temperature
-        
+
     elif ds.attrs['number_of_booms']==2:                                       # 2-boom processing
-        ds['z_boom_l'] = _reformatArray(ds['z_boom_l'])                        # Reformat boom height    
+        ds['z_boom_l'] = _reformatArray(ds['z_boom_l'])                        # Reformat boom height
         ds['t_l_interp'] = interpTemp(ds['t_l'], vars_df)
-        ds['z_boom_l'] = ds['z_boom_l'] * ((ds['t_l_interp']+ T_0)/T_0)**0.5   # Adjust sonic ranger readings for sensitivity to air temperature    
+        ds['z_boom_l'] = ds['z_boom_l'] * ((ds['t_l_interp']+ T_0)/T_0)**0.5   # Adjust sonic ranger readings for sensitivity to air temperature
 
     ds = clip_values(ds, vars_df)
     for key in ['hygroclip_t_offset', 'dsr_eng_coef', 'usr_eng_coef',
-          'dlr_eng_coef', 'ulr_eng_coef', 'pt_z_coef', 'pt_z_p_coef',
-          'pt_z_factor', 'pt_antifreeze', 'boom_azimuth', 'nodata',
-          'conf', 'file']:
+          'dlr_eng_coef', 'ulr_eng_coef', 'wind_u_coef','wind_l_coef',
+          'wind_i_coef', 'pt_z_coef', 'pt_z_p_coef', 'pt_z_factor',
+          'pt_antifreeze', 'boom_azimuth', 'nodata', 'conf', 'file']:
         ds.attrs.pop(key, None)
 
     return ds
@@ -220,10 +248,10 @@ def addTimeShift(ds, vars_df):
     # ds_out = xr.Dataset(dict(zip(df_out.columns, vals)), attrs=ds.attrs)
     return ds_out
 
-def getPressDepth(z_pt, p, pt_antifreeze, pt_z_factor, pt_z_coef, pt_z_p_coef): 
-    '''Adjust pressure depth and calculate pressure transducer depth based on 
+def getPressDepth(z_pt, p, pt_antifreeze, pt_z_factor, pt_z_coef, pt_z_p_coef):
+    '''Adjust pressure depth and calculate pressure transducer depth based on
     pressure transducer fluid density
-    
+
     Parameters
     ----------
     z_pt : xr.Dataarray
@@ -231,7 +259,7 @@ def getPressDepth(z_pt, p, pt_antifreeze, pt_z_factor, pt_z_coef, pt_z_p_coef):
     p : xr.Dataarray
         Air pressure
     pt_antifreeze : float
-        Pressure transducer anti-freeze percentage for fluid density 
+        Pressure transducer anti-freeze percentage for fluid density
         correction
     pt_z_factor : float
         Pressure transducer factor
@@ -239,7 +267,7 @@ def getPressDepth(z_pt, p, pt_antifreeze, pt_z_factor, pt_z_coef, pt_z_p_coef):
         Pressure transducer coefficient
     pt_z_p_coef : float
         Pressure transducer coefficient
-    
+
     Returns
     -------
     z_pt_cor : xr.Dataarray
@@ -247,8 +275,8 @@ def getPressDepth(z_pt, p, pt_antifreeze, pt_z_factor, pt_z_coef, pt_z_p_coef):
     z_pt : xr.Dataarray
         Pressure transducer depth
     '''
-    # Calculate pressure transducer fluid density                                        
-    if pt_antifreeze == 50:                                                    #TODO: Implement function w/ reference (analytical or from LUT)                                             
+    # Calculate pressure transducer fluid density
+    if pt_antifreeze == 50:                                                    #TODO: Implement function w/ reference (analytical or from LUT)
         rho_af = 1092                                                          #TODO: Track uncertainty
     elif pt_antifreeze == 100:
         rho_af = 1145
@@ -257,19 +285,19 @@ def getPressDepth(z_pt, p, pt_antifreeze, pt_z_factor, pt_z_coef, pt_z_p_coef):
         logger.info('ERROR: Incorrect metadata: "pt_antifreeze" = ' +
               f'{pt_antifreeze}. Antifreeze mix only supported at 50% or 100%')
         # assert(False)
-                
+
     # Correct pressure depth
     z_pt_cor = z_pt * pt_z_coef * pt_z_factor * 998.0 / rho_af + 100 * (pt_z_p_coef - p) / (rho_af * 9.81)
 
     # Calculate pressure transducer depth
     z_pt = z_pt * pt_z_coef * pt_z_factor * 998.0 / rho_af
-    
+
     return z_pt_cor, z_pt
 
 
 def interpTemp(temp, var_configurations, max_interp=pd.Timedelta(12,'h')):
     '''Clip and interpolate temperature dataset for use in corrections
-    
+
     Parameters
     ----------
     temp : `xarray.DataArray`
@@ -278,7 +306,7 @@ def interpTemp(temp, var_configurations, max_interp=pd.Timedelta(12,'h')):
         Dataframe to retrieve attribute hi-lo values from for temperature clipping
     max_interp : `pandas.Timedelta`
         Maximum time steps to interpolate across. The default is 12 hours.
-    
+
     Returns
     -------
     temp_interp : `xarray.DataArray`
@@ -286,18 +314,18 @@ def interpTemp(temp, var_configurations, max_interp=pd.Timedelta(12,'h')):
     '''
     # Determine if upper or lower temperature array
     var = temp.name.lower()
-    
+
     # Find range threshold and use it to clip measurements
     cols = ["lo", "hi", "OOL"]
     assert set(cols) <= set(var_configurations.columns)
     variable_limits = var_configurations[cols].dropna(how="all")
     temp = temp.where(temp >= variable_limits.loc[var,'lo'])
     temp = temp.where(temp <= variable_limits.loc[var, 'hi'])
-    
+
     # Drop duplicates and interpolate across NaN values
 #    temp_interp = temp.drop_duplicates(dim='time', keep='first')
     temp_interp = temp.interpolate_na(dim='time', max_gap=max_interp)
-    
+
     return temp_interp
 
 
@@ -309,7 +337,7 @@ def smoothTilt(tilt, win_size):
     In Python, this should be
     dstxy = dstxy.rolling(time=7, win_type='boxcar', center=True).mean()
     But the EDGE_MIRROR makes it a bit more complicated
-    
+
     Parameters
     ----------
     tilt : xarray.DataArray
@@ -338,9 +366,9 @@ def smoothTilt(tilt, win_size):
     return tdf_rolling
 
 def getTiltDegrees(tilt, threshold):
-    '''Filter tilt with given threshold, and convert from voltage to degrees. 
-    Voltage-to-degrees converseion is based on the equation in 3.2.9 at 
-    https://essd.copernicus.org/articles/13/3819/2021/#section3    
+    '''Filter tilt with given threshold, and convert from voltage to degrees.
+    Voltage-to-degrees converseion is based on the equation in 3.2.9 at
+    https://essd.copernicus.org/articles/13/3819/2021/#section3
 
     Parameters
     ----------
@@ -348,7 +376,7 @@ def getTiltDegrees(tilt, threshold):
         Array (either 'tilt_x' or 'tilt_y'), tilt values (voltage)
     threshold : int
         Values below this threshold (-100) will not be retained.
-    
+
     Returns
     -------
     dst.interpolate_na() : xarray.DataArray
@@ -358,7 +386,7 @@ def getTiltDegrees(tilt, threshold):
     notOKtilt = (tilt < threshold)
     OKtilt = (tilt >= threshold)
     tilt = tilt / 10
-    
+
     # IDL version:
     # tiltX = tiltX/10.
     # tiltnonzero = where(tiltX ne 0 and tiltX gt -40 and tiltX lt 40)
@@ -366,26 +394,26 @@ def getTiltDegrees(tilt, threshold):
     # tiltY = tiltY/10.
     # tiltnonzero = where(tiltY ne 0 and tiltY gt -40 and tiltY lt 40)
     # if n_elements(tiltnonzero) ne 1 then tiltY[tiltnonzero] = tiltY[tiltnonzero]/abs(tiltY[tiltnonzero])*(-0.49*(abs(tiltY[tiltnonzero]))^4 + 3.6*(abs(tiltY[tiltnonzero]))^3 - 10.4*(abs(tiltY[tiltnonzero]))^2 +21.1*(abs(tiltY[tiltnonzero])))
-    
+
     dst = tilt
     nz = (dst != 0) & (np.abs(dst) < 40)
-    
+
     dst = dst.where(~nz, other = dst / np.abs(dst)
                       * (-0.49
                          * (np.abs(dst))**4 + 3.6
                          * (np.abs(dst))**3 - 10.4
                          * (np.abs(dst))**2 + 21.1
                          * (np.abs(dst))))
-    
+
     # if n_elements(OKtiltX) gt 1 then tiltX[notOKtiltX] = interpol(tiltX[OKtiltX],OKtiltX,notOKtiltX) ; Interpolate over gaps for radiation correction; set to -999 again below.
     dst = dst.where(~notOKtilt)
     return dst.interpolate_na(dim='time', use_coordinate=False)                #TODO: Filling w/o considering time gaps to re-create IDL/GDL outputs. Should fill with coordinate not False. Also consider 'max_gap' option?
 
-    
+
 def decodeGPS(ds, gps_names):
-    '''Decode GPS information based on names of GPS attributes. This should be 
+    '''Decode GPS information based on names of GPS attributes. This should be
     applied if gps information does not consist of float values
-    
+
     Parameters
     ----------
     ds : xr.Dataset
@@ -393,63 +421,63 @@ def decodeGPS(ds, gps_names):
     gps_names : list
         Variable names for GPS information, such as "gps_lat", "gps_lon" and
         "gps_alt"
-    
+
     Returns
     -------
     ds : xr.Dataset
         Data set with decoded GPS information
     '''
     for v in gps_names:
-        a = ds[v].attrs    
+        a = ds[v].attrs
         str2nums = [re.findall(r"[-+]?\d*\.\d+|\d+", _) if isinstance(_, str) else [np.nan] for _ in ds[v].values]
         ds[v][:] = pd.DataFrame(str2nums).astype(float).T.values[0]
         ds[v] = ds[v].astype(float)
-        ds[v].attrs = a 
+        ds[v].attrs = a
     return ds
 
 def reformatGPS(pos_arr, attrs):
     '''Correct latitude and longitude from native format to decimal degrees.
-    
+
     v2 stations should send  "NH6429.01544","WH04932.86061" (NUK_L 2022)
     v3 stations should send coordinates as "6628.93936","04617.59187" (DY2) or 6430,4916 (NUK_Uv3)
     decodeGPS should have decoded these strings to floats in ddmm.mmmm format
     v1 stations however only saved decimal minutes (mm.mmmmm) as float<=60. '
-    In this case, we use the integer part of the latitude given in the config 
+    In this case, we use the integer part of the latitude given in the config
     file and append the gps value after it.
-        
+
     Parameters
     ----------
     pos_arr : xr.Dataarray
         Array of latitude or longitude measured by the GPS
     attrs : dict
-        The global attribute 'latitude' or 'longitude' associated with the 
-        file being processed. It is the standard latitude/longitude given in the 
+        The global attribute 'latitude' or 'longitude' associated with the
+        file being processed. It is the standard latitude/longitude given in the
         config file for that station.
-    
+
     Returns
     -------
     pos_arr : xr.Dataarray
         Formatted GPS position array in decimal degree
-    '''       
-    if np.any((pos_arr <= 90) & (pos_arr > 0)):  
-        # then pos_arr is in decimal minutes, so we add to it the integer 
+    '''
+    if np.any((pos_arr <= 90) & (pos_arr > 0)):
+        # then pos_arr is in decimal minutes, so we add to it the integer
         # part of the latitude given in the config file x100
         # so that it reads ddmm.mmmmmm like for v2 and v3 files
         # Note that np.sign and np.attrs handles negative longitudes.
         pos_arr = np.sign(attrs) * (pos_arr + 100*np.floor(np.abs(attrs)))
-    a = pos_arr.attrs                                                     
+    a = pos_arr.attrs
     pos_arr = np.floor(pos_arr / 100) + (pos_arr / 100 - np.floor(pos_arr / 100)) * 100 / 60
-    pos_arr.attrs = a 
-    return pos_arr 
+    pos_arr.attrs = a
+    return pos_arr
 
 def _reformatArray(ds_arr):
     '''Reformat DataArray values and attributes
-    
+
     Parameters
     ----------
     ds_arr : xr.Dataarray
         Data array
-    
+
     Returns
     -------
     ds_arr : xr.Dataarray
@@ -458,18 +486,18 @@ def _reformatArray(ds_arr):
     a = ds_arr.attrs                                                           # Store
     ds_arr.values = pd.to_numeric(ds_arr, errors='coerce')
     ds_arr.attrs = a                                                           # Reformat
-    return ds_arr         
+    return ds_arr
 
 def _removeVars(ds, v_names):
     '''Remove redundant variables if present in dataset
-    
+
     Parameters
     ----------
     ds : xr.Dataset
         Data set
     v_names : list
         List of column names to drop
-    
+
     Returns
     -------
     ds : xr.Dataset
@@ -481,7 +509,7 @@ def _removeVars(ds, v_names):
 
 def _popCols(ds, booms, data_type, vars_df, cols):
     '''Populate data array columns with given variable names from look-up table
-    
+
     Parameters
     ----------
     ds : xr.Dataset
@@ -494,7 +522,7 @@ def _popCols(ds, booms, data_type, vars_df, cols):
         Variables lookup table
     cols : list
         Names of columns to populate
-    
+
     Returns
     -------
     ds : xr.Dataset
@@ -505,10 +533,10 @@ def _popCols(ds, booms, data_type, vars_df, cols):
 
     elif booms==2:
         names = vars_df.loc[(vars_df[cols[0]]!='one-boom')]
-       
+
     for v in list(names.index):
         if v not in list(ds.variables):
-            ds[v] = (('time'), np.arange(ds['time'].size)*np.nan)      
+            ds[v] = (('time'), np.arange(ds['time'].size)*np.nan)
     return ds
 
 # def _popCols(ds, booms, data_type, vars_df, cols):
@@ -517,20 +545,20 @@ def _popCols(ds, booms, data_type, vars_df, cols):
 #             names = vars_df.loc[(vars_df[cols[0]]!='two-boom')]
 #         else:
 #             names = vars_df.loc[(vars_df[cols[0]] != 'two-boom') & vars_df[cols[1]] != 'tx']
-    
+
 #     elif booms==2:
 #         if data_type !='TX':
 #             names = vars_df.loc[(vars_df[cols[0]]!='two-boom')]
 #         else:
 #             names = vars_df.loc[(vars_df[cols[0]] != 'two-boom') & vars_df[cols[1]] != 'tx']
-       
+
 #     for v in list(names.index):
 #         if v not in list(ds.variables):
-#             ds[v] = (('time'), np.arange(ds['time'].size)*np.nan)      
+#             ds[v] = (('time'), np.arange(ds['time'].size)*np.nan)
 #     return ds
 
 #------------------------------------------------------------------------------
 
-if __name__ == "__main__": 
-    # unittest.main() 
-    pass    
+if __name__ == "__main__":
+    # unittest.main()
+    pass

pypromice/process/L1toL2.py

@@ -13,6 +13,7 @@ from pypromice.qc.github_data_issues import flagNAN, adjustTime, adjustData
 from pypromice.qc.percentiles.outlier_detector import ThresholdBasedOutlierDetector
 from pypromice.qc.persistence import persistence_qc
 from pypromice.process.value_clipping import clip_values
+from pypromice.process import wind
 
 __all__ = [
     "toL2",
@@ -29,8 +30,6 @@ def toL2(
     T_0=273.15,
     ews=1013.246,
     ei0=6.1071,
-    eps_overcast=1.0,
-    eps_clear=9.36508e-6,
     emissivity=0.97,
 ) -> xr.Dataset:
     '''Process one Level 1 (L1) product to Level 2.
@@ -72,7 +71,7 @@ def toL2(
     ds : xarray.Dataset
         Level 2 dataset
     '''
-    ds = L1.copy(deep=True)                                                    # Reassign dataset
+    ds = L1.copy()                                                    # Reassign dataset
     ds.attrs['level'] = 'L2'
     try:
         ds = adjustTime(ds, adj_dir=data_adjustments_dir.as_posix())       # Adjust time after a user-defined csv files
@@ -114,17 +113,83 @@ def toL2(
             ds['rh_i_wrt_ice_or_water'] = adjustHumidity(ds['rh_i'], ds['t_i'],
                                              T_0, T_100, ews, ei0)
 
-    # Determiune cloud cover for on-ice stations
-    cc = calcCloudCoverage(ds['t_u'], T_0, eps_overcast, eps_clear,        # Calculate cloud coverage
-                           ds['dlr'], ds.attrs['station_id'])
-    ds['cc'] = (('time'), cc.data)
-
     # Determine surface temperature
-    ds['t_surf'] = calcSurfaceTemperature(T_0, ds['ulr'], ds['dlr'],           # Calculate surface temperature
+    ds['t_surf'] = calcSurfaceTemperature(T_0, ds['ulr'], ds['dlr'],
                                           emissivity)
-    if not ds.attrs['bedrock']:
-        ds['t_surf'] = xr.where(ds['t_surf'] > 0, 0, ds['t_surf'])
+    is_bedrock = ds.attrs['bedrock']
+    if not is_bedrock:
+        ds['t_surf'] = ds['t_surf'].clip(max=0)
+
+    # smoothing tilt and rot
+    ds['tilt_x'] = smoothTilt(ds['tilt_x'])
+    ds['tilt_y'] = smoothTilt(ds['tilt_y'])
+    ds['rot'] = smoothRot(ds['rot'])
+
+    # Determiune cloud cover for on-ice stations
+    if not is_bedrock:
+        ds['cc'] = calcCloudCoverage(ds['t_u'], ds['dlr'], ds.attrs['station_id'], T_0)
+    else:
+        ds['cc'] = ds['t_u'].copy() * np.nan
+
+    # Filtering and correcting shortwave radiation
+    ds, _ = process_sw_radiation(ds)
 
+    # Correct precipitation
+    if hasattr(ds, 'correct_precip'):
+        precip_flag = ds.attrs['correct_precip']
+    else:
+        precip_flag=True
+    if ~ds['precip_u'].isnull().all() and precip_flag:
+        ds['precip_u_cor'], ds['precip_u_rate'] = correctPrecip(ds['precip_u'],
+                                                                ds['wspd_u'])
+    if ds.attrs['number_of_booms']==2:
+        if ~ds['precip_l'].isnull().all() and precip_flag:                     # Correct precipitation
+            ds['precip_l_cor'], ds['precip_l_rate']= correctPrecip(ds['precip_l'],
+                                                                   ds['wspd_l'])
+
+    # Calculate directional wind speed for upper boom
+    ds['wdir_u'] = wind.filter_wind_direction(ds['wdir_u'],
+                                              ds['wspd_u'])
+    ds['wspd_x_u'], ds['wspd_y_u'] = wind.calculate_directional_wind_speed(ds['wspd_u'],
+                                                                           ds['wdir_u'])
+    
+    # Calculate directional wind speed for lower boom
+    if ds.attrs['number_of_booms'] == 2:
+        ds['wdir_l'] = wind.filter_wind_direction(ds['wdir_l'],
+                                                  ds['wspd_l'])
+        ds['wspd_x_l'], ds['wspd_y_l'] = wind.calculate_directional_wind_speed(ds['wspd_l'],
+
+                                                                               ds['wdir_l'])
+    # Calculate directional wind speed for instantaneous measurements
+    if hasattr(ds, 'wdir_i'):
+        if ~ds['wdir_i'].isnull().all() and ~ds['wspd_i'].isnull().all():
+            ds['wdir_i'] = wind.filter_wind_direction(ds['wdir_i'],
+                                                      ds['wspd_i'])
+            ds['wspd_x_i'], ds['wspd_y_i'] = wind.calculate_directional_wind_speed(ds['wspd_i'],
+                                                                                   ds['wdir_i'])
+            # Get directional wind speed
+
+    ds = clip_values(ds, vars_df)
+    
+    return ds
+
+def process_sw_radiation(ds):
+    """
+    Processes shortwave radiation data from a dataset by applying tilt and sun
+    angle corrections.
+
+    Parameters:
+        ds (xarray.Dataset): Dataset containing variables such as time, tilt_x,
+                tilt_y, dsr (downwelling SW radiation), usr (upwelling SW radiation),
+                cloud cover (cc), gps_lat, gps_lon, and optional attributes
+                 latitude and longitude.
+
+    Returns:
+        ds (xarray.Dataset): Updated dataset with corrected downwelling ('dsr_cor')
+                and upwelling ('usr_cor') SW radiation, and derived surface albedo ('albedo').
+        tuple: A tuple containing masks and calculated TOA radiation:
+               (OKalbedos, sunonlowerdome, bad, isr_toa, TOA_crit_nopass)
+    """
     # Determine station position relative to sun
     doy = ds['time'].to_dataframe().index.dayofyear.values                     # Gather variables to calculate sun pos
     hour = ds['time'].to_dataframe().index.hour.values
@@ -137,11 +202,6 @@ def toL2(
         lat = ds['gps_lat'].mean()
         lon = ds['gps_lon'].mean()
 
-    # smoothing tilt and rot
-    ds['tilt_x'] = smoothTilt(ds['tilt_x'])
-    ds['tilt_y'] = smoothTilt(ds['tilt_y'])
-    ds['rot'] = smoothRot(ds['rot'])
-
     deg2rad, rad2deg = _getRotation()                                          # Get degree-radian conversions
     phi_sensor_rad, theta_sensor_rad = calcTilt(ds['tilt_x'], ds['tilt_y'],    # Calculate station tilt
                                                 deg2rad)
@@ -152,108 +212,64 @@ def toL2(
                                                   HourAngle_rad, deg2rad,
                                                   rad2deg)
 
+    # Setting to zero when sun below the horizon.
+    bad = ZenithAngle_deg > 95
+    ds['dsr'][bad & ds['dsr'].notnull()] = 0
+    ds['usr'][bad & ds['usr'].notnull()] = 0
 
-    # Correct Downwelling shortwave radiation
-    DifFrac = 0.2 + 0.8 * cc
-    CorFac_all = calcCorrectionFactor(Declination_rad, phi_sensor_rad,         # Calculate correction
-                                      theta_sensor_rad, HourAngle_rad,
-                                      ZenithAngle_rad, ZenithAngle_deg,
-                                      lat, DifFrac, deg2rad)
-    CorFac_all = xr.where(ds['cc'].notnull(), CorFac_all, 1)
-    ds['dsr_cor'] = ds['dsr'].copy(deep=True) * CorFac_all                     # Apply correction
+    # Setting to zero when values are negative
+    ds['dsr'] = ds['dsr'].clip(min=0)
+    ds['usr'] = ds['usr'].clip(min=0)
 
-    AngleDif_deg = calcAngleDiff(ZenithAngle_rad, HourAngle_rad,               # Calculate angle between sun and sensor
+    # Calculate angle between sun and sensor
+    AngleDif_deg = calcAngleDiff(ZenithAngle_rad, HourAngle_rad,
                                  phi_sensor_rad, theta_sensor_rad)
-
-    ds['albedo'], OKalbedos = calcAlbedo(ds['usr'], ds['dsr_cor'],             # Determine albedo
-                              AngleDif_deg, ZenithAngle_deg)
-
-    # Correct upwelling and downwelling shortwave radiation
-    sunonlowerdome =(AngleDif_deg >= 90) & (ZenithAngle_deg <= 90)             # Determine when sun is in FOV of lower sensor, assuming sensor measures only diffuse radiation
-    ds['dsr_cor'] = ds['dsr_cor'].where(~sunonlowerdome,
-                                        other=ds['dsr'] / DifFrac)             # Apply to downwelling
-    ds['usr_cor'] = ds['usr'].copy(deep=True)
-    ds['usr_cor'] = ds['usr_cor'].where(~sunonlowerdome,
-                                        other=ds['albedo'] * ds['dsr'] / DifFrac) # Apply to upwelling
-    bad = (ZenithAngle_deg > 95) | (ds['dsr_cor'] <= 0) | (ds['usr_cor'] <= 0) # Set to zero for solar zenith angles larger than 95 deg or either values are (less than) zero
-    ds['dsr_cor'][bad] = 0
-    ds['usr_cor'][bad] = 0
-    ds['dsr_cor'] = ds['usr_cor'].copy(deep=True) / ds['albedo']               # Correct DWR using more reliable USWR when sun not in sight of upper sensor
-    ds['albedo'] = ds['albedo'].where(OKalbedos)                               #TODO remove?
-
-    # Remove data where TOA shortwave radiation invalid
+    tilt_correction_possible = AngleDif_deg.notnull() & ds['cc'].notnull()
+
+    # Filtering usr and dsr for sun on lower dome
+    # in theory, this is not a problem in cloudy conditions, but the cloud cover
+    # index is too uncertain at this point to be used
+    sunonlowerdome = (AngleDif_deg >= 90) & (ZenithAngle_deg <= 90)
+    mask = ~sunonlowerdome | AngleDif_deg.isnull()                             # relaxing the filter for cases where sensor tilt is unknown
+    ds['dsr'] = ds['dsr'].where(mask)
+    ds['usr'] = ds['usr'].where(mask)
+
+    # Filter dsr values that are greater than top of the atmosphere irradiance
+    # Case where no tilt is available. If it is, then the same filter is used
+    # after tilt correction.
     isr_toa = calcTOA(ZenithAngle_deg, ZenithAngle_rad)                        # Calculate TOA shortwave radiation
-    TOA_crit_nopass = (ds['dsr_cor'] > (0.9 * isr_toa + 10))                   # Determine filter
-    ds['dsr_cor'][TOA_crit_nopass] = np.nan                                    # Apply filter and interpolate
-    ds['usr_cor'][TOA_crit_nopass] = np.nan
-
-    ds['dsr_cor'] = ds.dsr_cor.where(ds.dsr.notnull())
-    ds['usr_cor'] = ds.usr_cor.where(ds.usr.notnull())
-    # # Check sun position
-    # sundown = ZenithAngle_deg >= 90
-    # _checkSunPos(ds, OKalbedos, sundown, sunonlowerdome, TOA_crit_nopass)
-
-    if hasattr(ds, 'correct_precip'):                                          # Correct precipitation
-        precip_flag=ds.attrs['correct_precip']
-    else:
-        precip_flag=True
-    if ~ds['precip_u'].isnull().all() and precip_flag:
-        ds['precip_u_cor'], ds['precip_u_rate'] = correctPrecip(ds['precip_u'],
-                                                                ds['wspd_u'])
-    if ds.attrs['number_of_booms']==2:
-        if ~ds['precip_l'].isnull().all() and precip_flag:                     # Correct precipitation
-            ds['precip_l_cor'], ds['precip_l_rate']= correctPrecip(ds['precip_l'],
-                                                                   ds['wspd_l'])
-
-    get_directional_wind_speed(ds)                                            # Get directional wind speed
-
-    ds = clip_values(ds, vars_df)
-    return ds
-
-def get_directional_wind_speed(ds: xr.Dataset) -> xr.Dataset:
-    """
-    Calculate directional wind speed from wind speed and direction and mutates the dataset
-    """
-
-    ds['wdir_u'] = ds['wdir_u'].where(ds['wspd_u'] != 0)
-    ds['wspd_x_u'], ds['wspd_y_u'] = calcDirWindSpeeds(ds['wspd_u'], ds['wdir_u'])
+    TOA_crit_nopass = ~tilt_correction_possible & (ds['dsr'] > (1.2 * isr_toa + 150))
+    ds['dsr'][TOA_crit_nopass] = np.nan
 
-    if ds.attrs['number_of_booms']==2:
-        ds['wdir_l'] = ds['wdir_l'].where(ds['wspd_l'] != 0)
-        ds['wspd_x_l'], ds['wspd_y_l'] = calcDirWindSpeeds(ds['wspd_l'], ds['wdir_l'])
+    # the upward flux should not be higher than the TOA downard flux
+    TOA_crit_nopass_usr = (ds['usr'] > 0.8*(1.2 * isr_toa + 150))
+    ds['usr'][TOA_crit_nopass_usr] = np.nan
 
-    if hasattr(ds, 'wdir_i'):
-        if ~ds['wdir_i'].isnull().all() and ~ds['wspd_i'].isnull().all():
-            ds['wdir_i'] = ds['wdir_i'].where(ds['wspd_i'] != 0)
-            ds['wspd_x_i'], ds['wspd_y_i'] = calcDirWindSpeeds(ds['wspd_i'], ds['wdir_i'])
-    return ds
+    # Diffuse to direct irradiance fraction
+    DifFrac = 0.2 + 0.8 * ds['cc']
+    CorFac_all = calcCorrectionFactor(Declination_rad, phi_sensor_rad,         # Calculate correction
+                                      theta_sensor_rad, HourAngle_rad,
+                                      ZenithAngle_rad, ZenithAngle_deg,
+                                      lat, DifFrac, deg2rad)
+    CorFac_all = CorFac_all.where(tilt_correction_possible)
 
+    # Correct Downwelling shortwave radiation
+    ds['dsr_cor'] = ds['dsr'].copy() * CorFac_all
+    ds['usr_cor'] = ds['usr'].copy().where(ds['dsr_cor'].notnull())
 
-def calcDirWindSpeeds(wspd, wdir, deg2rad=np.pi/180):
-    '''Calculate directional wind speed from wind speed and direction
+    # Remove data where TOA shortwave radiation invalid
+    # this can only be done after correcting for tilt
+    TOA_crit_nopass_cor = ds['dsr_cor'] > (1.2 * isr_toa + 150)
+    ds['dsr_cor'][TOA_crit_nopass_cor] = np.nan
+    ds['usr_cor'][TOA_crit_nopass_cor] = np.nan
 
-    Parameters
-    ----------
-    wspd : xr.Dataarray
-        Wind speed data array
-    wdir : xr.Dataarray
-        Wind direction data array
-    deg2rad : float
-        Degree to radians coefficient. The default is np.pi/180
+    ds, OKalbedos = calcAlbedo(ds, AngleDif_deg, ZenithAngle_deg)
 
-    Returns
-    -------
-    wspd_x : xr.Dataarray
-        Wind speed in X direction
-    wspd_y : xr.Datarray
-        Wind speed in Y direction
-    '''
-    wspd_x = wspd * np.sin(wdir * deg2rad)
-    wspd_y = wspd * np.cos(wdir * deg2rad)
-    return wspd_x, wspd_y
+    return ds, (OKalbedos, sunonlowerdome, bad, isr_toa, TOA_crit_nopass_cor, TOA_crit_nopass, TOA_crit_nopass_usr)
 
 
-def calcCloudCoverage(T, T_0, eps_overcast, eps_clear, dlr, station_id):
+def calcCloudCoverage(T, dlr, station_id,T_0, eps_overcast=1.0,
+    eps_clear=9.36508e-6):
     '''Calculate cloud cover from T and T_0
 
     Parameters
@@ -291,6 +307,7 @@ def calcCloudCoverage(T, T_0, eps_overcast, eps_clear, dlr, station_id):
     cc = (dlr - LR_clear) / (LR_overcast - LR_clear)
     cc[cc > 1] = 1
     cc[cc < 0] = 0
+
     return cc
 
 
@@ -414,12 +431,10 @@ def calcTilt(tilt_x, tilt_y, deg2rad):
 
     # Total tilt of the sensor, i.e. 0 when horizontal
     theta_sensor_rad = np.arccos(Z / (X**2 + Y**2 + Z**2)**0.5)
-    # phi_sensor_deg = phi_sensor_rad * rad2deg                                #TODO take these out if not needed
-    # theta_sensor_deg = theta_sensor_rad * rad2deg
     return phi_sensor_rad, theta_sensor_rad
 
 
-def adjustHumidity(rh, T, T_0, T_100, ews, ei0):                        #TODO figure out if T replicate is needed
+def adjustHumidity(rh, T, T_0, T_100, ews, ei0):
     '''Adjust relative humidity so that values are given with respect to
     saturation over ice in subfreezing conditions, and with respect to
     saturation over water (as given by the instrument) above the melting
@@ -655,42 +670,41 @@ def calcAngleDiff(ZenithAngle_rad, HourAngle_rad, phi_sensor_rad,
                                    + np.cos(ZenithAngle_rad)
                                    * np.cos(theta_sensor_rad))
 
-def calcAlbedo(usr, dsr_cor, AngleDif_deg, ZenithAngle_deg):
-    '''Calculate surface albedo based on upwelling and downwelling shorwave
-    flux, the angle between the sun and sensor, and the sun zenith
+
+def calcAlbedo(ds, AngleDif_deg, ZenithAngle_deg):
+    '''
+    Calculate surface albedo based on upwelling and downwelling shortwave
+    flux, the angle between the sun and sensor, and the sun zenith angle.
 
     Parameters
     ----------
-    usr : xarray.DataArray
-        Upwelling shortwave radiation
-    dsr_cor : xarray.DataArray
-        Downwelling shortwave radiation corrected
-    AngleDif_def : float
-        Angle between sun and sensor in degrees
-    ZenithAngle_deg: float
-        Zenith angle in degrees
+    ds : xarray.Dataset
+        Dataset containing 'usr' (upwelling shortwave), 'dsr_cor' (corrected downwelling shortwave),
+        and optionally 'dsr' (uncorrected downwelling shortwave) and 'cc' (cloud cover).
+    AngleDif_deg : xarray.DataArray
+        Angle between the sun and the sensor in degrees.
+    ZenithAngle_deg : xarray.DataArray
+        Sun zenith angle in degrees.
 
     Returns
     -------
-    albedo : xarray.DataArray
-        Derived albedo
+    ds : xarray.Dataset
+        Input dataset with a new 'albedo' variable added.
     OKalbedos : xarray.DataArray
-        Valid albedo measurements
+        Boolean mask indicating valid albedo values.
     '''
-    albedo = usr / dsr_cor
+    tilt_correction_possible = AngleDif_deg.notnull() & ds['cc'].notnull()
 
-    # NaN bad data
-    OKalbedos = (AngleDif_deg < 70) & (ZenithAngle_deg < 70) & (albedo < 1) & (albedo > 0)
-    albedo[~OKalbedos] = np.nan
-
-    # Interpolate all. Note "use_coordinate=False" is used here to force
-    # comparison against the GDL code when that is run with *only* a TX file.
-    # Should eventually set to default (True) and interpolate based on time,
-    # not index.
-    albedo = albedo.interpolate_na(dim='time', use_coordinate=False)
-    albedo = albedo.ffill(dim='time').bfill(dim='time')                        #TODO remove this line and one above?
-    return albedo, OKalbedos
+    ds['albedo'] = xr.where(tilt_correction_possible,
+                            ds['usr'] / ds['dsr_cor'],
+                            ds['usr'] / ds['dsr'])
 
+    OOL = (ds['albedo']  >= 1) | (ds['albedo']  <= 0)
+    good_zenith_angle = ZenithAngle_deg < 70
+    good_relative_zenith_angle = (AngleDif_deg < 70) | (AngleDif_deg.isnull())
+    OKalbedos = good_relative_zenith_angle & good_zenith_angle & ~OOL
+    ds['albedo'] = ds['albedo'].where(OKalbedos)
+    return ds, OKalbedos
 
 def calcTOA(ZenithAngle_deg, ZenithAngle_rad):
     '''Calculate incoming shortwave radiation at the top of the atmosphere,
@@ -780,37 +794,8 @@ def calcCorrectionFactor(Declination_rad, phi_sensor_rad, theta_sensor_rad,
     # Calculating ds['dsr'] over a horizontal surface corrected for station/sensor tilt
     CorFac_all = CorFac / (1 - DifFrac + CorFac * DifFrac)
 
-    return CorFac_all
-
-
-def _checkSunPos(ds, OKalbedos, sundown, sunonlowerdome, TOA_crit_nopass):
-    '''Check sun position
+    return CorFac_all.where(theta_sensor_rad.notnull())
 
-    Parameters
-    ----------
-    ds : xarray.Dataset
-        Data set
-    OKalbedos : xarray.DataArray
-        Valid measurements flag
-    sundown : xarray.DataArray
-        Sun below horizon flag
-    sunonlowerdome : xarray.DataArray
-        Sun in view of lower sensor flag
-    TOA_crit_nopass : xarray.DataArray
-        Top-of-Atmosphere flag
-    '''
-    valid = (~(ds['dsr_cor'].isnull())).sum()
-    print('Sun in view of upper sensor / workable albedos:', OKalbedos.sum().values,
-          (100*OKalbedos.sum()/valid).round().values, "%")
-    print('Sun below horizon:', sundown.sum(),
-          (100*sundown.sum()/valid).round().values, "%")
-    print('Sun in view of lower sensor:', sunonlowerdome.sum().values,
-          (100*sunonlowerdome.sum()/valid).round().values, "%")
-    print('Spikes removed using TOA criteria:', TOA_crit_nopass.sum().values,
-          (100*TOA_crit_nopass.sum()/valid).round().values, "%")
-    print('Mean net SR change by corrections:',
-          (ds['dsr_cor']-ds['usr_cor']-ds['dsr']+ds['usr']).sum().values/valid.values,
-          "W/m2")
 
 def _getTempK(T_0):                                                            #TODO same as L2toL3._getTempK()
     '''Return steam point temperature in Kelvins

pypromice/process/L2toL3.py

@@ -41,6 +41,8 @@ def toL3(L2,
 
     T_100 = T_0+100                                                            # Get steam point temperature as K
 
+    is_bedrock = (str(ds.attrs['bedrock']).lower() == 'true')
+
     # Turbulent heat flux calculation
     if ('t_u' in ds.keys()) and \
         ('p_u' in ds.keys()) and \
@@ -59,7 +61,7 @@ def toL3(L2,
             z_WS_u = ds['z_boom_u'].copy() + 0.4                                       # Get height of Anemometer
             z_T_u = ds['z_boom_u'].copy() - 0.1                                        # Get height of thermometer
 
-            if not ds.attrs['bedrock']:
+            if not is_bedrock:
                 SHF_h_u, LHF_h_u= calculate_tubulent_heat_fluxes(T_0, T_h_u, Tsurf_h, WS_h_u,            # Calculate latent and sensible heat fluxes
                                                 z_WS_u, z_T_u, q_h_u, p_h_u)
 
@@ -90,7 +92,8 @@ def toL3(L2,
                 z_WS_l = ds['z_boom_l'].copy() + 0.4                                   # Get height of W
                 z_T_l = ds['z_boom_l'].copy() - 0.1                                    # Get height of thermometer
                 WS_h_l = ds['wspd_l'].copy()
-                if not ds.attrs['bedrock']:
+
+                if not is_bedrock:
                     SHF_h_l, LHF_h_l= calculate_tubulent_heat_fluxes(T_0, T_h_l, Tsurf_h, WS_h_l, # Calculate latent and sensible heat fluxes
                                                     z_WS_l, z_T_l, q_h_l, p_h_l)
 

pypromice/process/resample.py

@@ -8,7 +8,7 @@ Created on Mon Jun 10 10:58:39 2024
 import logging
 import numpy as np
 import xarray as xr
-from pypromice.process.L1toL2 import calcDirWindSpeeds
+from pypromice.process.wind import calculate_directional_wind_speed
 logger = logging.getLogger(__name__)
 
 def resample_dataset(ds_h, t):
@@ -81,7 +81,7 @@ def resample_dataset(ds_h, t):
                 df_d[var] = _calcWindDir(df_d['wspd_x_'+boom], df_d['wspd_y_'+boom])
             else:
                 logger.info(var+' in dataframe but not wspd_x_'+boom+' nor wspd_y_'+boom+', recalculating them')
-                ds_h['wspd_x_'+boom], ds_h['wspd_y_'+boom] = calcDirWindSpeeds(ds_h['wspd_'+boom], ds_h['wdir_'+boom])
+                ds_h['wspd_x_'+boom], ds_h['wspd_y_'+boom] = calculate_directional_wind_speed(ds_h['wspd_'+boom], ds_h['wdir_'+boom])
                 df_d[['wspd_x_'+boom, 'wspd_y_'+boom]] = ds_h[['wspd_x_'+boom, 'wspd_y_'+boom]].to_dataframe().resample(t).mean()
                 df_d[var] = _calcWindDir(df_d['wspd_x_'+boom], df_d['wspd_y_'+boom])
     

pypromice/process/wind.py

@@ -0,0 +1,66 @@
+__all__=['correct_wind_speed', 'filter_wind_direction', 'calculate_directional_wind_speed']
+
+import numpy as np
+import xarray as xr
+
+DEG2RAD=np.pi/180
+
+def correct_wind_speed(wspd: xr.DataArray, coefficient) -> xr.DataArray:
+    """Correct wind speed with a linear correction coefficient. For example, the conversion from a standard
+    Young anemometer to an Arctic Young anemometer is 1.7.
+
+    Parameters
+    ----------
+    wspd : xr.DataArray
+        Wind speed
+    coefficient : float
+        Correction coefficient
+
+    Returns
+    -------
+    xr.DataArray
+        Corrected wind speed
+    """
+    return wspd * coefficient
+
+def filter_wind_direction(wdir: xr.DataArray, wspd: xr.DataArray) -> xr.DataArray:
+    """Filter wind direction by wind speed, where wind direction values are removed if
+    wind speed is zero.
+
+    Parameters
+    ----------
+    wdir : xr.DataArray
+        Wind direction
+    wspd : xr.DataArray
+        Wind speed
+
+    Returns
+    -------
+    xr.DataArray
+        Filtered wind direction
+    """
+    return wdir.where(wspd != 0)
+
+
+def calculate_directional_wind_speed(wspd: xr.DataArray, wdir: xr.DataArray):
+    """Calculate directional wind speed from wind speed and direction
+
+    Parameters
+    ----------
+    wspd : xr.DataArray
+        Wind speed data array
+    wdir : xr.DataArray
+        Wind direction data array
+    deg2rad : float
+        Degree to radians coefficient. The default is np.pi/180
+
+    Returns
+    -------
+    wspd_x : xr.DataArray
+        Wind speed in X direction
+    wspd_y : xr.DatArray
+        Wind speed in Y direction
+    """
+    wspd_x = wspd * np.sin(wdir * DEG2RAD)
+    wspd_y = wspd * np.cos(wdir * DEG2RAD)
+    return wspd_x, wspd_y

pypromice/tx/tx.py

@@ -454,9 +454,13 @@ class L0tx(EmailMessage, PayloadFormat):
         bool
             Valid format flag
         '''
+      
         if self.getFirstByte().isdigit() or (self.payload[:2] == '\n' and self.imei == 300234064121930):     #TODO needed?
             return None, None, None, None, -9999, False
         
+        elif self.email_data['subject'].startswith("Data from station"):
+            return None, None, None, None, -9999, False    
+        
         elif 'watson' in self.email_data['subject'].lower() or 'gios' in self.email_data['subject'].lower():
             return None, None, None, None, -9999, False    
        

{pypromice-1.5.1.dist-info → pypromice-1.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pypromice
-Version: 1.5.1
+Version: 1.5.3
 Summary: PROMICE/GC-Net data processing toolbox
 Home-page: https://github.com/GEUS-Glaciology-and-Climate/pypromice
 Author: GEUS Glaciology and Climate
@@ -34,6 +34,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python

{pypromice-1.5.1.dist-info → pypromice-1.5.3.dist-info}/RECORD

@@ -11,9 +11,9 @@ pypromice/postprocess/get_bufr.py,sha256=98BZ7tTbmvvrVAzhxJ8LgHib3w7Q3S_x757pCub
 pypromice/postprocess/make_metadata_csv.py,sha256=lUw8fZC6dzG10IePZ4d7eZIrTbquHYCDuppYP4r_dF0,9776
 pypromice/postprocess/positions_seed.csv,sha256=0kVCQ8UfEALdeXNYCddmwxpseRqLRudbFStqp_bZRBw,224
 pypromice/postprocess/real_time_utilities.py,sha256=2GZUua5R8ocp-TnIjEA4ig8lC4TlI3SkiimzLxoHXFE,9476
-pypromice/process/L0toL1.py,sha256=aQmVEXhtRisHNrJuPGIg7NA4hjjmV9jUBu1DClRIGzs,23175
-pypromice/process/L1toL2.py,sha256=PM6lToL-WXbZk5p2m90XCxY9S_RNNV1QUB3klZlQDzc,30832
-pypromice/process/L2toL3.py,sha256=XqnUGKO17ADJkTOn0p8TESeCAKQGtPXpFadNfF52g6E,61378
+pypromice/process/L0toL1.py,sha256=U7TLoB3UfV7BcR4iReVA1FheR1WD_OBXk0faBV3QEW0,24022
+pypromice/process/L1toL2.py,sha256=0xy54wmTetZKpQ4NkqTb57tt4ERuONMbvwFMncaOrjU,30174
+pypromice/process/L2toL3.py,sha256=P7abSejGmq22L9Urv78K0wXnevG05GDGvnhabTMQql8,61424
 pypromice/process/__init__.py,sha256=xvd0I-9nIyVw4M4qjgkQ5vXYpNuKcVSkIVIROQsZDo0,147
 pypromice/process/aws.py,sha256=5N4rLptO23Ic9mgyR5K8NhtNmGPa9xb9Cu7SgzAgoi8,7561
 pypromice/process/get_l2.py,sha256=ALXJCMJ8qgg0_dEKx-dV5TQ9IAJnLLLGPUxlr5QVfpk,3076
@@ -21,9 +21,10 @@ pypromice/process/get_l2tol3.py,sha256=4Qu2d5rT25H2dObyCc70ivtJg3vw6WA-hzI-kRD6y
 pypromice/process/join_l2.py,sha256=ifjuhFR9scVvZt3xuy-ELp-iRchxV1dEK9qJ4UNh5bE,4567
 pypromice/process/join_l3.py,sha256=F90uvcy85iSl6GWxyj6C3K4j2eAoQvhQB8XqOXpShvo,20221
 pypromice/process/load.py,sha256=iaFvJeaDanAA60caVj4BWupZpqgQNj3CiNU4csz9FdU,4585
-pypromice/process/resample.py,sha256=VhcQ0UD5LkqFPHlwEFmwYIz3kLkUfvxTenxYadmCsSE,7301
+pypromice/process/resample.py,sha256=yydbsSQeUpTSyrsY3tZN0uZzp0Ddbe5HKrW-onB3Yos,7329
 pypromice/process/utilities.py,sha256=1pqSaF3bIbvRNtOjb25mbegHfuW9MY4KpCBDVXWyML8,1773
 pypromice/process/value_clipping.py,sha256=_pTAxogsqfkjwBQslGyyE3jZzhYY6_Wp-g5ZPHcudMc,1506
+pypromice/process/wind.py,sha256=-dpaBOtqGyPDIU4O1HbbWRzlLNRC2a50OdnZhIaWdeI,1701
 pypromice/process/write.py,sha256=ZpA9NAgtnzJIbnjEiJ0sOtsE0J1haHASbjHqzMvBDJE,15818
 pypromice/qc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pypromice/qc/github_data_issues.py,sha256=gbbF62oMMWbXiLnsrs60vXbwfAqSUP113plhidVeqCU,13353
@@ -41,13 +42,13 @@ pypromice/tx/get_l0tx.py,sha256=b34-96KGshTyTN2tBFaAIBl7oZZzbRB_JR7sXtDNfXA,6957
 pypromice/tx/get_msg.py,sha256=OGS60OHjy4Wf8JExTfOdK-9xhjFdjhuChxoTSPe_MjI,3417
 pypromice/tx/payload_formats.csv,sha256=A46-XcYdpe9-gzmADylP2UVizLi_UphF-BPT5u3Lyn8,7903
 pypromice/tx/payload_types.csv,sha256=C1-xCmHytAqqAzgzPwBLWqabzWu6s6tKAd8AjVd935s,457
-pypromice/tx/tx.py,sha256=mghUjwGqUKe_4JWuAEgWMyH4ME2QRufeMPPHoL72R08,34267
+pypromice/tx/tx.py,sha256=asbgXVI5vurKM-WVACTfpKRt-70wtzVvSbvjvYufajI,34416
 pypromice/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pypromice/utilities/dependency_graph.py,sha256=bqoXasC8pg5ipjBd6rqDhfHwIq11t2_cFlNT72ncw4w,3135
 pypromice/utilities/git.py,sha256=7EUGjDs_VZucrckakXKyZEclDAZ_mKIxhTWzhopCIxM,1785
-pypromice-1.5.1.dist-info/LICENSE.txt,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
-pypromice-1.5.1.dist-info/METADATA,sha256=Pk2LL4EmF_PBWe5VSaNo5uWyVINQO2FA68DKf6Xzyl0,4970
-pypromice-1.5.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-pypromice-1.5.1.dist-info/entry_points.txt,sha256=ufX1npmY3nqMPtSVRKVxn3MhG9IyFHD5FjPZQcELVXo,618
-pypromice-1.5.1.dist-info/top_level.txt,sha256=cBdfwgSbWDQq3a07nKRjrfmLC7jdaYXs98GG58HpTks,10
-pypromice-1.5.1.dist-info/RECORD,,
+pypromice-1.5.3.dist-info/licenses/LICENSE.txt,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+pypromice-1.5.3.dist-info/METADATA,sha256=-WPlDUHP4MXavNOtyK8ANhUD486iYbaPArw-V4Vt4fQ,4992
+pypromice-1.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pypromice-1.5.3.dist-info/entry_points.txt,sha256=ufX1npmY3nqMPtSVRKVxn3MhG9IyFHD5FjPZQcELVXo,618
+pypromice-1.5.3.dist-info/top_level.txt,sha256=cBdfwgSbWDQq3a07nKRjrfmLC7jdaYXs98GG58HpTks,10
+pypromice-1.5.3.dist-info/RECORD,,

{pypromice-1.5.1.dist-info → pypromice-1.5.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any