wolfhece 2.2.6__py3-none-any.whl → 2.2.7__py3-none-any.whl

wolfhece/PyVertex.py

@@ -178,6 +178,28 @@ class wolfvertex:
             self.values = {}
         self.values[id] = value
 
+    def add_value(self, id, value):
+        """
+        Add a set of values to the vertex
+
+        :param id: key of the value
+        :param value: value to add
+        """
+
+        self.addvalue(id, value)
+
+    def add_values(self, values:dict):
+        """
+        Add a set of values to the vertex
+
+        :param values: dictionary of values to add
+        """
+
+        if self.values is None:
+            self.values = {}
+        for key, value in values.items():
+            self.values[key] = value
+
     def getvalue(self, id):
         """
         Return a value from the vertex
@@ -191,6 +213,27 @@ class wolfvertex:
             else:
                 return None
 
+    def get_value(self, id):
+        """
+        Return a set of values from the vertex
+
+        :param id: key of the value
+        """
+
+        return self.getvalue(id)
+
+    def get_values(self, ids:list) -> dict:
+        """
+        Return a set of values from the vertex
+        """
+
+        ret = {}
+        for id in ids:
+            if id in self.values.keys():
+                ret[id] = self.values[id]
+
+        return ret
+
     def limit2bounds(self, bounds=None):
         """
         Limit the vertex to a set of bounds

wolfhece/__init__.py

@@ -1 +1,12 @@
-from . import _add_path
+from . import _add_path
+
+try:
+    from osgeo import gdal, osr
+    gdal.UseExceptions()
+except ImportError as e:
+    print(e)
+    raise Exception(_('Error importing GDAL library'))
+
+from .apps.version import WolfVersion
+
+__version__ = WolfVersion().get_version()

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 6
+        self.patch = 7
 
     def __str__(self):
 

wolfhece/drowning_victims/drowning_functions.py

@@ -4,7 +4,6 @@ import math
 from scipy.stats import beta
 from scipy.optimize import fsolve
 import random
-from wolfgpu.glsimulation import ResultsStore
 from pathlib import Path
 import json
 import wx
@@ -12,6 +11,11 @@ import queue
 import os
 import logging
 
+try:
+    from wolfgpu.glsimulation import ResultsStore
+except ImportError:
+    print("wolfgpu not available")
+
 EPS = 0.15
 G = [0, 0, -9.81]
 P_ATM = 101325  # Pa
@@ -19,7 +23,7 @@ RHO_F = 1000
 
 def beta_find(x, *data):
     """
-    Iterative function that finds the parameters alpha and beta defining a beta distribution and scales it in a range. 
+    Iterative function that finds the parameters alpha and beta defining a beta distribution and scales it in a range.
     The function fits the parameters based on two given percentiles of the data.
 
     :param x: Array containing initial guesses for alpha and beta.
@@ -47,7 +51,7 @@ def beta_find(x, *data):
 
 def Body_motion(a_RK, batch_turb, CFL, Delta, epsilon, H_pre, H_post, Human, k, NbX, NbY, Pos_bp, resurface, sinking, time_b, t_Wolf_pre, t_Wolf_post, time_goal, U_bp, Ux_pre, Ux_post, Uy_pre, Uy_post, Z_param):
     """
-    Function calculating the motion of the body at each time step using a Runge-Kutta method. 
+    Function calculating the motion of the body at each time step using a Runge-Kutta method.
     From body position, velocity and flow environment, the function determines the flow velocity at the body position and calculates its new velocities, checking for collisions with walls.
 
     :param a_RK: Runge-Kutta coefficient.
