Esempio n. 1
0
    def test_spectrum_dataset_stack_nondiagonal_no_bkg(self):
        aeff = EffectiveAreaTable.from_parametrization(self.src.energy.edges,
                                                       "HESS")
        edisp1 = EnergyDispersion.from_gauss(self.src.energy.edges,
                                             self.src.energy.edges, 0.1, 0.0)
        livetime = self.livetime
        dataset1 = SpectrumDataset(counts=None,
                                   livetime=livetime,
                                   aeff=aeff,
                                   edisp=edisp1,
                                   background=None)

        livetime2 = livetime
        aeff2 = EffectiveAreaTable(self.src.energy.edges[:-1],
                                   self.src.energy.edges[1:], aeff.data.data)
        edisp2 = EnergyDispersion.from_gauss(self.src.energy.edges,
                                             self.src.energy.edges, 0.2, 0.0)
        dataset2 = SpectrumDataset(
            counts=self.src.copy(),
            livetime=livetime2,
            aeff=aeff2,
            edisp=edisp2,
            background=None,
        )
        dataset1.stack(dataset2)

        assert dataset1.counts is None
        assert dataset1.background is None
        assert dataset1.livetime == 2 * self.livetime
        assert_allclose(dataset1.aeff.data.data.to_value("m2"),
                        aeff.data.data.to_value("m2"))
        assert_allclose(dataset1.edisp.get_bias(1 * u.TeV), 0.0, atol=1e-3)
        assert_allclose(dataset1.edisp.get_resolution(1 * u.TeV),
                        0.1581,
                        atol=1e-2)
Esempio n. 2
0
def test_compute_thresholds_from_parametrization():
    energy = np.logspace(-2, 2.0, 100) * u.TeV
    aeff = EffectiveAreaTable.from_parametrization(energy=energy)
    edisp = EnergyDispersion.from_gauss(e_true=energy,
                                        e_reco=energy,
                                        sigma=0.2,
                                        bias=0)

    thresh_lo, thresh_hi = compute_energy_thresholds(
        aeff=aeff,
        edisp=edisp,
        method_lo="area_max",
        method_hi="area_max",
        area_percent_lo=10,
        area_percent_hi=90,
    )

    assert_allclose(thresh_lo.to("TeV").value, 0.18557, rtol=1e-4)
    assert_allclose(thresh_hi.to("TeV").value, 43.818, rtol=1e-4)

    thresh_lo, thresh_hi = compute_energy_thresholds(aeff=aeff,
                                                     edisp=edisp,
                                                     method_hi="area_max",
                                                     area_percent_hi=70)

    assert_allclose(thresh_hi.to("TeV").value, 100.0, rtol=1e-4)
Esempio n. 3
0
def make_observation_list():
    """obs with dummy IRF"""
    nbin = 3
    energy = np.logspace(-1, 1, nbin + 1) * u.TeV
    livetime = 2 * u.h
    data_on = np.arange(nbin)
    dataoff_1 = np.ones(3)
    dataoff_2 = np.ones(3) * 3
    dataoff_1[1] = 0
    dataoff_2[1] = 0
    on_vector = CountsSpectrum(energy_lo=energy[:-1],
                               energy_hi=energy[1:],
                               data=data_on)
    off_vector1 = CountsSpectrum(energy_lo=energy[:-1],
                                 energy_hi=energy[1:],
                                 data=dataoff_1)
    off_vector2 = CountsSpectrum(energy_lo=energy[:-1],
                                 energy_hi=energy[1:],
                                 data=dataoff_2)
    aeff = EffectiveAreaTable.from_constant(energy, "1 cm2")
    edisp = EnergyDispersion.from_gauss(e_true=energy,
                                        e_reco=energy,
                                        sigma=0.2,
                                        bias=0)

    time_ref = Time("2010-01-01")
    gti1 = make_gti({
        "START": [5, 6, 1, 2],
        "STOP": [8, 7, 3, 4]
    },
                    time_ref=time_ref)
    gti2 = make_gti({"START": [14], "STOP": [15]}, time_ref=time_ref)

    obs1 = SpectrumDatasetOnOff(
        counts=on_vector,
        counts_off=off_vector1,
        aeff=aeff,
        edisp=edisp,
        livetime=livetime,
        mask_safe=np.ones(on_vector.energy.nbin, dtype=bool),
        acceptance=1,
        acceptance_off=2,
        name="1",
        gti=gti1,
    )
    obs2 = SpectrumDatasetOnOff(
        counts=on_vector,
        counts_off=off_vector2,
        aeff=aeff,
        edisp=edisp,
        livetime=livetime,
        mask_safe=np.ones(on_vector.energy.nbin, dtype=bool),
        acceptance=1,
        acceptance_off=4,
        name="2",
        gti=gti2,
    )

    obs_list = [obs1, obs2]
    return obs_list
