def _check_result_file(self, filename, nevents=253):
"""
Check result file
Parameters
----------
filename : str
Event list file name
nevents : int, optional
Expected number of events
"""
# Open event list
events = gammalib.GCTAEventList(filename)
# Check event list
self.test_value(events.size(), nevents, 'Check number of events')
# Check phases
phases = [events[i].phase() for i in range(events.size())]
test_result = int(sum(phases) > 0)
self.test_value(test_result, 1,
'Check whether phase information is set')
# Return
return
def _check_result_file(self, filename, nevents=253):
"""
Check result file
Parameters
----------
filename : str
Event list file name
nevents : int, optional
Expected number of events
"""
# Open result file
events = gammalib.GCTAEventList(filename)
# Check event list
self._check_events(events, nevents=nevents)
# Check that probability columns exist
colname1 = 'PROB_Background'
colname2 = 'PROB_Crab'
self._check_column(filename, colname1)
self._check_column(filename, colname2)
# Check that the probability values are correctly normalized
self._check_normalization(filename, [colname1,colname2])
# Return
return
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
def _check_result_file(self, filename):
"""
Check result file
"""
# Open result file
result = gammalib.GCTAEventList(filename)
# Check file
self.test_value(result.size(), 6127, 'Check for 6127 events')
self.test_value(result.roi().centre().dir().ra_deg(), 83.63, 1.0e-6,
'Check for ROI Right Ascension')
self.test_value(result.roi().centre().dir().dec_deg(), 22.01, 1.0e-6,
'Check for ROI Declination')
self.test_value(result.roi().radius(), 3.0, 1.0e-6,
'Check for ROI Radius')
# Return
return
def _test_ctobssim_cmd(self):
"""
Test ctobssim on the command line
"""
# Set tool name
ctobssim = self._tool('ctobssim')
# Setup ctobssim command
cmd = ctobssim+' inmodel="'+self._model+'" '+ \
' outevents="ctobssim_cmd1.fits"'+ \
' caldb="'+self._caldb+'" irf="'+self._irf+'" '+ \
' ra=83.63 dec=22.01 rad=2.0'+ \
' tmin="2020-01-01T00:00:00"'+ \
' tmax="2020-01-01T00:05:00"'+ \
' emin=1.0 emax=100.0'+ \
' logfile="ctobssim_cmd1.log" chatter=1'
# Check if execution was successful
self.test_assert(self._execute(cmd) == 0,
'Check successful execution from command line')
# Load counts cube and check content.
evt = gammalib.GCTAEventList('ctobssim_cmd1.fits')
self._test_list(evt, 261)
# Setup ctobssim command
cmd = ctobssim+' inmodel="model_that_does_not_exist.xml"'+ \
' outevents="ctobssim_cmd2.fits"'+ \
' caldb="'+self._caldb+'" irf="'+self._irf+'" '+ \
' ra=83.63 dec=22.01 rad=2.0'+ \
' tmin="2020-01-01T00:00:00"'+ \
' tmax="2020-01-01T00:05:00"'+ \
' emin=1.0 emax=100.0'+ \
' logfile="ctobssim_cmd2.log" debug=yes chatter=1'
# Check if execution failed
self.test_assert(self._execute(cmd, success=False) != 0,
'Check invalid input file when executed from command line')
# Check ctobssim --help
self._check_help(ctobssim)
# Return
return
def _test_ctobssim_cmd(self):
"""
Test ctobssim on the command line
"""
# Set tool name
ctobssim = self._tool('ctobssim')
# Setup ctobssim command
cmd = ctobssim+' inmodel="'+self._model+'" '+ \
' outevents="events.fits"'+ \
' caldb="'+self._caldb+'" irf="'+self._irf+'" '+ \
' ra=83.63 dec=22.01 rad=10.0'+ \
' tmin=0.0 tmax=1800.0 emin=0.1 emax=100.0'
# Check if execution of wrong command fails
self.test_assert(self._execute('command_that_does_not_exist') != 0,
'Self test of test script')
# Check if execution was successful
self.test_assert(self._execute(cmd) == 0,
'Check successful execution from command line')
# Load counts cube and check content.
evt = gammalib.GCTAEventList('events.fits')
self._test_list(evt, 6881)
# Setup ctobssim command
cmd = ctobssim+' inmodel="model_that_does_not_exist.xml"'+ \
' outevents="events.fits"'+ \
' caldb="'+self._caldb+'" irf="'+self._irf+'" '+ \
' ra=83.63 dec=22.01 rad=10.0'+ \
' tmin=0.0 tmax=1800.0 emin=0.1 emax=100.0'
# Check if execution failed
self.test_assert(self._execute(cmd) != 0,
'Check invalid input file when executed from command line')
# Return
return
def _check_result_file(self, filename, nevents=28, dec=22.51, rad=1.0):
"""
Check result file
Parameters
----------
filename : str
Event list file name
nevents : int, optional
Expected number of events
dec : float, optional
Expected Declination (deg)
rad : float, optional
Expected radius (deg)
"""
# Open result file
events = gammalib.GCTAEventList(filename)
# Check event list
self._check_events(events, nevents=nevents, dec=dec, rad=rad)
# Return
return
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
#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')
ebounds.append(e_min, e_max)
#Allocate event list
events = gammalib.GCTAEventList(eventfile)
obs.eventfile(eventfile)
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)
obs.id(str(number))
parser.add_argument("-v", "--verbose", action="count", default=0)
args = parser.parse_args()
# events with this attributes:
# dir() # GCTAInstDir. CTA instrument direction. measured/reconstructed direction of an event
# energy()
# event_id() # event identificator 1..N-1
# index() # event index 0..N
# mc_id() # Monte Carlo id, 1 is event from source, 2 is from background
# phase() # Always 0.0 (?)
# time()
events = []
try:
events_list = gammalib.GCTAEventList(
args.input_file
) # http://cta.irap.omp.eu/gammalib/doxygen/classGCTAEventList.html
for ev in events_list:
events.append(ev)
except:
g_obss = gammalib.GObservations(args.input_file)
for gcta_obs in g_obss:
if gcta_obs.has_events():
events_list = gcta_obs.events() # GCTAEventList
for ev in events_list:
events.append(ev)
data = {'l': [], 'b': [], 'ene': [], 'mc_id': [], 'detx': [], 'dety': []}
cnt = collections.Counter()
for ev in events:
gcta_inst_dir = ev.dir()
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.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 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 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 _test_ctobssim_python(self):
"""
Test ctobssim from Python
"""
# Allocate ctobssim
sim = ctools.ctobssim()
# Check that empty ctobssim tool holds an empty observation
self.test_value(sim.obs().size(), 0, 'Check number of observations')
# Check that saving saves an empty model definition file
sim['outevents'] = 'ctobssim_py0.fits'
sim['logfile'] = 'ctobssim_py0.log'
sim.logFileOpen()
sim.save()
self.test_assert(not os.path.isfile('ctobssim_py0.fits'),
'Check that no event list has been created')
# Check that clearing does not lead to an exception or segfault
sim.clear()
# Now set ctobssim parameters
sim = ctools.ctobssim()
sim['inmodel'] = self._model
sim['caldb'] = self._caldb
sim['irf'] = self._irf
sim['ra'] = 83.63
sim['dec'] = 22.01
sim['rad'] = 2.0
sim['tmin'] = '2020-01-01T00:00:00'
sim['tmax'] = '2020-01-01T00:05:00'
sim['emin'] = 1.0
sim['emax'] = 100.0
sim['outevents'] = 'ctobssim_py1.fits'
sim['logfile'] = 'ctobssim_py1.log'
sim['chatter'] = 2
# Run tool
sim.logFileOpen()
sim.run()
# Check content of observation
self._test_observation(sim)
self._test_list(sim.obs()[0].events(), 261)
# Save events
sim.save()
# Load counts cube and check content.
evt = gammalib.GCTAEventList('ctobssim_py1.fits')
self._test_list(evt, 261)
# Copy ctobssim tool
cpy_sim = sim.copy()
# Retrieve observation and check content of copy
self._test_observation(cpy_sim)
self._test_list(cpy_sim.obs()[0].events(), 261)
# Execute copy of ctobssim tool again, now with a higher chatter
# level than before
cpy_sim['outevents'] = 'ctobssim_py2.fits'
cpy_sim['logfile'] = 'ctobssim_py2.log'
cpy_sim['chatter'] = 3
cpy_sim['publish'] = True
cpy_sim.logFileOpen() # Needed to get a new log file
cpy_sim.execute()
# Load counts cube and check content.
evt = gammalib.GCTAEventList('ctobssim_py2.fits')
self._test_list(evt, 261)
# Set-up observation container
pnts = [{'ra': 83.63, 'dec': 21.01},
{'ra': 84.63, 'dec': 22.01}]
obs = obsutils.set_obs_list(pnts, caldb=self._caldb, irf=self._irf,
duration=300.0, rad=3.0)
# Set-up ctobssim tool from observation container
sim = ctools.ctobssim(obs)
sim['inmodel'] = self._model
sim['outevents'] = 'ctobssim_py3.xml'
sim['logfile'] = 'ctobssim_py3.log'
sim['chatter'] = 3
# Double maximum event range
max_rate = sim.max_rate()
sim.max_rate(2.0*max_rate)
self.test_value(sim.max_rate(), 2.0*max_rate, 1.0e-3,
'Check setting of maximum event rate')
# Run ctobssim tool
sim.logFileOpen()
sim.run()
# Retrieve observation and check content
self._test_observation(sim, nobs=2, pnts=pnts)
self._test_list(sim.obs()[0].events(), 3630)
self._test_list(sim.obs()[1].events(), 3594)
# Save events
sim.save()
# Load events
obs = gammalib.GObservations('ctobssim_py3.xml')
# Retrieve observation and check content
self._test_list(obs[0].events(), 3630)
self._test_list(obs[1].events(), 3594)
# Return
return
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 _test_ctobssim_python(self):
"""
Test ctobssim from Python
"""
# Set-up ctobssim
sim = ctools.ctobssim()
sim['inmodel'] = self._model
sim['outevents'] = 'events.fits'
sim['caldb'] = self._caldb
sim['irf'] = self._irf
sim['ra'] = 83.63
sim['dec'] = 22.01
sim['rad'] = 10.0
sim['tmin'] = 0.0
sim['tmax'] = 1800.0
sim['emin'] = 0.1
sim['emax'] = 100.0
# Run tool
sim.run()
# Check content of observation
self._test_observation(sim)
self._test_list(sim.obs()[0].events(), 6881)
# Save events
sim.save()
# Load counts cube and check content.
evt = gammalib.GCTAEventList('events.fits')
self._test_list(evt, 6881)
# Set-up observation container
pnts = [{'ra': 83.63, 'dec': 21.01},
{'ra': 84.63, 'dec': 22.01},
{'ra': 83.63, 'dec': 23.01},
{'ra': 82.63, 'dec': 22.01}]
obs = obsutils.set_obs_list(pnts, caldb=self._caldb, irf=self._irf)
# Set-up ctobssim from observation container
sim = ctools.ctobssim(obs)
sim['outevents'] = 'sim_events.xml'
sim['inmodel'] = self._model
# Run tool
sim.run()
# Retrieve observation and check content
self._test_observation(sim, nobs=4, pnts=pnts)
self._test_list(sim.obs()[0].events(), 6003)
self._test_list(sim.obs()[1].events(), 6084)
self._test_list(sim.obs()[2].events(), 5955)
self._test_list(sim.obs()[3].events(), 6030)
# Save events
sim.save()
# Load events
obs = gammalib.GObservations('sim_events.xml')
# Retrieve observation and check content
self._test_list(obs[0].events(), 6003)
self._test_list(obs[1].events(), 6084)
self._test_list(obs[2].events(), 5955)
self._test_list(obs[3].events(), 6030)
# Set-up ctobssim with invalid event file
sim = ctools.ctobssim()
sim['inmodel'] = 'model_file_that_does_not_exist.xml'
sim['outevents'] = 'events.fits'
sim['caldb'] = self._caldb
sim['irf'] = self._irf
sim['ra'] = 83.63
sim['dec'] = 22.01
sim['rad'] = 10.0
sim['tmin'] = 0.0
sim['tmax'] = 1800.0
sim['emin'] = 0.1
sim['emax'] = 100.0
# Run ctbin tool
self.test_try('Run ctobssim with invalid model file')
try:
sim.run()
self.test_try_failure()
except:
self.test_try_success()
# Return
return
