Пример #1
0
    def __init__(self, configurationFilePath):

        self.config = AgilepyConfig()

        # load only "input" and "output" sections
        self.config.loadBaseConfigurations(
            Utils._expandEnvVar(configurationFilePath))

        # Creating output directory

        self.outdir = self.config.getConf("output", "outdir")

        Path(self.outdir).mkdir(parents=True, exist_ok=True)

        self.logger = AgilepyLogger()

        self.logger.initialize(
            self.outdir, self.config.getConf("output", "logfilenameprefix"),
            self.config.getConf("output", "verboselvl"))

        self.plottingUtils = PlottingUtils(self.config, self.logger)

        if "AGILE" not in os.environ:
            raise AGILENotFoundError("$AGILE is not set.")

        if "PFILES" not in os.environ:
            raise PFILESNotFoundError("$PFILES is not set.")
Пример #2
0
    def setUp(self):
        self.currentDirPath = Path(__file__).parent.absolute()
        self.agilepyconfPath = os.path.join(self.currentDirPath,
                                            "conf/agilepyconf.yaml")

        self.config = AgilepyConfig()
        self.config.loadBaseConfigurations(self.agilepyconfPath)

        self.agilepyLogger = AgilepyLogger()

        self.agilepyLogger.initialize(
            self.config.getConf("output", "outdir"),
            self.config.getConf("output", "logfilenameprefix"),
            self.config.getConf("output", "verboselvl"))

        self.datadir = os.path.join(self.currentDirPath, "data")

        self.outDir = Path(self.config.getOptionValue("outdir"))

        if self.outDir.exists() and self.outDir.is_dir():
            self.agilepyLogger.reset()
            shutil.rmtree(self.outDir)

        self.tmpDir = Path("./tmp")
        self.tmpDir.mkdir(exist_ok=True)
Пример #3
0
    def setUp(self):
        self.currentDirPath = Path(__file__).parent.absolute()

        self.test_logs_dir = Path(self.currentDirPath).joinpath(
            "test_logs", "SourcesLibraryUT")
        self.test_logs_dir.mkdir(parents=True, exist_ok=True)
        os.environ["TEST_LOGS_DIR"] = str(self.test_logs_dir)

        self.agilepyConf = os.path.join(self.currentDirPath,
                                        "conf/agilepyconf.yaml")

        self.config = AgilepyConfig()
        self.config.loadBaseConfigurations(self.agilepyConf)
        self.config.loadConfigurationsForClass("AGAnalysis")

        self.logger = AgilepyLogger()
        self.logger.initialize(
            self.config.getConf("output", "outdir"),
            self.config.getConf("output", "logfilenameprefix"),
            self.config.getConf("output", "verboselvl"))

        outDir = Path(
            os.path.join(os.environ["AGILE"],
                         "agilepy-test-data/unittesting-output/core"))

        if outDir.exists() and outDir.is_dir():
            shutil.rmtree(outDir)

        self.sl = SourcesLibrary(self.config, self.logger)
Пример #4
0
def logger(request):

    testlogger = AgilepyLogger()

    script_path = Path(__file__).absolute().parent

    marker = request.node.get_closest_marker("testdir")

    if marker is None:
        raise ValueError(
            "marker is None! Something wrong passing 'testdir' to fixture!")

    testdir = marker.args[0]
    testname = marker.args[1]

    testlogger.initialize(testdir, f"{testname}", 1)

    yield testlogger

    testlogger.reset()
Пример #5
0
class AGBaseAnalysis:
    def __init__(self, configurationFilePath):

        self.config = AgilepyConfig()

        # load only "input" and "output" sections
        self.config.loadBaseConfigurations(
            Utils._expandEnvVar(configurationFilePath))

        # Creating output directory

        self.outdir = self.config.getConf("output", "outdir")

        Path(self.outdir).mkdir(parents=True, exist_ok=True)

        self.logger = AgilepyLogger()

        self.logger.initialize(
            self.outdir, self.config.getConf("output", "logfilenameprefix"),
            self.config.getConf("output", "verboselvl"))

        self.plottingUtils = PlottingUtils(self.config, self.logger)

        if "AGILE" not in os.environ:
            raise AGILENotFoundError("$AGILE is not set.")

        if "PFILES" not in os.environ:
            raise PFILESNotFoundError("$PFILES is not set.")

    def getAnalysisDir(self):
        """It returns the path of the output directory

        Returns:
            path (str) : the path of the output directory
        """

        if self.outdir.exists() and self.outdir.is_dir():
            return str(self.outdir)

        else:
            self.logger.warning(self, "OutputDirectory not found")

    def deleteAnalysisDir(self):
        """It deletes the output directory where all the products of the analysis are written.

        Args:

        Returns:
            True if the directory is succesfully deleted, False otherwise.

        """
        outDir = Path(self.config.getConf("output", "outdir"))

        if outDir.exists() and outDir.is_dir():
            self.logger.info(self, "Removing directory %s", str(outDir))
            self.logger.reset()
            rmtree(outDir)
        else:
            self.logger.warning(self,
                                "Output directory %s exists? %r is dir? %r",
                                str(outDir), outDir.exists(), outDir.is_dir())
            return False

        return True

    def setOptions(self, **kwargs):
        """It updates configuration options specifying one or more key=value pairs at once.

        Args:
            kwargs: key-values pairs, separated by a comma.

        Returns:
            None

        Raises:
            ConfigFileOptionTypeError: if the type of the option value is not wrong.
            ConfigurationsNotValidError: if the values are not coherent with the configuration.
            CannotSetHiddenOptionError: if the option is hidden.
            OptionNotFoundInConfigFileError: if the option is not found.

        Note:
            The ``config`` attribute is initialized by reading the corresponding
            yaml configuration file, loading its contents in memory. Updating the values
            held by this object will not affect the original values written on disk.

        Example:

            >>> aganalysis.setOptions(mapsize=60, binsize=0.5)
            True

        """
        return self.config.setOptions(**kwargs)

    def getOption(self, optionName):
        """It reads an option value from the configuration.

        Args:
            optionName (str): the name of the option.

        Returns:
            The option value

        Raises:
            OptionNotFoundInConfigFileError: if the optionName is not found in the configuration.
        """

        return self.config.getOptionValue(optionName)

    def printOptions(self, section=None):
        """It prints the configuration options in the console.

        Args:
            section (str): you can specify a configuration file section to be printed out.

        Returns:
            None
        """
        return self.config.printOptions(section)
