rubin-sim 2.6.1.dev2__py3-none-any.whl

tests/maf/test_simplemetrics.py

@@ -0,0 +1,200 @@
+import unittest
+
+import numpy as np
+
+import rubin_sim.maf.metrics as metrics
+
+
+class TestSimpleMetrics(unittest.TestCase):
+    def setUp(self):
+        dv = np.arange(0, 10, 0.5)
+        dv2 = np.arange(-10, 10.25, 0.5)
+        self.dv = np.array(list(zip(dv)), dtype=[("testdata", "float")])
+        self.dv2 = np.array(list(zip(dv2)), dtype=[("testdata", "float")])
+
+    def test_max_metric(self):
+        """Test max metric."""
+        testmetric = metrics.MaxMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), self.dv["testdata"].max())
+
+    def test_min_metric(self):
+        """Test min metric."""
+        testmetric = metrics.MinMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), self.dv["testdata"].min())
+
+    def test_mean_metric(self):
+        """Test mean metric."""
+        testmetric = metrics.MeanMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), self.dv["testdata"].mean())
+
+    def test_median_metric(self):
+        """Test median metric."""
+        testmetric = metrics.MedianMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), np.median(self.dv["testdata"]))
+
+    def test_abs_median_metric(self):
+        testmetric = metrics.AbsMedianMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), np.abs(np.median(self.dv["testdata"])))
+
+    def test_full_range_metric(self):
+        """Test full range metric."""
+        testmetric = metrics.FullRangeMetric("testdata")
+        self.assertEqual(
+            testmetric.run(self.dv),
+            self.dv["testdata"].max() - self.dv["testdata"].min(),
+        )
+
+    def test_coaddm5_metric(self):
+        """Test coaddm5 metric."""
+        testmetric = metrics.Coaddm5Metric(m5_col="testdata")
+        self.assertEqual(
+            testmetric.run(self.dv),
+            1.25 * np.log10(np.sum(10.0 ** (0.8 * self.dv["testdata"]))),
+        )
+
+    def test_rms_metric(self):
+        """Test rms metric."""
+        testmetric = metrics.RmsMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), np.std(self.dv["testdata"]))
+
+    def test_sum_metric(self):
+        """Test Sum metric."""
+        testmetric = metrics.SumMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), self.dv["testdata"].sum())
+
+    def test_count_unique_metric(self):
+        """Test CountUniqueMetric"""
+        testmetric = metrics.CountUniqueMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), np.size(np.unique(self.dv["testdata"])))
+        d2 = self.dv.copy()
+        d2["testdata"][1] = d2["testdata"][0]
+        self.assertEqual(testmetric.run(d2), np.size(np.unique(d2)))
+
+    def test_count_metric(self):
+        """Test count metric."""
+        testmetric = metrics.CountMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), np.size(self.dv["testdata"]))
+
+    def test_count_ratio_metric(self):
+        """Test countratio metric."""
+        testmetric = metrics.CountRatioMetric("testdata", norm_val=2.0)
+        self.assertEqual(testmetric.run(self.dv), np.size(self.dv["testdata"]) / 2.0)
+
+    def test_count_subset_metric(self):
+        """Test countsubset metric."""
+        testmetric = metrics.CountSubsetMetric("testdata", subset=0)
+        self.assertEqual(testmetric.run(self.dv), 1)
+
+    def test_max_percent_metric(self):
+        testmetric = metrics.MaxPercentMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), 1.0 / len(self.dv) * 100.0)
+        self.assertEqual(testmetric.run(self.dv2), 1.0 / len(self.dv2) * 100.0)
+
+    def test_abs_max_percent_metric(self):
+        testmetric = metrics.AbsMaxPercentMetric("testdata")
+        self.assertEqual(testmetric.run(self.dv), 1.0 / len(self.dv) * 100.0)
+        self.assertEqual(testmetric.run(self.dv2), 2.0 / len(self.dv2) * 100.0)
+
+    def test_robust_rms_metric(self):
+        """Test Robust RMS metric."""
+        testmetric = metrics.RobustRmsMetric("testdata")
+        rms_approx = (np.percentile(self.dv["testdata"], 75) - np.percentile(self.dv["testdata"], 25)) / 1.349
+        self.assertEqual(testmetric.run(self.dv), rms_approx)
+
+    def test_frac_above_metric(self):
+        cutoff = 5.1
+        testmetric = metrics.FracAboveMetric("testdata", cutoff=cutoff)
+        self.assertEqual(
+            testmetric.run(self.dv),
+            np.size(np.where(self.dv["testdata"] >= cutoff)[0]) / float(np.size(self.dv)),
+        )
+        testmetric = metrics.FracAboveMetric("testdata", cutoff=cutoff, scale=2)
+        self.assertEqual(
+            testmetric.run(self.dv),
+            2.0 * np.size(np.where(self.dv["testdata"] >= cutoff)[0]) / float(np.size(self.dv)),
+        )
+
+    def test_frac_below_metric(self):
+        cutoff = 5.1
+        testmetric = metrics.FracBelowMetric("testdata", cutoff=cutoff)
+        self.assertEqual(
+            testmetric.run(self.dv),
+            np.size(np.where(self.dv["testdata"] <= cutoff)[0]) / float(np.size(self.dv)),
+        )
+        testmetric = metrics.FracBelowMetric("testdata", cutoff=cutoff, scale=2)
+        self.assertEqual(
+            testmetric.run(self.dv),
+            2.0 * np.size(np.where(self.dv["testdata"] <= cutoff)[0]) / float(np.size(self.dv)),
+        )
+
+    def test_noutliers_nsigma(self):
+        data = self.dv
+        testmetric = metrics.NoutliersNsigmaMetric("testdata", n_sigma=1.0)
+        med = np.mean(data["testdata"])
+        should_be = np.size(np.where(data["testdata"] > med + data["testdata"].std())[0])
+        self.assertEqual(should_be, testmetric.run(data))
+        testmetric = metrics.NoutliersNsigmaMetric("testdata", n_sigma=-1.0)
+        should_be = np.size(np.where(data["testdata"] < med - data["testdata"].std())[0])
+        self.assertEqual(should_be, testmetric.run(data))
+
+    def test_mean_angle_metric(self):
+        """Test mean angle metric."""
+        rng = np.random.RandomState(6573)
+        dv1 = np.arange(0, 32, 2.5)
+        dv2 = (dv1 - 20.0) % 360.0
+        dv1 = np.array(list(zip(dv1)), dtype=[("testdata", "float")])
+        dv2 = np.array(list(zip(dv2)), dtype=[("testdata", "float")])
+        testmetric = metrics.MeanAngleMetric("testdata")
+        result1 = testmetric.run(dv1)
+        result2 = testmetric.run(dv2)
+        self.assertAlmostEqual(result1, (result2 + 20) % 360.0)
+        dv = rng.rand(10000) * 360.0
+        dv = dv
+        dv = np.array(list(zip(dv)), dtype=[("testdata", "float")])
+        result = testmetric.run(dv)
+        result = result
+        self.assertAlmostEqual(result, 180)
+
+    def test_full_range_angle_metric(self):
+        """Test full range angle metric."""
+        rng = np.random.RandomState(5422)
+        dv1 = np.arange(0, 32, 2.5)
+        dv2 = (dv1 - 20.0) % 360.0
+        dv1 = np.array(list(zip(dv1)), dtype=[("testdata", "float")])
+        dv2 = np.array(list(zip(dv2)), dtype=[("testdata", "float")])
+        testmetric = metrics.FullRangeAngleMetric("testdata")
+        result1 = testmetric.run(dv1)
+        result2 = testmetric.run(dv2)
+        self.assertAlmostEqual(result1, result2)
+        dv = np.arange(0, 358, 5)
+        dv = np.array(list(zip(dv)), dtype=[("testdata", "float")])
+        result = testmetric.run(dv)
+        self.assertAlmostEqual(result, 355)
+        dv = rng.rand(10000) * 360.0
+        dv = np.array(list(zip(dv)), dtype=[("testdata", "float")])
+        result = testmetric.run(dv)
+        result = result
+        self.assertGreater(result, 355)
+
+    def test_surfb_metric(self):
+        """Test the surface brightness metric"""
+        testmetric = metrics.SurfaceBrightLimitMetric()
+        names = [
+            "airmass",
+            "visitExposureTime",
+            "skyBrightness",
+            "numExposures",
+            "band",
+        ]
+        types = [float] * 4 + ["|U1"]
+        data = np.zeros(10, dtype=list(zip(names, types)))
+        data["airmass"] = 1.2
+        data["visitExposureTime"] = 30.0
+        data["skyBrightness"] = 25.0
+        data["numExposures"] = 2.0
+        data["band"] = "r"
+        _ = testmetric.run(data, None)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_snmetrics.py

