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)