def setUp(self):
# Radar & States generation
self.setUp_radar_states()
# Filter definition
## Classical models
self.radar_filter_ca = MultiplePeriodRadarsFilterCA(dim_x=9,
dim_z=3,
q=100.,
radars=self.radars)
self.radar_filter_cv = MultiplePeriodRadarsFilterCV(dim_x=9,
dim_z=3,
q=100.,
radars=self.radars)
self.radar_filter_ct = MultiplePeriodRadarsFilterCT(dim_x=9,
dim_z=3,
q=100.,
radars=self.radars)
## IMM with ca, cv and ct models
filters = [
self.radar_filter_cv, self.radar_filter_ca, self.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]])
self.radar_filter = RadarIMM(filters=filters, mu=mu, M=trans)
# Benchmark definition
self.benchmark = Benchmark(radars=self.radars,
radar_filter=self.radar_filter,
states=self.states)
def launch_benchmark(with_nees):
global radars, filter, attacker, states
benchmark = Benchmark(radars=radars,
radar_filter=filter,
states=states,
attacker=attacker)
benchmark.launch_benchmark(with_nees=with_nees)
class Benchmark2PeriodRadarsIMM2TestCase(Benchmark2PeriodRadarsTestEnv,
unittest.TestCase):
def setUp(self):
# Radar & States generation
self.setUp_radar_states()
# Filter definition
## Classical models
self.radar_filter_ca = MultiplePeriodRadarsFilterCA(dim_x=9,
dim_z=3,
q=100.,
radars=self.radars)
self.radar_filter_cv = MultiplePeriodRadarsFilterCV(dim_x=9,
dim_z=3,
q=100.,
radars=self.radars)
## IMM with ca, cv and ct models
filters = [self.radar_filter_cv, self.radar_filter_ca]
mu = [0.5, 0.5]
trans = np.array([[0.999, 0.001], [0.001, 0.999]])
self.radar_filter = RadarIMM(filters=filters, mu=mu, M=trans)
# Benchmark definition
self.benchmark = Benchmark(radars=self.radars,
radar_filter=self.radar_filter,
states=self.states)
def test_initialization_is_imm(self):
self.assertTrue(self.benchmark.filter_is_imm)
def test_process_filter_computes_probs(self):
self.benchmark.gen_data_set()
self.benchmark.process_filter(with_nees=True)
self.assertEqual(np.shape(self.benchmark.probs),
(self.len_elements, 2))
class Benchmark1RadarIMM4TestCase(Benchmark1RadarTestEnv,unittest.TestCase):
def setUp(self):
# Radar & States generation
self.setUp_radar_states()
# Filter definition
## Classical models
self.radar_filter_ca = RadarFilterCA(dim_x = 9, dim_z = 3, q = 100., radar = self.radar)
self.radar_filter_cv = RadarFilterCV(dim_x = 9, dim_z = 3, q = 100., radar = self.radar)
self.radar_filter_ct = RadarFilterCT(dim_x = 9, dim_z = 3, q = 100., radar = self.radar)
self.radar_filter_ta = RadarFilterTA(dim_x = 9, dim_z = 3, q = 100., radar = self.radar)
## IMM with ca, cv and ct models
filters = [self.radar_filter_cv, self.radar_filter_ca, self.radar_filter_ct, self.radar_filter_ta]
mu = [0.25, 0.25, 0.25, 0.25]
trans = np.array([[0.997, 0.001, 0.001, 0.001],
[0.050, 0.850, 0.050, 0.050],
[0.001, 0.001, 0.997, 0.001],
[0.001, 0.001, 0.001, 0.997]])
self.radar_filter = RadarIMM(filters = filters, mu = mu, M = trans)
# Benchmark definitions
self.benchmark = Benchmark(radars = self.radar, radar_filter = self.radar_filter, states = self.states)
def test_initialization_is_imm(self):
self.assertTrue(self.benchmark.filter_is_imm)
def test_process_filter_computes_probs(self):
self.benchmark.gen_data_set()
self.benchmark.process_filter(with_nees = True)
self.assertEqual(np.shape(self.benchmark.probs), (100,4))
def compute_nees(self, qs):
'''
Computes the average Normalized Estimated Error Squared (nees) for a given
filter and list process noises qs.
Parameters
----------
qs: float iterable
Process noises to be tested.
Returns
-------
mean_nees: float
Average nees of the tested filter/process noise.
'''
x0 = self.states[0, 0]
y0 = self.states[0, 3]
z0 = self.states[0, 6]
filters_to_be_tested = []
for filter, q in zip(self.filters, qs):
current_filter = filter(dim_x=9,
dim_z=3,
radar=self.radar,
q=q,
x0=x0,
y0=y0,
z0=z0)
filters_to_be_tested.append(current_filter)
imm = IMMEstimator(mu=self.mu, M=self.trans, filters=self.filters)
benchmark = Benchmark(radar=self.radar,
radar_filter=imm,
states=self.states)
benchmark.launch_benchmark(with_nees=True, plot=False)
return benchmark.nees
def setUp(self):
# Radar & States generation
self.setUp_radar_states()
# Filter definition: TA model
self.radar_filter = RadarFilterTA(dim_x = 9, dim_z = 3, q = 100., radar = self.radar)
# Benchmark definition
self.benchmark = Benchmark(radars = self.radar, radar_filter = self.radar_filter, states = self.states)
def setUp(self):
# Radar & States generation
self.setUp_radar_states()
# Filter definition
## Classical models
self.radar_filter_ca = RadarFilterCA(dim_x = 9, dim_z = 3, q = 100., radar = self.radar)
self.radar_filter_cv = RadarFilterCV(dim_x = 9, dim_z = 3, q = 100., radar = self.radar)
## IMM with ca, cv and ct models
filters = [self.radar_filter_cv, self.radar_filter_ca]
mu = [0.5, 0.5]
trans = np.array([[0.999, 0.001],
[0.001, 0.999]])
self.radar_filter = RadarIMM(filters = filters, mu = mu, M = trans)
# Benchmark definition
self.benchmark = Benchmark(radars = self.radar, radar_filter = self.radar_filter, states = self.states)
def setUp(self):
# Radar & States generation
self.setUp_radar_states()
# Filter definition: CA model
self.radar_filter = MultiplePeriodRadarsFilterCT(dim_x=9,
dim_z=6,
q=100.,
radars=self.radars)
# Benchmark definitions
self.benchmark = Benchmark(radars=self.radars,
radar_filter=self.radar_filter,
states=self.states)
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)
## note radar1 => radar_pos = 0, radar2 => radar_pos = 1, etc.
## No attacker
attacker = None
## Attacker for 1 or 2 Radars
attacker = DOSAttacker(filter = radar_filter,
t0 = 200, time = 100, radar_pos = 1)
attacker = DriftAttacker(filter = radar_filter, t0 = 200,
time = 100, radar_pos = 1, radar = radar2)
## Attackers for 2 Period Radars
attacker = DriftPeriodAttacker(filter = radar_filter_cv, t0 = 200, time = 2000,
radar = pradar2, radar_pos = 1)
attacker = DOSPeriodAttacker(filter = radar_filter, t0 = 200, time = 2000,
radar = pradar2, radar_pos = 1)
# ==========================================================================
# ========================= Benchmark Wrapping =============================
# ==========================================================================
## Comment the unused benchmark!
benchmark_standard = Benchmark(radars = radars,radar_filter = radar_filter,
states = states, attacker = attacker)
benchmark_ca.launch_benchmark(with_nees = True)
benchmark_period = Benchmark(radars = pradars,radar_filter = radar_filter,
states = states, attacker = attacker)
benchmark_ca.launch_benchmark(with_nees = True)
radars = [radar1, radar2]
radar_filter_cv = MultipleRadarsFilterCV(dim_x=9,
dim_z=6,
q=1.,
radars=radars,
x0=x0,
y0=y0,
z0=z0)
radar_filter_ca = MultipleRadarsFilterCA(dim_x=9,
dim_z=6,
q=400.,
radars=radars,
x0=x0,
y0=y0,
z0=z0)
radar_filter_ct = MultipleRadarsFilterCT(dim_x=9,
dim_z=6,
q=350.,
radars=radars,
x0=x0,
y0=y0,
z0=z0)
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=radars, radar_filter=imm, states=states)
benchmark_imm3.launch_benchmark(with_nees=True)
z0=z0)
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 = RadarIMM(filters, mu, trans)
# =============================== Attackers ================================
## No attacker
# attacker = None
## Attackers for 2 Period Radars
# attacker = DriftPeriodAttacker(filter = imm, t0 = 500, time = 300,
# attack_drift = np.array([[100,100,100]]).T,
# radar = pradar2, radar_pos = 1)
attacker = CumulativeDriftPeriodAttacker(filter=imm,
t0=300,
time=2000,
delta_drift=np.array([[0, 0,
1]]).T,
radar=pradar2,
radar_pos=1)
# =============================== Benchmark ================================
benchmark = Benchmark(radars=pradars,
radar_filter=imm,
states=states,
attacker=attacker)
benchmark.launch_benchmark(with_nees=True)