def _get_parameters(self):
"""
Get parameters from parfile
"""
# If there are no observations in container then get some ...
if self.obs().is_empty():
self.obs(self._get_observations())
# ... otherwise add response information and energy boundaries
# in case they are missing
else:
self._setup_observations(self.obs())
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Get number of energy bins
enumbins = self['enumbins'].integer()
# Query parameters for On/Off observation
if gammalib.toupper(self['onsrc'].string()) != 'NONE':
self['onrad'].real()
# Query parameters for binned if requested
elif enumbins > 0:
self['npix'].integer()
self['binsz'].real()
self['coordsys'].string()
self['proj'].string()
# Set models if we have none
if self.obs().models().is_empty():
self.obs().models(self['inmodel'].filename())
# Query other parameters
self['ntrials'].integer()
self['edisp'].boolean()
self['seed'].integer()
self['chatter'].integer()
# Query some parameters
self['outfile'].filename()
self['profile'].boolean()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Query datapath. If the parameter is not NONE then use it, otherwise
# use the datapath from the VHEFITS environment variable
datapath = self['datapath'].string()
if gammalib.toupper(datapath) != 'NONE':
self._datapath = datapath
else:
self._datapath = os.getenv('VHEFITS', '')
# Expand environment
self._datapath = gammalib.expand_env(self._datapath)
# Get filename of master index file
self._master_indx = self['master_indx'].string()
self._master_file = os.path.join(self._datapath, self._master_indx)
# Check for presence of master index file
if not os.path.isfile(self._master_file):
raise RuntimeError('Master index file "' + self._master_file +
'" not found. Use hidden parameter ' +
'"master_indx" to specifiy a different ' +
'filename.')
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Set observation if not done before
if self.obs().size() == 0:
self.obs(self._get_observations())
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Get source name
self._srcname = self['srcname'].string()
# Set models if we have none
if self.obs().models().size() == 0:
self.obs().models(self['inmodel'].filename())
# Query parameters
self['edisp'].boolean()
self['ntrials'].integer()
self['debug'].boolean()
self['outfile'].filename()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Set number of processes for multiprocessing
self._nthreads = mputils.nthreads(self)
# Return
return
def check_set_obs_statistic_onoff(self, statistic):
obs = gammalib.GObservations()
cta = gammalib.GCTAOnOffObservation()
obs.append(cta)
self.obs(obs)
self._set_obs_statistic(statistic)
return gammalib.toupper(self.obs()[0].statistic())
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Set observation if not done before
if self.obs().size() == 0:
self.obs(self._get_observations())
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Get source name
self._srcname = self['srcname'].string()
# Set models if we have none
if self.obs().models().size() == 0:
self.obs().models(self['inmodel'].filename())
# Query parameters
self['edisp'].boolean()
self['ntrials'].integer()
self['debug'].boolean()
# Read ahead output parameters
#if self._read_ahead():
# self['outfile'].filename()
self['outfile'].filename()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def check_set_obs_statistic_binned(self, statistic):
obs = gammalib.GObservations()
cube = gammalib.GCTAEventCube()
cta = gammalib.GCTAObservation()
cta.events(cube)
obs.append(cta)
self.obs(obs)
self._set_obs_statistic(statistic)
return gammalib.toupper(self.obs()[0].statistic())
def _get_parameters(self):
"""
Get user parameters from parfile
"""
# Set observation if not done before
if self.obs().size() == 0:
self.obs(self._set_obs(self['emin'].real(), self['emax'].real()))
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Set models if we have none
if self.obs().models().size() == 0:
self.obs().models(self['inmodel'].filename())
# Get source name
self._srcname = self['srcname'].string()
# Read further parameters
emin = self['emin'].real()
emax = self['emax'].real()
bins = self['bins'].integer()
# Query parameters for binned if requested
enumbins = self['enumbins'].integer()
if not enumbins == 0:
self['npix'].integer()
self['binsz'].real()
# Query input parameters
self['sigma'].real()
self['max_iter'].integer()
self['type'].string()
self['outfile'].filename()
self['edisp'].boolean()
self['debug'].boolean()
# Derive some parameters
self._ebounds = gammalib.GEbounds(bins, gammalib.GEnergy(emin, 'TeV'),
gammalib.GEnergy(emax, 'TeV'))
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Set number of processes for multiprocessing
self._nthreads = mputils.nthreads(self)
# Return
return
def _get_parameters(self):
"""
Get user parameters from parfile
"""
# Set observation if not done before
if self.obs().size() == 0:
self.obs(self._set_obs(self['emin'].real(), self['emax'].real()))
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Set models if we have none
if self.obs().models().size() == 0:
self.obs().models(self['inmodel'].filename())
# Get source name
self._srcname = self['srcname'].string()
# Read further parameters
emin = self['emin'].real()
emax = self['emax'].real()
bins = self['bins'].integer()
# Query parameters for binned if requested
enumbins = self['enumbins'].integer()
if not enumbins == 0:
self['npix'].integer()
self['binsz'].real()
# Query input parameters
self['sigma'].real()
self['max_iter'].integer()
self['type'].string()
self['outfile'].filename()
self['edisp'].boolean()
self['debug'].boolean()
# Derive some parameters
self._ebounds = gammalib.GEbounds(bins,
gammalib.GEnergy(emin, 'TeV'),
gammalib.GEnergy(emax, 'TeV'))
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile
"""
# Setup observations (require response and allow event list, don't
# allow counts cube)
self._setup_observations(self.obs(), True, True, False)
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Set models if there are none in the container
if self.obs().models().size() == 0:
self.obs().models(self['inmodel'].filename())
# Get phase boundaries
self._phbins = self._create_tbounds()
# Set On/Off analysis flag and query relevant user parameters
self._onoff = self._is_onoff()
# Get source name
self._srcname = self['srcname'].string()
# If cube analysis is selected
# Set stacked analysis flag and query relevant user parameters
if not self._onoff:
self._stacked = self._is_stacked()
# Query the hidden parameters, just in case
self['edisp'].boolean()
# Read ahead output parameters
if self._read_ahead():
self['outfile'].filename()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Set number of processes for multiprocessing
self._nthreads = mputils.nthreads(self)
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile
"""
# Setup observations (require response and allow event list, don't
# allow counts cube)
self._setup_observations(self.obs(), True, True, False)
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Set models if there are none in the container
if self.obs().models().size() == 0:
self.obs().models(self['inmodel'].filename())
# Get source name
self._srcname = self['srcname'].string()
# Get time boundaries
self._tbins = self._create_tbounds()
# Set On/Off analysis flag and query relevant user parameters
self._onoff = self._is_onoff()
# Set stacked analysis flag and query relevant user parameters
if not self._onoff:
self._stacked = self._is_stacked()
# Query the hidden parameters, just in case
self['edisp'].boolean()
self['calc_ulim'].boolean()
self['calc_ts'].boolean()
self['fix_bkg'].boolean()
self['fix_srcs'].boolean()
# Read ahead output parameters
if self._read_ahead():
self['outfile'].filename()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Set observation if not done before
if self.obs().is_empty():
self._require_inobs('csspec::get_parameters()')
self.obs(self._get_observations())
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Set models if we have none
if self.obs().models().is_empty():
self.obs().models(self['inmodel'].filename())
# Query source name
self['srcname'].string()
# Get spectrum generation method
self._method = self['method'].string()
# Collect number of unbinned, binned and On/Off observations in
# observation container
n_unbinned = 0
n_binned = 0
n_onoff = 0
for obs in self.obs():
if obs.classname() == 'GCTAObservation':
if obs.eventtype() == 'CountsCube':
n_binned += 1
else:
n_unbinned += 1
elif obs.classname() == 'GCTAOnOffObservation':
n_onoff += 1
n_cta = n_unbinned + n_binned + n_onoff
n_other = self.obs().size() - n_cta
# If spectrum method is not "NODES" then set spectrum method and
# script mode according to type of observations
if self._method != 'NODES':
if n_other > 0:
self._method = 'NODES'
else:
if n_unbinned == 0 and n_binned != 0 and n_onoff == 0:
self._binned_mode = True
self._method = 'SLICE'
elif n_unbinned == 0 and n_binned == 0 and n_onoff != 0:
self._onoff_mode = True
self._method = 'SLICE'
elif n_unbinned == 0 and n_binned != 0 and n_onoff != 0:
msg = 'Mix of binned and On/Off CTA observations found ' \
'in observation container. csscript does not support ' \
'this mix.'
raise RuntimeError(msg)
elif n_unbinned != 0 and (n_binned != 0 or n_onoff != 0):
msg = 'Mix of unbinned and binned or On/Off CTA observations ' \
'found in observation container. csscript does not ' \
'support this mix.'
raise RuntimeError(msg)
elif n_unbinned != 0:
self._method = 'SLICE'
# Set ebounds
self._set_ebounds()
# Query other parameeters
self['edisp'].boolean()
self['calc_ulim'].boolean()
self['calc_ts'].boolean()
self['fix_bkg'].boolean()
self['fix_srcs'].boolean()
# Read ahead output parameters
if self._read_ahead():
self['outfile'].filename()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Set number of processes for multiprocessing
self._nthreads = mputils.nthreads(self)
# Write spectrum method header and parameters
self._log_header1(gammalib.TERSE, 'Spectrum method')
self._log_value(gammalib.TERSE, 'Unbinned CTA observations',
n_unbinned)
self._log_value(gammalib.TERSE, 'Binned CTA observations', n_binned)
self._log_value(gammalib.TERSE, 'On/off CTA observations', n_onoff)
self._log_value(gammalib.TERSE, 'Other observations', n_other)
# If there are a mix of CTA and non-CTA observations and the method
# is 'SLICE' then log a warning that non-CTA observations will be
# ignored
warning = False
if n_cta > 0 and n_other > 0 and self._method == 'SLICE':
warning = True
# If there are only non-CTA observations and the method is 'SLICE'
# then stop now
elif n_other > 0:
if self._method == 'SLICE':
msg = 'Selected "SLICE" method but none of the observations ' \
'is a CTA observation. Please select "AUTO" or "NODES" ' \
'if no CTA observation is provided.'
raise RuntimeError(msg)
else:
self._method = 'NODES'
# Log selected spectrum method
self._log_value(gammalib.TERSE, 'Selected spectrum method',
self._method)
# Signal warning
if warning:
self._log_string(
gammalib.TERSE, ' WARNING: Only CTA observation '
'can be handled with the "SLICE" method, all '
'non-CTA observation will be ignored.')
# Return
return
def plot_irf(irf, emin, emax, tmin, tmax, plotfile):
"""
Plot Instrument Response Function
Parameters
----------
irf : `~gammalib.GCTAResponseIrf`
Instrument Response Function
emin : float
Minimum energy (TeV)
emax : float
Maximum energy (TeV)
tmin : float
Minimum offset angle (deg)
tmax : float
Maximum offset angle (deg)
plotfile : str
Plot filename
"""
# Build selection string
selection = ''
eselection = ''
tselection = ''
if emin != None and emax != None:
eselection += '%.3f-%.1f TeV' % (emin, emax)
elif emin != None:
eselection += ' >%.3f TeV' % (emin)
elif emax != None:
eselection += ' <%.1f TeV' % (emax)
if tmin != None and tmax != None:
tselection += '%.1f-%.1f deg' % (tmin, tmax)
elif tmin != None:
tselection += ' >%.1f deg' % (tmin)
elif tmax != None:
tselection += ' <%.1f deg' % (tmax)
if len(eselection) > 0 and len(tselection) > 0:
selection = ' (%s, %s)' % (eselection, tselection)
elif len(eselection) > 0:
selection = ' (%s)' % (eselection)
elif len(tselection) > 0:
selection = ' (%s)' % (tselection)
# Build title
mission = irf.caldb().mission()
instrument = irf.caldb().instrument()
response = irf.rspname()
title = '%s "%s" Instrument Response Function "%s"%s' % \
(gammalib.toupper(mission), instrument, response, selection)
# Create figure
fig = plt.figure(figsize=(16,8))
# Add title
fig.suptitle(title, fontsize=16)
# Plot Aeff
ax1 = fig.add_subplot(231)
plot_aeff(ax1, irf.aeff(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Plot Psf
ax2 = fig.add_subplot(232)
plot_psf(ax2, irf.psf(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Plot Background
ax3 = fig.add_subplot(233)
plot_bkg(ax3, irf.background(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Plot Edisp
fig.add_subplot(234)
plot_edisp(irf.edisp(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Show plots or save it into file
if len(plotfile) > 0:
plt.savefig(plotfile)
else:
plt.show()
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Query datapath. If the parameter is not NONE then use it, otherwise
# use the datapath from the VHEFITS environment variable
datapath = self['datapath'].string()
if gammalib.toupper(datapath) != 'NONE':
self._datapath = datapath
else:
self._datapath = os.getenv('VHEFITS', '')
# Expand environment
self._datapath = gammalib.expand_env(self._datapath)
# Query input parameters
self['inmodel'].query()
# Read FITS production
self._prodname = self['prodname'].string()
# Read runlist file if list not already filled
if len(self._runlist) == 0:
# Get file name
self._runlistfile = self['infile'].filename()
# Read runlist from file
runfile = open(self._runlistfile.url())
for line in runfile.readlines():
if len(line) == 0:
continue
if line[0] == '#':
continue
if len(line.split()) > 0:
self._runlist.append(line.split()[0])
runfile.close()
# Read number of background parameters
self._bkgpars = self['bkgpars'].integer()
# Query ahead output parameters
if self._read_ahead():
self['outmodel'].filename()
self['outobs'].filename()
# Master index file name
self._master_indx = self['master_indx'].string()
# Read flag for background scaling factor
self._use_bkg_scale = self['bkg_scale'].boolean()
# Read hierarchy of file loading
self._ev_hiera = self['ev_hiera'].string().split('|')
self._aeff_hiera = self['aeff_hiera'].string().split('|')
self._psf_hiera = self['psf_hiera'].string().split('|')
self._bkg_hiera = self['bkg_hiera'].string().split('|')
self._edisp_hiera = self['edisp_hiera'].string().split('|')
self._bkg_mod_hiera = self['bkg_mod_hiera'].string().split('|')
# Read hidden background parameters
self._bkg_gauss_norm = self['bkg_gauss_norm'].real()
self._bkg_gauss_index = self['bkg_gauss_index'].real()
self._bkg_gauss_sigma = self['bkg_gauss_sigma'].real()
self._bkg_aeff_index = self['bkg_aeff_index'].real()
self._bkg_aeff_norm = self['bkg_aeff_norm'].real()
self._bkg_range_factor = self['bkg_range_factor'].real()
# Open master index file and look for prodname
master_file = os.path.join(self._datapath, self._master_indx)
if not os.path.isfile(master_file):
raise RuntimeError('FITS data store not available. No master '
'index file found. Make sure the file is '
'copied from the server and your datapath '
'is set correctly.')
# Open and load JSON file
json_data = open(master_file).read()
data = json.loads(json_data)
if not 'datasets' in data:
raise RuntimeError('Key "datasets" not available in master '
'index file.')
# Get configurations
configs = data['datasets']
# Initialise HDUs
self._hdu_index = self._obs_index = ''
# Get HDUs
for config in configs:
# Check if prodname is present
if self._prodname == config['name']:
self._hdu_index = str(
os.path.join(self._datapath, config['hduindx']))
self._obs_index = str(
os.path.join(self._datapath, config['obsindx']))
# Leave loop if index file names were found
break
# Check index files
if self._hdu_index == '' or self._obs_index == '':
raise RuntimeError('*** ERROR: FITS data store "' +
self._prodname +
'" not available. Run csiactdata to get a list '
'of available storage names')
# Check HDU names
filename = gammalib.GFilename(self._hdu_index + '[HDU_INDEX]')
if not filename.is_fits():
raise RuntimeError('*** ERROR: HDU index file "' +
self._hdu_index +
'[HDU_INDEX]" for FITS data store "' +
self._prodname + '" not available. Check your '
'master index file or run csiactdata to get '
'a list of available storage names.')
# Check for existence of 'BKG_SCALE' in the observation index file if
# required
if self._use_bkg_scale:
# Create filename
filename = gammalib.GFilename(self._obs_index + '[OBS_INDEX]')
# Check if it is a FITS file
if filename.is_fits():
# Open FITS file
fits = gammalib.GFits(self._obs_index)
# Check if column "BKG_SCALE" is found and signal its possible
# usage
if not fits['OBS_INDEX'].contains('BKG_SCALE'):
self._use_bkg_scale = False
# Close FITS file
fits.close()
else:
# Signal that there is no background scale
self._use_bkg_scale = False
# Create base data directory from hdu index file location
self._subdir = os.path.dirname(self._hdu_index)
self._debug = False # Debugging in client tools
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def _get_parameters(self):
"""
Get parameters and setup the observation
"""
# Set observation if not done before
if self.obs().is_empty():
self._require_inobs('csdmatter::get_parameters')
self.obs(self._get_observations())
# Set Obs statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Set Models
if self.obs().models().is_empty():
self.obs().models(self['inmodel'].filename())
# Query source name
self['srcname'].string()
# Collect number of unbinned, binned and OnOff obs
# in observation container
n_unbinned = 0
n_binned = 0
n_onoff = 0
for obs in self.obs():
if obs.classname() == 'GCTAObservation':
if obs.eventtype() == 'CountsCube':
n_binned += 1
else:
n_unbinned += 1
elif obs.classname() == 'GCTAOnOffObservation':
n_onoff += 1
n_cta = n_unbinned + n_binned + n_onoff
n_other = self.obs().size() - n_cta
# Set energy bounds
self._set_ebounds()
# Query other parameters
self['edisp'].boolean()
self['calc_ulim'].boolean()
self['calc_ts'].boolean()
self['fix_bkg'].boolean()
self['fix_srcs'].boolean()
# self[ 'dmass' ].real()
# self[ 'sigmav' ].real()
# Read ahead output parameters
if self._read_ahead():
self['outfile'].filename()
# Write into logger
self._log_parameters(gammalib.TERSE)
# Set number of processes for multiprocessing
self._nthreads = mputils.nthreads(self)
self._log_header1(gammalib.TERSE, 'DM analysis')
self._log_value(gammalib.TERSE, 'Unbinned observations', n_unbinned)
self._log_value(gammalib.TERSE, 'Binned observations', n_binned)
self._log_value(gammalib.TERSE, 'OnOff Observations', n_onoff)
self._log_value(gammalib.TERSE, 'NonCTA Observations', n_other)
if n_other == 0:
if n_unbinned == 0 and n_binned != 0 and n_onoff == 0:
self._binned_mode = True
elif n_unbinned == 0 and n_binned == 0 and n_onoff != 0:
self._onoff_mode = True
elif n_unbinned == 0 and n_binned != 0 and n_onoff != 0:
msg = 'Mixing of binned and OnOff Observations'
raise RuntimeError(msg)
elif n_unbinned != 0 and (n_binned != 0 or n_onoff != 0):
msg = 'Mixing of different CTA Observations'
raise RuntimeError(msg)
else:
msg = 'csdmatter only supports CTA-observations'
raise RuntimeError(msg)
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Set observation if not done before
if self.obs().is_empty():
self._require_inobs('csspec::get_parameters()')
self.obs(self._get_observations())
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Set models if we have none
if self.obs().models().is_empty():
self.obs().models(self['inmodel'].filename())
# Query source name
self['srcname'].string()
# Get spectrum generation method
self._method = self['method'].string()
# Collect number of unbinned, binned and On/Off observations in
# observation container
n_unbinned = 0
n_binned = 0
n_onoff = 0
for obs in self.obs():
if obs.classname() == 'GCTAObservation':
if obs.eventtype() == 'CountsCube':
n_binned += 1
else:
n_unbinned += 1
elif obs.classname() == 'GCTAOnOffObservation':
n_onoff += 1
n_cta = n_unbinned + n_binned + n_onoff
n_other = self.obs().size() - n_cta
# If spectrum method is not "NODES" then set spectrum method and
# script mode according to type of observations
if self._method != 'NODES':
if n_other > 0:
self._method = 'NODES'
else:
if n_unbinned == 0 and n_binned != 0 and n_onoff == 0:
self._binned_mode = True
self._method = 'SLICE'
elif n_unbinned == 0 and n_binned == 0 and n_onoff != 0:
self._onoff_mode = True
self._method = 'SLICE'
elif n_unbinned == 0 and n_binned != 0 and n_onoff != 0:
msg = 'Mix of binned and On/Off CTA observations found ' \
'in observation container. csscript does not support ' \
'this mix.'
raise RuntimeError(msg)
elif n_unbinned != 0 and (n_binned != 0 or n_onoff != 0):
msg = 'Mix of unbinned and binned or On/Off CTA observations ' \
'found in observation container. csscript does not ' \
'support this mix.'
raise RuntimeError(msg)
elif n_unbinned != 0:
self._method = 'SLICE'
# Set ebounds
self._set_ebounds()
# Query other parameeters
self['edisp'].boolean()
self['calc_ulim'].boolean()
self['calc_ts'].boolean()
self['fix_bkg'].boolean()
self['fix_srcs'].boolean()
# Read ahead output parameters
if self._read_ahead():
self['outfile'].filename()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Write spectrum method header and parameters
self._log_header1(gammalib.TERSE, 'Spectrum method')
self._log_value(gammalib.TERSE, 'Unbinned CTA observations', n_unbinned)
self._log_value(gammalib.TERSE, 'Binned CTA observations', n_binned)
self._log_value(gammalib.TERSE, 'On/off CTA observations', n_onoff)
self._log_value(gammalib.TERSE, 'Other observations', n_other)
# If there are a mix of CTA and non-CTA observations and the method
# is 'SLICE' then log a warning that non-CTA observations will be
# ignored
warning = False
if n_cta > 0 and n_other > 0 and self._method == 'SLICE':
warning = True
# If there are only non-CTA observations and the method is 'SLICE'
# then stop now
elif n_other > 0:
if self._method == 'SLICE':
msg = 'Selected "SLICE" method but none of the observations ' \
'is a CTA observation. Please select "AUTO" or "NODES" ' \
'if no CTA observation is provided.'
raise RuntimeError(msg)
else:
self._method = 'NODES'
# Log selected spectrum method
self._log_value(gammalib.TERSE, 'Selected spectrum method', self._method)
# Signal warning
if warning:
self._log_string(gammalib.TERSE, ' WARNING: Only CTA observation '
'can be handled with the "SLICE" method, all '
'non-CTA observation will be ignored.')
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation.
"""
# Query datapath. If the parameter is not NONE then use it, otherwise
# use the datapath from the VHEFITS environment variable
datapath = self['datapath'].string()
if gammalib.toupper(datapath) != 'NONE':
self._datapath = datapath
else:
self._datapath = os.getenv('VHEFITS', '')
# Expand environment
self._datapath = gammalib.expand_env(self._datapath)
# Get production name
self._prodname = self['prodname'].string()
# Master index file name
master_indx = self['master_indx'].string()
# Initialise flag if spatial selection is required
self._select_radec = True
# Initialise invalid radius
self._radius = 0.0
# Check for validity of spatial parameters
if (self['ra'].is_valid() and self['dec'].is_valid()
and self['rad'].is_valid()):
# Read spatial parameters
self._ra = self['ra'].real()
self._dec = self['dec'].real()
self._radius = self['rad'].real()
# ... otherwise signal that there are no spatial parameters for
# selection
else:
self._select_radec = False
# Check Radius for validity
if self._radius <= 0.0:
self._select_radec = False
# Query other parameters
self['min_qual'].integer()
self['expression'].string()
# Read ahead output parameters
if self._read_ahead():
self['outfile'].filename()
# Set filename of JSON master file and raise an exception if the file
# does not exist
master_file = os.path.join(self._datapath, master_indx)
if not os.path.isfile(master_file):
msg = ('FITS data store not available. No master index file found '
'at "%s". Make sure the file is copied from the server and '
'your datapath is set correctly.' % master_file)
raise RuntimeError(msg)
# Open and load JSON master file. If the "dataset" key is not available
# then raise an exception
json_data = open(master_file).read()
data = json.loads(json_data)
if not 'datasets' in data:
msg = ('Key "datasets" not available in master index file.')
raise RuntimeError(msg)
# Get configurations from JSON master file
configs = data['datasets']
# Initialise obs index file
self._obs_index = ''
# Get name of observation index file
for config in configs:
if self._prodname == config['name']:
self._obs_index = str(
os.path.join(self._datapath, config['obsindx']))
break
# If the observation index file name is empty then raise an exception
if self._obs_index == '':
msg = ('FITS data store "%s" not available. Run csiactdata to get '
'a list of available storage names.' % self._prodname)
raise RuntimeError(msg)
# If the observation index file is not a FITS file then raise an
# exception
filename = gammalib.GFilename(self._obs_index + '[OBS_INDEX]')
if not filename.is_fits():
msg = (
'Observation index file "%s[OBS_INDEX]" for FITS data store '
'"%s" not available. Check your master index file or run '
'csiactdata to get a list of available storage names.' %
(self._obs_index, self._prodname))
raise RuntimeError(msg)
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Return
return
def plot_irf(irf, emin, emax, tmin, tmax, plotfile):
"""
Plot Instrument Response Function
Parameters
----------
irf : `~gammalib.GCTAResponseIrf`
Instrument Response Function
emin : float
Minimum energy (TeV)
emax : float
Maximum energy (TeV)
tmin : float
Minimum offset angle (deg)
tmax : float
Maximum offset angle (deg)
plotfile : str
Plot filename
"""
# Build selection string
selection = ''
eselection = ''
tselection = ''
if emin != None and emax != None:
eselection += '%.3f-%.1f TeV' % (emin, emax)
elif emin != None:
eselection += ' >%.3f TeV' % (emin)
elif emax != None:
eselection += ' <%.1f TeV' % (emax)
if tmin != None and tmax != None:
tselection += '%.1f-%.1f deg' % (tmin, tmax)
elif tmin != None:
tselection += ' >%.1f deg' % (tmin)
elif tmax != None:
tselection += ' <%.1f deg' % (tmax)
if len(eselection) > 0 and len(tselection) > 0:
selection = ' (%s, %s)' % (eselection, tselection)
elif len(eselection) > 0:
selection = ' (%s)' % (eselection)
elif len(tselection) > 0:
selection = ' (%s)' % (tselection)
# Build title
mission = irf.caldb().mission()
instrument = irf.caldb().instrument()
response = irf.rspname()
title = '%s "%s" Instrument Response Function "%s"%s' % \
(gammalib.toupper(mission), instrument, response, selection)
# Create figure
fig = plt.figure(figsize=(16,8))
# Add title
fig.suptitle(title, fontsize=16)
# Plot Aeff
ax1 = fig.add_subplot(231)
plot_aeff(ax1, irf.aeff(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Plot Psf
ax2 = fig.add_subplot(232)
plot_psf(ax2, irf.psf(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Plot Background
ax3 = fig.add_subplot(233)
plot_bkg(ax3, irf.background(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Plot Edisp
fig.add_subplot(234)
plot_edisp(irf.edisp(), emin=emin, emax=emax, tmin=tmin, tmax=tmax)
# Show plots or save it into file
if len(plotfile) > 0:
plt.savefig(plotfile)
else:
plt.show()
# Return
return
def _get_parameters(self):
"""
Get parameters from parfile and setup the observation
"""
# Setup observations (require response and allow event list as well as
# counts cube)
self._setup_observations(self.obs(), True, True, True)
# Set observation statistic
self._set_obs_statistic(gammalib.toupper(self['statistic'].string()))
# Collect number of unbinned, binned and On/Off observations in
# observation container
n_unbinned = 0
n_binned = 0
n_onoff = 0
for obs in self.obs():
if obs.classname() == 'GCTAObservation':
if obs.eventtype() == 'CountsCube':
n_binned += 1
else:
n_unbinned += 1
elif obs.classname() == 'GCTAOnOffObservation':
n_onoff += 1
n_cta = n_unbinned + n_binned + n_onoff
n_other = self.obs().size() - n_cta
# Query whether to compute model for individual components
components = self['components'].boolean()
# If there is only one binned observation and no model for individual
# components is required, query for precomputed model file and set
# use_maps to True
if self.obs().size() == 1 and n_binned == 1 and not components:
self._use_maps = self['modcube'].is_valid()
# If there are unbinned observations query the energy binning parameters
if n_unbinned != 0:
self['ebinalg'].string()
if self['ebinalg'].string() == 'FILE':
self['ebinfile'].filename()
else:
self['emin'].real()
self['emax'].real()
self['enumbins'].integer()
if n_cta > n_unbinned:
n_notunbin = n_cta - n_unbinned
# If there is more than one observation, and observations are all
# unbinned or all onoff query user to know if they wish stacked results
if self.obs().size() > 1 and \
(n_unbinned == self.obs().size() or n_onoff == self.obs().size()):
self._stack = self['stack'].boolean()
# If we are to stack event lists query parameters for cube creation
if self._stack and n_unbinned == self.obs().size():
self['coordsys'].string()
self['proj'].string()
self['xref'].real()
self['yref'].real()
self['nxpix'].integer()
self['nypix'].integer()
self['binsz'].real()
# If we are not using a precomputed model and no models are available
# in the observation container query input XML model file
if not self._use_maps and self.obs().models().size() == 0:
self.obs().models(self['inmodel'].filename())
# Unless all observations are On/Off query for mask definition
if n_onoff == n_cta:
pass
else:
self._mask = self['mask'].boolean()
if self._mask:
self['ra'].real()
self['dec'].real()
self['rad'].real()
self['regfile'].query()
# Unless all observations are On/Off, or we are using precomputed model
# maps query whether to use energy dispersion
if n_onoff == n_cta or self._use_maps:
pass
else:
self['edisp'].boolean()
# Query algorithm for residual computation
self['algorithm'].string()
# Read ahead output parameters
if self._read_ahead():
self['outfile'].filename()
# Write input parameters into logger
self._log_parameters(gammalib.TERSE)
# Write header for observation census
self._log_header1(gammalib.TERSE, 'Observation census')
# Log census of input observations
self._log_value(gammalib.NORMAL, 'Unbinned CTA observations',
n_unbinned)
self._log_value(gammalib.NORMAL, 'Binned CTA observations', n_binned)
self._log_value(gammalib.NORMAL, 'On/off CTA observations', n_onoff)
self._log_value(gammalib.NORMAL, 'Other observations', n_other)
if n_other > 0:
msg = 'WARNING: Only CTA observation can be handled, all non-CTA ' \
+ 'observations will be ignored.'
self._log_string(gammalib.TERSE, msg)
# Log for unbinned observations
if n_unbinned != 0:
msg = ' User defined energy binning will be used for %d unbinned ' \
'observations.' % (n_unbinned)
self._log_string(gammalib.TERSE, msg)
if n_cta > n_unbinned:
msg = ' The intrinsic binning will be used for the remaining ' \
'%d CTA observations.' % (n_notunbin)
self._log_string(gammalib.TERSE, msg)
# Signal how energy dispersion is applied
if n_onoff == n_cta or self._use_maps:
msg = ' Energy dispersion is applied based on the input data/model ' \
+ 'and not according to the edisp parameter'
self._log_string(gammalib.TERSE, msg)
# Return
return
def _trial(self, seed):
"""
Compute the pull for a single trial
Parameters
----------
seed : int
Random number generator seed
Returns
-------
result : dict
Dictionary of results
"""
# Write header
self._log_header2(gammalib.NORMAL, 'Trial %d' %
(seed-self['seed'].integer()+1))
# Get number of energy bins and On source name and initialise
# some parameters
nbins = self['enumbins'].integer()
onsrc = self['onsrc'].string()
edisp = self['edisp'].boolean()
statistic = self['statistic'].string()
emin = None
emax = None
binsz = 0.0
npix = 0
proj = 'TAN'
coordsys = 'CEL'
# If we have a On source name then set On region radius
if gammalib.toupper(onsrc) != 'NONE':
onrad = self['onrad'].real()
emin = self['emin'].real()
emax = self['emax'].real()
edisp = True # Use always energy dispersion for On/Off
else:
# Reset On region source name and radius
onrad = 0.0
onsrc = None
# If we have a binned obeservation then specify the lower and
# upper energy limit in TeV
if nbins > 0:
emin = self['emin'].real()
emax = self['emax'].real()
binsz = self['binsz'].real()
npix = self['npix'].integer()
proj = self['proj'].string()
coordsys = self['coordsys'].string()
# Simulate events
obs = obsutils.sim(self.obs(),
emin=emin, emax=emax, nbins=nbins,
onsrc=onsrc, onrad=onrad,
addbounds=True, seed=seed,
binsz=binsz, npix=npix, proj=proj, coord=coordsys,
edisp=edisp, log=False, debug=self._logDebug(),
chatter=self['chatter'].integer())
# Determine number of events in simulation
nevents = 0.0
for run in obs:
nevents += run.nobserved()
# Write simulation results
self._log_header3(gammalib.NORMAL, 'Simulation')
for run in self.obs():
self._log_value(gammalib.NORMAL, 'Input observation %s' % run.id(),
self._obs_string(run))
for run in obs:
self._log_value(gammalib.NORMAL, 'Output observation %s' % run.id(),
self._obs_string(run))
self._log_value(gammalib.NORMAL, 'Number of simulated events', nevents)
# Fit model
if self['profile'].boolean():
models = self.obs().models()
for model in models:
like = ctools.cterror(obs)
like['srcname'] = model.name()
like['edisp'] = edisp
like['statistic'] = statistic
like['debug'] = self._logDebug()
like['chatter'] = self['chatter'].integer()
like.run()
else:
like = ctools.ctlike(obs)
like['edisp'] = edisp
like['statistic'] = statistic
like['debug'] = self._logDebug()
like['chatter'] = self['chatter'].integer()
like.run()
# Store results
logL = like.opt().value()
npred = like.obs().npred()
models = like.obs().models()
# Write result header
self._log_header3(gammalib.NORMAL, 'Pulls')
# Gather results in form of a list of result columns and a
# dictionary containing the results. The result contains the
# log-likelihood, the number of simulated events, the number of
# predicted events and for each fitted parameter the fitted value,
# the pull and the fit error.
#
# Note that we do not use the model and parameter iterators
# because we need the indices to get the true (or real) parameter
# values from the input models.
colnames = ['LogL', 'Sim_Events', 'Npred_Events']
values = {'LogL': logL, 'Sim_Events': nevents, 'Npred_Events': npred}
for i in range(models.size()):
model = models[i]
for k in range(model.size()):
par = model[k]
if par.is_free():
# Set name as a combination of model name and parameter
# name separated by an underscore. In that way each
# parameter has a unique name.
name = model.name()+'_'+par.name()
# Append parameter, Pull_parameter and e_parameter column
# names
colnames.append(name)
colnames.append('Pull_'+name)
colnames.append('e_'+name)
# Compute pull for this parameter as the difference
# (fitted - true) / error
# In case that the error is 0 the pull is set to 99
fitted_value = par.value()
real_value = self.obs().models()[i][k].value()
error = par.error()
if error != 0.0:
pull = (fitted_value - real_value) / error
else:
pull = 99.0
# Store results in dictionary
values[name] = fitted_value
values['Pull_'+name] = pull
values['e_'+name] = error
# Write results into logger
value = '%.4f (%e +/- %e)' % (pull, fitted_value, error)
self._log_value(gammalib.NORMAL, name, value)
# Bundle together results in a dictionary
result = {'colnames': colnames, 'values': values}
# Return
return result