Пример #6
0
class AgilepyUtilsUT(unittest.TestCase):
    def setUp(self):
        self.currentDirPath = Path(__file__).parent.absolute()
        self.agilepyconfPath = os.path.join(self.currentDirPath,
                                            "conf/agilepyconf.yaml")

        self.config = AgilepyConfig()
        self.config.loadBaseConfigurations(self.agilepyconfPath)

        self.agilepyLogger = AgilepyLogger()

        self.agilepyLogger.initialize(
            self.config.getConf("output", "outdir"),
            self.config.getConf("output", "logfilenameprefix"),
            self.config.getConf("output", "verboselvl"))

        self.datadir = os.path.join(self.currentDirPath, "data")

        self.outDir = Path(self.config.getOptionValue("outdir"))

        if self.outDir.exists() and self.outDir.is_dir():
            self.agilepyLogger.reset()
            shutil.rmtree(self.outDir)

        self.tmpDir = Path("./tmp")
        self.tmpDir.mkdir(exist_ok=True)

    def tearDown(self):
        self.agilepyLogger.reset()
        if self.tmpDir.exists() and self.tmpDir.is_dir():
            shutil.rmtree(self.tmpDir)

    def test_display_sky_map(self):

        pu = PlottingUtils(self.config, self.agilepyLogger)

        smooth = 4
        fileFormat = ".png"
        title = "testcase"
        cmap = "CMRmap"
        regFiles = [
            Utils._expandEnvVar("$AGILE/catalogs/2AGL_2.reg"),
            Utils._expandEnvVar("$AGILE/catalogs/2AGL_2.reg")
        ]
        regFileColors = ["yellow", "blue"]


        file = pu.displaySkyMap(
                    self.datadir+"/testcase_EMIN00100_EMAX00300_01.cts.gz", \
                    smooth = smooth,
                    fileFormat = fileFormat,
                    title = title,
                    cmap = cmap,
                    regFiles = regFiles,
                    regFileColors=regFileColors,
                    catalogRegions = "2AGL",
                    catalogRegionsColor = "red",
                    saveImage=True,
                    normType="linear")

        assert True == os.path.isfile(file)

    def test_display_sky_map_single_mode_3_imgs(self):

        pu = PlottingUtils(self.config, self.agilepyLogger)

        smooth = 4
        fileFormat = ".png"
        title = "testcase"
        cmap = "CMRmap"
        regFiles = [
            Utils._expandEnvVar("$AGILE/catalogs/2AGL_2.reg"),
            Utils._expandEnvVar("$AGILE/catalogs/2AGL_2.reg")
        ]
        regFileColors = ["yellow", "blue"]
        img = self.datadir + "/testcase_EMIN00100_EMAX00300_01.cts.gz"

        file = pu.displaySkyMapsSingleMode(
                    [img, img, img], \
                    smooth = smooth,
                    fileFormat = fileFormat,
                    titles = [title+"_1", title+"_2", title+"_3"],
                    cmap = cmap,
                    regFiles = regFiles,
                    regFileColors=regFileColors,
                    catalogRegions = "2AGL",
                    catalogRegionsColor = "red",
                    saveImage=True,
                    normType="linear")

        assert True == os.path.isfile(file)

    def test_display_sky_map_single_mode_2_imgs(self):

        pu = PlottingUtils(self.config, self.agilepyLogger)

        smooth = 4
        fileFormat = ".png"
        title = "testcase"
        cmap = "CMRmap"
        regFiles = [
            Utils._expandEnvVar("$AGILE/catalogs/2AGL_2.reg"),
            Utils._expandEnvVar("$AGILE/catalogs/2AGL_2.reg")
        ]
        regFileColors = ["yellow", "blue"]
        img = self.datadir + "/testcase_EMIN00100_EMAX00300_01.cts.gz"

        file = pu.displaySkyMapsSingleMode(
                    [img, img], \
                    smooth = smooth,
                    fileFormat = fileFormat,
                    titles = [title+"_1", title+"_2", title+"_3"],
                    cmap = cmap,
                    regFiles = regFiles,
                    regFileColors=regFileColors,
                    catalogRegions = "2AGL",
                    catalogRegionsColor = "red",
                    saveImage=True,
                    normType="linear")

        assert True == os.path.isfile(file)

    def test_plot_data_availability(self):

        outputDir = self.currentDirPath.joinpath(
            "output", "test_plot_data_availability")
        outputDir.mkdir(parents=True, exist_ok=True)
        os.environ["TEST_LOGS_DIR"] = str(outputDir)

        config = AgilepyConfig()
        config.loadBaseConfigurations(
            self.currentDirPath.joinpath("conf",
                                         "test_plot_data_availability.yaml"))

        pu = PlottingUtils(config, self.agilepyLogger)

        dataDir = Path(self.datadir).joinpath("test_plot_data_availability")

        pu.plotDataAvailability(dataDir.joinpath("EVT.qfile"),
                                dataDir.joinpath("EVT.index"),
                                saveImage=True)

        #pu.plotDataAvailability(dataDir.joinpath("LOG.qfile"), dataDir.joinpath("LOG.index"), saveImage=True)

    def test_initialize_logger_verboselvl_2(self):
        sleep(1.0)
        self.agilepyLogger.reset()

        self.config.loadBaseConfigurations(
            os.path.join(self.currentDirPath,
                         "conf/agilepyconf_verbose_2.yaml"))

        logfilePath = self.agilepyLogger.initialize(
            self.config.getOptionValue("outdir"),
            self.config.getOptionValue("logfilenameprefix"),
            self.config.getOptionValue("verboselvl"))

        assert True == logfilePath.is_file()

        with open(logfilePath, "r") as f:
            linesNumber = len(f.readlines())
            assert 1 == linesNumber

        self.agilepyLogger.debug(self, "%s %s", "Debug", "message")
        self.agilepyLogger.info(self, "%s %s", "Info", "message")
        self.agilepyLogger.warning(self, "%s %s", "Warning", "message")
        self.agilepyLogger.critical(self, "%s %s", "Critical", "message")

        with open(logfilePath, "r") as f:
            linesNumber = len(f.readlines())
            assert 5 == linesNumber

    def test_initialize_logger_verboselvl_1(self):
        sleep(1.0)
        self.agilepyLogger.reset()

        self.config.loadBaseConfigurations(
            os.path.join(self.currentDirPath,
                         "conf/agilepyconf_verbose_1.yaml"))

        logfilePath = self.agilepyLogger.initialize(
            self.config.getOptionValue("outdir"),
            self.config.getOptionValue("logfilenameprefix"),
            self.config.getOptionValue("verboselvl"))

        assert True == logfilePath.is_file()

        with open(logfilePath, "r") as f:
            linesNumber = len(f.readlines())
            assert 1 == linesNumber

        self.agilepyLogger.debug(self, "%s %s", "Debug", "message")
        self.agilepyLogger.info(self, "%s %s", "Info", "message")
        self.agilepyLogger.warning(self, "%s %s", "Warning", "message")
        self.agilepyLogger.critical(self, "%s %s", "Critical", "message")

        with open(logfilePath, "r") as f:
            linesNumber = len(f.readlines())
            assert 5 == linesNumber

    def test_initialize_logger_verboselvl_0(self):
        sleep(1.0)
        self.agilepyLogger.reset()

        self.config.loadBaseConfigurations(
            os.path.join(self.currentDirPath,
                         "conf/agilepyconf_verbose_0.yaml"))

        logfilePath = self.agilepyLogger.initialize(
            self.config.getOptionValue("outdir"),
            self.config.getOptionValue("logfilenameprefix"),
            self.config.getOptionValue("verboselvl"))

        assert True == logfilePath.is_file()

        with open(logfilePath, "r") as f:
            linesNumber = len(f.readlines())
            assert 1 == linesNumber

        self.agilepyLogger.debug(self, "%s %s", "Debug", "message")
        self.agilepyLogger.info(self, "%s %s", "Info", "message")
        self.agilepyLogger.warning(self, "%s %s", "Warning", "message")
        self.agilepyLogger.critical(self, "%s %s", "Critical", "message")

        with open(logfilePath, "r") as f:
            linesNumber = len(f.readlines())
            assert 5 == linesNumber

    def test_filterAP(self):

        print(self.datadir + "/E1q1_604800s_emin100_emax10000_r2.ap")
        print(self.currentDirPath)
        product = AstroUtils.AP_filter(
            self.datadir + "/E1q1_604800s_emin100_emax10000_r2.ap", 1,
            174142800, 447490800, self.currentDirPath)
        with open(product, "r") as f:
            linesNumber = len(f.readlines())
            assert 4 == linesNumber

        os.remove(os.path.join(self.currentDirPath, "result.txt"))
        os.remove(os.path.join(self.currentDirPath, product))

    """
    Time conversions
        # https://tools.ssdc.asi.it/conversionTools
        # https://heasarc.gsfc.nasa.gov/cgi-bin/Tools/xTime/xTime.pl?time_in_i=&time_in_c=&time_in_d=&time_in_j=&time_in_m=58871.45616898&time_in_sf=&time_in_wf=&time_in_sl=&time_in_sni=&time_in_snu=&time_in_s=&time_in_h=&time_in_sz=&time_in_ss=&time_in_sn=&timesys_in=u&timesys_out=u&apply_clock_offset=yes
    """

    def test_astro_utils_time_mjd_to_agile_seconds(self):
        sec_tolerance = 0.001
        tt = AstroUtils.time_mjd_to_agile_seconds(
            58871.45616898)  # 506861812.99987227
        assert abs(506861813 - tt) <= sec_tolerance

    def test_astro_utils_time_agile_seconds_to_mjd(self):
        sec_tolerance = 0.0000001
        mjd = AstroUtils.time_agile_seconds_to_mjd(507391426.9447)
        assert abs(58877.58595999 - mjd) <= sec_tolerance

    def test_astro_utils_time_utc_to_jd(self):

        tol = 0.00000001

        dt = "2020-01-23T10:56:53.000"

        jd = AstroUtils.time_fits_to_jd(dt)

        assert abs(2458871.95616898 - jd) <= tol

    def test_astro_utils_time_utc_to_mjd(self):

        tol = 0.00000001

        dt = "2020-01-23T10:56:53.000"

        mjd = AstroUtils.time_fits_to_mjd(dt)

        assert abs(58871.45616898 - mjd) <= tol

    def test_astro_utils_time_utc_to_tt(self):

        tol = 0.0001

        agileseconds = AstroUtils.time_fits_to_agile_seconds(
            "2020-01-23T10:56:53.000")

        assert abs(506861813 - agileseconds) <= tol

    def test_astro_utils_time_agile_seconds_to_jd(self):
        jd = AstroUtils.time_agile_seconds_to_jd(449582332)
        assert jd == pytest.approx(2458208.99921296, 0.00001)

    def test_astro_utils_time_agile_seconds_to_utc(self):

        sec_tol = 1
        """
        utc = AstroUtils.time_tt_to_utc(506861813)
        dt = datetime.strptime(utc, '%Y-%m-%dT%H:%M:%S.%f')

        assert dt.year == 2020
        assert dt.month == 1
        assert dt.day == 23
        assert dt.hour == 10
        assert dt.minute == 56
        assert abs(53 - dt.second) <= sec_tol
        """

        # This date would result in "0 days"
        sec_tolerance = 0.0000001
        fitstime = AstroUtils.time_agile_seconds_to_fits(449582332)
        dt = datetime.strptime(fitstime, '%Y-%m-%dT%H:%M:%S.%f')

        assert dt.year == 2018
        assert dt.month == 3
        assert dt.day == 31
        assert dt.hour == 11
        assert dt.minute == 58
        assert abs(52 - dt.second) <= sec_tol

    def test_astro_utils_time_mjd_to_fits(self):

        sec_tol = 1

        fitstime = AstroUtils.time_mjd_to_fits(58871.45616898)

        dt = datetime.strptime(fitstime, '%Y-%m-%dT%H:%M:%S.%f')

        assert dt.year == 2020
        assert dt.month == 1
        assert dt.day == 23
        assert dt.hour == 10
        assert dt.minute == 56
        assert abs(53 - dt.second) <= sec_tol

    def test_astro_utils_time_fits_to_mjd_2(self):

        sec_tol = 0.00000001

        mjd = AstroUtils.time_fits_to_mjd("2020-01-23T10:56:53.000")

        assert abs(58871.45616898 - mjd) <= sec_tol

    def test_get_first_and_last_line_in_file(self):

        line1 = '/ASDC_PROC2/FM3.119_2/EVT/agql2004151750_2004151850.EVT__FM.gz 514057762.000000 514061362.000000 EVT\n'
        line2 = '/ASDC_PROC2/FM3.119_2/EVT/agql2004152249_2004160008.EVT__FM.gz 514075704.000000 514080437.000000 EVT\n'
        line3 = '/ASDC_PROC2/FM3.119_2/EVT/agql2004160008_2004160045.EVT__FM.gz 514080437.000000 514082644.000000 EVT\n'

        # I test: 1 line
        test_file = self.tmpDir.joinpath("test_file1.txt")
        with open(test_file, "w") as f:
            f.write(line1)
        (first, last) = Utils._getFirstAndLastLineInFile(test_file)
        assert first == line1
        assert last == line1

        # II test: 2 lines
        test_file = self.tmpDir.joinpath("test_file2.txt")
        with open(test_file, "w") as f:
            f.write(line1)
            f.write(line2)
        (first, last) = Utils._getFirstAndLastLineInFile(test_file)
        assert first == line1
        assert last == line2

        # III test: 3 lines
        test_file = self.tmpDir.joinpath("test_file3.txt")
        with open(test_file, "w") as f:
            f.write(line1)
            f.write(line2)
            f.write(line3)
        (first, last) = Utils._getFirstAndLastLineInFile(test_file)
        assert first == line1
        assert last == line3

    """
Пример #7
0
class SourcesLibraryUT(unittest.TestCase):
    def setUp(self):
        self.currentDirPath = Path(__file__).parent.absolute()

        self.test_logs_dir = Path(self.currentDirPath).joinpath(
            "test_logs", "SourcesLibraryUT")
        self.test_logs_dir.mkdir(parents=True, exist_ok=True)
        os.environ["TEST_LOGS_DIR"] = str(self.test_logs_dir)

        self.agilepyConf = os.path.join(self.currentDirPath,
                                        "conf/agilepyconf.yaml")

        self.config = AgilepyConfig()
        self.config.loadBaseConfigurations(self.agilepyConf)
        self.config.loadConfigurationsForClass("AGAnalysis")

        self.logger = AgilepyLogger()
        self.logger.initialize(
            self.config.getConf("output", "outdir"),
            self.config.getConf("output", "logfilenameprefix"),
            self.config.getConf("output", "verboselvl"))

        outDir = Path(
            os.path.join(os.environ["AGILE"],
                         "agilepy-test-data/unittesting-output/core"))

        if outDir.exists() and outDir.is_dir():
            shutil.rmtree(outDir)

        self.sl = SourcesLibrary(self.config, self.logger)

    @staticmethod
    def get_free_params(source):

        return {
            "curvature": source.spectrum.curvature["free"],
            "pivot_energy": source.spectrum.pivotEnergy["free"],
            "index": source.spectrum.index["free"],
            "pos": source.spatialModel.pos["free"],
            "flux": source.spectrum.flux["free"]
        }

    def test_load_file_with_wrong_extension(self):

        xmlsourcesconfPath = os.path.join(self.currentDirPath,
                                          "test_data/sourceconf.wrongext")

        self.assertRaises(SourceModelFormatNotSupported,
                          self.sl.loadSourcesFromFile, xmlsourcesconfPath)

    def test_load_wrong_file(self):

        xmlsourcesconfPath = os.path.join(self.currentDirPath,
                                          "conf/idontexitst.txt")

        self.assertRaises(FileNotFoundError, self.sl.loadSourcesFromFile,
                          xmlsourcesconfPath)

    def test_load_from_catalog(self):

        added = self.sl.loadSourcesFromCatalog("2AGL")
        self.assertEqual(175, len(added))
        self.assertEqual(175, len(self.sl.sources))

        self.assertRaises(FileNotFoundError, self.sl.loadSourcesFromCatalog,
                          "paperino")

    def test_load_catalog_from_catalog_filtering_on_distances(self):

        added = self.sl.loadSourcesFromCatalog("2AGL", rangeDist=(70, 80))

        self.assertEqual(13, len(added))
        self.assertEqual(13, len(self.sl.sources))

        self.sl.sources = []
        added = self.sl.loadSourcesFromCatalog("2AGL", rangeDist=(0, 10))
        self.assertEqual(1, len(added))
        self.assertEqual(1, len(self.sl.sources))

        self.sl.sources = []
        added = self.sl.loadSourcesFromCatalog("2AGL", rangeDist=(0, 50))
        self.assertEqual(30, len(added))
        self.assertEqual(30, len(self.sl.sources))

    def test_load_sources_from_xml_file(self):

        added = self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))

        self.assertEqual(2, len(added))
        self.assertEqual(2, len(self.sl.sources))

        sources = self.sl.selectSources('name == "2AGLJ2021+4029"')
        self.assertEqual(1, len(sources))
        source = sources.pop()
        self.assertEqual(119.3e-08, source.spectrum.getVal("flux"))
        self.assertEqual(1.75, source.spectrum.getVal("index"))
        self.assertEqual(78.2375, source.spatialModel.getVal("pos")[0])
        self.assertEqual(True, source.spatialModel.getVal("dist") > 0)

        sources = self.sl.selectSources('name == "2AGLJ2021+3654"')
        self.assertEqual(1, len(sources))
        source = sources.pop()
        self.assertEqual(70.89e-08, source.spectrum.getVal("flux"))
        self.assertEqual(1.38, source.spectrum.getVal("index"))
        self.assertEqual(75.2562, source.spatialModel.getVal("pos")[0])
        self.assertEqual(True, source.spatialModel.getVal("dist") > 0)

    def test_load_sources_from_txt_file(self):

        added = self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.txt"))

        self.assertEqual(10, len(added))
        self.assertEqual(10, len(self.sl.sources))

        sources = self.sl.selectSources('name == "2AGLJ1801-2334"')
        self.assertEqual(1, len(sources))
        source = sources.pop()

        self.assertEqual(3.579e-07, source.spectrum.getVal("flux"))
        self.assertEqual(3.37991, source.spectrum.getVal("index"))
        self.assertEqual(6.16978, source.spatialModel.getVal("pos")[0])

        # testing fixflags
        f0 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 0,
            "pos": 0,
            "flux": 0
        }  # special case
        f1 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 0,
            "pos": 0,
            "flux": 1
        }
        f2 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 0,
            "pos": 1,
            "flux": 0
        }
        f3 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 0,
            "pos": 1,
            "flux": 1
        }
        f4 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 1,
            "pos": 0,
            "flux": 0
        }
        f5 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 1,
            "pos": 0,
            "flux": 1
        }

        f7 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 1,
            "pos": 1,
            "flux": 1
        }

        f28 = {
            "curvature": 1,
            "pivot_energy": 1,
            "index": 1,
            "pos": 0,
            "flux": 0
        }
        f30 = {
            "curvature": 1,
            "pivot_energy": 1,
            "index": 1,
            "pos": 1,
            "flux": 0
        }
        f32 = {
            "curvature": 0,
            "pivot_energy": 0,
            "index": 0,
            "pos": 2,
            "flux": 0
        }  # special case

        fs = [f0, f1, f2, f3, f4, f5, f7, f28, f30, f32]

        for i in range(len(fs)):
            ff = i
            if ff == 6: ff = 7
            elif ff == 7: ff = 28
            elif ff == 8: ff = 30
            elif ff == 9: ff = 32

            self.assertDictEqual(
                fs[i], SourcesLibraryUT.get_free_params(self.sl.sources[i]))

    def test_source_file_parsing(self):

        sourceFile = os.path.join(self.currentDirPath,
                                  "test_data/testcase_2AGLJ0835-4514.source")

        res = self.sl.parseSourceFile(sourceFile)

        self.assertEqual(True, bool(res))

        self.assertEqual(True, isinstance(res.multiFlux["value"], float))
        self.assertEqual(9.07364e-06, res.multiFlux["value"])
        self.assertEqual(True, isinstance(res.multiSqrtTS["value"], float))
        self.assertEqual(2.17268, res.multiSqrtTS["value"])
        self.assertEqual(None, res.multiDist["value"])

    def test_load_source_from_catalog_without_scaling(self):

        sources = self.sl.loadSourcesFromCatalog(catalogName="2AGL")

        self.assertEqual(175, len(sources))

        self.assertEqual(7.45398e-08, sources[0].spectrum.getVal("flux"))

    def test_load_source_from_catalog_with_scaling(self):

        self.config.setOptions(emin_sources=10, emax_sources=1000)

        sources = self.sl.loadSourcesFromCatalog(catalogName="2AGL")

        self.assertEqual(175, len(sources))

        self.assertEqual(6.940938928095228e-07,
                         sources[0].spectrum.getVal("flux"))

    def test_select_sources_with_selection_string(self):

        self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))
        self.assertEqual(2, len(self.sl.sources))

        sources = self.sl.selectSources(
            'name == "2AGLJ2021+3654" AND flux > 0')
        self.assertEqual(1, len(sources))

        sourceFile = os.path.join(self.currentDirPath,
                                  "test_data/testcase_2AGLJ2021+3654.source")

        mleAnalysisResults = self.sl.parseSourceFile(sourceFile)

        self.sl.updateSourceWithMLEResults(mleAnalysisResults)

        sources = self.sl.selectSources(
            'name == "2AGLJ2021+3654" AND flux > 0')
        self.assertEqual(1, len(sources))

        sources = self.sl.selectSources('multisqrtts == 10')
        self.assertEqual(1, len(sources))

        sources = self.sl.selectSources('sqrtts == 10')
        self.assertEqual(1, len(sources))

    def test_select_sources_with_selection_lambda(self):

        self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))

        sources = self.sl.selectSources(lambda name: name == "2AGLJ2021+3654")
        self.assertEqual(1, len(sources))

        sourceFile = os.path.join(self.currentDirPath,
                                  "test_data/testcase_2AGLJ2021+3654.source")

        mleAnalysisResults = self.sl.parseSourceFile(sourceFile)

        self.sl.updateSourceWithMLEResults(mleAnalysisResults)

        sources = self.sl.selectSources(
            lambda name, flux: name == "2AGLJ2021+3654" and flux > 0)
        self.assertEqual(1, len(sources))

    def test_free_sources_with_selection_string(self):

        self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))
        sourceFile = os.path.join(self.currentDirPath,
                                  "test_data/testcase_2AGLJ2021+3654.source")
        mleAnalysisResults = self.sl.parseSourceFile(sourceFile)
        self.sl.updateSourceWithMLEResults(mleAnalysisResults)

        sources = self.sl.freeSources('name == "2AGLJ2021+3654" AND flux > 0',
                                      "flux", False)

        self.assertEqual(1, len(sources))
        self.assertEqual(True, "flux" not in sources[0].getFreeParams())

        sources = self.sl.freeSources('name == "2AGLJ2021+3654" AND flux > 0',
                                      "flux", True)
        self.assertEqual(True, "flux" in sources[0].getFreeParams())

        sources = self.sl.freeSources('name == "2AGLJ2021+3654" AND flux > 0',
                                      "index", True)
        self.assertEqual(True, "index" in sources[0].getFreeParams())

        sources = self.sl.freeSources('name == "2AGLJ2021+3654" AND flux > 0',
                                      "index", False)
        self.assertEqual(True, "index" not in sources[0].getFreeParams())

    def test_free_sources_with_selection_lambda(self):

        self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))
        sourceFile = os.path.join(self.currentDirPath,
                                  "test_data/testcase_2AGLJ2021+3654.source")
        mleAnalysisResults = self.sl.parseSourceFile(sourceFile)
        self.sl.updateSourceWithMLEResults(mleAnalysisResults)

        sources = self.sl.freeSources(
            lambda name, flux: name == "2AGLJ2021+3654" and flux > 0, "flux",
            False)
        self.assertEqual(1, len(sources))
        self.assertEqual(True, "flux" not in sources[0].getFreeParams())

        sources = self.sl.freeSources(
            lambda name, flux: name == "2AGLJ2021+3654" and flux > 0, "flux",
            True)
        self.assertEqual(True, "flux" in sources[0].getFreeParams())

        sources = self.sl.freeSources(
            lambda name, flux: name == "2AGLJ2021+3654" and flux > 0, "index",
            True)
        self.assertEqual(True, "index" in sources[0].getFreeParams())

        sources = self.sl.freeSources(
            lambda name, flux: name == "2AGLJ2021+3654" and flux > 0, "index",
            False)
        self.assertEqual(True, "index" not in sources[0].getFreeParams())

    def test_write_to_file_xml(self):

        self.config = AgilepyConfig()

        self.config.loadBaseConfigurations(self.agilepyConf)

        self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))

        outfileName = "write_to_file_testcase"

        outputFile = Path(self.sl.writeToFile(outfileName, fileformat="xml"))

        self.assertEqual(True, outputFile.exists())

        sourcesxml = parse(outputFile).getroot()

        self.assertEqual(2, len(sourcesxml))

    def test_write_to_file_txt(self):

        self.config = AgilepyConfig()

        self.config.loadBaseConfigurations(self.agilepyConf)

        sourcesFile = os.path.join(
            self.currentDirPath,
            "test_data/sourcesconf_for_write_to_file_txt.txt")

        self.sl.loadSourcesFromFile(sourcesFile)

        outfileName = "write_to_file_testcase"

        outputFile = Path(self.sl.writeToFile(outfileName, fileformat="txt"))

        self.assertEqual(True, outputFile.exists())

        with open(outputFile) as of:
            lines = of.readlines()

        self.assertEqual(
            "1.57017e-07 80.3286 1.12047 2.16619 0 2 _2AGLJ2032+4135 0 0 0 0 0.5 5.0 20 10000 0 100",
            lines[0].strip())
        self.assertEqual(
            "1.69737e-07 79.9247 0.661449 1.99734 0 2 CYGX3 0 0 0 0 0.5 5.0 20 10000 0 100",
            lines[1].strip())
        self.assertEqual(
            "1.19303e-06 78.2375 2.12298 1.75823 3 2 _2AGLJ2021+4029 0 1 3307.63 0 0.5 5.0 20.0 10000.0  0 100",
            lines[2].strip())

    def test_add_source(self):

        self.config = AgilepyConfig()

        self.config.loadBaseConfigurations(self.agilepyConf)

        self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))

        newSourceDict = {"a": 10}
        self.assertRaises(SourceParamNotFoundError, self.sl.addSource,
                          "newsource", newSourceDict)

        newSourceDict = {
            "glon": 250,
            "glat": 30,
            "spectrumType": "LogPaperone"
        }
        self.assertRaises(SpectrumTypeNotFoundError, self.sl.addSource,
                          "newsource", newSourceDict)

        newSourceDict = {
            "glon": 250,
            "glat": 30,
            "spectrumType": "LogParabola"
        }
        self.assertRaises(SourceParamNotFoundError, self.sl.addSource, "",
                          newSourceDict)
        self.assertRaises(SourceParamNotFoundError, self.sl.addSource, None,
                          newSourceDict)
        self.assertRaises(SourceParamNotFoundError, self.sl.addSource,
                          "newsource", newSourceDict)

        newSourceDict = {
            "glon": 250,
            "glat": 30,
            "spectrumType": "LogParabola",
            "flux": 40,
            "index": 2,
            "pivotEnergy": 4,
            "curvature": 5
        }
        newSourceObj = self.sl.addSource("newsource", newSourceDict)

        self.assertEqual(True, isinstance(newSourceObj, PointSource))

        newSource = self.sl.selectSources('name == "newsource"').pop()

        self.assertEqual(40, newSource.spectrum.getVal("flux"))
        self.assertEqual(5, newSource.spectrum.getVal("curvature"))
        self.assertEqual("newsource", newSource.name)
        self.assertEqual(35.2462913047547,
                         newSource.spatialModel.getVal("dist"))

    def test_convert_catalog_to_xml(self):

        catalogFile = "$AGILE/catalogs/2AGL.multi"

        outfile = self.sl.convertCatalogToXml(catalogFile)

        sourcesxml = parse(outfile).getroot()

        self.assertEqual(175, len(sourcesxml))

        added = self.sl.loadSourcesFromFile(outfile)

        self.assertEqual(175, len(added))

        self.assertEqual(175, len(self.sl.sources))

    def test_backup_restore(self):
        self.config = AgilepyConfig()

        self.config.loadBaseConfigurations(self.agilepyConf)

        self.sl.loadSourcesFromFile(
            os.path.join(self.currentDirPath, "test_data/sources_2.xml"))
        """
        for s in self.sl.getSources():
            print(s)
        """

        self.assertEqual(2, len(self.sl.sources))

        self.sl.backupSL()

        self.sl.deleteSources('name=="2AGLJ2021+4029"')

        self.assertEqual(1, len(self.sl.sources))

        self.sl.deleteSources('name=="2AGLJ2021+3654"')

        self.assertEqual(0, len(self.sl.sources))

        self.sl.restoreSL()

        self.assertEqual(2, len(self.sl.sources))
Пример #8
0
class SourceModelUT(unittest.TestCase):
    def setUp(self):
        self.currentDirPath = Path(__file__).parent.absolute()

        self.test_logs_dir = Path(self.currentDirPath).joinpath(
            "test_logs", "SourceModelUT")
        self.test_logs_dir.mkdir(parents=True, exist_ok=True)

        os.environ["TEST_LOGS_DIR"] = str(self.test_logs_dir)

        outDir = Path(os.path.join(os.environ["AGILE"])).joinpath(
            "agilepy-test-data/unittesting-output/core")
        if outDir.exists() and outDir.is_dir():
            shutil.rmtree(outDir)

        self.sourcesTxt = os.path.join(self.currentDirPath,
                                       "test_data/sources.txt")
        self.sourcesXml = os.path.join(self.currentDirPath,
                                       "test_data/sources.xml")

        self.agilepyConf = os.path.join(self.currentDirPath,
                                        "conf/agilepyconf.yaml")

        self.config = AgilepyConfig()
        self.config.loadBaseConfigurations(self.agilepyConf)
        self.config.loadConfigurationsForClass("AGAnalysis")

        self.logger = AgilepyLogger()
        self.logger.initialize(
            self.config.getConf("output", "outdir"),
            self.config.getConf("output", "logfilenameprefix"),
            self.config.getConf("output", "verboselvl"))

        self.sl = SourcesLibrary(self.config, self.logger)

    def test_parse_source_XML_format(self):

        xmlRoot = parse(self.sourcesXml).getroot()

        sources = []

        for sourceRoot in xmlRoot:

            source = Source.parseSourceXMLFormat(sourceRoot)

            sources.append(source)

        assert sources[0].get("flux")["value"] == 7.45398e-08
        assert sources[0].get("pos")["value"] == (92.4102, -10.3946)

        assert sources[1].get("flux")["value"] == 41.6072e-08
        assert sources[1].get("pos")["value"] == (119.677, 10.544)

        assert sources[2].get("flux")["value"] == 969.539e-08
        assert sources[2].get("index2")["value"] == 1.3477
        assert sources[2].get("index2")["free"] == 1
        assert sources[2].get("pos")["value"] == (263.585, -2.84083)

        assert sources[3].get("flux")["value"] == 35.79e-08
        assert sources[3].get("curvature")["value"] == 0.682363
        assert sources[3].get("curvature")["max"] == 3
        assert sources[3].get("pos")["value"] == (6.16978, -0.0676943)

    def test_parse_source_TXT_format(self):

        sources = []

        with open(self.sourcesTxt, "r") as txtFile:

            for line in txtFile:

                if line == "\n":
                    continue

                source = Source.parseSourceTXTFormat(line)

                sources.append(source)

        assert sources[0].name == "2AGLJ2021+4029"
        assert sources[0].get("flux")["value"] == 119.3e-08
        assert sources[0].get("pos")["value"] == (78.2375, 2.12298)

        assert sources[1].name == "2AGLJ2021+3654"
        assert sources[1].get("flux")["value"] == 70.89e-08
        assert sources[1].get("pos")["value"] == (75.2562, 0.151831)

    def test_init(self):

        source = PointSource(name="test-source")
        source.spectrum = Spectrum.getSpectrum("PowerLaw")
        assert "PointSource" == type(source.spatialModel).__name__

    def test_get(self):

        source = PointSource(name="test-source")
        source.spectrum = Spectrum.getSpectrum("PowerLaw")
        assert "PointSource" == type(source.spatialModel).__name__

        assert len(source.get("flux").keys()) == 6
        assert source.getVal("flux") == None

        with pytest.raises(SourceParameterNotFound):
            source.get("fluxxx")

        with pytest.raises(SourceParameterNotFound):
            source.getVal("fluxxx")

    def test_set(self):

        source = PointSource(name="test-source")
        source.spectrum = Spectrum.getSpectrum("PowerLaw")
        assert "PointSource" == type(source.spatialModel).__name__

        source.set("flux", {"min": 1})
        source.setVal("flux", 10)
        assert source.spectrum.flux["min"] == 1
        assert source.spectrum.flux["value"] == 10

        with pytest.raises(SourceParameterNotFound):
            source.set("fluxxx", {"value": 10})

        with pytest.raises(ValueError):
            source.set("fluxxx", 10)

        with pytest.raises(SourceParameterNotFound):
            source.setVal("fluxxx", 100)

    def test_str(self):
        source = PointSource(name="test-source")
        source.spectrum = Spectrum.getSpectrum("PowerLaw")
        source.setVal("flux", 100)
        source.setVal("index", 1000)
        source.setVal("pos", (30, 15))

        print(source)
        """