def ctmodel(self, log=False, debug=False):
'''
Create ctmodel instance with given parameters
Parameters
---------
log : save or not the log file
debug : debug mode or not. This will print a lot of information
'''
self.info("Running ctmodel to create model map")
if self.m_obs:
model = ct.ctmodel(self.m_obs)
else:
model = ct.ctmodel()
for k in self.config.keys():
try:
for kk in self.config[k].keys():
if model._has_par(kk):
model[kk] = self.config[k][kk]
except:
if model._has_par(k):
model[k] = self.config[k]
model["inobs"] = join(self.workdir,
self.config['file']["selectedevent"])
model["incube"] = join(self.workdir, self.config['file']["cube"])
model["outcube"] = join(self.workdir, self.config['file']["model"])
# Optionally open the log file
if log:
model.logFileOpen()
# Optionally switch-on debugging model
if debug:
model["debug"].boolean(True)
if self.verbose:
print model
# Run ctbin application. This will loop over all observations in
# the container and bin the events in counts maps
model.run()
model.save()
if self.m_obs:
# Make a deep copy of the observation that will be returned
# (the ctbin object will go out of scope one the function is
# left)
self.m_obs = model.obs().copy()
def ctmodel(self,obsXml= None, log=False,debug=False, **kwargs):
'''
Create ctmodel instance with given parameters
Parameters
---------
log : save or not the log file
debug : debug mode or not. This will print a lot of information
'''
self.info("Running ctmodel to create model map")
self.model= ct.ctmodel()
self._fill_app( self.model,log=log,debug=debug, **kwargs)
self.model["incube"] = join(self.outdir,self.config['file']["cntcube"])
self.model["outcube"] = join(self.outdir,self.config['file']["model"])
if self.verbose:
print self.model
# Run ctmodel application. This will loop over all observations in
# the container and bin the events in counts maps
self.model.run()
self.model.save()
self.info("Saved Model cube to {0:s}".format(self.model["outcube"]))
del self.model
def create_modcube(obs, cntcube):
"""
Create model cube
Parameters
----------
obs : `~gammalib.GObservations`
Observation container
cntcube : `~gammalib.GCTAEventCube`
Counts cube
Returns
-------
modcube : `~gammalib.GCTAEventCube`
Model cube
"""
# Setup task parameters
ctmodel = ctools.ctmodel(obs)
ctmodel.cube(cntcube)
# Generate model cube
ctmodel.run()
# Extract model cube
modcube = ctmodel.cube().copy()
# Return model cube
return modcube
def _sim(self, seed):
"""
Return a simulated observation container
Parameters
----------
seed : int
Random number generator seed
Returns
-------
sim : `~gammalib.GObservations`
Simulated observation container
"""
# If observation is a counts cube then simulate events from the counts
# cube model ...
if self.obs().size() == 1 and self.obs()[0].eventtype() == 'CountsCube':
# If no counts cube model exists then compute it now
if self._model == None:
model = ctools.ctmodel(self.obs())
model['debug'] = self['debug'].boolean()
model['chatter'] = self['chatter'].integer()
model.run()
self._model = model.cube().copy() # Save copy for persistence
# Allocate random number generator
ran = gammalib.GRan()
# Get copy of model map
counts = self._model.counts().copy()
# Randomize counts
for i in range(counts.npix()):
counts[i] = ran.poisson(counts[i])
# Copy observations
sim = self.obs().copy()
# Set counts map
sim[0].events().counts(counts)
# ... otherwise simuate events from the observation container (works
# only for event lists
else:
sim = obsutils.sim(self.obs(),
seed = seed,
log = self._log_clients,
debug = self['debug'].boolean(),
nthreads = 1)
# Return simulated observation
return sim
def _sim(self, seed):
"""
Return a simulated observation container
Parameters
----------
seed : int
Random number generator seed
Returns
-------
sim : `~gammalib.GObservations`
Simulated observation container
"""
# If observation is a counts cube then simulate events from the counts
# cube model ...
if self.obs().size() == 1 and self.obs()[0].eventtype() == 'CountsCube':
# If no counts cube model exists then compute it now
if self._model == None:
model = ctools.ctmodel(self.obs())
model['debug'] = self['debug'].boolean()
model['chatter'] = self['chatter'].integer()
model.run()
self._model = model.cube().copy() # Save copy for persistence
# Allocate random number generator
ran = gammalib.GRan()
# Get copy of model map
counts = self._model.counts().copy()
# Randomize counts
for i in range(counts.npix()):
counts[i] = ran.poisson(counts[i])
# Copy observations
sim = self.obs().copy()
# Set counts map
sim[0].events().counts(counts)
# ... otherwise simuate events from the observation container (works
# only for event lists
else:
sim = obsutils.sim(self.obs(),
seed = seed,
log = self._log_clients,
debug = self['debug'].boolean())
# Return simulated observation
return sim
def test_functional(self):
"""
Test ctmodel functionnality.
"""
# Set-up ctmodel from scratch
model = ctools.ctmodel()
model["incube"] = "NONE"
model["outcube"] = "modmap.fits"
model["inmodel"] = self.model_name
model["inobs"] = "NONE"
model["expcube"] = "NONE"
model["psfcube"] = "NONE"
model["bkgcube"] = "NONE"
model["caldb"] = self.caldb
model["irf"] = self.irf
model["rad"] = 5
model["ra"] = 83.63
model["dec"] = 22.01
model["tmin"] = 0
model["tmax"] = 1800
model["emin"] = 0.1
model["emax"] = 100
model["enumbins"] = 20
model["nxpix"] = 200
model["nypix"] = 200
model["binsz"] = 0.02
model["coordsys"] = "CEL"
model["proj"] = "CAR"
model["xref"] = 83.63
model["yref"] = 22.01
# Run tool
self.test_try("Run ctmodel")
try:
model.run()
self.test_try_success()
except:
self.test_try_failure("Exception occured in ctmodel.")
# Save counts cube
self.test_try("Save model cube")
try:
model.save()
self.test_try_success()
except:
self.test_try_failure("Exception occured in saving model cube.")
# Return
return
def test_functional(self):
"""
Test ctmodel functionnality.
"""
# Set-up ctmodel from scratch
model = ctools.ctmodel()
model["incube"].filename("NONE")
model["outcube"].filename("modmap.fits")
model["inmodel"].filename(self.model_name)
model["inobs"].filename("NONE")
model["expcube"].filename("NONE")
model["psfcube"].filename("NONE")
model["bkgcube"].filename("NONE")
model["caldb"].string(self.caldb)
model["irf"].string(self.irf)
model["rad"].real(5.0)
model["ra"].real(83.63)
model["dec"].real(22.01)
model["tmin"].real(0.0)
model["tmax"].real(1800.0)
model["emin"].real(0.1)
model["emax"].real(100.0)
model["enumbins"].integer(20)
model["nxpix"].integer(200)
model["nypix"].integer(200)
model["binsz"].real(0.02)
model["coordsys"].string("CEL")
model["proj"].string("CAR")
model["xref"].real(83.63)
model["yref"].real(22.01)
# Run tool
self.test_try("Run ctmodel")
try:
model.run()
self.test_try_success()
except:
self.test_try_failure("Exception occured in ctmodel.")
# Save counts cube
self.test_try("Save model cube")
try:
model.save()
self.test_try_success()
except:
self.test_try_failure("Exception occured in saving model cube.")
# Return
return
def sim(src="cCrab"): #bkg, Crabbkg
"Simulates acceptance ccube and model cube"
print 30 * "-" + "\n", "Simulating", src + "\n" + 30 * "-"
#Simulate observation
sim = ctools.ctobssim()
sim["inmodel"] = modeldir + src + ".xml"
sim["outevents"] = outdir + "events_" + src + ".fits"
sim["caldb"] = caldb
sim["irf"] = irf
sim["ra"] = ra
sim["dec"] = dec
sim["rad"] = 10.0
sim["tmin"] = 0.0
sim["tmax"] = tsim
sim["emin"] = emin
sim["emax"] = emax
sim["edisp"] = False
sim.execute()
#Bin data into a cube
ctbin = ctools.ctbin()
ctbin["inobs"] = outdir + "events_" + src + ".fits"
ctbin["outcube"] = outdir + "ccube_" + src + ".fits"
ctbin["ebinalg"] = "LOG"
ctbin["emin"] = emin
ctbin["emax"] = emax
ctbin["enumbins"] = enumbins
ctbin["nxpix"] = npix
ctbin["nypix"] = npix
ctbin["binsz"] = binsz
ctbin["coordsys"] = "CEL"
ctbin["xref"] = ra
ctbin["yref"] = dec
ctbin["proj"] = "AIT"
ctbin.execute()
#Create model cube
ctmodel = ctools.ctmodel()
ctmodel["inobs"] = outdir + "events_" + src + ".fits"
ctmodel["inmodel"] = modeldir + src + ".xml"
ctmodel["incube"] = outdir + "ccube_" + src + ".fits"
ctmodel["caldb"] = "prod2"
ctmodel["caldb"] = caldb
ctmodel["irf"] = irf
ctmodel["outcube"] = outdir + "mcube_" + src + ".fits"
ctmodel["edisp"] = False
ctmodel.execute()
def _test_python(self):
"""
Test ctmodel from Python
"""
# Set-up ctmodel from scratch
model = ctools.ctmodel()
model['incube'] = 'NONE'
model['outcube'] = 'ctmodel_py1.fits'
model['inmodel'] = self._model
model['inobs'] = 'NONE'
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['bkgcube'] = 'NONE'
model['caldb'] = self._caldb
model['irf'] = self._irf
model['rad'] = 5
model['ra'] = 83.63
model['dec'] = 22.01
model['tmin'] = 0
model['tmax'] = 1800
model['emin'] = 0.1
model['emax'] = 100
model['enumbins'] = 20
model['nxpix'] = 200
model['nypix'] = 200
model['binsz'] = 0.02
model['coordsys'] = 'CEL'
model['proj'] = 'CAR'
model['xref'] = 83.63
model['yref'] = 22.01
model['logfile'] = 'ctmodel_py1.log'
model['chatter'] = 2
# Run ctmodel tool
model.logFileOpen() # Make sure we get a log file
model.run()
model.save()
# Check result file
self._check_result_file('ctmodel_py1.fits')
# 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 observation into logger
self._log_observations(gammalib.NORMAL, self.obs(), 'Observation')
# If a counts and model cube are specified then load them as sky map
if self._use_maps:
countmap = gammalib.GSkyMap(self['inobs'].filename())
modelmap = gammalib.GSkyMap(self['modcube'].filename())
# ... otherwise build a counts cube and model cube
else:
# Do not build counts cube if we have already one in the observation
# container
if self._skip_binning:
cta_counts_cube = gammalib.GCTAEventCube(self.obs()[0].events())
# ... otherwise generate one now from the event list
else:
# Write header
self._log_header1(gammalib.TERSE, 'Generate binned map (ctbin)')
# Create countsmap
binning = ctools.ctbin(self.obs())
binning['xref'] = self['xref'].real()
binning['yref'] = self['yref'].real()
binning['proj'] = self['proj'].string()
binning['coordsys'] = self['coordsys'].string()
binning['ebinalg'] = self['ebinalg'].string()
binning['nxpix'] = self['nxpix'].integer()
binning['nypix'] = self['nypix'].integer()
binning['binsz'] = self['binsz'].real()
if self['ebinalg'].string() == 'FILE':
binning['ebinfile'] = self['ebinfile'].filename().file()
else:
binning['enumbins'] = self['enumbins'].integer()
binning['emin'] = self['emin'].real()
binning['emax'] = self['emax'].real()
binning['chatter'] = self['chatter'].integer()
binning['clobber'] = self['clobber'].boolean()
binning['debug'] = self['debug'].boolean()
binning.run()
# Retrieve counts cube
cta_counts_cube = binning.cube()
# Assign GCTAEventCube to skymap
countmap = cta_counts_cube.counts()
# Write header
self._log_header1(gammalib.TERSE, 'Generate model map (ctmodel)')
# Create model map
model = ctools.ctmodel(self.obs())
model.cube(cta_counts_cube)
model['chatter'] = self['chatter'].integer()
model['clobber'] = self['clobber'].boolean()
model['debug'] = self['debug'].boolean()
model['edisp'] = self['edisp'].boolean()
model.run()
# Get model map into GSkyMap object
modelmap = model.cube().counts().copy()
# Calculate residual maps
# Note that we need a special
# construct here to avoid memory leaks. This seems to be a SWIG feature
# as SWIG creates a new object when calling binning.cube()
countmap1 = countmap.copy()
countmap1.stack_maps()
modelmap.stack_maps()
self._resmap = obsutils.residuals(self,countmap1,modelmap)
# Optionally publish map
if self['publish'].boolean():
self.publish()
# 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 input parameters into logger
if self.logTerse():
self.log_parameters()
self.log("\n")
# Write observation into logger
if self.logTerse():
self.log("\n")
self.log.header1("Observation")
self.log(str(self.obs))
self.log("\n")
# Use input file directly if given
if self.m_use_maps:
countmap = gammalib.GSkyMap(self["inobs"].filename())
modelmap = gammalib.GSkyMap(self.m_modcube)
else:
if self.m_skip_binning:
cta_counts_cube = gammalib.GCTAEventCube(self.obs[0].events().clone())
else:
# Write header
if self.logTerse():
self.log("\n")
self.log.header1("Generate binned map (ctbin)")
# Create countsmap
bin = ctools.ctbin(self.obs)
bin["nxpix"].integer(self.m_nxpix)
bin["nypix"].integer(self.m_nypix)
bin["proj"].string(self.m_proj)
bin["coordsys"].string(self.m_coordsys)
bin["xref"].real(self.m_xref)
bin["yref"].real(self.m_yref)
bin["enumbins"].integer(self.m_enumbins)
bin["ebinalg"].string(self.m_ebinalg)
bin["emin"].real(self.m_emin)
bin["emax"].real(self.m_emax)
bin["binsz"].real(self.m_binsz)
bin["chatter"].integer(self.m_chatter)
bin["clobber"].boolean(self.m_clobber)
bin["debug"].boolean(self.m_debug)
bin.run()
# Retrieve counts cube
cta_counts_cube = bin.cube()
# Assign GCTAEventCube to skymap
countmap = cta_counts_cube.map()
# Write header
if self.logTerse():
self.log("\n")
self.log.header1("Generate model map (ctmodel)")
# Create model map
model = ctools.ctmodel(self.obs)
model.cube(cta_counts_cube)
model["chatter"].integer(self.m_chatter)
model["clobber"].boolean(self.m_clobber)
model["debug"].boolean(self.m_debug)
model["edisp"].boolean(self.m_edisp)
model.run()
# Get model map into GSkyMap object
modelmap = model.cube().map().copy()
# Store counts map as residual map. Note that we need a
# special construct here to avoid memory leaks. This seems
# to be a SWIG feature as SWIG creates a new object when
# calling bin.cube()
#residualmap = bin.cube().map()
self.resmap = countmap.copy()
self.resmap.stack_maps()
modelmap.stack_maps()
# Continue calculations depending on given algorithm
if self.m_algorithm == "SUB":
# Subtract maps
self.resmap -= modelmap
elif self.m_algorithm == "SUBDIV":
# Subtract and divide by model map
self.resmap -= modelmap
self.resmap /= modelmap
#for pixel in modelmap:
# if pixel != 0.0:
# pixel = 1.0/pixel
#self.resmap *= modelmap
elif self.m_algorithm == "SUBDIVSQRT":
# subtract and divide by sqrt of model map
self.resmap -= modelmap
self.resmap /= modelmap.sqrt()
#for pixel in modelmap:
# if pixel != 0.0:
# pixel = 1.0/math.sqrt(pixel)
#self.resmap *= modelmap
else:
# Raise error if algorithm is unkown
raise TypeError("Algorithm \""+self.m_algorithm+"\" not known")
# Return
return
def model_cube(output_dir,
map_reso,
map_coord,
map_fov,
emin,
emax,
enumbins,
ebinalg,
edisp=False,
stack=True,
inmodel_usr=None,
outmap_usr=None,
logfile=None,
silent=False):
"""
Compute a model cube.
http://cta.irap.omp.eu/ctools/users/reference_manual/ctmodel.html
Parameters
----------
- output_dir (str): directory where to get input files and
save outputs
- map_reso (float): the resolution of the map (can be an
astropy.unit object, or in deg)
- map_coord (float): a skycoord object that give the center of the map
- map_fov (float): the field of view of the map (can be an
astropy.unit object, or in deg)
- emin/emax (float): min and max energy in TeV
- enumbins (int): the number of energy bins
- ebinalg (str): the energy binning algorithm
- stack (bool): do we use stacking of individual event files or not
- inmodel_usr (str): use this keyword to pass non default inmodel
- outmap_usr (str): use this keyword to pass non default outmap
- silent (bool): use this keyword to print information
Outputs
--------
"""
npix = utilities.npix_from_fov_def(map_fov, map_reso)
model = ctools.ctmodel()
if stack:
model['inobs'] = output_dir + '/Ana_Countscube.fits'
else:
model['inobs'] = output_dir + '/Ana_ObsDef.xml'
if inmodel_usr is None:
model['inmodel'] = output_dir + '/Ana_Model_Output.xml'
else:
model['inmodel'] = inmodel_usr
model['incube'] = 'NONE'
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['edispcube'] = 'NONE'
model['bkgcube'] = 'NONE'
if stack:
model['incube'] = output_dir + '/Ana_Countscube.fits'
model['expcube'] = output_dir + '/Ana_Expcube.fits'
model['psfcube'] = output_dir + '/Ana_Psfcube.fits'
if edisp:
model['edispcube'] = output_dir + '/Ana_Edispcube.fits'
model['bkgcube'] = output_dir + '/Ana_Bkgcube.fits'
model['caldb'] = 'NONE'
model['irf'] = 'NONE'
model['edisp'] = edisp
if outmap_usr is None:
model['outcube'] = output_dir + '/Ana_Model_Cube.fits'
else:
model['outcube'] = outmap_usr
model['ra'] = 'NONE'
model['dec'] = 'NONE'
model['rad'] = 'NONE'
model['tmin'] = 'NONE'
model['tmax'] = 'NONE'
model['deadc'] = 'NONE'
model['ebinalg'] = ebinalg
model['emin'] = emin.to_value('TeV')
model['emax'] = emax.to_value('TeV')
model['enumbins'] = enumbins
model['ebinfile'] = 'NONE'
model['usepnt'] = False
model['nxpix'] = npix
model['nypix'] = npix
model['binsz'] = map_reso.to_value('deg')
model['coordsys'] = 'CEL'
model['proj'] = 'TAN'
model['xref'] = map_coord.icrs.ra.to_value('deg')
model['yref'] = map_coord.icrs.dec.to_value('deg')
if logfile is not None: model['logfile'] = logfile
if logfile is not None: model.logFileOpen()
model.execute()
if logfile is not None: model.logFileClose()
if not silent:
print(model)
print('')
return model
binn = ctools.ctbin() binn["inobs"] = outfile binn["outcube"] = cntcube binn["coordsys"] = "CEL" binn["proj"] = "CAR" binn["ebinalg"] = "LOG" binn["xref"] = centerx binn["yref"] = centery binn["nxpix"] = nxpix binn["nypix"] = nypix binn["binsz"] = binsz binn["enumbins"] = enumbins binn["emin"] = emin binn["emax"] = emax binn["debug"] = True binn.execute() #PRODUCE MODELCUBE mod = ctools.ctmodel() mod["inobs"] = outfile mod["inmodel"] = input_model mod["outcube"] = modcube mod["incube"] = cntcube mod["expcube"] = "NONE" mod["psfcube"] = "NONE" mod["bkgcube"] = "NONE" mod["caldb"] = caldb_ mod["irf"] = irf_ mod["debug"] = True mod.execute()
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 observation into logger
if self._logTerse():
self._log("\n")
self._log.header1("Observation")
self._log(str(self._obs))
self._log("\n")
# Use input file directly if given
if self._use_maps:
countmap = gammalib.GSkyMap(self["inobs"].filename())
modelmap = gammalib.GSkyMap(self._modcube)
else:
# ...
if self._skip_binning:
cta_counts_cube = gammalib.GCTAEventCube(self._obs[0].events().clone())
# ...
else:
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Generate binned map (ctbin)")
# Create countsmap
bin = ctools.ctbin(self._obs)
bin["nxpix"].integer(self._nxpix)
bin["nypix"].integer(self._nypix)
bin["proj"].string(self._proj)
bin["coordsys"].string(self._coordsys)
bin["xref"].real(self._xref)
bin["yref"].real(self._yref)
bin["enumbins"].integer(self._enumbins)
bin["ebinalg"].string(self._ebinalg)
bin["emin"].real(self._emin)
bin["emax"].real(self._emax)
bin["binsz"].real(self._binsz)
bin["chatter"].integer(self._chatter)
bin["clobber"].boolean(self._clobber)
bin["debug"].boolean(self._debug)
bin.run()
# Retrieve counts cube
cta_counts_cube = bin.cube()
# Assign GCTAEventCube to skymap
countmap = cta_counts_cube.counts()
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Generate model map (ctmodel)")
# Create model map
model = ctools.ctmodel(self._obs)
model.cube(cta_counts_cube)
model["chatter"].integer(self._chatter)
model["clobber"].boolean(self._clobber)
model["debug"].boolean(self._debug)
model["edisp"].boolean(self._edisp)
model.run()
# Get model map into GSkyMap object
modelmap = model.cube().counts().copy()
# Store counts map as residual map. Note that we need a
# special construct here to avoid memory leaks. This seems
# to be a SWIG feature as SWIG creates a new object when
# calling bin.cube()
#residualmap = bin.cube().counts()
self._resmap = countmap.copy()
self._resmap.stack_maps()
modelmap.stack_maps()
# Continue calculations depending on given algorithm
if self._algorithm == "SUB":
# Subtract maps
self._resmap -= modelmap
elif self._algorithm == "SUBDIV":
# Subtract and divide by model map
self._resmap -= modelmap
self._resmap /= modelmap
#for pixel in modelmap:
# if pixel != 0.0:
# pixel = 1.0/pixel
#self._resmap *= modelmap
elif self._algorithm == "SUBDIVSQRT":
# subtract and divide by sqrt of model map
self._resmap -= modelmap
self._resmap /= modelmap.sqrt()
#for pixel in modelmap:
# if pixel != 0.0:
# pixel = 1.0/math.sqrt(pixel)
#self._resmap *= modelmap
else:
# Raise error if algorithm is unkown
raise TypeError("Algorithm \""+self._algorithm+"\" not known")
# Optionally publish map
if self._publish:
self.publish()
# Return
return
def _test_python(self):
"""
Test ctmodel from Python
"""
# Allocate ctmodel
model = ctools.ctmodel()
# Check that empty ctmodel tool holds an empty model cube
self._check_cube(model.cube(), nx=0, ny=0, nebins=0)
# Check that saving does not nothing
model['outcube'] = 'ctmodel_py0.fits'
model['logfile'] = 'ctmodel_py0.log'
model.logFileOpen()
model.save()
self.test_assert(not os.path.isfile('ctmodel_py0.fits'),
'Check that no model cube has been created')
# Check that clearing does not lead to an exception or segfault
model.clear()
# Now set ctmodel parameters
model['incube'] = 'NONE'
model['inmodel'] = self._model
model['inobs'] = 'NONE'
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['bkgcube'] = 'NONE'
model['caldb'] = self._caldb
model['irf'] = self._irf
model['rad'] = 5
model['ra'] = 83.63
model['dec'] = 22.01
model['tmin'] = 0
model['tmax'] = 1800
model['ebinalg'] = 'LOG'
model['emin'] = 1.0
model['emax'] = 100.0
model['enumbins'] = 5
model['nxpix'] = 40
model['nypix'] = 40
model['binsz'] = 0.1
model['coordsys'] = 'CEL'
model['proj'] = 'CAR'
model['xref'] = 83.63
model['yref'] = 22.01
model['outcube'] = 'ctmodel_py1.fits'
model['logfile'] = 'ctmodel_py1.log'
model['chatter'] = 2
# Run ctmodel tool
model.logFileOpen() # Make sure we get a log file
model.run()
model.save()
# Check result file
self._check_result_file('ctmodel_py1.fits')
# Copy ctmodel tool
cpy_model = model.copy()
# Check model cube of ctmodel copy
self._check_cube(cpy_model.cube())
# Execute copy of ctmodel tool again, now with a higher chatter
# level than before
cpy_model['outcube'] = 'ctmodel_py2.fits'
cpy_model['logfile'] = 'ctmodel_py2.log'
cpy_model['publish'] = True
cpy_model['chatter'] = 3
cpy_model.logFileOpen() # Needed to get a new log file
cpy_model.execute()
# Check result file
self._check_result_file('ctmodel_py2.fits')
# Now clear copy of ctmodel tool
cpy_model.clear()
# Check that the cleared copy has also cleared the model cube
self._check_cube(cpy_model.cube(), nx=0, ny=0, nebins=0)
# Get mixed observation container
obs = self._obs_mixed()
# Setup ctmodel tool from observation container and get model cube
# definition from counts cube
model = ctools.ctmodel(obs)
model.models(gammalib.GModels(self._model))
model['incube'] = self._cntcube
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['bkgcube'] = 'NONE'
model['caldb'] = self._caldb
model['irf'] = self._irf
model['outcube'] = 'ctmodel_py3.fits'
model['logfile'] = 'ctmodel_py3.log'
model['chatter'] = 4
# Execute ctmodel tool
model.logFileOpen() # Needed to get a new log file
model.execute()
# Check result file
self._check_result_file('ctmodel_py3.fits', nx=20, ny=20, nebins=5)
# Publish with name
model.publish('My model')
# Setup ctmodel from event list FITS file
model = ctools.ctmodel()
model['inobs'] = self._events
model['incube'] = 'NONE'
model['inmodel'] = self._model
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['edispcube'] = 'NONE'
model['bkgcube'] = 'NONE'
model['caldb'] = self._caldb
model['irf'] = self._irf
model['rad'] = 5
model['ra'] = 83.63
model['dec'] = 22.01
model['tmin'] = 0
model['tmax'] = 1800
model['ebinalg'] = 'LOG'
model['emin'] = 1.0
model['emax'] = 100.0
model['enumbins'] = 5
model['nxpix'] = 40
model['nypix'] = 40
model['binsz'] = 0.1
model['coordsys'] = 'CEL'
model['proj'] = 'CAR'
model['xref'] = 83.63
model['yref'] = 22.01
model['outcube'] = 'ctmodel_py4.fits'
model['logfile'] = 'ctmodel_py4.log'
model['chatter'] = 2
# Run ctmodel tool
model.logFileOpen() # Make sure we get a log file
model.execute()
# Check result file
self._check_result_file('ctmodel_py4.fits')
# Setup ctmodel from observation definition XML file
model = ctools.ctmodel()
model['inobs'] = self._obs_unbinned
model['incube'] = 'NONE'
model['inmodel'] = self._model
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['edispcube'] = 'NONE'
model['bkgcube'] = 'NONE'
model['caldb'] = self._caldb
model['irf'] = self._irf
model['rad'] = 5
model['ra'] = 83.63
model['dec'] = 22.01
model['tmin'] = 0
model['tmax'] = 1800
model['ebinalg'] = 'LOG'
model['emin'] = 1.0
model['emax'] = 100.0
model['enumbins'] = 5
model['nxpix'] = 40
model['nypix'] = 40
model['binsz'] = 0.1
model['coordsys'] = 'CEL'
model['proj'] = 'CAR'
model['xref'] = 83.63
model['yref'] = 22.01
model['outcube'] = 'ctmodel_py5.fits'
model['logfile'] = 'ctmodel_py5.log'
model['chatter'] = 2
# Run ctmodel tool
model.logFileOpen() # Make sure we get a log file
model.execute()
# Check result file
self._check_result_file('ctmodel_py5.fits')
# Setup ctmodel for stacked IRF
model = ctools.ctmodel()
model['inobs'] = 'NONE'
model['incube'] = 'NONE'
model['inmodel'] = self._bkgmodel
model['expcube'] = self._expcube
model['psfcube'] = self._psfcube
model['edispcube'] = 'NONE'
model['bkgcube'] = self._bkgcube
model['edisp'] = False
model['rad'] = 5
model['ra'] = 83.63
model['dec'] = 22.01
model['tmin'] = 0
model['tmax'] = 1800
model['ebinalg'] = 'LOG'
model['emin'] = 1.0
model['emax'] = 100.0
model['enumbins'] = 5
model['nxpix'] = 40
model['nypix'] = 40
model['binsz'] = 0.1
model['coordsys'] = 'CEL'
model['proj'] = 'CAR'
model['xref'] = 83.63
model['yref'] = 22.01
model['outcube'] = 'ctmodel_py6.fits'
model['logfile'] = 'ctmodel_py6.log'
model['chatter'] = 2
# Run ctmodel tool
model.logFileOpen() # Make sure we get a log file
model.execute()
# Check result file
self._check_result_file('ctmodel_py6.fits')
# Setup ctmodel for stacked IRF using energy dispersion
model = ctools.ctmodel()
model['inobs'] = 'NONE'
model['incube'] = 'NONE'
model['inmodel'] = self._bkgmodel
model['expcube'] = self._expcube
model['psfcube'] = self._psfcube
model['edispcube'] = self._edispcube
model['bkgcube'] = self._bkgcube
model['edisp'] = True
model['rad'] = 5
model['ra'] = 83.63
model['dec'] = 22.01
model['tmin'] = 0
model['tmax'] = 1800
model['ebinalg'] = 'LOG'
model['emin'] = 1.0
model['emax'] = 100.0
model['enumbins'] = 5
model['nxpix'] = 40
model['nypix'] = 40
model['binsz'] = 0.1
model['coordsys'] = 'CEL'
model['proj'] = 'CAR'
model['xref'] = 83.63
model['yref'] = 22.01
model['outcube'] = 'ctmodel_py7.fits'
model['logfile'] = 'ctmodel_py7.log'
model['chatter'] = 2
# Run ctmodel tool
model.logFileOpen() # Make sure we get a log file
model.execute()
# Check result file
self._check_result_file('ctmodel_py7.fits')
# Return
return
def _test_python(self):
"""
Test ctmodel from Python
"""
# Allocate ctmodel
model = ctools.ctmodel()
# Check that empty ctmodel tool holds an empty model cube
self._check_cube(model.cube(), nx=0, ny=0, nebins=0)
# Check that saving does not nothing
model['outcube'] = 'ctmodel_py0.fits'
model['logfile'] = 'ctmodel_py0.log'
model.logFileOpen()
model.save()
self.test_assert(not os.path.isfile('ctmodel_py0.fits'),
'Check that no model cube has been created')
# Check that clearing does not lead to an exception or segfault
model.clear()
# Now set ctmodel parameters
model['incube'] = 'NONE'
model['inmodel'] = self._model
model['inobs'] = 'NONE'
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['bkgcube'] = 'NONE'
model['caldb'] = self._caldb
model['irf'] = self._irf
model['rad'] = 5
model['ra'] = 83.63
model['dec'] = 22.01
model['tmin'] = 0
model['tmax'] = 1800
model['ebinalg'] = 'LOG'
model['emin'] = 0.1
model['emax'] = 100.0
model['enumbins'] = 10
model['nxpix'] = 40
model['nypix'] = 40
model['binsz'] = 0.1
model['coordsys'] = 'CEL'
model['proj'] = 'CAR'
model['xref'] = 83.63
model['yref'] = 22.01
model['outcube'] = 'ctmodel_py1.fits'
model['logfile'] = 'ctmodel_py1.log'
model['chatter'] = 2
# Run ctmodel tool
model.logFileOpen() # Make sure we get a log file
model.run()
model.save()
# Check result file
self._check_result_file('ctmodel_py1.fits')
# Copy ctmodel tool
cpy_model = model.copy()
# Check model cube of ctmodel copy
self._check_cube(cpy_model.cube())
# Execute copy of ctmodel tool again, now with a higher chatter
# level than before
cpy_model['outcube'] = 'ctmodel_py2.fits'
cpy_model['logfile'] = 'ctmodel_py2.log'
cpy_model['publish'] = True
cpy_model['chatter'] = 3
cpy_model.logFileOpen() # Needed to get a new log file
cpy_model.execute()
# Check result file
self._check_result_file('ctmodel_py2.fits')
# Now clear copy of ctmodel tool
cpy_model.clear()
# Check that the cleared copy has also cleared the model cube
self._check_cube(cpy_model.cube(), nx=0, ny=0, nebins=0)
# Get mixed observation container
obs = self._obs_mixed()
# Setup ctmodel tool from observation container and get model cube
# definition from counts cube
model = ctools.ctmodel(obs)
model.models(gammalib.GModels(self._model))
model['incube'] = self._cntcube
model['expcube'] = 'NONE'
model['psfcube'] = 'NONE'
model['bkgcube'] = 'NONE'
model['caldb'] = self._caldb
model['irf'] = self._irf
model['outcube'] = 'ctmodel_py3.fits'
model['logfile'] = 'ctmodel_py3.log'
model['chatter'] = 4
# Execute ctmodel tool
model.logFileOpen() # Needed to get a new log file
model.execute()
# Check result file
self._check_result_file('ctmodel_py3.fits', nx=200, ny=200, nebins=20)
# Publish with name
model.publish('My model')
# Return
return
def _residuals_3D(self, obs, models, obs_id, ccube=None):
"""
Calculate residuals for 3D observation
Parameters
----------
obs : `~gammalib.GCTAObservation`
CTA observation
models : `~gammalib.GModels`
Models
obs_id : str
Observation ID
ccube : `~gammalib.GCTAEventCube', optional
Count cube with stacked events lists
Returns
-------
result : dict
Residual result dictionary
"""
# Create observation container with observation
obs_container = gammalib.GObservations()
obs_container.append(obs)
obs_container.models(models)
# If binned data already exist set the evlist_info dictionary to have
# attribute was_list False
if obs.eventtype() == 'CountsCube' or ccube is not None:
evlist_info = {'was_list': False}
# ... otherwise bin now
else:
# we remember if we binned an event list so that we can
# mask only the ROI for residual calculation
msg = 'Setting up binned observation'
self._log_string(gammalib.NORMAL, msg)
obs_container, evlist_info = self._bin_evlist(obs_container)
# Calculate Model and residuals. If model cube is provided load
# it
if self._use_maps:
modcube = gammalib.GCTAEventCube(self['modcube'].filename())
# ... otherwise calculate it now
else:
msg = 'Computing model cube'
self._log_string(gammalib.NORMAL, msg)
modelcube = ctools.ctmodel(obs_container)
if ccube is not None:
modelcube.cube(ccube)
modelcube['edisp'] = self['edisp'].boolean()
modelcube.run()
modcube = modelcube.cube().copy()
# Extract cntcube for residual computation
if ccube is not None:
cntcube = ccube
else:
cntcube = obs_container[0].events().copy()
# Derive count spectra from cubes
msg = 'Computing counts, model, and residual spectra'
self._log_string(gammalib.NORMAL, msg)
counts = self._cube_to_spectrum(cntcube, evlist_info)
model = self._cube_to_spectrum(modcube, evlist_info)
# Calculate residuals
residuals = obsutils.residuals(self, counts, model)
# Extract energy bounds
ebounds = cntcube.ebounds().copy()
# Set result dictionary
result = {
'obs_id': obs_id,
'ebounds': ebounds,
'counts_on': counts,
'model': model,
'residuals_on': residuals
}
# Calculate models of individual components if requested
if self['components'].boolean():
# Loop over components
for component in models:
# Log action
self._log_value(gammalib.NORMAL, 'Computing model component',
component.name())
# Set model cube models to individual component
model_cont = gammalib.GModels()
model_cont.append(component)
modelcube.obs().models(model_cont)
# Reset base cube that was modified internally by ctmodel
if ccube is not None:
modelcube.cube(ccube)
# Run model cube
modelcube['edisp'] = self['edisp'].boolean()
modelcube.run()
# Extract spectrum of individual component
modcube = modelcube.cube().copy()
model = self._cube_to_spectrum(modcube, evlist_info)
# Append to results
result['component_%s' % component.name()] = model
# Return result
return result
