def setUp_radars_states(self):
# Radars definitions
self.radar1 = Radar(x=2000,y=2000)
self.radar2 = Radar(x=1000,y=1000)
self.radars = [self.radar1, self.radar2]
# States definition
self.states = np.array([[i,i/2,i/10]*3 for i in range(3000)])
def setUp(self):
self.radar1 = Radar(x=800,y=800)
self.radar2 = Radar(x=200,y=200)
radars = [self.radar1,self.radar2]
self.q = 10.
self.multiplef_ta = MultiplePeriodRadarsFilterTA(dim_x = 9, dim_z = 3, q = self.q,
radars = radars,
x0 = 100, y0 = 100)
def setUp(self):
self.radar1 = Radar(x=800,y=800)
self.radar2 = Radar(x=200,y=200)
radars = [self.radar1,self.radar2]
self.q = 10.
self.multiple_cv = MultipleRadarsFilterCV(dim_x = 9, dim_z = 3, q = self.q,
radars = radars,
x0 = 100, y0 = 100)
def test_initialization_no_errors(self):
self.assertTrue(np.array_equal(self.attacker.gamma,self.gamma))
self.assertTrue(np.array_equal(self.attacker.mag_vector,self.mag_vector))
self.assertEqual(self.t0,10)
self.assertEqual(self.time,50)
self.assertEqual(self.radar, Radar(x=10,y=10))
self.assertTrue(np.array_equal(self.attacker.attack_drift,np.array([[0,0,10]]).T))
def setUp(self):
self.radar = Radar(x=0, y=0)
self.q = 10.
self.filter_ct = RadarFilterCT(dim_x=9,
dim_z=3,
q=self.q,
radar=self.radar)
def setUp(self):
# Simulated filter for 2 radars (2*3 measurements)
self.filter = ExtendedKalmanFilter(dim_x = 9, dim_z = 6)
self.gamma = np.eye(3)
self.mag_vector = np.array([[-10, -10, -10]]).T
self.t0 = 10
self.time = 50
self.radar = Radar(x=10,y=10)
self.radar_pos = 1
self.attacker = PeriodAttacker(filter = self.filter,
radar = self.radar, radar_pos = self.radar_pos,
gamma = self.gamma,mag_vector = self.mag_vector,
t0 = self.t0, time = self.time)
def generate_radars(radar_type):
global std_dict
global prec_dict
global radars
if radar_type == "Radar":
if std_dict["is_chosen"]:
x = int(std_dict["x"])
y = int(std_dict["y"])
std_radar = Radar(x=x,
y=y,
r_std=5.,
theta_std=0.005,
phi_std=0.005)
radars.append(std_radar)
if prec_dict["is_chosen"]:
x = int(prec_dict["x"])
y = int(prec_dict["y"])
prec_radar = Radar(x=x, y=y)
radars.append(prec_radar)
elif radar_type == "PeriodRadar":
if std_dict["is_chosen"]:
x = int(std_dict["x"])
y = int(std_dict["y"])
dt = float(std_dict["dt"])
std_radar = PeriodRadar(x=x,
y=y,
r_std=5.,
theta_std=0.005,
phi_std=0.005,
dt=dt)
radars.append(std_radar)
if prec_dict["is_chosen"]:
x = int(prec_dict["x"])
y = int(prec_dict["y"])
dt = float(prec_dict["dt"])
prec_radar = PeriodRadar(x=x, y=y, dt=dt)
radars.append(prec_radar)
def setUp(self):
# Simulated filter for 2 radars (2*3 measurements)
self.filter = ExtendedKalmanFilter(dim_x=9, dim_z=6)
# Attack matrix: second radar is compromised
self.gamma = np.array([[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]])
self.mag_vector = np.array([[0, 0, 0, -10, -10, -10]]).T
self.t0 = 10
self.time = 50
self.radar = Radar(x=10, y=10)
self.attacker = Attacker(filter=self.filter,
radar=self.radar,
gamma=self.gamma,
mag_vector=self.mag_vector,
t0=self.t0,
time=self.time)
def gen_env():
trajectory = Track()
states = trajectory.gen_landing()
x0 = states[0, 0]
y0 = states[0, 3]
z0 = states[0, 6]
radar = Radar(x=0, y=2000)
radar_filter_cv = RadarFilterCV(dim_x=9,
dim_z=3,
q=1.,
x0=x0,
y0=y0,
z0=z0,
radar=radar)
radar_filter_ca = RadarFilterCA(dim_x=9,
dim_z=3,
q=400.,
x0=x0,
y0=y0,
z0=z0,
radar=radar)
radar_filter_ct = RadarFilterCT(dim_x=9,
dim_z=3,
q=350.,
x0=x0,
y0=y0,
z0=z0,
radar=radar)
filters = [radar_filter_cv, radar_filter_ca, radar_filter_ct]
mu = [0.33, 0.33, 0.33]
trans = np.array([[0.998, 0.001, 0.001], [0.050, 0.900, 0.050],
[0.001, 0.001, 0.998]])
imm = IMMEstimator(filters, mu, trans)
benchmark_imm3 = Benchmark(radars=radar, radar_filter=imm, states=states)
benchmark_imm3.launch_benchmark(with_nees=True)
if __name__ == "__main__":
# ==========================================================================
# ================== Position generation for the aircraft ==================
# ==========================================================================
trajectory = Track()
states = trajectory.gen_landing()
x0,y0,z0 = trajectory.initial_position(states)
# ==========================================================================
# ========================= Radar(s) Generation ============================
# ==========================================================================
## =================== Standard Radars (same data rates)
## Specify your own radar positions and beliefs over measurements!
# Radar 1: Precision radar
radar1 = Radar(x = -6000, y = 10000)
# Radar 2: Standard radar
radar2 = Radar(x = 1000, y = 8000,
r_std = 5., theta_std = 0.005, phi_std = 0.005)
radars = [radar1,radar2]
## ================== Period Radars (different data rates)
# Radar 1: Precision radar
dt_rad1 = 0.1
pradar1 = PeriodRadar(x = -6000, y = 10000, dt = dt_rad1)
# Radar 2: Standard radar
pradar2 = PeriodRadar(x = 1000, y = 8000, dt = dt_rad2,
r_std = 5., theta_std = 0.005, phi_std = 0.005)
MultipleRadarsFilterCV, MultipleRadarsFilterCA, MultipleRadarsFilterCT,
MultipleRadarsFilterTA
]
# Filters to be tested for 2 radars with different data rates
FILTERS_2_FRADARS = [
MultiplePeriodRadarsFilterCV, MultiplePeriodRadarsFilterCA,
MultiplePeriodRadarsFilterCT, MultiplePeriodRadarsFilterTA
]
# Initialization of our components:
## Writer
writer = CSVWriter()
## Radars
## For 1&2 radars same data rate
radar1 = Radar(x=-6000, y=10000)
radar2 = Radar(x=1000, y=8000)
radars = [radar1, radar2]
## Different data rates radars
dt1 = 0.1
dt2 = 0.4
fradar1 = PeriodRadar(x=-6000, y=10000, dt=dt1)
fradar2 = PeriodRadar(x=1000,
y=8000,
dt=dt2,
r_std=5.,
theta_std=0.005,
phi_std=0.005)
fradars = [fradar1, fradar2]
##States
def setUp(self):
self.radar = Radar(x=200,
y=200,
r_std=1.,
theta_std=0.001,
phi_std=0.001)
class RadarTestCase(unittest.TestCase):
def setUp(self):
self.radar = Radar(x=200,
y=200,
r_std=1.,
theta_std=0.001,
phi_std=0.001)
# ==========================================================================
# ========================= Initialization tests ===========================
def test_initial_r_std(self):
self.assertEqual(self.radar.r_std, 1.)
def test_initial_theta_std(self):
self.assertEqual(self.radar.theta_std, 0.001)
def test_initial_phi_std(self):
self.assertEqual(self.radar.phi_std, 0.001)
def test_initial_position(self):
self.assertEqual(self.radar.x, 200)
self.assertEqual(self.radar.y, 200)
self.assertEqual(self.radar.z, 0)
def test_initial_step(self):
dt = 0.1
DT_TRACK = 0.01
step = dt / DT_TRACK
self.assertEqual(self.radar.step, step)
# ==========================================================================
# ========================= Initialization tests ===========================
def test_get_position(self):
position = [self.radar.x, self.radar.y, self.radar.z]
self.assertEqual(position, self.radar.get_position())
def test_sample_position_data(self):
position_data = np.array([[i, i, i] for i in range(10)])
self.radar.step = 3
sample = np.array([[0, 0, 0], [3, 3, 3], [6, 6, 6], [9, 9, 9]])
computed_sample = self.radar.sample_position_data(position_data)
self.assertTrue(np.array_equal(sample, computed_sample))
def test_gen_data_1_position(self):
position_data = np.array([[100., 200., 1000.]])
x = position_data[0][0] - self.radar.x
y = position_data[0][1] - self.radar.y
z = position_data[0][2] - self.radar.z
r = sqrt(x**2 + y**2 + z**2)
theta = atan2(y, x)
phi = atan2(z, sqrt(x**2 + y**2))
radar_data = [r], [theta], [phi]
self.assertEqual(radar_data, self.radar.gen_data(position_data))
def test_gen_data_2_positions(self):
position_data = np.array([[100., 200., 1000.], [110., 210., 1010.]])
x1 = position_data[0][0] - self.radar.x
y1 = position_data[0][1] - self.radar.y
z1 = position_data[0][2] - self.radar.z
r1 = sqrt(x1**2 + y1**2 + z1**2)
theta1 = atan2(y1, x1)
phi1 = atan2(z1, sqrt(x1**2 + y1**2))
x2 = position_data[1][0] - self.radar.x
y2 = position_data[1][1] - self.radar.y
z2 = position_data[1][2] - self.radar.z
r2 = sqrt(x2**2 + y2**2 + z2**2)
theta2 = atan2(y2, x2)
phi2 = atan2(z2, sqrt(x2**2 + y2**2))
radar_data = [r1, r2], [theta1, theta2], [phi1, phi2]
self.assertEqual(radar_data, self.radar.gen_data(position_data))
def test_radar2cartesian(self):
pass
def test_radar_pos_no_influence(self):
position_data = np.array([[i, i, i] for i in range(10)])
rs, thetas, phis = self.radar.gen_data(position_data)
xs, ys, zs = self.radar.radar2cartesian(rs, thetas, phis)
computed_position_data = np.array(list(zip(xs, ys, zs)))
print(position_data)
print(computed_position_data)
self.assertTrue(np.allclose(position_data, computed_position_data))
def test_initialization_noise_finder(self):
self.assertEqual(self.process_noise_finder.radars, [Radar(x=2000,y=2000),Radar(x=1000,y=1000)])
self.assertTrue(np.array_equal(self.process_noise_finder.states,np.array([[i,i/2,i/10]*3 for i in range(3000)])))
def setUp_radar_states(self):
# Radar definition
self.radar = Radar(x=2000,y=2000)
self.radar.step = 1.
# States definition
self.states = np.array([[i,i/2,i/10]*3 for i in range(100)])