def test_calculate_est_anj_coords_and_cov_matrix_for_jammer_and_jammer(self) -> None:
"""Проверка вычисления координат и ковариационной матрциы ближайшей точки на пеленге
при отождествлении двух трасс постановщиков АШП
:return: None
"""
# Определим нужные для функции параметры
self.source_trace.coordinates = np.array([1., 0., 0.])
self.source_trace.mfr_position = np.ones(3)
self.source_trace.coordinate_covariance_matrix = np.diag([1., 1., 0.])
# Вторая трасса по постановщику АШП
trace = SourceTrace(mfr_position=np.zeros(3))
trace.coordinates = np.array([0., 0., 1.])
trace.coordinate_covariance_matrix = np.diag([1., 0., 1])
# Расчет тестируемой функцией
coordinates, cov_matrix = self.source_trace.calc_est_anj_coords_and_cov_matrix_for_jammer_and_jammer(trace)
# Проверка для координат
coordinates = coordinates.tolist()
real_coordinates = [1, 0, 0]
self.assertEqual(real_coordinates, coordinates, "Расчет координат неверный")
# Проверка для ковариационной матрицы
cov_matrix = cov_matrix.tolist()
real_cov_matrix = [[1., 0., 0.],
[0., 1., 0.],
[0., 0., 0.]]
self.assertEqual(real_cov_matrix, cov_matrix, "Расчет ковариационной матрицы неверный")
def test_unsuccessful_must_identify_with_source_trace(self) -> None:
"""Проверка для возможности отождествления с трассой источника
Должны получить True для трассы с номером МФР, от которого в трассе ЕМТ есть трасса источника
:return: None
"""
# Подготовка данных для функции, по такому номеру МФР есть трасса головного источника
source_trace = SourceTrace(mfr_number=1)
# Вызов тестируемой функции
must_identify = self.cta_trace.must_identify_with_source_trace(
source_trace)
# Проверка для необходимости отождествления
self.assertFalse(must_identify, "Не должны были отождествлять")
# ______________________________________________________________________________________________________________
# Проверим, что влияет и наличие дополнительного источника:
# если в трассе ЕМТ от МФР с таким номером есть трасса, то отождествления происходить не должно
add_source_trace = SourceTrace(mfr_number=2)
self.cta_trace.additional_source_trace_array.append(add_source_trace)
another_source_trace = SourceTrace(mfr_number=2)
# Вызов тестируемой функции
must_identify = self.cta_trace.must_identify_with_source_trace(
another_source_trace)
# Проверка для необходимости отождествления
self.assertFalse(must_identify, "Не должны были отождествлять")
def test_remove_all_less_accuracy_traces(self) -> None:
"""Тест удаления всех менее точных трасс из списка
:return: None
"""
# Подготовка данных для функции
first_source_trace = SourceTrace(mfr_number=1)
self.common_trace_array.append(first_source_trace)
first_cta_trace = self.common_trace_array[0]
second_source_trace = SourceTrace(mfr_number=2)
self.common_trace_array.append(second_source_trace)
second_cta_trace = self.common_trace_array[1]
# Объединение в список
identified_traces = [first_cta_trace, second_cta_trace]
# Вызов тестируемой функции
self.common_trace_array.remove_all_less_accuracy_traces(
identified_traces)
# Проверка для длины ЕМТ
len_cta = len(self.common_trace_array)
real_len_cta = 1
self.assertEqual(real_len_cta, len_cta, "Длина ЕМТ определена неверно")
def test_unsuccessful_must_identify_with_cta_trace(self) -> None:
"""Проверяет возможность отождествления с трассой ЕМТ
:return: None
"""
# Подготовка данных для функций
add_source_trace = SourceTrace(mfr_number=2,
mfr_position=np.array([100., 34., 43.]))
self.cta_trace.additional_source_trace_array.append(add_source_trace)
identifying_head_source_trace = SourceTrace(mfr_number=4)
identifying_cta_trace = CTATrace(identifying_head_source_trace)
identifying_add_source_trace = SourceTrace(mfr_number=1)
identifying_cta_trace.additional_source_trace_array.append(
identifying_add_source_trace)
# Не должны отождествлять (номера мфр)
must_identify = self.cta_trace.must_identify_with_cta_trace(
identifying_cta_trace)
# Проверка для возможности отождествления
self.assertFalse(must_identify)
identifying_head_source_trace = SourceTrace(mfr_number=4)
identifying_cta_trace = CTATrace(identifying_head_source_trace)
identifying_add_source_trace = SourceTrace(mfr_number=3)
identifying_cta_trace.additional_source_trace_array.append(
identifying_add_source_trace)
# Должны отождествлять
must_identify = self.cta_trace.must_identify_with_cta_trace(
identifying_cta_trace)
self.assertTrue(must_identify)
def test_unsuccessful_identification_with_others_cta_traces_for_cta_trace(
self) -> None:
"""Тест неудачного отождествления трассы ЕМТ с другими трассами ЕМТ
:return: None
"""
# Подготовка данных для функции
# Подготовка первой трассы ЕМТ
first_source_trace = SourceTrace(mfr_number=0)
self.common_trace_array.append(first_source_trace)
first_cta_trace: CTATrace = self.common_trace_array[0]
# Подготовка второй трассы ЕМТ
second_source_trace = SourceTrace(mfr_number=2)
second_source_trace.coordinates = np.array([40., 3535., 42246.])
self.common_trace_array.append(second_source_trace)
second_cta_trace: CTATrace = self.common_trace_array[1]
# Вызов тестируемой функции
self.common_trace_array.identification_with_others_cta_traces_for_cta_trace(
first_cta_trace)
# После вызова тестируемой функции, в ЕМТ должны были остаться обе трассы,
# так как трассы не отождествлились
# Проверка для наличия в ЕМТ первой трассы ЕМТ
is_first_trace_in_cta = first_cta_trace in self.common_trace_array
self.assertTrue(is_first_trace_in_cta, "Первая трасса ушла из ЕМТ")
# Проверка для наличия в ЕМТ второй трассы
is_second_trace_in_cta = second_cta_trace in self.common_trace_array
self.assertTrue(is_second_trace_in_cta, "Вторая трасса ушла из ЕМТ")
def test_append_new_additional_source_trace_in_cta_trace(self) -> None:
"""Тест добавления нового дополнительного источника
:return: None
"""
# Подготовка данных для функции
# Первая трасса ЕМТ
head_source_trace = SourceTrace(mfr_number=0)
self.common_trace_array.append(head_source_trace)
first_cta_trace: CTATrace = self.common_trace_array[0]
# Вторая трасса ЕМТ
head_source_trace = SourceTrace(mfr_number=1)
self.common_trace_array.append(head_source_trace)
second_cta_trace: CTATrace = self.common_trace_array[1]
# Добавление трассы дополнительного источника, которая успешно отождествлится с двумя трассами ЕМТ
new_source_trace = SourceTrace(mfr_number=2)
# Отождествление c двумя трассами ЕМТ
new_source_trace.identified_number_cta_trace_dict = {5.87: 1, 0.: 0}
# Выполнение тестируемой функции
self.common_trace_array.append_new_additional_source_trace_in_cta_trace(
new_source_trace)
# Проверим, что у первой трассы появился новый доп. источник
new_source_in_first_cta_trace = new_source_trace in first_cta_trace.additional_source_trace_array
self.assertTrue(new_source_in_first_cta_trace)
# Проверка, что у второй трассы такого источника нет
self.assertFalse(
new_source_trace in second_cta_trace.additional_source_trace_array)
def test_unsuccessful_identification_with_head_source_trace_for_additional_source_trace(
self) -> None:
"""Тест неудачного отождествления с головной трассой источника для трассы дополнительного источника
:return: None
"""
# Подготовка данных для функции
head_source_trace = SourceTrace(mfr_number=0)
another_source_trace = SourceTrace(mfr_number=1)
another_source_trace.coordinates = np.array([232., 3554., 464.])
self.common_trace_array.append(head_source_trace)
cta_trace: CTATrace = self.common_trace_array[0]
cta_trace.additional_source_trace_array.append(another_source_trace)
# Вызов тестируемой функции
self.common_trace_array.identification_with_head_source_trace_for_additional_source_trace(
another_source_trace)
# Проверка для признака наличия трассы в составе массива трасс источников
is_in_source_array = another_source_trace in cta_trace.additional_source_trace_array
self.assertFalse(
is_in_source_array,
"Трасса не была удалена из массива трасс от дополнительных источников"
)
def test_calculate_est_anj_coords_and_cov_matrix_for_jammer_and_target(self) -> None:
"""Расчет координат и ковариационной матрицы в случае отождествления чистой трассы и постановщика АШП
:return: None
"""
# Определим необходимые для функции данные
self.source_trace.coordinates = np.array([1., 0., 0.])
self.source_trace.mfr_position = np.ones(3)
self.source_trace.coordinate_covariance_matrix = np.diag([1., 1., 0.])
# Трасса постановщика АШП
trace = SourceTrace()
trace.coordinates = np.array([0., 0, 1.])
trace.coordinate_covariance_matrix = np.diag([1., 0., 1])
# Расчет тестируемой функцией
coordinates, cov_matrix = self.source_trace.calc_est_anj_coords_and_cov_matrix_for_jammer_and_target(trace)
# Проверка для координат
coordinates = coordinates.tolist()
real_coordinates = [1., 0.5, 0.5]
self.assertEqual(coordinates, real_coordinates, "Расчет координат неверный")
# Проверка для ковариационной матрицы
cov_matrix = cov_matrix.tolist()
real_cov_matrix = [[0.25, 0.0, 0.0],
[0.0, 0.25, 0.0],
[0.0, 0.0, 0.0]]
self.assertEqual(cov_matrix, real_cov_matrix, "Расчет ковариационной матрицы неверный")
def generate_estimator_two_not_bearing_traces(
self) -> EstimatorTwoNotBearingTraces:
"""Конструирует оценивателя для случая, когда есть две трассы по постановщику АШП
:return: Оцениватель
:rtype: EstimatorTwoNotBearingTraces
"""
source_trace_list = [SourceTrace(), SourceTrace()]
return self.fabric.generate(source_trace_list)
def test_identification(self) -> None:
"""Тест отождествления трасс источников с трассами ЕМТ
:return: None
"""
# Подготовка нужных для функции данных
first_source_trace = SourceTrace(mfr_number=0)
self.common_trace_array.append(first_source_trace)
first_cta_trace: CTATrace = self.common_trace_array[0]
# (дополнительный источник по той же трассе ЕМТ, произойдёт успешное отожедствление с головным)
second_source_trace = SourceTrace(mfr_number=1)
second_source_trace.identified_number_cta_trace_dict = {2.74: 0}
first_cta_trace.add_new_source_trace(second_source_trace)
# Третья трасса источника (её нет в ЕМТ, не отождествится ни с чем (из-за номера))
third_source_trace = SourceTrace(mfr_number=1)
# Объединение в один список
source_trace_list = SourceTraceList(
[first_source_trace, second_source_trace, third_source_trace])
# ______________________________________________________________________________________________________________
# Выполнение тестируемой функции
self.common_trace_array.identification(source_trace_list)
# ______________________________________________________________________________________________________________
# После отождествление в ЕМТ две трассы, первая с доп. источником, вторая по третьей трассе
second_cta_trace: CTATrace = self.common_trace_array[1]
# Проверка для длины ЕМТ
len_cta = len(self.common_trace_array)
real_len_cta = 2
self.assertEqual(real_len_cta, len_cta, "Длина ЕМТ опредлена неверно")
# Проверка для нахождения второй трассы источника в массиве доп. трасс
second_trace_in_additional_array = second_source_trace in first_cta_trace.additional_source_trace_array
self.assertTrue(second_trace_in_additional_array,
"Вторая трасса источника не была добавлена в ЕМТ")
# Проверка для длины массива трасс от доп. источников
len_additional_array = len(
first_cta_trace.additional_source_trace_array)
real_len_additional_array = 1
self.assertEqual(real_len_additional_array, len_additional_array,
"Длина массива трасс от доп. неверна")
# Проверка того, что головной трассой по второй трассе ЕМТ стала третья трасса истчочника
is_third_source_trace_head = third_source_trace == second_cta_trace.head_source_trace
self.assertTrue(
is_third_source_trace_head,
"Третья трасса источника не стала головной по второй трассе ЕМТ")
# Проверка что у второй трассы нет дополнительных источников
additional_array = second_cta_trace.additional_source_trace_array
real_additional_array = []
self.assertEqual(real_additional_array, additional_array,
"У второй трассы ЕМТ есть доп. источник")
def generate_estimator_two_bearing_traces(
self) -> EstimatorTwoBearingTraces:
"""Конструирует оценивателя для случая, когда есть две трассы чистой цели
:return: Оцениватель
:rtype: EstimatorTwoBearingTraces
"""
first_trace = SourceTrace()
second_trace = SourceTrace()
first_trace.is_bearing = second_trace.is_bearing = True
source_trace_list = [first_trace, second_trace]
return self.fabric.generate(source_trace_list)
def test_append(self) -> None:
"""Тест добавления трассы источника как новой трассы ЕМТ
:return: None
"""
# Подготовка данных для функции
source_trace = SourceTrace(mfr_number=1, mfr_position=np.zeros(3))
# Вызов тестируемой функции
self.common_trace_array.append(source_trace)
appended_cta_trace = self.common_trace_array[0]
# Проверка для типа добавленной трассы
type_trace = type(appended_cta_trace)
real_type_trace = CTATrace
self.assertEqual(real_type_trace, type_trace,
"Тип трассы установлен неверно")
# Проверка для номера трассы ЕМТ
num_cta_trace = appended_cta_trace.number
real_num_cta_trace = 0
self.assertEqual(real_num_cta_trace, num_cta_trace,
"Номер трассы ЕМТ определен неверно")
# Проверка для длины ЕМТ
len_cta = len(self.common_trace_array)
real_len_cta = 1
self.assertEqual(real_len_cta, len_cta, "Длина ЕМТ определена неверно")
def test_get_all_sources_trace(self) -> None:
"""Тест для получения всех трасс источников
:return: None
"""
# Подготовка данных для функции
add_source_trace = SourceTrace(mfr_number=2,
mfr_position=np.array([100., 34., 43.]))
self.cta_trace.additional_source_trace_array.append(add_source_trace)
# Вызов тестируемой функции
all_source_traces = self.cta_trace.all_source_traces
# Проверка для нахождения трассы головного источника в списке
is_head_source_trace_in_list = self.cta_trace.head_source_trace in all_source_traces
self.assertTrue(is_head_source_trace_in_list,
"Трасса головного источника не в списке")
# Проверка для нахождения трассы дополнительного источника в списке
is_add_source_trace_in_list = add_source_trace in all_source_traces
self.assertTrue(is_add_source_trace_in_list,
"Трасса дополнительного источника не в списке")
# Проверка для длины возващаемого функцией массива
len_all_source_traces = len(all_source_traces)
real_len_all_source_traces = 2
self.assertEqual(real_len_all_source_traces, len_all_source_traces,
"Длина списка определена неверно")
def setUp(self) -> None:
"""Сохраняет ссылки на нужные объекты, откатывает их после каждого теста
:return: None
"""
self.head_source_trace = SourceTrace(mfr_number=1)
self.cta_trace = CTATrace(self.head_source_trace)
def test_get_sorted_traces(self) -> None:
"""Тест для сортировки трасс источников по точности
:return: None
"""
# Подготовка данных для функции
# Создание списка из трасс источников, в котором источника расположены в убывании по точности
list_source_traces = [SourceTrace(1, np.zeros(3)) for _ in range(8)]
for trace, index in zip(list_source_traces,
range(len(list_source_traces))):
trace.is_bearing = index <= 3
trace.is_auto_tracking = index not in [0, 1, 4, 5]
trace.estimate_tick = index % 2
# На основвании такого списка создание списка трасс ЕМТ
list_cta_traces = [
CTATrace(source_trace) for source_trace in list_source_traces
]
# Вызов тестируемой функции для сортировки
sorted_cta_traces = self.common_trace_array.get_sorted_traces(
list_cta_traces)
# В результате выполнения функции должен был получиться в этом случае инвертированный входной список
# Проверка для результирующего списка
real_sorted_cta_traces = list(reversed(list_cta_traces))
self.assertEqual(real_sorted_cta_traces, sorted_cta_traces,
"Результирующий список определён неверно")
def test_sort_sources(self) -> None:
"""
:return: None
"""
add_source_trace = SourceTrace(mfr_number=2,
mfr_position=np.array([100., 34., 43.]))
add_source_trace.is_auto_tracking = True
self.cta_trace.additional_source_trace_array.append(add_source_trace)
# Дполнительный и головной иоточник должны поменяться местами (у доп. АС - он точнее)
self.cta_trace.sort_sources()
self.assertTrue(add_source_trace is self.cta_trace.head_source_trace)
self.assertTrue(self.head_source_trace in
self.cta_trace.additional_source_trace_array)
def test_register(self) -> None:
"""Тест для регистрации ПБУ
:return: None
"""
# Определение нужной для функции данных
self.command_post.tick = 23
self.command_post.common_trace_array.append(SourceTrace())
cta_trace: CTATrace = self.command_post.common_trace_array[0]
cta_trace.number = 88
cta_trace.coordinates = np.array([34., 323., -293.])
cta_trace.velocities = np.array([200., 23., -21.])
cta_trace.coordinate_covariance_matrix = np.diag([32., 34., 569.])
# Выполненение тестируемой функции
self.command_post.register()
# Проверка для регистрации
registration = self.command_post.registration
real_registration = [[
23, 88, 34.0, 323.0, -293.0, 200.0, 23.0, -21.0, 32.0, 34.0, 569.0,
0.0, 0.0, 0.0, 1
]]
self.assertEqual(real_registration, registration,
"Регистрация посчитана неверно")
def __init__(self, target: Target, mfr_number: int,
mfr_stable_point: ndarray) -> None:
# Текущее время в тиках
self.estimate_tick = 0
# Цель
self.target = target
# Признак пеленга
self.is_bearing = target.is_anj[mfr_number]
# Тип сопровождения
self.is_auto_tracking = target.is_auto_tracking[mfr_number]
# Априорная дальность (для постановщика АШП)
self.default_range = 50_000.
# Временных тиков между измерениями
self.frame_tick = 2 if self.is_auto_tracking else 20
frame_time = self.frame_tick * time_in_tick
# Собственный фильтр
self.filter = FilterAB(frame_time, manoeuvre_overload=4)
# Данные по координатам
self.coordinates_data = TraceCoordinatesData()
# Данные по скоростям
self.velocities_data = TraceVelocitiesData()
# Данные по дисперсиям в БСК
self.variance_bcs_data = TraceVarianceBCSData()
# Данные по ковариационным матрицам
self.covariance_matrix_data = TraceCovarianceMatrixData()
# Трасса источника (для пользования ПБУ)
self.source_trace = SourceTrace(mfr_number, mfr_stable_point,
target.number)
def test_add_new_source_trace(self) -> None:
"""
:return: None
"""
add_source_trace = SourceTrace(mfr_number=2,
mfr_position=np.array([100., 34., 43.]))
add_source_trace.identified_number_cta_trace_dict = {
0.: self.cta_trace.number
}
self.cta_trace.add_new_source_trace(add_source_trace)
self.assertEqual(1, len(self.cta_trace.additional_source_trace_array))
self.assertTrue(
add_source_trace in self.cta_trace.additional_source_trace_array)
def append(self, trace: SourceTrace) -> None:
"""Добавление трассы в ЕМТ
:param trace: Трасса ЕМТ, которую необходимо добавить
:type trace: SourceTrace
:return: None
"""
# Создаём новую трассу ЕМТ
new_cta_trace = CTATrace(head_source_trace=trace)
# Добавляем в ЕМТ
super().append(new_cta_trace)
# Даём новой трассе новый номер
new_cta_trace.number = self.index(new_cta_trace)
# Добавляем информацию и номер трассы ЕМТ в трассу источника
trace.append_cta_info_and_number(num=new_cta_trace.number, is_head=True)
def test_unsuccessful_identify_with_others_cta_traces_for_new_trace_with_number(
self) -> None:
"""Тест неуспешного отождествления из-за номера МФР
:return: None
"""
# Подготовка данных для функции
self.common_trace_array.append(SourceTrace(mfr_number=1))
another_source_trace = SourceTrace(mfr_number=1)
# Выполнение ототждествления тестируемой функцией
self.common_trace_array.identification_with_others_cta_traces_for_new_source_trace(
another_source_trace)
# Проверка для длины ЕМТ
len_cta = len(self.common_trace_array)
real_len_cta = 2
self.assertEqual(real_len_cta, len_cta, "Длина ЕМТ определена неверно")
def generate_estimator_only_head_source_trace(
self) -> EstimatorOnlyHeadSourceTrace:
"""Конструирует оценивателя для случая, когда есть только один источник
:return: Оцениватель
:rtype: EstimatorOnlyHeadSourceTrace
"""
source_trace_list = [SourceTrace()]
return self.fabric.generate(source_trace_list)
def setUp(self) -> None:
"""Сохраняет ссылку на объекты, откатывавет их после каждого теста
:return: None
"""
mfr_position = np.array([1100., 20., 800])
self.source_trace = SourceTrace(mfr_number=4, mfr_position=mfr_position)
initial_list = [self.source_trace]
self.source_trace_list = SourceTraceList(initial_list)
def test_update_numbers_in_cta_traces(self) -> None:
"""Тест обновления номеров в трассах ЕМТ
:return: None
"""
# Подготвка данных для функции
# Первая трасса ЕМТ
first_head_source_trace = SourceTrace(mfr_number=1)
self.common_trace_array.append(first_head_source_trace)
first_cta_trace: CTATrace = self.common_trace_array[0]
# Вторая трасса ЕМТ
second_head_source_trace = SourceTrace(mfr_number=2)
self.common_trace_array.append(second_head_source_trace)
second_cta_trace: CTATrace = self.common_trace_array[1]
# Вызов тестируемой функции
self.common_trace_array.update_numbers_in_cta_traces()
# Проверка для номера первой трассы ЕМТ
first_cta_trace_num = first_cta_trace.number
real_first_cta_trace_num = 0
self.assertEqual(real_first_cta_trace_num, first_cta_trace_num,
"Номер трассы ЕМТ неверный")
# Проверка для номера трассы ЕМТ головного источника первой трассы ЕМТ
first_cta_trace_num_in_source_trace = first_head_source_trace.cta_number
self.assertEqual(real_first_cta_trace_num,
first_cta_trace_num_in_source_trace,
"Номер трассы ЕМТ неверный")
# Проверка для номера второй трассы ЕМТ
second_cta_trace_num = second_cta_trace.number
real_second_cta_trace_num = 1
self.assertEqual(real_second_cta_trace_num, second_cta_trace_num,
"Номер трассы ЕМТ неверный")
# Проверка для номера трассы ЕМТ головного источника второй трассы ЕМТ
second_cta_trace_num_in_source_trace = second_head_source_trace.cta_number
self.assertEqual(real_second_cta_trace_num,
second_cta_trace_num_in_source_trace,
"Номер трассы ЕМТ неверный")
def identification_with_head_source_trace_for_additional_source_trace(self,
additional_source_trace: SourceTrace) -> None:
"""Отождествление трассы дополнительного источника с трассой головного источника по той же трассе ЕМТ
:param additional_source_trace: Трасса дополнительного источника
:type additional_source_trace: SourceTrace
:return: None
"""
# Очищаем вспомогательный словарь для хранения трасс ЕМТ, с которыми отождествились
additional_source_trace.clear_identified_number_cta_trace_dict()
# Трасса ЕМТ, с которой работает эта трасса источника
cta_trace: CTATrace = self[additional_source_trace.cta_number]
additional_source_trace.identification_with_trace(cta_trace.head_source_trace)
# Если если трасса дополнительного источника не отождествилась с трассой головного источника
if not additional_source_trace.identified_number_cta_trace_dict:
# Удаляем трассу этого источника из дополнительных
cta_trace.del_additional_source_trace(additional_source_trace)
# Добавляем трассу в ЕМТ
self.append(additional_source_trace)
def test_false_identification_target_and_target(self) -> None:
"""Тестирование отождествления двух трасс по двум разным чистым целям
:return: None
"""
# Определим нужные для функции параметры
self.source_trace.coordinates = np.array([0., 0., 1_100.])
self.source_trace.coordinate_covariance_matrix = np.diag([22_443., 258., 3_344.])
# Трасса, с которой будет проводиться отождествление
trace = SourceTrace()
trace.cta_number = 4
trace.coordinates = np.array([45_860., 0, 1_100.])
trace.coordinate_covariance_matrix = np.diag([243., 659., 496])
# Отождествляем функцией
self.source_trace.identification_target_and_target(trace)
# Проверка для словаря с отождествишимися трассами
dictionary = self.source_trace.identified_number_cta_trace_dict
real_dictionary = {}
self.assertDictEqual(real_dictionary, dictionary, "Словарь с отождествившимися трассами не пуст")
def test_false_identification_jammer_and_jammer(self) -> None:
"""Проверка отождествления двух трасс по двум разным постановщикам АШП
:return: None
"""
# Определим нужные для функции параметры
self.source_trace.mfr_position = np.array([1_100., 0., 0.])
self.source_trace.coordinates = np.array([550., 0., 5_500.])
self.source_trace.coordinate_covariance_matrix = np.diag([22_443., 258., 3_344.])
# Трасса, с которой будет проводиться отождествление
trace = SourceTrace(mfr_position=np.array([-1_100., 0., 0.]))
trace.coordinates = np.array([-34_550., 43_430, -43_550.])
trace.coordinate_covariance_matrix = np.diag([243., 659., 496])
# Отождествляем функцией
self.source_trace.identification_jammer_and_jammer(trace)
# Проверка для словаря с отождествиишимимся трассами
dictionary = self.source_trace.identified_number_cta_trace_dict
real_dictionary = {}
self.assertDictEqual(real_dictionary, dictionary, "Словарь с отождествившимися трассами не пуст")
def test_successful_identification_with_others_cta_traces_for_cta_trace(
self) -> None:
"""Тест успешного отождествления трассы ЕМТ с другими трассами ЕМТ
:return: None
"""
# Подготовка данных для функции
# Подготовка первой трассы ЕМТ
first_source_trace = SourceTrace(mfr_number=0)
first_source_trace.is_auto_tracking = True
self.common_trace_array.append(first_source_trace)
first_cta_trace: CTATrace = self.common_trace_array[0]
# Подготовка второй трассы ЕМТ
second_source_trace = SourceTrace(mfr_number=1)
second_source_trace.is_auto_tracking = False
self.common_trace_array.append(second_source_trace)
second_cta_trace: CTATrace = self.common_trace_array[1]
# Вызов тестируемой функции
self.common_trace_array.identification_with_others_cta_traces_for_cta_trace(
first_cta_trace)
# После вызова тестируемой функции, в ЕМТ должна была остаться только первая трасса,
# так как трассы отождествлились,
# и первая трасса имеет более высокий приоритет за счет признака автосопровождения
# Проверка для наличия в ЕМТ первой трассы
is_first_trace_in_cta = first_cta_trace in self.common_trace_array
self.assertTrue(is_first_trace_in_cta, "Первая трасса ушла из ЕМТ")
# Проверка для наличия в ЕМТ второй трассы
is_second_trace_in_cta = second_cta_trace in self.common_trace_array
self.assertFalse(is_second_trace_in_cta,
"Вторая трасса ЕМТ не ушла из ЕМТ")
def test_remove_less_accuracy_cta_traces_with_numbers(self) -> None:
"""Тест удаления наименее точных трасс с указаннами номерами
:return: None
"""
# Подготовка данных для функции
# Первая трасса, самая точная
num_first_trace_in_cta = 0
first_head_source_trace = SourceTrace(mfr_number=1)
first_head_source_trace.is_auto_tracking = True
self.common_trace_array.append(first_head_source_trace)
first_cta_trace: CTATrace = self.common_trace_array[0]
# Вторая трасса, менее точная
num_second_trace_in_cta = 1
second_head_source_trace = SourceTrace(mfr_number=2)
second_head_source_trace.is_auto_tracking = False
self.common_trace_array.append(second_head_source_trace)
second_cta_trace: CTATrace = self.common_trace_array[1]
# Объединение в список
cta_traces = [num_first_trace_in_cta, num_second_trace_in_cta]
# Вызов тестируемой функции
self.common_trace_array.remove_less_accuracy_cta_traces_with_numbers(
cta_traces)
# Проверка для нахождения первой трассы в ЕМТ
is_first_trace_in_cta = first_cta_trace in self.common_trace_array
self.assertTrue(is_first_trace_in_cta, "Первая трасса ушла из ЕМТ")
# Проверка для нахождения второй трассы в ЕМТ
is_second_trace_in_cta = second_cta_trace in self.common_trace_array
self.assertFalse(is_second_trace_in_cta,
"Вторая трасса не ушла из ЕМТ")
def test_delete_sources_traces(self) -> None:
"""
:return: None
"""
add_source_trace = SourceTrace(mfr_number=2,
mfr_position=np.array([100., 34., 43.]))
self.cta_trace.additional_source_trace_array.append(add_source_trace)
self.cta_trace.delete_sources_traces()
self.assertEqual([], self.cta_trace.additional_source_trace_array)
self.assertIsNone(self.cta_trace.head_source_trace)