Esempio n. 4
0
 def setup(self):
     self.e_true = np.logspace(0, 1, 101) * u.TeV
     self.e_reco = self.e_true
     self.resolution = 0.1
     self.bias = 0
     self.edisp = EnergyDispersion.from_gauss(
         e_true=self.e_true,
         e_reco=self.e_reco,
         pdf_threshold=1e-7,
         sigma=self.resolution,
         bias=self.bias,
     )
Esempio n. 5
0
def get_test_cases():
    e_true = Quantity(np.logspace(-1, 2, 120), "TeV")
    e_reco = Quantity(np.logspace(-1, 2, 100), "TeV")
    return [
        dict(model=PowerLawSpectralModel(amplitude="1e2 TeV-1"),
             e_true=e_true,
             npred=999),
        dict(
            model=PowerLaw2SpectralModel(amplitude="1",
                                         emin="0.1 TeV",
                                         emax="100 TeV"),
            e_true=e_true,
            npred=1,
        ),
        dict(
            model=PowerLawSpectralModel(amplitude="1e-11 TeV-1 cm-2 s-1"),
            aeff=EffectiveAreaTable.from_parametrization(e_true),
            livetime="10 h",
            npred=1448.05960,
        ),
        dict(
            model=PowerLawSpectralModel(reference="1 GeV",
                                        amplitude="1e-11 GeV-1 cm-2 s-1"),
            aeff=EffectiveAreaTable.from_parametrization(e_true),
            livetime="30 h",
            npred=4.34417881,
        ),
        dict(
            model=PowerLawSpectralModel(amplitude="1e-11 TeV-1 cm-2 s-1"),
            aeff=EffectiveAreaTable.from_parametrization(e_true),
            edisp=EnergyDispersion.from_gauss(e_reco=e_reco,
                                              e_true=e_true,
                                              bias=0,
                                              sigma=0.2),
            livetime="10 h",
            npred=1437.450076,
        ),
        dict(
            model=TemplateSpectralModel(
                energy=[0.1, 0.2, 0.3, 0.4] * u.TeV,
                values=[4.0, 3.0, 1.0, 0.1] * u.Unit("TeV-1"),
            ),
            e_true=[0.1, 0.2, 0.3, 0.4] * u.TeV,
            npred=0.554513062,
        ),
    ]
Esempio n. 6
0
    def run(self):
        self.make_empty_vectors(self.bkg_estimate)
        self.extract_counts(self.bkg_estimate)

        aeff = extract_aeff(self.exposure, self.target_position, self.energy)

        containment_factor = extract_psf_containment(
            self.psf, self.on_radius, self.energy
        )
        aeff.data.data *= containment_factor

        # Not the real Fermi-LAT EDISP
        # Use 5% energy resolution as approximation
        edisp = EnergyDispersion.from_gauss(
            e_true=self.energy, e_reco=self.energy, sigma=0.05, bias=0
        )

        return SpectrumObservation(
            on_vector=self._on_vector,
            aeff=aeff,
            off_vector=self._off_vector,
            edisp=edisp,
        )
Esempio n. 7
0
def extract_edisp(energy):
    """Dummy migration matrix for the fermi filename

    Its presence is needed for the sherpa fit, otherwise will trigger the issue
    commented in
    https://github.com/sherpa/sherpa/blob/7f9d31714eccfc7851fe2c439e5f186781109211/sherpa/astro/instrument.py#L556

    Parameters
    ----------
    energy : `~astropy.units.Quantity`
        energy binning to calculate the the migration matrix,
        since it's a mock energy dispersion we assume same binning
        for `e_true` and `e_reco`

    Returns
    -------
    `~gammapy.irf.EnergyDispersion`
    energy dispersion ontained assuming bias 0 and 0.05 resolution
    """
    edisp = EnergyDispersion.from_gauss(
        e_true=energy, e_reco=energy, sigma=0.05, bias=0
    )
    return edisp
"""Plot energy dispersion example."""
import matplotlib.pyplot as plt
import astropy.units as u
import numpy as np
from gammapy.irf import EnergyDispersion

ebounds = np.logspace(-1, 2, 101) * u.TeV
energy_dispersion = EnergyDispersion.from_gauss(e_true=ebounds, e_reco=ebounds, sigma=0.3)

energy_dispersion.plot_matrix()
plt.show()
import astropy.units as u
from gammapy.irf import EnergyDispersion, EffectiveAreaTable
from gammapy.spectrum import SpectrumSimulation, SpectrumFit
from gammapy.spectrum.models import PowerLaw

