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 createobs(ra=86.171648, dec=-1.4774586, rad=5.0,
emin=0.1, emax=100.0, duration=360000.0, deadc=0.95,
):
obs = gammalib.GCTAObservation()
# Set pointing direction
pntdir = gammalib.GSkyDir()
pntdir.radec_deg(ra, dec)
pnt = gammalib.GCTAPointing()
pnt.dir(pntdir)
obs.pointing(pnt)
# Set ROI
roi = gammalib.GCTARoi()
instdir = gammalib.GCTAInstDir()
instdir.dir(pntdir)
roi.centre(instdir)
roi.radius(rad)
# Set GTI
gti = gammalib.GGti()
start = gammalib.GTime(0.0)
stop = gammalib.GTime(duration)
gti.append(start, stop)
# Set energy boundaries
ebounds = gammalib.GEbounds()
e_min = gammalib.GEnergy()
e_max = gammalib.GEnergy()
e_min.TeV(emin)
e_max.TeV(emax)
ebounds.append(e_min, e_max)
# Allocate event list
events = gammalib.GCTAEventList()
events.roi(roi)
events.gti(gti)
events.ebounds(ebounds)
obs.events(events)
# Set ontime, livetime, and deadtime correction factor
obs.ontime(duration)
obs.livetime(duration * deadc)
obs.deadc(deadc)
# Return observation
return obs
#STORE THE OBSERVATION IN GObservations Class and store it in the .xml output file.
#Allocate CTA observation
obs = gammalib.GCTAObservation()
#Set pointing direction
pntdir = gammalib.GSkyDir()
pntdir.radec_deg(ra, dec)
pnt = gammalib.GCTAPointing()
pnt.dir(pntdir)
obs.pointing(pnt)
#Set ROI
roi = gammalib.GCTARoi()
instdir = gammalib.GCTAInstDir()
instdir.dir(pntdir)
roi.centre(instdir)
roi.radius(rad)
#Set GTI
gti = gammalib.GGti()
start = gammalib.GTime(tstart)
stop = gammalib.GTime(tstart + duration)
gti.append(start, stop)
#Set Energy Boundaries
ebounds = gammalib.GEbounds()
e_min = gammalib.GEnergy(emin, 'TeV')
e_max = gammalib.GEnergy(emax, 'TeV')
def plot_lookup(filename, ax, nengs=300, nthetas=300):
"""
Plot lookup table
Parameters
----------
filename : str
Lookup table filename
ax : figure
Subplot
nengs : int, optional
Number of energies
nthetas : int, optional
Number of offset angles
"""
# Load lookup table
lookup = gammalib.GCTAModelSpatialLookup(filename)
table = lookup.table()
# Get boundaries
axis_eng = table.axis('ENERG')
axis_theta = table.axis('THETA')
emin = table.axis_lo(axis_eng, 0)
emax = table.axis_hi(axis_eng, table.axis_bins(axis_eng) - 1)
tmin = table.axis_lo(axis_theta, 0)
tmax = table.axis_hi(axis_theta, table.axis_bins(axis_theta) - 1)
# Use log energies
emin = math.log10(emin)
emax = math.log10(emax)
# Set axes
denergy = (emax - emin) / (nengs - 1)
dtheta = (tmax - tmin) / (nthetas - 1)
logenergies = [emin + i * denergy for i in range(nengs)]
thetas = [tmax - i * dtheta for i in range(nthetas)]
# Initialise image
image = []
# Set event time
time = gammalib.GTime()
# Loop over offset angles
for theta in thetas:
# Set event direction
dir = gammalib.GCTAInstDir(theta * gammalib.deg2rad, 0.0)
# Initialise row
row = []
# Loop over energies
for logenergy in logenergies:
# Set event energy
energy = gammalib.GEnergy()
energy.log10TeV(logenergy)
# Get lookup table value
value = lookup.eval(dir, energy, time)
# Append value
row.append(value)
# Append row
image.append(row)
# Plot image
c = ax.imshow(image,
extent=[emin, emax, tmin, tmax],
cmap=plt.get_cmap('jet'),
aspect=0.8)
cbar = plt.colorbar(c, orientation='vertical', shrink=0.7)
cbar.set_label('sr$^{-1}$', labelpad=-22, y=-0.05, rotation=0)
# Plot title and axis
ax.set_xlabel('log10(E/TeV)', fontsize=12)
ax.set_ylabel('Offset angle (deg)', fontsize=12)
# Return
return
def run(self):
"""
Run the script
Raises
------
RuntimeError
Invalid pointing definition file format
"""
# Switch screen logging on in debug mode
if self._logDebug():
self._log.cout(True)
# Get parameters
self._get_parameters()
# Write header into logger
self._log_header1(gammalib.TERSE,
'Creating observation definition XML file')
# Load pointing definition file if it is not already set. Extract
# the number of columns and pointings
if self._pntdef.size() == 0:
self._pntdef = gammalib.GCsv(self['inpnt'].filename(), ',')
ncols = self._pntdef.ncols()
npnt = self._pntdef.nrows() - 1
# Raise an exception if there is no header information
if self._pntdef.nrows() < 1:
raise RuntimeError('No header found in pointing definition file.')
# Clear observation container
self._obs.clear()
# Initialise observation identifier counter
identifier = 1
# Extract header columns from pointing definition file and put them
# into a list
header = []
for col in range(ncols):
header.append(self._pntdef[0, col])
# Loop over all pointings
for pnt in range(npnt):
# Set pointing definition CSV file row index
row = pnt + 1
# Create empty CTA observation
obs = gammalib.GCTAObservation()
# Set observation name. If no observation name was given then
# use "None".
if 'name' in header:
name = self._pntdef[row, header.index('name')]
else:
name = self['name'].string()
obs.name(name)
# Set observation identifier. If no observation identified was
# given the use the internal counter.
if 'id' in header:
obsid = self._pntdef[row, header.index('id')]
else:
obsid = '%6.6d' % identifier
identifier += 1
obs.id(obsid)
# Set pointing. Either use "ra" and "dec" or "lon" and "lat".
# If none of these pairs are given then raise an exception.
if 'ra' in header and 'dec' in header:
ra = float(self._pntdef[row, header.index('ra')])
dec = float(self._pntdef[row, header.index('dec')])
pntdir = gammalib.GSkyDir()
pntdir.radec_deg(ra, dec)
elif 'lon' in header and 'lat' in header:
lon = float(self._pntdef[row, header.index('lon')])
lat = float(self._pntdef[row, header.index('lat')])
pntdir = gammalib.GSkyDir()
pntdir.lb_deg(lon, lat)
else:
raise RuntimeError('No (ra,dec) or (lon,lat) columns '
'found in pointing definition file.')
obs.pointing(gammalib.GCTAPointing(pntdir))
# Set response function. If no "caldb" or "irf" information is
# provided then use the user parameter values.
if 'caldb' in header:
caldb = self._pntdef[row, header.index('caldb')]
else:
caldb = self['caldb'].string()
if 'irf' in header:
irf = self._pntdef[row, header.index('irf')]
else:
irf = self['irf'].string()
if caldb != '' and irf != '':
obs = self._set_irf(obs, caldb, irf)
# Set deadtime correction factor. If no information is provided
# then use the user parameter value "deadc".
if 'deadc' in header:
deadc = float(self._pntdef[row, header.index('deadc')])
else:
deadc = self['deadc'].real()
obs.deadc(deadc)
# Set Good Time Interval. If no information is provided then use
# the user parameter values "tmin" and "duration".
if 'tmin' in header:
self._tmin = float(self._pntdef[row, header.index('tmin')])
if 'duration' in header:
duration = float(self._pntdef[row, header.index('duration')])
else:
duration = self['duration'].real()
tref = gammalib.GTimeReference(self['mjdref'].real(), 's')
tmin = self._tmin
tmax = self._tmin + duration
gti = gammalib.GGti(tref)
tstart = gammalib.GTime(tmin, tref)
tstop = gammalib.GTime(tmax, tref)
self._tmin = tmax
gti.append(tstart, tstop)
obs.ontime(gti.ontime())
obs.livetime(gti.ontime() * deadc)
# Set Energy Boundaries. If no "emin" or "emax" information is
# provided then use the user parameter values in case they are
# valid.
has_emin = False
has_emax = False
if 'emin' in header:
emin = float(self._pntdef[row, header.index('emin')])
has_emin = True
else:
if self['emin'].is_valid():
emin = self['emin'].real()
has_emin = True
if 'emax' in header:
emax = float(self._pntdef[row, header.index('emax')])
has_emax = True
else:
if self['emax'].is_valid():
emax = self['emax'].real()
has_emax = True
has_ebounds = has_emin and has_emax
if has_ebounds:
ebounds = gammalib.GEbounds(gammalib.GEnergy(emin, 'TeV'),
gammalib.GEnergy(emax, 'TeV'))
# Set ROI. If no ROI radius is provided then use the user
# parameters "rad".
has_roi = False
if 'rad' in header:
rad = float(self._pntdef[row, header.index('rad')])
has_roi = True
else:
if self['rad'].is_valid():
rad = self['rad'].real()
has_roi = True
if has_roi:
roi = gammalib.GCTARoi(gammalib.GCTAInstDir(pntdir), rad)
# Create an empty event list
event_list = gammalib.GCTAEventList()
event_list.gti(gti)
# If available, set the energy boundaries and the ROI
if has_ebounds:
event_list.ebounds(ebounds)
if has_roi:
event_list.roi(roi)
# Attach event list to CTA observation
obs.events(event_list)
# Write observation into logger
name = obs.instrument() + ' observation'
value = 'Name="%s" ID="%s"' % (obs.name(), obs.id())
self._log_value(gammalib.NORMAL, name, value)
self._log_string(gammalib.EXPLICIT, str(obs) + '\n')
# Append observation
self._obs.append(obs)
# Return
return
def set_obs(pntdir, tstart=0.0, duration=1800.0, deadc=0.95, \
emin=0.1, emax=100.0, rad=5.0, \
irf="South_50h", caldb="prod2", id="000000"):
"""
Set a single CTA observation.
The function sets a single CTA observation containing an empty CTA
event list. By looping over this function you can add CTA observations
to the observation container.
Args:
pntdir: Pointing direction [GSkyDir]
Kwargs:
tstart: Start time (seconds) (default: 0.0)
duration: Duration of observation (seconds) (default: 1800.0)
deadc: Deadtime correction factor (default: 0.95)
emin: Minimum event energy (TeV) (default: 0.1)
emax: Maximum event energy (TeV) (default: 100.0)
rad: ROI radius used for analysis (deg) (default: 5.0)
irf: Instrument response function (default: "South_50h")
caldb: Calibration database path (default: "prod2")
id: Run identifier (default: "000000")
"""
# Allocate CTA observation
obs_cta = gammalib.GCTAObservation()
# Set calibration database
db = gammalib.GCaldb()
if (gammalib.dir_exists(caldb)):
db.rootdir(caldb)
else:
db.open("cta", caldb)
# Set pointing direction
pnt = gammalib.GCTAPointing()
pnt.dir(pntdir)
obs_cta.pointing(pnt)
# Set ROI
roi = gammalib.GCTARoi()
instdir = gammalib.GCTAInstDir()
instdir.dir(pntdir)
roi.centre(instdir)
roi.radius(rad)
# Set GTI
gti = gammalib.GGti()
gti.append(gammalib.GTime(tstart), gammalib.GTime(tstart + duration))
# Set energy boundaries
ebounds = gammalib.GEbounds(gammalib.GEnergy(emin, "TeV"),
gammalib.GEnergy(emax, "TeV"))
# Allocate event list
events = gammalib.GCTAEventList()
events.roi(roi)
events.gti(gti)
events.ebounds(ebounds)
obs_cta.events(events)
# Set instrument response
obs_cta.response(irf, db)
# Set ontime, livetime, and deadtime correction factor
obs_cta.ontime(duration)
obs_cta.livetime(duration * deadc)
obs_cta.deadc(deadc)
obs_cta.id(id)
# Return CTA observation
return obs_cta
def modmap(obs, eref=0.1, proj="TAN", coord="GAL", xval=0.0, yval=0.0, \
binsz=0.05, nxpix=200, nypix=200, \
outname="modmap.fits"):
"""
Make model map for a given reference energy by combining all observations.
The model map will be evaluated for a given reference energy 'eref' and will
be given in units of [counts/(sr MeV s)].
Parameters:
obs - Observation container
Keywords:
eref - Reference energy for which model is created [TeV] (default: 0.1)
proj - Projection type (e.g. TAN, CAR, STG, ...) (default: TAN)
coord - Coordinate type (GAL, CEL) (default: GAL)
xval - Reference longitude value [deg] (default: 0.0)
yval - Reference latitude value [deg] (default: 0.0)
binsz - Pixel size [deg/pixel] (default: 0.05)
nxpix - Number of pixels in X direction (default: 200)
nypix - Number of pixels in Y direction (default: 200)
outname - Model map FITS filename (default: modmap.fits)
"""
# Allocate model map
map = gammalib.GSkyMap(proj, coord, xval, yval, -binsz, binsz, nxpix,
nypix, 1)
# Set reference energy, time and direction. The time is not initialised and is
# in fact not used (as the IRF is assumed to be time independent for now).
# The sky direction is set later using the pixel values.
energy = gammalib.GEnergy()
time = gammalib.GTime()
instdir = gammalib.GCTAInstDir()
energy.TeV(eref)
# Loop over all map pixels
for pixel in range(map.npix()):
# Get sky direction
skydir = map.inx2dir(pixel)
instdir.dir(skydir)
# Create event atom for map pixel
atom = gammalib.GCTAEventAtom()
atom.dir(instdir)
atom.energy(energy)
atom.time(time)
# Initialise model value
value = 0.0
# Loop over all observations
for run in obs:
value += obs.models().eval(atom, run)
# Set map value
map[pixel] = value
# Save sky map
map.save(outname, True)
# Return model map
return map
def set(RA=83.63,
DEC=22.01,
tstart=0.0,
duration=1800.0,
deadc=0.95,
emin=0.1,
emax=100.0,
rad=5.0,
irf="cta_dummy_irf",
caldb="$GAMMALIB/share/caldb/cta"):
"""
Create one CTA observation
Copied from ctools/scripts/obsutils.py and modified a bit.
"""
# Allocate CTA observation
obs = gammalib.GCTAObservation()
# Set pointing direction
pntdir = gammalib.GSkyDir()
pntdir.radec_deg(RA, DEC)
pnt = gammalib.GCTAPointing()
pnt.dir(pntdir)
obs.pointing(pnt)
# Set ROI
roi = gammalib.GCTARoi()
instdir = gammalib.GCTAInstDir()
instdir.dir(pntdir)
roi.centre(instdir)
roi.radius(rad)
# Set GTI
gti = gammalib.GGti()
start = gammalib.GTime(tstart)
stop = gammalib.GTime(tstart + duration)
gti.append(start, stop)
# Set energy boundaries
ebounds = gammalib.GEbounds()
e_min = gammalib.GEnergy()
e_max = gammalib.GEnergy()
e_min.TeV(emin)
e_max.TeV(emax)
ebounds.append(e_min, e_max)
# Allocate event list
events = gammalib.GCTAEventList()
events.roi(roi)
events.gti(gti)
events.ebounds(ebounds)
obs.events(events)
# Set instrument response
obs.response(irf, caldb)
# Set ontime, livetime, and deadtime correction factor
obs.ontime(duration)
obs.livetime(duration * deadc)
obs.deadc(deadc)
# Return observation
return obs
def run(self):
"""
Run the script.
Raises
------
RuntimeError
Invalid pointing definition file format.
"""
# Switch screen logging on in debug mode
if self._logDebug():
self._log.cout(True)
# Get parameters
self._get_parameters()
# Write header into logger
if self._logTerse():
self._log('\n')
self._log.header1('Creating observation definition XML file')
# Load pointing definition file if it is not already set
if self._pntdef.size() == 0:
self._pntdef = gammalib.GCsv(self['inpnt'].filename(), ',')
ncols = self._pntdef.ncols()
npnt = self._pntdef.nrows()-1
# Throw an exception is there is no header information
if self._pntdef.nrows() < 1:
raise RuntimeError('No header found in pointing definition file.')
# Clear observation container
self._obs.clear()
identifier = 1
# Extract header from pointing definition file
header = []
for col in range(ncols):
header.append(self._pntdef[0,col])
# Loop over all pointings
for pnt in range(npnt):
# Set row index
row = pnt + 1
# Create CTA observation
obs = gammalib.GCTAObservation()
# Set observation name
if 'name' in header:
name = self._pntdef[row, header.index('name')]
else:
name = 'None'
obs.name(name)
# Set identifier
if 'id' in header:
id_ = self._pntdef[row, header.index('id')]
else:
id_ = '%6.6d' % identifier
identifier += 1
obs.id(id_)
# Set pointing
if 'ra' in header and 'dec' in header:
ra = float(self._pntdef[row, header.index('ra')])
dec = float(self._pntdef[row, header.index('dec')])
pntdir = gammalib.GSkyDir()
pntdir.radec_deg(ra,dec)
elif 'lon' in header and 'lat' in header:
lon = float(self._pntdef[row, header.index('lon')])
lat = float(self._pntdef[row, header.index('lat')])
pntdir = gammalib.GSkyDir()
pntdir.lb_deg(lon,lat)
else:
raise RuntimeError('No (ra,dec) or (lon,lat) columns '
'found in pointing definition file.')
obs.pointing(gammalib.GCTAPointing(pntdir))
# Set response function
if 'caldb' in header:
caldb = self._pntdef[row, header.index('caldb')]
else:
caldb = self['caldb'].string()
if 'irf' in header:
irf = self._pntdef[row, header.index('irf')]
else:
irf = self['irf'].string()
if caldb != '' and irf != '':
obs = self._set_response(obs, caldb, irf)
# Set deadtime correction factor
if 'deadc' in header:
deadc = float(self._pntdef[row, header.index('deadc')])
else:
deadc = self['deadc'].real()
obs.deadc(deadc)
# Set Good Time Interval
if 'duration' in header:
duration = float(self._pntdef[row, header.index('duration')])
else:
duration = self['duration'].real()
tmin = self._tmin
tmax = self._tmin + duration
gti = gammalib.GGti(self._time_reference())
tstart = gammalib.GTime(tmin, self._time_reference())
tstop = gammalib.GTime(tmax, self._time_reference())
self._tmin = tmax
gti.append(tstart, tstop)
obs.ontime(gti.ontime())
obs.livetime(gti.ontime()*deadc)
# Set Energy Boundaries
has_emin = False
has_emax = False
if 'emin' in header:
emin = float(self._pntdef[row, header.index('emin')])
has_emin = True
else:
if self['emin'].is_valid():
emin = self['emin'].real()
has_emin = True
if 'emax' in header:
emax = float(self._pntdef[row, header.index('emax')])
has_emax = True
else:
if self['emax'].is_valid():
emax = self['emax'].real()
has_emax = True
has_ebounds = has_emin and has_emax
if has_ebounds:
ebounds = gammalib.GEbounds(gammalib.GEnergy(emin, 'TeV'),
gammalib.GEnergy(emax, 'TeV'))
# Set ROI
has_roi = False
if 'rad' in header:
rad = float(self._pntdef[row, header.index('rad')])
has_roi = True
else:
if self['rad'].is_valid():
rad = self['rad'].real()
has_roi = True
if has_roi:
roi = gammalib.GCTARoi(gammalib.GCTAInstDir(pntdir), rad)
# Create an empty event list
list_ = gammalib.GCTAEventList()
list_.gti(gti)
# Set optional information
if has_ebounds:
list_.ebounds(ebounds)
if has_roi:
list_.roi(roi)
# Attach event list to CTA observation
obs.events(list_)
# Write observation into logger
if self._logExplicit():
self._log(str(obs))
self._log('\n')
elif self._logTerse():
self._log(gammalib.parformat(obs.instrument()+' observation'))
self._log('Name="'+obs.name()+'" ')
self._log('ID="'+obs.id()+'"\n')
# Append observation
self._obs.append(obs)
# Return
return
def set_obs(pntdir, tstart=0.0, duration=1800.0, deadc=0.98, \
emin=0.1, emax=100.0, rad=5.0, \
irf='South_50h', caldb='prod2', obsid='000000'):
"""
Set a single CTA observation
The function sets a single CTA observation containing an empty CTA
event list. By looping over this function CTA observations can be
added to the observation container.
Parameters
----------
pntdir : `~gammalib.GSkyDir`
Pointing direction
tstart : float, optional
Start time (s)
duration : float, optional
Duration of observation (s)
deadc : float, optional
Deadtime correction factor
emin : float, optional
Minimum event energy (TeV)
emax : float, optional
Maximum event energy (TeV)
rad : float, optional
ROI radius used for analysis (deg)
irf : str, optional
Instrument response function
caldb : str, optional
Calibration database path
obsid : str, optional
Observation identifier
Returns
-------
obs : `~gammalib.GCTAObservation`
CTA observation
"""
# Allocate CTA observation
obs = gammalib.GCTAObservation()
# Set CTA calibration database
db = gammalib.GCaldb()
if (gammalib.dir_exists(caldb)):
db.rootdir(caldb)
else:
db.open('cta', caldb)
# Set pointing direction for CTA observation
pnt = gammalib.GCTAPointing()
pnt.dir(pntdir)
obs.pointing(pnt)
# Set ROI
roi = gammalib.GCTARoi()
instdir = gammalib.GCTAInstDir()
instdir.dir(pntdir)
roi.centre(instdir)
roi.radius(rad)
# Set GTI
gti = gammalib.GGti()
gti.append(gammalib.GTime(tstart), gammalib.GTime(tstart + duration))
# Set energy boundaries
ebounds = gammalib.GEbounds(gammalib.GEnergy(emin, 'TeV'),
gammalib.GEnergy(emax, 'TeV'))
# Allocate event list
events = gammalib.GCTAEventList()
# Set ROI, GTI and energy boundaries for event list
events.roi(roi)
events.gti(gti)
events.ebounds(ebounds)
# Set the event list as the events for CTA observation
obs.events(events)
# Set instrument response for CTA observation
obs.response(irf, db)
# Set ontime, livetime, and deadtime correction factor for CTA observation
obs.ontime(duration)
obs.livetime(duration * deadc)
obs.deadc(deadc)
obs.id(obsid)
# Return CTA observation
return obs
def createobs(ra=86.171648, dec=-1.4774586, rad=5.0,
emin=0.1, emax=100.0, duration=360000.0, deadc=0.95,
irf="South_50h", caldb="prod2"):
"""
Create CTA observation.
"""
# Allocate CTA observation
obs = gammalib.GCTAObservation()
# Set calibration database
db = gammalib.GCaldb()
if (gammalib.dir_exists(caldb)):
db.rootdir(caldb)
else:
db.open("cta", caldb)
# Set pointing direction
pntdir = gammalib.GSkyDir()
pntdir.radec_deg(ra, dec)
pnt = gammalib.GCTAPointing()
pnt.dir(pntdir)
obs.pointing(pnt)
# Set ROI
roi = gammalib.GCTARoi()
instdir = gammalib.GCTAInstDir()
instdir.dir(pntdir)
roi.centre(instdir)
roi.radius(rad)
# Set GTI
gti = gammalib.GGti()
start = gammalib.GTime(0.0)
stop = gammalib.GTime(duration)
gti.append(start, stop)
# Set energy boundaries
ebounds = gammalib.GEbounds()
e_min = gammalib.GEnergy()
e_max = gammalib.GEnergy()
e_min.TeV(emin)
e_max.TeV(emax)
ebounds.append(e_min, e_max)
# Allocate event list
events = gammalib.GCTAEventList()
events.roi(roi)
events.gti(gti)
events.ebounds(ebounds)
obs.events(events)
# Set instrument response
obs.response(irf, db)
# Set ontime, livetime, and deadtime correction factor
obs.ontime(duration)
obs.livetime(duration*deadc)
obs.deadc(deadc)
# Return observation
return obs