Merge branch 'pull-request-1991-ctprob-eval-event-probs' into integration

Jürgen Knödlseder
2 parents 4b7d6042 fc5614e8
Showing 19 changed files with 1697 additions and 150 deletions
.gitignore
configure.ac
doc/source/users/reference_manual/ctprob.rst
doc/source/users/reference_manual/index.rst
pyext/Makefile.am
pyext/ctools/tools.i
pyext/ctprob.i
src/Makefile.am
src/ctprob/Makefile.am
src/ctprob/ctprob.cpp
src/ctprob/ctprob.hpp
src/ctprob/ctprob.par
src/ctprob/main.cpp
src/ctselect/ctselect.cpp
src/ctselect/ctselect.hpp
src/support/ctool.cpp
src/support/ctool.hpp
test/test_ctprob.py
test/test_python_ctools.py
@@ -71,6 +71,7 @@ src/ctcubemask/ctcubemask
 src/ctbutterfly/ctbutterfly
 src/ctulimit/ctulimit
 src/cterror/cterror
+src/ctprob/ctprob
 test/pfiles/
 test/caldb/
 test/prod3
@@ -1035,6 +1035,7 @@ AC_CONFIG_FILES([Makefile
                  src/ctbutterfly/Makefile
                  src/ctulimit/Makefile
                  src/cterror/Makefile
+                 src/ctprob/Makefile
                  src/support/Makefile
                  src/ctools-setup
                  test/Makefile
+.. _ctprob:
+
+ctprob
+========
+
+Compute event probability for a given model.
+
+
+Synopsis
+--------
+
+This tool takes an event list file (or an XML observation definition file) and
+a model as input and computes for each event the probability that it originates
+from a specific model component. The probability is computed by by evaluating
+the differential event probability for a given model and normalizing these
+probabilities so that the sum of the probabilities for all model components is
+unity for each event.
+
+The tool appends for each model component a single precision column to the event
+list that contains the event probabilities. The name of the column is build from
+the model name prefixed with ``PROB_``.
+
+
+General parameters
+------------------
+
+``inobs [file]``
+    Input event list or observation definition XML file
+ 	 	 
+``outobs [file]``
+    Output event list or observation definition XML file.
+ 	 	 
+``(prefix = "prob_") [string]``
+    Prefix for output event lists in observation definition file.
+ 	 	 
+``inmodel [string]``
+    Input model definition XML file.
+
+``caldb [string]``
+    Calibration database.
+ 	 	 
+``irf [string]``
+    Instrument response function.
+ 	 	 
+``(edisp = no) [boolean]``
+    Applies energy dispersion to response computation.
+
+
+Standard parameters
+-------------------
+
+``(publish = no) [boolean]``
+    Specifies whether the event list(s) should be published on VO Hub.
+
+``(chatter = 2) [integer]``
+    Verbosity of the executable:
+     chatter = 0: no information will be logged
+     
+     chatter = 1: only errors will be logged
+     
+     chatter = 2: errors and actions will be logged
+     
+     chatter = 3: report about the task execution
+     
+     chatter = 4: detailed report about the task execution
+ 	 	 
+``(clobber = yes) [boolean]``
+    Specifies whether existing output files should be overwritten.
+ 	 	 
+``(debug = no) [boolean]``
+    Enables debug mode. In debug mode the executable will dump any log file output to the console.
+ 	 	 
+``(mode = ql) [string]``
+    Mode of automatic parameters (default is "ql", i.e. "query and learn").
+
+``(logfile = ctprob.log) [string]``
+    Name of log file.
+
+
+Related tools or scripts
+------------------------
+
+:doc:`ctphase`
+:doc:`csphasecrv`
+
@@ -27,6 +27,7 @@ ctools
    ctmodel --- Computes model counts cube <ctmodel>
    ctobssim --- Simulate observations <ctobssim>
    ctpsfcube --- Generates point spread function cube <ctpsfcube>
+   ctprob --- Computes event probability for a given model <ctprob>
    ctselect --- Selects event data <ctselect>
    ctskymap --- Generates sky map <ctskymap>
    cttsmap --- Generates Test Statistic map <cttsmap>
@@ -58,6 +58,7 @@ testscripts = ctools/tests/__init__.py \
               $(top_srcdir)/test/test_ctbutterfly.py \
               $(top_srcdir)/test/test_ctulimit.py \
               $(top_srcdir)/test/test_cterror.py \
+              $(top_srcdir)/test/test_ctprob.py \
               $(top_srcdir)/test/test_pipelines.py
 # Test data to be distributed in $(pyexecdir)/ctools/tests/data
@@ -72,6 +72,7 @@ namespace std {
 %include "ctbutterfly.i"
 %include "ctulimit.i"
 %include "cterror.i"
+%include "ctprob.i"
 /* __ Test function ______________________________________________________ */
 %pythoncode %{
+/***************************************************************************
+ *           ctprob - Computes probability for a given model               *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2012-2016 by Leonardo Di Venere                          *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  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   *
+ *  the Free Software Foundation, either version 3 of the License, or      *
+ *  (at your option) any later version.                                    *
+ *                                                                         *
+ *  This program is distributed in the hope that it will be useful,        *
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
+ *  GNU General Public License for more details.                           *
+ *                                                                         *
+ *  You should have received a copy of the GNU General Public License      *
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
+ *                                                                         *
+ ***************************************************************************/
+/**
+ * @file ctprob.i
+ * @brief Computes probability for a given model
+ * @author Leonardo Di Venere
+ */
+%{
+/* Put headers and other declarations here that are needed for compilation */
+#include "ctprob.hpp"
+%}
+
+
+/***********************************************************************//**
+ * @class ctprob
+ *
+ * @brief Data selection tool
+ ***************************************************************************/
+class ctprob : public ctobservation {
+public:
+    // Constructors and destructors
+    ctprob(void);
+    explicit ctprob(const GObservations& obs);
+    ctprob(int argc, char *argv[]);
+    ctprob(const ctprob& app);
+    virtual ~ctprob(void);
+
+    // Methods
+    void clear(void);
+    void run(void);
+    void save(void);
+    void publish(const std::string& name = "");
+};
+
+
+/***********************************************************************//**
+ * @brief Data selection tool Python extension
+ ***************************************************************************/
+%extend ctprob {
+    ctprob copy() {
+        return (*self);
+    }
+}
@@ -40,7 +40,8 @@ SUBDIRS = support \
           cttsmap \
           ctbutterfly \
           ctulimit \
-          cterror
+          cterror \
+          ctprob
 # Scripts to be distributed
 scripts = ctools-setup \
@@ -68,7 +69,8 @@ libctools_la_LIBADD = support/libsupport.la \
                       cttsmap/libcttsmap.la \
                       ctbutterfly/libctbutterfly.la \
                       ctulimit/libctulimit.la \
-                      cterror/libcterror.la
+                      cterror/libcterror.la \
+                      ctprob/libctprob.la
 libctools_la_LDFLAGS = -version-info $(CTOOLS_LT_VERSION) @OPENMP_LIB_LDFLAGS@
 # Distribute scripts
+#############################################################################
+# Makefile.am for ctprob tool                                               #
+# ------------------------------------------------------------------------- #
+# Copyright (C) 2017 Leonardo Di Venere                                     #
+# ------------------------------------------------------------------------- #
+#                                                                           #
+#  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     #
+#  the Free Software Foundation, either version 3 of the License, or        #
+#  (at your option) any later version.                                      #
+#                                                                           #
+#  This program is distributed in the hope that it will be useful,          #
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of           #
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
+#  GNU General Public License for more details.                             #
+#                                                                           #
+#  You should have received a copy of the GNU General Public License        #
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.    #
+#                                                                           #
+#############################################################################
+
+# Set include directories
+INCLUDES = -I$(top_srcdir)/src/support
+
+# Program name
+bin_PROGRAMS = ctprob
+
+# Sources
+sources = ctprob.cpp ctprob.hpp
+
+# Libtool library
+noinst_LTLIBRARIES = libctprob.la
+libctprob_la_SOURCES = $(sources)
+libctprob_la_LDFLAGS = @OPENMP_LIB_LDFLAGS@
+
+# Program definition
+ctprob_SOURCES = main.cpp
+ctprob_LDFLAGS = $(LIB_LINK_OPTION) @LDFLAGS@
+ctprob_CPPFLAGS = @CPPFLAGS@
+ctprob_LDADD = libctprob.la $(top_builddir)/src/support/libsupport.la
+
+# Parameter files
+pfilesdir = $(prefix)/syspfiles
+pfiles_DATA = $(srcdir)/ctprob.par
+
+# Extra files to be distributed in the tar file
+EXTRA_DIST = $(pfiles_DATA)
+/***************************************************************************
+ *          ctprob - Computes event probability for a given model          *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2017 by Leonardo Di Venere                               *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  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   *
+ *  the Free Software Foundation, either version 3 of the License, or      *
+ *  (at your option) any later version.                                    *
+ *                                                                         *
+ *  This program is distributed in the hope that it will be useful,        *
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
+ *  GNU General Public License for more details.                           *
+ *                                                                         *
+ *  You should have received a copy of the GNU General Public License      *
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
+ *                                                                         *
+ ***************************************************************************/
+/**
+ * @file ctprob.cpp
+ * @brief Computes event probability for a given model
+ * @author Leonardo Di Venere
+ */
+
+/* __ Includes ___________________________________________________________ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <cstdlib>
+#include "ctprob.hpp"
+#include "GTools.hpp"
+
+/* __ Method name definitions ____________________________________________ */
+#define G_GET_OBS                                         "ctprob::get_obs()"
+#define G_EVALUATE_PROB      "ctprob::evaluate_probability(GCTAObservation*)"
+
+/* __ Debug definitions __________________________________________________ */
+
+/* __ Coding definitions _________________________________________________ */
+
+
+/*==========================================================================
+ =                                                                         =
+ =                        Constructors/destructors                         =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Void constructor
+ ***************************************************************************/
+ctprob::ctprob(void) : ctobservation(CTPROB_NAME, VERSION)
+{
+    // Initialise members
+    init_members();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Observations constructor
+ *
+ * param[in] obs Observation container.
+ *
+ * Creates an instance of the class that is initialised using the information
+ * provided in an observation container.
+ ***************************************************************************/
+ctprob::ctprob(const GObservations& obs) :
+        ctobservation(CTPROB_NAME, VERSION, obs)
+{
+    // Initialise members
+    init_members();
+
+    // Return
+    return;
+}
+
+
+
+
+/***********************************************************************//**
+ * @brief Command line constructor
+ *
+ * @param[in] argc Number of arguments in command line.
+ * @param[in] argv Array of command line arguments.
+ ***************************************************************************/
+ctprob::ctprob(int argc, char *argv[]) : 
+        ctobservation(CTPROB_NAME, VERSION, argc, argv)
+{
+    // Initialise members
+    init_members();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy constructor
+ *
+ * @param[in] app Application.
+ ***************************************************************************/
+ctprob::ctprob(const ctprob& app) : ctobservation(app)
+{
+    // Initialise members
+    init_members();
+
+    // Copy members
+    copy_members(app);
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Destructor
+ ***************************************************************************/
+ctprob::~ctprob(void)
+{
+    // Free members
+    free_members();
+
+    // Return
+    return;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                               Operators                                 =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Assignment operator
+ *
+ * @param[in] app Application.
+ * @return Application.
+ ***************************************************************************/
+ctprob& ctprob::operator=(const ctprob& app)
+{
+    // Execute only if object is not identical
+    if (this != &app) {
+
+        // Copy base class members
+        this->ctobservation::operator=(app);
+
+        // Free members
+        free_members();
+
+        // Initialise members
+        init_members();
+
+        // Copy members
+        copy_members(app);
+
+    } // endif: object was not identical
+
+    // Return this object
+    return *this;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                            Public methods                               =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Clear ctprob tool
+ *
+ * Clears ctprob tool.
+ ***************************************************************************/
+void ctprob::clear(void)
+{
+    // Free members
+    free_members();
+    this->ctobservation::free_members();
+    this->ctool::free_members();
+
+    // Clear base class (needed to conserve tool name and version)
+    this->GApplication::clear();
+
+    // Initialise members
+    this->ctool::init_members();
+    this->ctobservation::init_members();
+    init_members();
+
+    // Write header into logger
+    log_header();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Runs the ctprob tool
+ *
+ * This method reads in the application parameters and loops over all
+ * unbinned observations to compute the probability for each event that it
+ * comes from one of the model components.
+ ***************************************************************************/
+void ctprob::run(void)
+{
+    // Switch screen logging on in debug mode
+    if (logDebug()) {
+        log.cout(true);
+    }
+
+    // Get parameters
+    get_parameters();
+
+    // Set energy dispersion flags of all CTA observations and save old
+    // values in save_edisp vector
+    std::vector<bool> save_edisp = set_edisp(m_obs, m_apply_edisp);
+
+    // Write input observation container into logger
+    log_observations(NORMAL, m_obs, "Input observation");
+
+    // Write header into logger
+    log_header1(TERSE, "Compute event probabilities");
+
+    // Initialise counters
+    int n_observations = 0;
+
+    // Loop over all unbinned CTA observations in the container
+    for (GCTAObservation* obs = first_unbinned_observation(); obs != NULL;
+         obs = next_unbinned_observation()) {
+
+        // Increment counter
+        n_observations++;
+
+        // Evaluate event probabilities
+        evaluate_probability(obs);
+
+    } // endfor: looped over observations
+
+    // If more than a single observation has been handled then make sure that
+    // an XML file will be used for storage
+    if (n_observations > 1) {
+        m_use_xml = true;
+    }
+
+    // Write observation(s) into logger
+    log_observations(NORMAL, m_obs, "Output observation");
+
+    // Restore energy dispersion flags of all CTA observations
+    restore_edisp(m_obs, save_edisp);
+
+    // Optionally publish event list(s)
+    if ((*this)["publish"].boolean()) {
+        publish();
+    }
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Save the selected event list(s)
+ *
+ * This method saves the selected event list(s) into FITS file(s). There are
+ * two modes, depending on the m_use_xml flag.
+ *
+ * If m_use_xml is true, all selected event list(s) will be saved into FITS
+ * files, where the output filenames are constructued from the input
+ * filenames by prepending the m_prefix string to name. Any path information
+ * will be stripped form the input name, hence event files will be written
+ * into the local working directory (unless some path information is present
+ * in the prefix). In addition, an XML file will be created that gathers
+ * the filename information for the selected event list(s). If an XML file
+ * was present on input, all metadata information will be copied from this
+ * input file.
+ *
+ * If m_use_xml is false, the selected event list will be saved into a FITS
+ * file.
+ ***************************************************************************/
+void ctprob::save(void)
+{
+    // Write header into logger
+    log_header1(TERSE, gammalib::number("Save event list", m_obs.size()));
+
+    // Case A: Save event file(s) and XML metadata information
+    if (m_use_xml) {
+        save_xml();
+    }
+
+    // Case B: Save event file as FITS file
+    else {
+        save_fits();
+    }
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Publish event lists
+ *
+ * @param[in] name Event list name.
+ ***************************************************************************/
+void ctprob::publish(const std::string& name)
+{
+    // Write header into logger
+    log_header1(TERSE, gammalib::number("Publish event list", m_obs.size()));
+
+    // Loop over all observation in the container
+    for (int i = 0; i < m_obs.size(); ++i) {
+
+        // Get CTA observation
+        GCTAObservation* obs = dynamic_cast<GCTAObservation*>(m_obs[i]);
+
+        // Handle only CTA observations
+        if (obs != NULL) {
+
+            // Continue only if there is an event list
+            if (obs->events()->size() != 0) {
+
+                // Set default name if user name is empty
+                std::string user_name(name);
+                if (user_name.empty()) {
+                    user_name = CTPROB_NAME;
+                }
+
+                // If there are several event lists then add an index
+                if (m_use_xml) {
+                    user_name += gammalib::str(i);
+                }
+
+                // Write event list name into logger
+                log_value(NORMAL, "Event list name", user_name);
+
+                // Write events into in-memory FITS file
+                GFits fits;
+                obs->write(fits);
+
+                // Publish
+                fits.publish(gammalib::extname_cta_events, user_name);
+
+            } // endif: there were events
+
+        } // endif: observation was a CTA observation
+
+    } // endfor: looped over observations
+
+    // Return
+    return;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                             Private methods                             =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Initialise class members
+ ***************************************************************************/
+void ctprob::init_members(void)
+{
+    // Initialise parameters
+    m_outobs.clear();
+    m_prefix.clear();
+    /*    m_usepnt = false;
+    m_roi.clear();
+    m_tmin   = 0.0;
+    m_tmax   = 0.0;
+    m_emin   = 0.0;
+    m_emax   = 0.0;
+    m_expr.clear();
+    m_usethres.clear();*/
+    m_chatter = static_cast<GChatter>(2);
+
+    // Initialise protected members
+    m_infiles.clear();
+    m_evtname.clear();
+    m_gtiname.clear();
+    //    m_timemin.clear();
+    //m_timemax.clear();
+    //m_select_energy = true;
+    //m_select_roi    = true;
+    //m_select_time   = true;
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy class members
+ *
+ * @param[in] app Application.
+ ***************************************************************************/
+void ctprob::copy_members(const ctprob& app)
+{
+    // Copy parameters
+    m_outobs   = app.m_outobs;
+    m_prefix   = app.m_prefix;
+    /*    m_usepnt   = app.m_usepnt;
+    m_roi      = app.m_roi;
+    m_tmin     = app.m_tmin;
+    m_tmax     = app.m_tmax;
+    m_emin     = app.m_emin;
+    m_emax     = app.m_emax;
+    m_expr     = app.m_expr;
+    m_usethres = app.m_usethres;*/
+    m_chatter  = app.m_chatter;
+
+    // Copy protected members
+    m_infiles       = app.m_infiles;
+    m_evtname       = app.m_evtname;
+    m_gtiname       = app.m_gtiname;
+    /*    m_timemin       = app.m_timemin;
+    m_timemax       = app.m_timemax;
+    m_select_energy = app.m_select_energy;
+    m_select_roi    = app.m_select_roi;
+    m_select_time   = app.m_select_time;*/
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Delete class members
+ ***************************************************************************/
+void ctprob::free_members(void)
+{
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Get application parameters
+ *
+ * Get all user parameters from parameter file or (if required) by querying
+ * the user. Times are assumed to be in the native CTA MJD format.
+ *
+ * This method also loads observations if no observations are yet allocated.
+ * Observations are either loaded from a single CTA even list, or from a
+ * XML file using the metadata information that is stored in that file.
+ ***************************************************************************/
+void ctprob::get_parameters(void)
+{
+    // Setup observations from "inobs" parameter. Do not request response
+    // information and do not accept counts cubes.
+    if (m_obs.size() == 0) {
+        get_obs();
+    }
+    // ... otherwise add response information and energy boundaries in case
+    // that they are missing
+    else {
+        setup_observations(m_obs);
+    }
+
+    // Read model definition file if required
+    if (m_obs.models().size() == 0) {
+
+        // Get model filename
+        std::string inmodel = (*this)["inmodel"].filename();
+
+        // Load models from file
+        m_obs.models(inmodel);
+
+    } // endif: there were no models
+
+    // Get energy dispersion flag parameters
+    m_apply_edisp = (*this)["edisp"].boolean();
+
+
+    // Get remaining parameters
+    m_publish = (*this)["publish"].boolean();
+    m_chatter = static_cast<GChatter>((*this)["chatter"].integer());
+
+    // Optionally read ahead parameters so that they get correctly
+    // dumped into the log file
+    if (read_ahead()) {
+        m_outobs = (*this)["outobs"].filename();
+        m_prefix = (*this)["prefix"].string();
+    }
+
+    // Write parameters into logger
+    log_parameters(TERSE);
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Get observation container
+ *
+ * @exception GException::invalid_value
+ *            Invalid FITS file.
+ *
+ * Get an observation container according to the user parameters. The method
+ * supports loading of a individual FITS file or an observation definition
+ * file in XML format.
+ ***************************************************************************/
+void ctprob::get_obs(void)
+{
+    // Get the filename from the input parameters
+    std::string filename = (*this)["inobs"].filename();
+
+    // If no observation definition file throw an exception 
+    if (!is_valid_filename(filename)) {
+      throw GException::invalid_value(G_GET_OBS, "Input event list is not valid.");
+    } // endif: filename was not valid
+
+    // ... otherwise we have a file name
+    else {
+
+        // If file is a FITS file then create an empty CTA observation
+        // and load file into observation
+        if (GFilename(filename).is_fits()) {
+
+            // Allocate empty CTA observation
+            GCTAObservation cta;
+
+            // Load data
+            cta.load(filename);
+
+            // Set response
+            set_obs_response(&cta);
+
+            // Append observation to container
+            m_obs.append(cta);
+
+            // Signal that no XML file should be used for storage
+            m_use_xml = false;
+
+        }
+
+        // ... otherwise load file into observation container
+        else {
+
+            // Load observations from XML file
+            m_obs.load(filename);
+
+            // For all observations that have no response, set the response
+            // from the task parameters
+            set_response(m_obs);
+
+            // Set observation boundary parameters (emin, emax, rad)
+            set_obs_bounds(m_obs);
+
+            // Signal that XML file should be used for storage
+            m_use_xml = true;
+
+        } // endelse: file was an XML file
+
+    }
+
+    // Return
+    return;
+
+}
+
+
+
+/***********************************************************************//**
+ * @brief Evaluate probability for events
+ *
+ * @param[in,out] obs CTA observation.
+ *
+ * @exception GException::invalid_value
+ *            Observation does not contain an event list.
+ *
+ * Computes for all events the probability that an event arises from a
+ * specific model component. The computation is done by by evaluating the
+ * differential event probability for a given model and normalizing these
+ * probabilities so that the sum of the probabilities for all model
+ * components is unity for each event.
+ *
+ * The method appends for each model component a single precision column to
+ * the event list that contains the event probabilities. The name of the
+ * column is build from the model name prefixed with `PROB_`.
+ ***************************************************************************/
+void ctprob::evaluate_probability(GCTAObservation* obs)
+{
+    // Write header into logger
+    log_header3(NORMAL, "Evaluate events probabilities");
+
+    // Make sure that the observation holds a CTA event list. If this
+    // is not the case then throw an exception.
+    GCTAEventList* events = dynamic_cast<GCTAEventList*>(const_cast<GEvents*>
+                            (obs->events()));
+    if (events == NULL) {
+        std::string msg = "CTA Observation does not contain an event list. An "
+                          "event list is needed to compute the event "
+                          "probabilities.";
+        throw GException::invalid_value(G_EVALUATE_PROB, msg);
+    }
+
+    // Continue only if there are model components
+    int nmodels = m_obs.models().size();
+    if (nmodels > 0) {
+
+        // Allocate single precision FITS table columns for all model components
+        std::vector<GFitsTableFloatCol*> columns;
+        for (int k = 0; k < nmodels; ++k) {
+            const std::string   colname = "PROB_" + m_obs.models()[k] ->name();
+            GFitsTableFloatCol* col     =
+                                new GFitsTableFloatCol(colname, events->size());
+            columns.push_back(col);
+        }
+
+        // Loop over all events in the event list
+        for (int i = 0; i < events->size(); ++i) {
+
+            // Initialise total probability
+            double total = 0.0;
+
+            // Get point to event
+            const GEvent* event = (*events)[i];
+
+            // Initialise probability vector
+            std::vector<double> probabilities(nmodels, 0.0);
+
+            // Loop over models
+            for (int k = 0; k < nmodels; ++k) {
+                double value      =  m_obs.models()[k]->eval(*event, *obs);
+                probabilities[k]  = value;
+                total            += value;
+            }
+
+            // Normalize probabilities to unity
+            if (total > 0.0) {
+                for (int k = 0; k < nmodels; ++k) {
+                    probabilities[k] /= total;
+                }
+            }
+
+            // Store probabilities in FITS columns
+            for (int k = 0; k < nmodels; ++k) {
+                (*(columns[k]))(i) = probabilities[k];
+            }
+	
+        } // endfor: looped over all events
+
+        // Append columns to event list
+        for (int k = 0; k < nmodels; ++k) {
+            events->append_column(*columns[k]);
+        }
+
+    } // endif: there were model components
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Set output file name.
+ *
+ * @param[in] filename Input file name.
+ *
+ * Converts an input file name into an output filename by prepending the
+ * prefix stored in the member m_prefix to the input file name. Any path as
+ * well as extension will be stripped from the input file name. Also a
+ * trailing ".gz" will be stripped as one cannot write into gzipped files.
+ ***************************************************************************/
+std::string ctprob::set_outfile_name(const std::string& filename) const
+{
+    // Create filename
+    GFilename fname(filename);
+
+    // Split input filename without any extensions into path elements
+    std::vector<std::string> elements = gammalib::split(fname.url(), "/");
+
+    // The last path element is the filename
+    std::string outname = m_prefix + elements[elements.size()-1];
+
+    // Strip any ".gz"
+    outname = gammalib::strip_chars(outname, ".gz");
+    
+    // Return output filename
+    return outname;
+}
+
+
+/***********************************************************************//**
+ * @brief Save event list in FITS format.
+ *
+ * Save the event list as a FITS file. The file name of the FITS file is
+ * specified by the `outobs` parameter.
+ ***************************************************************************/
+void ctprob::save_fits(void)
+{
+    // Save only if there are observations
+    if (m_obs.size() > 0) {
+
+        // Get output filename
+        m_outobs = (*this)["outobs"].filename();
+
+        // Loop over all unbinned CTA observations in the container
+        for (GCTAObservation* obs = first_unbinned_observation(); obs != NULL;
+             obs = next_unbinned_observation()) {
+
+            // Get input file name and default extension names
+            std::string infile  = obs->eventfile();
+            std::string evtname = gammalib::extname_cta_events;
+            std::string gtiname = gammalib::extname_gti;
+
+            // Create file name object
+            GFilename fname(m_outobs);
+
+            // Extract filename and event extension name
+            std::string outfile = fname.url();
+
+            // Append event extension name. We handle here the possibility
+            // to write the events into a different extension.
+            if (fname.has_extname()) {
+                outfile += "["+fname.extname()+"]";
+            }
+            else {
+                outfile += "["+gammalib::extname_cta_events+"]";
+            }
+
+            // Log filename
+            log_value(NORMAL, "Event list file", outfile);
+            
+            // Save event list
+            save_event_list(obs, infile, evtname, gtiname, outfile);
+
+            // Exit the loop (if this method is called we should only
+            // have a single unbinned observation in the observation
+            // container
+            break;
+
+        } // endfor: looped over all unbinned observations
+
+    } // endif: there were observations
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Save event list(s) in XML format.
+ *
+ * Save the event list(s) into FITS files and write the file path information
+ * into a XML file. The filename of the XML file is specified by the `outobs`
+ * parameter, the filename(s) of the event lists are built by prepending a
+ * prefix to the input event list filenames. Any path present in the input
+ * filename will be stripped, i.e. the event list(s) will be written in the
+ * local working directory (unless a path is specified in the prefix).
+ ***************************************************************************/
+void ctprob::save_xml(void)
+{
+    // Get output filename and prefix
+    m_outobs = (*this)["outobs"].filename();
+    m_prefix = (*this)["prefix"].string();
+
+    // Issue warning if output filename has no .xml suffix
+    log_string(TERSE, warn_xml_suffix(m_outobs));
+
+    // Loop over all unbinned CTA observations in the container
+    for (GCTAObservation* obs = first_unbinned_observation(); obs != NULL;
+         obs = next_unbinned_observation()) {
+
+        // Get input file name and default extension names
+        std::string infile  = obs->eventfile();
+        std::string evtname = gammalib::extname_cta_events;
+        std::string gtiname = gammalib::extname_gti;
+
+        // Extract event and GTI extension names from input FITS file
+        GFilename fname(infile);
+        if (fname.has_extname()) {
+            evtname = fname.extname();
+        }
+        gtiname = get_gtiname(fname.url(), evtname);
+
+        // Set event output file name
+        std::string outfile = set_outfile_name(infile);
+
+        // Append event extension name
+        outfile += "["+evtname+"]";
+
+        // Log filename
+        log_value(NORMAL, "Event list file", outfile);
+
+        // Store output file name in observation
+        obs->eventfile(outfile);
+
+        // Save event list
+        save_event_list(obs, infile, evtname, gtiname, outfile);
+
+    } // endfor: looped over observations
+
+    // Write observation definition XML file name into logger
+    log_value(NORMAL, "Obs. definition file", m_outobs);
+
+    // Save observations in XML file
+    m_obs.save(m_outobs);
+
+    // Return
+    return;
+}
+/***************************************************************************
+ *          ctprob - Computes event probability for a given model          *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2017 by Leonardo Di Venere                               *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  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   *
+ *  the Free Software Foundation, either version 3 of the License, or      *
+ *  (at your option) any later version.                                    *
+ *                                                                         *
+ *  This program is distributed in the hope that it will be useful,        *
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
+ *  GNU General Public License for more details.                           *
+ *                                                                         *
+ *  You should have received a copy of the GNU General Public License      *
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
+ *                                                                         *
+ ***************************************************************************/
+/**
+ * @file ctprob.hpp
+ * @brief Computes event probability for a given model
+ * @author Leonardo Di Venere
+ */
+
+#ifndef CTPROB_HPP
+#define CTPROB_HPP
+
+/* __ Includes ___________________________________________________________ */
+#include <vector>
+#include <string>
+#include "GammaLib.hpp"
+#include "GCTALib.hpp"
+#include "ctobservation.hpp"
+
+/* __Definitions _________________________________________________________ */
+#define CTPROB_NAME "ctprob"
+
+
+/***********************************************************************//**
+ * @class ctprob
+ *
+ * @brief Data selection tool
+ ***************************************************************************/
+class ctprob : public ctobservation {
+
+public:
+    // Constructors and destructors
+    ctprob(void);
+    explicit ctprob(const GObservations& obs);
+    ctprob(int argc, char *argv[]);
+    ctprob(const ctprob& app);
+    virtual ~ctprob(void);
+
+    // Operators
+    ctprob& operator=(const ctprob& app);
+
+    // Methods
+    void clear(void);
+    void run(void);
+    void save(void);
+    void publish(const std::string& name = "");
+
+protected:
+    // Protected methods
+    void        init_members(void);
+    void        copy_members(const ctprob& app);
+    void        free_members(void);
+    void        get_parameters(void);
+    void        get_obs(void);
+    void        evaluate_probability(GCTAObservation* obs);
+    std::string set_outfile_name(const std::string& filename) const;
+    void        save_fits(void);
+    void        save_xml(void);
+
+    // User parameters
+    std::string m_outobs;      //!< Output event list or XML file
+    std::string m_prefix;      //!< Prefix for multiple event lists
+    bool        m_apply_edisp; //!< Apply energy dispersion?
+    bool        m_publish;     //!< Publish event list?
+    GChatter    m_chatter;     //!< Chattiness
+
+    // Protected members
+    std::vector<std::string> m_infiles;  //!< Input event filenames
+    std::vector<std::string> m_evtname;  //!< Event extension names
+    std::vector<std::string> m_gtiname;  //!< GTI extension names
+};
+
+#endif /* CTPROB_HPP */
+#############################################################################
+#                                                                           #
+#                       CTA Science Analysis Tools                          #
+#                                                                           #
+# ------------------------------------------------------------------------- #
+#                                                                           #
+#  File:      ctprob.par                                                    #
+#                                                                           #
+#  Author:    Leonardo Di Venere                                            #
+#             leonardo.divenere@ba.infn.it                                  #
+#             INFN                                                          #
+#                                                                           #
+#  Purpose:   Parameter file for the ctprob application                     #
+#                                                                           #
+#############################################################################
+#
+# General parameters
+#===================
+inobs,   f, a, "events.fits",,, "Input event list or observation definition XML file"
+outobs,  f, a, "prob_events.fits",,, "Output event list or observation definition XML file"
+prefix,  s, h, "prob_",,, "Prefix for event lists in observation definition XML file"
+inmodel, f, a, "$CTOOLS/share/models/crab.xml",,, "Input model definition XML file"
+caldb,   s, a, "prod2",,, "Calibration database"
+irf,     s, a, "South_0.5h",,, "Instrument response function"
+edisp,   b, h, no,,, "Apply energy dispersion?"
+
+#
+# Standard parameters
+#====================
+publish, b, h, no,,, "Publish event list on VO Hub?"
+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, "ctprob.log",,, "Log filename"
+/***************************************************************************
+ *          ctprob - Computes event probability for a given model          *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2017 by Leonardo Di Venere                               *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  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   *
+ *  the Free Software Foundation, either version 3 of the License, or      *
+ *  (at your option) any later version.                                    *
+ *                                                                         *
+ *  This program is distributed in the hope that it will be useful,        *
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
+ *  GNU General Public License for more details.                           *
+ *                                                                         *
+ *  You should have received a copy of the GNU General Public License      *
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
+ *                                                                         *
+ ***************************************************************************/
+/**
+ * @file main.cpp
+ * @brief Computes event probability for a given model
+ * @author Leonardo Di Venere
+ */
+
+/* __ Includes ___________________________________________________________ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "support.hpp"
+#include "ctprob.hpp"
+
+
+/***********************************************************************//**
+ * @brief Main entry point of application
+ *
+ * @param[in] argc Number of command line arguments.
+ * @param[in] argv Command line arguments.
+ *
+ * This is the main entry point of the ctprob application. It allocates a
+ * ctprob object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and into the standard output.
+ ***************************************************************************/
+int main (int argc, char *argv[])
+{
+    // Initialise return code
+    int rc = 1;
+
+    // Initialise pointer on application
+    ctprob* application = NULL;
+
+    // Execute application
+    try {
+
+        // Create instance of application
+        application = new ctprob(argc, argv);
+
+        // Execute ctool
+        rc = execute_ctool(application);
+
+    }
+
+    catch (std::exception &e) {
+
+        // Report exception
+        report_ctool_failure("ctprob", e.what());
+
+    }
+
+    // Delete application
+    delete application;
+
+    // Return
+    return rc;
+}
@@ -1175,39 +1175,6 @@ std::string ctselect::set_outfile_name(const std::string&amp; filename) const
 /***********************************************************************//**
- * @brief Get Good Time Intervals extension name
- *
- * @param[in] filename Input file name.
- * @param[in] evtname Events extension name.
- *
- * Extracts the Good Time Intervals extension name from the event file. We
- * do this by loading the events and accessing the Good Time Intervals
- * extension name using the GCTAEventList::gtiname() method. If the file name
- * is empty, the method returns `GTI`.
- ***************************************************************************/
-std::string ctselect::get_gtiname(const std::string& filename,
-                                  const std::string& evtname) const
-{
-    // Initialise GTI name
-    std::string gtiname = gammalib::extname_gti;
-
-    // Continue only if the filename is not empty
-    if (!filename.empty()) {
-
-        // Load events
-        GCTAEventList events(filename+"["+evtname+"]");
-
-        // Get GTI name
-        gtiname = events.gtiname();
-
-    }
-
-    // Return GTI name
-    return (gtiname);
-}
-
-
-/***********************************************************************//**
  * @brief Save event list in FITS format.
  *
  * Save the event list as a FITS file. The file name of the FITS file is
@@ -1325,109 +1292,3 @@ void ctselect::save_xml(void)
     // Return
     return;
 }
-
-
-/***********************************************************************//**
- * @brief Save event list into FITS file
- *
- * @param[in] obs Pointer to CTA observation.
- * @param[in] infile Input file name.
- * @param[in] evtname Event extension name.
- * @param[in] gtiname GTI extension name.
- * @param[in] outfile Output file name.
- *
- * Saves an event list and the corresponding Good Time Intervals into a FITS
- * file and copy all others extensions from the input file to the output
- * file.
- *
- * If an extension name is specified in the @p outfile argument, the events
- * and eventually also the Good Time Intervals will be extracted from the
- * argument and used for writing the events. The format is
- *
- *      <filename>[<event extension name;GTI extension name>]
- *
- * where <filename> needs to be replaced by the name of the FITS file,
- * and <event extension name;GTI extension name> by the name of the events
- * and Good Time Intervals extensions. For example 
- *
- *      myfits.fits[EVENTS1;GTI1]
- *
- * will write the selected events into the "EVENTS1" extension and the
- * Good Time Intervals into the "GTI1" extension of the "myfits.fits" FITS
- * file. If the Good Time Intervals extension name is skipped, e.g.
- *
- *      myfits.fits[EVENTS1]
- *
- * the original extension name for the Good Time Intervals will be kept.
- * Analogously, only the Good Time Intervals extension name can be changed
- * by specifying
- *
- *      myfits.fits[;GTI1]
- *
- * In none of the cases will the original events and Good Time Intervals be
- * copied over to the output file.
- ***************************************************************************/
-void ctselect::save_event_list(const GCTAObservation* obs,
-                               const std::string&     infile,
-                               const std::string&     evtname,
-                               const std::string&     gtiname,
-                               const std::string&     outfile) const
-{
-    // Save only if we have an event list
-    if (obs->eventtype() == "EventList") {
-
-        // Set output FITS file event extension names
-        GFilename   outname(outfile);
-        std::string outevt = evtname;
-        std::string outgti = gtiname;
-        if (outname.has_extname()) {
-            std::vector<std::string> extnames =
-                       gammalib::split(outname.extname(), ";");
-            if (extnames.size() > 0) {
-                std::string extname = gammalib::strip_whitespace(extnames[0]);
-                if (!extname.empty()) {
-                    outevt = extname;
-                }
-            }
-            if (extnames.size() > 1) {
-                std::string extname = gammalib::strip_whitespace(extnames[1]);
-                if (!extname.empty()) {
-                    outgti = extname;
-                }
-            }
-        }
-
-        // Create output FITS file
-        GFits outfits;
-
-        // Write observation into FITS file
-        obs->write(outfits, outevt, outgti);
-
-        // Copy all extensions other than evtname and gtiname extensions
-        // from the input to the output event list. The evtname and
-        // gtiname extensions are written by the save method, all others
-        // that may eventually be present have to be copied over
-        // explicitly.
-        GFits infits(infile);
-        for (int extno = 1; extno < infits.size(); ++extno) {
-            GFitsHDU* hdu = infits.at(extno);
-            if (hdu->extname() != evtname &&
-                hdu->extname() != gtiname &&
-                hdu->extname() != outevt  &&
-                hdu->extname() != outgti) {
-                outfits.append(*hdu);
-            }
-        }
-
-        // Close input file
-        infits.close();
-
-        // Save file to disk and close it (we need both operations)
-        outfits.saveto(outname.url(), clobber());
-        outfits.close();
-
-    } // endif: observation was unbinned
-
-    // Return
-    return;
-}
 /***************************************************************************
  *                      ctselect - Data selection tool                     *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2016 by Juergen Knoedlseder                         *
+ *  copyright (C) 2010-2017 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -77,15 +77,8 @@ protected:
     std::string check_infile(const std::string& filename,
                              const std::string& evtname) const;
     std::string set_outfile_name(const std::string& filename) const;
-    std::string get_gtiname(const std::string& filename,
-                            const std::string& evtname) const;
     void        save_fits(void);
     void        save_xml(void);
-    void        save_event_list(const GCTAObservation* obs,
-                                const std::string&     infile,
-                                const std::string&     evtname,
-                                const std::string&     gtiname,
-                                const std::string&     outfile) const;
     // User parameters
     std::string m_outobs;     //!< Output event list or XML file
@@ -1730,6 +1730,145 @@ std::vector&lt;bool&gt; ctool::cube_layer_usage(const GEbounds&amp; cube_ebounds,
 /***********************************************************************//**
+ * @brief Save event list into FITS file
+ *
+ * @param[in] obs Pointer to CTA observation.
+ * @param[in] infile Input file name.
+ * @param[in] evtname Event extension name.
+ * @param[in] gtiname GTI extension name.
+ * @param[in] outfile Output file name.
+ *
+ * Saves an event list and the corresponding Good Time Intervals into a FITS
+ * file and copy all others extensions from the input file to the output
+ * file.
+ *
+ * If an extension name is specified in the @p outfile argument, the events
+ * and eventually also the Good Time Intervals will be extracted from the
+ * argument and used for writing the events. The format is
+ *
+ *      <filename>[<event extension name;GTI extension name>]
+ *
+ * where <filename> needs to be replaced by the name of the FITS file,
+ * and <event extension name;GTI extension name> by the name of the events
+ * and Good Time Intervals extensions. For example 
+ *
+ *      myfits.fits[EVENTS1;GTI1]
+ *
+ * will write the selected events into the `EVENTS1` extension and the
+ * Good Time Intervals into the `GTI1` extension of the `myfits.fits` FITS
+ * file. If the Good Time Intervals extension name is skipped, e.g.
+ *
+ *      myfits.fits[EVENTS1]
+ *
+ * the original extension name for the Good Time Intervals will be kept.
+ * Analogously, only the Good Time Intervals extension name can be changed
+ * by specifying
+ *
+ *      myfits.fits[;GTI1]
+ *
+ * In none of the cases will the original events and Good Time Intervals be
+ * copied over to the output file.
+ ***************************************************************************/
+void ctool::save_event_list(const GCTAObservation* obs,
+                            const std::string&     infile,
+                            const std::string&     evtname,
+                            const std::string&     gtiname,
+                            const std::string&     outfile) const
+{
+    // Save only if we have an event list
+    if (obs->eventtype() == "EventList") {
+
+        // Set output FITS file event extension names
+        GFilename   outname(outfile);
+        std::string outevt = evtname;
+        std::string outgti = gtiname;
+        if (outname.has_extname()) {
+            std::vector<std::string> extnames =
+                       gammalib::split(outname.extname(), ";");
+            if (extnames.size() > 0) {
+                std::string extname = gammalib::strip_whitespace(extnames[0]);
+                if (!extname.empty()) {
+                    outevt = extname;
+                }
+            }
+            if (extnames.size() > 1) {
+                std::string extname = gammalib::strip_whitespace(extnames[1]);
+                if (!extname.empty()) {
+                    outgti = extname;
+                }
+            }
+        }
+
+        // Create output FITS file
+        GFits outfits;
+
+        // Write observation into FITS file
+        obs->write(outfits, outevt, outgti);
+
+        // Copy all extensions other than evtname and gtiname extensions
+        // from the input to the output event list. The evtname and
+        // gtiname extensions are written by the save method, all others
+        // that may eventually be present have to be copied over
+        // explicitly.
+        GFits infits(infile);
+        for (int extno = 1; extno < infits.size(); ++extno) {
+            GFitsHDU* hdu = infits.at(extno);
+            if (hdu->extname() != evtname &&
+                hdu->extname() != gtiname &&
+                hdu->extname() != outevt  &&
+                hdu->extname() != outgti) {
+                outfits.append(*hdu);
+            }
+        }
+
+        // Close input file
+        infits.close();
+
+        // Save file to disk and close it (we need both operations)
+        outfits.saveto(outname.url(), clobber());
+        outfits.close();
+
+    } // endif: observation was unbinned
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Get Good Time Intervals extension name
+ *
+ * @param[in] filename Input file name.
+ * @param[in] evtname Events extension name.
+ *
+ * Extracts the Good Time Intervals extension name from the event file. We
+ * do this by loading the events and accessing the Good Time Intervals
+ * extension name using the GCTAEventList::gtiname() method. If the file name
+ * is empty, the method returns `GTI`.
+ ***************************************************************************/
+std::string ctool::get_gtiname(const std::string& filename,
+                               const std::string& evtname) const
+{
+    // Initialise GTI name
+    std::string gtiname = gammalib::extname_gti;
+
+    // Continue only if the filename is not empty
+    if (!filename.empty()) {
+
+        // Load events
+        GCTAEventList events(filename+"["+evtname+"]");
+
+        // Get GTI name
+        gtiname = events.gtiname();
+
+    }
+
+    // Return GTI name
+    return (gtiname);
+}
+
+
+/***********************************************************************//**
  * @brief Set warning string if there are too few energies
  *
  * @param[in] energies Energies.
 /***************************************************************************
  *                        ctool - ctool base class                         *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014-2016 by Juergen Knoedlseder                         *
+ *  copyright (C) 2014-2017 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -121,6 +121,13 @@ protected:
     std::vector<bool> cube_layer_usage(const GEbounds& cube_ebounds,
                                        const GEbounds& list_ebounds) const;
     bool              is_valid_filename(const GFilename& filename) const;
+    std::string       get_gtiname(const std::string& filename,
+                                  const std::string& evtname) const;
+    void              save_event_list(const GCTAObservation* obs,
+                                      const std::string&     infile,
+                                      const std::string&     evtname,
+                                      const std::string&     gtiname,
+                                      const std::string&     outfile) const;
     // Protected warning strings
     std::string     warn_too_few_energies(const GEnergies& energies) const;
+#! /usr/bin/env python
+# ==========================================================================
+# This scripts performs unit tests for the ctprob tool.
+#
+# Copyright (C) 2017 by Leonardo Di Venere
+#
+# 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
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# ==========================================================================
+import os
+import gammalib
+import ctools
+from testing import test
+
+
+# ============================ #
+# Test class for ctprob tool #
+# ============================ #
+class Test(test):
+    """
+    Test class for ctprob tool
+    """
+    # Constructor
+    def __init__(self):
+        """
+        Constructor
+        """
+        # Call base class constructor
+        test.__init__(self)
+
+        # Set test data
+        self._invalid_events = self._datadir + '/invalid_event_list.fits'
+
+        # Return
+        return
+
+    # Set test functions
+    def set(self):
+        """
+        Set all test functions
+        """
+        # Set test name
+        self.name('ctprob')
+
+        # Append tests
+        self.append(self._test_cmd, 'Test ctprob on command line')
+        self.append(self._test_python, 'Test ctprob from Python')
+
+        # Return
+        return
+
+    # Test ctprob on command line
+    def _test_cmd(self):
+        """
+        Test ctprob on the command line
+        """
+        # Set tool name
+        ctprob = self._tool('ctprob')
+
+        # Setup ctprob command
+        cmd = ctprob+' inobs="'+self._events+'"'+ \
+                     ' outobs="ctprob_cmd1.fits"'+ \
+                     ' inmodel='+self._model+ \
+                     ' caldb='+self._caldb+' irf='+self._irf+ \
+                     ' edisp=no'+ \
+                     ' logfile="ctprob_cmd1.log" chatter=1'
+
+        # Check if execution was successful
+        self.test_assert(self._execute(cmd) == 0,
+             'Check successful execution from command line')
+
+        # Check result file
+        self._check_result_file('ctprob_cmd1.fits')
+
+        # Setup ctprob command
+        cmd = ctprob+' inobs="event_file_that_does_not_exist.fits"'+ \
+                     ' outobs="ctprob_cmd2.fits"'+ \
+                     ' inmodel='+self._model+ \
+                     ' caldb='+self._caldb+' irf='+self._irf+ \
+                     ' edisp=no'+ \
+                     ' logfile="ctprob_cmd2.log" chatter=1'
+
+        # Check if execution failed
+        self.test_assert(self._execute(cmd) != 0,
+             'Check invalid input file when executed from command line')
+
+        # Setup ctprob --help option
+        cmd = ctprob+' --help'
+
+        # Check if execution was successful in case that the CTOOLS
+        # environment variable was set or failed otherwise
+        if 'CTOOLS' in os.environ:
+            self.test_value(self._execute(cmd), 0,
+                 'Check successful execution with --help option')
+        else:
+            self.test_assert(self._execute(cmd) != 0,
+                 'Check execution failure with --help option')
+
+        # Return
+        return
+
+    # Test ctprob from Python
+    def _test_python(self):
+        """
+        Test ctprob from Python
+        """
+        # Allocate empty ctprob tool
+        prob = ctools.ctprob()
+
+        # Check that empty ctprob tool holds an empty observation
+        self._check_obs(prob.obs(), nobs=0)
+
+        # Check that saving does nothing
+        prob['outobs']  = 'ctprob_py0.fits'
+        prob['logfile'] = 'ctprob_py0.log'
+        prob.logFileOpen()
+        prob.save()
+        self.test_assert(not os.path.isfile('ctprob_py0.fits'),
+             'Check that no event list has been created')
+
+        # Check that clearing does not lead to an exception or segfault
+        prob.clear()
+
+        # Now set ctprob parameters
+        prob['inobs']   = self._events
+        prob['outobs']  = 'ctprob_py1.fits'
+        prob['inmodel'] = self._model
+        prob['caldb']   = self._caldb
+        prob['irf']     = self._irf
+        prob['edisp']   = False
+        prob['logfile'] = 'ctprob_py1.log'
+        prob['chatter'] = 2
+
+        # Run ctprob tool
+        prob.logFileOpen()   # Make sure we get a log file
+        prob.run()
+        prob.save()
+
+        # Check result file
+        self._check_result_file('ctprob_py1.fits')
+
+        # Setup ctprob tool for an invalid event file
+        prob = ctools.ctprob()
+        prob['inobs']   = self._invalid_events
+        prob['outobs']  = 'ctprob_py2.fits'
+        prob['inmodel'] = self._model
+        prob['caldb']   = self._caldb
+        prob['irf']     = self._irf
+        prob['edisp']   = False
+        prob['logfile'] = 'ctprob_py2.log'
+        prob['chatter'] = 3
+
+        # Execute tool
+        prob.logFileOpen()  # Needed to get a new log file
+        self.test_try('Test invalid event file')
+        try:
+            prob.execute()
+            self.test_try_failure('Exception not thrown')
+        except RuntimeError:
+            self.test_try_success()
+
+        # Setup ctprob with a list of observations and test prefix
+        prob = ctools.ctprob()
+        prob['inobs']   = self._datadir + '/obs_unbinned.xml'
+        prob['prefix']  = 'ctprob_py3_'
+        prob['outobs']  = 'ctprob_py3_obs.xml'
+        prob['inmodel'] = self._model
+        prob['caldb']   = self._caldb
+        prob['irf']     = self._irf
+        prob['edisp']   = True
+        prob['logfile'] = 'ctprob_py3.log'
+        prob['chatter'] = 4
+
+        # Run ctprob tool
+        prob.logFileOpen()   # Make sure we get a log file
+        prob.execute()
+
+        # Check result file
+        self._check_result_file('ctprob_py3_crab_events.fits')
+
+        # Return
+        return
+
+    # Check result file
+    def _check_result_file(self, filename, nevents=6141):
+        """
+        Check result file
+
+        Parameters
+        ----------
+        filename : str
+            Event list file name
+        nevents : int, optional
+            Expected number of events
+        """
+        # Open result file
+        events = gammalib.GCTAEventList(filename)
+
+        # Check event list
+        self._check_events(events, nevents=nevents)
+
+        # Check that probability columns exist
+        colname1 = 'PROB_Background'
+        colname2 = 'PROB_Crab'
+        self._check_column(filename, colname1)
+        self._check_column(filename, colname2)        
+
+        # Check that the probability values are correctly normalized
+        self._check_normalization(filename, [colname1,colname2])
+
+        # Return
+        return
+
+    # Check observation and event list
+    def _check_obs(self, obs, nobs=1, nevents=6141):
+        """
+        Check observation and event list
+
+        Parameters
+        ----------
+        obs : `~gammalib.GObservations`
+            Models
+        nobs : int, optional
+            Expected number of observations
+        nevents : int, optional
+            Expected number of events
+        """
+        # Check number of observations
+        self.test_value(obs.size(), nobs, 'Check number of observations')
+
+        # If there is an observation then check the event list of the first
+        # one
+        if obs.size() > 0:
+            self._check_events(obs[0].events(), nevents=nevents)
+
+        # Return
+        return
+
+    # Check events
+    def _check_events(self, events, nevents=6141):
+        """
+        Check event list
+
+        Parameters
+        ----------
+        events : `~gammalib.GCTAEventList`
+            Event list
+        nevents : int, optional
+            Expected number of events
+        """
+        # Check event list
+        self.test_value(events.size(), nevents, 'Check number of events')
+
+        # Return
+        return
+
+
+    def _check_column(self, filename, colname):
+        """
+        Check that column colname exists.
+
+        Parameters
+        ----------
+        filename : str
+            Event list file name
+        colname : str
+            Name of the column to check
+        """
+        # Check that column exists
+        gfits = gammalib.GFits(filename)
+        gtable = gfits[1]
+        check = int(gtable.contains(colname))
+        self.test_value(check, 1, 'Check column '+colname)
+
+        # Return
+        return
+
+
+    def _check_normalization(self, filename, colnames):
+        """
+        Check that the probability values in columns identified by colnames are
+        correctly normalized.
+
+        Parameters
+        ----------
+        filename : str
+            Event list file name
+        colnames : list
+            Names of the columns to check
+        """
+        # Check that the probability values are correctly normalized
+
+        # Open fits table
+        gfits  = gammalib.GFits(filename)
+        gtable = gfits[1]
+        ncols  = gtable.ncols()
+        nevt   = gtable.nrows()
+        srcs   = []
+
+        # Loop over colnames
+        for colname in colnames:
+
+            # Get the correct column corresponding to colname from the table
+            for icol in range(ncols):
+                gcol = gtable[icol] 
+                if gcol.name()==colname:
+                    break
+
+            # Read and save column content 
+            src1 = []
+            for ievt in range(nevt):
+                src1.append(gcol[ievt])
+            srcs.extend(src1)
+
+        # Compute sum
+        tot = sum(srcs)
+        self.test_value(int(tot+0.5), nevt, 'Check that probability columns '
+                                            'are normalized')
+
+        # Return
+        return
+
@@ -39,6 +39,7 @@ import test_ctcubemask
 import test_ctbutterfly
 import test_ctulimit
 import test_cterror
+import test_ctprob
 import test_pipelines
@@ -116,6 +117,7 @@ def test(installed=False):
              test_ctbutterfly.Test(),
              test_ctulimit.Test(),
              test_cterror.Test(),
+             test_ctprob.Test(),
              test_pipelines.Test()]
     # Allocate test suite container