def solve(self, field_pos=None):
field = self._field
tx_apertures = self._tx_apertures
fs = self.fs
result = self.result
if field_pos is None:
field_pos = self.field_pos
field_pos = np.atleast_2d(field_pos)
# iterate over field positions
tx_p, tx_t0 = [], []
for tx in tx_apertures:
_p, _t0 = field.calc_hp(tx, field_pos)
tx_p.append(_p.T)
tx_t0.append(_t0)
p, t0 = util.sum_with_padding(tx_p, tx_t0, fs)
brightness = np.max(util.envelope(p,
N=util.nextpow2(p.shape[1]),
axis=1),
axis=1)
# result['p'] = tx_p
# result['t0'] = tx_t0
result['brightness'] = brightness
def process(job):
job_id, (file, field_pos, rotation_rule) = job
rotation_rule = rotation_rule[0] # remove enclosing list
arrays = arrays_base.copy() # make copy of array so following manipulations do not persist
# rotate arrays based on rotation rule
for array_id, dir, angle in rotation_rule:
for array in arrays:
if array['id'] == array_id:
abstract.rotate_array(array, dir, np.deg2rad(angle))
# create and run simulation
kwargs, meta = Solver.connector(simulation, *arrays)
solver = Solver(**kwargs)
solver.solve(field_pos)
# extract results and save
rf_data = solver.result['rf_data']
p = np.max(util.envelope(rf_data, axis=1), axis=1)
angle = rotation_rule[0][2]
with write_lock:
with closing(sql.connect(file)) as con:
update_image_table(con, angle, field_pos, p)
util.update_progress(con, job_id)
def process(job):
job_id, (file, field_pos) = job
solver.solve(field_pos)
rf_data = solver.result['rf_data']
b = np.max(util.envelope(rf_data, axis=1), axis=1)
with write_lock:
with closing(sql.connect(file)) as con:
update_image_table(con, field_pos, b)
util.update_progress(con, job_id)
def process(job):
job_id, (file, field_pos, rotation_rule) = job
rotation_rule = rotation_rule[0] # remove enclosing list
arrays = arrays_base.copy()
simulation = simulation_base.copy()
# rotate arrays based on rotation rule
for array_id, dir, angle in rotation_rule:
for array in arrays:
if array['id'] == array_id:
abstract.rotate_array(array, dir, np.deg2rad(angle))
# set focus delays while array is in rotated state
focus = simulation['focus']
if focus is not None:
c = simulation['sound_speed']
delay_quant = simulation['delay_quantization']
for array in arrays:
abstract.focus_array(array, focus, c, delay_quant, kind='both')
arrays_plus = arrays.copy()
arrays_minus = arrays.copy()
# rotate arrays again based on plus and minus tolerance
angle_tol = simulation['angle_tolerance']
for array_id, dir, _ in rotation_rule:
for array in arrays_plus:
if array['id'] == array_id:
abstract.rotate_array(array, dir, np.deg2rad(angle_tol))
for array in arrays_minus:
if array['id'] == array_id:
abstract.rotate_array(array, dir, np.deg2rad(-angle_tol))
# create and run simulation
kwargs, meta = Solver.connector(simulation, *arrays_plus)
solver_plus = Solver(**kwargs)
solver_plus.solve(field_pos)
# create and run simulation
kwargs, meta = Solver.connector(simulation, *arrays_minus)
solver_minus = Solver(**kwargs)
solver_minus.solve(field_pos)
# extract results and save
angle = rotation_rule[0][2]
with write_lock:
with closing(sql.connect(file)) as con:
rf_data = solver_plus.result['rf_data']
b = np.max(util.envelope(rf_data, axis=1), axis=1)
update_image_table(con, angle, angle_tol, 'plus', field_pos, b)
rf_data = solver_minus.result['rf_data']
b = np.max(util.envelope(rf_data, axis=1), axis=1)
update_image_table(con, angle, angle_tol, 'minus', field_pos, b)
util.update_progress(con, job_id)