# ## Create detector
#
# For the sake of self consistency of this tutorial, we will simulate a simple detector. For a real application you would want to replace this part of the code with loading the IRFs or your detector.

# In[ ]:

e_true = np.logspace(-2, 2.5, 109) * u.TeV
e_reco = np.logspace(-2, 2, 79) * u.TeV

edisp = EnergyDispersion.from_gauss(e_true=e_true,
                                    e_reco=e_reco,
                                    sigma=0.2,
                                    bias=0)
aeff = EffectiveAreaTable.from_parametrization(energy=e_true)

fig, axes = plt.subplots(1, 2, figsize=(12, 6))
edisp.plot_matrix(ax=axes[0])
aeff.plot(ax=axes[1])

# ## Power law
#
# In this section we will simulate one observation using a power law model.

# In[ ]:

pwl = PowerLaw(index=2.3,
               amplitude=1e-11 * u.Unit("cm-2 s-1 TeV-1"),
Esempio n. 10
0
"""Plot energy dispersion example."""
import numpy as np
import matplotlib.pyplot as plt
import astropy.units as u
from gammapy.irf import EnergyDispersion

ebounds = np.logspace(-1, 2, 101) * u.TeV

edisp = EnergyDispersion.from_gauss(
    e_true=ebounds,
    e_reco=ebounds,
    bias=0,
    sigma=0.3,
)

edisp.peek()
plt.show()
Esempio n. 11
0
"""Plot energy dispersion example."""
import matplotlib.pyplot as plt
import astropy.units as u
import numpy as np
from gammapy.irf import EnergyDispersion

ebounds = np.logspace(-1, 2, 101) * u.TeV
energy_dispersion = EnergyDispersion.from_gauss(e_true=ebounds,
                                                e_reco=ebounds,
                                                sigma=0.3)

energy_dispersion.plot_matrix()
plt.show()
Esempio n. 12
0
"""

from gammapy.irf import EnergyDispersion, EffectiveAreaTable, abramowski_effective_area
from gammapy.spectrum.models import PowerLaw
from gammapy.spectrum import calculate_predicted_counts, SpectrumExtraction, PHACountsSpectrum, SpectrumObservation
from gammapy.utils.random import get_random_state
import numpy as np
import astropy.units as u
import matplotlib.pyplot as plt

e_true = SpectrumExtraction.DEFAULT_TRUE_ENERGY
e_reco = SpectrumExtraction.DEFAULT_RECO_ENERGY

# EDISP
edisp = EnergyDispersion.from_gauss(e_true=e_true, e_reco=e_true, sigma=0.2)

# AEFF
nodes = np.sqrt(e_true[:-1] * e_true[1:])
data = abramowski_effective_area(energy=nodes)
aeff = EffectiveAreaTable(data=data, energy=e_true)
lo_threshold = aeff.find_energy(0.1 * aeff.max_area)


# MODEL
model = PowerLaw(index=2.3 * u.Unit(""), amplitude=2.5 * 1e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1 * u.TeV)

# COUNTS
livetime = 2 * u.h
npred = calculate_predicted_counts(model=model, aeff=aeff, edisp=edisp, livetime=livetime)
Esempio n. 13
0
"""Plot energy dispersion example."""
import matplotlib.pyplot as plt
from gammapy.irf import EnergyDispersion
from gammapy.utils.energy import EnergyBounds

ebounds = EnergyBounds.equal_log_spacing(0.1, 100, 100, 'TeV')
energy_dispersion = EnergyDispersion.from_gauss(ebounds, sigma=0.3)

energy_dispersion.plot_matrix()
plt.show()
Esempio n. 14
0
"""Plot energy dispersion example."""
import matplotlib.pyplot as plt
import astropy.units as u
import numpy as np
from gammapy.irf import EnergyDispersion

ebounds = np.logspace(-1, 2, 101) * u.TeV

edisp = EnergyDispersion.from_gauss(
    e_true=ebounds, e_reco=ebounds,
    bias=0, sigma=0.3,
)

edisp.peek()
plt.show()
Esempio n. 15
0
"""Plot energy dispersion example."""
import numpy as np
import matplotlib.pyplot as plt
from gammapy.irf import EnergyDispersion
from gammapy.spectrum import EnergyBounds

ebounds = EnergyBounds.equal_log_spacing(0.1, 100, 100, 'TeV')
energy_dispersion = EnergyDispersion.from_gauss(ebounds, sigma=0.3)

energy_dispersion.plot(type='matrix')
plt.show()