Coverage for kwave/kWaveSimulation_helper/display_simulation_params.py: 13%

1import logging 

2 

3import numpy as np 

4 

5from kwave.kgrid import kWaveGrid 

6from kwave.kmedium import kWaveMedium 

7from kwave.utils.data import scale_SI 

8 

9 

10def display_simulation_params(kgrid: kWaveGrid, medium: kWaveMedium, elastic_code: bool): 

11 dt = kgrid.dt 

12 t_array_end = kgrid.t_array[0][-1] 

13 Nt = int(kgrid.Nt) 

14 k_size = kgrid.size 

15 

16 # display time step information 

17 logging.log(logging.INFO, f" dt: {scale_SI(dt)[0]} s, t_end: {scale_SI(t_array_end)[0]}s, time steps: {Nt}") 

18 

19 c_min, c_min_comp, c_min_shear = get_min_sound_speed(medium, elastic_code) 

20 

21 # get suitable scaling factor 

22 _, scale, _, _ = scale_SI(np.min(k_size[k_size != 0])) 

23 

24 print_grid_size(kgrid, scale) 

25 print_max_supported_freq(kgrid, c_min) 

26 

27 

28def get_min_sound_speed(medium, is_elastic_code): 

29 # if using the elastic code, 

30 # get the minimum sound speeds (not including zero if set for the shear speed) 

31 if not is_elastic_code: 

32 c_min = np.min(medium.sound_speed) 

33 return c_min, None, None 

34 else: # pragma: no cover 

35 c_min_comp = np.min(medium.sound_speed_compression) 

36 c_min_shear = np.min(medium.sound_speed_shear[medium.sound_speed_shear != 0]) 

37 return None, c_min_comp, c_min_shear 

38 

39 

40def print_grid_size(kgrid, scale): 

41 k_size = kgrid.size 

42 

43 grid_size_pts = [int(kgrid.Nx)] 

44 if kgrid.dim >= 2: 

45 grid_size_pts.append(int(kgrid.Ny)) 

46 if kgrid.dim == 3: 

47 grid_size_pts.append(int(kgrid.Nz)) 

48 

49 if kgrid.dim == 1: 

50 grid_size_scale = [scale_SI(k_size[0])[0]] 

51 elif kgrid.dim == 2: 

52 grid_size_scale = [k_size[0] * scale, k_size[1] * scale] 

53 elif kgrid.dim == 3: 

54 grid_size_scale = [round(k_size[0] * scale, 4), round(k_size[1] * scale, 4), round(k_size[2] * scale, 4)] 

55 else: 

56 raise NotImplementedError 

57 

58 grid_size_str = " by ".join(map(str, grid_size_pts)) 

59 grid_scale_str = " by ".join(map(str, grid_size_scale)) 

60 

61 # display grid size 

62 logging.log(logging.INFO, f" input grid size: {grid_size_str} grid points ({grid_scale_str}m)") 

63 

64 

65def print_max_supported_freq(kgrid, c_min): 

66 # display the grid size and maximum supported frequency 

67 k_max, k_max_all = kgrid.k_max, kgrid.k_max_all 

68 

69 def max_freq_str(kfreq): 

70 scaled_num_str, _, _, _ = scale_SI(kfreq * c_min / (2 * np.pi)) 

71 return scaled_num_str 

72 

73 if kgrid.dim == 1: 

74 # display maximum supported frequency 

75 logging.log(logging.INFO, f" maximum supported frequency: {max_freq_str(k_max_all)}Hz") 

76 

77 elif kgrid.dim == 2: 

78 # display maximum supported frequency 

79 if k_max.x == k_max.y: 

80 logging.log(logging.INFO, f" maximum supported frequency: {max_freq_str(k_max_all)}Hz") 

81 else: 

82 logging.log(logging.INFO, f" maximum supported frequency: {max_freq_str(k_max.x)}Hz by {max_freq_str(k_max.y)}Hz") 

83 

84 elif kgrid.dim == 3: 

85 # display maximum supported frequency 

86 if k_max.x == k_max.z and k_max.x == k_max.y: 

87 logging.log(logging.INFO, f" maximum supported frequency: {max_freq_str(k_max_all)}Hz") 

88 else: 

89 logging.log( 

90 logging.INFO, 

91 f" maximum supported frequency: {max_freq_str(k_max.x)}Hz by {max_freq_str(k_max.y)}Hz by {max_freq_str(k_max.z)}Hz", 

92 )