diff --git a/cscripts/lsmodel.par b/cscripts/lsmodel.par new file mode 100644 index 0000000..19135e2 --- /dev/null +++ b/cscripts/lsmodel.par @@ -0,0 +1,38 @@ +############################################################################# +# # +# Fermi/LAT Science Tools # +# # +# ------------------------------------------------------------------------- # +# # +# File: lsmodel.par # +# Version: 1.1.0 # +# # +# Author: Juergen Knoedlseder # +# Jurgen.Knodlseder@irap.omp.eu # +# IRAP # +# # +# Purpose: Parameter file for the lsmodel script # +# # +############################################################################# +# +# Input and output parameters +#============================ +cntmap, f, a, cntmap.fits,,, "Counts map" +expmap, f, a, binned_expmap.fits,,, "Exposure map" +ltcube, f, a, ltcube.fits,,, "Livetime cube" +srcmdl, f, a, crab_model.xml,,, "Source model" +caldb, s, h, ,,, "Calibration database" +irf, s, a, P8R2_SOURCE_V6,,, "Instrument response function" +outfile, f, a, model_cube.fits,,, "Output file name" + +# +# Standard parameters +#==================== +chatter, i, h, 2,0,4, "Chattiness of output" +clobber, b, h, yes,,, "Overwrite existing output files with new output files?" +debug, b, h, no,,, "Debugging mode activated" +mode, s, h, ql,,, "Mode of automatic parameters" +logfile, f, h, lsmodel.log,,, "Log filename" + + + diff --git a/cscripts/lsmodel.py b/cscripts/lsmodel.py index 0ab020c..d84fc05 100755 --- a/cscripts/lsmodel.py +++ b/cscripts/lsmodel.py @@ -1,8 +1,8 @@ #! /usr/bin/env python # ========================================================================== -# This script generates a model map from a counts map and a source model. +# Generates model cube for Fermi/LAT data. # -# Copyright (C) 2014 Juergen Knoedlseder +# Copyright (C) 2014-2016 Juergen Knoedlseder # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -27,135 +27,97 @@ import sys # ============= # class lsmodel(gammalib.GApplication): """ + Generates model cube for Fermi/LAT data. + This class implements the model map generation script. It derives from the GammaLib::GApplication class which provides support for parameter files, command line arguments, and logging. In that way the Python script behaves just as a regular ctool. """ + + # Constructor def __init__(self, *argv): """ Constructor. """ - # Set name - self.name = "lsmodel" - self.version = "0.1.0" - - # Make sure that parfile exists - file = self.parfile() + # Set name and version + self._name = "lsmodel" + self._version = "1.1.0" # Initialise application if len(argv) == 0: - gammalib.GApplication.__init__(self, self.name, self.version) + gammalib.GApplication.__init__(self, self._name, self._version) elif len(argv) ==1: - gammalib.GApplication.__init__(self, self.name, self.version, *argv) + gammalib.GApplication.__init__(self, self._name, self._version, *argv) else: raise TypeError("Invalid number of arguments given.") # Set logger properties - self.log_header() - self.log.date(True) + self._log_header() + self._log.date(True) # Return return - def __del__(self): - """ - Destructor. - """ - # Write separator into logger - if self.logTerse(): - self.log("\n") - - # Return - return - def parfile(self): + # Private methods + def _get_parameters(self): """ - Check if parfile exists. If parfile does not exist then create a - default parfile. This kluge avoids shipping the script with a parfile. + Get parameters from parfile. """ - # Set parfile name - parfile = self.name+".par" - - try: - pars = gammalib.GApplicationPars(parfile) - except: - # Signal if parfile was not found - sys.stdout.write("Parfile "+parfile+" not found. Create default parfile.\n") - - # Create default parfile - pars = gammalib.GApplicationPars() - pars.append(gammalib.GApplicationPar("cntmap","f","a","cntmap.fits","","","Counts map")) - pars.append(gammalib.GApplicationPar("expmap","f","a","binned_expmap.fits","","","Exposure map")) - pars.append(gammalib.GApplicationPar("ltcube","f","a","ltcube.fits","","","Livetime cube")) - pars.append(gammalib.GApplicationPar("srcmdl","f","a","crab_model.xml","","","Source model")) - pars.append(gammalib.GApplicationPar("caldb","s","h","","","","Calibration database")) - pars.append(gammalib.GApplicationPar("irf","s","a","P7REP_SOURCE_V15","","","Instrument response function")) - pars.append(gammalib.GApplicationPar("outfile","f","a","model_cube.fits","","","Output file name")) - pars.append_standard() - pars.save(parfile) - - # Return - return + # Query user parameters + self["cntmap"].filename() + self["expmap"].filename() + self["ltcube"].filename() + self["srcmdl"].filename() + self["caldb"].string() + self["irf"].string() + + # Read ahead output parameters + if (self._read_ahead()): + self["outfile"].filename() - def get_parameters(self): - """ - Get parameters from parfile and setup the observation. - """ - # Get parameters - self.m_cntmap = self["cntmap"].filename() - self.m_expmap = self["expmap"].filename() - self.m_ltcube = self["ltcube"].filename() - self.m_srcmdl = self["srcmdl"].filename() - self.m_caldb = self["caldb"].string() - self.m_irf = self["irf"].string() - self.m_outfile = self["outfile"].filename() - - # Set some fixed parameters - self.m_log = False # Logging in client tools - self.m_debug = False # Debugging in client tools + # Write input parameters into logger + if self._logTerse(): + self._log_parameters() + self._log("\n") # Return return - def execute(self): - """ - Execute the script. - """ - # Run the script - self.run() - - # Return - return + # Public methods def run(self): """ Run the script. """ # Switch screen logging on in debug mode - if self.logDebug(): - self.log.cout(True) + 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") + self._get_parameters() # Write header - if self.logTerse(): - self.log("\n") - self.log.header1("Generate model cube") + if self._logTerse(): + self._log("\n") + self._log.header1("Generate model cube") + + # Get user parameters + cntmap = self["cntmap"].filename() + expmap = self["expmap"].filename() + ltcube = self["ltcube"].filename() + srcmdl = self["srcmdl"].filename() + caldb = self["caldb"].string() + irf = self["irf"].string() # Set LAT observation obs = gammalib.GLATObservation() - obs.load_binned(self.m_cntmap, self.m_expmap, self.m_ltcube) - obs.response(self.m_irf, self.m_caldb) + obs.load_binned(cntmap, expmap, ltcube) + obs.response(irf, caldb) # Set model (use first model for the moment) - models = gammalib.GModels(self.m_srcmdl) + models = gammalib.GModels(srcmdl) model = models[0] # Get deep copy of GLATEventCube from observation @@ -169,17 +131,52 @@ class lsmodel(gammalib.GApplication): cube[i] = event # Log cube - if self.logTerse(): - self.log(str(cube)) - self.log("\n") + if self._logTerse(): + self._log(str(cube)) + self._log("\n") - # Write header - if self.logTerse(): - self.log("\n") - self.log.header1("Save model cube") + # Return + return + + def execute(self): + """ + Execute the script. + """ + # Open logfile + self._logFileOpen() + + # Read ahead output parameters + self._read_ahead(True) + + # Run the script + self.run() + + # Save event cube + self.save() + + # Return + return - # Save model cube - cube.save(self.m_outfile, self.clobber()) + 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 @@ -189,14 +186,9 @@ class lsmodel(gammalib.GApplication): # Main routine entry point # # ======================== # if __name__ == '__main__': - """ - Generates a model map from a counts map and a source model. - """ + # Create instance of application app = lsmodel(sys.argv) - # Open logfile - app.logFileOpen() - # Execute application app.execute()