209 lines
6.4 KiB
Python
Executable File
209 lines
6.4 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# -*- coding: utf8 -*-
|
|
# -----------------------------------------------------------------------------
|
|
# Copyright (c) 2020-2025 IKI RAS (http://iki.rssi.ru/)
|
|
# Space Research Institute of the Russian Academy of Science
|
|
#
|
|
# This file is part of the M. Pavlinsky SRG/ART-XC software project.
|
|
# -----------------------------------------------------------------------------
|
|
|
|
import os, sys
|
|
import unittest
|
|
import unittest.mock as mock
|
|
|
|
import numpy as np
|
|
|
|
sys.path.append(os.path.join(os.getcwd(), '../src/'))
|
|
|
|
|
|
import arttools
|
|
from arttools.gti import Gti
|
|
|
|
|
|
class TestGti(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.gti_0 = Gti()
|
|
self.gti_1 = Gti([[100., 200.],])
|
|
self.gti_2 = Gti([[100., 200.], [300, 305]])
|
|
self.gti_3 = Gti([100., 200., 300., 400.])
|
|
|
|
def test_create_empty(self):
|
|
self.assertTrue (self.gti_0.empty)
|
|
self.assertEqual(self.gti_0.size, 0)
|
|
|
|
def test_create_from_intervals_1(self):
|
|
self.assertFalse(self.gti_1.empty)
|
|
self.assertEqual(self.gti_1.size, 1)
|
|
self.assertEqual(self.gti_1.exposure(), 100.)
|
|
|
|
def test_create_from_intervals_2(self):
|
|
self.assertFalse(self.gti_2.empty)
|
|
self.assertEqual(self.gti_2.size, 2)
|
|
self.assertEqual(self.gti_2.exposure(), 105.)
|
|
|
|
def test_create_from_intervals_3(self):
|
|
with self.assertRaises(ValueError):
|
|
Gti([100., 200., 300.])
|
|
|
|
def test_startstop(self):
|
|
self.assertEqual(self.gti_0.start, None)
|
|
self.assertEqual(self.gti_0.stop , None)
|
|
self.assertEqual(self.gti_2.start, 100.)
|
|
self.assertEqual(self.gti_2.stop , 305.)
|
|
|
|
def test_create_from_timemask(self):
|
|
times = np.array([100, 200, 300, 400, 500, 600])
|
|
param = np.array([-99, -98, -10, 0, -98, -99])
|
|
|
|
gti = Gti.from_timemask(times, param < -95)
|
|
|
|
self.assertFalse(gti.empty)
|
|
self.assertEqual(gti.size , 2)
|
|
self.assertEqual(gti.exposure(), 200)
|
|
self.assertEqual(gti.start , 100)
|
|
self.assertEqual(gti.stop , 600)
|
|
|
|
def test_clone(self):
|
|
gti_clone = self.gti_2.clone()
|
|
|
|
self.assertFalse(gti_clone.empty)
|
|
self.assertEqual(gti_clone.size, 2)
|
|
self.assertEqual(gti_clone.exposure(), 105.)
|
|
|
|
def test_equal(self):
|
|
gti = Gti([100., 200.])
|
|
|
|
self.assertTrue (gti == gti )
|
|
self.assertTrue (gti == self.gti_1)
|
|
self.assertFalse(gti == self.gti_2)
|
|
self.assertFalse(gti == None )
|
|
|
|
def test_union_1(self):
|
|
gti_1 = Gti([100., 200.])
|
|
gti_2 = Gti()
|
|
|
|
res_gti_1 = gti_1 + None
|
|
res_gti_2 = gti_1 + gti_1
|
|
res_gti_3 = gti_1 + gti_2
|
|
res_gti_4 = gti_2 + gti_1
|
|
|
|
self.assertTrue(res_gti_1 == gti_1 )
|
|
self.assertTrue(res_gti_2 == gti_1 )
|
|
self.assertTrue(res_gti_3 == gti_1 )
|
|
self.assertTrue(res_gti_4 == gti_1 )
|
|
self.assertTrue(res_gti_3 == res_gti_4)
|
|
|
|
def test_union_2(self):
|
|
gti_1 = Gti([100., 200.])
|
|
gti_2 = Gti([150., 250.])
|
|
|
|
res_gti_1 = gti_1 + gti_2
|
|
res_gti_2 = gti_2 + gti_1
|
|
|
|
self.assertEqual(res_gti_1.size , 1)
|
|
self.assertEqual(res_gti_1.exposure(), 150)
|
|
self.assertEqual(res_gti_1.start , 100)
|
|
self.assertEqual(res_gti_1.stop , 250)
|
|
self.assertTrue (res_gti_1 == res_gti_2)
|
|
|
|
def test_union_3(self):
|
|
gti_1 = Gti([100., 200., 300., 400.])
|
|
gti_2 = Gti([150., 250., 350., 450., 370., 470.])
|
|
gti_3 = Gti([170., 270.])
|
|
|
|
res_gti = gti_1 + gti_2 + gti_3
|
|
|
|
self.assertEqual(res_gti.size , 2)
|
|
self.assertEqual(res_gti.exposure(), 340)
|
|
self.assertEqual(res_gti.start , 100)
|
|
self.assertEqual(res_gti.stop , 470)
|
|
|
|
def test_subtraction_1(self):
|
|
gti_1 = Gti([100., 200.])
|
|
gti_2 = Gti()
|
|
|
|
res_gti_1 = gti_1 - None
|
|
res_gti_2 = gti_1 - gti_1
|
|
res_gti_3 = gti_1 - gti_2
|
|
res_gti_4 = gti_2 - gti_1
|
|
|
|
self.assertTrue(res_gti_1 == gti_1 )
|
|
self.assertTrue(res_gti_2 == self.gti_0)
|
|
self.assertTrue(res_gti_3 == gti_1 )
|
|
self.assertTrue(res_gti_4 == self.gti_0)
|
|
|
|
def test_subtraction_2(self):
|
|
gti_1 = Gti([100., 200.])
|
|
gti_2 = Gti([150., 250.])
|
|
|
|
res_gti = gti_1 - gti_2
|
|
|
|
self.assertEqual(res_gti.size , 1)
|
|
self.assertEqual(res_gti.start , 100)
|
|
self.assertEqual(res_gti.stop , 200)
|
|
self.assertEqual(res_gti.exposure(), 50)
|
|
self.assertTrue(
|
|
np.array_equal(res_gti.array, np.array([[150., 200.]])))
|
|
|
|
|
|
def test_subtraction_3(self):
|
|
gti_2 = Gti([50., 120., 170., 250.])
|
|
gti_1 = Gti([100., 200.])
|
|
|
|
res_gti = gti_2 - gti_1
|
|
|
|
self.assertEqual(res_gti.size , 2)
|
|
self.assertEqual(res_gti.start , 50)
|
|
self.assertEqual(res_gti.stop , 250)
|
|
self.assertEqual(res_gti.exposure(), 50)
|
|
self.assertTrue(
|
|
np.array_equal(res_gti.array, np.array([[100., 120.], [170., 200.]])))
|
|
|
|
def test_intersection_1(self):
|
|
gti_1 = Gti([100., 200.])
|
|
gti_2 = Gti()
|
|
|
|
res_gti_1 = gti_1 * None
|
|
res_gti_2 = gti_1 * gti_1
|
|
res_gti_3 = gti_1 * gti_2
|
|
res_gti_4 = gti_2 * gti_1
|
|
|
|
self.assertTrue(res_gti_1 == self.gti_0)
|
|
self.assertTrue(res_gti_2 == gti_1 )
|
|
self.assertTrue(res_gti_3 == self.gti_0)
|
|
self.assertTrue(res_gti_4 == self.gti_0)
|
|
|
|
def test_intersection_2(self):
|
|
gti_1 = Gti([100., 200.])
|
|
gti_2 = Gti([50., 120., 170., 250.])
|
|
|
|
res_gti = gti_2 * gti_1
|
|
|
|
self.assertEqual(res_gti.size , 2)
|
|
self.assertEqual(res_gti.start , 50)
|
|
self.assertEqual(res_gti.stop , 250)
|
|
self.assertEqual(res_gti.exposure(), 50)
|
|
self.assertTrue(
|
|
np.array_equal(res_gti.array, np.array([[100., 120.], [170., 200.]])))
|
|
|
|
def test_intersection_3(self):
|
|
gti_1 = Gti([100., 200.])
|
|
gti_2 = Gti([50., 120., 170., 250.])
|
|
|
|
res_gti = gti_1 * gti_2
|
|
|
|
self.assertEqual(res_gti.size , 2)
|
|
self.assertEqual(res_gti.start , 50)
|
|
self.assertEqual(res_gti.stop , 250)
|
|
self.assertEqual(res_gti.exposure(), 50)
|
|
self.assertTrue(
|
|
np.array_equal(res_gti.array, np.array([[100., 120.], [170., 200.]])))
|
|
|
|
# def test_inversion(self):
|
|
# pass
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|