@@ -0,0 +1,335 @@
+import os
+import unittest
+import warnings
+
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+
+from rubin_sim.maf.metrics import SNCadenceMetric, SNSLMetric, SNSNRMetric
+from rubin_sim.maf.utils.sn_utils import Lims, ReferenceData
+
+m5_ref = dict(zip("ugrizy", [23.60, 24.83, 24.38, 23.92, 23.35, 22.44]))
+
+
+def observations_band(day0=59000, daymin=59000, cadence=3.0, season_length=140.0, band="r"):
+    # Define fake data
+    names = [
+        "observationStartMJD",
+        "fieldRA",
+        "fieldDec",
+        "fiveSigmaDepth",
+        "visitExposureTime",
+        "numExposures",
+        "visitTime",
+        "season",
+        "seeingFwhmEff",
+        "seeingFwhmGeom",
+        "pixRA",
+        "pixDec",
+    ]
+    types = ["f8"] * len(names)
+    names += ["night", "healpixID"]
+    types += ["i2", "i2"]
+    names += ["band"]
+    types += ["O"]
+
+    daylast = daymin + season_length
+    cadence = cadence
+    dayobs = np.arange(daymin, daylast, cadence)
+    npts = len(dayobs)
+    data = np.zeros(npts, dtype=list(zip(names, types)))
+    data["observationStartMJD"] = dayobs
+    data["night"] = np.floor(data["observationStartMJD"] - day0 + 1)
+    data["fiveSigmaDepth"] = m5_ref[band]
+    data["visitExposureTime"] = 30.0
+    data["numExposures"] = 1
+    data["visitTime"] = 34
+    data["band"] = band
+    data["seeingFwhmEff"] = 0.8
+    data["seeingFwhmGeom"] = 0.8
+    data["healpixID"] = 10
+    data["pixRA"] = 0.0
+    data["pixDec"] = 0.0
+    return data
+
+
+def observations_season(mjdmin=59000, cadence=3.0):
+    bands = "grizy"
+    nvisits = dict(zip(bands, [10, 20, 20, 26, 20]))
+    rat = 34.0 / 3600.0 / 24.0
+    shift_visits = {}
+    shift_visits["g"] = 0
+    shift_visits["r"] = rat * nvisits["g"]
+    shift_visits["i"] = rat * nvisits["r"]
+    shift_visits["z"] = rat * nvisits["i"]
+    shift_visits["y"] = rat * nvisits["z"]
+
+    # get data
+    data = None
+    season_length = 180
+    shift = 30.0 / (3600.0 * 24)
+    for band in bands:
+        mjd = mjdmin + shift_visits[band]
+        for i in range(nvisits[band]):
+            mjd += shift
+            dat = observations_band(daymin=mjd, season_length=season_length, cadence=cadence, band=band)
+            if data is None:
+                data = dat
+            else:
+                data = np.concatenate((data, dat))
+
+    return data
+
+
+def fake_data(band, season=1):
+    # Define fake data
+    names = [
+        "observationStartMJD",
+        "fieldRA",
+        "fieldDec",
+        "fiveSigmaDepth",
+        "visitExposureTime",
+        "numExposures",
+        "visitTime",
+        "season",
+        "seeingFwhmEff",
+        "seeingFwhmGeom",
+        "airmass",
+        "sky",
+        "moonPhase",
+        "pixRA",
+        "pixDec",
+    ]
+
+    types = ["f8"] * len(names)
+    names += ["night"]
+    types += ["i2"]
+    names += ["healpixID"]
+    types += ["i2"]
+    names += ["band"]
+    types += ["O"]
+
+    dayobs = [
+        59948.31957176,
+        59959.2821412,
+        59970.26134259,
+        59973.25978009,
+        59976.26383102,
+        59988.20670139,
+        59991.18412037,
+        60004.1853588,
+        60032.08975694,
+        60045.11981481,
+        60047.98747685,
+        60060.02083333,
+        60071.986875,
+        60075.96452546,
+    ]
+    day0 = np.min(dayobs)
+    npts = len(dayobs)
+    data = np.zeros(npts, dtype=list(zip(names, types)))
+    data["observationStartMJD"] = dayobs
+    data["night"] = np.floor(data["observationStartMJD"] - day0 + 1)
+    data["fiveSigmaDepth"] = m5_ref[band]
+    data["visitExposureTime"] = 15.0
+    data["numExposures"] = 2
+    data["visitTime"] = 2.0 * 15.0
+    data["season"] = season
+    data["band"] = band
+    data["seeingFwhmEff"] = 0.0
+    data["seeingFwhmGeom"] = 0.0
+    data["airmass"] = 1.2
+    data["sky"] = 20.0
+    data["moonPhase"] = 0.5
+    data["pixRA"] = 0.0
+    data["pixDec"] = 0.0
+    data["healpixID"] = 1
+
+    return data
+
+
+class TestSNmetrics(unittest.TestCase):
+    def setUp(self):
+        if not os.path.isdir(os.path.join(get_data_dir(), "maf")):
+            self.skipTest("Skipping SN tests because running unit tests without full rubin_sim.data.")
+
+    @unittest.skip("The SNCadenceMetric is not used")
+    def test_sn_cadence_metric(self):
+        """Test the SN cadence metric"""
+
+        # Load up the files from sims_maf_contrib if possible
+        sims_maf_contrib_dir = os.path.join(get_data_dir(), "maf")
+        if sims_maf_contrib_dir is not None:
+            # Load required SN info to run the metric
+            band = "r"
+            SNR = dict(zip("griz", [30.0, 40.0, 30.0, 20.0]))  # SNR for WFD
+            mag_range = [21.0, 25.5]  # WFD mag range
+            dt_range = [0.5, 30.0]  # WFD dt range
+            li_files = [os.path.join(sims_maf_contrib_dir, "Li_SNCosmo_-2.0_0.2.npy")]
+            mag_to_flux_files = [os.path.join(sims_maf_contrib_dir, "Mag_to_Flux_SNCosmo.npy")]
+            lim_sn = Lims(
+                li_files,
+                mag_to_flux_files,
+                band,
+                SNR[band],
+                mag_range=mag_range,
+                dt_range=dt_range,
+            )
+
+            # Define fake data
+            names = [
+                "observationStartMJD",
+                "fieldRA",
+                "fieldDec",
+                "fiveSigmaDepth",
+                "visitExposureTime",
+                "numExposures",
+                "visitTime",
+            ]
+            types = ["f8"] * len(names)
+            names += ["night"]
+            types += ["i2"]
+            names += ["band"]
+            types += ["O"]
+
+            day0 = 59000
+            daylast = day0 + 250
+            cadence = 5
+            dayobs = np.arange(day0, daylast, cadence)
+            npts = len(dayobs)
+            data = np.zeros(npts, dtype=list(zip(names, types)))
+            data["observationStartMJD"] = dayobs
+            data["night"] = np.floor(data["observationStartMJD"] - day0)
+            data["fiveSigmaDepth"] = m5_ref[band]
+            data["visitExposureTime"] = 15.0
+            data["numExposures"] = 2
+            data["visitTime"] = 2.0 * 15.0
+            data["band"] = band
+
+            # Run the metric with these fake data
+            slice_point = {"nside": 64, "ebv": 0}
+            metric = SNCadenceMetric(lim_sn=lim_sn, coadd=False)
+            result = metric.run(data, slice_point)
+
+            # And the result should be...
+            result_ref = 0.3743514
+
+            assert np.abs(result - result_ref) < 1.0e-5
+
+        else:
+            warnings.warn("skipping SN test because no rubin_sim.data set")
+
+    @unittest.skip("This metric is not used")
+    def test_snsnr_metric(self):
+        """Test the SN SNR metric"""
+
+        sims_maf_contrib_dir = os.path.join(get_data_dir(), "maf")
+        if sims_maf_contrib_dir is not None:
+            # Load required SN info to run the metric
+            band = "r"
+            z = 0.3
+            season = 1.0
+            li_files = [os.path.join(sims_maf_contrib_dir, "Li_SNCosmo_-2.0_0.2.npy")]
+            mag_to_flux_files = [os.path.join(sims_maf_contrib_dir, "Mag_to_Flux_SNCosmo.npy")]
+
+            names_ref = ["SNCosmo"]
+            coadd = False
+
+            lim_sn = ReferenceData(li_files, mag_to_flux_files, band, z)
+
+            # Define fake data
+            names = [
+                "observationStartMJD",
+                "fieldRA",
+                "fieldDec",
+                "fiveSigmaDepth",
+                "visitExposureTime",
+                "numExposures",
+                "visitTime",
+                "season",
+            ]
+            types = ["f8"] * len(names)
+            names += ["night"]
+            types += ["i2"]
+            names += ["band"]
+            types += ["O"]
+
+            dayobs = [
+                59948.31957176,
+                59959.2821412,
+                59970.26134259,
+                59973.25978009,
+                59976.26383102,
+                59988.20670139,
+                59991.18412037,
+                60004.1853588,
+                60032.08975694,
+                60045.11981481,
+                60047.98747685,
+                60060.02083333,
+                60071.986875,
+                60075.96452546,
+            ]
+            day0 = np.min(dayobs)
+            npts = len(dayobs)
+            data = np.zeros(npts, dtype=list(zip(names, types)))
+
+            data["observationStartMJD"] = dayobs
+            data["night"] = np.floor(data["observationStartMJD"] - day0)
+            data["fiveSigmaDepth"] = m5_ref[band]
+            data["visitExposureTime"] = 15.0
+            data["numExposures"] = 2
+            data["visitTime"] = 2.0 * 15.0
+            data["season"] = season
+            data["band"] = band
+
+            # Run the metric with these fake data
+            slice_point = {"nside": 64, "ebv": 0.0}
+            metric = SNSNRMetric(lim_sn=lim_sn, coadd=coadd, names_ref=names_ref, season=season, z=z)
+
+            result = metric.run(data, slice_point)
+
+            # And the result should be...
+            result_ref = 0.4830508474576271
+
+            assert np.abs(result - result_ref) < 1.0e-5
+        else:
+            warnings.warn("skipping SN test because no rubin_sim.data set")
+
+    def test_snsl_metric(self):
+        """Test the SN SL metric"""
+
+        # load some fake data
+        data = None
+        bands = "griz"
+        cadence = dict(zip(bands, [2, 1, 2, 1]))
+        for band in bands:
+            for i in range(cadence[band]):
+                fakes = fake_data(band)
+                if data is None:
+                    data = fakes
+                else:
+                    data = np.concatenate((data, fakes))
+
+        # metric instance
+
+        metric = SNSLMetric(
+            nfilters_min=4,
+            min_season_obs=5,
+            m5mins={"u": 22.7, "g": 24.1, "r": 23.7, "i": 23.1, "z": 22.2, "y": 21.4},
+        )
+
+        # run the metric
+        n_sl = metric.run(data, slice_point={"nside": 64, "ra": 0.0, "ebv": 0.0})
+
+        # and the result should be
+        # Changing the reference value because we have new coadd and mag limits
+        # Change again to switch to per-season calc rather than average
+        # Change again to reflect updated calculation
+        # (due to counting year = 365.25 days, not 360)
+        n_sl_ref = 1.4569195613987307e-06
+        assert np.abs(n_sl - n_sl_ref) < 1.0e-8
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_snmetrics_nsn.py

