def temporalFun(inTime):
# --------------------
# CREATE TEMPORAL MODEL
# --------------------
#get model name (TDB)
#SpatModel = inTime[0]
SpatModel = "Light"
norm = float(inTime[0])
fitspath = inTime[1]
# set text to be put in the xml file
norm_text = 'parameter scale="' + numdiv(
norm
)[1] + '" name="Normalization" min="0.0" max="1000.0" free="0" value="' + numdiv(
norm)[0] + '"'
if (SpatModel == 'Light'):
temporal = gammalib.GXmlElement(
'temporal type="LightCurve" file="' + fitspath + '"')
temporal.append(gammalib.GXmlElement(norm_text))
else:
print(
"The only supported temporal model is the one with Normalization and a fits file"
)
sys.exit()
return temporal
def _set_response(self, obs, caldb, irf):
"""
Set response for an observation.
The method creates an XML element so that that the response XML
writer will write the database and response name into the
observation definition file.
"""
# Create XML element
xml = gammalib.GXmlElement()
# Append parameter
parameter = 'parameter name="Calibration" database="'+caldb+\
'" response="'+irf+'"'
xml.append(gammalib.GXmlElement(parameter))
# Create CTA response
response = gammalib.GCTAResponseIrf()
response.read(xml)
# Attach response to observation
obs.response(response)
# Return observation
return obs
def __init__(self, *argv):
"""
Constructor
"""
# Initialise application by calling the base class constructor
self._init_cscript(self.__class__.__name__, ctools.__version__, argv)
# Initialise some members
self._obs = gammalib.GObservations()
self._ebounds = gammalib.GEbounds()
self._datapath = os.getenv('VHEFITS', '')
self._prodname = ''
self._xml = gammalib.GXml()
self._models = gammalib.GModels()
self._runlist = []
self._runlistfile = gammalib.GFilename()
self._bkgpars = 0
self._master_indx = ''
self._use_bkg_scale = False
self._ev_hiera = ['']
self._aeff_hiera = ['']
self._psf_hiera = ['']
self._bkg_hiera = ['']
self._edisp_hiera = ['']
self._bkg_mod_hiera = ['']
self._bkg_gauss_norm = 1.0
self._bkg_gauss_index = 0.0
self._bkg_gauss_sigma = 1.0
self._bkg_aeff_index = 0.0
self._bkg_aeff_norm = 1.0
self._bkg_range_factor = 1.0
self._hdu_index = ''
self._obs_index = ''
self._subdir = ''
self._debug = False
# Initialise empty observation definition XML file
self._xml.append(
gammalib.GXmlElement('observation_list '
'title="observation list"'))
# Append an observation list to XML instance
self._xml.append(
gammalib.GXmlElement('observation_list title="observation list"'))
self._xml_obslist = self._xml.element('observation_list', 0)
# Return
return
def _set_irf(self, obs, caldb, irf):
"""
Set response for an observation
The method creates an XML element so that that the response XML
writer will write the database and response name into the
observation definition file.
Parameters
----------
obs : `~gammalib.GCTAObservation`
CTA observation
caldb : str
Calibration database
irf : str
Instrument response function
Returns
obs : `~gammalib.GCTAObservation`
CTA observation with response attached
-------
"""
# Create XML element
xml = gammalib.GXmlElement()
# Append parameter
parameter = 'parameter name="Calibration" database="'+caldb+\
'" response="'+irf+'"'
xml.append(gammalib.GXmlElement(parameter))
# Create CTA response
response = gammalib.GCTAResponseIrf()
response.read(xml)
# Attach response to observation
obs.response(response)
# Return observation
return obs
def manipulate_xml(xml):
"""
Illustrates the manipulation of an XML document.
This function illustrates the manipulation of an XML document by
using the remove(), insert(), set() and extend() methods.
"""
# Remove the third child node containing the processing instruction
# (Note that the third node has the index 2!).
xml.remove(2)
# Insert now at the location where we just removed the processing
# instruction a new child element named 'replacement'. This new
# child element will have four levels of child nodes.
level0 = xml.insert(2, gammalib.GXmlElement('replacement'))
level1 = level0.append('level1')
level2 = level1.append('level2')
level3 = level2.append('level3')
level4 = level3.append('level4')
# Set now a text node at the place of the level4 child node (the
# level4 child node was sitting in the first slot of the level3
# node, hence we have to set the text using the index 0)
level4 = level3.set(
0, gammalib.GXmlText('This text replaces the level 4 child node'))
# We extend the level2 child node by adding four further child nodes
# containg a text node, one comment and one processing instruction.
# In total, the level2 child node now has six childs, four of which
# are elements, one is a comment and one a processing instruction.
#
# We could do this simply using the append method, but we illustrate
# here another case: the extension of a child node using child nodes
# of another element. For this purpose we create first a fresh element
# 'ext'. To this fresh element we append four child nodes which all
# will contain a text node. We furthermore append one comment and one
# processing instruction. Once this is setup we call the extend() method
# to extend the level2 child node.
ext = gammalib.GXmlElement('level2 extension="yes"')
element1 = ext.append('level3')
element2 = ext.append('level3')
element3 = ext.append('level3')
element4 = ext.append('level3')
comment = ext.append(gammalib.GXmlComment('This is a comment'))
pi = ext.append(gammalib.GXmlPI('<?xml-stylesheet type="text/xsl"?>'))
element1.append(gammalib.GXmlText('This is the first element'))
element2.append(gammalib.GXmlText('This is the second element'))
element3.append(gammalib.GXmlText('This is the third element'))
element4.append(gammalib.GXmlText('This is the forth element'))
level2.extend(ext)
# Now we replace the text of the last element in the level2 childs.
# The emphasis is here on 'element'. The comment and the processing
# instruction are NOT elements, they are special markup tags. The
# last 'element' is the forth child node!
#
# Instead of explicitly quoting the index of the forth child, we
# determine the number of elements using the elements() method, and
# we access the last element by using number-1 as the index in the
# element() method.
#
# The text child is then accessed using the [0] index operator. As
# there is only a single text node in the last element, we use the
# index 0.
number = level2.elements()
last = level2.element(number - 1)
text = last[0]
text.text('This replaces the text of the last element')
# Now we change the name of the last element in the level2 childs
# to 'new3' and we benefit to illustrate also how attributes can
# be set. The name change is done using the name() method, attributes
# are manipulated using the attribute() method.
#
# There are three calls to attribute(). The first adds a new attribute
# 'type' with a value of 'none'. As this attribute did not exist before,
# the attribute() method adds it to the element. The same is done by the
# second call which add the attribute 'case' with value 'mixed'. The
# third class modifies the attribute 'type' by giving it a new value of
# 'info'. This illustrates the logic of the attribute() method: if the
# attribute name does not exist the attribute will be added, otherwise
# it will be modified.
#
# Finally, the 'case' attribute is removed using the remove_attribute()
# method.
last.name('new3')
last.attribute('type', 'none')
last.attribute('case', 'mixed')
last.attribute('type', 'info')
last.remove_attribute('case')
# Now we make again a text replacement, but instead of chaning the
# text of the last element we change the text of the last element with
# name 'level3'. This is not the last in the list as we just changed
# the name of the last element to 'new3'. This example illustrates
# how elements can be accessed by name.
number = level2.elements('level3')
text = level2.element('level3', number - 1)[0]
text.text('This replaces the text of the last "level3" element')
# Return XML document
return xml
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()
# Clear models
self._models.clear()
# Log output
msg = 'Looping over %d runs' % len(self._runlist)
self._log_header1(gammalib.TERSE, msg)
# Initialise energy range values for logging
self._ebounds.clear()
# Loop over runs
for obs_id in self._runlist:
# Create selection string
obs_selection = '[OBS_ID==' + str(obs_id) + ']'
# Open HDU index file
hduindx = gammalib.GFits(self._hdu_index + '[HDU_INDEX]' +
obs_selection)
hduindx_hdu = hduindx['HDU_INDEX']
# Initialise types and formats
formats = []
for i in range(hduindx_hdu.nrows()):
formats.append(hduindx_hdu['HDU_CLASS'][i])
# Retrieve filenames
eventfile = self._get_filename(hduindx_hdu, self._ev_hiera,
formats)
aefffile = self._get_filename(hduindx_hdu, self._aeff_hiera,
formats)
psffile = self._get_filename(hduindx_hdu, self._psf_hiera, formats)
edispfile = self._get_filename(hduindx_hdu, self._edisp_hiera,
formats)
bkgfile = self._get_filename(hduindx_hdu, self._bkg_hiera, formats)
# Check for presence of required event file
if not self._is_present(eventfile, obs_id, "event file"):
continue
# Check for presence of required effective area file
if not self._is_present(aefffile, obs_id, "effective area file"):
continue
# Check for presence of required psf file
if not self._is_present(psffile, obs_id, "PSF file"):
continue
# Check for optional energy dispersion file
if not gammalib.GFilename(edispfile).exists():
# Print warning that edisp cannot be used for this observation
msg = ('Warning: observation "%s" has no energy dispersion '
'information' % obs_id)
self._log_string(gammalib.NORMAL, msg)
# Set energy dispersion file as empty
edispfile = ''
# Create a copy of background model hierarchy for this run
run_bkg_mod_hierarchy = list(self._bkg_mod_hiera)
# Check if background file is available
# Remove IRF background from hierarchy if file doesnt exist
if not gammalib.GFilename(bkgfile).exists():
# Set background file as empty
bkgfile = ''
# Check for IRF background in background model hierarchy
if 'irf' in run_bkg_mod_hierarchy:
# Remove IRF background if file doesnt exist
run_bkg_mod_hierarchy.remove('irf')
# Print warning that edisp cannot be used for this
# observation
msg = ('Warning: observation "%s" has no background '
'information (IRF background cannot be used)' %
obs_id)
self._log_string(gammalib.NORMAL, msg)
# Check if background model hierarchy is empty
if len(run_bkg_mod_hierarchy) == 0:
# Skip observation if no background can be used
msg = ('Skipping observation "%s": No background can be '
'used' % obs_id)
self._log_string(gammalib.NORMAL, msg)
continue
else:
# Log if we fall back to next background approach
msg = (
'Observation "%s": Falling back to background "%s"' %
(obs_id, run_bkg_mod_hierarchy[0]))
self._log_string(gammalib.NORMAL, msg)
# Close hdu index file
hduindx.close()
# Initialise background scale
bkg_scale = 1.0
# Check if background scale should be used
if self._use_bkg_scale:
# Read background scale from fits file
obsindx = gammalib.GFits(self._obs_index + '[OBS_INDEX]' +
obs_selection)
bkg_scale = obsindx['OBS_INDEX']['BKG_SCALE'][0]
obsindx.close()
# Open event FITS file
fits = gammalib.GFits(eventfile)
# Get object and telescope strings from event hdu
events = fits[gammalib.GFilename(eventfile).extname()]
object_name = events.string('OBJECT')
telescope = events.string('TELESCOP')
# Close FITS file
fits.close()
# Open effective area file to look for threshold
aeff_fits = gammalib.GFits(aefffile)
aeff_table = aeff_fits[gammalib.GFilename(aefffile).extname()]
# Set energy range from header keyword if present
if aeff_table.has_card('LO_THRES') and aeff_table.has_card(
'HI_THRES'):
# Get safe energy range
run_emin = gammalib.GEnergy(aeff_table.real('LO_THRES'), 'TeV')
run_emax = gammalib.GEnergy(aeff_table.real('HI_THRES'), 'TeV')
# Append to ebounds
self._ebounds.append(run_emin, run_emax)
else:
# Set default values for energy range
run_emin = gammalib.GEnergy(10, 'GeV')
run_emax = gammalib.GEnergy(100, 'TeV')
# Close Aeff fits file
aeff_fits.close()
# Append instrumental background model
self._models.append(
self._iact_background(telescope, obs_id, bkg_scale,
run_bkg_mod_hierarchy[0], run_emin.TeV(),
run_emax.TeV()))
# Append observation to XML and set attributes
obs = self._xml_obslist.append('observation')
obs.attribute('name', object_name)
obs.attribute('id', str(obs_id))
obs.attribute('instrument', telescope)
# Append event file
ev = gammalib.GXmlElement('parameter name="EventList"')
ev.attribute('file', eventfile)
# Append effective area
aeff = gammalib.GXmlElement('parameter name="EffectiveArea"')
aeff.attribute('file', aefffile)
# Append PSF
psf = gammalib.GXmlElement('parameter name="PointSpreadFunction"')
psf.attribute('file', psffile)
# Append energy dispersion
edisp = gammalib.GXmlElement('parameter name="EnergyDispersion"')
edisp.attribute('file', edispfile)
# Append background
bck = gammalib.GXmlElement('parameter name="Background"')
bck.attribute('file', bkgfile)
# Assign events and IRFs to observation
obs.append(ev)
obs.append(aeff)
obs.append(psf)
obs.append(edisp)
obs.append(bck)
# Log the observation ID and object name that has been appended
self._log_value(gammalib.NORMAL, 'Append observation',
'%s ("%s")' % (obs_id, object_name))
# Log the file names of the event and response files
self._log_value(gammalib.EXPLICIT, ' Event file', eventfile)
self._log_value(gammalib.EXPLICIT, ' Effective area file',
aefffile)
self._log_value(gammalib.EXPLICIT, ' Point spread function file',
psffile)
self._log_value(gammalib.EXPLICIT, ' Energy dispersion file',
edispfile)
self._log_value(gammalib.EXPLICIT, ' Background file', bkgfile)
if self._use_bkg_scale:
self._log_value(gammalib.EXPLICIT, ' Background scale',
bkg_scale)
# Append models provided by "inmodel" to the model container
self._append_inmodels()
# Write observation summary
self._write_summary()
# Write warning in no observation could be used from runlist
if self._xml_obslist.size() == 0:
self._log_string(
gammalib.NORMAL, 'WARNING: No observation was '
'appended from specified runlist')
# 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()
# Clear models
self._models.clear()
# Clear xml file and append an observation list
self._xml.clear()
self._xml.append(
gammalib.GXmlElement('observation_list title="observation list"'))
lib = self._xml.element('observation_list', 0)
# Log output
if self._logTerse():
self._log('\n')
self._log.header1('Looping over ' + str(len(self._runlist)) +
' runs')
# Initialise energy range values for logging
self._ebounds.clear()
# Loop over runs
for obs_id in self._runlist:
# Create selection string
obs_selection = '[OBS_ID==' + str(obs_id) + ']'
# Open HDU index file
hduindx = gammalib.GFits(self._hdu_index + '[HDU_INDEX]' +
obs_selection)
hduindx_hdu = hduindx['HDU_INDEX']
# Initialise files and hdu names
eventfile = aefffile = psffile = edispfile = bkgfile = ''
eventhdu = aeffhdu = ''
types = []
formats = []
for i in range(hduindx_hdu.nrows()):
types.append(hduindx_hdu['HDU_TYPE'][i])
formats.append(hduindx_hdu['HDU_CLASS'][i])
# Handle events
index = -1
for version in self._ev_hiera:
n = formats.count(version)
if n > 0:
index = formats.index(version)
break
if index >= 0:
eventfile = os.path.join(self._subdir,
hduindx_hdu['FILE_DIR'][index],
hduindx_hdu['FILE_NAME'][index])
eventhdu = hduindx_hdu['HDU_NAME'][index]
eventfile += '[' + eventhdu + ']'
if not gammalib.GFilename(eventfile).is_fits():
if self._logTerse():
self._log('Skipping observation ' + str(obs_id) +
': eventfile "' + eventfile + '" not found\n')
continue
# Handle Aeff
index = -1
for version in self._aeff_hiera:
n = formats.count(version)
if n > 0:
index = formats.index(version)
break
if index >= 0:
aefffile = os.path.join(self._subdir,
hduindx_hdu['FILE_DIR'][index],
hduindx_hdu['FILE_NAME'][index])
aeffhdu = hduindx_hdu['HDU_NAME'][index]
aefffile += '[' + aeffhdu + ']'
if not gammalib.GFilename(aefffile).is_fits():
if self._logTerse():
self._log('Skipping observation ' + str(obs_id) +
': effective area "' + aefffile +
'" not found\n')
continue
# Handle psf
index = -1
for version in self._psf_hiera:
n = formats.count(version)
if n > 0:
index = formats.index(version)
break
if index >= 0:
psffile = os.path.join(self._subdir,
hduindx_hdu['FILE_DIR'][index],
hduindx_hdu['FILE_NAME'][index])
psffile += '[' + hduindx_hdu['HDU_NAME'][index] + ']'
if not gammalib.GFilename(psffile).is_fits():
if self._logTerse():
self._log('Skipping observation ' + str(obs_id) +
': point spread function "' + psffile +
'" not found\n')
continue
# Handle edisp
index = -1
for version in self._edisp_hiera:
n = formats.count(version)
if n > 0:
index = formats.index(version)
break
if index >= 0:
edispfile = os.path.join(self._subdir,
hduindx_hdu['FILE_DIR'][index],
hduindx_hdu['FILE_NAME'][index])
edispfile += '[' + hduindx_hdu['HDU_NAME'][index] + ']'
if not gammalib.GFilename(edispfile).is_fits():
if self._logTerse():
self._log('Warning: observation ' + str(obs_id) +
' has no energy dispersion "' + edispfile +
'" information\n')
edispfile = ''
# Handle background
index = -1
bkg_mod_hierarchy = list(self._bkg_mod_hiera)
for version in self._bkg_hiera:
n = formats.count(version)
if n > 0:
index = formats.index(version)
break
if index >= 0:
bkgfile = os.path.join(self._subdir,
hduindx_hdu['FILE_DIR'][index],
hduindx_hdu['FILE_NAME'][index])
bkgfile += '[' + hduindx_hdu['HDU_NAME'][index] + ']'
if 'irf' in bkg_mod_hierarchy and not gammalib.GFilename(
bkgfile).is_fits():
bkg_mod_hierarchy.remove('irf')
if self._logTerse():
self._log('Warning: observation ' + str(obs_id) +
' has no background information (file="' +
bkgfile + '"). IRF background cannot be used\n')
bkgfile = ''
if len(bkg_mod_hierarchy) == 0:
if self._logTerse():
self._log('Skipping observation ' + str(obs_id) +
': No background can be used\n')
continue
else:
if self._logTerse():
self._log('Observation ' + str(obs_id) +
': Falling back to background "' +
bkg_mod_hierarchy[0] + '"\n')
# Close hdu index file
hduindx.close()
# Handle background scale information if available
bkg_scale = 1.0
if self._use_bkg_scale:
obsindx = gammalib.GFits(self._obs_index + '[OBS_INDEX]' +
obs_selection)
bkg_scale = obsindx['OBS_INDEX']['BKG_SCALE'][0]
obsindx.close()
# Open fits file to determine the observation name
fits = gammalib.GFits(eventfile)
events = fits[eventhdu]
object_name = events.string('OBJECT')
telescope = events.string('TELESCOP')
# Close FITS file
fits.close()
# Open effective area file to look for threshold
aeff_fits = gammalib.GFits(aefffile)
aeff_table = aeff_fits[aeffhdu]
# Set energy range from header keyword if present
if aeff_table.has_card('LO_THRES') and aeff_table.has_card(
'HI_THRES'):
# Get safe energy range
run_emin = gammalib.GEnergy(aeff_table.real('LO_THRES'), 'TeV')
run_emax = gammalib.GEnergy(aeff_table.real('HI_THRES'), 'TeV')
# Append to ebounds
self._ebounds.append(run_emin, run_emax)
else:
# Set default values for energy range
run_emin = gammalib.GEnergy(10, 'GeV')
run_emax = gammalib.GEnergy(100, 'TeV')
# Close Aeff fits file
aeff_fits.close()
# Append instrumental background model
self._models.append(
self._iact_background(telescope, obs_id, bkg_scale,
bkg_mod_hierarchy[0], run_emin.TeV(),
run_emax.TeV()))
# Logging
if self._logTerse():
self._log('Adding observation ' + str(obs_id) + ' ("' +
object_name + '")\n')
if self._logExplicit():
self._log(' Event file: ' + eventfile + '\n')
self._log(' Effective area: ' + aefffile + '\n')
self._log(' Point spread function: ' + psffile + '\n')
self._log(' Energy dispersion: ' + edispfile + '\n')
self._log(' Background file: ' + bkgfile + '\n')
if self._use_bkg_scale:
self._log(' Background scale: ' + str(bkg_scale) + '\n')
self._log('\n')
# Append observation to XML and set attributes
obs = lib.append('observation')
obs.attribute('name', object_name)
obs.attribute('id', str(obs_id))
obs.attribute('instrument', telescope)
# Append event file
ev = gammalib.GXmlElement('parameter name="EventList"')
ev.attribute('file', eventfile)
# Append effective area
aeff = gammalib.GXmlElement('parameter name="EffectiveArea"')
aeff.attribute('file', aefffile)
# Append PSF
psf = gammalib.GXmlElement('parameter name="PointSpreadFunction"')
psf.attribute('file', psffile)
# Append energy dispersion
edisp = gammalib.GXmlElement('parameter name="EnergyDispersion"')
edisp.attribute('file', edispfile)
# Append background
bck = gammalib.GXmlElement('parameter name="Background"')
bck.attribute('file', bkgfile)
# assign events and IRFs to observation
obs.append(ev)
obs.append(aeff)
obs.append(psf)
obs.append(edisp)
obs.append(bck)
# Continue only if there are observations available
if lib.size():
# Log header of energy range
if self._logTerse():
self._log('\n')
self._log.header3('Energy range of obervation list')
# Logging if energy range is available
if self._ebounds.size() > 0:
# Write energy range into log file
self._log(
str(self._ebounds.emin()) + ' - ' +
str(self._ebounds.emax()))
self._log('\n')
else:
# Write 'not available' into log file
self._log('not available')
self._log('\n')
else:
self._log.header2(
'WARNING: No observation from given runlist available')
# Append models provided by 'inmodels' if necessary
if not self._inmodels == None:
if self._logTerse():
self._log('\n')
self._log.header1('Appending models')
# Loop over input models
for model in self._inmodels:
if self._logTerse():
self._log.header3('Adding model "' + model.name() + '"')
self._models.append(model)
# Return
return
def sim_select_like(sim_yaml, jobs_in, model_xml, background_fits, counter):
"""
:param sim_yaml:
:param jobs_in:
:param model_xml:
:param background_fits:
:param counter:
:return:
"""
#print("----------------------------")
print(model_xml.split('/')[-1], counter)
config_in = yaml.safe_load(open(jobs_in))
ctools_pipe_path = create_path(config_in['exe']['software_path'])
sim_in = yaml.safe_load(open(sim_yaml))
ctobss_params = sim_in['ctobssim']
# find proper IRF name
irf = IRFPicker(sim_in, ctools_pipe_path)
name_irf = irf.irf_pick()
if irf.prod_version == "3b" and irf.prod_number == 0:
caldb = "prod3b"
else:
caldb = f'prod{irf.prod_number}-v{irf.prod_version}'
# loading background (this is a way of doing it without saving any file)
# output.save("name.xml") to save the file
obs_def = gammalib.GObservations()
background_id = f"{str(int(counter) + 1).zfill(6)}"
output = gammalib.GXml()
level0 = gammalib.GXmlElement('observation_list title="observation library"')
level1 = gammalib.GXmlElement(f'observation name="name_source" id="{background_id}" instrument="CTA"')
level2 = gammalib.GXmlElement(f'parameter name="EventList" file="{background_fits}"')
level1.append(level2)
level0.append(level1)
output.append(level0)
obs_def.read(output)
seed = int(counter)*10
# do the simulation
sim = ctools.ctobssim()
sim['inmodel'] = model_xml
sim['caldb'] = caldb
sim['irf'] = name_irf
sim['ra'] = 0
sim['dec'] = 0
sim['rad'] = ctobss_params['radius']
sim['tmin'] = u.Quantity(ctobss_params['time']['t_min']).to_value(u.s)
sim['tmax'] = u.Quantity(ctobss_params['time']['t_max']).to_value(u.s)
sim['emin'] = u.Quantity(ctobss_params['energy']['e_min']).to_value(u.TeV)
sim['emax'] = u.Quantity(ctobss_params['energy']['e_max']).to_value(u.TeV)
sim['seed'] = seed
sim.run()
obs_def.append(sim.obs()[0])
# for obs in obs_def:
# print(obs.id(), obs.nobserved())
select = ctools.ctselect(obs_def)
select['rad'] = 3
select['tmin'] = 0
select['tmax'] = 50
select['emin'] = 0.05
select['emax'] = 1.0
select.run()
def sourceDef(info):
# --------------------
# CREATE SOURCE BRANCH
# --------------------
# spectral and spatial components will be appended to this branch
# 1 branch for each source in the XML model
srcname = info[0]
modelname = info[1] #extract model name for SOURCE
ts = info[2]
#if ver != '': print('--------------------------------')
pointList = ['Point']
extendedList = ['RadDisk', 'RadGauss', 'RadShell', 'EllDisk', 'EllGauss']
diffuseList = ['DiffIso', 'DiffMap', 'DiffMapCube']
bkg_radial = ['BkgGauss', 'Profile', 'Polynom']
bkg_irf = ['CTAIrf']
bkg_cube = ['CTACube']
if (modelname in pointList):
source_txt = 'source type="PointSource" name="' + str(srcname) + '"'
elif (modelname in extendedList):
source_txt = 'source type="ExtendedSource" name="' + str(
srcname) + '"'
elif (modelname in diffuseList):
source_txt = 'source type="DiffuseSource" name="' + str(srcname) + '"'
elif (modelname in bkg_radial):
source_txt = 'source name="Background" type="RadialAcceptance" instrument="CTA"'
elif (modelname in bkg_irf):
source_txt = 'source name="Background" type="CTAIrfBackground" instrument="CTA"'
elif (modelname in bkg_cube):
source_txt = 'source name="Background" type="CTACubeBackground" instrument="CTA"'
else:
print("Mispelled spatial model, open the .txt and check it!")
sys.exit()
if (ts == "1"):
source_txt = source_txt + ' tscalc="1"'
source_branch = gammalib.GXmlElement(source_txt)
if (srcname[0:2] == "BKG"):
if ver != '': print("-----------background-----------")
if ver != '': print('The source ' + srcname + ' is a ' + modelname)
#create SPECTRAL model
spectral = specFun(info[8:]) #string
source_branch.append(spectral)
else:
if ver != '': print("------source: " + srcname + "-------")
if ver != '': print('The source ' + srcname + ' is a ' + modelname)
#create SPECTRAL model
spectral = specFun(info[8:]) #string
source_branch.append(spectral)
if (modelname != 'CTAIrf' and modelname != 'CTACube'):
#create SPATIAL model
spatial = spatFun(info[1:])
source_branch.append(spatial)
#check if the last item is a file fits for the TEMPORAL evolution
if (info[-1][-4:] == 'fits'):
#create TEMPORAL model (use last two item in list, NORMALIZATION and FITS file)
temporal = temporalFun(info[-2:])
source_branch.append(temporal)
if (ts == "1"):
if ver != '': print("TS calculation: yes")
#source_txt=source_txt+' tscalc="1"'
else:
if ver != '': print("TS calculation: no")
return source_branch
def specFun(inSpec):
# --------------------
# CREATE SPECTRAL MODEL
# --------------------
# CHOOSE BETWEEN = "PowerLaw2", "PowerLaw", "NodeFunction", "LogParabola", "Gaussian", "FileFunction", "ExpCutoff", "ConstantValue", "BrokenPowerLaw"
#set spectral model name
SpecModel = inSpec[0]
if (SpecModel == 'CONST'):
#CONSTANT MODEL
if ver != '': print('Spectral model: ' + SpecModel)
norm = float(inSpec[1])
norm_text = 'parameter scale="' + numdiv(
norm
)[1] + '" name="Normalization" min="1e-7" max="1000" free="1" value="' + numdiv(
norm)[0] + '"'
spectral = gammalib.GXmlElement('spectrum type="ConstantValue"')
spectral.append(norm_text)
elif (SpecModel == 'FUNC'):
# FILE FUNCTION
if ver != '': print('Spectral model: ' + SpecModel)
norm = float(inSpec[1])
filepath = inSpec[2]
norm_text = 'parameter scale="' + numdiv(
norm
)[1] + '" name="Normalization" min="1e-7" max="1000" free="1" value="' + numdiv(
norm)[0] + '"'
spectral = gammalib.GXmlElement(
'spectrum type="FileFunction" file="' + filepath + '"')
spectral.append(norm_text)
elif (SpecModel == 'NODE'):
if ver != '': print(SpecModel)
n_param = int(inSpec[1]) #number of parameters
if n_param % 2 != 0:
if ver != '':
print("Wrong number of parameters in NODE SPECTRAL MODEL")
sys.exit()
spectral = gammalib.GXmlElement('spectrum type="NodeFunction"')
values = []
for n in range(2, n_param + 2, 2):
if ver != '': print(inSpec[n])
if ver != '': print(type(inSpec[n]))
values.append(EnConv(inSpec[n], "MeV")) #energy
values.append(inSpec[n + 1]) #intensity
val_x = values[0::2] #select only even characters
val_y = values[1::2] #select only odd characters
if ver != '': print(val_x)
points = [(val_x[i], val_y[i])
for i in range(0, len(val_x))] #making list of points
pointss = sorted(points, key=lambda k: k[1]) #sort points by energy
if ver != '': print(pointss)
for n in range(0, len(pointss)):
energy_text = 'parameter scale="' + str(
pointss[n][0][1]
) + '" name="Energy" min="0.1" max="1.0e20" free="0" value="' + str(
pointss[n][0][0]) + '"'
intens_text = 'parameter scale="1e-07" name="Intensity" min="1e-07" max="1000.0" free="1" value="' + pointss[
n][1] + '"'
node = spectral.append('node')
node.append(energy_text)
node.append(intens_text)
elif (SpecModel == 'PL'):
#POWER LAW MODEL
if ver != '': print('Spectral model: ' + SpecModel)
pref = float(inSpec[1])
index = inSpec[2]
PivotEnergy = EnConv(inSpec[3], "MeV") #convert the energy in MeV
pref_text = 'parameter scale="' + numdiv(
pref
)[1] + '" name="Prefactor" min="1e-7" max="1000" free="1" value="' + numdiv(
pref)[0] + '"'
index_text = 'parameter scale="-1.0" name="Index" min="0.0" max="+10.0" free="1" value="' + index + '"'
energy_text = 'parameter scale="' + str(
PivotEnergy[1]
) + '" name="Scale" min="0.0" max="+10000000.0" free="0" value="' + str(
PivotEnergy[0]) + '"'
spectral = gammalib.GXmlElement('spectrum type="PowerLaw"')
spectral.append(pref_text)
spectral.append(index_text)
spectral.append(energy_text)
elif (SpecModel == 'PL2'):
#POWER LAW 2 MODEL
if ver != '': print('Spectral model: ' + SpecModel)
pref = float(inSpec[1])
index = inSpec[2]
MinEnergy = EnConv(inSpec[3], "MeV") #convert the energy in MeV
MaxEnergy = EnConv(inSpec[4], "MeV") #convert the energy in MeV
if ver != '': print(MaxEnergy)
pref_text = 'parameter scale="' + numdiv(
pref
)[1] + '" name="Integral" min="1e-7" max="1000" free="1" value="' + numdiv(
pref)[0] + '"'
index_text = 'parameter scale="-1.0" name="Index" min="0.0" max="+10.0" free="1" value="' + index + '"'
min_energy_text = 'parameter scale="' + str(
MinEnergy[1]
) + '" name="LowerLimit" min="10.0" max="+100000000.0" free="0" value="' + str(
MinEnergy[0]) + '"'
max_energy_text = 'parameter scale="' + str(
MaxEnergy[1]
) + '" name="UpperLimit" min="10.0" max="+100000000.0" free="0" value="' + str(
MaxEnergy[0]) + '"'
spectral = gammalib.GXmlElement('spectrum type="PowerLaw2"')
spectral.append(pref_text)
spectral.append(index_text)
spectral.append(min_energy_text)
spectral.append(max_energy_text)
elif (SpecModel == 'BRPL'):
# BrokenPowerLaw MODEL
if ver != '': print('Spectral model: ' + SpecModel)
pref = float(inSpec[1])
index1 = inSpec[2] #must be negative
CutEnergy = EnConv(inSpec[3], "GeV") #convert the energy in GeV
index2 = inSpec[4] # must be negative
pref_text = 'parameter scale="' + numdiv(
pref
)[1] + '" name="Prefactor" min="1e-7" max="1000" free="1" value="' + numdiv(
pref)[0] + '"'
index1_text = 'parameter scale="-1.0" name="Index1" min="0.01" max="+10.0" free="1" value="' + index1 + '"'
cut_energy_text = 'parameter scale="' + str(
CutEnergy[1]
) + '" name="BreakValue" min="10.0" max="+100000000.0" free="1" value="' + str(
CutEnergy[0]) + '"'
index2_text = 'parameter scale="-1.0" name="Index2" min="0.01" max="+10.0" free="1" value="' + index2 + '"'
spectral = gammalib.GXmlElement('spectrum type="BrokenPowerLaw"')
spectral.append(pref_text)
spectral.append(index1_text)
spectral.append(cut_energy_text)
spectral.append(index2_text)
elif (SpecModel == 'EXPL'):
#Exponential CUT OFF POWER LAW MODEL
if ver != '': print('Spectral model: ' + SpecModel)
pref = float(inSpec[1])
index = inSpec[2]
PivotEnergy = EnConv(inSpec[3], "MeV") #convert the energy in MeV
CutEnergy = EnConv(inSpec[4], "MeV") #convert the energy in MeV
pref_text = 'parameter scale="' + numdiv(
pref
)[1] + '" name="Prefactor" min="1e-7" max="1000" free="1" value="' + numdiv(
pref)[0] + '"'
index_text = 'parameter scale="-1.0" name="Index" min="0.0" max="+10.0" free="1" value="' + index + '"'
cut_energy_text = 'parameter scale="1.0" name="Cutoff" min="0.01" max="100000000.0" free="1" value="' + str(
CutEnergy[0]) + '"'
piv_energy_text = 'parameter scale="1.0" name="Scale" min="0.01" max="100000000.0" free="0" value="' + str(
PivotEnergy[0]) + '"'
spectral = gammalib.GXmlElement('spectrum type="ExpCutoff"')
spectral.append(pref_text)
spectral.append(index_text)
spectral.append(cut_energy_text)
spectral.append(piv_energy_text)
elif (SpecModel == 'SEPL'):
#SUPER EXPONENTIALY CUY-OFF POWER LAW
if ver != '': print('Spectral model: ' + SpecModel)
pref = float(inSpec[1])
index1 = inSpec[2]
index2 = inSpec[3]
PivotEnergy = EnConv(inSpec[4], "MeV") #convert the energy in MeV
CutEnergy = EnConv(inSpec[5], "MeV") #convert the energy in MeV
pref_text = 'parameter scale="' + numdiv(
pref
)[1] + '" name="Prefactor" min="1e-7" max="1000" free="1" value="' + numdiv(
pref)[0] + '"'
index1_text = 'parameter scale="-1.0" name="Index1" min="0.0" max="+10.0" free="1" value="' + index1 + '"'
index2_text = 'parameter scale="1.0" name="Index2" min="0.1" max="10.0" free="1" value="' + index2 + '"'
cut_energy_text = 'parameter scale="' + str(
CutEnergy[1]
) + '" name="Cutoff" min="0.01" max="100000000.0" free="1" value="' + str(
CutEnergy[0]) + '"'
piv_energy_text = 'parameter scale="' + str(
PivotEnergy[1]
) + '" name="Scale" min="0.01" max="100000000.0" free="0" value="' + str(
PivotEnergy[0]) + '"'
spectral = gammalib.GXmlElement('spectrum type="PLSuperExpCutoff"')
spectral.append(pref_text)
spectral.append(index1_text)
spectral.append(index2_text)
spectral.append(cut_energy_text)
spectral.append(piv_energy_text)
elif (SpecModel == 'LOGPAR'):
if ver != '': print('Spectral model: ' + SpecModel)
#LOG PARABOLA
pref = float(inSpec[1])
index = inSpec[2]
curv = inSpec[3]
E_scale = EnConv(inSpec[4], "MeV") #convert the energy in MeV
pref_text = 'parameter scale="' + numdiv(
pref
)[1] + '" name="Prefactor" min="1e-7" max="1000" free="1" value="' + numdiv(
pref)[0] + '"'
index_text = 'parameter scale="-1.0" name="Index" min="0.0" max="+10.0" free="1" value="' + index + '"'
curv_text = 'parameter scale="-1.0" name="Curvature" min="-5.0" max="+5.0" free="1" value="' + curv + '"'
E_scale_text = 'parameter scale="1.0" name="Scale" min="0.01" max="100000000.0" free="0" value="' + str(
E_scale[0]) + '"'
spectral = gammalib.GXmlElement('spectrum type="LogParabola"')
spectral.append(pref_text)
spectral.append(index_text)
spectral.append(curv_text)
spectral.append(E_scale_text)
elif (SpecModel == 'GAUSS'):
if ver != '': print('Spectral model: ' + SpecModel)
#GAUSSIAN FUNCTION
norm = float(inSpec[1])
mean = EnConv(inSpec[2], "GeV")
sigma = inSpec[3]
norm_text = 'parameter scale="' + numdiv(
norm
)[1] + '" name="Normalization" min="1e-7" max="1000.0" free="1" value="' + numdiv(
norm)[0] + '"'
mean_text = 'parameter scale="1e6" name="Mean" value="' + str(
mean[0]) + '"'
sigma_text = 'parameter scale="1e6" name="Sigma" min="0.01" max="100.0" free="1" value="' + sigma + '"'
spectral = gammalib.GXmlElement('spectrum type="Gaussian"')
spectral.append(norm_text)
spectral.append(mean_text)
spectral.append(sigma_text)
else:
print("Wrong Spectral model!!! CHECK MODEL NAME!!!")
sys.exit()
return spectral
def spatFun(inSpat):
# --------------------
# CREATE SPATIAL MODEL
# --------------------
#get model name
SpatModel = inSpat[0]
# set RA and DEC, common for all the spatial models
ra = inSpat[2]
dec = inSpat[3]
# set text to be put in the xml file
ra_text = 'parameter scale="1.0" name="RA" min="-360" max="360" free="0" value="' + ra + '"'
dec_text = 'parameter scale="1.0" name="DEC" min="-90" max="90" free="0" value="' + dec + '"'
if (SpatModel == 'Point'):
spatial = gammalib.GXmlElement('spatialModel type="SkyDirFunction"'
) #compatibility with Fermi/LAT
spatial.append(ra_text)
spatial.append(dec_text)
elif (SpatModel == 'RadDisk'):
spatial = gammalib.GXmlElement('spatialModel type="DiskFunction"')
spatial.append(ra_text)
spatial.append(dec_text)
radius = inSpat[4]
radius_text = 'parameter name="Radius" scale="1.0" min="0.01" max="10" free="0" value="' + radius + '"'
spatial.append(radius_text)
elif (SpatModel == 'RadGauss'):
spatial = gammalib.GXmlElement('spatialModel type="GaussFunction"')
spatial.append(ra_text)
spatial.append(dec_text)
sig = inSpat[4]
sig_text = 'parameter name="Sigma" scale="1.0" min="0.01" max="10" free="0" value="' + sig + '"'
spatial.append(sig_text)
elif (SpatModel == 'RadShell'):
spatial = gammalib.GXmlElement('spatialModel type="ShellFunction"')
spatial.append(ra_text)
spatial.append(dec_text)
radius = inSpat[4]
width = inSpat[5]
radius_text = 'parameter name="Radius" scale="1.0" min="0.01" max="10" free="0" value="' + radius + '"'
width_text = 'parameter name="Width" scale="1.0" min="0.01" max="10" free="0" value="' + width + '"'
spatial.append(radius_text)
spatial.append(width_text)
elif (SpatModel == 'EllDisk'):
spatial = gammalib.GXmlElement('spatialModel type="EllipticalDisk"')
spatial.append(ra_text)
spatial.append(dec_text)
PA = inSpat[4]
minr = inSpat[5]
maxr = inSpat[6]
PA_text = 'parameter name="PA" scale="1.0" min="-360" max="360" free="0" value="' + PA + '"'
minr_text = 'parameter name="MinorRadius" scale="1.0" min="0.001" max="10" free="0" value="' + minr + '"'
maxr_text = 'parameter name="MajorRadius" scale="1.0" min="0.001" max="10" free="0" value="' + maxr + '"'
spatial.append(PA_text)
spatial.append(minr_text)
spatial.append(maxr_text)
elif (SpatModel == 'EllGauss'):
spatial = gammalib.GXmlElement('spatialModel type="EllipticalGauss"')
spatial.append(ra_text)
spatial.append(dec_text)
PA = inSpat[4]
minr = inSpat[5]
maxr = inSpat[6]
PA_text = 'parameter name="PA" scale="1.0" min="-360" max="360" free="0" value="' + PA + '"'
minr_text = 'parameter name="MinorRadius" scale="1.0" min="0.001" max="10" free="0" value="' + minr + '"'
maxr_text = 'parameter name="MajorRadius" scale="1.0" min="0.001" max="10" free="0" value="' + maxr + '"'
spatial.append(PA_text)
spatial.append(minr_text)
spatial.append(maxr_text)
elif (SpatModel == 'DiffIso'):
spatial = gammalib.GXmlElement('spatialModel type="DiffuseSource"')
value = inSpat[4]
value_text = 'parameter name="Value" scale="1" min="1" max="1" free="0" value="' + value + '"'
spatial.append(value_text)
elif (SpatModel == 'DiffMap'):
spatial = gammalib.GXmlElement(
'spatialModel type="DiffuseSource" file="map.fits"')
value = inSpat[4]
value_text = 'parameter name="Prefactor" scale="1" min="0.001" max="1000.0" free="0" value="' + value + '"'
spatial.append(value_text)
elif (SpatModel == 'DiffMapCube'):
spatial = gammalib.GXmlElement(
'spatialModel type="MapCubeFunction" file="map_cube.fits"')
value = inSpat[4]
value_text = 'parameter name="Normalization" scale="1" min="0.001" max="1000.0" free="0" value="' + value + '"'
spatial.append(value_text)
#---------- Here starts background spatial models
elif (SpatModel == 'BkgGauss'):
spatial = gammalib.GXmlElement('radialModel type="Gaussian"')
sig = inSpat[2]
sig_text = 'parameter name="Sigma" scale="1.0" min="0.01" max="10.0" free="0" value="' + sig + '"'
spatial.append(sig_text)
elif (SpatModel == 'Profile'):
spatial = gammalib.GXmlElement('radialModel type="Profile"')
width = inSpat[2]
core = inSpat[3]
tail = inSpat[4]
width_text = 'parameter name="Width" scale="1.0" min="0.01" max="10000.0" free="0" value="' + width + '"'
core_text = 'parameter name="Core" scale="1.0" min="0.01" max="10000.0" free="0" value="' + core + '"'
tail_text = 'parameter name="Tail" scale="1.0" min="0.01" max="10000.0" free="0" value="' + tail + '"'
spatial.append(width_text)
spatial.append(core_text)
spatial.append(tail_text)
elif (SpatModel == 'Polynom'):
spatial = gammalib.GXmlElement('radialModel type="Polynom"')
coef = inSpat[2]
coef = coef.split("_")
for i in range(0, len(coef)):
name_coef = 'Coeff' + str(i)
coef_text = 'parameter name="' + name_coef + '" scale="1.0" value="' + coef[
i] + '" min="-10.0" max="10.0" free="0"'
spatial.append(coef_text)
else:
print("Wrong input model")
sys.exit()
return spatial
