def xpmdp(**kwargs):
"""Calculate the MDP.
"""
logger.info('Loading the instrument response functions...')
aeff = load_arf(kwargs['irfname'])
modf = load_mrf(kwargs['irfname'])
module_name = os.path.basename(kwargs['configfile']).replace('.py', '')
ROI_MODEL = imp.load_source(module_name, kwargs['configfile']).ROI_MODEL
logger.info(ROI_MODEL)
# This is copied from xpobbsim and should probably be factored out.
# Actually, this should be a method of the ROI class. TBD
if kwargs['tstart'] < ROI_MODEL.min_validity_time():
kwargs['tstart'] = ROI_MODEL.min_validity_time()
logger.info('Simulation start time set to %s...' % kwargs['tstart'])
tstop = kwargs['tstart'] + kwargs['duration']
if tstop > ROI_MODEL.max_validity_time():
tstop = ROI_MODEL.max_validity_time()
logger.info('Simulation stop time set to %s...' % tstop)
kwargs['tstop'] = tstop
observation_time = kwargs['tstop'] - kwargs['tstart']
# This is copied from roi.py and should probably be factored out.
# Again, the ROI class should be able to sum the count spectra of all the
# component and expose the result.
sources = ROI_MODEL.values()
if len(sources) > 1:
abort('Multiple sources not implemented, yet.')
source = sources[0]
if isinstance(source, xPeriodicPointSource):
psamples = numpy.linspace(kwargs['phasemin'], kwargs['phasemax'], 100)
logger.info('Sampling phases: %s' % psamples)
count_spectrum = xCountSpectrum(source.energy_spectrum,
aeff,
psamples,
scale=observation_time)
time_integrated_spectrum = count_spectrum.build_time_integral()
else:
tsamples = source.sampling_time(kwargs['tstart'], kwargs['tstop'])
logger.info('Sampling times: %s' % tsamples)
count_spectrum = xCountSpectrum(source.energy_spectrum, aeff, tsamples)
time_integrated_spectrum = count_spectrum.build_time_integral()
# Thuis should be a callable method in the binning module.
ebinning = _make_binning(kwargs['ebinalg'], kwargs['emin'], kwargs['emax'],
kwargs['ebins'], kwargs['ebinning'])
# And this might be implemented in the irf.mrf module.
_x = time_integrated_spectrum.x
_y = time_integrated_spectrum.y * modf(_x)
mu_spectrum = xInterpolatedUnivariateSplineLinear(_x, _y)
for _emin, _emax in zip(ebinning[:-1], ebinning[1:]) +\
[(ebinning[0], ebinning[-1])]:
num_counts = count_spectrum.num_expected_counts(emin=_emin, emax=_emax)
mu_average = mu_spectrum.integral(_emin, _emax) / num_counts
mdp = 4.29 / mu_average / numpy.sqrt(num_counts)
logger.info('%.2f--%.2f keV: %d counts in %d s, mu %.3f, MDP %.2f%%' %\
(_emin, _emax, num_counts, observation_time, mu_average,
100*mdp))
def test_vignetting(self):
"""
"""
from ximpol import XIMPOL_CONFIG
file_path = os.path.join(XIMPOL_CONFIG, 'fits', 'casa_1p5_3p0_keV.fits')
aeff = load_arf(DEFAULT_IRF_NAME)
image = xFITSImage(file_path)
def setUpClass(cls):
"""Setup.
"""
cls.aeff = load_arf(DEFAULT_IRF_NAME)
cls.modf = load_mrf(DEFAULT_IRF_NAME)
cls.generator = xAzimuthalResponseGenerator()
cls.emin = 1.
cls.emax = 10.
def xpmdp(**kwargs):
"""Calculate the MDP.
"""
logger.info('Loading the instrument response functions...')
aeff = load_arf(kwargs['irfname'])
modf = load_mrf(kwargs['irfname'])
module_name = os.path.basename(kwargs['configfile']).replace('.py', '')
ROI_MODEL = imp.load_source(module_name, kwargs['configfile']).ROI_MODEL
logger.info(ROI_MODEL)
# This is copied from xpobbsim and should probably be factored out.
# Actually, this should be a method of the ROI class. TBD
if kwargs['tstart'] < ROI_MODEL.min_validity_time():
kwargs['tstart'] = ROI_MODEL.min_validity_time()
logger.info('Simulation start time set to %s...' % kwargs['tstart'])
tstop = kwargs['tstart'] + kwargs['duration']
if tstop > ROI_MODEL.max_validity_time():
tstop = ROI_MODEL.max_validity_time()
logger.info('Simulation stop time set to %s...' % tstop)
kwargs['tstop'] = tstop
observation_time = kwargs['tstop'] - kwargs['tstart']
# This is copied from roi.py and should probably be factored out.
# Again, the ROI class should be able to sum the count spectra of all the
# component and expose the result.
sources = ROI_MODEL.values()
if len(sources) > 1:
abort('Multiple sources not implemented, yet.')
source = sources[0]
if isinstance(source, xPeriodicPointSource):
psamples = numpy.linspace(kwargs['phasemin'], kwargs['phasemax'], 100)
logger.info('Sampling phases: %s' % psamples)
count_spectrum = xCountSpectrum(source.energy_spectrum, aeff, psamples,
scale=observation_time)
time_integrated_spectrum = count_spectrum.build_time_integral()
else:
tsamples = source.sampling_time(kwargs['tstart'], kwargs['tstop'])
logger.info('Sampling times: %s' % tsamples)
count_spectrum = xCountSpectrum(source.energy_spectrum, aeff, tsamples)
time_integrated_spectrum = count_spectrum.build_time_integral()
# Thuis should be a callable method in the binning module.
ebinning =_make_binning(kwargs['ebinalg'], kwargs['emin'], kwargs['emax'],
kwargs['ebins'], kwargs['ebinning'])
# And this might be implemented in the irf.mrf module.
_x = time_integrated_spectrum.x
_y = time_integrated_spectrum.y*modf(_x)
mu_spectrum = xInterpolatedUnivariateSplineLinear(_x, _y)
for _emin, _emax in zip(ebinning[:-1], ebinning[1:]) +\
[(ebinning[0], ebinning[-1])]:
num_counts = count_spectrum.num_expected_counts(emin=_emin, emax=_emax)
mu_average = mu_spectrum.integral(_emin, _emax)/num_counts
mdp = 4.29/mu_average/numpy.sqrt(num_counts)
logger.info('%.2f--%.2f keV: %d counts in %d s, mu %.3f, MDP %.2f%%' %\
(_emin, _emax, num_counts, observation_time, mu_average,
100*mdp))
def setUpClass(cls):
"""Setup.
"""
cls.irf_name = "xipe_baseline"
cls.aeff = load_arf(cls.irf_name)
cls.modf = load_mrf(cls.irf_name)
cls.emin = 2.0
cls.emax = 8.0
cls.ebinning = numpy.linspace(cls.emin, cls.emax, 4)
cls.ism_model = xpeInterstellarAbsorptionModel()
def xpmdp(**kwargs):
"""Calculate the MDP.
"""
logger.info('Loading the instrument response functions...')
aeff = load_arf(kwargs['irfname'])
modf = load_mrf(kwargs['irfname'])
module_name = os.path.basename(kwargs['configfile']).replace('.py', '')
ROI_MODEL = imp.load_source(module_name, kwargs['configfile']).ROI_MODEL
logger.info(ROI_MODEL)
# This is copied from xpobbsim and should probably be factored out.
# Actually, this should be a method of the ROI class. TBD
if kwargs['tstart'] < ROI_MODEL.min_validity_time():
kwargs['tstart'] = ROI_MODEL.min_validity_time()
logger.info('Simulation start time set to %s...' % kwargs['tstart'])
tstop = kwargs['tstart'] + kwargs['duration']
if tstop > ROI_MODEL.max_validity_time():
tstop = ROI_MODEL.max_validity_time()
logger.info('Simulation stop time set to %s...' % tstop)
kwargs['tstop'] = tstop
# This is copied from roi.py and should probably be factored out.
# Again, the ROI class should be able to sum the count spectra of all the
# component and expose the result.
sources = ROI_MODEL.values()
if len(sources) > 1:
abort('Multiple sources not implemented, yet.')
source = sources[0]
if isinstance(source, xPeriodicPointSource):
observation_time = kwargs['tstop'] - kwargs['tstart']
psamples = numpy.linspace(kwargs['phasemin'], kwargs['phasemax'], 100)
logger.info('Sampling phases: %s' % psamples)
count_spectrum = xCountSpectrum(source.energy_spectrum, aeff, psamples,
source.column_density, source.redshift,
scale_factor=observation_time)
else:
tsamples = source.sampling_time(kwargs['tstart'], kwargs['tstop'])
logger.info('Sampling times: %s' % tsamples)
count_spectrum = xCountSpectrum(source.energy_spectrum, aeff, tsamples,
source.column_density, source.redshift)
# Do the actual work.
ebinning =_make_energy_binning(**kwargs)
mdp_table = count_spectrum.build_mdp_table(ebinning, modf)
logger.info(mdp_table)
file_path = kwargs['outfile']
if file_path is not None:
logger.info('Writing output file path %s...' % file_path)
open(file_path, 'w').write('%s\n\n%s' % (kwargs, mdp_table))
logger.info('Done.')
return mdp_table
def test_xipe_arf(self):
"""Test the XIPE effective area.
This is loading the effective area from the .arf FITS file, then
loading the data points from the text files the response function
is created from, and finally testing that the actual values from the
two methods are close enough over the entire energy range.
"""
_x, _y = numpy.loadtxt(OPT_AEFF_FILE_PATH, unpack=True)
opt_aeff = xInterpolatedUnivariateSplineLinear(_x, _y)
_x, _y = numpy.loadtxt(GPD_QEFF_FILE_PATH, unpack=True)
gpd_eff = xInterpolatedUnivariateSplineLinear(_x, _y)
aeff = load_arf(IRF_NAME)
_x = numpy.linspace(aeff.xmin(), aeff.xmax(), 100)
# Remove the data points where the effective area is 0.
_x = _x[aeff(_x) > 0.]
_delta = abs((aeff(_x) - opt_aeff(_x)*gpd_eff(_x))/aeff(_x))
self.assertTrue(_delta.max() < 5e-3, 'max. diff. %.9f' % _delta.max())
if p_opt_min < 0.5:
p_opt_min = 0.5
if p_opt_max > 0.5:
src = {
"name": name,
"flux_min": flux_min,
"flux_max": flux_max,
"p_opt_max": p_opt_max,
"p_opt_min": p_opt_min,
}
src_list.append(src)
pl_norm_ref = int_eflux2pl_norm(FLUX_REF, E_MIN, E_MAX, PL_INDEX)
logger.info("PL normalization @ %.3e erg cm^-2 s^-1: %.3e keV^-1 cm^-2 s^-1" % (FLUX_REF, pl_norm_ref))
aeff = load_arf(DEFAULT_IRF_NAME)
modf = load_mrf(DEFAULT_IRF_NAME)
tsamples = numpy.array([0, OBS_TIME_REF])
ebinning = numpy.array([E_MIN, E_MAX])
energy_spectrum = power_law(pl_norm_ref, PL_INDEX)
count_spectrum = xCountSpectrum(energy_spectrum, aeff, tsamples)
mdp_table = count_spectrum.build_mdp_table(ebinning, modf)
mdp_ref = mdp_table.mdp_values()[-1]
logger.info("Reference MDP for %s s: %.3f" % (OBS_TIME_REF, mdp_ref))
blazar_list = parse_blazar_list(PRIORITY_ONLY)
mirror_list = [1, 3, 9, 17, 18]
numpy.random.seed(10)
_color = numpy.random.random((3, len(blazar_list)))
# numpy.random.seed(1)