@@ -0,0 +1,123 @@
+import os
+import unittest
+
+import numpy as np
+import pandas as pd
+from rubin_scheduler.data import get_data_dir
+
+import rubin_sim.maf as maf
+
+
+class TestSNmetrics(unittest.TestCase):
+    def setUp(self):
+        # Make sure we can read SN lightcurve and reference info
+        if not os.path.isdir(os.path.join(get_data_dir(), "maf")):
+            self.skipTest("Skipping SN tests because running unit tests without full rubin_scheduler.data.")
+        # Read test point data
+        testfile = os.path.join(get_data_dir(), "tests", "test_simData.hdf")
+        if not os.path.isfile(testfile):
+            raise FileExistsError("%s not found" % testfile)
+        self.simdata = {}
+        with pd.HDFStore(testfile, mode="r") as f:
+            keys = f.keys()
+            for k in keys:
+                newkey = k.lstrip("/")
+                self.simdata[newkey] = f.get(k).to_records()
+
+    def test_nsn(self):
+        # Set up a mock slicerPoint
+        nside = 64
+        slice_point = {"nside": nside, "ebv": 0.0}
+
+        # Set up the metric
+        metric = maf.SNNSNMetric(
+            season=[-1],
+            n_aft=8,
+            n_bef=3,
+            add_dust=False,
+            hard_dust_cut=0.25,
+            zmin=0.1,
+            zmax=0.5,
+            z_step=0.03,
+            daymax_step=3,
+            snr_min=1,
+            zlim_coeff=0.95,
+            sigma_c=0.04,
+            bands="grizy",
+            gamma_name="gamma_WFD.hdf5",
+            verbose=False,
+            # To match old test data
+            filter_col="filter",
+        )
+
+        # Expected keys and results
+        expected = {}
+        # Muddle with m5 - very shallow
+        expected["one_season_shallow"] = metric.badval
+        # Very few visits
+        expected["sparse_pointing"] = metric.badval
+        # Very dense pointing
+        expected["dense_pointing"] = np.rec.fromrecords([(5.158324, 0.276509)], names=["nSN", "zlim"])
+        # These are of the same point on the sky, with/without DD fields -
+        # they should be the same as the metric rejects DD visits internally
+        # ---XXX except now the metric does
+        # not reject visits based on notes, so not sure why these still pass
+
+        expected["one_season_noDD"] = np.rec.fromrecords([(0.870031, 0.289703)], names=["nSN", "zlim"])
+        expected["one_season_wDD"] = np.rec.fromrecords([(0.870031, 0.289703)], names=["nSN", "zlim"])
+        # Here we muddle with the visit exposure time (without changing m5)
+        expected["one_season_singleExp_20"] = np.rec.fromrecords([(0.879159, 0.29006)], names=["nSN", "zlim"])
+        # Here we muddle with the number of visits per exposure,
+        # without changing m5 or visitExpTime
+        expected["one_season_singleExp_30"] = np.rec.fromrecords(
+            [(0.870031, 0.289703)], names=["nSN", "zlim"]
+        )
+
+        verbose = True
+
+        for k in self.simdata:
+            res = metric.run(self.simdata[k], slice_point=slice_point)
+            if verbose:
+                print("")
+                print(f"pointing test {k} with {len(self.simdata[k])} visits")
+                try:
+                    print(f"expected results {expected[k]}")
+                except KeyError:
+                    print(f"no expected results for {k}")
+                print(f"calculated results {res}")
+                print("")
+            # self.assertEqual(expected[k], res)
+
+        # And run for DD observations
+        metric = maf.SNNSNMetric(
+            season=[-1],
+            n_aft=10,
+            n_bef=4,
+            add_dust=False,
+            hard_dust_cut=0.25,
+            zmin=0.1,
+            zmax=0.5,
+            z_step=0.03,
+            daymax_step=3,
+            snr_min=1,
+            zlim_coeff=0.95,
+            sigma_c=0.04,
+            bands="grizy",
+            gamma_name="gamma_DDF.hdf5",
+            coadd_night=True,
+            verbose=False,
+            # Match old test data
+            filter_col="filter",
+        )
+        for k in ["one_season_wDD"]:
+            res = metric.run(self.simdata[k], slice_point=slice_point)
+            if verbose:
+                print("")
+                print(f"pointing test {k} for {len(self.simdata[k])} DD-only visits")
+
+                print(f"calculated results {res}")
+                print("")
+
+
+if __name__ == "__main__":
+    unittest.main()