Added generating code for simulations

code/KwaveUpdateDomainParams.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+import numpy as np
+import h5py
+import argparse
+import random
+import shutil
+import os
+import scipy.interpolate as si
+
+from scipy.signal import gaussian
+from itertools import product
+
+from typing import Tuple
+
+def generate_sound_speed(shape = [1152, 512],
+        c_ref: float = 1500., c_min: float = 1300., c_max: float = 1800.,
+        atn_min: float = 0.05, atn_max: float = 0.15,
+        max_ell: int = 6, max_lines: int = 4) -> Tuple[np.ndarray, np.ndarray]:
+    """[summary]
+    Generate a random speed of sound and attenuation map with up to max_ell ellipses and max_lines straight reflectors
+
+    Args:
+        shape (list, optional): [description]. Defaults to [1152, 512].
+        c_ref (float, optional): [description]. Defaults to 1500..
+        c_min (float, optional): [description]. Defaults to 1300..
+        c_max (float, optional): [description]. Defaults to 1800..
+        atn_min (float, optional): [description]. Defaults to 0.05.
+        atn_max (float, optional): [description]. Defaults to 0.15.
+        max_ell (int, optional): [description]. Defaults to 6.
+        max_lines (int, optional): [description]. Defaults to 4.
+
+    Returns:
+        [type]: [description]
+    """
+
+    while True:
+        n_ell = np.random.randint(max_ell + 1)
+        n_lines = np.random.randint(max_lines + 1)
+
+        if n_ell + n_lines > 0:
+            break
+
+    ell_type = np.array([0,] * n_ell + [1,] * n_lines)[np.random.permutation(n_ell + n_lines)]
+    c = np.random.rand(n_ell + n_lines + 1) * (c_max - c_min) + c_min
+    atn = np.random.rand(n_ell + n_lines + 1) * (atn_max - atn_min) + atn_min
+
+    ell_params = np.random.rand(5, n_ell); # x0, y0, a, b, \theta in columns
+
+    ell_params[0, :] = ell_params[0, :] * shape[-1]
+    ell_params[1, :] = ell_params[1, :] * shape[-2]
+    ell_params[2, :] = ell_params[2, :] * shape[-1];
+    ell_params[3, :] = ell_params[3, :] * shape[-2];
+    ell_params[4, :] = (ell_params[4, :] - 0.5) * np.pi / 4;
+
+    line_params = np.random.rand(2, n_lines); # Angle and offset
+
+    line_params[0, :] = (line_params[0, :] - 0.5) * np.pi / 6;
+    line_params[1, :] = line_params[1, :] * (shape[-2] - 68) + 68
+
+    sound_speed = np.empty(shape[-2:], dtype=np.single)
+    sound_speed[...] = c[-1]
+    alpha_coeff = np.empty(shape[-2:], dtype=np.single)
+    alpha_coeff[...] = atn[-1]
+
+    i_ellp = 0
+    i_lines = 0
+
+    X, Y = np.meshgrid(range(shape[-1]), range(shape[-2]))
+
+    for i,t in enumerate(ell_type):
+        if t == 0:
+            # elipse
+            x0 = np.array([ell_params[0, i_ellp], ell_params[1, i_ellp]])
+            a  = np.array([ell_params[2, i_ellp], ell_params[3, i_ellp]])
+
+            th = ell_params[4, i_ellp]
+            ath = np.abs(th)
+
+            R = np.array([[np.cos(th), -np.sin(th)], [np.sin(th), np.cos(th)]])
+            aR = np.array([[np.cos(ath), -np.sin(ath)], [np.sin(ath), np.cos(ath)]])
+
+            toff = aR.dot(a)[1]
+
+            if x0[1] - toff < 68:
+                x0[1] = 68 + toff
+
+            x = X - x0[0]
+            y = Y - x0[1]
+
+            u = np.cos(th) * x - np.sin(th) * y
+            v = np.sin(th) * x + np.cos(th) * y
+
+            sound_speed[(u / ell_params[2, i_ellp]) ** 2 + (v / min(ell_params[3, i_ellp], ell_params[1, i_ellp] - 68)) ** 2 < 1] = c[i]
+            alpha_coeff[(u / ell_params[2, i_ellp]) ** 2 + (v / min(ell_params[3, i_ellp], ell_params[1, i_ellp] - 68)) ** 2 < 1] = atn[i]
+
+            i_ellp += 1
+        else:
+            # plane
+            th =  line_params[0, i_lines]
+            off = line_params[1, i_lines]
+
+            if off - shape[-1] * np.tan(np.abs(th)) < 68:
+                off = shape[-1] * np.tan(np.abs(th)) + 68
+
+            sound_speed[X * np.sin(th) + (Y - off) * np.cos(th) > 0] = c[i]
+            alpha_coeff[X * np.sin(th) + (Y - off) * np.cos(th) > 0] = atn[i]
+
+            i_lines += 1
+
+    return sound_speed, alpha_coeff
+
+
+def generate_density(shape: tuple = [1152, 1152],
+    d_ref: float = 900.,
+    n_spec: float = -1.,
+    spec_amp: float = 0.1) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Generate a speckle map in the density domain, including the x and y derivatives
+
+
+    Args:
+        shape (_type_, optional): shape of output map. Defaults to [1152, 1152]
+        d_ref (float, optional): reference density (kg / m^3). Defaults to 900
+        n_spec (float, optional): speckle density. Defaults to -1
+        spec_amp (float, optional): speckle amplitude. Defaults to 0.1
+
+    Returns:
+        _type_: _description_
+    """
+
+    if n_spec < 0:
+        n_spec = shape[-1] * shape[-2] * (2. / 64.)
+
+    t_n_spec = int(np.round(n_spec * (10 - np.random.rand() * 8) * 0.1))
+
+    speckle = np.zeros((shape[-2] - 48 - 68, shape[-1] - 48*2), np.single)
+    speckle.reshape(-1,1)[np.random.permutation(speckle.size)[:t_n_spec]] = d_ref * (np.random.rand(t_n_spec, 1) - 1/3) * spec_amp
+
+    rho0 = np.empty(shape[-2:], dtype=np.single)
+    rho0[...] = d_ref
+
+    rho0[68:-48, 48:-48] += speckle
+
+    rho0_sgx = np.empty_like(rho0)
+    rho0_sgx[:,:-1] = (rho0[:,:-1] + rho0[:,1:]) * 0.5
+    rho0_sgx[:,-1] = rho0[:,-1]
+
+    rho0_sgy = np.empty_like(rho0)
+    rho0_sgy[:-1,:] = (rho0[:-1,:] + rho0[1:,:]) * 0.5
+    rho0_sgy[-1,:] = rho0[-1,:]
+
+    return rho0, rho0_sgx, rho0_sgy
+
+
+def generate_pulse(center_freq=5e6, n_periods=4.4, sampling_freq=40e6):
+        samples_per_cycle = sampling_freq / center_freq
+        n_samples = np.ceil(samples_per_cycle * n_periods + 1)
+
+        signal = np.sin(np.arange(n_samples, dtype=np.float32) / samples_per_cycle * 2 * np.pi) * gaussian(n_samples, (n_samples - 1) / 6).astype(np.single)
+
+        return signal
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('input', help='reference file')
+    parser.add_argument('--device',      '-d', type=int, default=0, help='cuda device to use')
+    parser.add_argument('--frequencies', '-f', type=float, nargs='+', default=[5e6, 2.5e6],
+        help='at which frequencies to run the simulation')
+    parser.add_argument('--offsets',     '-o', type=int, nargs='+', default=[-32, -24, -16, -8, 0, 8, 16, 24, 32],
+        help='list of (signed) offsets to use with respect to center, in elements. Angles will be calculated from offsets')
+    parser.add_argument('--n_periods', '-p', type=float, default=5.0,
+        help='how many periods to use for the pulse')
+    parser.add_argument('--ref_offset',  '-r', type=int, default=59 * 1152 + (1152 - (128 + 127) * 4) // 2 + 32 * 2 * 4,
+        help='reference offset in entries (where to start offset 0) - default: line 60, element 33, remember the kerf')
+    parser.add_argument('--ref_speed',  '-s', type=float, default=1540,
+        help='reference speed under which to computer angle')
+
+    args = parser.parse_args()
+
+    hash = f'{random.getrandbits(128):x}'
+
+    tmp_input = f'tmp_input_{hash}.h5'
+    tmp_output = f'tmp_output_{hash}.h5'
+    sim_result = f'sim_result_{hash}.h5'
+
+    # costs an additional copy but solves problem of opening file multiple times in parallel
+    shutil.copyfile(args.input, tmp_input)
+
+    try:
+        with h5py.File(tmp_input, 'r+') as f_i:
+            shape = np.squeeze(f_i['c0'][()]).shape
+            dt = f_i['dt'][0,0,0]
+            dx = f_i['dx'][0,0,0]
+
+            c0, alpha_coeff = generate_sound_speed(shape)
+            rho0, rho0_sgx, rho0_sgy = generate_density(shape)
+
+            f_i['c0'][...] = c0
+            f_i['alpha_coeff'][...] = alpha_coeff
+
+            f_i['rho0'][...] = rho0
+            f_i['rho0_sgx'][...] = rho0_sgx
+            f_i['rho0_sgy'][...] = rho0_sgy
+
+            # # Also record receive traces
+            # smi = np.tile(np.array(f_i['sensor_mask_index']), (1,1,2))
+            # smi[...,smi.shape[-1]//2:] += 1152 * (1152 - 60)
+            # del f_i['sensor_mask_index']
+            # f_i["sensor_mask_index"] = smi
+            # f_i["sensor_mask_index"].attrs["data_type"] = np.string_(b"long")
+            # f_i["sensor_mask_index"].attrs["domain_type"] = np.string_(b"real")
+
+        with h5py.File(sim_result, 'w') as f_o:
+            f_o.create_dataset(f'c0', data=c0, compression="gzip", compression_opts=9)
+            f_o.create_dataset(f'alpha_coeff', data=alpha_coeff, compression="gzip", compression_opts=9)
+            f_o.create_dataset(f'f', data=np.array(args.frequencies))
+            f_o.create_dataset(f'offsets', data=np.array(args.offsets))
+
+        for frequency, offset in product(args.frequencies, args.offsets):
+            # TODO: deal with offsets / angles
+            w = 127 * 4
+            o = offset * 8
+            dn = w * o / np.sqrt(64 * o ** 2 + 4 * w ** 2) * (dx / dt) / args.ref_speed
+
+            pulse = generate_pulse(center_freq=frequency, n_periods=args.n_periods, sampling_freq=1.0/dt) * 1e-7
+
+            signal = np.zeros((1, int(np.ceil(np.abs(dn))) + len(pulse), 127 * 4), dtype=np.single)
+            for i in range(127 * 4):
+                signal[0, int(np.round(-dn * i / 507 if o < 0 else dn - dn * i / 507)) + np.arange(len(pulse)), i] = pulse
+
+            with h5py.File(tmp_input, 'r+') as f_i:
+                del f_i["u_source_index"]
+                f_i["u_source_index"] = (np.arange((64 + 63) * 4, dtype=np.uint64) + args.ref_offset + offset * 8).reshape(1, 1, -1).astype(np.uint64)
+                f_i["u_source_index"].attrs["data_type"] = np.string_(b"long")
+                f_i["u_source_index"].attrs["domain_type"] = np.string_(b"real")
+
+                del f_i["uy_source_input"]
+                f_i["uy_source_input"] = signal
+                f_i["uy_source_input"].attrs["data_type"] = np.string_(b"float")
+                f_i["uy_source_input"].attrs["domain_type"] = np.string_(b"real")
+
+                f_i["uy_source_flag"][:] = signal.shape[1]
+
+            os.system(f'../../scripts/kspaceFirstOrder-CUDA -r 20 -t 8 -g {args.device} -i {tmp_input} -o {tmp_output}')
+
+            with h5py.File(tmp_output, 'r+') as f_t:
+                p = np.squeeze(f_t['p'][()]).T
+
+            p = 0.35 * (p[0::4,:] + p[3::4,:]) + 0.95 * (p[1::4,:] + p[2::4,:])
+            T = (p.shape[1] - 1) * dt
+
+            x_orig = np.linspace(0,T,p.shape[1])
+            x_out = np.arange(0,T,1/40e6)
+
+            p_out = si.interp1d(x_orig, p, kind='linear', copy=False, bounds_error=False, fill_value=0, assume_sorted=True)(x_out).astype(np.float32)
+
+            with h5py.File(sim_result, 'r+') as f_o:
+                f_o.create_dataset(f'p_f{frequency/1e6}_o{offset}', data=p_out, compression="gzip", compression_opts=9)
+    except Exception as e:
+        print(f"Error : {e.args[0]}")
+        os.system(f'rm {sim_result}')
+
+    try:
+        os.system(f'rm {tmp_input}')
+    except Exception as e:
+        print(f"Error removing {tmp_input} : {e.args[0]}")
+
+    try:
+        os.system(f'rm {tmp_output}')
+    except Exception as e:
+        print(f"Error removing {tmp_output} : {e.args[0]}")

code/reference_file.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32fdd3e2950b5a13b02d6e98c2e9a55d229df362bb7a6822f9da7f0e2dcae65e
+size 31711238