def make_dirs(self):
# Create gammalib Caldb
caldb = gammalib.GCaldb()
# Set calibration directory
self.cal_dir = "data"
self.cal_dir += "/"+self.m_mission.lower()
self.cal_dir += "/"+self.m_instrument.lower()
self.cal_dir += "/bcf/"+self.m_rspname
# Set absolute path
self.base_dir = caldb.rootdir() +"/data"
self.base_dir += "/"+self.m_mission.lower()
self.base_dir += "/"+self.m_instrument.lower()
# Set directory for irf file
self.rsp_dir = caldb.rootdir() + "/" + self.cal_dir
# Create directories and log information
if not os.path.isdir(self.rsp_dir):
if self.logExplicit():
self.log(gammalib.parformat("Directory"))
self.log(self.rsp_dir)
self.log("\n")
os.makedirs(self.rsp_dir)
else:
if self.logExplicit():
self.log(gammalib.parformat("Directory (existing)"))
self.log(self.rsp_dir)
self.log("\n")
# Return
return
def save(self):
"""
Save calibration database FITS file.
"""
# Write header into logger
if self._logTerse():
self._log("\n")
self._log.header1("Save calibration database")
# Set response filename
filename = self._rsp_dir + "/" + self._outfile
# Write filenames into logger
if self._logNormal():
self._log(gammalib.parformat("CALDB index file"))
self._log(self._caldb_inx.filename().url())
self._log("\n")
self._log(gammalib.parformat("Response file"))
self._log(filename)
self._log("\n")
# Save caldb index file
self._caldb_inx.save(self._clobber())
# Save response file
self._irf_fits.saveto(filename, self._clobber())
# Return
return
def save(self):
"""
Save TS map and remove slices if requested.
"""
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Save TS map")
# Get output filename in case it was not read ahead
outmap = self["outmap"].filename()
# Log filename
if self._logTerse():
self._log(gammalib.parformat("TS map file"))
self._log(outmap.url())
self._log("\n")
# Create FITS file
fits = gammalib.GFits()
# Write TS map into primary
self._tsmap.write(fits)
# Loop over maps and write them to fits
for i in range(len(self._maps)):
self._maps[i].write(fits)
# Set map names as extensions
for i in range(len(self._mapnames)):
fits[i + 1].extname(self._mapnames[i])
# Check if map is fully done
done = True
for pix in self._statusmap:
if pix < 0.5:
done = False
break
# Write status map if we are not done yet
if not done:
self._statusmap.write(fits)
fits[fits.size() - 1].extname("STATUS MAP")
# Save FITS file
fits.saveto(outmap, self._clobber())
# Delete TS input maps if requested
if self._delete:
for filename in self._merged_files:
os.remove(filename)
if self._logTerse():
self._log(gammalib.parformat("Deleted input file"))
self._log(filename)
self._log("\n")
# Return
return
def run(self):
"""
Run the script
"""
# Switch screen logging on in debug mode
if self._logDebug():
self._log.cout(True)
# Get parameters
self._get_parameters()
# Write header
if self._logTerse():
self._log('\n')
self._log.header1('Merge models')
# Initialise model container
self._models = gammalib.GModels()
# Loop over model files
for f in self._files:
# Construct container from XML file
models = gammalib.GModels(f)
# Log number of models to add
if self._logTerse():
nmodels = models.size()
if nmodels == 0:
self._log(gammalib.parformat('Add no model from file'))
elif nmodels == 1:
self._log(gammalib.parformat('Add 1 model from file'))
else:
self._log(
gammalib.parformat('Add %d models from file' %
nmodels))
self._log(f)
self._log('\n')
# Extend model container by adding all models in the model file
self._models.extend(models)
# Log total number of models
if self._logTerse():
self._log(gammalib.parformat('Models after merging'))
self._log(self._models.size())
self._log('\n')
# Return
return
def save(self):
"""
Save spectrum.
"""
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Save spectrum")
# Get outmap parameter
outfile = self["outfile"].filename()
# Continue only filename and residual map are valid
if self._fits != None:
# Log file name
if self._logTerse():
self._log(gammalib.parformat("Spectrum file"))
self._log(outfile.url())
self._log("\n")
# Save spectrum
self._fits.saveto(outfile, self._clobber)
# Return
return
def save(self):
"""
Save model definition XML file
"""
# Write header
if self._logTerse():
self._log('\n')
self._log.header1('Save models')
# Get output filename in case it was not read ahead
outmodel = self['outmodel'].filename()
# If file exists and clobber flag is false then raise an exception
if outmodel.exists() and not self._clobber:
msg = 'Cannot save ""+outmodel.url()+"": File already exists. '\
'Use parameter clobber=yes to allow overwriting of files.'
raise RuntimeError(msg)
else:
# Log filename
if self._logTerse():
self._log(gammalib.parformat('Model definition XML file'))
self._log(outmodel.url())
self._log('\n')
# Save models
self._models.save(outmodel)
# Return
return
def save(self):
"""
Save runlist.
"""
# Write header
if self._logTerse():
self._log('\n')
self._log.header1('Save runlist')
# Get filename
outfile = self['outfile'].filename()
# Check for clobber
if outfile.exists() and not self._clobber():
if self._logTerse():
self._log('File ' + outfile + ' already exists. ')
self._log('Set clobber=yes to overwrite file.')
self._log('\n')
else:
# Log file name
if self._logTerse():
self._log(gammalib.parformat('Runlist file'))
self._log(outfile.url())
self._log('\n')
# Write runs to file
f = open(outfile.url(), 'w')
for run in self._runs:
f.write(str(run) + ' \n')
f.close()
# Return
return
def save(self):
"""
Save observation definition XML file.
"""
# Write header and filename into logger
if self._logTerse():
self._log('\n')
self._log.header1('Save observation definition XML file')
# Get output filename in case it was not read ahead
outobs = self['outobs'].filename()
# Check if observation definition XML file is valid
if outobs.url() != 'NONE':
# Log filename
if self._logTerse():
self._log(gammalib.parformat('Observation XML file'))
self._log(outobs.url())
self._log('\n')
# Save observation definition XML file
self._obs.save(outobs)
# Return
return
def save(self):
"""
Save light curve.
"""
# Write header
if self._logTerse():
self._log('\n')
self._log.header1('Save light curve')
# Get light curve filename
outfile = self["outfile"].filename()
# Continue only filename and residual map are valid
if self._fits != None:
# Log file name
if self._logTerse():
self._log(gammalib.parformat("Light curve file"))
self._log(outfile.url())
self._log("\n")
# Save spectrum
self._fits.saveto(outfile, self._clobber())
# Return
return
def save(self):
"""
Save residual map.
"""
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Save residual map")
# Get outmap parameter
outmap = self["outmap"].filename()
# Continue only filename and residual map are valid
if self._resmap != None:
# Log file name
if self._logTerse():
self._log(gammalib.parformat("Residual map file"))
self._log(outmap.url())
self._log("\n")
# Save residual map
self._resmap.save(outmap, self._clobber)
# Return
return
def _make_dirs(self):
"""
Make CALDB directories.
"""
# Write header into logger
if self._logTerse():
self._log("\n")
self._log.header2("Creating directory structure")
# Create calibration database
caldb = gammalib.GCaldb(self["rootdir"].string())
# Set calibration directory
self._cal_dir = "data"
self._cal_dir += "/"+self._mission.lower()
self._cal_dir += "/"+self._caldb.lower()
self._cal_dir += "/bcf/"+self["irf"].string()
# Set absolute path
self._base_dir = caldb.rootdir() +"/data"
self._base_dir += "/"+self._mission.lower()
self._base_dir += "/"+self._caldb.lower()
# Set directory for irf file
self._rsp_dir = caldb.rootdir() + "/" + self._cal_dir
# Log resulting FITS table
if self._logNormal():
self._log(gammalib.parformat("Calibration directory"))
self._log(self._cal_dir)
self._log("\n")
self._log(gammalib.parformat("Base directory"))
self._log(self._base_dir)
self._log("\n")
if not os.path.isdir(self._rsp_dir):
self._log(gammalib.parformat("IRF directory"))
else:
self._log(gammalib.parformat("IRF directory (existing)"))
self._log(self._rsp_dir)
self._log("\n")
# Create IRF directory is it does not yet exist
if not os.path.isdir(self._rsp_dir):
os.makedirs(self._rsp_dir)
# Return
return
def _adjust_model_pars(self):
"""
Adjust model parameters dependent on user parameters.
"""
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Adjust model parameters")
# Adjust model parameters dependent on input user parameters
for model in self._obs.models():
# Set TS flag for all models to false. The source of interest
# will be set to true later
model.tscalc(False)
# Log model name
if self._logNormal():
self._log.header3(model.name())
# Deal with the source of interest
if model.name() == self._srcname:
if self["calc_ts"].boolean():
model.tscalc(True)
elif (self["fix_bkg"].boolean()
and model.classname() != "GModelSky"):
for par in model:
if par.is_free():
par.fix()
if self._logNormal():
self._log(gammalib.parformat(par.name()))
self._log("fixed\n")
elif (self["fix_srcs"].boolean()
and model.classname() == "GModelSky"):
for par in model:
if par.is_free():
par.fix()
if self._logNormal():
self._log(gammalib.parformat(par.name()))
self._log("fixed\n")
# Return
return
def save(self):
"""
Save models to ds9 region file if required
"""
# Get output filename in case it was not read ahead
self._ds9file = self["ds9file"].filename()
# Check if DS9 file is valid
if self._ds9file != "NONE":
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Save models in DS9 file")
# Log filename
if self._logTerse():
self._log(gammalib.parformat("DS9 filename"))
self._log(self._ds9file.url())
self._log("\n")
# Open file
f = open(self._ds9file.url(), "w")
# Write coordinate system
f.write("fk5\n")
# Loop over models
for model in self._models:
# Continue only if point source or extended source model
if (model.type() == "PointSource"
or model.type() == "ExtendedSource"):
line = self._model2ds9string(model)
if len(line):
f.write(line + "\n")
# Logging for diffuse components
elif model.type() == "DiffuseSource":
self._log("Skipping diffuse model \"" + model.name() +
"\"\n")
# Logging for background components
else:
if self._logExplicit():
self._log("Skipping background model \"" +
model.name() + "\"\n")
# Close file
f.close()
# Return
return
def save(self):
"""
Save pointings into DS9 region file
This method saves all pointing directions that are found in the
observation container into a DS9 region file. If "NONE" is
specified for the "ds9file" parameter the method does nothing.
"""
# Get output filename in case it was not read ahead
ds9file = self['ds9file'].filename()
# Check if DS9 file is valid
if ds9file.url() != 'NONE':
# Write header
if self._logTerse():
self._log('\n')
self._log.header1('Save pointings in DS9 file')
# Log filename
if self._logTerse():
self._log(gammalib.parformat('DS9 filename'))
self._log(ds9file.url())
self._log('\n')
# Open file
f = open(ds9file.url(), 'w')
# Write coordinate system
f.write('fk5\n')
# Loop over pointings
for i in range(len(self._pnt_ra)):
# Create string
line = 'point('
line += str(self._pnt_ra[i]) + ',' + str(
self._pnt_dec[i]) + ')'
line += ' # point=cross 20 width=3\n'
# Write to file
f.write(line)
# Close file
f.close()
# Return
return
def save(self):
"""
Save model cube.
"""
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Save model cube")
# Get outfile parameter
outfile = self["outfile"].filename()
# Log file name
if self._logTerse():
self._log(gammalib.parformat("Model cube"))
self._log(outfile.url())
self._log("\n")
# Save event cube
self._cube.save(outfile, self._clobber())
# Return
return
def run(self):
"""
Run the script.
"""
# Switch screen logging on in debug mode
if self._logDebug():
self._log.cout(True)
# Get parameters
self._get_parameters()
# Write header into logger
if self._logTerse():
self._log("\n")
self._log.header1("Merge TS maps")
# Initialise file to start with
file0 = ""
self._merged_files = []
# Test files for the entry status map. Use the first one to appear
# useful
for fitsfile in self._files:
# Skip file if it's not a FITS file
if not gammalib.GFilename(fitsfile).is_fits():
if self._logExplicit():
self._log(gammalib.parformat("Skip file"))
self._log(fitsfile)
self._log(" (not a FITS file)\n")
continue
# Open FITS file
fits = gammalib.GFits(fitsfile)
# If file contains a status map then use it
if fits.contains("STATUS MAP"):
fits.close()
file0 = fitsfile
if self._logTerse():
self._log(gammalib.parformat("Initial TS map file"))
self._log(fitsfile)
count = self._get_number_of_ts_pixels(fitsfile)
self._log(" (%d TS pixels computed)" % count)
self._log("\n")
break
# ... otherwise signal that file is useless
else:
fits.close()
if self._logExplicit():
self._log(gammalib.parformat("Skip file"))
self._log(fitsfile)
self._log(" (no \"STATUS MAP\" extension)\n")
continue
# Signal if no suitable file was found
if file0 == "":
if self._logTerse():
self._log("None of the provided files seems to be a sliced "
"TS map file (none has a \"STATUS MAP\" "
"extension).\n")
# ... otherwise merge files
else:
# Copy file list
workfiles = self._files
# Remove entry which will be used to initalise the map
workfiles.remove(file0)
# Initialise map from first file
self._init_ts_map(file0)
# Append to added files
self._merged_files.append(file0)
# Loop over files
for fitsfile in workfiles:
# Skip if file is not FITS
if not gammalib.GFilename(fitsfile).is_fits():
if self._logExplicit():
self._log(gammalib.parformat("Skip file"))
self._log(fitsfile)
self._log(" (not a FITS file)\n")
continue
# Open FITS file
fits = gammalib.GFits(fitsfile)
# Skip if file does not contain status map
if not fits.contains("STATUS MAP"):
fits.close()
if self._logExplicit():
self._log(gammalib.parformat("Skip file"))
self._log(fitsfile)
self._log(" (no \"STATUS MAP\" extension)\n")
continue
# Close FITS file
fits.close()
# Logging
if self._logTerse():
self._log(gammalib.parformat("Merge TS map file"))
self._log(fitsfile)
count = self._get_number_of_ts_pixels(fitsfile)
self._log(" (%d TS pixels computed)" % count)
self._log("\n")
# Merge TS map
self._merge_ts_map(fitsfile)
# Append FITS file to merged files
self._merged_files.append(fitsfile)
# Return
return
def _make_irf_file(self):
"""
Creates an IRF FITS file.
"""
# Write header into logger
if self._logTerse():
self._log("\n")
self._log.header2("Creating IRF file")
# Get response for the observation
rsp = self._observation.response()
# Extract response file names
fname_aeff = rsp.aeff().filename()
fname_psf = rsp.psf().filename()
fname_edisp = rsp.edisp().filename()
fname_bkg = rsp.background().filename()
# Log filenames
if self._logNormal():
self._log.header3("IRF input files")
self._log(gammalib.parformat("Effective area"))
self._log(fname_aeff.url())
self._log("\n")
self._log(gammalib.parformat("Point spread function"))
self._log(fname_psf.url())
self._log("\n")
self._log(gammalib.parformat("Energy dispersion"))
self._log(fname_edisp.url())
self._log("\n")
self._log(gammalib.parformat("Background rate"))
self._log(fname_bkg.url())
self._log("\n")
# Open FITS files of response components
fits_aeff = gammalib.GFits(fname_aeff)
fits_psf = gammalib.GFits(fname_psf)
fits_edisp = gammalib.GFits(fname_edisp)
fits_bkg = gammalib.GFits(fname_bkg)
# Get extension names
ext_aeff = fname_aeff.extname("EFFECTIVE AREA")
ext_psf = fname_psf.extname("POINT SPREAD FUNCTION")
ext_edisp = fname_edisp.extname("ENERGY DISPERSION")
ext_bkg = fname_bkg.extname("BACKGROUND")
# Create empty FITS file
fits = gammalib.GFits()
# Append IRF component to FITS file
fits.append(fits_aeff[ext_aeff])
fits.append(fits_psf[ext_psf])
fits.append(fits_edisp[ext_edisp])
fits.append(fits_bkg[ext_bkg])
# Log resulting FITS file
if self._logNormal():
self._log(str(fits))
self._log("\n")
if self._logExplicit():
self._log(str(fits[ext_aeff].header()))
self._log("\n")
self._log(str(fits[ext_psf].header()))
self._log("\n")
self._log(str(fits[ext_edisp].header()))
self._log("\n")
self._log(str(fits[ext_bkg].header()))
self._log("\n")
# Return fits file
return fits
def handle_matrix():
"""
Illustrates the handling of matrix. Although we use in this example the
GMatrix class, the same operations can be performed on a sparse matrix
GMatrixSparse or a symmetric matrix GMatrixSymmetric.
"""
# Create matrix with 4 rows and 5 columns
matrix = gammalib.GMatrix(4, 5)
# Get matrix attributes
number_of_rows = matrix.rows() # Will be 4
number_of_columns = matrix.columns() # Will be 5
number_of_elements = matrix.size() # Will be 20=4*5
matrix_fill = matrix.fill() # Will be 0
matrix_minimum = matrix.min() # Will be 0
matrix_maximum = matrix.max() # Will be 0
matrix_sum = matrix.sum() # Will be 0
# Dump some information
print("Attributes of an empty GMatrix:")
print(gammalib.parformat("Matrix rows") + str(number_of_rows))
print(gammalib.parformat("Matrix columns") + str(number_of_columns))
print(gammalib.parformat("Matrix elements") + str(number_of_elements))
print(gammalib.parformat("Matrix fill") + str(matrix_fill))
print(gammalib.parformat("Smallest matrix element") + str(matrix_minimum))
print(gammalib.parformat("Largest matrix element") + str(matrix_maximum))
print(gammalib.parformat("Sum of all element") + str(matrix_sum))
# Set all matrix elements to 2.0
matrix.set(2.0)
# Now set all matrix elements to specific values
for row in range(matrix.rows()):
for column in range(matrix.columns()):
matrix[row, column] = row + column * matrix.rows() + 1.5
# Get matrix attributes
matrix_fill = matrix.fill() # Will be 1
matrix_minimum = matrix.min() # Will be 1.5
matrix_maximum = matrix.max() # Will be 20.5
matrix_sum = matrix.sum() # Will be 220.0
# Dump some information
print("Attributes of a filled GMatrix:")
print(gammalib.parformat("Matrix fill") + str(matrix_fill))
print(gammalib.parformat("Smallest matrix element") + str(matrix_minimum))
print(gammalib.parformat("Largest matrix element") + str(matrix_maximum))
print(gammalib.parformat("Sum of all element") + str(matrix_sum))
# Perform some matrix operations
other_matrix = matrix.copy() # Use copy() to create a deep copy
sum_matrix = matrix + other_matrix # Add two matrices
zero_matrix = matrix - other_matrix # Subtract two matrices
other_matrix += matrix # Add-on matrix
other_matrix -= matrix # Subtract off matrix
other_matrix *= 2.0 # Multiply elements by 2
other_matrix /= 2.0 # Divide elements by 2
neg_matrix = -matrix # Negate matrix
abs_matrix = neg_matrix.abs() # Absolute value of elements
# And now some more tricky operations
transposed = matrix.transpose() # First transpose matrix
mult_matrix = matrix * transposed # Now we can multiply it
other_matrix *= transposed # Multiply on matrix
#inverted = matrix.invert() # NOT YET IMPLEMENTED
vector = gammalib.GVector(5) # Allocate vector
multiplied = matrix * vector # Vector multiplication
# Compare matrices
if matrix == abs_matrix:
print("Yes, got it!")
if matrix != transposed:
print("Got it again!")
# Copy columns one-by-one from one matrix into another
destination = gammalib.GMatrix(4, 5)
for column in range(matrix.columns()):
vector = matrix.column(column) # Extract column
destination.column(column, vector) # Set column
# Add columns one-by-one from one matrix into another
destination = matrix.copy()
for column in range(matrix.columns()):
vector = matrix.column(column) # Extract column
destination.add_to_column(column, vector) # Add column
# Copy rows one-by-one from one matrix into another
destination = gammalib.GMatrix(4, 5)
for row in range(matrix.rows()):
vector = matrix.row(row) # Extract row
destination.row(row, vector) # Set row
# Add rows one-by-one from one matrix into another
destination = matrix.copy()
for row in range(matrix.rows()):
vector = matrix.row(row) # Extract row
destination.add_to_row(row, vector) # Add row
# 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
if self._logTerse():
self._log("\n")
self._log.header1("Observation")
self._log(str(self._obs))
self._log("\n")
# Adjust model parameters dependent on user parameters
self._adjust_model_pars()
# Write header
if self._logTerse():
self._log("\n")
self._log.header1("Generate lightcurve")
# Initialise list of result dictionaries
results = []
# Get source parameters
pars = self._get_free_par_names()
# Loop over time bins
for i in range(self._tbins.size()):
# Get time boundaries
tmin = self._tbins.tstart(i)
tmax = self._tbins.tstop(i)
# Write time bin into header
if self._logTerse():
self._log.header2("MJD " + str(tmin.mjd()) + "-" +
str(tmax.mjd()))
# Compute time bin center and time width
twidth = 0.5 * (tmax - tmin) # in seconds
tmean = tmin + twidth
# Initialise result dictionary
result = {
'mjd': tmean.mjd(),
'e_mjd': twidth / gammalib.sec_in_day,
'ts': 0.0,
'ulimit': 0.0,
'pars': pars,
'values': {}
}
# Log information
if self._logExplicit():
self._log.header3("Selecting events")
# Select events
select = ctools.ctselect(self._obs)
select["emin"] = self["emin"].real()
select["emax"] = self["emax"].real()
select["tmin"] = tmin.convert(self._time_reference())
select["tmax"] = tmax.convert(self._time_reference())
select["rad"] = "UNDEFINED"
select["ra"] = "UNDEFINED"
select["dec"] = "UNDEFINED"
select.run()
# Retrieve observation
obs = select.obs()
# If a stacked analysis is requested then bin the events
# and compute the stacked response functions and setup
# an observation container with a single stacked observation.
if self._stacked:
obs = self._bin_observation(obs)
# Header
if self._logExplicit():
self._log.header3("Fitting the data")
# Do maximum likelihood model fitting
like = ctools.ctlike(obs)
like["edisp"] = self["edisp"].boolean()
like.run()
# Skip bin if no event was present
if like.obs().logL() == 0.0:
# Signal skipping of bin
if self._logTerse():
self._log(gammalib.parformat("Warning"))
self._log("No event in this time bin, skip bin.\n")
# Set all results to 0
for par in pars:
result['values'][par] = 0.0
result['values']["e_" + par] = 0.0
# Append result
results.append(result)
# Continue with next time bin
continue
# Retrieve model fitting results for source of interest
source = like.obs().models()[self._srcname]
# Extract parameter values
for par in pars:
result['values'][par] = source.spectral()[par].value()
result['values']["e_" + par] = source.spectral()[par].error()
# Calculate upper limit (-1 if not computed)
ulimit_value = self._compute_ulimit(like.obs())
if ulimit_value > 0.0:
result['ulimit'] = ulimit_value
# Extract Test Statistic value
if self["calc_ts"].boolean():
result['ts'] = source.ts()
# Append result to list of dictionaries
results.append(result)
# Log results for this time bin
if self._logNormal():
self._log.header3("Results")
pars = self._get_free_par_names()
for par in pars:
value = source.spectral()[par].value()
error = source.spectral()[par].error()
unit = source.spectral()[par].unit()
self._log(gammalib.parformat(par))
self._log(str(value))
self._log(" +/- ")
self._log(str(error))
self._log(" ")
self._log(unit)
self._log("\n")
if result['ulimit'] > 0.0:
self._log(gammalib.parformat("Upper flux limit"))
self._log(str(result['ulimit']) + " ph/cm2/s\n")
if self["calc_ts"].boolean():
self._log(gammalib.parformat("Test Statistic"))
self._log(str(result['ts']) + "\n")
# Create FITS table from results
table = self._create_fits_table(results)
# Create FITS file and append FITS table to FITS file
self._fits = gammalib.GFits()
self._fits.append(table)
# 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 information into logger
if self._logTerse():
self._log('\n')
self._log.header1('Test source')
model = self._obs.models()[self._srcname]
self._log(str(model))
self._log('\n')
# Set log-likelihood to zero
logL0 = 0.0
# Pre-compute null hypothesis if requested
if self._compute_null:
# Write information into logger
if self._logTerse():
self._log('\n')
self._log.header1('Compute null hypothesis')
# Compute null hypothesis
logL0 = self._compute_null_hypothesis()
# Write likelihood into logger
if self._logTerse():
self._log(gammalib.parformat('Source removed'))
self._log(self._srcname)
self._log('\n')
self._log(gammalib.parformat('Log-likelihood'))
self._log(repr(logL0))
self._log('\n')
# Get parameters of TS map ctool
pars = gammalib.GApplicationPars('cttsmap.par')
# Compute total number of jobs
nbins = self._map.npix()
njobs = int(math.ceil(float(nbins) / float(self._bins_per_job)) + 0.1)
# Set parameters to be skipped now, we will deal with them later
skip_pars = ['binmin', 'binmax', 'logL0', 'outmap', 'logfile']
# Set tool name for computation
base_command = 'cttsmap'
# Write information into logger
if self._logTerse():
self._log('\n')
self._log.header1('Create commands')
self._log(gammalib.parformat('Number of cttsmap calls'))
self._log(str(njobs))
self._log('\n')
# Loop over TS map parameters
for par in pars:
# Skip if we deal with them later
if par.name() in skip_pars:
continue
# Skip if they need to be queried
# This way we ensure we pass only parameters
# that were queried before
if self[par.name()].is_query():
continue
# Set TS map parameter according to input from
# this script
par.value(self[par.name()].value())
# Append command to set parameter
base_command += ' ' + par.name() + '=' + par.value()
# Append null hypothesis parameter
base_command += ' logL0=' + repr(logL0)
# Set binning to start from zero
binmin = 0
binmax = 0
# Clear command sequence
self._cmd = []
# Loop over jobs and create commands
for job in range(njobs):
# Set specific outmap file name
outmap = self._outmap.url().replace('.fits',
'_' + str(job) + '.fits')
# Set bin numbers to be computed in this job
binmin = binmax
binmax = binmin + self._bins_per_job
if binmax > nbins:
binmax = nbins
# Setup sliced command
sliced_command = '%s binmin=%s binmax=%s outmap=%s logfile=%s' % \
(base_command, str(binmin), str(binmax),
outmap, outmap.replace('.fits','.log'))
# Append command to list of commands
self._cmd.append(sliced_command)
# Write information into logger
if self._logExplicit():
self._log('\n')
self._log.header2('Commands')
for cmd in self._cmd:
self._log(cmd)
self._log('\n')
self._log('\n')
# Return
return
def handle_matrix():
"""
Illustrates the handling of matrix. Although we use in this example the
GMatrix class, the same operations can be performed on a sparse matrix
GMatrixSparse or a symmetric matrix GMatrixSymmetric.
"""
# Create matrix with 4 rows and 5 columns
matrix = gammalib.GMatrix(4,5)
# Get matrix attributes
number_of_rows = matrix.rows() # Will be 4
number_of_columns = matrix.columns() # Will be 5
number_of_elements = matrix.size() # Will be 20=4*5
matrix_fill = matrix.fill() # Will be 0
matrix_minimum = matrix.min() # Will be 0
matrix_maximum = matrix.max() # Will be 0
matrix_sum = matrix.sum() # Will be 0
# Dump some information
print("Attributes of an empty GMatrix:")
print(gammalib.parformat("Matrix rows")+str(number_of_rows))
print(gammalib.parformat("Matrix columns")+str(number_of_columns))
print(gammalib.parformat("Matrix elements")+str(number_of_elements))
print(gammalib.parformat("Matrix fill")+str(matrix_fill))
print(gammalib.parformat("Smallest matrix element")+str(matrix_minimum))
print(gammalib.parformat("Largest matrix element")+str(matrix_maximum))
print(gammalib.parformat("Sum of all element")+str(matrix_sum))
# Set all matrix elements to 2.0
matrix.set(2.0)
# Now set all matrix elements to specific values
for row in range(matrix.rows()):
for column in range(matrix.columns()):
matrix[row,column] = row + column*matrix.rows() + 1.5
# Get matrix attributes
matrix_fill = matrix.fill() # Will be 1
matrix_minimum = matrix.min() # Will be 1.5
matrix_maximum = matrix.max() # Will be 20.5
matrix_sum = matrix.sum() # Will be 220.0
# Dump some information
print("Attributes of a filled GMatrix:")
print(gammalib.parformat("Matrix fill")+str(matrix_fill))
print(gammalib.parformat("Smallest matrix element")+str(matrix_minimum))
print(gammalib.parformat("Largest matrix element")+str(matrix_maximum))
print(gammalib.parformat("Sum of all element")+str(matrix_sum))
# Perform some matrix operations
other_matrix = matrix.copy() # Use copy() to create a deep copy
sum_matrix = matrix + other_matrix # Add two matrices
zero_matrix = matrix - other_matrix # Subtract two matrices
other_matrix += matrix # Add-on matrix
other_matrix -= matrix # Subtract off matrix
other_matrix *= 2.0 # Multiply elements by 2
other_matrix /= 2.0 # Divide elements by 2
neg_matrix = -matrix # Negate matrix
abs_matrix = neg_matrix.abs() # Absolute value of elements
# And now some more tricky operations
transposed = matrix.transpose() # First transpose matrix
mult_matrix = matrix * transposed # Now we can multiply it
other_matrix *= transposed # Multiply on matrix
#inverted = matrix.invert() # NOT YET IMPLEMENTED
vector = gammalib.GVector(5) # Allocate vector
multiplied = matrix * vector # Vector multiplication
# Compare matrices
if matrix == abs_matrix:
print("Yes, got it!")
if matrix != transposed:
print("Got it again!")
# Copy columns one-by-one from one matrix into another
destination = gammalib.GMatrix(4,5)
for column in range(matrix.columns()):
vector = matrix.column(column) # Extract column
destination.column(column, vector) # Set column
# Add columns one-by-one from one matrix into another
destination = matrix.copy()
for column in range(matrix.columns()):
vector = matrix.column(column) # Extract column
destination.add_to_column(column, vector) # Add column
# Copy rows one-by-one from one matrix into another
destination = gammalib.GMatrix(4,5)
for row in range(matrix.rows()):
vector = matrix.row(row) # Extract row
destination.row(row, vector) # Set row
# Add rows one-by-one from one matrix into another
destination = matrix.copy()
for row in range(matrix.rows()):
vector = matrix.row(row) # Extract row
destination.add_to_row(row, vector) # Add row
# 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
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
