Catch exception during ctools construction.

So far any exception occuring during the construction of the ctools were not catched. This is corrected now.

Catch exception during ctools construction.
So far any exception occuring during the construction of the ctools were not catched. This is corrected now.
Jürgen Knödlseder
1 parent 55989652
Showing 16 changed files with 393 additions and 179 deletions
src/ctbin/main.cpp
src/ctbkgcube/main.cpp
src/ctbutterfly/main.cpp
src/ctcubemask/main.cpp
src/ctedispcube/main.cpp
src/cterror/main.cpp
src/ctexpcube/main.cpp
src/ctlike/main.cpp
src/ctmapcube/main.cpp
src/ctmodel/main.cpp
src/ctobssim/main.cpp
src/ctpsfcube/main.cpp
src/ctselect/main.cpp
src/ctskymap/main.cpp
src/cttsmap/main.cpp
src/ctulimit/main.cpp
 /***************************************************************************
- *                    ctbin - CTA data binning main code                   *
+ *                    ctbin - CTA binning tool main code                   *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file ctbin/main.cpp
  * @brief CTA data binning tool main code
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 /* __ Includes ___________________________________________________________ */
@@ -38,21 +38,30 @@
  * @param[in] argc Number of command line arguments.
  * @param[in] argv Command line arguments.
  *
