def npred(obs, analysis, pars):
"""
Determine Npred of source
Parameters
----------
obs : `~gammalib.GObservations()`
Observation container
analysis : str
Analyse name
pars : dict
Dictionary of analysis parameters
"""
# Set file names
inmodel = 'rx_results_%s.xml' % analysis
outmodel = 'rx_npred_%s.xml' % analysis
logfile = 'rx_npred_%s.log' % analysis
# Continue only if result file does not exist
if not os.path.isfile(outmodel) and os.path.isfile(inmodel):
# Set models
models = gammalib.GModels(inmodel)
model = models['RX J1713.7-3946']
for par in model:
par.fix()
model.tscalc(False) # Otherwise leads to an error
npred_models = gammalib.GModels()
npred_models.append(model)
# Attach models
obs.models(npred_models)
# If statistic is wstat then switch to cstat (since wstat does not
# correctly compute Npred)
for o in obs:
if o.statistic() == 'wstat':
o.statistic('cstat')
# Perform maximum likelihood fitting
like = ctools.ctlike(obs)
like['edisp'] = pars['edisp']
like['outmodel'] = outmodel
like['logfile'] = logfile
like['debug'] = True
like.logFileOpen()
like.execute()
# Return
return
def run(self):
"""
Run the script
"""
# Switch screen logging on in debug mode
if self._logDebug():
self._log.cout(True)
# Get parameters
self._get_parameters()
# Write header
if self._logTerse():
self._log('\n')
self._log.header1('Merge models')
# Initialise model container
self._models = gammalib.GModels()
# Loop over model files
for f in self._files:
# Construct container from XML file
models = gammalib.GModels(f)
# Log number of models to add
if self._logTerse():
nmodels = models.size()
if nmodels == 0:
self._log(gammalib.parformat('Add no model from file'))
elif nmodels == 1:
self._log(gammalib.parformat('Add 1 model from file'))
else:
self._log(
gammalib.parformat('Add %d models from file' %
nmodels))
self._log(f)
self._log('\n')
# Extend model container by adding all models in the model file
self._models.extend(models)
# Log total number of models
if self._logTerse():
self._log(gammalib.parformat('Models after merging'))
self._log(self._models.size())
self._log('\n')
# Return
return
def npred(obs, analysis, pars, fitname='pks_results', npredname='pks_npred'):
"""
Determine Npred of source
Parameters
----------
obs : `~gammalib.GObservations()`
Observation container
analysis : str
Analyse name
pars : dict
Dictionary of analysis parameters
fitname : str, optional
Fit result prefix
npredname : str, optional
Npred result prefix
"""
# Set file names
inmodel = '%s_%s.xml' % (fitname, analysis)
outmodel = '%s_%s.xml' % (npredname, analysis)
logfile = '%s_%s.log' % (npredname, analysis)
# Continue only if result file does not exist
if not os.path.isfile(outmodel) and os.path.isfile(inmodel):
# Set models
models = gammalib.GModels(inmodel)
model = models['PKS 2155-304']
for par in model:
par.fix()
model.tscalc(False) # Otherwise leads to an error
npred_models = gammalib.GModels()
npred_models.append(model)
# Attach models
obs.models(npred_models)
# Perform maximum likelihood fitting
like = ctools.ctlike(obs)
like['edisp'] = pars['edisp']
like['outmodel'] = outmodel
like['logfile'] = logfile
like['debug'] = True
like.logFileOpen()
like.execute()
# Return
return
def _gen_cubemodel(self):
"""
Generates a binned model from the model file using ctmapcube
"""
# Get a list of sources we DONT want to put into the cube
sources = self['soilist'].string().split(',')
# Load the model into a model container
if (self._models.size() == 0):
self._models = gammalib.GModels(self['inmodel'].filename())
# Store a copy of the models
self._cubemodels = self._models.copy()
# Loop through models and pull out all models not in the list
for model in self._models:
# If model is not a sky model then continue
if model.classname() != 'GModelSky':
self._cubemodels.remove(model.name())
# ... otherwise, if model is in list of sources the remove it
# from the container
elif model.name() in sources:
self._cubemodels.remove(model.name())
# Log the number of models to be put into the cube
self._log_value(self['chatter'].integer(), 'Numner of cube models',
self._cubemodels.size())
# Return
return
def simulate_ctobssim(obs, xmlname, seed=0):
"""
Simulate events using ctobssim.
"""
# Create containers
observations = gammalib.GObservations()
observations.append(obs)
# Append models
models = gammalib.GModels(xmlname)
observations.models(models)
print(models[0])
# Allocate ctobssim application and set parameters
sim = ctools.ctobssim(observations)
sim['seed'].integer(seed)
# Run simulator
sim.run()
# Retrieve events
events = sim.obs()[0].events().copy()
# Print event statistics
npred = obs.npred(models)
print(str(len(events)) + " events simulated.")
print(str(npred) + " events expected from Npred.")
# Delete the simulation
del sim
# Return events
return events
def simulate(obs, xmlname):
"""
Simulate events.
"""
# Allocate random number generator
ran = gammalib.GRan()
# Load models and extract first model
models = gammalib.GModels(xmlname)
model = models[0]
print(model)
# Simulate events
events = model.mc(obs, ran)
# Print event statistics
npred = obs.npred(models)
print(str(len(events)) + " events simulated.")
print(str(npred) + " events expected from Npred.")
# Check distance
pntdir = obs.pointing().dir()
for event in events:
distance = gammalib.GCTAInstDir(event.dir()).dir().dist_deg(pntdir)
if (distance > 5.0):
print("Too far: "+str(distance))
# Return events
return events
def _check_result_files(self, fitsfile, xmlfile, nmodels):
"""
Check ctfindvar result
Parameters
----------
fitsfile : str
FITS file name
xmlfile : str
Model definition XML file name
nmodels : int
Expected number of models
"""
# Read variability FITS file
if fitsfile is not 'NONE':
fits = gammalib.GFits(fitsfile)
self.test_value(fits.size(), 3, 'Check for 3 extensions in output file')
# Read model definition XML file
models = gammalib.GModels(xmlfile)
self.test_value(models.size(), nmodels,
'Check for %d models in model definition XML file' % nmodels)
# Return
return
def get_binpop_models(datadir, flux_thresh, outdir, bmax):
models = gammalib.GModels()
# get file names
files = []
# r=root, d=directories, f = files
for r, d, f in os.walk(datadir):
for file in f:
if '.txt' in file:
files.append(os.path.join(r, file))
# load models
for file in files:
model, lat = bin2gammalib(file, flux_thresh, outdir)
if model.size() > 0 and np.abs(lat) < bmax:
models.append(model)
else:
pass
# dictionary with parameters
lons, lats, radii, fluxes, names = dist_from_gammalib(models)
d = {
'name': np.array(names),
'GLON': np.array(lons),
'radius': np.array(radii),
'GLAT': np.array(lats),
'flux': np.array(fluxes)
}
return models, d
def __init__(self, *argv):
"""
Constructor.
"""
# Set name
self._name = "csmodelinfo"
self._version = "1.1.0"
# Initialise class members
self._models = gammalib.GModels()
self._ds9file = gammalib.GFilename("NONE")
self._pnt_type = ""
self._pnt_mark_size = 12
self._show_labels = True
self._width = 2
self._fontfamily = "helvetica"
self._fontsize = 12
self._fontweight = "normal"
self._fontslant = "roman"
self._show_ext_type = True
self._free_color = "green"
self._fixed_color = "magenta"
# Initialise application by calling the appropriate class
# constructor.
self._init_cscript(argv)
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation.
"""
# Get models
self._models = gammalib.GModels(self["inmodel"].filename())
# Get hidden parameters for region file
self._pnt_type = self["pnt_type"].string()
self._pnt_mark_size = self["pnt_mark_size"].integer()
self._show_labels = self["show_labels"].boolean()
self._width = self["width"].integer()
self._fontfamily = self["fontfamily"].string()
self._fontsize = self["fontsize"].integer()
self._fontweight = self["fontweight"].string()
self._fontslant = self["fontslant"].string()
self._show_ext_type = self["show_ext_type"].boolean()
self._free_color = self["free_color"].string()
self._fixed_color = self["fixed_color"].string()
# Read ahead DS9 filename
if self._read_ahead():
self._ds9file = self["ds9file"].filename()
# Write input parameters into logger
if self._logTerse():
self._log_parameters()
self._log("\n")
# Return
return
def _check_fit_result(self, filename):
"""
Check result file
"""
# Load fit results
models = gammalib.GModels(filename)
# Set reference values
prefactor = 3.63152145731529e-16
index = 2.39100016863397
pre_background = 1.30910556742873
index_background = 0.252909973473968
# Check fit result values
self.test_value(models['Crab'][2].value(), prefactor,
1.0e-4 * prefactor, 'Check Crab prefactor')
self.test_value(models['Crab'][3].value(), -index, 1.0e-4 * index,
'Check Crab index')
self.test_value(models['Background'][0].value(), pre_background,
1.0e-4 * pre_background,
'Check background model prefactor')
self.test_value(models['Background'][1].value(), -index_background,
1.0e-4 * index_background,
'Check background model index')
# Return
return
def show_model():
"""
Show model spectrum
"""
# Set usage string
usage = 'show_model.py [-n name] [-p plotfile] file'
# Set default options
options = [{'option': '-n', 'value': ''}, {'option': '-p', 'value': ''}]
# Get arguments and options from command line arguments
args, options = cscripts.ioutils.get_args_options(options, usage)
# Extract script parameters from options
name = options[0]['value']
plotfile = options[1]['value']
if len(name) == 0:
name = 0
# Read models XML file
models = gammalib.GModels(args[0])
# Extract relevant model
model = models[name]
# Plot spectrum
plot_spectrum(model, plotfile)
# Return
return
def main():
mev2erg = 1.6021765e-6 # MeV => erg
input_model = sys.argv[1]
models = gammalib.GModels(input_model)
print(models)
first_model = models[0]
m_spect = first_model.spectral()
print("TS:", first_model.ts())
emin = gammalib.GEnergy(25, 'GeV')
emax = gammalib.GEnergy(150, 'TeV')
r = m_spect.flux(emin, emax)
er = m_spect.eflux(emin, emax)
print('gl Flux: {:.4e} ph/cm²/s'.format(r))
print('fl EFlux: {:.4e} erg/cm²/s'.format(er))
for par in ['Prefactor', 'PivotEnergy', 'Index']:
print(par, m_spect[par].value(), m_spect[par].error())
# pref = m_spect['Prefactor'].value()
# print('pref', pref)
print('my flux: {0:.4e} ph/cm²/s'.format(
flux_eval_following_ctools([25 * 1e3, 150 * 1e6])))
my_eflux = eflux_eval_following_ctools(
[25 * 1e3, 150 * 1e6]) #, m_spect['Prefactor'].value())
print('my eflux: {0:.4e} MeV/cm²/s => {1:.4e} erg/cm²/s'.format(
my_eflux, my_eflux * mev2erg))
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Get models
self._models = gammalib.GModels(self['inmodel'].filename())
# Query hidden parameters for region file
self['pnt_type'].string()
self['pnt_mark_size'].integer()
self['show_labels'].boolean()
self['width'].integer()
self['fontfamily'].string()
self['fontsize'].integer()
self['fontweight'].string()
self['fontslant'].string()
self['show_ext_type'].boolean()
self['free_color'].string()
self['fixed_color'].string()
# Query ahead DS9 filename
if self._read_ahead():
self['outds9file'].query()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def _check_result_file(self, filename):
"""
Check result file
"""
# Open result file
result = gammalib.GModels(filename)
# Check results
self.test_value(result['Crab']['Prefactor'].value(), 1.58907e-16,
1.0e-3, 'Check fitted Crab Prefactor')
self.test_value(result['Crab']['Prefactor'].error(), 0.0529105e-16,
1.0e-3, 'Check Crab Prefactor error')
self.test_value(result['Crab']['Index'].value(), -2.43549, 1.0e-3,
'Check fitted Crab Index')
self.test_value(result['Crab']['Index'].error(), 0.027804, 1.0e-3,
'Check Crab Index error')
self.test_value(result['Background']['Prefactor'].value(), 61.6919e-6,
1.0e-3, 'Check fitted background Prefactor')
self.test_value(result['Background']['Prefactor'].error(), 1.49438e-6,
1.0e-3, 'Check background Prefactor error')
self.test_value(result['Background']['Index'].value(), -2.20535,
1.0e-3, 'Check fitted background Index')
self.test_value(result['Background']['Index'].error(), 0.0113269,
1.0e-3, 'Check background Index error')
self.test_value(result['Background']['Sigma'].value(), 3.04252, 1.0e-3,
'Check fitted background Sigma')
self.test_value(result['Background']['Sigma'].error(), 0.0307008,
1.0e-3, 'Check background Sigma error')
# Return
return
def _append_inmodels(self):
"""
Append input models
"""
# If there are models provided by "inmodels" then append them now to
# the model container
if self['inmodel'].is_valid():
# Get filename
filename = self['inmodel'].filename().url()
# Log header and input model file
self._log_header1(gammalib.TERSE, 'Append input models')
self._log_value(gammalib.NORMAL, 'Input model file', filename)
# Load input models
models = gammalib.GModels(filename)
# Loop over input models and append them to the model container
for model in models:
self._models.append(model)
self._log_value(gammalib.NORMAL, 'Append model',
'"' + model.name() + '"')
# Return
return
def ctlike_run(self,
input_obs_list,
input_models=None,
output_models='ml_result.xml',
log_file='ctlike.log',
force=False,
save=False):
like = ctools.ctlike()
if isinstance(input_obs_list, gammalib.GObservations):
like.obs(input_obs_list)
if input_models is not None:
like.obs().models(input_models)
elif os.path.isfile(input_obs_list) and os.path.isfile(input_models):
# observations list from file
like["inobs"] = input_obs_list
like["inmodel"] = input_models
else:
raise Exception('Cannot understand input obs list for ctlike')
like["outmodel"] = output_models
like["logfile"] = log_file
like["nthreads"] = self.nthreads
if force or not os.path.isfile(output_models):
like.logFileOpen()
like.run()
elif os.path.isfile(output_models):
ml_models = gammalib.GModels(output_models)
like.obs().models(ml_models)
else:
raise Exception("Cannot proceed with ctlike")
saved = False
if (save and force) or (save and not os.path.isfile(output_models)):
like.save()
saved = True
logger.info("File {} created.".format(output_models))
return like
def lightcurve(cpipe):
"""
Function running the lightcurve plots
Parameters
----------
- cpipe (ClusterPipe object): a cluster pipe object
associated to the analysis
Outputs
--------
- plots
"""
#========== Flux for each source
models = gammalib.GModels(cpipe.output_dir + '/Ana_Model_Output.xml')
for isource in range(len(models)):
if models[isource].type() not in [
'CTACubeBackground', 'CTAIrfBackground'
]:
srcname = models[isource].name()
specfile = cpipe.output_dir + '/Ana_Lightcurve_' + srcname + '.fits'
outfile = cpipe.output_dir + '/Ana_Lightcurve_' + srcname + '.pdf'
file_exist = os.path.isfile(specfile)
if file_exist:
plotting.show_lightcurve(specfile, outfile)
else:
if not cpipe.silent:
print(specfile + ' does not exist, no Lightcurve_' +
srcname + ' plot')
def _check_result_files(self, filename, nebounds=5, nmodels=2):
"""
Check result file
Parameters
----------
filename : str
Test file name without extension
nebounds : int, optional
Number of energy boundaries
"""
# Open background cube
cube = gammalib.GCTACubeBackground(filename + '.fits')
# Open model definition file
models = gammalib.GModels(filename + '.xml')
# Check cube
self._check_cube(cube, nebounds=nebounds)
# Check models
self._check_models(models, nmodels=nmodels)
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Query input parameters
self['inobs'].filename()
self['inmodel'].filename()
# Query hidden parameters
self['roilimit'].real()
self['roimargin'].real()
self['ethres'].real()
self['fluxlimit'].real()
self['tslimit'].real()
self['fit_pos'].boolean()
self['fit_shape'].boolean()
# Query ahead output model filename
if self._read_ahead():
self['outmodel'].filename()
# If there are no observations in container then get them from the
# parameter file
if self.obs().size() == 0:
self.obs(self._get_observations(False))
# Get models
self._models = gammalib.GModels(self['inmodel'].filename())
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def survey_single():
"""
Creates a single observation survey for test purposes.
"""
# Allocate observation container
obs = gammalib.GObservations()
# Set single pointing at galactic centre
pntdir = gammalib.GSkyDir()
pntdir.lb_deg(0.0, 0.0)
run = obsutils.set_obs(pntdir)
obs.append(run)
# Define single point source with Crab flux at galactic centre
center = gammalib.GSkyDir()
center.lb_deg(0.0, 0.0)
point_spatial = gammalib.GModelSpatialPointSource(center)
point_spectrum = crab_spec()
point = gammalib.GModelSky(point_spatial, point_spectrum)
point.name('GC source')
# Create model container
models = gammalib.GModels()
models.append(point)
obs.models(models)
# Return observation container
return obs
def show_events(events, xmlname, duration, emin, emax, ebins=30):
"""
Show events using matplotlib.
"""
# Create figure
plt.figure(1)
plt.title("MC simulated event spectrum (" + str(emin) + '-' + str(emax) + " TeV)")
# Setup energy range covered by data
ebds = gammalib.GEbounds(ebins, gammalib.GEnergy(emin, "TeV"),
gammalib.GEnergy(emax, "TeV"))
# Create energy axis
energy = []
for i in range(ebds.size()):
energy.append(ebds.elogmean(i).TeV())
# Fill histogram
counts = [0.0 for i in range(ebds.size())]
for event in events:
index = ebds.index(event.energy())
counts[index] = counts[index] + 1.0
# Create error bars
error = [math.sqrt(c) for c in counts]
# Get model values
sum = 0.0
models = gammalib.GModels(xmlname)
m = models[0]
model = []
t = gammalib.GTime()
for i in range(ebds.size()):
eval = ebds.elogmean(i)
ewidth = ebds.emax(i) - ebds.emin(i)
f = m.npred(eval, t, obs) * ewidth.MeV() * duration
sum += f
model.append(f)
print(str(sum) + " events expected from spectrum (integration).")
# Plot data
plt.loglog(energy, counts, 'ro')
plt.errorbar(energy, counts, error, fmt=None, ecolor='r')
# Plot model
plt.plot(energy, model, 'b-')
# Set axes
plt.xlabel("Energy (TeV)")
plt.ylabel("Number of events")
# Notify
print("PLEASE CLOSE WINDOW TO CONTINUE ...")
# Show plot
plt.show()
# Return
return
def __init__(self, *argv):
"""
Constructor.
"""
# Set name and version
self._name = 'csiactobs'
self._version = '1.1.0'
# Initialise some members
self._ebounds = gammalib.GEbounds()
self._datapath = os.getenv('VHEFITS', '')
self._inmodels = gammalib.GModels()
self._prodname = ''
self._xml = gammalib.GXml()
self._models = gammalib.GModels()
self._runlist = []
self._runlistfile = gammalib.GFilename()
self._bkgpars = 0
self._outmodel = gammalib.GFilename()
self._outobs = gammalib.GFilename()
self._master_indx = ''
self._use_bkg_scale = False
self._ev_hiera = ['']
self._aeff_hiera = ['']
self._psf_hiera = ['']
self._bkg_hiera = ['']
self._edisp_hiera = ['']
self._bkg_mod_hiera = ['']
self._bkg_gauss_norm = 1.0
self._bkg_gauss_index = 0.0
self._bkg_gauss_sigma = 1.0
self._bkg_aeff_index = 0.0
self._bkg_aeff_norm = 1.0
self._bkg_range_factor = 1.0
self._hdu_index = ''
self._obs_index = ''
self._subdir = ''
self._debug = False
# Initialise application by calling the appropriate class
# constructor.
self._init_cscript(argv)
# Return
return
def spectrum(cpipe):
"""
Function running the spectrum plots
Parameters
----------
- cpipe (ClusterPipe object): a cluster pipe object
associated to the analysis
Outputs
--------
- plots
"""
#========== Flux for each source
models = gammalib.GModels(cpipe.output_dir + '/Ana_Model_Output.xml')
for isource in range(len(models)):
if models[isource].type() != 'CTACubeBackground':
srcname = models[isource].name()
specfile = cpipe.output_dir + '/Ana_Spectrum_' + srcname + '.fits'
outfile = cpipe.output_dir + '/Ana_Spectrum_' + srcname + '.pdf'
butfile = cpipe.output_dir + '/Ana_Spectrum_Buterfly_' + srcname + '.txt'
butexist = os.path.isfile(butfile)
if butexist:
butfile_spec = butfile
else:
butfile_spec = None
if srcname == cpipe.cluster.name:
expfile = cpipe.output_dir + '/Sim_Model_Spectrum.txt'
else:
expfile = None
file_exist = os.path.isfile(specfile)
if file_exist:
plotting.show_spectrum(specfile,
outfile,
butfile=butfile_spec,
expected_file=expfile)
else:
if not cpipe.silent:
print(specfile + ' does not exist, no Spectrum_' +
srcname + ' plot')
#========== Residual counts in ROI
file_exist = os.path.isfile(cpipe.output_dir +
'/Ana_Spectrum_Residual.fits')
if file_exist:
plotting.show_spectrum_residual(
cpipe.output_dir + '/Ana_Spectrum_Residual.fits',
cpipe.output_dir + '/Ana_Spectrum_Residual.pdf')
else:
if not cpipe.silent:
print(
cpipe.output_dir +
'/Ana_Spectrum_Residual.fits does not exist, no Spectrum_Residual plot'
)
def inspect_likelihood_model(model):
ml = gl.GModels(model)
# print(ml)
ts = ml[0].ts()
sign = math.sqrt(ts)
print('''likelihood:
TS: {}
√TS: {}'''.format(ts, sign))
return sign
def _set_replace_src_spectrum_by_nodes(self):
"""
Replace source spectrum by node function
"""
# Initialise model container
models = gammalib.GModels()
# Loop over model containers
for model in self.obs().models():
# If we deal with source model then replace the spectral model
# by a node function
if model.name() == self['srcname'].string():
# Setup energies at log mean energies of bins
energies = gammalib.GEnergies()
for i in range(self._ebounds.size()):
energies.append(self._ebounds.elogmean(i))
# Setup spectral node function
spectrum = gammalib.GModelSpectralNodes(
model.spectral(), energies)
spectrum.autoscale()
# Make sure that all nodes are positive. Autoscale all
# parameters so that their nominal value is unity.
for i in range(spectrum.nodes()):
par = spectrum[i * 2 + 1]
par.autoscale()
value = par.value()
minimum = 1.0e-20 * value
if minimum <= 0.0:
minimum = 1.0e-20
if minimum < value:
value = minimum
par.value(value)
par.min(minimum)
# Set spectral component of source model
model.spectral(spectrum)
# Make sure that TS computation is disabled (makes computation
# faster)
model.tscalc(False)
# Append model
models.append(model)
# ... otherwise just append model
else:
models.append(model)
# Put new model in observation containers
self.obs().models(models)
# Return
return
def _make_model(self, prefix='Model', includeIC=True, obsID=None):
"""
This function is used to construct the model.
Parameters
----------
- prefix (str): text to add as a prefix of the file names
- includeIC (bool): include inverse Compton in the model
"""
#----- Make cluster template files
if (not self.silent) and (self.cluster.map_reso > 0.01 * u.deg):
print(
'WARNING: the FITS map resolution (self.cluster.map_reso) is larger'
)
print(
' than 0.01 deg, while the PSF at 100 TeV is ~0.02 deg. '
)
print('')
make_cluster_template.make_map(self.cluster,
self.output_dir + '/' + prefix +
'_Map.fits',
Egmin=self.obs_setup.get_emin(),
Egmax=self.obs_setup.get_emax(),
includeIC=includeIC)
make_cluster_template.make_spectrum(
self.cluster,
self.output_dir + '/' + prefix + '_Spectrum.txt',
energy=np.logspace(-1, 5, 1000) * u.GeV,
includeIC=includeIC)
#----- Create the model
model_tot = gammalib.GModels()
if self.cluster.X_cr_E[
'X'] > 0: # No need to include the cluster if it is 0
build_ctools_model.cluster(
model_tot,
self.output_dir + '/' + prefix + '_Map.fits',
self.output_dir + '/' + prefix + '_Spectrum.txt',
ClusterName=self.cluster.name,
tscalc=True)
build_ctools_model.compact_sources(model_tot,
self.compact_source,
tscalc=True)
if obsID is None:
background = self.obs_setup.bkg
else:
background = self.obs_setup.select_obs(obsID).bkg
build_ctools_model.background(model_tot, background)
model_tot.save(self.output_dir + '/' + prefix + '_Unstack.xml')
def generate_resmap(emin=0.3, emax=50.0, ebins=40, edisp=True):
"""
Generate residual map
Parameters
----------
emin : float, optional
Minimum energy (TeV)
emax : float, optional
Maximum energy (TeV)
ebins : int, optional
Number of energy bins
edisp : bool, optional
Enable energy dispersion?
"""
# Set filenames
inobs = 'obs_rx_selected.xml'
inmodel = 'rx_results_map0.48_eplaw_lookup_grad_hess_edisp.xml'
outmodel = 'rx_background_map0.48_eplaw_lookup_grad_hess_edisp.xml'
outmap = 'rx_resmap.fits'
logfile = 'rx_resmap.log'
# Continue only if inmodel exists
if os.path.isfile(inobs) and os.path.isfile(inmodel):
# Create model definition XML file without source
models = gammalib.GModels(inmodel)
models.remove('RX J1713.7-3946')
models.save(outmodel)
# Setup task parameters
resmap = cscripts.csresmap()
resmap['inobs'] = inobs
resmap['inmodel'] = outmodel
resmap['edisp'] = edisp
resmap['algorithm'] = 'SUB'
resmap['ebinalg'] = 'LOG'
resmap['emin'] = emin
resmap['emax'] = emax
resmap['enumbins'] = ebins
resmap['coordsys'] = 'CEL'
resmap['proj'] = 'CAR'
resmap['xref'] = 258.1125
resmap['yref'] = -39.6867
resmap['nxpix'] = 300
resmap['nypix'] = 300
resmap['binsz'] = 0.02
resmap['outmap'] = outmap
resmap['logfile'] = logfile
resmap.logFileOpen()
# Generate residual map
resmap.execute()
# Return
return
def make_xml(nametag):
spatial = gammalib.GModelSpatialDiffuseCube(
gammalib.GFilename(nametag + '_map.fits'))
spectral = gammalib.GModelSpectralConst(1.)
model = gammalib.GModelSky(spatial, spectral)
model.name(nametag)
# fill to model container and write to disk
models = gammalib.GModels()
models.append(model)
models.save(nametag + '.xml')
def get_obs_results(obsname, resname):
"""
Get observation results
Parameters
----------
obsname : str
Observation definition XML file
resname : str
Model result XML file
"""
# Initialise results
results = []
# Load observations and models
inobs = gammalib.GObservations(obsname)
models = gammalib.GModels(resname)
# Loop over runs in observations
for run in inobs:
# Build observation container with single run
obs = gammalib.GObservations()
obs.append(run)
# Get background model
has_model = False
for model in models:
if model.classname() == 'GCTAModelBackground' and model.is_valid('HESS', run.id()):
has_model = True
break
# Fall through if we have no model
if not has_model:
continue
# Set results
result = {'id': run.id(),
'ontime': run.ontime(), 'livetime': run.livetime(),
'deadc': run.deadc(),
'ra': run.pointing().dir().ra_deg(),
'dec': run.pointing().dir().dec_deg(),
'zenith': run.pointing().zenith(),
'azimuth': run.pointing().azimuth(),
'detx': model.spatial()[1].value(),
'e_detx': model.spatial()[1].error(),
'dety': model.spatial()[2].value(),
'e_dety': model.spatial()[2].error()}
# Append results
results.append(result)
# Return
return results
