def __check_equality_of_phase_closure_outputs(mpi_conf, sr_conf):
m_config = Configuration(mpi_conf)
s_config = Configuration(sr_conf)
m_close = m_config.closure()
s_close = s_config.closure()
m_closure = np.load(m_close.closure)
s_closure = np.load(s_close.closure)
# loops
m_loops = np.load(m_close.loops, allow_pickle=True)
s_loops = np.load(s_close.loops, allow_pickle=True)
m_weights = [m.weight for m in m_loops]
s_weights = [m.weight for m in s_loops]
np.testing.assert_array_equal(m_weights, s_weights)
for i, (m, s) in enumerate(zip(m_loops, s_loops)):
assert all(m_e == s_e for m_e, s_e in zip(m.edges, s.edges))
# closure
np.testing.assert_array_almost_equal(np.abs(m_closure),
np.abs(s_closure),
decimal=4)
# num_occurrences_each_ifg
m_num_occurences_each_ifg = np.load(m_close.num_occurences_each_ifg,
allow_pickle=True)
s_num_occurences_each_ifg = np.load(s_close.num_occurences_each_ifg,
allow_pickle=True)
np.testing.assert_array_equal(m_num_occurences_each_ifg,
s_num_occurences_each_ifg)
# check ps
m_ifgs_breach_count = np.load(m_close.ifgs_breach_count)
s_ifgs_breach_count = np.load(s_close.ifgs_breach_count)
np.testing.assert_array_equal(m_ifgs_breach_count, s_ifgs_breach_count)
def __wrap_closure_check(config: Configuration) -> \
Tuple[
List[str],
NDArray[(Any, Any), Float32],
NDArray[(Any, Any, Any), UInt16],
NDArray[(Any,), UInt16],
List[WeightedLoop]]:
"""
This wrapper function returns the closure check outputs for a single iteration of closure check.
:param config: Configuration class instance
For return variables see docstring in `sum_phase_closures`.
"""
params = config.__dict__
ifg_files = [
ifg_path.tmp_sampled_path for ifg_path in params[C.INTERFEROGRAM_FILES]
]
ifg_files.sort()
log.debug(f"The number of ifgs in the list is {len(ifg_files)}")
sorted_signed_loops = mpiops.run_once(sort_loops_based_on_weights_and_date,
params)
log.info(
f"Total number of selected closed loops with up to MAX_LOOP_LENGTH = "
f"{params[C.MAX_LOOP_LENGTH]} edges is {len(sorted_signed_loops)}")
if len(sorted_signed_loops) < 1:
return None
retained_loops = mpiops.run_once(discard_loops_containing_max_ifg_count,
sorted_signed_loops, params)
ifgs_with_loops = mpiops.run_once(__drop_ifgs_if_not_part_of_any_loop,
ifg_files, retained_loops, params)
msg = f"After applying MAX_LOOP_REDUNDANCY = {params[C.MAX_LOOP_REDUNDANCY]} criteria, " \
f"{len(retained_loops)} loops are retained"
if len(retained_loops) < 1:
return None
else:
log.info(msg)
closure, ifgs_breach_count, num_occurences_each_ifg = sum_phase_closures(
ifgs_with_loops, retained_loops, params)
if mpiops.rank == 0:
closure_ins = config.closure()
np.save(closure_ins.closure, closure)
np.save(closure_ins.ifgs_breach_count, ifgs_breach_count)
np.save(closure_ins.num_occurences_each_ifg, num_occurences_each_ifg)
np.save(closure_ins.loops, retained_loops, allow_pickle=True)
selected_ifg_files = mpiops.run_once(__drop_ifgs_exceeding_threshold,
ifgs_with_loops, ifgs_breach_count,
num_occurences_each_ifg, params)
# update the ifg list in the parameters dictionary
params[C.INTERFEROGRAM_FILES] = \
mpiops.run_once(update_ifg_list, selected_ifg_files, params[C.INTERFEROGRAM_FILES])
return selected_ifg_files, closure, ifgs_breach_count, num_occurences_each_ifg, retained_loops
def test_mpi_vs_single_process(modified_config):
mpi_conf, m_params = modified_config(MEXICO_CROPA_CONF, 0, 'mpi_conf.conf')
sub_process_run(f"mpirun -n 3 pyrate conv2tif -f {mpi_conf}")
sub_process_run(f"mpirun -n 3 pyrate prepifg -f {mpi_conf}")
sub_process_run(f"mpirun -n 3 pyrate correct -f {mpi_conf}")
serial_conf, s_params = modified_config(MEXICO_CROPA_CONF, 0,
'single_conf.conf')
sub_process_run(f"pyrate conv2tif -f {serial_conf}")
sub_process_run(f"pyrate prepifg -f {serial_conf}")
sub_process_run(f"pyrate correct -f {serial_conf}")
parallel_conf, p_params = modified_config(MEXICO_CROPA_CONF, 1,
'parallel_conf.conf')
sub_process_run(f"pyrate conv2tif -f {parallel_conf}")
sub_process_run(f"pyrate prepifg -f {parallel_conf}")
sub_process_run(f"pyrate correct -f {parallel_conf}")
m_config = Configuration(mpi_conf)
s_config = Configuration(serial_conf)
p_config = Configuration(parallel_conf)
m_closure = np.load(m_config.closure().closure)
s_closure = np.load(s_config.closure().closure)
p_closure = np.load(p_config.closure().closure)
# loops
m_loops = np.load(m_config.closure().loops, allow_pickle=True)
s_loops = np.load(s_config.closure().loops, allow_pickle=True)
p_loops = np.load(p_config.closure().loops, allow_pickle=True)
m_weights = [m.weight for m in m_loops]
s_weights = [m.weight for m in s_loops]
p_weights = [m.weight for m in p_loops]
np.testing.assert_array_equal(m_weights, s_weights)
np.testing.assert_array_equal(m_weights, p_weights)
for i, (m, s) in enumerate(zip(m_loops, s_loops)):
assert all(m_e == s_e for m_e, s_e in zip(m.edges, s.edges))
# closure
np.testing.assert_array_almost_equal(np.abs(m_closure),
np.abs(s_closure),
decimal=4)
np.testing.assert_array_almost_equal(np.abs(m_closure),
np.abs(p_closure),
decimal=4)
# num_occurrences_each_ifg
m_num_occurrences_each_ifg = np.load(
m_config.closure().num_occurences_each_ifg, allow_pickle=True)
s_num_occurrences_each_ifg = np.load(
s_config.closure().num_occurences_each_ifg, allow_pickle=True)
p_num_occurrences_each_ifg = np.load(
p_config.closure().num_occurences_each_ifg, allow_pickle=True)
np.testing.assert_array_equal(m_num_occurrences_each_ifg,
s_num_occurrences_each_ifg)
np.testing.assert_array_equal(m_num_occurrences_each_ifg,
p_num_occurrences_each_ifg)
# check ps
m_ifgs_breach_count = np.load(m_config.closure().ifgs_breach_count)
s_ifgs_breach_count = np.load(s_config.closure().ifgs_breach_count)
p_ifgs_breach_count = np.load(p_config.closure().ifgs_breach_count)
np.testing.assert_array_equal(m_ifgs_breach_count, s_ifgs_breach_count)
np.testing.assert_array_equal(m_ifgs_breach_count, p_ifgs_breach_count)