@@ -115,7 +119,7 @@ def Body_motion(a_RK, batch_turb, CFL, Delta, epsilon, H_pre, H_post, Human, k,
 
         ## Get the velocity at exact time and horizontal position of each run, most time consuming function of the drowning calculation
         [du_insta,_,_,H_f,k_f,U_x_vec,U_y_vec,walls] = interp_mailles_mat(Delta,epsilon,H_pre,H_post,index_bp,k,NbX,NbY,Pos_RK[j,:,:],t_Wolf_perc,t_Wolf_perc_insta,Ux_pre,Ux_post,Uy_pre,Uy_post)
-        
+
         ## Parameters and calculations to have the velocity at the body vertical position and its relative velocity
         l_tilde = EPS/H_f
         z = np.clip(Pos_RK[j, :, -1],EPS, H_f)
@@ -144,12 +148,12 @@ def Body_motion(a_RK, batch_turb, CFL, Delta, epsilon, H_pre, H_post, Human, k,
 
         t_Wolf_perc += dt/dt_Wolf
 
-        
+
     U_b = (1-a_RK)*U_RK[0,:,:] + a_RK*U_RK[1,:,:]
     Pos_b = (1-a_RK)*Pos_RK[0,:,:] + a_RK*Pos_RK[1,:,:]
 
     time_b += dt
-    
+
     ## Check and corrections for collisions with walls
     index_b = ((np.floor(Pos_b[:,:2].T / Delta[0:2,None])).T).astype(int)
     walls = (H_pre[index_b[:,1], index_b[:,0]] < EPS)
@@ -161,11 +165,11 @@ def Body_motion(a_RK, batch_turb, CFL, Delta, epsilon, H_pre, H_post, Human, k,
         ind_walls = np.where(walls)[0]
         U_b[ind_walls,0:2] = 0
 
-    
+
     ## Storage of times when bodies sank and resurfaced
     sinking[:,0] = sinking[:,0] + (sinking[:,0]==0)*(Pos_b[:,2] == EPS)*(U_b[:,2]==0) * Pos_b[:,0]
     sinking[:,1] = sinking[:,1] + (sinking[:,1]==0)*(Pos_b[:,2] == EPS)*(U_b[:,2]==0) * time_b
-    
+
     H_f = H_f.ravel()
     V_b = V_b.ravel()
     resurface[:,0] = resurface[:,0] + (resurface[:,0]==0)*(Pos_b[:,2] >= H_f-0.5)*(m_b/V_b/RHO_F<1) * Pos_b[:,0]
@@ -196,14 +200,14 @@ def Body_temperature(BSA, mass, T_w, t):
     Res = 3000
 
     T_b = T_w + (T_body_ini - T_w)*np.exp(-t/Res)
-                                          
+
     ADD = ((T_body_ini - T_w) * Res * (1 - np.exp(-t / Res)) + T_w * t)/3600/24 #Integral of the body temperature as a function of time, ADD in [°C.day]
 
     return ADD,T_b
 
 def Body_volume_variation(alpha_1, BSA, FRC, H_f, m_b, time_b, T_w, TLC, V_b0, V_clothes1, V_clothes2, z):
     """
-    Function calculating the body volume variation due to the putrefaction gases. 
+    Function calculating the body volume variation due to the putrefaction gases.
     The method is described in Delhez et al. 2025, "Predicting the buoyancy and Postmortem Submersion Interval of victims of river drowning".
 
     :param alpha_1: Alpha parameter.
@@ -225,18 +229,18 @@ def Body_volume_variation(alpha_1, BSA, FRC, H_f, m_b, time_b, T_w, TLC, V_b0, V
     p_ext = P_ATM+p_hydro
     V_s = V_b0 - FRC #fraction of FRC on the whole body volume
     n_0 = P_ATM*FRC/(8.3144621*(37+273.15)) #initial amount of gas in the lungs, perfect gas law
-    
+
     ADD = time_b/60/60/24 * T_w
     _,T_b = Body_temperature(BSA,m_b,T_w,time_b) #Consideration of the actual body temperature
     ratio_ADD = ADD/alpha_1
-    
+
     n_1 = 2*P_ATM * TLC/(8.3144621*(T_w+273.15))
     coef_eta = [10,-15,6]
     eta = n_1*(coef_eta[2]*(ratio_ADD)**5+coef_eta[1]*(ratio_ADD)**4+coef_eta[0]*(ratio_ADD)**3)
     eta = np.minimum(eta,n_1)
-    
+
     V_clothes = np.where(T_w < 15, V_clothes1, V_clothes2)
-    
+
     V_comp = (n_0+eta/n_1*(n_1-n_0))*8.3144621*(T_b+273.15)/(p_ext) #Compressible Volume
     V_b = V_s + V_comp + V_clothes
 
@@ -287,7 +291,7 @@ def Flow_time_t(batch_turb, dt, epsilon, H_f, k, turb_type, U_bp, U_x_vec, U_y_v
     """
     U_x_dif = (U_x_vec-U_bp[:,0])
     U_y_dif = (U_y_vec-U_bp[:,1])
-    U_x_vec,U_y_vec = U_turbulence(batch_turb,dt,epsilon,H_f,k,turb_type,U_x_vec,U_x_dif,U_y_vec,U_y_dif,z,z_0) 
+    U_x_vec,U_y_vec = U_turbulence(batch_turb,dt,epsilon,H_f,k,turb_type,U_x_vec,U_x_dif,U_y_vec,U_y_dif,z,z_0)
     U_x_dif = (U_x_vec-U_bp[:,0])
     U_y_dif = (U_y_vec-U_bp[:,1])
     U_x_sign = np.sign(U_x_dif)
@@ -297,7 +301,7 @@ def Flow_time_t(batch_turb, dt, epsilon, H_f, k, turb_type, U_bp, U_x_vec, U_y_v
 
 def interp_mailles_mat(Delta, epsilon, H_0, H_1, index_b, k, NbX, NbY, Pos_b, t_WOLF_perc, t_Wolf_perc_insta, Ux_0, Ux_1, Uy_0, Uy_1):
     """
-    Determines the flow velocity and height at the body position based on the value of the cells in which the body is and the next cells in x, y and xy. 
+    Determines the flow velocity and height at the body position based on the value of the cells in which the body is and the next cells in x, y and xy.
     It is a spatial bi-linear and temporal linear interpolation.
     Method described in Delhez et al. 2025, Lagrangian modelling of the drift of a victim of river drowning.
 
@@ -377,7 +381,7 @@ def interp_mailles_mat(Delta, epsilon, H_0, H_1, index_b, k, NbX, NbY, Pos_b, t_
         #                         var[index_b[ind_walls,1],index_bo_x[ind_walls]] +
         #                         var[index_bo_y[ind_walls],index_b[ind_walls,0]] +
         #                         var[index_bo_y[ind_walls],index_bo_x[ind_walls]))
-        
+
         Ux_v[ind_walls] = sum_vars(Ux_0) / active_cells[ind_walls]
         Uy_v[ind_walls] = sum_vars(Uy_0) / active_cells[ind_walls]
         H_v[ind_walls] = sum_vars(H_0) / active_cells[ind_walls]
@@ -458,9 +462,9 @@ def Loading(Path_loading, Pos_b, time_b, U_b):
 
 def Loop_management(progress_queue, process_id, a_RK, BC_cells, count, count_Wolf, CFL, Delta, Human_np, i_initial, n_b, n_saved, n_t, NbX, NbY, Path_Saving, Path_Wolf, Pos, Pos_b, resurface, sinking, time, time_b, time_goal, U, U_b, wanted_time, wanted_Wolf, Z_param_np):
     """
-    Main loop of the code. Calculates the motion of each body at each time in the loop and updates the flow when needed. 
-    Everything is based on the array "still" which contains the index of all the bodies that need more calculations, as we work with variable time step for each body. 
-    If a body is out of the domain, it is out of still; if a body reaches a time for which we need a save, it is out of still; 
+    Main loop of the code. Calculates the motion of each body at each time in the loop and updates the flow when needed.
+    Everything is based on the array "still" which contains the index of all the bodies that need more calculations, as we work with variable time step for each body.
+    If a body is out of the domain, it is out of still; if a body reaches a time for which we need a save, it is out of still;
     if a body reaches a time for which the flow needs to be updated, it is out of still.
 
     :param progress_queue: Queue for progress updates.
@@ -516,7 +520,7 @@ def Loop_management(progress_queue, process_id, a_RK, BC_cells, count, count_Wol
         sp = 0 + i%2
 
         # Body position calculation at each time step
-        (Human_np[still,:],Pos[still,:,s],resurface[still,:],sinking[still,:],time[still],U[still,:,s]) = Body_motion(a_RK,batch_turb,CFL,Delta,epsilon,H_pre,H_post,Human_np[still,:],k,NbX,NbY,Pos[still,:,sp],resurface[still,:],sinking[still,:],time[still],t_Wolf-wanted_Wolf[count_Wolf_ini],wanted_Wolf[count_Wolf+1]-wanted_Wolf[count_Wolf_ini],t_for,U[still,:,sp],Ux_pre,Ux_post,Uy_pre,Uy_post,Z_param_np[still,:])  
+        (Human_np[still,:],Pos[still,:,s],resurface[still,:],sinking[still,:],time[still],U[still,:,s]) = Body_motion(a_RK,batch_turb,CFL,Delta,epsilon,H_pre,H_post,Human_np[still,:],k,NbX,NbY,Pos[still,:,sp],resurface[still,:],sinking[still,:],time[still],t_Wolf-wanted_Wolf[count_Wolf_ini],wanted_Wolf[count_Wolf+1]-wanted_Wolf[count_Wolf_ini],t_for,U[still,:,sp],Ux_pre,Ux_post,Uy_pre,Uy_post,Z_param_np[still,:])
         index = np.floor_divide(Pos[:, :2, s], Delta[:2]).astype(int)
         still = np.where((time < t_for) & (time < t_Wolf) & (~np.any(np.all(index[:, None] == BC_cells, axis=2), axis=1)))[0]
 
@@ -567,7 +571,7 @@ def Loop_management(progress_queue, process_id, a_RK, BC_cells, count, count_Wol
 
         # pbar.update(int(time[0] - pbar.n))
         i += 1
-            
+
     return Pos_b,resurface,sinking,time_b,U_b
 
 def Motion_equations(CAM, CDA, CLA, CSA, dt, du_insta, m_b, mu, U_bp, U_x_dif, U_x_sign, U_y_dif, U_y_sign, V_b, vertical):
@@ -599,7 +603,7 @@ def Motion_equations(CAM, CDA, CLA, CSA, dt, du_insta, m_b, mu, U_bp, U_x_dif, U
 
     m_added = (CAM * RHO_F * V_b).T
     # m_added = ((1+CAM) * RHO_F * V_b).T
-    
+
     # Initialisation of the forces arrays
     F_fb = zeros_n_b_3.copy()
     F_g = zeros_n_b_3.copy()
@@ -607,7 +611,7 @@ def Motion_equations(CAM, CDA, CLA, CSA, dt, du_insta, m_b, mu, U_bp, U_x_dif, U
     F_A = zeros_n_b_3.copy()
 
     #Rotation matrix to apply to the hydrodynamic coefficients, see article Delhez et al., 2025 for the detail computation of the resultant matrix
-    angle_rel = np.arctan2(U_y_dif, U_x_dif) 
+    angle_rel = np.arctan2(U_y_dif, U_x_dif)
     angle_rel[(U_y_dif == 0) & (U_x_dif == 0)] = 0
 
     cos_angle_rel_2 = np.cos(2*angle_rel)
@@ -640,7 +644,7 @@ def Motion_equations(CAM, CDA, CLA, CSA, dt, du_insta, m_b, mu, U_bp, U_x_dif, U
 
     # Friction forces, calculation of value and direction
     F_fr_tot = mu * np.abs(Forces_but_friction[:,2]) * (Forces_but_friction[:,2]<0) #mu depends on the depth (activating the friction only at the bottom)
-    angle = np.arctan2(U_bp[:,1], U_bp[:,0]) 
+    angle = np.arctan2(U_bp[:,1], U_bp[:,0])
     angle[(U_bp[:, 1] == 0) & (U_bp[:, 0] == 0)] = np.arctan2(Forces_but_friction[(U_bp[:, 1] == 0) & (U_bp[:, 0] == 0), 1], Forces_but_friction[(U_bp[:, 1] == 0) & (U_bp[:, 0] == 0), 0])  #Force the angle to be 0 also when both speed are -0.0 which gives -pi by convention
     cos_angle = np.abs(np.cos(angle))# + 1*(angle*180/pi==90)
     sin_angle = np.abs(np.sin(angle))# + 1*(angle*180/pi==0)
@@ -713,9 +717,9 @@ def Preparation_parallelisation(progress_queue, a_RK, BC_cells, count, count_Wol
             end_idx = (i + 1) * chunk_size if i != n_parallel - 1 else n_b  # Prend tout jusqu'à la fin au dernier
 
             # Préparation des arguments pour chaque processus avec sous-vecteurs
-            task = (progress_queue,i,a_RK,BC_cells, count,count_Wolf, CFL, Delta, Human_np[start_idx:end_idx,:], i_initial, chunk_size, n_saved, n_t, NbX, NbY, 
-                    Path_saving,Path_Wolf, Pos[start_idx:end_idx,:,:], Pos_b[start_idx:end_idx,:,:], resurface[start_idx:end_idx], 
-                    sinking[start_idx:end_idx,:], time[start_idx:end_idx], time_b[start_idx:end_idx,:], time_goal, 
+            task = (progress_queue,i,a_RK,BC_cells, count,count_Wolf, CFL, Delta, Human_np[start_idx:end_idx,:], i_initial, chunk_size, n_saved, n_t, NbX, NbY,
+                    Path_saving,Path_Wolf, Pos[start_idx:end_idx,:,:], Pos_b[start_idx:end_idx,:,:], resurface[start_idx:end_idx],
+                    sinking[start_idx:end_idx,:], time[start_idx:end_idx], time_b[start_idx:end_idx,:], time_goal,
                     U[start_idx:end_idx,:,:], U_b[start_idx:end_idx,:,:], wanted_time, wanted_Wolf, Z_param_np[start_idx:end_idx,:])
             TASKS.append(task)
 
@@ -811,13 +815,13 @@ def Skinfold(n_b, known, Human):
     ind_40_m = np.where((Human.Age.to_numpy()<=40)&(Human.Age.to_numpy()>30) & (Human.gender.to_numpy()==1))
     ind_50_m = np.where((Human.Age.to_numpy()<=50)&(Human.Age.to_numpy()>40) & (Human.gender.to_numpy()==1))
     ind_max_m = np.where((Human.Age.to_numpy()>50) & (Human.gender.to_numpy() ==1))
-    
+
     ind_20_w = np.where((Human.Age.to_numpy()<=20) & (Human.gender.to_numpy()==2))
     ind_30_w = np.where((Human.Age.to_numpy()<=30)&(Human.Age.to_numpy()>20) & (Human.gender.to_numpy()==2))
     ind_40_w = np.where((Human.Age.to_numpy()<=40)&(Human.Age.to_numpy()>30) & (Human.gender.to_numpy()==2))
     ind_50_w = np.where((Human.Age.to_numpy()<=50)&(Human.Age.to_numpy()>40) & (Human.gender.to_numpy()==2))
     ind_max_w = np.where((Human.Age.to_numpy()>50) & (Human.gender.to_numpy() ==2))
-    
+
     ind_20 = np.where(Human.Age.to_numpy()<=24)
     ind_30 = np.where((Human.Age.to_numpy()<=34)&(Human.Age.to_numpy()>24))
     ind_40 = np.where((Human.Age.to_numpy()<=44)&(Human.Age.to_numpy()>34))
@@ -825,45 +829,45 @@ def Skinfold(n_b, known, Human):
     ind_60 = np.where((Human.Age.to_numpy()<=64)&(Human.Age.to_numpy()>54))
     ind_70 = np.where((Human.Age.to_numpy()<=74)&(Human.Age.to_numpy()>64))
     ind_max = np.where(Human.Age.to_numpy()>74)
-    
+
     BMI_25 = [20, 21.3, 22.5, 23.3, 22.9, 23.7, 23.1]
     BMI_50 = [21.7, 23.4, 24.8, 25.7, 25.9, 26.3, 25.3]
     BMI_75 = [24.3, 26.4, 28, 29, 29.1, 29.7, 28]
 
-    
+
     change = [ind_20,ind_30,ind_40,ind_50,ind_60,ind_70,ind_max]
 
     ind_Age = np.minimum(math.floor(np.mean(Human.Age.to_numpy())/10)-1,6)
 
     if known == 0:
-        
+
         for i in range(7):
             ind = np.array((change[i]))
             (aBMI,bBMI) = known_1(3,16,40,BMI_25[i],BMI_50[i],0.25,0.5)
             Human.loc[ind[0,:],'BMI'] = rnd.beta(aBMI,bBMI,size=(len(ind[:][0])))*(40-16)+16
-            
+
         error_perc_fat = (rnd.beta(2,2,size=(n_b))*(2*std_perc_fat_m[ind_Age]+2*std_perc_fat_m[ind_Age])-2*std_perc_fat_m[ind_Age])*(Human.gender.to_numpy()==1) + (rnd.beta(2,2,size=(n_b))*(2*std_perc_fat_w[ind_Age]+2*std_perc_fat_w[ind_Age])-2*std_perc_fat_w[ind_Age])*(Human.gender.to_numpy()==2)
-        
+
         Human.loc[:,'mass'] = Human.BMI * Human.height**2
-            
+
         perc_fat = -32.515 + 12.409*(Human.gender.to_numpy()-1) + 3.306*Human.BMI.to_numpy() - 0.03*Human.BMI.to_numpy()**2 - 0.006*Human.Age.to_numpy() + 0.033*Human.Age.to_numpy()*(Human.gender.to_numpy()-1) - 0.001*Human.Age.to_numpy()*Human.BMI.to_numpy() #Meeuwsen et al
         perc_fat = perc_fat*(perc_fat+error_perc_fat<45) + (perc_fat-(perc_fat+error_perc_fat-45-random.randint(-100,200))/100)*(perc_fat+error_perc_fat>=45)
         perc_fat = np.maximum(perc_fat+error_perc_fat,8)
         Human.rho = 4.95/(perc_fat/100+4.5) * 1000#Siri's equation
         Human.Volume = Human.mass/Human.rho
-        
+
     else: #if known != 3:
 
         ind_Age = np.minimum(math.floor(np.mean(Human.Age.to_numpy())/10)-1,6)
 
         error_perc_fat = rnd.beta(2,2,size=(n_b))*(2*std_perc_fat_m[ind_Age]+2*std_perc_fat_m[ind_Age])-(2*std_perc_fat_m[ind_Age])*(Human.gender.to_numpy()==1) + (rnd.beta(2,2,size=(n_b))*(2*std_perc_fat_w[ind_Age]+2*std_perc_fat_w[ind_Age])-2*std_perc_fat_w[ind_Age])*(Human.gender.to_numpy()==2)
-        
+
         perc_fat = -32.515 + 12.409*(Human.gender.to_numpy()-1) + 3.306*Human.BMI.to_numpy() - 0.03*Human.BMI.to_numpy()**2 - 0.006*Human.Age.to_numpy() + 0.033*Human.Age.to_numpy()*(Human.gender.to_numpy()-1) - 0.001*Human.Age.to_numpy()*Human.BMI.to_numpy() #Meeuwsen et al
         perc_fat = perc_fat*(perc_fat+error_perc_fat<45) + (perc_fat-(perc_fat+error_perc_fat-45-random.randint(-100,200))/100)*(perc_fat+error_perc_fat>=45)
         perc_fat = np.maximum(perc_fat+error_perc_fat,8)
         Human.rho = 4.95/(perc_fat/100+4.5) * 1000;#Siri's equation
         Human.Volume = Human.mass.to_numpy()/Human.rho.to_numpy()
-            
+
     return Human,error_perc_fat
 
 def state_of_run(progress_queue, frame, interval):
@@ -886,7 +890,7 @@ def state_of_run(progress_queue, frame, interval):
             continue  # Pas de mise à jour dispo, on continue
         except (EOFError, BrokenPipeError):
             break
-        
+
         # Close window when all processes are done
         # if all(value is not None for value in progress_dict.values()):
         #     wx.CallAfter(frame.Close)  # Close the frame after all tasks are complete
@@ -921,7 +925,7 @@ def U_turbulence(batch, dt, epsilon, H, k, turb_type, U_x, U_x_dif, U_y, U_y_dif
 
     mask_zero = (H >= 0) & (z >= 0)
 
-    U_shear_x[mask_zero] = np.abs(U_x[mask_zero])*n*np.sqrt(9.81)/(H[mask_zero]**(1/6)) #based on the combination of Manning equation and definition of bed shear stress and shear velocity 
+    U_shear_x[mask_zero] = np.abs(U_x[mask_zero])*n*np.sqrt(9.81)/(H[mask_zero]**(1/6)) #based on the combination of Manning equation and definition of bed shear stress and shear velocity
     U_shear_y[mask_zero] = np.abs(U_y[mask_zero])*n*np.sqrt(9.81)/(H[mask_zero]**(1/6))
 
     U_x_sign[mask_zero] = np.sign(U_x[mask_zero])
@@ -977,7 +981,7 @@ def U_turbulence(batch, dt, epsilon, H, k, turb_type, U_x, U_x_dif, U_y, U_y_dif
 
         #U_y_shear = (U_y / factor) * ln_z_z0 #Log law of the wall
         K_H = 0.6*H*np.abs(U_shear_y)#np.abs(U_y_shear) #Turbulent diffusion coefficient (or turbulent diffusivity coefficient)
-        U_y_turb = R*np.sqrt(2*K_H*dt) 
+        U_y_turb = R*np.sqrt(2*K_H*dt)
         U_y = U_shear_y/ kappa * ln_z_z0 + U_y_turb/dt
 
     elif turb_type ==3: #See Bocksell & Loth (2001), Eqs. 16 to 21, based on k-eps
@@ -995,7 +999,7 @@ def U_turbulence(batch, dt, epsilon, H, k, turb_type, U_x, U_x_dif, U_y, U_y_dif
         C_delta = 1.6 #Table 2 of the reference
         C_mu = 0.09 #After Eq. 17 of reference
         C_tau = 0.27 #Table 2 of the reference
-        
+
         Delta = np.array([C_c_x,C_c_y])*C_delta*C_mu**(3/4)*(k**(3/2)/epsilon) #Eq. 17
 
         tau_delta = C_tau*eps_01_09*(k/epsilon) #Eq. 17
@@ -1013,7 +1017,3 @@ def U_turbulence(batch, dt, epsilon, H, k, turb_type, U_x, U_x_dif, U_y, U_y_dif
         ##At this time, compatible only with Wolf CPU because no k-eps given by GPU
 
     return U_x,U_y
-
-
-
-

wolfhece/wolf_array.py

@@ -9468,11 +9468,20 @@ class WolfArray(Element_To_Draw, header_wolf):
                                 'classic']='scipyfft',
                  inplace:bool=True) -> "WolfArray":
         """
-        Convolve the array with a filter
+        Convolve the array with a filter.
+
+        The array and the filter should have the same dtype. If not, a warning is issued and the array dtype is used.
+
+        Thus:
+
+        - An int8 array convolved with float32 filter will be converted to int8.
+        - A float32 array convolved with int8 filter will be converted to float32.
+
+        **User should be careful with the dtype of both the array AND the filter.**
 
         :param filter: filter to convolve with
         :param method: method to use for convolution ('scipyfft', 'jaxfft', 'classic')
-        :param inplace: if True, the array is modified in place, otherwise a new array is returned
+        :param inplace: if True, the array is modified in place, otherwise a new array is returned -- same type as the original one
         :return: convolved array, WolfArray instance
 
         """
@@ -9487,6 +9496,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             logging.error("Filter must be a WolfArray or a numpy array")
             return None
 
+        if self.dtype != _filter.dtype:
+            logging.warning(_("Filter and array should have the same dtype - {} - {}").format(self.dtype, _filter.dtype))
+            logging.warning(_("Convolution result will have the dtype - {}").format(self.dtype))
+
         if method == 'classic':
             from scipy.signal import convolve2d
             convolved = convolve2d(self.array.data, _filter, mode='same', fillvalue=0.0)
@@ -9508,7 +9521,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.array.data[:,:] = convolved
             return self
         else:
-            newWolfArray = WolfArray(mold=self)
+            newWolfArray = WolfArray(mold=self, whichtype=self.wolftype)
             newWolfArray.array.data[:,:] = convolved
             newWolfArray.array.mask[:,:] = self.array.mask[:,:]
             newWolfArray.count()

{wolfhece-2.2.6.dist-info → wolfhece-2.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.6
+Version: 2.2.7
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.2.6.dist-info → wolfhece-2.2.7.dist-info}/RECORD

@@ -16,7 +16,7 @@ wolfhece/PyPalette.py,sha256=k9b_95GYD0USQ8DS5zGXeZ577712U6772kmhEbJtlXw,35406
 wolfhece/PyParams.py,sha256=Dh9C_WYICMjo3m9roRySsu8ZgFzzYhSr6RpbaXZni0M,99423
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
-wolfhece/PyVertex.py,sha256=Ym42pHWwEVv6Fu5v-OzhlHiQB46DnvLf9MUe_c3lbR0,45610
+wolfhece/PyVertex.py,sha256=WboSqzI0fYI7wLk-jtgQ0ykX5QBKuVJuoavc8NnjEoo,46593
 wolfhece/PyVertexvectors.py,sha256=0lt0YyHIz_IxgXqdqPlTDruDwjeP6L1Dw6B2Q35a8kQ,325801
 wolfhece/PyWMS.py,sha256=LWkQk3R7miiVal-n5K5P5ClSQJA_vi5ImBxYGuxCx9A,9122
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
@@ -24,7 +24,7 @@ wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,5
 wolfhece/RatingCurve_xml.py,sha256=cUjReVMHFKtakA2wVey5zz6lCgHlSr72y7ZfswZDvTM,33891
 wolfhece/ReadDataDCENN.py,sha256=vm-I4YMryvRldjXTvRYEUCxZsjb_tM7U9yj6OaPyD0k,1538
 wolfhece/Results2DGPU.py,sha256=45bLAkWvqHcw60QIP7qXyizbmS7buoDC7ndzOVfiWXg,26302
-wolfhece/__init__.py,sha256=FRDE8PiJAWxX9PMXsShRMZ8YADAY4WIgKMRh52rmhiw,23
+wolfhece/__init__.py,sha256=kw2zFam1CqCH6CHgRHCZt7YXzsGaOQ-PwNkIi_E2H-Y,272
 wolfhece/_add_path.py,sha256=nudniS-lsgHwXXq5o626XRDzIeYj76GoGKYt6lcu2Nc,616
 wolfhece/analyze_vect.py,sha256=3lkMwaQ4KRddBVRvlP9PcM66wZwwC0eCmypP91AW-os,6015
 wolfhece/cli.py,sha256=U8D7e_OezfrRfgMsa4TyQ7rI4voLKSY3RK-c8fb6rrw,3156
@@ -58,7 +58,7 @@ wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools2d_dll.py,sha256=oU0m9XYAf4CZsMoB68IuKeE6SQh-AqY7O5NVED8r9uw,13125
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=ObPgmLLqv3n8Y9CtgiJnS27pfFhrNgJ_Fb6LDzMjHdo,490794
+wolfhece/wolf_array.py,sha256=8ZM75yOInSkoJQsKaCABmgP_j2KLevO5BgxsSmvRvi8,491510
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=IvFtekT5iLU2sivZOOlJXpE4CevjTQYSxHaOp4cH_wI,17723
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
@@ -86,7 +86,7 @@ wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVz
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=eCPAUYscZPWDYKBHDBWum_VIcE7WXOCBe1GLHL3KUmU,3088
-wolfhece/apps/version.py,sha256=rAnYNDLsdGsc3H4jwJAMgO-Q_31WYx7Onj9Vdx0xPC8,387
+wolfhece/apps/version.py,sha256=UGz-NV4qzN96AWCtJsnDr27SQMMZUOgYsoje1cRxP8s,387
 wolfhece/apps/wolf.py,sha256=j_CgvsL8rwixbVvVD5Z0s7m7cHZ86gmFLojKGuetMls,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -114,7 +114,7 @@ wolfhece/coupling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 wolfhece/coupling/hydrology_2d.py,sha256=QBIcgujfOX1xX3ARF2PQz6Uqwu3j6EaRw0QlGjG_H7k,53090
 wolfhece/drowning_victims/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/drowning_victims/drowning_class.py,sha256=xWr_SoFqpodQ51x2CqCRbfIiL903kk2YqIRoU35xZy0,93482
-wolfhece/drowning_victims/drowning_functions.py,sha256=hlAOyzt15GYe0urDPYquJaV6i0LyDj7X5BAUGE6ppso,47535
+wolfhece/drowning_victims/drowning_functions.py,sha256=6VP9KBqZWVfEwUcvwOErxRDaDjVNjHAZso5U_Ox1mw8,47369
 wolfhece/eva/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/eva/bootstrap.py,sha256=Ys4xTDIvG_QtxCKWLYzb3_XAZU441jGX7fHIbd9Mvr0,840
 wolfhece/eva/hydrogramme_mono.py,sha256=uZFIgJJ-JogMFzt7D7OnyVaHvgxCQJPZz9W9FgnuthA,8138
@@ -314,8 +314,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.2.6.dist-info/METADATA,sha256=mW2wEErzRwRsbNfbCDsF13a7MCDZ-hNV2LLzgf1yuGY,2744
-wolfhece-2.2.6.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-wolfhece-2.2.6.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
-wolfhece-2.2.6.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.6.dist-info/RECORD,,
+wolfhece-2.2.7.dist-info/METADATA,sha256=L3cl2QpOoOfUeWa8ox5Y41HslP4ad6In6xbQi1Ydk5U,2744
+wolfhece-2.2.7.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+wolfhece-2.2.7.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.2.7.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.7.dist-info/RECORD,,