- * This is the main entry point of the gtbin application. It allocates a
- * ctbin object and runs the application.
+ * This is the main entry point of the ctbin application. It allocates a
+ * ctbin object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctbin application(argc, argv);
+    // Initialise pointer on application
+    ctbin* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctbin(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctbin. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctbin. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                  ctbkgcube - CTA background cube tool                   *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014 by Chia-Chun Lu                                     *
+ *  copyright (C) 2014-2016 by Chia-Chun Lu                                *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -39,20 +39,29 @@
  * @param[in] argv Command line arguments.
  *
  * This is the main entry point of the ctbkgcube application. It allocates a
- * ctbkgcube object and runs the application.
+ * ctbkgcube object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctbkgcube application(argc, argv);
+    // Initialise pointer on application
+    ctbkgcube* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctbkgcube(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctbkgcube. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctbkgcube. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                   ctbutterfly - TS map calculation tool                 *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014 by Michael Mayer                                    *
+ *  copyright (C) 2014-2016 by Michael Mayer                               *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -38,21 +38,30 @@
  * @param[in] argc Number of command line arguments.
  * @param[in] argv Command line arguments.
  *
- * This is the main entry point of the ctbutterfly application. It allocates a
- * ctbutterfly object and runs the application.
+ * This is the main entry point of the ctbutterfly application. It allocates
+ * a ctbutterfly object and executes the application. Any exceptions that
+ * occur will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctbutterfly application(argc, argv);
+    // Initialise pointer on application
+    ctbutterfly* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctbutterfly(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctbutterfly. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctbutterfly. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                ctcubemask - CTA mask cube tool main code                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014 Chia-Chun Lu                                        *
+ *  copyright (C) 2014-2016 Chia-Chun Lu                                   *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -37,19 +37,31 @@
  *
  * @param[in] argc Number of arguments
  * @param[in] argv Arguments
+ *
+ * This is the main entry point of the ctcubemask application. It allocates
+ * a ctcubemask object and executes the application. Any exceptions that
+ * occur will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctcubemask application(argc, argv);
+    // Initialise pointer on application
+    ctcubemask* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctcubemask(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -58,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctcubemask. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctcubemask. Run aborted ...";
  
-        // Write error in logger
-        application.log << message << std::endl;
-        application.log << signal  << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << message << std::endl;
@@ -38,21 +38,30 @@
  * @param[in] argc Number of command line arguments.
  * @param[in] argv Command line arguments.
  *
- * This is the main entry point of the ctedispcube application. It allocates a
- * ctedispcube object and runs the application.
+ * This is the main entry point of the ctedispcube application. It allocates
+ * a ctedispcube object and executes the application. Any exceptions that
+ * occur will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctedispcube application(argc, argv);
+    // Initialise pointer on application
+    ctedispcube* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctedispcube(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctedispcube. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctedispcube. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                  cterror - Parameter error calculation tool             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2015 by Florent Forest                                   *
+ *  copyright (C) 2015-2016 by Florent Forest                              *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -39,20 +39,29 @@
  * @param[in] argv Command line arguments.
  *
  * This is the main entry point of the cterror application. It allocates a
- * cterror object and runs the application.
+ * cterror object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    cterror application(argc, argv);
+    // Initialise pointer on application
+    cterror* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new cterror(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " cterror. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "cterror. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                  ctexpcube - CTA exposure cube tool                     *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014 by Juergen Knoedlseder                              *
+ *  copyright (C) 2014-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -39,20 +39,29 @@
  * @param[in] argv Command line arguments.
  *
  * This is the main entry point of the ctexpcube application. It allocates a
- * ctexpcube object and runs the application.
+ * ctexpcube object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctexpcube application(argc, argv);
+    // Initialise pointer on application
+    ctexpcube* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctexpcube(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctexpcube. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctexpcube. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *               ctlike - CTA maximum likelihood tool main code            *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file ctlike/main.cpp
  * @brief CTA maximum likelihood tool main code
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 /* __ Includes ___________________________________________________________ */
@@ -39,20 +39,29 @@
  * @param[in] argv Arguments
  *
  * This is the main entry point of the ctlike application. It allocates a
- * ctlike object and executes the application.
+ * ctlike object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctlike application(argc, argv);
+    // Initialise pointer on application
+    ctlike* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctlike(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctlike. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctlike. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
@@ -38,21 +38,30 @@
  * @param[in] argc Number of command line arguments.
  * @param[in] argv Command line arguments.
  *
- * This is the main entry point of the gtbin application. It allocates a
- * ctmapcube object and runs the application.
+ * This is the main entry point of the ctmapcube application. It allocates a
+ * ctmapcube object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctmapcube application(argc, argv);
+    // Initialise pointer on application
+    ctmapcube* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctmapcube(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctmapcube. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctmapcube. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                     ctmodel - CTA counts model tool                     *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2012 by Juergen Knoedlseder                              *
+ *  copyright (C) 2012-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -38,21 +38,30 @@
  * @param[in] argc Number of command line arguments.
  * @param[in] argv Command line arguments.
  *
- * This is the main entry point of the gtbin application. It allocates a
- * ctmodel object and runs the application.
+ * This is the main entry point of the ctmodel application. It allocates a
+ * ctmodel object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctmodel application(argc, argv);
+    // Initialise pointer on application
+    ctmodel* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctmodel(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,13 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctmodel. Run aborted ...";
-
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctmodel. Run aborted ...";
  
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
         // Write error on standard output
         std::cout << signal  << std::endl;
         std::cout << message << std::endl;
 /***************************************************************************
  *           ctobssim - CTA observation simulator tool main code           *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011-2013 by Juergen Knoedlseder                         *
+ *  copyright (C) 2011-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -37,19 +37,31 @@
  *
  * @param[in] argc Number of arguments.
  * @param[in] argv Arguments.
+ *
+ * This is the main entry point of the ctobssim application. It allocates a
+ * ctobssim object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctobssim application(argc, argv);
+    // Initialise pointer on application
+    ctobssim* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctobssim(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -58,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctobssim. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctobssim. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                    ctpsfcube - CTA PSF cube tool                        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014 by Chia-Chun Lu                                     *
+ *  copyright (C) 2014-2016 by Chia-Chun Lu                                *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -39,20 +39,29 @@
  * @param[in] argv Command line arguments.
  *
  * This is the main entry point of the ctpsfcube application. It allocates a
- * ctpsfcube object and runs the application.
+ * ctpsfcube object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctpsfcube application(argc, argv);
+    // Initialise pointer on application
+    ctpsfcube* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctpsfcube(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctpsfcube. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctpsfcube. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                ctselect - CTA data selection tool main code             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2013 by Juergen Knoedlseder                         *
+ *  copyright (C) 2010-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -37,19 +37,31 @@
  *
  * @param[in] argc Number of arguments
  * @param[in] argv Arguments
+ *
+ * This is the main entry point of the ctselect application. It allocates a
+ * ctselect object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctselect application(argc, argv);
+    // Initialise pointer on application
+    ctselect* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctselect(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -58,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctselect. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctselect. Run aborted ...";
  
-        // Write error in logger
-        application.log << message << std::endl;
-        application.log << signal  << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << message << std::endl;
 /***************************************************************************
  *                   ctskymap - CTA sky mapping main code                  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2013 by Juergen Knoedlseder                         *
+ *  copyright (C) 2010-2016 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -39,20 +39,29 @@
  * @param[in] argv Command line arguments.
  *
  * This is the main entry point of the ctskymap application. It allocates a
- * ctskymap object and runs the application.
+ * ctskymap object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctskymap application(argc, argv);
+    // Initialise pointer on application
+    ctskymap* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctskymap(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctskymap. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctskymap. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                      cttsmap - TS map calculation tool                  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014 by Michael Mayer                                    *
+ *  copyright (C) 2014-2016 by Michael Mayer                               *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -39,20 +39,29 @@
  * @param[in] argv Command line arguments.
  *
  * This is the main entry point of the cttsmap application. It allocates a
- * cttsmap object and runs the application.
+ * cttsmap object and executes the application. Any exceptions that occur
+ * will be catched and corresponding error messages written in the
+ * application logger and on the standard output.
  ***************************************************************************/
 int main (int argc, char *argv[])
 {
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    cttsmap application(argc, argv);
+    // Initialise pointer on application
+    cttsmap* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new cttsmap(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +70,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " cttsmap. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "cttsmap. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;
 /***************************************************************************
  *                  ctulimit - upper limit calculation tool                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2015 by Michael Mayer                                    *
+ *  copyright (C) 2015-2016 by Michael Mayer                               *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -46,13 +46,20 @@ int main (int argc, char *argv[])
     // Initialise return code
     int rc = 1;
  
-    // Create instance of application
-    ctulimit application(argc, argv);
+    // Initialise pointer on application
+    ctulimit* application = NULL;
  
-    // Run application
+    // Execute application
     try {
+
+        // Create instance of application
+        application = new ctulimit(argc, argv);
+
         // Execute application
-        application.execute();
+        application->execute();
+
+        // Delete application
+        delete application;
  
         // Signal success
         rc = 0;
@@ -61,12 +68,16 @@ int main (int argc, char *argv[])
  
         // Extract error message
         std::string message = e.what();
-        std::string signal  = "*** ERROR encounterted in the execution of"
-                              " ctulimit. Run aborted ...";
+        std::string signal  = "*** ERROR encounterted in the execution of "
+                              "ctulimit. Run aborted ...";
  
-        // Write error in logger
-        application.log << signal  << std::endl;
-        application.log << message << std::endl;
+        // If application exists then write error in logger and delete
+        // application
+        if (application != NULL) {
+            application->log << signal  << std::endl;
+            application->log << message << std::endl;
+            delete application;
+        }
  
         // Write error on standard output
         std::cout << signal  << std::endl;