Merge branch 'hess' into comptel

Jürgen Knödlseder
2 parents 9bf38725 e779cc94
Showing 412 changed files with 12415 additions and 8668 deletions
AUTHORS
ChangeLog
NEWS
configure.ac
doc/Doxyfile
doc/dev/coding/gammalib_coding.tex
doc/dev/coding/manual.sty
doc/gammalib_um.tex
doc/manual.sty
gammalib.pc.in
gammalib.sh
include/GApplication.hpp
include/GBase.hpp
include/GCaldb.hpp
include/GCsv.hpp
include/GDerivative.hpp
include/GEbounds.hpp
include/GEnergy.hpp
include/GEvent.hpp
include/GEvents.hpp
 Juergen Knoedlseder (jurgen.knodlseder@irap.omp.eu) - overall design
 Christoph Deil (Christoph.Deil@mpi-hd.mpg.de)       - radial models
 Jean-Baptiste Cayrou (cayrou@etud.insa-toulouse.fr) - openmp support, test suite
+Mathieu De Naurois (denauroi@in2p3.fr)              - HESS support
+2012-10-14  Juergen Knoedlseder  <jurgen.knodlseder@irap.omp.eu>
+
+        * Version 0.7.0 released
+        ========================
+
+        Add base module for interface classes
+        Introduce GBase from which almost all classes derive
+        Add dependency tracking for Python interface
+
 2012-09-17  Juergen Knoedlseder  <jurgen.knodlseder@irap.omp.eu>
  
         * Bug fix version 0.6.2 released
-New Features and Important Changes in GammaLib 00-06-02
+New Features and Important Changes in GammaLib 00-07-00
  
 Author(s) : Juergen Knoedlseder
  
-September, 17th, 2012
+October, 14th, 2012
  
  
 1. Introduction
@@ -13,42 +13,7 @@ changes made since the last release of GammaLib.
  
 2. Configuration
 -----------------
-The clang++ compiler takes now only precedence over the g++ compiler
-if the system on which compilation is performed is Mac OS X 10.7 or
-later.
-
-If Python bindings are disabled we omit now all the Python related
-checks during configuration. This includes detection of the Python
-executable, detection of the swig executable, and the checks for the
-presence of the Python wrapper files.
-
-The Apple gcc compiler requires the gomp_thread_attr global to be
-defined when OpenMP functions are called without having any OpenMP
-section in the code. This specific requirement is now detected in
-the configure script using some dedicated test code, and the compile
-definition HAVE_OPENMP_DARWIN_KLUGE is set that allows inclusion of
-the appropriate code when needed.
-
-Furthermore, the OPENMP_LIB_LDFLAGS is not set to -lgomp on Darwin
-anymore as this appears not to be needed.
-
-The MACOSX_DEPLOYMENT_TARGET environment variable is now only exported
-when the --enable-universalsdk option is specified. This solved problems
-related to uncatched exceptions in unit tests. Possibly, these uncatched
-exceptions were due to weak linking, a feature that exists since Mac OS
-X version 10.2. By not exporting MACOSX_DEPLOYMENT_TARGET, Mac OS X
-version 10.1 is assumed.
-
-The Python bindings configuration has been improved to handle also
-the MacPorts gcc compiler on Mac OS X. Static linking during unit
-testing has been removed as this is no longer needed (don't ask me why).
-The double compilation for unit check has also be removed. A static
-link is used instead that allows adding of the wrapper directory to
-the PYTHONPATH.
-
-The TEST_ENV_DIR environment variable is also added to the load
-library path in the GammaLib setup script. This ensures the correct
-loading of shared libraries in non-standard locations.
+None
  
  
 3. Application module
@@ -56,67 +21,80 @@ loading of shared libraries in non-standard locations.
 None
  
  
-4. FITS I/O Interface
+4. Base module
+--------------
+This new module was introduced to implement interface classes that are
+used to define standard interfaces for GammaLib classes. 
+
+The basis of most classes is the GBase class. This class requires the
+clear, clone, and print methods to be present. The ostream and GLog
+functions are now also implement at the GBase level, hence classes do 
+not need to implement the output streamers anymore. Classes that do not
+derive from GBase are essentially internal classes that are not expected
+to be used by a GammaLib user.
+
+
+5. FITS I/O Interface
 ---------------------
 None
  
  
-5. Linear algebra module
+6. Linear algebra module
 ------------------------
 None
  
  
-6. Model module
+7. Model module
 ---------------
 None
  
  
-7. Numerics module
+8. Numerics module
 ------------------
 None
  
  
-8. Observation module
+9. Observation module
 ---------------------
 None
  
  
-9. Optimization module
-----------------------
+10. Optimization module
+-----------------------
 None
  
  
-10. Sky module
+11. Sky module
 --------------
 None
  
  
-11. Support module
+12. Support module
 ------------------
 None
  
  
-12. XML module
+13. XML module
 --------------
 None
  
  
-13. Test module
+14. Test module
 ---------------
 None
  
  
-14. Multi-wavelength interface
+15. Multi-wavelength interface
 ------------------------------
 None
  
  
-15. Fermi-LAT interface
+16. Fermi-LAT interface
 ----------------------
 None
  
  
-16. CTA interface
+17. CTA interface
 -----------------
 None
  
@@ -29,10 +29,12 @@
 #############################################################################
 # Initialisation                                                            #
 #############################################################################
-AC_INIT([gammalib], [0.6.2], [jurgen.knodlseder@irap.omp.eu], [gammalib])
+AC_INIT([gammalib], [0.7.0], [jurgen.knodlseder@irap.omp.eu], [gammalib])
 AC_CONFIG_SRCDIR([src/support/GTools.cpp])
 AC_CONFIG_MACRO_DIR([m4])
-AM_INIT_AUTOMAKE([gnu no-dependencies])
+#AM_INIT_AUTOMAKE([gnu no-dependencies])
+AM_INIT_AUTOMAKE([gnu no-dependencies -Wno-portability])
+#AM_INIT_AUTOMAKE([gnu -Wno-portability])
 AM_CONFIG_HEADER([config.h])
  
  
@@ -670,8 +672,8 @@ if test &quot;x$openmp_ok&quot; = &quot;xyes&quot; ; then
   # dynamically
   if test "$OPENMP_CXXFLAGS" = "-fopenmp" -a "$ac_sys_system" = "Linux"; then
     AC_MSG_CHECKING(whether we can dynamically load libgomp)
-    SAVED_LDFLAGS=$LDFLAGS
-    LDFLAGS="$LDFLAGS -ldl"
+    SAVED_LIBS=$LIBS
+    LIBS="-ldl"
     AC_TRY_RUN(AC_LANG_PROGRAM([#include <dlfcn.h>],
                                [if (dlopen("libgomp.so.1", RTLD_NOW) == 0) return 1;]),
                [AC_MSG_RESULT(yes)],
@@ -679,7 +681,7 @@ if test &quot;x$openmp_ok&quot; = &quot;xyes&quot; ; then
                 AC_MSG_RESULT(no)
                 AC_MSG_WARN([OpenMP detected but shared libgomp.so.1 library cannot be dlopen()ed.])
                 AC_MSG_WARN([If you use a gcc 4.2.x compiler, this is a known feature. Try to use gcc >= 4.3.])])
-    LDFLAGS=$SAVED_LDFLAGS
+    LIBS=$SAVED_LIBS
   fi
  
   # Special Darwin test to see whether OpenMP compiles without adding the
@@ -850,6 +852,7 @@ else
   # Do we have Python wrappers
   has_wrappers="yes"
   AC_CHECK_FILES([pyext/gammalib/app_wrap.cpp pyext/gammalib/app.py
+                  pyext/gammalib/base_wrap.cpp pyext/gammalib/base.py
                   pyext/gammalib/fits_wrap.cpp pyext/gammalib/fits.py
                   pyext/gammalib/linalg_wrap.cpp pyext/gammalib/linalg.py
                   pyext/gammalib/model_wrap.cpp pyext/gammalib/model.py
@@ -1196,7 +1199,7 @@ if [test &quot;x$add_gammalib_prefix&quot; = &quot;xyes&quot;]; then
 fi
 if [test "x$add_opt_local" = "xyes"]; then
     LDFLAGS="$LDFLAGS -L/opt/local/lib"
-    TEST_ENV_DIR="$TEST_ENV_DIR:/opt/local/lib"
+    #TEST_ENV_DIR="$TEST_ENV_DIR:/opt/local/lib"
 fi
 if [test "x$add_usr_local" = "xyes"]; then
     LDFLAGS="$LDFLAGS -L/usr/local/lib"
@@ -1223,6 +1226,7 @@ DX_INIT_DOXYGEN([GammaLib], [doc/Doxyfile], [doc/doxygen])
 #############################################################################
 AC_CONFIG_FILES([Makefile
                  src/Makefile
+                 src/base/Makefile
                  src/support/Makefile
                  src/linalg/Makefile
                  src/numerics/Makefile
@@ -31,7 +31,7 @@ PROJECT_NAME           = GammaLib
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
  
-PROJECT_NUMBER         = 00-06-02
+PROJECT_NUMBER         = 00-07-00
  
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% GammaLib Coding conventions
+% GammaLib Coding and Design Conventions
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -7,12 +7,11 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \newcommand{\task}{\mbox{GammaLib}}
 \newcommand{\this}{\mbox{\tt \task}}
-\newcommand{\shorttype}{\mbox{CCD}}
-\newcommand{\doctype}{\mbox{Coding Conventions Document}}
+\newcommand{\shorttype}{\mbox{CDC}}
+\newcommand{\doctype}{\mbox{Coding and Design Conventions}}
 \newcommand{\version}{\mbox{draft}}
-\newcommand{\calendar}{\mbox{10 November 2011}}
+\newcommand{\calendar}{\mbox{12 October 2012}}
 \newcommand{\auth}{\mbox{J\"urgen Kn\"odlseder}}
-\newcommand{\approv}{\mbox{J\"urgen Kn\"odlseder}}
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -35,10 +34,22 @@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Introduction}
  
-The present document summarises the coding conventions that should be
-followed in implementing the \this\ toolbox.
-The respect of coherent coding conventions throughout the code
-improves code readibility and enhances the portability of the code.
+This document summarises the coding and design conventions that should be following for
+the \this\ development.
+
+Respecting uniform and coherent coding and design conventions is crucial for software
+development.
+They improve code readability, ease code development and maintenance, ensure code
+portability, and provide standards for the user interface.
+
+Coding and design conventions were introduced at a very early stage of the \this\ project, and
+are followed as strictly as possible.
+The choices that were made for \this\ were inspired by a large survey of existing C++ coding
+rules, combined with the experience of the leading code developers.
+Obviously, there is no single best way to code in C++, and the adopted conventions may not
+meet the coding usage of individual developers.
+They should nevertheless be respected strictly, as the \this\ code base is already very large,
+and assuring uniformity and coherence is a primary goal of the project.
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -46,95 +57,590 @@ improves code readibility and enhances the portability of the code.
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{General coding rules}
  
-The following general rules should be followed:
-\begin{itemize}
-\item[R1] Each function and/or method terminates with a {\tt return} statement.
-\item[R2] Each function and/or method has only a single exit point (i.e. a single {\tt return} statement).
-\item[R3] Put a blank line at the end of each file.
-\item[R4] Use {\tt explicit} for constructors to avoid use of the constructor for unintended
-type conversion.
-\item[R5] Do not use tabs to make code formating independent of editor configurations.
-\item[R6] Blocks are indented by 4 characters.
-\end{itemize}
-
+This section provides lists of general coding rules for the \this\ development.
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Coding style
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\section{Coding style}
+\subsection{C++ rules}
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Code configuration}
-
-The code configuration is controlled via an include file that has to be added on top of
-each source file.
-Each source file should start with:
+\paragraph{Code format}
  
+\begin{itemize}
+\item Blocks are indented by 4 characters.
+\item Do not use tabs (code formatting should be independent of editor configurations).
+\item Do not exceed a line length of 80 characters (a few more characters are in exceptional cases acceptable).
+\item Put a blank line at the end of each file (this is required by some compilers).
+\item Each function starts with a curly bracket in the line following the function name.
+The return type is in the same line as the function name. Example:
 \begin{verbatim}
-/* __ Includes ___________________________________________________________ */
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+void function(void)
+{
+    int = 0;
+    return;
+}
+\end{verbatim}
+\item Each block should be encompassed in curly brackets, even if the block consists only
+of a single line.
+\item The opening curly bracket of a block starts in the same line as the related statement. 
+Example:
+\begin{verbatim}
+for (int i = 0; i < 10; ++i) {
+    sum += i;
+}
+\end{verbatim}
+\item Use spaces between code elements (see above example).
+\item Align successive similar lines on common elements.
+Example illustrating the alignment on the {\tt =} symbol:
+\begin{verbatim}
+m_max    = par.m_max;
+m_prompt = par.m_prompt;
+sum     += par.m_sum;
 \end{verbatim}
+Example illustrating the alignment in a class definition on the member function name:
+\begin{verbatim}
+void        log10GeV(const double& eng);
+void        log10TeV(const double& eng);
+std::string print(void) const;
+\end{verbatim}
+\end{itemize}
  
-Note that the {\tt config.h} file should {\bf not be included in header files}, since header file
-are used by the outside world for which a different {\tt config.h} include file may exist.
  
-One of the most common options used throughout \this\ is range checking.
-Range checking is particularily important during code development since it allows to catch
-memory leaks.
-However, range checking is time consuming and thus leads to somewhat slower code.
-Range checking can thus be disable during installation of \this\ by using
-{\tt ./configure --disable-range-check} during library installation.
-Within the code, the following instruction adds range checking that dependens on
-the library configuration:
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\paragraph{Code semantics}
  
+\begin{itemize}
+\item Each function and/or method terminates with a {\tt return} statement.
+\item Each function and/or method has only a single exit point (i.e. a single {\tt return} statement).
+\item Use {\tt explicit} for constructors with arguments to prevent unintended type conversions.
+The only exception to this rule is the copy constructor or type conversion constructors.
+\item Specify {\tt void} for function definitions without arguments.
+\item Use pre incrementation in loops (pre incrementation is faster than post incrementation).
+Example:
 \begin{verbatim}
-#if defined(G_RANGE_CHECK)
-if (inx < 0 || inx >= m_num)
-    throw GException::out_of_range("GVector::operator(int)", inx, m_num);
-#endif
+for (int i = 0; i < 10; ++i) {
+    sum += i;
+}
 \end{verbatim}
+\item Where possible (and appropriate), use {\tt std::vector} containers instead of
+allocating memory. In other words: avoid direct memory allocation.
+\item Provide comments, comments, comments!!!
+\end{itemize}
  
-Range checking is provided if the {\tt G\_RANGE\_CHECK} macro is defined.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\paragraph{Language features}
+
+\begin{itemize}
+\item Do not use templates.
+\item Do not use macros.
+\item Do not use namespaces.
+\item Do not use {\tt \#define} directives for the declaration of constants. Use {\tt const} instead.
+\item Do not use {\tt std::strncpy}, {\tt std::memcpy} or similar as these functions are corrupted on
+some systems.
+\item If possible, pass arguments by reference.
+\item Use C++ (std::string) instead of C-style (char*) strings.
+\item Use C++ casts instead of C-style casts.
+\end{itemize}
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Header inclusions}
+% Coding conventions
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{Coding conventions}
+
+The style summarizes coding conventions for the \this\ development.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsection{C++ classes}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsubsection{General rules}
+
+Each class should be defined in a pair of individual files:
+\begin{itemize}
+\item a header file that defines the class interface (with filename suffix {\tt .hpp})
+\item a source code file that implements the class (with filename suffix {\tt .cpp})
+\end{itemize}
+In addition, a SWIG interface file should be provided for the Python bindings (with filename suffix {\tt .i}).
  
 Each file should contain the {\tt \#include} directives that are necessary for compilation of
 the specific file.
-Only {\tt \#include} directives that are already given by the corresponding header file can
-be omitted.
-
-As \this\ is written in C++, the C++ style headers should be used instead of the C style
-headers to ensure maximum portability.
-Examples of common C++ style headers are
-{\tt <cstdio>} (instead of {\tt <stdio.h>}),
-{\tt <cmath>} (instead of {\tt <math.h>}),
-{\tt <cstring>} (instead of {\tt <string.h>}), etc.
-Functions and types should then be prefixed by {\tt std::}.
+{\tt \#include} directives that are specified in the header file can be omitted in the source code
+file, provided that the header file is include in the source code file.
+
+The C++ style header files should be used instead of the C style header files to ensure 
+maximum portability.
+The following table provides the correspondence between C++ and C header files for
+headers commonly used in \this.
+
+%%% Header files correspondence %%%%%%%%%%%%%%%%%%%%%%%%%%%
+\begin{center}
+\begin{tabular}{lll}
+\hline
+\hline
+\noalign{\smallskip}
+C++ & C & Function examples \\
+\noalign{\smallskip}
+\hline
+\noalign{\smallskip}
+{\tt <cctype>} & & \\
+{\tt <cmath>} & {\tt <math.h>} & {\tt std::abs}, {\tt std::cos} \\
+{\tt <cfloat>} & & \\
+{\tt <cstdio>} & {\tt <stdio.h>} & {\tt std::fopen}, {\tt std::fgets}, {\tt std::fclose}, {\tt std::fprintf}, {\tt std::sprintf} \\
+{\tt <cstdlib>} & & \\
+{\tt <cstring>} & {\tt <string.h>} & {\tt std::strlen} \\
+\noalign{\smallskip}
+\hline
+\end{tabular}
+\end{center}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+Note that functions and types should be prefixed by {\tt std::}.
 For example,
 {\tt cos} becomes {\tt std::cos},
 {\tt time\_t} becomes {\tt std::time\_t}, etc.
-One significant change is that {\tt fabs} becomes {\tt std::abs} since
+One significant change between C and C++ is that {\tt fabs} becomes {\tt std::abs} since
 the C style {\tt abs} function only applies to integers.
 Here, the {\tt std::} prefix is crucial to distinguish the C++ function (which is
 also defined for doubles) from the C function.
  
-Note also that some compilers are more tolerant in omitting {\tt \#include} directives, such
-as {\tt <cstdio>} or {\tt <cstring>}, so these directives should also be included for compatibility,
-even if they seem not to be required on specific systems.
-Examples of include directives needed by common functions are:
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsubsection{Header file structure}
+\label{sec:header}
+
+The header file defines the interface of the class.
+Here is an example of a header file.
+\begin{verbatim}
+/***************************************************************************
+ *                        GClass.hpp  -  My nice class                     *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  This program is free software: you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  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 GClass.hpp
+ * @brief Definition of my nice class interface
+ * @author Juergen Knoedlseder
+ */
+
+#ifndef GCLASS_HPP
+#define GCLASS_HPP
+
+/* __ Includes ___________________________________________________________ */
+#include <string>
+#include <iostream>
+#include "GLog.hpp"
+
+
+/***********************************************************************//**
+ * @class GClass
+ *
+ * @brief Illustration of a GammaLib class
+ *
+ * My nice class illustrates how a GammaLib class should be defined.
+ ***************************************************************************/
+class GClass {
+
+    // I/O friends
+    friend std::ostream& operator<< (std::ostream& os, const GClass& c);
+    friend GLog&         operator<< (GLog& log, const GClass& c);
+
+public:
+    // Constructors and destructors
+    GClass(void);
+    GClass(const GClass& c);
+    virtual ~GClass(void);
+ 
+    // Operators
+    GClass& operator= (const GClass& c);
+
+    // Methods
+    void        clear(void);
+    GClass*     clone(void) const;
+    std::string print(void) const;
+  
+protected:
+    // Protected methods
+    void init_members(void);
+    void copy_members(const GClass& c);
+    void free_members(void);
+
+    // Protected data members
+    std::string     m_name;          //!< Name
+};
+
+#endif /* GCLASS_HPP */
+\end{verbatim}
+
+The header file starts with a comment containing the file name and class purpose, the
+copyright information and the license text.
+The years in the copyright information should cover the years over which the file has been
+modified, the author is the person who initially created the file.
+
+Following the header comment is a comment that provides file information to the
+Doxygen documentation system.
+
+The subsequent
+\begin{verbatim}
+    #ifndef GCLASS_HPP
+    #define GCLASS_HPP
+\end{verbatim}
+declarations together with the 
+\begin{verbatim}
+    #endif /* GCLASS_HPP */
+\end{verbatim}
+declaration at the end protect the file from multiple inclusions of the header.
+This is a crucial feature needed for proper compilation of the code.
+
+Now all header files are included.
+Standard header files are included using the {\tt < >} brackets, \this\ header files are included
+using {\tt " "}.
+A 80 character long separator precedes the header inclusion.
+Further 80 character long separators may be added for additional sections, such as
+constants, type definitions, forward declarations, etc.
+Use one separator to precede each additional section.
+
+The class definition is preceded by a comment block that will be used by the Doxygen system
+to extract the class definition.
+Provide here the class name, a brief one line description of the class, and an extended
+detailed description of the class purpose.
+
+The class definition is structured in several sections:
+\begin{itemize}
+\item Declaration of friend functions
+\item Definition of public constructors
+\item Definition of public operators
+\item Definition of public methods
+\item Definition of protected methods
+\item Definition of protected members
+\end{itemize}
+The definition of pure virtual methods should be done in a section that is separate from the
+methods that are implemented.
+Output stream and logging operators should be implemented for every class as friend
+operators.
+
+Here any illustration of the expected structure, based on the {\tt GObservation} class:
+\begin{verbatim}
+class GObservation {
+
+    // Friend classes
+    friend std::ostream& operator<< (std::ostream& os, const GObservation& obs);
+    friend GLog&         operator<< (GLog& log,        const GObservation& obs);
+
+public:
+    // Constructors and destructors
+    GObservation(void);
+    GObservation(const GObservation& obs);
+    virtual ~GObservation(void);
+
+    // Operators
+    virtual GObservation& operator= (const GObservation& obs);
+
+    // Pure virtual methods
+    virtual void          clear(void) = 0;
+    virtual GObservation* clone(void) const = 0;
+
+    // Virtual methods
+    virtual double        model(const GModels& models, const GEvent& event,
+                                GVector* gradient = NULL) const;
+    virtual double        npred(const GModels& models, GVector* gradient = NULL) const;
+
+    // Implemented methods
+    void                  name(const std::string& name);
+    void                  id(const std::string& id);
+
+protected:
+    // Protected methods
+    void init_members(void);
+    void copy_members(const GObservation& obs);
+    void free_members(void);
+
+    // Protected data area
+    std::string m_name;         //!< Name of observation
+    std::string m_id;           //!< Observation identifier
+    std::string m_statistics;   //!< Optimizer statistics (default=poisson)
+    GEvents*    m_events;       //!< Pointer to event container
+};
+\end{verbatim}
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsubsection{Source code file structure}
+\label{sec:sourcecode}
+
+The source code file implements the code of the class.
+Here is an example of the start of a source code file.
+\begin{verbatim}
+/***************************************************************************
+ *                        GClass.cpp  -  My nice class                     *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  This program is free software: you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  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 GClass.cpp
+ * @brief Implementation of my nice class
+ * @author Juergen Knoedlseder
+ */
+
+/* __ Includes ___________________________________________________________ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "GClass.hpp"
+#include "GTools.hpp"
+
+/* __ Method name definitions ____________________________________________ */
+#define G_CLEAR                                             "GClass::clear()"
+#define G_CLONE                                       "GClass::clone() const"
+#define G_PRINT                                       "GClass::print() const"
+
+/* __ Compile options ____________________________________________________ */
+#define G_USE_MY_OPTION
+
+/* __ Debug options ______________________________________________________ */
+#define G_DEBUG_PRINT
+
+/* __ Constants __________________________________________________________ */
+const double pi = 3.14;
+\end{verbatim}
+
+The include section starts with a conditional include of the code configuration header file
+(see section \ref{sec:configure}).
+This makes \this\ compile options available to the source code.
+
+The include section is followed by the declaration of method names.
+These method names will be used in exceptions (see section \ref{sec:exceptions}).
+Define the method names at the top of the file eases the maintainability of the code,
+as changes in method names or interfaces need only to be implemented in a single 
+place.
+Method names need only be defined for methods throwing exceptions.
+
+Compile options are used to control which parts of the code should be compiled.
+Such options may be used, for example, to compare different algorithms or computation
+methods.
+They can also be used during development, allowing an easy switch between the new and
+the old code for comparison.
+
+Debug options are compile options that are used to add additional code for debugging.
+Often, these are print statements that allow to trace the execution of the code.
+For code checked into the repository, all debug options should be commented out.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsection{Python classes}
+\label{sec:pyhton}
+
+The Python interface for C++ classes is defined by a so-called SWIG interface file.
+SWIG uses these interface files to build Python wrapper files, which are C files
+that define the interface between \this\ and Python.
+The structure of the SWIG interface file follows closely that of the header file, with
+a few exceptions.
+Here an example:
+\begin{verbatim}
+/***************************************************************************
+ *                         GClass.i  -  My nice class                      *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  This program is free software: you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  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 GClass.i
+ * @brief Python interface of my nice class
+ * @author Juergen Knoedlseder
+ */
+%{
+/* Put headers and other declarations here that are needed for compilation */
+#include "GClass.hpp"
+#include "GTools.hpp"
+%}
+
+
+/***********************************************************************//**
+ * @class GClass
+ *
+ * @brief Illustration of a GammaLib class
+ *
+ * My nice class illustrates how a GammaLib class should be defined.
+ ***************************************************************************/
+class GClass {
+public:
+    // Constructors and destructors
+    GClass(void);
+    GClass(const GClass& c);
+    virtual ~GClass(void);
+
+    // Methods
+    void        clear(void);
+    GClass*     clone(void) const;
+};
+
+
+/***********************************************************************//**
+ * @brief GClass class extension
+ ***************************************************************************/
+%extend GClass {
+    char *__str__() {
+        return tochar(self->print());
+    }
+    GClass copy() {
+        return (*self);
+    }
+};
+\end{verbatim}
+
+The code starts with a section that is enclosed in {\tt \%\{  \%\}} brackets.
+In this section, all header files are specified that are needed to compile the SWIG wrapper
+file.
+
+Then follows the class definition, with the following differences with respect to the
+definition in the header file:
 \begin{itemize}
-\item[] {\tt <cstdio>} contains {\tt std::fopen}, {\tt std::fgets}, {\tt std::fclose}, {\tt std::fprintf}, {\tt std::sprintf}
-\item[] {\tt <cstring>} contains {\tt std::strncpy}, {\tt std::memcpy}
+\item it does not include the assignment operator
+\item it does not include any access operator (these have to be implemented specifically, see below)
+\item it does not include the {\tt print()} method (see below)
+\item it does not include protected or private members
 \end{itemize}
  
-If possible, however, {\tt std::strncpy} and {\tt std::memcpy} should be avoided at all as these
-functions happend to have some compatibility problems in the past.
+Finally, there is a section with extension to the C++ class.
+Here, methods are implement that do not exist in the actual C++ class, but that will
+exist in the Python interface.
+In this example, the {\tt\_\_str\_\_()} method is the generic Python conversion operator that
+converts an object into a string.
+It can be seen that this method calls the class's @print()@ method.
+By providing the conversion method, the class becomes "printable", and one
+my specify
+\begin{verbatim}
+>>> GClass c
+>>> print c
+\end{verbatim}
+to print out the class (i.e. to invoke the print() method of the class).
+
+In case that an access operator needs to be implement, the {\tt\_\_getitem\_\_()} and {\tt\_\_setitem\_\_()}
+methods need to be added to the class extensions.
  
  
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Design conventions
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section{Design conventions}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsection{Code configuration}
+\label{sec:configure}
+
+The code configuration is controlled via the {\tt config.h} header file that is created during the
+configuration step of \this.
+To make configuration options available the following code has to be added to the
+source code file:
+\begin{verbatim}
+/* __ Includes ___________________________________________________________ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+\end{verbatim}
+Note that the {\tt config.h} file should {\bf not be included in header files}, since header files
+are used by the outside world without any knowledge about {\tt config.h}.
+
+One of the most commonly used configuration options used throughout \this\ is related to
+range checking.
+Range checks are usually performed when accessing array elements, assuring that no
+elements outside the valid range are accessed.
+Range checking, however, is time consuming, in particular if many elements are
+accessed subsequently.
+\this\ therefore allows to disable range checks.
+This can be done by specifying {\tt ./configure --disable-range-check} when configuring 
+\this\ for compilation.
+The {\tt --disable-range-check} option undefines {\tt G\_RANGE\_CHECK}, and optional
+range checking is thus achieved by adding for example
+\begin{verbatim}
+#if defined(G_RANGE_CHECK)
+if (inx < 0 || inx >= m_num) {
+    throw GException::out_of_range("GVector::operator(int)", inx, m_num);
+}
+#endif
+\end{verbatim}
+to the code.
+
+The following table gives a list of important configuration options that are available in 
+{\tt config.h} and that can be used to tune the code:
+
+%%% Configuration options %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\begin{center}
+\begin{tabular}{lll}
+\hline
+\hline
+\noalign{\smallskip}
+Definition & Option & Usage \\
+\noalign{\smallskip}
+\hline
+\noalign{\smallskip}
+{\tt G\_DEBUG} & {\tt --enable-debug} & Code debugging \\
+{\tt G\_PROFILE} & {\tt --enable-profiling} & Code profiling \\
+{\tt G\_RANGE\_CHECK} & {\tt --enable-range-check} & Performs range checking \\
+{\tt G\_NAN\_CHECK} & {\tt --enable-nan-check} & Check for NaN and Inf values \\
+{\tt G\_SMALL\_MEMORY} & {\tt --enable-small-memory} & Optimizes for small memory \\
+{\tt HAVE\_OPENMP} &{\tt  --enable-openmp} & Has OpenMP multi-threading support \\
+{\tt HAVE\_LIBREADLINE} & {\tt --with-readline} & Has readline library \\
+{\tt HAVE\_LIBCFITSIO} & {\tt --with-cfitsio} & Has cfitsio library \\
+{\tt HAVE\_PYTHON} & {\tt --enable-python-binding} & Has Python bindings \\
+{\tt PACKAGE} & n.a. & {\tt gammalib} \\
+{\tt PACKAGE\_PREFIX} & n.a. & Installation location (e.g. {\tt /usr/local/gamma}) \\
+{\tt PACKAGE\_STRING} & n.a. & Full name and version of \this\ \\
+{\tt PACKAGE\_VERSION} & n.a. & Version of \this\ (format: x.y.z) \\
+\noalign{\smallskip}
+\hline
+\end{tabular}
+\end{center}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+Note that {\tt enable} may be replaced by {\tt disable} and {\tt with} by {\tt without} for switching off
+an option.
+
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \subsection{C++ classes}
@@ -149,10 +655,10 @@ Members should be prefixed by {\tt m\_} and should be in lower case.
 For long member names, additional underscores may be added.
 Examples of valid member names are
 \begin{verbatim}
-  m_num
-  m_response
-  m_grid_length
-  m_axis_dir_qual
+m_num
+m_response
+m_grid_length
+m_axis_dir_qual
 \end{verbatim}
  
 Initialisation, copying and deleting of class members should be gathered in a single
@@ -164,8 +670,8 @@ methods for memory management:
 initial values. The class should be fully operational and consistent with these initial
 values. All pointers that will hold dynamically allocated memory should be
 initialised to {\tt NULL}.
-\item {\tt copy\_members(const \&A a)} copies all members from one instance {\tt a}
-to the {\tt this} instance.
+\item {\tt copy\_members(const \&A a)} copies all members from an instance {\tt a}
+into the class.
 \item {\tt free\_members()} frees all memory that has been allocated by the class.
 Memory pointers should be set to {\tt NULL} after the memory was deleted to signal
 that no valid memory is associated to the pointer.
@@ -207,6 +713,30 @@ void GEbounds::free_members(void)
     return;
 }
 \end{verbatim}
+In this example, on may probably want to add a {\tt alloc\_members()} method for memory allocation:
+\begin{verbatim}
+void GEbounds::alloc_members(const int& num)
+{
+    if (num > 0) {
+        m_min = new GEnergy[num];
+        m_max = new GEnergy[num];
+        for (int i = 0; i < num; ++i) {
+            m_min[i] = 0.0;
+            m_max[i] = 0.0;
+        }
+        m_num = num;
+    }
+    return;
+}
+\end{verbatim}
+This example illustrates several design conventions:
+\begin{itemize}
+\item Always check if a pointer is not {\tt NULL} before de-allocating memory.
+\item After de-allocation, always set the pointer immediately to {\tt NULL}.
+\item Never allocate zero elements (check if the number of elements to be allocated is positive).
+\item Always initialise allocated memory to well defined values (do not expect that the compiler
+will do this for your).
+\end{itemize}
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -248,19 +778,79 @@ GEbounds&amp; GEbounds::operator= (const GEbounds&amp; ebds)
     return *this;
 }
 \end{verbatim}
-Note that for a derived class, the assignment operator will have the form:
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsubsection{Inheritance}
+
+Class inheritance is central feature of the C++ language, and is largely used throughout \this.
+Multiple inheritance is not used at the moment in \this.
+Because of the added complexity of multiple inheritance in C++ in python there would have to 
+be very good reasons to use it in \this.
+
+Although the inheritance philosophy may differ from class to class, the following guidelines
+should be respected as far as possible:
+\begin{itemize}
+\item The base class and derived class destructors should be declared {\tt virtual}.
+\item Avoid overloading of base class methods by derived class methods. 
+Preferentially, define base class methods as pure virtual.
+\item All base class methods that should be implemented in the derived class should
+be declared {\tt virtual}.
+Exceptions are the {\tt init\_members()}, the {\tt copy\_members()} and the {\tt free\_members()}
+methods that will be implemented in the base class and the derived class.
+\item Base classes manage base class members, derived classes manage derived class
+members. 
+By managing we mean here in particular memory allocation and de-allocation,
+but also proper initialization.
+\item Derived class constructors should invoke base class constructors for proper
+base class initialization. A void constructor should look like
+\begin{verbatim}
+GEventList::GEventList(void) : GEvents()
+{
+    init_members();
+    return;
+}
+\end{verbatim}
+and a copy constructor should look like
 \begin{verbatim}
-GEventCube& GEventCube::operator= (const GEventCube& cube)
+GEventList::GEventList(const GEventList& list) : GEvents(list)
 {
-    if (this != &cube) {
-        this->GEvents::operator=(cube);    // Copy base class members
+    init_members();
+    copy_members(list);
+    return;
+}
+\end{verbatim}
+\item Derived class operators should invoke base class operators, as illustrated
+by the following example:
+\begin{verbatim}
+GEventList& GEventList::operator=(const GEventList& list)
+{
+    if (this != &list) {
+        this->GEvents::operator=(list);
         free_members();
         init_members();
-        copy_members(cube);
+        copy_members(list);
     }
     return *this;
 }
 \end{verbatim}
+\item The {\tt clear()} method of a derived class show invoke the {\tt free\_members()} method
+of the base class, as illustrated by the following example:
+\begin{verbatim}
+void GCTAEventList::clear(void)
+{
+    free_members();
+    this->GEventList::free_members();
+    this->GEvents::free_members();
+    this->GEvents::init_members();
+    this->GEventList::init_members();
+    init_members();
+    return;
+}
+\end{verbatim}
+\item Avoid as far as possible methods that are only defined in the derived class.
+\end{itemize}
+
 Also note that {\bf for a derived class, {\tt init\_members()}, {\tt copy\_members(const \&A a)}
 and {\tt free\_members()} should only act on derived class members but not on
 base class members}.
@@ -269,35 +859,35 @@ the source of memory leaks.
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{Inheritence}
-
-Class inheritence is heavily used in \this\ to implement instrument specific functionnalities
-that satisfy a generic interface.
-
-Derived classes should never set explicitely base class members.
-Base class members should be set by proper constructors, and base class constructors are
-to to be invoked in derived class constructors.
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{Methods}
+\subsubsection{Method naming conventions}
  
 Uniform {\tt public} method names should be provided throughout \this\ for all classes.
 Unless the {\tt public} method names are very long (which should be avoided), names
 should not comprise underscores as separators.
 {\tt Public} method names are all lowercase.
  
-{\tt Private} or {\tt protected} may differ from this since they are hidden within the class.
+{\tt Private} or {\tt protected} method name may differ from this since they are hidden within 
+the class.
 Yet also here, all method names should be lowercase, and the use of underscores
 should be limited.
- 
-In addition, the following {\tt public} method names should be used:
+
+Methods that set or retrieve class attributes should be named after the attribute.
+Here an example for the attribute {\tt m\_name}:
+\begin{verbatim}
+public:
+    void        name(const std::string& name);
+    std::string name(void) const;
+protected:
+    m_name;
+\end{verbatim}
+
+A method name that is used in multiple classes should always perform an equivalent action.
+Here is a list of method names that are widely used in \this, together with their typical usage.
+The last column specifies where these methods are used.
+Note that {\bf the {\tt clear()}, {\tt clone()}, and {\tt print()} methods should be implemented for all 
+classes}.
  
 %%% Naming conventions %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\begin{table}[!h]
-\caption{Naming conventions for class methods.
-\label{tab:naming}}
 \begin{center}
 \begin{tabular}{lll}
 \hline
@@ -308,19 +898,34 @@ Method &amp; Usage &amp; Implementation \\
 \hline
 \noalign{\smallskip}
 {\tt clear()} & Set object to initial empty state & all classes \\
+{\tt clone()} & Provides a deep copy of the class & all classes \\
 {\tt print()} & Print object into string & all classes (see section \ref{sec:output}) \\
-{\tt append()} & Append element to list of elements & container classes \\
-{\tt size()} & Return number of elements in object & container classes \\
+\noalign{\smallskip}
+\hline
+\noalign{\smallskip}
+{\tt append()} & Append element to list of elements & container classes (see section \ref{sec:containers}) \\
+{\tt extend()} & Append container elements to list of elements & container classes (see section \ref{sec:containers}) \\
+{\tt insert()} & Insert element to list of elements & container classes (see section \ref{sec:containers}) \\
+{\tt pop()} & Remove element from list of elements & container classes (see section \ref{sec:containers}) \\
+\noalign{\smallskip}
+\hline
+\noalign{\smallskip}
 {\tt load()} & Load data from file (open, read, close) & if applicable \\
 {\tt save()} & Save data into file (open, write, close) & if applicable \\
+{\tt open()} & Open file & if applicable \\
 {\tt read()} & Read data from open file & if applicable \\
 {\tt write()} & Write data into open file & if applicable \\
+{\tt close()} & Close file & if applicable \\
 {\tt name()} & Name of object & if applicable \\
+{\tt type()} & Type of object & if applicable \\
+{\tt size()} & Size of object & if applicable \\
+{\tt real()} & Returns {\tt double} precision value & if applicable \\
+{\tt integer()} & Returns {\tt int} value & if applicable \\
+{\tt string()} & Returns {\tt std::string} value & if applicable \\
 \noalign{\smallskip}
 \hline
 \end{tabular}
 \end{center}
-\end{table}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
 Note the difference between {\tt load()} and {\tt read()} and between {\tt save()} and {\tt write()}.
@@ -332,77 +937,224 @@ Typically, these methods take a {\tt GFits*} or a {\tt GFitsHDU*} pointer as arg
  
 Methods that perform checks should return a {\tt bool} type and should start with the
 prefix {\tt is} or {\tt has}.
-
-Valid examples are:
+Examples are:
 \begin{verbatim}
-  islong()
-  isin()
-  hasedisp()
+islong()
+isin()
+hasedisp()
 \end{verbatim}
  
-Method arguments should be generally passed as {\tt const} and by reference.
  
-Numeric argument types should be typically {\tt int} and {\tt double}.
-Unless absolutely required, {\tt short int}, {\tt long}, and {\tt float} should be avoided.
-True/false checks should always be done using {\tt bool}.
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsubsection{Method const declarations}
+
+All methods that do not alter accessible class members should be declared {\tt const}.
+With accessible we mean here class members that can be read or written in some
+way by one of the methods.
+Non-accessible class members would be members that are only used internally, and
+for which no consistent state has to be preserved for the outside world.
+These could for example be members that hold pre-computed values.
+
+Methods that do not alter accessible members, but that modify non-accessible
+members, should also be declared {\tt const}.
+The non-accessible class members need then to be declared {\tt mutable} to avoid
+compiler errors.
+Alternatively, the {\tt const\_cast} declaration can be used to allow member modifications
+within a {\tt const} method.
+
+As example we show here part of the definition of {\tt GModelSpectralPlaw2}:
+\begin{verbatim}
+class GModelSpectralPlaw2 : public GModelSpectral {
+public:
+    virtual double eval(const GEnergy& srcEng) const;
+    virtual void   read(const GXmlElement& xml);
+protected:
+    // Protected members
+    GModelPar       m_integral;        //!< Integral flux
+    GModelPar       m_index;           //!< Spectral index
+    GModelPar       m_emin;            //!< Lower energy limit (MeV)
+    GModelPar       m_emax;            //!< Upper energy limit (MeV)
+
+    // Cached members used for pre-computations
+    mutable double  m_log_emin;        //!< Log(emin)
+    mutable double  m_log_emax;        //!< Log(emax)
+    mutable double  m_pow_emin;        //!< emin^(index+1)
+    mutable double  m_pow_emax;        //!< emax^(index+1)
+    mutable double  m_norm;            //!< Power-law normalization (for pivot energy 1 MeV)
+    mutable double  m_g_norm;          //!< Power-law normalization gradient
+    mutable double  m_power;           //!< Power-law factor
+    mutable double  m_last_integral;   //!< Last integral flux
+    mutable double  m_last_index;      //!< Last spectral index (MeV)
+    mutable double  m_last_emin;       //!< Last lower energy limit (MeV)
+    mutable double  m_last_emax;       //!< Last upper energy limit (MeV)
+    mutable GEnergy m_last_energy;     //!< Last source energy
+    mutable double  m_last_value;      //!< Last function value
+    mutable double  m_last_g_integral; //!< Last integral flux gradient
+    mutable double  m_last_g_index;    //!< Last spectral index gradient
+\end{verbatim}
+This class has an internal cache for precomputation, which is potentially updated when
+{\tt eval} is called.
+Here the corresponding code:
+\begin{verbatim}
+double GModelSpectralPlaw2::eval(const GEnergy& srcEng) const
+{
+    // Update precomputed values
+    update(srcEng);
  
-Methods should be declared as {\tt const} if they do not alter class members.
-In some classes, pre-computations are done to speed up calculations, and these
-pre-computations will alter class members.
-If these pre-computation are not supposed to alter the content of a class,
-methods that perform pre-computations should also be declared as {\tt const}.
-Internally, they have to circumvent const correctness by casting the pointer to
-non {\tt const} or by using the {\tt mutable} attribute in the declaration of the members
-that hold the pre-computed values (the latter option is preferred).
+    // Compute function value
+    double value = integral() * m_norm * m_power;
+
+    // Return
+    return value;
+}
+\end{verbatim}
+As the pre-computation cache is not exposed to the external world but fully handled within
+the class, {\tt eval()} is declared {\tt const} as it does not modify any of the model parameters
+(which are {\tt m\_integral}, {\tt m\_index}, {\tt m\_emin}, and {\tt m\_emax}).
+It may however modified some of the cache members, that's why these members are
+declared {\tt mutable}.
+As there is however no way to access these cache values from the outside (no method exists
+to access them), the {\tt eval()} method does not modify any {\em observable} property of the class,
+hence it is declared {\tt const}.
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \subsubsection{Method arguments and return values}
  
-Arguments to methods should in general be passed by reference to reduce function
-overhead.
-In addition, arguments that are not intended to be changed by a method call should
-be passed as {\tt const}.
-Return values should also be passed by reference.
-To assure that the return values will not change class members inadvertably, return
-values passed by reference should also be declared as {\tt const}.
-
-If the class member is a pointer, the argument should also be a pointer to allow
-setting the pointer to {\tt NULL}.
-The exception to this are container classes which in general do not contain
-{\tt NULL} pointers in the container.
-
-Return values should be passed by reference if they concern class members.
-
-If the class member is a pointer, and if the pointer may be {\tt NULL}, it should be
-returned as a pointer.
-Again, the pointer should be declared {\tt const} to avoid inadvertable changes of
-the class members.
-The exception to this are container classes which in general do not contain
-{\tt NULL} pointers in the container.
-Container classes should return references to container elements.
-
-An example is given by the following excerpt of the {\tt GObservation} class.
-Note that in general there are two distinct methods to set and to return a
-class member.
+%True/false checks should always be done using {\tt bool}.
+
+If possible, method arguments should always be passed by reference.
+To protect references from changes by the method, {\bf arguments passed by reference
+should always be declared {\tt const}}.
+Pointers should only be used as arguments if {\tt NULL} should be a possible
+argument value.
+Also pointers should always be declared {\tt const}.
+Here an example based on the definition of {\tt GObservation}:
 \begin{verbatim}
-    void               obsname(const std::string& obsname);
-    void               ebounds(const GEbounds& ebounds);
-    void               gti(const GGti& gti);
-    void               roi(const GRoi* roi);
-    void               events(const GEvents* events);
-    void               statistics(const std::string& statistics);
-    const std::string& obsname(void) const;
-    GTime              tstart(void) const { return m_gti.tstart(); }  // no class member
-    GTime              tstop(void) const { return  m_gti.tstop(); }   // no class member
-    GEnergy            emin(void) const { return m_ebounds.emin(); }  // no class member
-    GEnergy            emax(void) const { return m_ebounds.emax(); }  // no class member
-    const GEbounds&    ebounds(void) const;
-    const GGti&        gti(void) const;
-    const GRoi*        roi(void) const;
-    const GEvents*     events(void) const;
-    const std::string& statistics(void) const;
+class GObservation {
+public:
+    void                  events(const GEvents* events);
+    void                  statistics(const std::string& statistics);
+protected:
+    std::string m_statistics;   //!< Optimizer statistics (default=poisson)
+    GEvents*    m_events;       //!< Pointer to event container
+};
 \end{verbatim}
+The {\tt statictics} value is passed by reference because the class will hold the actual
+value, while {\tt events} is passed as a pointer because the class will hold the
+pointer.
+
+Numeric argument types should be either {\tt int} or {\tt double}.
+Unless absolutely necessary, avoid {\tt short int}, {\tt long}, and {\tt float}.
+
+If a method returns a class member, the return value should be passed by reference.
+Unless we explicitly want to modify a class member through the method call,
+return values passed by reference should be declared {\tt const}.
+
+If a method returns a base class object, a pointer should be returned.
+{\bf Do never return base class objects by reference, as this will lead to
+code slicing if the method is used for object assignment.}
+Unless we explicitly want to modify a class member through the method call,
+the returned pointer should be declared {\tt const}.
+
+Here an example based on the definition of {\tt GObservation}:
+\begin{verbatim}
+class GObservation {
+public:
+    virtual double        ontime(void) const = 0;
+    const GEvents*        events(void) const;
+    const std::string&    statistics(void) const { return m_statistics; }
+protected:
+    std::string m_statistics;   //!< Optimizer statistics (default=poisson)
+    GEvents*    m_events;       //!< Pointer to event container
+};
+\end{verbatim}
+The {\tt ontime()} method does return a double by value as the ontime property is not
+stored explicitly in the class (hence no reference can be returned to it).
+On the other hand, the {\tt statistics()} method returns by reference as the statistics
+property is stored as a data member (hence a reference can be returned).
+Although we could have returned a reference to the event container, this would lead
+to code slicing.
+Therefore, the {\tt events()} method returns a pointer.
+All returned references or pointers are declared {\tt const} to prevent modification of
+class members.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\subsubsection{Container classes}
+\label{sec:containers}
+
+Container classes are classes that contain list of elements.
+Two cases are distinguished here: containers holding objects, and containers holding
+pointers to objects.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\paragraph{Containers holding objects}
+
+Containers holding objects should have element access operators {\tt operator[]} implemented
+that return container elements by reference.
+A non-const and a const version of the operator should exist.
+Eventually, {\tt at()} methods could be added that always perform range checking.
+Here is a list of mandatory methods for container classes holding objects:
+
+%%% Mandatory methods for container classes %%%%%%%%%%%%%%%%%%%%%%%%%%%
+\begin{center}
+\begin{tabular}{ll}
+\hline
+\hline
+\noalign{\smallskip}
+Method & Usage \\
+\noalign{\smallskip}
+\hline
+\noalign{\smallskip}
+{\tt e\& operator[](const int\&)} & Element access operator \\
+{\tt const e\& operator[](const int\&) const} & Element access operator \\
+{\tt void clear()} & Delete all objects in container \\
+{\tt void size()} & Return number of elements in container \\
+{\tt void append(const e\&)} & Append an element to the container \\
+{\tt void insert(const int\&, const e\&)} & Insert an element into the container \\
+{\tt void extend(const C\&)} & Append another container to the container \\
+{\tt void pop(const int\&)} & Removes an element from the container \\
+{\tt std::string print()} & Print container (see section \ref{sec:output}) \\
+\noalign{\smallskip}
+\hline
+\end{tabular}
+\end{center}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\paragraph{Containers holding pointers}
+
+Containers holding pointers different from those holding objects in that their {\tt operator[]}
+operators return a pointer, and in that they implement a {\tt set()} method for value setting.
+Here is a list of mandatory methods for container classes holding pointers:
+
+%%% Mandatory methods for container classes %%%%%%%%%%%%%%%%%%%%%%%%%%%
+\begin{center}
+\begin{tabular}{ll}
+\hline
+\hline
+\noalign{\smallskip}
+Method & Usage \\
+\noalign{\smallskip}
+\hline
+\noalign{\smallskip}
+{\tt e* operator[](const int\&)} & Element access operator \\
+{\tt const e* operator[](const int\&) const} & Element access operator \\
+{\tt void set(const int\&, const e\&)} & Set an element of the container \\
+{\tt void clear()} & Delete all objects in container \\
+{\tt void size()} & Return number of elements in container \\
+{\tt void append(const e\&)} & Append an element to the container \\
+{\tt void insert(const int\&, const e\&)} & Insert an element into the container \\
+{\tt void extend(const C\&)} & Append another container to the container \\
+{\tt void pop(const int\&)} & Removes an element from the container \\
+{\tt std::string print()} & Print container (see section \ref{sec:output}) \\
+\noalign{\smallskip}
+\hline
+\end{tabular}
+\end{center}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -410,16 +1162,7 @@ class member.
 \label{sec:output}
  
 Output stream and logging operators should be implemented for every class as friend
-operators.
-An example is:
-\begin{verbatim}
-#include <iostream>
-#include "GLog.hpp"
-class GFits {
-    friend std::ostream& operator<< (std::ostream& os, const GFits& fits);
-    friend GLog&         operator<< (GLog& log, const GFits& fits);
-    ...
-\end{verbatim}
+operators (see section \ref{sec:header}).
 The usage of friend operators (instead of member operators) allows for correct handling
 of code such as
 \begin{verbatim}
@@ -446,63 +1189,38 @@ GLog&amp; operator&lt;&lt; (GLog&amp; log, const GFits&amp; fits)
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{Container classes}
+\subsubsection{Exceptions}
+\label{sec:exceptions}
  
-Container classes are classes that contain list of elements.
+Exceptions are largely used in \this\ to handle the occurrence of unexpected events.
+\this\ exceptions are implement by the {\tt GException} class.
+For each new exception type, a new exception subclass is added.
  
-Each container class should have element access operators {\tt operator[]} implemented,
-returning either a reference or a pointer to the class elements.
-A non-const and a const version of the operator should exist.
+Each exception returns the method name in which the exception occurs and an exception
+message.
+The exception message is generally build from values that are passed as arguments to the
+exception constructor.
  
-Similar to the C++ template classes, {\tt at()} methods could also be implemented that
-perform range checking.
+Below a list of conventions for implementing and using exceptions:
+\begin{itemize}
+\item Re-use existing exceptions as far as possible.
+\item Pass exception arguments by reference.
+\item Use exceptions only for events that cannot be handled by a method.
+Do not use exceptions to check a value or a state. Implement appropriate methods instead.
+\item Never use exceptions in a destructor.
+\item De-allocate all memory that is not de-allocated by the destructor before throwing an
+exception. 
+\item Always catch exceptions by reference.
+\end{itemize}
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Documentation
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\section{Documentation}
-
-Code documentation should be done within the source files using Doxygen
-compliant annotations.
-
-The following rules apply.
+%\subsection{Python classes}
  
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%\subsubsection{Container classes}
  
-\subsection{File descriptor}
-
-Put a 80 character wide header comment on top of {\bf each file}
-(header, source code, templates, etc.).
-The header contains
-the file name,
-a brief description of the file content,
-the development period and the name of the person which {\bf initially}
-created the file, and
-a standard GNU Public License statement.
-The header comment is immediately followed by a Doxygen compliant
-file description that provides
-the file name,
-a brief description of the file content, and
-the name of the person which {\bf initially} created the file.
-\begin{verbatim}
-/***************************************************************************
- *                       GMatrix.cpp  -  matrix class                      *
- * ----------------------------------------------------------------------- *
- *  copyright (C) 2006-2010 by Jurgen Knodlseder                           *
- * ----------------------------------------------------------------------- *
- *                                                                         *
- *   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 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- ***************************************************************************/
-/**
- * @file GMatrix.cpp
- * @brief GVector class implementation.
- * @author J. Knodlseder
- */
-\end{verbatim}
+%TBW
  
  
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -516,29 +1234,24 @@ the name of the person which {\bf initially} created the file.
 \this\ applies a three-number version numbering scheme:
 {\tt major\_revision-minor\_revision-patch}.
  
-A {\tt major\_revision} of {\tt 00} designates the development version of \this.
-At this level, external interfaces of \this\ may change constantly, hence no
+A {\tt major\_revision} of {\tt 00} indicates that the \this\ design is not yet frozen.
+At this level, external interfaces of \this\ may change without notification, and no
 interface control system is implemented.
-The {\tt minor\_revision} tag will be incremented once new major features become
-available.
-The {\tt patch} tag will be incremented after adding minor features and code corrections.
-
-Once the development phase is finished the release phase is entred.
-At this moment the {\tt major\_revision} number will be incremented to {\tt 01}.
-
-During release phase, external interfaces of \this\ will be under configuration control.
-If modifications of existing external interfaces will be done, the {\tt major\_revision}
-number will be incremented.
-At the same time, the {\tt libtool} version number of the \this\ will also change.
-
-The {\tt minor\_revision} number will be incremented in the release phase when
-extensions of the existing interfaces get implemented.
-Extensions should always be backward compatible, i.e. any existing software should
-not break due to the add of extensions.
-
-The {\tt patch} number will be incremented in the release phase after bug corrections
-or code improvements.
-The corresponding modifications should not change the functionality of the library.
+The {\tt minor\_revision} tag will be incremented for each new release, signaling
+that new features have become available.
+The {\tt patch} tag will be incremented after correcting bugs that were reported
+on releases.
+
+Once the \this\ design is frozen, the {\tt major\_revision} number will be incremented 
+to {\tt 01}.
+From this moment on, external interfaces of \this\ will be under configuration control.
+If existing external interfaces will be modified, the {\tt major\_revision} number will be
+incremented.
+At the same time, the {\tt libtool} version number of the \this\ will also be incremented.
+The {\tt minor\_revision} number will be incremented if modifications and extensions
+are backward compatible
+As before, the {\tt patch} number will be incremented after correcting bugs that were 
+reported on releases.
  
 \end{document}
  
 %%
 %% "manual.sty" provides definitions for the gammalib documentation
 %% 
-%% Copyright (C) 2009 Jurgen Knodlseder
+%% Copyright (C) 2009-2012 Juergen Knoedlseder
 %%
 \NeedsTeXFormat{LaTeX2e}
-\ProvidesPackage{manual}[2009/10/07 gammalib ducomentation]
+\ProvidesPackage{manual}[2012/09/22 gammalib documentation]
  
 %
 % The page dimensions
@@ -73,7 +73,6 @@
 % Author
 \rm
 Author: \auth\ \\
-Approved by: \approv\ \\
  
 % Affiliation
 \vspace*{1cm}
@@ -97,13 +96,6 @@ FRANCE
 \vspace{200mm}
 \centerline{This page intentionally left blank}
 \vspace{3mm}
-%This software has been written to analyse data of the SPI 
-%telescope onboard INTEGRAL. 
-%Particular care has been taken in making the software user friendly 
-%and well documented.
-%If you appreciated this effort, and if this software and User Manual 
-%were useful for your scientific work, the author would appreciate a 
-%corresponding acknowledgment in your published work.
 }
 \end{center}
  
-%---------------------------------------------------------------------------- 
-%                             GammaLib User Manual
-%
-% Version: 0.4
-% Last modification: 30 November 2010
-%----------------------------------------------------------------------------
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Definitions for manual package
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newcommand{\task}{\mbox{GammaLib}}
-\newcommand{\this}{\mbox{\tt \task}}
-\newcommand{\version}{\mbox{0.4}}
-\newcommand{\calendar}{\mbox{30 November 2010}}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Document definition
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\documentclass{article}[12pt,a4]
-\usepackage{epsfig}
-\usepackage{manual}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Begin of document body
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\begin{document}
-\frontpage
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Introduction
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\section{Introduction}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Overview}
-
-\this\ is a machine-independent library of C++ classes for analysing gamma-ray astronomy
-data.
-The core of \this\ implements an abstract interface to gamma-ray observations,
-provides services for reading and writing the data,
-enables the analysis of multi-mission data,
-and implements support for building ftools like analysis executables.
-On top of this core library, instrument specific C++ classes implement the interfaces to
-handle data and response functions of specific gamma-ray instruments.
-
-The development of \this\ has been initiated by scientists from IRAP (Institut de Recherche
-en Astrophysique et Plan\'etologie), an astrophysics laboratory of CNRS and of the University
-Paul Sabatier situated in Toulouse, France.
-\this\ is based on past experience gained in developing software for gamma-ray space
-missions, such as
-the COMPTEL telescope aboard {\em CGRO}, 
-the SPI telescope aboard {\em INTEGRAL},
-and the LAT telescope aboard {\em Fermi}.
-Initial elements of \this\ can be found in the {\tt spi\_toolslib} that is part of the
-Off-line Science Analysis (OSA) software distributed by ISDC for the science analysis 
-of {\em INTEGRAL} data.
-The development of \this\ is nowadays mainly driven by the advances in 
-ground-based gamma-ray astronomy, and in particular by the development of the
-CTA observatory.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Getting \this}
-
-The latest version of the \this\ source code, documentation, and example programs are
-available on the World-Wide Web from:
-\begin{verbatim}
-   https://sourceforge.net/projects/gammalib/
-\end{verbatim}
-Any questions, bug reports, or suggested enhancements related to \this\ should be submitted
-via the {\em Tracker} or the
-\begin{verbatim}
-   gammalib-users@lists.sourceforge.net
-\end{verbatim}
-mailing list.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Prerequisites}
-
-\this\ should compile on every modern Unix system without any need to install any
-specific library.
-
-To enable support for FITS file handling, however, the {\tt cfitsio} library from HEASARC
-needs to be installed.
-{\tt cfitsio} can be downloaded from
-\begin{verbatim}
-   http://heasarc.gsfc.nasa.gov/fitsio
-\end{verbatim}
-and detailed installation instructions can be found there.
-If {\tt cfitsio} does not already exist on your system, we recommend installation of {\tt cfitsio}
-in the default \this\ install directory as a shared library by typing:
-\begin{verbatim}
-> ./configure --prefix=/usr/local/gamma
-> make shared
-> make install
-\end{verbatim}
-
-\this\ can also benefit from the presence of the {\tt readline} library that provides line-editing
-and history capabilities for text input (\this\ offers however also full functionality without having
-{\tt readline} installed).
-{\tt readline} can be downloaded from
-\begin{verbatim}
-  http://ftp.gnu.org/gnu/readline/
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Installing \this}
-
-\this\ is built on Unix systems by typing:
-\begin{verbatim}
-> ./autogen.sh
-> ./configure
-> make
-> make install
-\end{verbatim}
-at the operating system prompt.
-The configuration command customizes the Makefiles for the particular system,
-the {\tt make} command compiles the source files and builds the library, and
-the {\tt make install} command installs the library in the install directory.
-Type {\tt ./configure} and not simply {\tt configure} to ensure that the configuration
-script in the current directory is run and not some other system-wide configuration
-script.
-By default, the install directory is set to
-{\tt /usr/local/gamma}.
-To change the install directory an optional {\tt --prefix} argument should be given,
-for example:
-\begin{verbatim}
-> ./configure --prefix=/usr/local
-\end{verbatim}
-A full list of configuration options can be found using
-\begin{verbatim}
-> ./configure --help
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Testing \this}
-
-\this\ should be tested by typing:
-\begin{verbatim}
-> make check
-\end{verbatim}
-This will execute an extensive testing suite that should terminate with
-\begin{verbatim}
-===================
-All 14 tests passed
-===================
-\end{verbatim}
-If an older version of \this\ exists already on the system one has to make sure that the
-library in installed using {\tt make install} before executing the tests.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Getting started with \this}
-
-In order to effectively use \this\ it is recommended that new users begin by reading the
-\this\ Quick Start Guide.
-It contains all basic information needed to write programs to analyse gamma-ray data.
-{\bf TBW ...}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Example program}
-
-{\bf TBD: Give a short example program here ...}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Programming Guidelines
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\section{Programming guidelines}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{\this\ definitions}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% GammaLib components
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\section{\this\ components}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Observations}
-
-The primary user interface for the analysis of gamma-ray data is implemented by
-the container class {\tt GObservations}.
-{\tt GObservations} collects a list of gamma-ray observations which are the basic
-entity used
-
-The basic entity used for analysis of gamma-ray data is an observation.
-{\bf TBW: Define what an observation is: single instrument, specific response function}.
-
-An observation is implemented by the abstract {\tt GObservation} class that provides
-the instrument independent interface to the data.
-
-To combine several observation for an analysis, a list of {\tt GObservation} objects is
-gather by the container class {\tt GObservations}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Models}
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Optimizers}
-
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Applications}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Interfaces}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{FITS interface}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{XML interface}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{Parameter interface}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Numerics}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{Linear algebra}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{Vectors}
-
-%----------------------------------------------------------------------------
-\paragraph{General}
-
-A vector is a one-dimensional array of successive {\tt double} type values.
-Vectors are handled in \this\ by {\tt GVector} objects.
-On construction, the dimension of the vector has to be specified.
-In other words
-\begin{verbatim}
- GVector vector;                        // WRONG: constructor needs dimension
-\end{verbatim}
-is not allowed.
-The minimum dimension of a vector is 1, i.e. there is no such thing 
-like an empty vector:
-\begin{verbatim}
- GVector vector(0);                     // WRONG: empty vector not allowed
-\end{verbatim}
-The correct allocation of a vector is done using
-\begin{verbatim}
- GVector vector(10);                    // Allocates a vector with 10 elements
-\end{verbatim}
-On allocation, all elements of a vector are set to 0.
-Vectors may also be allocated by copying from another vector
-\begin{verbatim}
- GVector vector(10);                    // Allocates a vector with 10 elements
- GVector another = vector;              // Allocates another vector with 10 elements
-\end{verbatim}
-or by using 
-\begin{verbatim}
- GVector vector = GVector(10);          // Allocates a vector with 10 elements
-\end{verbatim}
-
-Vector elements are accessed using the {\tt ( )} operator:
-\begin{verbatim}
- GVector vector(10);                    // Allocates a vector with 10 elements
- for (int i = 0; i < 10; ++i)
-   vector(i) = (i+1)*10.0;              // Set elements 10, 20, ..., 100
- for (int i = 0; i < 10; ++i)
-   cout << vector(i) << endl;           // Dump all elements, one by row 
-\end{verbatim}
-The content of a vector may also be dumped using
-\begin{verbatim}
- cout << vector << endl;                // Dump entire vector
-\end{verbatim}
-which in the above example will put the sequence
-\begin{verbatim}
- 10 20 30 40 50 60 70 80 90 100
-\end{verbatim}
-on the screen.
-
-
-%----------------------------------------------------------------------------
-\paragraph{Vector arithmetics}
-
-Vectors can be very much handled like {\tt double} type variables
-with the difference that operations are performed on each element of 
-the vector.
-The complete list of fundamental vector operators is:
-\begin{verbatim}
- c = a + b;                             // Vector + Vector addition
- c = a + s;                             // Vector + Scalar addition
- c = s + b;                             // Scalar + Vector addition
- c = a - b;                             // Vector - Vector subtraction
- c = a - s;                             // Vector - Scalar subtraction
- c = s - b;                             // Scalar - Vector subtraction
- s = a * b;                             // Vector * Vector multiplication (dot product)
- c = a * s;                             // Vector * Scalar multiplication
- c = s * b;                             // Scalar * Vector multiplication
- c = a / s;                             // Vector * Scalar division
-\end{verbatim}
-where {\tt a}, {\tt b} and {\tt c} are of type {\tt GVector} and 
-{\tt s} is of type {\tt double}.
-Note in particular the combination of {\tt GVector} and {\tt double} 
-type objects in addition, subtraction, multiplication and division.
-In these cases the specified operation is applied to each of the 
-vector elements.
-It is also obvious that only vector of identicial dimension can occur 
-in vector operations.
-Dimension errors can be catched by the {\tt try} - {\tt catch} 
-functionality:
-\begin{verbatim}
- try {
-   GVector a(10);                       
-   GVector b(11);
-   GVector c = a + b;                   // WRONG: Vectors have incompatible dimensions
- }
- catch (GVector::vector_mismatch &e) {
-   cout << e.what() << endl;            // Dimension exception is catched here
-   throw;
- }
-\end{verbatim}
-Further vector operations are
-\begin{verbatim}
- c = a;                                 // Vector assignment
- c = s;                                 // Scalar assignment
- s = c(index);                          // Vector element access
- c += a;                                // c = c + a;
- c -= a;                                // c = c - a;
- c += s;                                // c = c + s;
- c -= s;                                // c = c - s;
- c *= s;                                // c = c * s;
- c /= s;                                // c = c / s;
- c = -a;                                // Vector negation
-\end{verbatim}
-Finally, the comparison operators
-\begin{verbatim}
- int equal   = (a == b);                // True if all elements equal
- int unequal = (a != b);                // True if at least one elements unequal
-\end{verbatim}
-allow to compare all elements of a vector. If all elements are
-identical, the {\tt ==} operator returns true, otherwise false.
-If at least one element differs, the {\tt !=} operator returns true, 
-is all elements are identical it returns false.
-
-In addition to the operators, the following mathematical functions 
-can be applied to vectors:
-\begin{verbatim}
-    acos         atan         exp          sin          tanh
-    acosh        atanh        fabs         sinh
-    asin         cos          log          sqrt
-    asinh        cosh         log10        tan
-\end{verbatim}
-Again, these functions should be understood to be applied element wise.
-They all take a vector as argument and produce a vector as result.
-For example
-\begin{verbatim}
- c = sin(a);
-\end{verbatim}
-attributes the sine of each element of vector {\tt a} to vector 
-{\tt c}.
-Additional implemented functions are
-\begin{verbatim}
- c = cross(a, b);                       // Vector cross product (for 3d only)
- s = norm(a);                           // Vector norm |a|
- s = min(a);                            // Minimum element of vector
- s = max(a);                            // Maximum element of vector
- s = sum(a);                            // Sum of vector elements
-\end{verbatim}
-Finally, a small number of vector methods have been implemented:
-\begin{verbatim}
- int n = a.size();                      // Returns dimension of vector
- int n = a.non_zeros();                 // Returns number of non-zero elements in vector
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsubsection{Matrixes}
-
-%----------------------------------------------------------------------------
-\paragraph{General}
-
-A matrix is a two-dimensional array of {\tt double} type values, 
-arranged in rows and columns.
-Matrixes are handled in \this\ by {\tt GMatrix} objects and the 
-derived classes {\tt GSymMatrix} and {\tt GSparseMatrix} (see section 
-\ref{sec:matrix:storage}).
-On construction, the dimension of the matrix has to be specified:
-\begin{verbatim}
- GMatrix matrix(10,20);                 // Allocates 10 rows and 20 columns
-\end{verbatim}
-Similar to vectors, there is no such thing as a matrix without 
-dimensions in \this.
-
-
-%----------------------------------------------------------------------------
-\paragraph{Matrix storage classes}
-\label{sec:matrix:storage}
-
-In the most general case, the {\tt rows} and {\tt columns} of a 
-matrix are stored in a continuous array of 
-${\tt rows} \times {\tt columns}$
-memory locations.
-This storage type is referred to as a {\em full matrix}, and is 
-implemented by the class {\tt GMatrix}.
-Operations on full matrixes are in general relatively fast, but 
-memory requirements may be important to hold all the elements.
-In general matrixes are stored by \this\ column-wise (or in 
-column-major format).
-For example, the matrix
-\begin{verbatim}
-    1  2  3  4  5
-    6  7  8  9 10
-   11 12 13 14 15 
-\end{verbatim}
-is stored in memory as
-\begin{verbatim}
-    |  1  6 11 |  2  7 12 |  3  8 13 |  4  9 14 |  5 10 15 |
-\end{verbatim}
-
-Many physical or mathematical problems treat with a subclass of 
-matrixes that is symmetric, i.e. for which the element
-{\tt (row,col)} is identical to the element {\tt (col,row)}.
-In this case, the duplicated elements need not to be stored.
-The derived class {\tt GSymMatrix} implements such a storage type.
-{\tt GSymMatrix} stores the lower-left triangle of the matrix in 
-column-major format.
-For illustration, the matrix
-\begin{verbatim}
-    1  2  3  4
-    2  5  6  7
-    3  6  8  9
-    4  7  9 10
-\end{verbatim}
-is stored in memory as
-\begin{verbatim}
-    |  1  2  3  4 |  5  6  7 |  8  9 | 10 |
-\end{verbatim}
-This divides the storage requirements to hold the matrix elements by 
-almost a factor of two.
-
-Finally, quite often one has to deal with matrixes that contain a 
-large number of zeros.
-Such matrixes are called {\em sparse matrixes}.
-If only the non-zero elements of a sparse matrix are stored the memory 
-requirements are considerably reduced.
-This goes however at the expense of matrix element access, which has 
-become now more complex.
-In particular, filling efficiently a sparse matrix is a non-trivial 
-problem (see section \ref{sec:matrix:filling}).
-Sparse matrix storage is implemented in \this\ by the derived class 
-{\tt GSparseMatrix}.
-A {\tt GSparseMatrix} object contains three one-dimensional arrays to 
-store the matrix elements: 
-a {\tt double} type array that contains in continuous column-major order 
-all non-zero elements, 
-an {\tt int} type array that contains for each non-zero element the 
-row number of its location, and
-an {\tt int} type array that contains the storage location of the 
-first non-zero element for each matrix column.
-To illustrate this storage format, the matrix
-\begin{verbatim}
-    1  0  0  7
-    2  5  0  0
-    3  0  6  0
-    4  0  0  8
-\end{verbatim}
-is stored in memory as 
-\begin{verbatim}
-    |  1  2  3  4 |  5 |  6 |  7  8 |  Matrix elements
-    |  0  1  2  3 |  1 |  2 |  0  3 |  Row indices for all elements
-    |  0          |  4 |  5 |  6    |  Storage location of first element of each column
-\end{verbatim}
-This example is of course not very economic, since the total number of 
-Bytes used to store the matrix is 
-$8 \times 8 + (8 + 4) \times 4 = 112$ Bytes, while a full $4 \times 4$
-matrix is stored in
-$(4 \times 4) \times 8 = 128$ Bytes (recall: a {\tt double} type 
-values takes 8 Bytes, an {\tt int} type value takes 4 Bytes).
-For realistic large systems, however, the gain in memory space can be 
-dramatical.
-
-The usage of the {\tt GMatrix}, {\tt GSymMatrix} and {\tt GSparseMatrix} 
-classes is analoguous in that they implement basically all functions 
-and methods in an identical way.
-So from the semantics the user has not to worry about the storage 
-class. 
-However, matrix element access speeds are not identical for all 
-storage types, and if performance is an issue (as it certainly always 
-will be), the user has to consider matrix access more carefully
-(see section \ref{sec:matrix:filling}).
-
-Matrix allocation is performed using the constructors:
-\begin{verbatim}
- GMatrix       A(10,20);                // Full 10 x 20 matrix
- GSymMatrix    B(10,10);                // Symmetric 10 x 10 matrix
- GSparseMatrix C(1000,10000);           // Sparse 1000 x 10000 matrix
-
- GMatrix       A(0,0);                  // WRONG: empty matrix not allowed
- GSymMatrix    B(20,22);                // WRONG: symmetric matrix requested
-\end{verbatim}
-In the constructor, the first argument specifies the number of rows, 
-the second the number of columns: {\tt A(row,column)}.
-A symmetric matrix needs of course an equal number of rows and columns.
-And an empty matrix is not allowed.
-All matrix elements are initialised to 0 by the matrix allocation.
-
-Matrix elements are accessed by the {\tt A(row,col)} function,
-where {\tt row} and {\tt col} start from 0 for the first row or column 
-and run up to the number of rows or columns minus 1:
-\begin{verbatim}
- for (int row = 0; row < n_rows; ++row) {
-   for (int col = 0; col < n_cols; ++col)
-     A(row,col) = (row+col)/2.0;        // Set value of matrix element
- }
- ...
- double sum2 = 0.0;
- for (int row = 0; row < n_rows; ++row) {
-   for (int col = 0; col < n_cols; ++col)
-     sum2 *= A(row,col) * A(row,col);   // Get value of matrix element
- }
-\end{verbatim}
-
-The content of a matrix can be visualised using
-\begin{verbatim}
- cout << A << endl;                     // Dump matrix
-\end{verbatim}
-
-
-%----------------------------------------------------------------------------
-\paragraph{Matrix arithmetics}
-
-The following description of matrix arithmetics applies to all storage 
-classes (see section \ref{sec:matrix:storage}).
-The following matrix operators have been implemented in \this:
-\begin{verbatim}
- C = A + B;                             // Matrix Matrix addition
- C = A - B;                             // Matrix Matrix subtraction
- C = A * B;                             // Matrix Matrix multiplication
- C = A * v;                             // Matrix Vector multiplication
- C = A * s;                             // Matrix Scalar multiplication
- C = s * A;                             // Scalar Matrix multiplication
- C = A / s;                             // Matrix Scalar division
- C = -A;                                // Negation
- A += B;                                // Matrix inplace addition
- A -= B;                                // Matrix inplace subtraction
- A *= B;                                // Matrix inplace multiplications
- A *= s;                                // Matrix inplace scalar multiplication
- A /= s;                                // Matrix inplace scalar division
-\end{verbatim}
-The comparison operators
-\begin{verbatim}
- int equal   = (A == B);                // True if all elements equal
- int unequal = (A != B);                // True if at least one elements unequal
-\end{verbatim}
-allow to compare all elements of a matrix. 
-If all elements are identical, the {\tt ==} operator returns true, 
-otherwise false.
-If at least one element differs, the {\tt !=} operator returns true, 
-is all elements are identical it returns false.
-
-
-%----------------------------------------------------------------------------
-\paragraph{Matrix methods and functions}
-
-A number of methods has been implemented to manipulate matrixes.
-The method
-\begin{verbatim}
- A.clear();                             // Set all elements to 0
-\end{verbatim}
-sets all elements to 0.
-The methods
-\begin{verbatim}
- int rows = A.rows();                   // Returns number of rows in matrix
- int cols = A.cols();                   // Returns number of columns in matrix
-\end{verbatim}
-provide access to the matrix dimensions, the methods
-\begin{verbatim}
- double sum = A.sum();                  // Sum of all elements in matrix
- double min = A.min();                  // Returns minimum element of matrix
- double max = A.max();                  // Returns maximum element of matrix
-\end{verbatim}
-inform about some matrix properties.
-The methods
-\begin{verbatim}
- GVector v_row    = A.extract_row(row); // Puts row in vector
- GVector v_column = A.extract_col(col); // Puts column in vector
-\end{verbatim}
-extract entire rows and columns from a matrix.
-Extraction of lower or upper triangle parts of a matrix into another
-is performed using
-\begin{verbatim}
- B = A.extract_lower_triangle();        // B holds lower triangle
- B = A.extract_upper_triangle();        // B holds upper triangle
-\end{verbatim}
-{\tt B} is of the same storage class as {\tt A}, except for the case 
-that {\tt A} is a {\tt GSymMatrix} object. 
-In this case, {\tt B} will be a full matrix of type {\tt GMatrix}.
-
-The methods
-\begin{verbatim}
- A.insert_col(v_col,col);               // Puts vector in column
- A.add_col(v_col,col);                  // Add vector to column
-\end{verbatim}
-inserts or adds the elements of a vector into a matrix column.
-Note that no row insertion routines have been implemented (so far) 
-since they would be less efficient (recall that all matrix types are 
-stored in column-major format).
-
-Conversion from one storage type to another is performed using
-\begin{verbatim}
- B = A.convert_to_full();               // Converts A -> GMatrix
- B = A.convert_to_sym();                // Converts A -> GSymMatrix
- B = A.convert_to_sparse();             // Converts A -> GSparseMatrix
-\end{verbatim}
-Note that {\tt convert\_to\_sym()} can only be applied to a matrix that 
-is indeed symmetric.
-
-The transpose of a matrix can be obtained by using one of
-\begin{verbatim}
- A.transpose();                         // Transpose method
- B = transpose(A);                      // Transpose function
-\end{verbatim}
-
-The absolute value of a matrix is provided by
-\begin{verbatim}
- B = fabs(A);                           // B = |A|
-\end{verbatim}
-
-
-%----------------------------------------------------------------------------
-\paragraph{Matrix factorisations}
-
-A general tool of numeric matrix calculs is factorisation.
-
-Solve linear equation {\tt Ax = b}.
-Inverse a matrix (by solving successively {\tt Ax = e}, where {\tt e} 
-are the unit vectors for all dimensions).
-
-For symmetric and positive definite matrices the most efficient 
-factorisation is the Cholesky decomposition.
-The following code fragment illustrates the usage:
-\begin{verbatim}
- GMatrix A(n_rows, n_cols};
- GVector x(n_rows};
- GVector b(n_rows};
- ...
- A.cholesky_decompose();                // Perform Cholesky factorisation
- x = A.cholesky_solver(b);              // Solve Ax=b for x
-\end{verbatim}
-Note that once the function {\tt A.cholesky\_decompose()} has been 
-applied, the original matrix content has been replaced by its Cholesky 
-decomposition.
-Since the Cholesky decomposition can be performed inplace (i.e. 
-without the allocation of additional memory to hold the result), the 
-matrix replacement is most memory economic.
-In case that the original matrix should be kept, one may either copy 
-it before into another {\tt GMatrix} object or use the function
-\begin{verbatim}
- GMatrix L = cholesky_decompose(A);
- x = L.cholesky_solver(b);
-\end{verbatim}
-
-A symmetric and positif definite matrix can be inverted using the 
-Cholesky decomposition using
-\begin{verbatim}
- A.cholesky_invert();                   // Inverse matrix using Cholesky fact.
-\end{verbatim}
-Alternatively, the function 
-\begin{verbatim}
- GMatrix A_inv = cholesky_invert(A);
-\end{verbatim}
-may be used.
-
-The Cholesky decomposition, solver and inversion
-routines may also be applied to matrices that contain rows or
-columns that are filled by zeros.
-In this case the functions provide the option to (logically)
-compress the matrices by skipping the zero rows and columns during
-the calculation.
-
-For compressed matrix Cholesky factorisation, only the non-zero rows 
-and columns have to be symmetric and positive definite.
-In particular, the full matrix may even be non-symmetric.
-
-
-%----------------------------------------------------------------------------
-\paragraph{Sparse matrixes}
-
-The only exception that does not work is
-\begin{verbatim}
- GSparseMatrix A(10,10);
- A(0,0) = A(1,1) = A(2,2) = 1.0;        // WRONG: Cannot assign multiple at once
-\end{verbatim}
-In this case the value {\tt 1.0} is only assigned to the last 
-element, i.e. {\tt A(2,2)}, the other elements will remain
-{\tt 0}.
-This feature has to do with the way how the compiler translates
-the code and how \this\ implements sparse matrix filling.
-{\tt GSparseMatrix} provides a pointer for a new element to be 
-filled.
-Since there is only one such {\em fill pointer}, only one element can 
-be filled at once in a statement.
-{\bf So it is strongly advised to avoid multiple matrix element 
-assignment in a single row.}
-Better write the above code like
-\begin{verbatim}
- GSparseMatrix A;
- A(0,0) = 1.0;
- A(1,1) = 1.0;
- A(2,2) = 1.0;
-\end{verbatim}
-This way, element assignment works fine.
-
-Inverting a sparse matrix produces in general a full matrix, so the 
-inversion function should be used with caution.
-Note that a full matrix that is stored in sparse format takes roughly
-twice the memory than a normal {\tt GMatrix} object.
-If nevertheless the inverse of a sparse matrix should be examined, it 
-is recommended to perform the analysis column-wise:
-\begin{verbatim}
- GSparseMatrix A(rows,cols);            // Allocate sparse matrix
- GVector       unit(rows);              // Allocate vector
- ...
- A.cholesky_decompose();                // Factorise matrix
-
- // Column-wise solving the matrix equation
- for (int col = 0; col < cols; ++col) {
-   unit(col) = 1.0;                     // Set unit vector
-   GVector x = cholesky_solver(unit);   // Get column x of inverse
-   ...
-   unit(col) = 0.0;                     // Clear unit vector for next round
- }
-\end{verbatim}
-
-
-%----------------------------------------------------------------------------
-\paragraph{Filling sparse matrixes}
-\label{sec:matrix:filling}
-
-The filling of a sparse matrix is a tricky issue since the storage
-of the elements depends on their distribution in the matrix.
-If one would know beforehand this distribution, sparse matrix filling
-would be easy and fast.
-In general, however, the distribution is not known a priori, and
-matrix filling may become a quite time consuming task.
-
-If a matrix has to be filled element by element, the access through
-the operator
-\begin{verbatim}
- m(row,col) = value;
-\end{verbatim}
-may be mandatory.
-In principle, if a new element is inserted into a matrix a new memory
-cell has to be allocated for this element, and other elements may be 
-moved.
-Memory allocation is quite time consuming, and to reduce the overhead,
-{\tt GSparseMatrix} can be configured to allocate memory in bunches.
-By default, each time more matrix memory is needed, {\tt GSparseMatrix}
-allocates 512 cells at once (or 6144 Bytes since each element requires 
-a {\tt double} and a {\tt int} storage location).
-If this amount of memory is not adequat one may change this value by
-using
-\begin{verbatim}
- m.set_mem_block(size);
-\end{verbatim}
-where {\tt size} is the number of matrix elements that should be
-allocated at once (corresponding to a total memory of 
-$12 \times {\tt size}$ Bytes).
-
-Alternatively, a matrix may be filled column-wise using the functions
-\begin{verbatim}
- m.insert_col(vector,col);              // Insert a vector in column
- m.add_col(vector,col);                 // Add content of a vector to column
-\end{verbatim}
-While {\tt insert\_col} sets the values of column {\tt col} (deleting 
-thus any previously existing entries), {\tt add\_col} adds the content 
-of {\tt vector} to all elements of column {\tt col}.
-Using these functions is considerably more rapid than filling individual 
-values.
-
-Still, if the matrix is big (i.e. severeal thousands of rows and 
-columns), filling individual columns may still be slow.
-To speed-up dynamical matrix filling, an internal fill-stack has been 
-implemented in {\tt GSparseMatrix}.
-Instead of inserting values column-by-column, the columns are stored 
-in a stack and filled into the matrix once the stack is full.
-This reduces the number of dynamic memory allocations to let the 
-matrix grow as it is built.
-By default, the internal stack is disabled.
-The stack can be enabled and used as follows:
-\begin{verbatim}
- m.stack_init(size, entries);           // Initialise stack
- ...
- m.add_col(vector,col);                 // Add columns
- ...
- m.stack_destroy();                     // Flush and destory stack
-\end{verbatim}
-The method {\tt stack\_init} initialises a stack with a number of 
-{\tt size} elements and a maximum of {\tt entries} columns.
-The larger the values {\tt size} and {\tt entries} are chosen, the
-more efficient the stack works.
-The total amount of memory of the stack can be estimated as
-$12 \times {\tt size} + 8 \times {\tt entries}$ Bytes.
-If a rough estimate of the total number of non-zero elements is
-available it is recommended to set {\tt size} to this value.
-As a rule of thumb, {\tt size} should be at least of the dimension of 
-either the number of rows or the number of columns of the matrix 
-(take the maximum of both).
-{\tt entries} is best set to the number of columns of the matrix.
-If memory limits are an issue smaller values may be set, but if the
-values are too small, the speed increase may become negligible (or 
-stack-filling may even become slower than normal filling).
-
-Stack-filling only works with the method {\tt add\_col}.
-Note also that filling sub-sequently the same column leads to stack 
-flushing.
-In the code
-\begin{verbatim}
- for (int col = 0; col < 100; ++col) {
-   column      = 0.0;                   // Reset column
-   column(col) = col;                   // Set column
-   m.add_col(column,col);               // Add column
- }   
-\end{verbatim}
-stack flushing occurs in each loop, and consequently, the 
-stack-filling approach will be not very efficient (it 
-would probably be even slover than normal filling).
-If successive operations are to be performed on columns, 
-it is better to perform them before adding.
-The code
-\begin{verbatim}
- column = 0.0;                          // Reset column
- for (int col = 0; col < 100; ++col)
-   column(col) = col;                   // Set column
- m.add_col(column,col);                 // Add column
-\end{verbatim}
-would be far more efficient.
-
-A avoidable overhead occurs for the case that the column to be added 
-is sparse.
-The vector may contain many zeros, and {\tt GSparseMatrix} has to 
-filter them out.
-If the sparsity of the column is known, this overhead can be avoided 
-by directly passing a compressed array to {\tt add\_col}:
-\begin{verbatim}
- int     number = 5;                    // 5 elements in array
- double* values = new double[number];   // Allocate values
- int*    rows   = new int[number];      // Allocate row index
- ...
- m.stack_init(size, entries);           // Initialise stack
- ...
- for (int i = 0; i < number; ++i) {     // Initialise array
-   values[i] = ...                      // ... set values
-   rows[i]   = ...                      // ... set row indices
- }
- ...
- m.add_col(values,rows,number,col);     // Add array
- ...
- m.stack_destroy();                     // Flush and destory stack
- ...
- delete [] values;                      // Free array
- delete [] rows;
-\end{verbatim}
-
-The method {\tt add\_col} calls the method {\tt stack\_push\_column}
-for stack filling.
-{\tt add\_col} is more general than {\tt stack\_push\_column} in that 
-it decides which of stack- or direct filling is more adequate.
-In particular, {\tt stack\_push\_column} may refuse pushing a column 
-onto the stack if there is not enough space.
-In that case, {\tt stack\_push\_column} returns a non-zero value that 
-corresponds to the number of non-zero elements in the vector that 
-should be added.
-However, it is recommended to not use {\tt stack\_push\_column} and 
-call instead {\tt add\_col}.
-
-The method {\tt stack\_destroy} is used to flush and destroy the
-stack. 
-After this call the stack memory is liberated.
-If the stack should be flushed without destroying it, the method
-{\tt stack\_flush} may be used:
-\begin{verbatim}
- m.stack_init(size, entries);           // Initialise stack
- ...
- m.add_col(vector,col);                 // Add columns
- ...
- m.stack_flush();                       // Simply flush stack
-\end{verbatim}
-Once flushed, the stack can be filled anew.
-
-Note that stack flushing is not automatic!
-This means, if one trys to use a matrix for calculs without flushing, 
-the calculs may be wrong.
-{\bf If a stack is used for filling, always flush the stack before using 
-the matrix.}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Code reference
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\clearpage
-\section{Code reference}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GApplication}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEbounds}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEnergy}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEvent} \small[abstract]}
-{\tt GEvent} implements the abstract interface for a gamma-ray event.
-It handles both event atoms (\ref{GEventAtom}) and event bins (\ref{GEventBin}).
-\begin{verbatim}
-  /* Constructors */
-  GEvent(void);
-  GEvent(const GEvent& event);
-
-  /* Operators */
-  GEvent& operator= (const GEvent& event);
-
-  /* Methods */
-  void            clear(void);         // Clear event
-  GEvent*         clone(void) const;   // Clone event
-  double          size(void) const;    // Returns size of event bin
-  const GInstDir& dir(void) const;     // Returns event's instrument direction
-  const GEnergy&  energy(void) const;  // Returns event energy
-  const GTime&    time(void) const;    // Returns event time
-  double          counts(void) const;  // Returns number of counts in event
-  double          error(void) const;   // Returns uncertainty in number of counts in event
-  bool            isatom(void) const;  // Event is an atom
-  bool            isbin(void) const;   // Event is a bin
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEventAtom} \small[abstract]}
-\label{GEventAtom}
-{\tt GEventAtom} derives from {GEvent} and implements the abstract interface for an event
-atom. 
-Each atom is characterised by an instrument direction, an energy and an event arrival time. 
-\begin{verbatim}
-  /* Constructors */
-  GEventAtom(void);
-  GEventAtom(const GEventAtom& atom);
-
-  /* Operators */
-  GEventAtom& operator= (const GEventAtom& atom);
-
-  /* Methods */
-  void            clear(void);         // Clear event
-  GEventAtom*     clone(void) const;   // Clone event
-  double          size(void) const;    // Returns 1.0
-  const GInstDir& dir(void) const;     // Returns event's instrument direction
-  const GEnergy&  energy(void) const;  // Returns event energy
-  const GTime&    time(void) const;    // Returns event time
-  double          counts(void) const;  // Returns 1.0
-  double          error(void) const;   // Returns 0.0
-  bool            isatom(void) const;  // Returns true
-  bool            isbin(void) const;   // Returns false
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEventBin} \small[abstract]}
-\label{GEventBin}
-{\tt GEventBin} derives from {GEvent} and implements the abstract interface for an event
-bin.
-Each bin is characterised by a mean instrument direction, a mean energy and a
-mean event arrival time.
-The size of the event bin is the solid angle subtended by the event bin times the energy 
-width times the time interval that is covered.
-Multiplication of the event occurence probability with the bin size provides the expected
-number of counts in a bin.
-\begin{verbatim}
-  /* Constructors */
-  GEventBin(void);
-  GEventBin(const GEventBin& bin);
-
-  /* Operators */
-  GEventBin& operator= (const GEventBin& bin);
-
-  /* Methods */
-  void            clear(void);         // Clear event bin
-  GEventBin*      clone(void) const;   // Clone event bin
-  double          size(void) const;    // Returns size of event bin
-  const GInstDir& dir(void) const;     // Returns bin's mean instrument direction
-  const GEnergy&  energy(void) const;  // Returns mean bin energy
-  const GTime&    time(void) const;    // Returns mean bin time
-  double          counts(void) const;  // Returns number of events in bin
-  double          error(void) const;   // Returns uncertainty in number of events in bin
-  bool            isatom(void) const;  // Returns false
-  bool            isbin(void) const;   // Returns true
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEvents} \small[abstract]}
-Events are collected in the abstract container class {\tt GEvents}.
-This class handles both event lists (\ref{GEventList}) and event cubes (\ref{GEventCube}).
-\begin{verbatim}
-  /* Constructors */
-  GEvents(void);
-  GEvents(const GEvents& events);
-
-  /* Operators */
-  GEvents& operator= (const GEvents& events);
-
-  /* Methods */
-  void     clear(void);                       // Clear events
-  GEvents* clone(void) const;                 // Clone events
-  int      size(void) const;                  // Returns number of atoms or bins
-  void     load(const std::string& filename); // Load events from file
-  GEvent*  pointer(int index);                // Returns pointer on atom or bin
-  int      number(void) const;                // Returns number of events
-  bool     islist(void) const;                // Object is event list
-  bool     iscube(void) const;                // Object is event cube
-  iterator begin(void);                       // Returns iterator on first atom or bin
-  iterator end(void);                         // Returns iterator on last atom or bin
-\end{verbatim}
-{\tt GEvents} implements an event iterator as a nested class 
-{\tt GEvents::iterator} with the following definition:
-\begin{verbatim}
-  /* Constructor */
-  iterator(void);
-  iterator(GEvents *events);
-
-  /* Operators */
-  iterator& operator++(void);
-  iterator  operator++(int junk);
-  bool      operator==(const iterator& it) const;
-  bool      operator!=(const iterator& it) const;
-  GEvent&   operator*(void);
-  GEvent*   operator->(void);
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEventList} \small[abstract]}
-\label{GEventList}
-{\tt GEventList} is an abstract container class for event atoms.
-\begin{verbatim}
-  /* Constructors */
-  GEventList(void);
-  GEventList(const GEventList& list);
-
-  /* Operators */
-  GEventList& operator= (const GEventList& list);
-  
-  /* Methods */
-  void        clear(void);                       // Clear event list
-  GEventList* clone(void) const;                 // Clone event list
-  int         size(void) const;                  // Returns number of events in list
-  void        load(const std::string& filename); // Load list from file
-  GEventAtom* pointer(int index);                // Returns pointer on event atom
-  int         number(void) const;                // Returns number of events in list
-  bool        islist(void) const;                // Returns true
-  bool        iscube(void) const;                // Returns false
-  
-  /* Friends */
-  std::ostream& operator<< (std::ostream& os, const GEventList& list);
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GEventCube} \small[abstract]}
-\label{GEventCube}
-{\tt GEventCube} is an abstract container class for event bins.
-\begin{verbatim}
-  /* Constructors */
-  GEventCube(void);
-  GEventCube(const GEventCube& cube);
-
-  /* Operators */
-  GEventCube& operator= (const GEventCube& cube);
-  
-  /* Methods */
-  void        clear(void);                       // Clear event cube
-  GEventCube* clone(void) const;                 // Clone event cube
-  int         size(void) const;                  // Returns number of bins in cube
-  void        load(const std::string& filename); // Load cube from file
-  GEventBin*  pointer(int index);                // Returns pointer on bin
-  int         number(void) const;                // Returns number of events in cube
-  int         dim(void) const;                   // Returns dimension of cube
-  int         naxis(int axis) const;             // Returns dimension of cube axis
-  bool        islist(void) const;                // Returns false
-  bool        iscube(void) const;                // Returns true
-  
-  /* Friends */
-  std::ostream& operator<< (std::ostream& os, const GEventCube& cube);
-\end{verbatim}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GFits}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GGti}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GInstDir}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GIntegral}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GIntegrand}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GLog}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GMatrix}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModel}}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModel(void);                                            // Creates empty model
-GModel(const GModel& model);                             // Creates copy of model
-GModel(const GModelSpatial& spatial,                     // Creates model from spatial and
-       const GModelSpectral& spectral);                  //   spectral components
-GModel(const GXmlElement& spatial,                       // Creates model from spatial and
-       const GXmlElement& spectral);                     //   spectral XML elements
-
-/* Operators */
-GModelPar&       operator() (int index);                 // Returns reference to parameter
-const GModelPar& operator() (int index) const;           // Returns reference to parameter
-GModel&          operator= (const GModel& model);        // Assign model
-
-/* Methods */
-void            clear(void);                             // Clear model
-GModel*         clone(void) const;                       // Clone model
-int             size(void) const;                        // Returns number of parameters
-std::string     name(void) const;                        // Returns model name
-void            name(const std::string& name);           // Set model name
-GModelSpatial*  spatial(void) const;                     // Returns spatial component
-GModelSpectral* spectral(void) const;                    // Returns spectral component
-GModelTemporal* temporal(void) const;                    // Returns temporal component
-double          value(const GSkyDir& srcDir,             // Returns model value
-                      const GEnergy& srcEng,
-                      const GTime& srcTime); 
-GVector         gradients(const GSkyDir& srcDir,         // Returns model gradient
-                          const GEnergy& srcEng,
-                          const GTime& srcTime); 
-double          eval(const GEvent& event,                // Evaluates model for an event
-                     const GObservation& obs);
-double          eval_gradients(const GEvent& event,      // Evaluates model and gradients
-                               const GObservation& obs); //   for an event
-bool            isvalid(const std::string& name) const;  // Model applies to instrument?
-std::string     print(void) const;                       // Print model
-\end{verbatim}
-
-\paragraph{Description:}
-The {\tt GModel} class implements the factorized source model
-\begin{equation}
-S(\vec{p}, E, t) = M(\vec{p}) \times P(E) \times V(t)
-\end{equation}
-where
-\begin{itemize}
-\item[] $M(\vec{p})$ is a map of the intensity distribution (in units of sr$^{-1}$),
-\item[] $P(E)$ is the source spectrum (in units of photons cm$^{-2}$ s$^{-1}$ MeV$^{-1}$), and
-\item[] $V(t)$ is a source modulation function (unitless),
-\item[] $\vec{p}$ is the true photon arrival direction,
-\item[] $E$ is the true photon energy, and
-\item[] $t$ is the true photon arrival time.
-\end{itemize}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelPar}}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelPar(void);                                          // Creates empty parameter
-GModelPar(const GModelPar& par);                          // Creates copy of parameter
-
-/* Operators */
-GModelPar& operator= (const GModelPar& par);              // Assign parameter
-
-/* Methods */
-std::string name(void) const;                             // Returns name
-std::string unit(void) const;                             // Returns unit
-double      real_value(void) const;                       // Returns true value
-double      real_error(void) const;                       // Returns true error
-double      real_gradient(void) const;                    // Returns true gradient
-double      real_min(void) const;                         // Returns true minimum
-double      real_max(void) const;                         // Returns true maximum
-double      value(void) const;                            // Returns value
-double      error(void) const;                            // Returns error
-double      gradient(void) const;                         // Returns gradient
-double      min(void) const;                              // Returns minimum
-double      max(void) const;                              // Returns maximum
-double      scale(void) const;                            // Returns scale factor
-bool        isfree(void) const;                           // Signals that parameter is free
-bool        hasmin(void) const;                           // Signals that parameter has minimum
-bool        hasmax(void) const;                           // Signals that parameter has maximum
-void        name(const std::string& name);                // Set name
-void        unit(const std::string& unit);                // Set unit
-void        value(const double& value);                   // Set value
-void        error(const double& error);                   // Set error
-void        gradient(const double& gradient);             // Set gradient
-void        min(const double& min);                       // Set minimum
-void        max(const double& max);                       // Set maximum
-void        scale(const double& scale);                   // Set scale factor
-void        range(const double& min, const double& max);  // Set minimum and maximum
-void        remove_min(void);                             // Remove minimum
-void        remove_max(void);                             // Remove maximum
-void        remove_range(void);                           // Remove minimum and maximum
-void        free(void);                                   // Set parameter free
-void        fix(void);                                    // Fix parameter
-void        read(const GXmlElement& xml);                 // Read parameter from XML element
-void        write(GXmlElement& xml) const;                // Write parameter into XML element
-std::string print(void) const;                            // Print parameter
-\end{verbatim}
-
-\paragraph{Description:}
-This class implements a model parameter.
-The true parameter value is given by
-\begin{equation}
-{\tt true} = {\tt scale} \times {\tt value}
-\end{equation}
-and is accessed through the {\tt real\_} methods.
-The optimizer will only affect the {\tt value} part of the parameter.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModels}}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModels(void);                                       // Creates empty model container
-GModels(const GModels& models);                      // Creates copy of container
-GModels(const std::string& filename);                // Creates container from XML file
-
-/* Operators */
-GModel&       operator() (int index);                // Returns reference to model
-const GModel& operator() (int index) const;          // Returns reference to model
-GModels&      operator= (const GModels& models);     // Assign model container
-
-/* Methods */
-void        clear(void);                             // Clear models
-GModels*    clone(void) const;                       // Clone models
-int         size(void) const;                        // Returns number of models in container
-void        append(const GModel& model);             // Append model to container
-void        load(const std::string& filename);       // Load models from XML file
-void        save(const std::string& filename) const; // Save models into XML file
-void        read(const GXml& xml);                   // Read models from XML document
-void        write(GXml& xml) const;                  // Write models into XML document
-int         npars(void) const;                       // Returns total number of parameters
-int         nfree(void) const;                       // Returns total number of free parameters
-GModelPar*  par(int index) const;                    // Returns pointer to model parameter
-double      value(const GSkyDir& srcDir,             // Returns model value
-                  const GEnergy& srcEng,
-                  const GTime& srcTime);
-double      eval(const GEvent& event,                // Evaluates models for an event
-                 const GObservation& obs);
-double      eval_gradients(const GEvent& event,      // Evaluates models and parameter
-                           const GObservation& obs); //   gradients for an event
-std::string print(void) const;                       // Print model
-\end{verbatim}
-
-\paragraph{Description:}
-Container class for {\tt GModel} source models.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelSpatial} \small[abstract]}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelSpatial(void);                                      // Creates empty component
-GModelSpatial(const GModelSpatial& model);                // Creates copy of component
-
-/* Operators */
-GModelPar&       operator() (int index);                  // Access model parameter
-const GModelPar& operator() (int index) const;            // Access model parameter
-GModelSpatial&   operator= (const GModelSpatial& model);  // Assign component
-
-/* Methods */
-void           clear(void);                               // Clear component
-GModelSpatial* clone(void) const;                         // Clone component
-int            size(void) const;                          // Returns number of model parameters
-std::string    type(void) const;                          // Returns type of component
-double         eval(const GSkyDir& srcDir);               // Evaluate component
-double         eval_gradients(const GSkyDir& srcDir);     // Evaluate component and gradients
-void           read(const GXmlElement& xml);              // Read component from XML element
-void           write(GXmlElement& xml) const;             // Write component into XML element
-bool           isptsource(void) const;                    // Signals if component is point source
-std::string    print(void) const;                         // Print component
-\end{verbatim}
-
-\paragraph{Description:}
-Implements the spatial component $M(\vec{p})$ of the factorized source model.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelSpatialPtsrc}}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelSpatialPtsrc(void);                             // Creates empty point source
-GModelSpatialPtsrc(const GSkyDir& dir);               // Creates point source from sky direction
-GModelSpatialPtsrc(const GXmlElement& xml);           // Creates point source from XML element
-GModelSpatialPtsrc(const GModelSpatialPtsrc& model);  // Creates copy of point source
-
-/* Operators */
-GModelPar&          operator() (int index);                      // Access model parameter
-const GModelPar&    operator() (int index) const;                // Access model parameter
-GModelSpatialPtsrc& operator= (const GModelSpatialPtsrc& model); // Assign point source
-
-/* Methods */
-void                clear(void);                            // Clear point source
-GModelSpatialPtsrc* clone(void) const;                      // Clone point source
-int                 size(void) const;                       // Returns 2
-std::string         type(void) const;                       // Returns "PointSource"
-double              eval(const GSkyDir& srcDir);            // Evaluate point source
-double              eval_gradients(const GSkyDir& srcDir);  // Evaluate point source and gradients
-void                read(const GXmlElement& xml);           // Read point source from XML element
-void                write(GXmlElement& xml) const;          // Write point source into XML element
-bool                isptsource(void) const;                 // Returns true
-double              ra(void) const;                         // Returns Right Ascension (deg)
-double              dec(void) const;                        // Returns Declination (deg)
-GSkyDir             dir(void) const;                        // Returns position of point source
-void                dir(const GSkyDir& dir);                // Set position of point source
-std::string         print(void) const;                      // Print component
-\end{verbatim}
-
-\paragraph{Description:}
-Implements a point source model with parameters Right Ascension and Declination.
-
-The {\tt eval} method returns 1 if the specified position coincides with the position
-of the point source, 0 otherwise (coincidence is defined as the angular distance between
-the specified and the point source position being inferior to 0.1 arcseconds).
-
-The {\tt eval\_gradients} method sets both parameter gradients to 0.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelSpectral} \small[abstract]}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelSpectral(void);                                      // Creates empty component
-GModelSpectral(const GModelSpectral& model);               // Creates copy of component
-
-/* Operators */
-GModelPar&       operator() (int index);                   // Access model parameter
-const GModelPar& operator() (int index) const;             // Access model parameter
-GModelSpectral&  operator= (const GModelSpectral& model);  // Assign component
-
-/* Methods */
-void            clear(void);                               // Clear component
-GModelSpectral* clone(void) const;                         // Clone component
-int             size(void) const;                          // Returns number of model parameters
-std::string     type(void) const;                          // Returns type of component
-double          eval(const GSkyDir& srcDir);               // Evaluate component
-double          eval_gradients(const GSkyDir& srcDir);     // Evaluate component and gradients
-void            read(const GXmlElement& xml);              // Read component from XML element
-void            write(GXmlElement& xml) const;             // Write component into XML element
-std::string     print(void) const;                         // Print component
-\end{verbatim}
-
-\paragraph{Description:}
-Implements the spectra component $P(E)$ of the factorized source model.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelSpectralPlaw}}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelSpectralPlaw(void);                             // Creates empty power law
-GModelSpectralPlaw(const double& norm,);              // Creates power law from
-                   const double& index);              //   normalization and index
-GModelSpectralPlaw(const GXmlElement& xml);           // Creates power law from XML element
-GModelSpectralPlaw(const GModelSpectralPlaw& model);  // Creates copy of power law
-
-/* Operators */
-GModelPar&          operator() (int index);                      // Access model parameter
-const GModelPar&    operator() (int index) const;                // Access model parameter
-GModelSpectralPlaw& operator= (const GModelSpectralPlaw& model); // Assign power law
-
-/* Methods */
-void                clear(void);                            // Clear power law
-GModelSpectralPlaw* clone(void) const;                      // Clone power law
-int                 size(void) const;                       // Returns 3
-std::string         type(void) const;                       // Returns "PowerLaw"
-double              eval(const GEnergy& srcEng);            // Evaluate power law
-double              eval_gradients(const GEnergy& srcEng);  // Evaluate power law and gradients
-void                read(const GXmlElement& xml);           // Read power law from XML element
-void                write(GXmlElement& xml) const;          // Write power law into XML element
-void                autoscale(void);                        // Automatically scale normalization
-double              norm(void) const;                       // Returns normalization
-double              index(void) const;                      // Returns index
-double              pivot(void) const;                      // Returns pivot energy (MeV)
-std::string         print(void) const;                      // Print power law
-\end{verbatim}
-
-\paragraph{Description:}
-Implements power law spectral model
-\begin{equation}
-I(E) = {\tt norm} \, (E/{\tt pivot})^{{\tt index}}
-\end{equation}
-where
-${\tt norm}=n_s n_v$ is the normalization or prefactor (units ph/cm$^2$/s/MeV),
-${\tt index}=i_s i_v$ is the spectral index, and
-${\tt pivot}=p_s p_v$ is the pivot energy (units MeV).
-Note that each parameter is factorised into a scaling factor (indexed by $s$) and a 
-parameter value (indexed by $v$).
-This function is evaluated using the {\tt eval} method.
-
-The {\tt eval\_gradients} methods computes in addition the partial derivatives of 
-the parameter values:
-\begin{eqnarray}
-dI/dn_v &= & n_s (E/{\tt pivot})^{{\tt index}} \\
-dI/di_v & = & {\tt norm} (E/{\tt pivot})^{{\tt index}} i_s \ln(E/{\tt pivot}) \\
-dI/dp_v & = & {\tt norm} (E/{\tt pivot})^{{\tt index}} (-{\tt index}) / p_v
-\end{eqnarray}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelSpectralExpPlaw}}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelSpectralExpPlaw(void);                               // Creates empty cutoff power law
-GModelSpectralExpPlaw(const double& norm,);                // Creates cutoff power law from
-                      const double& index,                 //   normalization, index and
-                      const double& ecut);                 //   exponential cutoff energy
-GModelSpectralExpPlaw(const GXmlElement& xml);             // Creates cutoff PL from XML element
-GModelSpectralExpPlaw(const GModelSpectralExpPlaw& model); // Creates copy of cutoff power law
-
-/* Operators */
-GModelPar&             operator() (int index);                         // Access model parameter
-const GModelPar&       operator() (int index) const;                   // Access model parameter
-GModelSpectralExpPlaw& operator= (const GModelSpectralExpPlaw& model); // Assign cutoff power law
-
-/* Methods */
-void                   clear(void);                            // Clear cutoff power law
-GModelSpectralExpPlaw* clone(void) const;                      // Clone cutoff power law
-int                    size(void) const;                       // Returns 4
-std::string            type(void) const;                       // Returns "ExpCutoff"
-double                 eval(const GEnergy& srcEng);            // Evaluate cutoff power law
-double                 eval_gradients(const GEnergy& srcEng);  // Evaluate cutoff PL and gradients
-void                   read(const GXmlElement& xml);           // Read cutoff PL from XML element
-void                   write(GXmlElement& xml) const;          // Write cutoff PL into XML element
-void                   autoscale(void);                        // Automatically scale normalization
-double                 norm(void) const;                       // Returns normalization
-double                 index(void) const;                      // Returns index
-double                 ecut(void) const;                       // Returns cutoff energy (MeV)
-double                 pivot(void) const;                      // Returns pivot energy (MeV)
-std::string            print(void) const;                      // Print cutoff power law
-\end{verbatim}
-
-\paragraph{Description:}
-Implements power law spectral model
-\begin{equation}
-I(E) = {\tt norm} \, (E/{\tt pivot})^{{\tt index}} \exp(-E/{\tt ecut})
-\end{equation}
-where
-${\tt norm}=n_s n_v$ is the normalization or prefactor (units ph/cm$^2$/s/MeV),
-${\tt index}=i_s i_v$ is the spectral index,
-${\tt ecut}=c_s c_v$ is the cutoff energy (units MeV), and
-${\tt pivot}=p_s p_v$ is the pivot energy (units MeV).
-Note that each parameter is factorised into a scaling factor (indexed by $s$) and a 
-parameter value (indexed by $v$).
-This function is evaluated using the {\tt eval} method.
-
-The {\tt eval\_gradients} methods computes in addition the partial derivatives of 
-the parameter values:
-\begin{eqnarray}
-dI/dn_v &= & n_s (E/{\tt pivot})^{{\tt index}}  \exp(-E/{\tt ecut}) \\
-dI/di_v & = & {\tt norm} (E/{\tt pivot})^{{\tt index}}  \exp(-E/{\tt ecut}) i_s \ln(E/{\tt pivot}) \\
-dI/dc_v & = & {\tt norm} (E/{\tt pivot})^{{\tt index}} \exp(-E/{\tt ecut}) (E/{\tt ecut}^2) c_s \\
-dI/dp_v & = & {\tt norm} (E/{\tt pivot})^{{\tt index}}  \exp(-E/{\tt ecut}) (-{\tt index}) / p_v
-\end{eqnarray}
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelTemporal} \small[abstract]}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelTemporal(void);                                      // Creates empty component
-GModelTemporal(const GModelTemporal& model);               // Creates copy of component
-
-/* Operators */
-GModelPar&       operator() (int index);                   // Access model parameter
-const GModelPar& operator() (int index) const;             // Access model parameter
-GModelTemporal&  operator= (const GModelTemporal& model);  // Assign component
-
-/* Methods */
-void            clear(void);                               // Clear component
-GModelTemporal* clone(void) const;                         // Clone component
-int             size(void) const;                          // Returns number of model parameters
-std::string     type(void) const;                          // Returns type of component
-double          eval(const GTime& srcTime);                // Evaluate component
-double          eval_gradients(const GTime& srcTime);      // Evaluate component and gradients
-void            read(const GXmlElement& xml);              // Read component from XML element
-void            write(GXmlElement& xml) const;             // Write component into XML element
-std::string     print(void) const;                         // Print component
-\end{verbatim}
-
-\paragraph{Description:}
-Implements the temporal component $V(t)$ of the factorized source model.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\newpage
-\subsection{{\tt GModelTemporalConst}}
-
-\paragraph{Class definition:}
-\begin{verbatim}
-/* Constructors */
-GModelTemporalConst(void);                                         // Creates empty component
-GModelTemporalConst(const GModelTemporalConst& model);             // Creates copy of component
-
-/* Operators */
-GModelPar&           operator() (int index);                       // Access model parameter
-const GModelPar&     operator() (int index) const;                 // Access model parameter
-GModelTemporalConst& operator= (const GModelTemporalConst& model); // Assign component
-
-/* Methods */
-void                 clear(void);                           // Clear component
-GModelTemporalConst* clone(void) const;                     // Clone component
-int                  size(void) const;                      // Returns 1
-std::string          type(void) const;                      // Returns "Constant"
-double               eval(const GTime& srcTime);            // Evaluate component
-double               eval_gradients(const GTime& srcTime);  // Evaluate component and gradients
-void                 read(const GXmlElement& xml);          // Read component from XML element
-void                 write(GXmlElement& xml) const;         // Write component into XML element
-std::string          print(void) const;                     // Print component
-\end{verbatim}
-
-\paragraph{Description:}
-Implements a non-variable (constant) source.
-
-The {\tt eval} method returns 1, the {\tt eval\_gradients} methods sets the gradient to 0.
-
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GNodeArray}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GObservation}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GObservations}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GOptimizer}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GOptimizerFunction}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GOptimizerLM}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GOptimizerPars}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GPar}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GPars}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GPointing}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GResponse}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GRoi}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GSkyDir}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GSkymap}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GSkyPixel}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GSparseMatrix}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GSymMatrix}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GTime}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GTools}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GVector}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GWcs}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GWcsCAR}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GWcsHPX}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXml}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXmlAttribute}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXmlComment}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXmlDocument}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXmlElement}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXmlNode}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXmlPI}}
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-\subsection{{\tt GXmlText}}
-
-
-\end{document} 
-%%
-%% "manual.sty" provides definitions for the ISDC User Manuals
-%% 
-%% Copyright (C) 2002 Jurgen Knodlseder
-%%
-\NeedsTeXFormat{LaTeX2e}
-\ProvidesPackage{manual}[2002/02/18 v1.0 ISDC User Manual]
-
-%
-% The page dimensions
-%
-%\setlength\paperheight{9.25in}
-%\setlength\paperwidth{7.375in}
-\setlength\parindent{0cm}
-\setlength\parskip{0.2cm}
-\setlength\linewidth{13.2cm}
-\setlength\headheight{1.5cm}
-\setlength\textwidth{16.3cm}
-\setlength\textheight{22.5cm}
-\setlength\oddsidemargin{0cm}
-\setlength\topmargin{-1.7cm}
-%\setlength\parindent{2em}
-%\setlength\headheight{8pt}
-\setlength\headsep{19pt}
-\setlength\footskip{24pt}
-%\setlength\textwidth{345pt}
-%\setlength\textheight{46pc}
-\setlength\evensidemargin{1.6804in}
-%\setlength\oddsidemargin{1.5139in}
-%\setlength\topmargin{.625in}
-
-%
-% ISDC page style
-%
-\pagestyle{myheadings}
-\markboth{\task\ User Manual}
-         {\task\ User Manual}
-
-%\renewcommand{\subsection}{\@startsection{subsection}{3}{-4pc}{-16pt}{6pt}{%
-% \rightmark{Introduction}}}
-
-%
-% Define front-page command
-%
-\newcommand{\frontpage}{%
-\begin{center}
-\framebox[16cm]{
-\begin{minipage}[c]{16cm}
-\vspace*{6.5cm}
-\begin{center}
-
-% Software component
-\framebox{
- \framebox{
-  \parbox{10cm}{
-   \vspace{5mm} \centerline{
-    \vspace{5mm} \Huge \bf
-     \task
-   }
-  }
- }
-}
-
-% User Manual
-\vspace{10mm}
-{\Huge \bf User Manual}
-\\[10mm]
-
-% Version, Date
-{\normalsize \bf Version \version\\ \calendar}
-\\[10mm]
-
-% Author
-\rm
-J\"urgen Kn\"odlseder\\
-Institut de Recherche en Astrophysique et Plan\'etologie (IRAP)\\
-knodlseder@cesr.fr\\
-http://www.irap.omp.eu/
-
-\vfill
-\end{center}
-\vspace*{6.5cm}
-\end{minipage}
-}
-\end{center}
-
-\thispagestyle{empty}
-\pagenumbering{roman}
-\newpage
-\begin{center}
-\parbox{15cm}{
-\vspace{200mm}
-\centerline{Note to the user}
-\vspace{3mm}
-This software has been written to analyse gamma-ray data. 
-Particular care has been taken in making the software user friendly 
-and well documented.
-If you appreciated this effort, and if this software and User Manual 
-were useful for your scientific work, the author would appreciate a 
-corresponding acknowledgment in your published work.
-}
-\end{center}
-
-\newpage
-\tableofcontents
-\newpage
-\pagenumbering{arabic}
-}
-
-
-%
-% Further commands
-%
-%\newcommand{\icd}[1]{\item[{\tt #1}] }
-\newcommand{\icd}[1]{\item{\tt #1} }
-\newcommand{\cur}[1]{%
-\icd{#1} specifies the current ISDC status when the function is entered. 
-         If {\tt status != ISDC\_OK} the function does nothing and 
-         returns the input status as return code.
-}
-\endinput
-%%
-%% End of file `manual.sty'.
@@ -6,7 +6,7 @@ includedir=${prefix}/include
 Name: GammaLib
 Description: Versatile toolbox for analysis of astronomical gamma-ray data
 URL: http://gammalib.sourceforge.net/
-Version: 0.6.2
+Version: 0.7.0
 Requires: 
 Requires.private: @CFITSIO@
 Conflicts: 
-#! /bin/bash -f
-
-# Set parameters
-installdir=$(pwd)/build
-makedoc="no"
-
-echo "Checkout latest GammaLib"
-rm -rf gammalib
-cvs -Q -d /home/cvs export -N -r HEAD "gammalib"
-
-# Extract version number
-version=`cat gammalib/configure.ac | grep 'AC_INIT' | awk -F"[" '{print $3}' | sed 's/],//' | sed 's/\./ /g'`
-version=`printf "%2.2d-%2.2d-%2.2d" $version`
-echo "GammaLib version: "$version
-
-# Set source directory
-sourcedir=gammalib-$version
-rm -rf $sourcedir
-mv gammalib $sourcedir
-
-#
-echo "Create Makefile.in and configure scripts"
-cd $sourcedir
-./autogen.sh
-rm -f gammalib.sh
-cd ..
-
-#
-echo "Create gammalib_wrap.cpp and gammalib.py files for python binding (making swig obsolete)"
-inc_inst="-I$sourcedir/inst/mwl/pyext -I$sourcedir/inst/lat/pyext -I$sourcedir/inst/cta/pyext"
-opt_inst="-DWITH_INST_MWL -DWITH_INST_LAT -DWITH_INST_CTA"
-swig -c++ -python -Wall -includeall -I$sourcedir/src $inc_inst $opt_inst -o $sourcedir/pyext/gammalib_wrap.cpp -outdir $sourcedir/pyext $sourcedir/pyext/gammalib.i
-
-#
-if [ "x$makedoc" == "xyes" ] ; then
-  echo "Create doxygen documentation"
-  cd $sourcedir/doc
-  doxygen Doxyfile
-  cd latex
-  make
-  make
-  dvips -o refman.ps refman
-  ps2pdf refman.ps 
-  cd ../..
-fi
-
-#
-echo "Create LaTeX documentation"
-cd $sourcedir/doc
-#
-latex gammalib_um.tex
-dvips gammalib_um.dvi -o gammalib_um.ps
-ps2pdf gammalib_um.ps
-rm -f gammalib_um.dvi gammalib_um.aux gammalib_um.log gammalib_um.tex gammalib_um.toc manual.sty gammalib_um.ps
-#
-cd dev/coding
-latex gammalib_coding.tex
-dvips gammalib_coding.dvi -o gammalib_coding.ps
-ps2pdf gammalib_coding.ps
-cd ../..
-mv dev/coding/gammalib_coding.pdf .
-#
-cd dev/inst
-latex gammalib_inst.tex
-dvips gammalib_inst.dvi -o gammalib_inst.ps
-ps2pdf gammalib_inst.ps
-cd ../..
-mv dev/inst/gammalib_inst.pdf .
-#
-cd dev/maths
-latex gammalib_maths.tex
-dvips gammalib_maths.dvi -o gammalib_maths.ps
-ps2pdf gammalib_maths.ps
-cd ../..
-mv dev/maths/gammalib_maths.pdf .
-#
-cd dev/sdd 
-latex gammalib_sdd.tex
-dvips gammalib_sdd.dvi -o gammalib_sdd.ps
-ps2pdf gammalib_sdd.ps
-cd ../..
-mv dev/sdd/gammalib_sdd.pdf .
-#
-cd dev/srs 
-latex gammalib_srs.tex
-dvips gammalib_srs.dvi -o gammalib_srs.ps
-ps2pdf gammalib_srs.ps
-cd ../..
-mv dev/srs/gammalib_srs.pdf .
-#
-rm -rf dev
-cd ../..
-
-echo "Make files read/write"
-chmod -R u+rw $sourcedir
-
-echo "Create tarball"
-tar cvf - $sourcedir > $sourcedir.tar
-rm -f $sourcedir.tar.gz
-gzip $sourcedir.tar
-
-#
-echo "Configure GammaLib"
-cd $sourcedir
-./configure --prefix=$installdir
-
-#
-echo "Compile GammaLib"
-make -j10
-
-#
-echo "Check GammaLib"
-make check
-
-#
-echo "Install GammaLib"
-make install
 /***************************************************************************
  *             GApplication.hpp - GammaLib application base class          *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GApplication.hpp
  * @brief GammaLib application base class
- * @author Jurgen Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GAPPLICATION_HPP
@@ -31,7 +31,7 @@
 #include <ctime>
 #include <vector>
 #include <string>
-#include <iostream>
+#include "GBase.hpp"
 #include "GLog.hpp"
 #include "GPars.hpp"
  
@@ -46,11 +46,7 @@
  * classes, and automatically have access to task parameters and the
  * application logger.
  ***************************************************************************/
-class GApplication {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GApplication& app);
-    friend GLog&         operator<< (GLog&        log, const GApplication& app);
+class GApplication : public GBase {
  
 public:
     // Constructors and destructors
@@ -67,33 +63,35 @@ public:
     const GPar&   operator[](const std::string& name) const;
  
     // Methods
-    std::string name(void) const;
-    std::string version(void) const;
-    double      telapse(void) const;
-    double      celapse(void) const;
-    void        logFileOpen(bool clobber = true);
-    bool        logTerse(void) const;
-    bool        logNormal(void) const;
-    bool        logExplicit(void) const;
-    bool        logVerbose(void) const;
-    bool        logDebug(void) const;
-    bool        clobber(void) const;
-    bool        haspar(const std::string& name) const;
-    std::string par_filename(void) const;
-    std::string log_filename(void) const;
-    void        log_header(void);
-    void        log_trailer(void);
-    void        log_parameters(void);
-    std::string print(void) const;
+    void          clear(void);
+    GApplication* clone(void) const;
+    std::string   name(void) const;
+    std::string   version(void) const;
+    double        telapse(void) const;
+    double        celapse(void) const;
+    void          logFileOpen(bool clobber = true);
+    bool          logTerse(void) const;
+    bool          logNormal(void) const;
+    bool          logExplicit(void) const;
+    bool          logVerbose(void) const;
+    bool          logDebug(void) const;
+    bool          clobber(void) const;
+    bool          haspar(const std::string& name) const;
+    std::string   par_filename(void) const;
+    std::string   log_filename(void) const;
+    void          log_header(void);
+    void          log_trailer(void);
+    void          log_parameters(void);
+    std::string   print(void) const;
  
     // Public members
-    GLog        log;                       //!< Application logger
+    GLog          log;                       //!< Application logger
  
 protected:
     // Protected methods
-    void        init_members(void);
-    void        copy_members(const GApplication& app);
-    void        free_members(void);
+    void init_members(void);
+    void copy_members(const GApplication& app);
+    void free_members(void);
  
     // Protected data members
     std::string              m_name;       //!< Application name
+/***************************************************************************
+ *                      GBase.hpp - GammaLib base class                    *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2012 by Juergen Knoedlseder                              *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  This program is free software: you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  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 GBase.hpp
+ * @brief Definition of interface for all GammaLib classes
+ * @author Juergen Knoedlseder
+ */
+
+#ifndef GBASE_HPP
+#define GBASE_HPP
+
+/* __ Includes ___________________________________________________________ */
+#include <string>
+#include <iostream>
+
+
+/***********************************************************************//**
+ * @class GBase
+ *
+ * @brief Interface class for all GammaLib classes
+ *
+ * This class defines the interface for all GammaLib classes. It is an
+ * abstract base class from which all other GammaLib classes will be
+ * derived. The interface class imposes on all GammaLib classes to
+ * implement the following methods:
+ * 
+ * clear() Sets the object to a clean initial state
+ *
+ * clone() Creates a deep copy of the object
+ *
+ * print() Print content of object
+ ***************************************************************************/
+class GBase {
+
+public:
+    /// @brief Destructor
+    ///
+    /// Destroys class.
+    virtual ~GBase(void) {}
+ 
+    /// @brief Clear object
+    ///
+    /// Sets the object to a clean initial state. After calling the method
+    /// the object will be in the same state as it were if an empty instance
+    /// of the object would have been created.
+    virtual void        clear(void) = 0;
+
+    /// @brief Clones object
+    ///
+    /// @return Pointer to deep copy of object.
+    ///
+    /// Creates a deep copy of the object and returns a pointer to the
+    /// object.
+    virtual GBase*      clone(void) const = 0;
+
+    /// @brief Print content of object
+    ///
+    /// @return String containing the content of the object.
+    ///
+    /// Formats the content in a standard way and puts this content in a
+    /// C++ string that is returned.
+    virtual std::string print(void) const = 0;
+};
+
+/* __ Forward declarations _______________________________________________ */
+class GLog;
+
+/* __ Prototypes _________________________________________________________ */
+std::ostream& operator<<(std::ostream& os, const GBase& base);
+GLog&         operator<<(GLog& log,        const GBase& base);
+
+#endif /* GBASE_HPP */
 /***************************************************************************
  *                GCaldb.hpp  -  Calibration database class                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Juergen Knoedlseder                              *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,18 +21,17 @@
 /**
  * @file GCaldb.hpp
  * @brief Calibration database class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GCALDB_HPP
 #define GCALDB_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
 #include <string>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GFits.hpp"
-#include "GFitsBinTable.hpp"
+#include "GFitsTable.hpp"
  
  
 /***********************************************************************//**
@@ -47,21 +46,29 @@
  * variable, or set using the dir() method.
  *
  * It is assumed that the calibration data are found under
- *   $CALDB/data/<mission>[/<instrument>]
+ *
+ *     $CALDB/data/<mission>[/<instrument>]
+ *
+ * or
+ *
+ *     $GAMMALIB_CALDB/data/<mission>[/<instrument>]
+ *
  * and that the Calibration Index File (CIF) is located at
- *   $CALDB/data/<mission>[/<instrument>]/caldb.indx
- * where <mission> is the name of the mission and <instrument> is the
+ *
+ *     $CALDB/data/<mission>[/<instrument>]/caldb.indx
+ *
+ * or
+ *
+ *     $GAMMALIB_CALDB/data/<mission>[/<instrument>]/caldb.indx
+ *
+ * where \<mission\> is the name of the mission and \<instrument\> is the
  * optional instrument name (all lower case).
  *
  * The calibration database for a given mission and instrument is opened
  * using the open() method. Once opened, database information can be
  * accessed. After usage, the database is closed using the close() method.
  ***************************************************************************/
-class GCaldb {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GCaldb& caldb);
-    friend GLog&         operator<<(GLog& log,        const GCaldb& caldb);
+class GCaldb : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *             GCsv.hpp - Column separated values table class              *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010 by Jurgen Knodlseder                                *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,17 +21,16 @@
 /**
  * @file GCsv.hpp
  * @brief Column separated values table class definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
-#ifndef GCsv_HPP
-#define GCsv_HPP
+#ifndef GCSV_HPP
+#define GCSV_HPP
  
 /* __ Includes ___________________________________________________________ */
 #include <vector>
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -39,11 +38,7 @@
  *
  * @brief Column separated values table class definition
  ***************************************************************************/
-class GCsv {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GCsv& csv);
-    friend GLog&         operator<< (GLog& log, const GCsv& csv);
+class GCsv : public GBase {
  
 public:
     // Constructors and destructors
@@ -81,4 +76,4 @@ protected:
     std::vector<std::vector<std::string> > m_data;  //!< CSV table data
 };
  
-#endif /* GCsv_HPP */
+#endif /* GCSV_HPP */
 /***************************************************************************
  *                  GDerivative.hpp  -  Derivative class                   *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GDerivative.hpp
  * @brief GDerivative class interface definition.
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GDERIVATIVE_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GFunction.hpp"
  
  
@@ -43,11 +42,7 @@
  * The function to be derived is implemented by the abstract GFunction
  * class.
  ***************************************************************************/
-class GDerivative {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GDerivative& dx);
-    friend GLog&         operator<<(GLog& log,        const GDerivative& dx);
+class GDerivative : public GBase {
  
 public:
  
 /***************************************************************************
  *               GEbounds.hpp  -  Energy boundaries class                  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Juergen Knoedlseder                         *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,16 +21,15 @@
 /**
  * @file GEbounds.hpp
  * @brief Energy boundaries class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GEBOUNDS_HPP
 #define GEBOUNDS_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
 #include <string>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GFits.hpp"
 #include "GFitsTable.hpp"
 #include "GEnergy.hpp"
@@ -43,11 +42,7 @@
  *
  * This class holds a list of energy intervals.
  ***************************************************************************/
-class GEbounds {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GEbounds& ebds);
-    friend GLog&         operator<<(GLog& log,        const GEbounds& ebds);
+class GEbounds : public GBase {
  
 public:
     // Constructors and destructors
@@ -81,7 +76,7 @@ public:
     GEnergy     emax(int inx) const;
     GEnergy     emean(int inx) const;
     GEnergy     elogmean(int inx) const;
-    bool        isin(const GEnergy& eng) const;
+    bool        contains(const GEnergy& eng) const;
     std::string print(void) const;
  
  
 /***************************************************************************
  *                        GEnergy.hpp - Energy class                       *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010 by Jurgen Knodlseder                                *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GEnergy.hpp
  * @brief Energy value class definition.
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GENERGY_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -46,11 +45,7 @@
  * value is changed. This considerably reduces the number of log10 operations
  * in many applications and speeds up the performance.
  ***************************************************************************/
-class GEnergy {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GEnergy& eng);
-    friend GLog&         operator<< (GLog& log, const GEnergy& eng);
+class GEnergy : public GBase {
  
     // Operator friends
     friend GEnergy operator+ (const GEnergy &a, const GEnergy &b);
@@ -78,6 +73,7 @@ public:
  
     // Methods
     void        clear(void);
+    GEnergy*    clone(void) const;
     double      erg(void) const;
     double      keV(void) const;
     double      MeV(void) const;
 /***************************************************************************
  *                  GEvent.hpp  -  Event abstract base class               *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2010 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GEvent.hpp
  * @brief GEvent abstract base class interface definition.
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GEVENT_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GInstDir.hpp"
 #include "GEnergy.hpp"
 #include "GTime.hpp"
@@ -69,11 +68,7 @@
  * The GEvent class does not hold any data members. Data members are stored
  * in the derived classes.
  ***************************************************************************/
-class GEvent {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GEvent& event);
-    friend GLog&         operator<< (GLog& log, const GEvent& event);
+class GEvent : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *              GEvents.hpp  -  Abstract event container class             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Juergen Knoedlseder                         *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GEvents.hpp
  * @brief Abstract event container class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GEVENTS_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GEvent.hpp"
 #include "GFits.hpp"
 #include "GEbounds.hpp"
@@ -61,11 +60,7 @@
  * An event iterator allows iterating over the event atoms or bins of the
  * container.
  ***************************************************************************/
-class GEvents {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GEvents& events);
-    friend GLog&         operator<<(GLog& log,        const GEvents& events);
+class GEvents : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *                    GFits.hpp  - FITS file access class                  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Juergen Knoedlseder                         *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFits.hpp
  * @brief FITS file access class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITS_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <string>
 #include <vector>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GFitsHDU.hpp"
 #include "GFitsImage.hpp"
 #include "GFitsTable.hpp"
@@ -47,11 +46,7 @@
  * which are implemented by the GFitsHDU class. Each HDU is composed of a
  * header (GFitsHeader) and some data (GFitsData).
  ***************************************************************************/
-class GFits {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GFits& fits);
-    friend GLog&         operator<<(GLog& log,        const GFits& fits);
+class GFits : public GBase {
  
 public:
     // Constructors and destructors
@@ -65,6 +60,7 @@ public:
  
     // Methods
     void        clear(void);
+    GFits*      clone(void) const;
     int         size(void) const;
     void        open(const std::string& filename, bool create = false);
     void        save(bool clobber = false);
 /***************************************************************************
- *             GFitsAsciiTable.hpp  - FITS ASCII table class               *
+ *             GFitsAsciiTable.hpp - FITS ASCII table class                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2010 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GFitsAsciiTable.hpp
- * @brief GFitsAsciiTable class definition.
- * @author J. Knodlseder
+ * @brief FITS ASCII table class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSASCIITABLE_HPP
@@ -34,9 +34,9 @@
 /***********************************************************************//**
  * @class GFitsAsciiTable
  *
- * @brief Interface for FITS binary table
+ * @brief Interface for FITS ASCII table
  *
- * The following ASCII tables are supported: 
+ * The following ASCII table columns are supported: 
  * TSTRING (A),
  * TLONG (I),
  * TDOUBLE (F,D)
@@ -54,19 +54,16 @@ public:
     // Operators
     GFitsAsciiTable& operator= (const GFitsAsciiTable& table);
  
-    // Implemented pure virtual methods
-    HDUType exttype(void) const { return HT_ASCII_TABLE; }
-
     // Methods
+    virtual void             clear(void);
+    virtual GFitsAsciiTable* clone(void) const;
+    HDUType                  exttype(void) const { return HT_ASCII_TABLE; }
  
 private:
     // Private methods
-    void             init_members(void);
-    void             copy_members(const GFitsAsciiTable& table);
-    void             free_members(void);
-    GFitsAsciiTable* clone(void) const;
-
-    // Private data area
+    void init_members(void);
+    void copy_members(const GFitsAsciiTable& table);
+    void free_members(void);
 };
  
 #endif /* GFITSASCIITABLE_HPP */
 /***************************************************************************
- *              GFitsBinTable.hpp  - FITS binary table class               *
+ *               GFitsBinTable.hpp - FITS binary table class               *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2010 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GFitsBinTable.hpp
- * @brief GFitsBinTable class definition.
- * @author J. Knodlseder
+ * @brief FITS binary table class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSBINTABLE_HPP
@@ -49,18 +49,15 @@ public:
     GFitsBinTable& operator= (const GFitsBinTable& table);
  
     // Implemented pure virtual methods
-    HDUType exttype(void) const { return HT_BIN_TABLE; }
-
-    // Methods
+    virtual void           clear(void);
+    virtual GFitsBinTable* clone(void) const;
+    HDUType                exttype(void) const { return HT_BIN_TABLE; }
  
 private:
     // Private methods
-    void           init_members(void);
-    void           copy_members(const GFitsBinTable& table);
-    void           free_members(void);
-    GFitsBinTable* clone(void) const;
-
-    // Private data area
+    void init_members(void);
+    void copy_members(const GFitsBinTable& table);
+    void free_members(void);
 };
  
 #endif /* GFITSBINTABLE_HPP */
 /***************************************************************************
  *                  GFitsHDU.hpp  - FITS HDU handling class                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2010 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsHDU.hpp
  * @brief GFitsHDU class definition.
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSHDU_HPP
@@ -29,6 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
+#include "GBase.hpp"
 #include "GFitsHeader.hpp"
 #include "GFitsHeaderCard.hpp"
  
@@ -47,7 +48,7 @@
  * @todo Implement GFitsHDU* select(const std::string& expr) that applies
  * to a table HDU for row selection.
  ***************************************************************************/
-class GFitsHDU {
+class GFitsHDU : public GBase {
  
     // Friend classes
     friend class GFits;
@@ -69,8 +70,9 @@ public:
     };
  
     // Pure virtual methods
-    virtual HDUType     exttype(void) const = 0;
+    virtual void        clear(void) = 0;
     virtual GFitsHDU*   clone(void) const = 0;
+    virtual HDUType     exttype(void) const = 0;
     virtual std::string print(void) const = 0;
  
     // Implemented methods
@@ -96,6 +98,9 @@ public:
  
 protected:
     // Protected methods
+    void         init_members(void);
+    void         copy_members(const GFitsHDU& hdu);
+    void         free_members(void);
     void         connect(void* fptr);
     void         move_to_hdu(void);
     HDUType      get_hdu_type(void) const;
@@ -115,12 +120,6 @@ protected:
     int          m_hdunum;      //!< HDU number (starting from 0)
     std::string  m_name;        //!< HDU name (extname)
     GFitsHeader  m_header;      //!< HDU header
-
-private:
-    // Private methods
-    void init_members(void);
-    void copy_members(const GFitsHDU& hdu);
-    void free_members(void);
 };
  
 #endif /* GFITSHDU_HPP */
 /***************************************************************************
  *               GFitsHeader.hpp  - FITS header handling class             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Juergen Knoedlseder                         *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,15 +21,14 @@
 /**
  * @file GFitsHeader.hpp
  * @brief FITS header class definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSHEADER_HPP
 #define GFITSHEADER_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GFitsHeaderCard.hpp"
  
  
@@ -44,11 +43,7 @@
  * saved into another file (using the 'save' method). Cards are added or
  * changed using the 'update' method.
  ***************************************************************************/
-class GFitsHeader {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GFitsHeader& header);
-    friend GLog&         operator<< (GLog& log, const GFitsHeader& header);
+class GFitsHeader : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *               GFitsHeaderCard.hpp  - FITS header card class             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,15 +21,15 @@
 /**
  * @file GFitsHeaderCard.hpp
  * @brief FITS header card class definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSHEADERCARD_HPP
 #define GFITSHEADERCARD_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
-#include "GLog.hpp"
+#include <string>
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -43,15 +43,11 @@
  *
  * @todo Many more datatypes may exist for a header card.
  ***************************************************************************/
-class GFitsHeaderCard {
+class GFitsHeaderCard : public GBase {
  
     // Friend classes
     friend class GFitsHeader;
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GFitsHeaderCard& card);
-    friend GLog&         operator<<(GLog& log,        const GFitsHeaderCard& card);
-
 public:
     // Constructors & Destructors
     GFitsHeaderCard(void);
@@ -67,32 +63,32 @@ public:
     // Operators
     GFitsHeaderCard& operator= (const GFitsHeaderCard& card);
  
-    // Methods to set card properties
-    void         keyname(const std::string& keyname);
-    void         value(const std::string& value);
-    void         value(const bool& value);
-    void         value(const float& value);
-    void         value(const double& value);
-    void         value(const unsigned short& value);
-    void         value(const short& value);
-    void         value(const unsigned int& value);
-    void         value(const int& value);
-    void         value(const long& value);
-    void         value(const unsigned long& value);
-    void         value(const long long& value);
-    void         unit(const std::string& unit);
-    void         comment(const std::string& comment);
-
-    // Methods to get card properties
-    std::string  keyname(void) const;
-    std::string  value(void) const;
-    int          decimals(void) const;
-    std::string  unit(void) const;
-    std::string  comment(void) const;
-    std::string  string(void);
-    double       real(void);
-    int          integer(void);
-    std::string  print(void) const;
+    // Methods
+    void             clear(void);
+    GFitsHeaderCard* clone(void) const;
+    void             keyname(const std::string& keyname);
+    std::string      keyname(void) const;
+    void             value(const std::string& value);
+    void             value(const bool& value);
+    void             value(const float& value);
+    void             value(const double& value);
+    void             value(const unsigned short& value);
+    void             value(const short& value);
+    void             value(const unsigned int& value);
+    void             value(const int& value);
+    void             value(const long& value);
+    void             value(const unsigned long& value);
+    void             value(const long long& value);
+    std::string      value(void) const;
+    int              decimals(void) const;
+    void             unit(const std::string& unit);
+    std::string      unit(void) const;
+    void             comment(const std::string& comment);
+    std::string      comment(void) const;
+    std::string      string(void);
+    double           real(void);
+    int              integer(void);
+    std::string      print(void) const;
  
 private:
     // Private methods
@@ -28,8 +28,6 @@
 #define GFITSIMAGE_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
-#include "GLog.hpp"
 #include "GFitsHDU.hpp"
  
  
@@ -42,10 +40,6 @@
  ***************************************************************************/
 class GFitsImage : public GFitsHDU {
  
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GFitsImage& image);
-    friend GLog&         operator<< (GLog& log, const GFitsImage& image);
-
 public:
     // Constructors and destructors
     GFitsImage(void);
@@ -61,13 +55,14 @@ public:
     GFitsImage& operator= (const GFitsImage& image);
  
     // Pure virtual methods
+    virtual void        clear(void) = 0;
+    virtual GFitsImage* clone(void) const = 0;
     virtual void*       pixels(void) = 0;
     virtual double      pixel(const int& ix) const = 0;
     virtual double      pixel(const int& ix, const int& iy) const = 0;
     virtual double      pixel(const int& ix, const int& iy, const int& iz) const = 0;
     virtual double      pixel(const int& ix, const int& iy, const int& iz, const int& it) const = 0;
     virtual int         type(void) const = 0;
-    virtual GFitsImage* clone(void) const = 0;
  
     // Implemented pure virtual methods
     HDUType exttype(void) const { return HT_IMAGE; }
@@ -84,6 +79,9 @@ public:
  
 protected:
     // Protected methods
+    void  init_members(void);
+    void  copy_members(const GFitsImage& image);
+    void  free_members(void);
     void  data_open(void* vptr);
     void  data_save(void);
     void  data_close(void);
@@ -113,12 +111,6 @@ protected:
     long* m_naxes;       //!< Number of pixels in each dimension
     int   m_num_pixels;  //!< Number of image pixels
     int   m_anynul;      //!< Number of NULLs encountered
-
-private:
-    // Private methods
-    void init_members(void);
-    void copy_members(const GFitsImage& image);
-    void free_members(void);
 };
  
 #endif /* GFITSIMAGE_HPP */
 /***************************************************************************
  *               GFitsImageByte.hpp  - FITS Byte image class               *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010 by Jurgen Knodlseder                                *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -61,6 +61,8 @@ public:
     const unsigned char& operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void                 clear(void);
+    GFitsImageByte*      clone(void) const;
     unsigned char&       at(const int& ix);
     unsigned char&       at(const int& ix, const int& iy);
     unsigned char&       at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double               pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*                pixels(void);
     int                  type(void) const;
-    GFitsImageByte*      clone(void) const;
  
 private:
     // Private methods
@@ -21,7 +21,7 @@
 /**
  * @file GFitsImageDouble.hpp
  * @brief GFitsImageDouble class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSIMAGEDOUBLE_HPP
@@ -61,6 +61,8 @@ public:
     const double&     operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void              clear(void);
+    GFitsImageDouble* clone(void) const;
     double&           at(const int& ix);
     double&           at(const int& ix, const int& iy);
     double&           at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double            pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*             pixels(void);
     int               type(void) const;
-    GFitsImageDouble* clone(void) const;
  
 private:
     // Private methods
@@ -21,7 +21,7 @@
 /**
  * @file GFitsImageFloat.hpp
  * @brief GFitsImageFloat class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSIMAGEFLOAT_HPP
@@ -61,6 +61,8 @@ public:
     const float&     operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void             clear(void);
+    GFitsImageFloat* clone(void) const;
     float&           at(const int& ix);
     float&           at(const int& ix, const int& iy);
     float&           at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double           pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*            pixels(void);
     int              type(void) const;
-    GFitsImageFloat* clone(void) const;
  
 private:
     // Private methods
@@ -61,6 +61,8 @@ public:
     const long&     operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void            clear(void);
+    GFitsImageLong* clone(void) const;
     long&           at(const int& ix);
     long&           at(const int& ix, const int& iy);
     long&           at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double          pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*           pixels(void);
     int             type(void) const;
-    GFitsImageLong* clone(void) const;
  
 private:
     // Private methods
@@ -21,7 +21,7 @@
 /**
  * @file GFitsImageLongLong.hpp
  * @brief GFitsImageLongLong class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSIMAGELONGLONG_HPP
@@ -61,6 +61,8 @@ public:
     const long long&    operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void                clear(void);
+    GFitsImageLongLong* clone(void) const;
     long long&          at(const int& ix);
     long long&          at(const int& ix, const int& iy);
     long long&          at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double              pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*               pixels(void);
     int                 type(void) const;
-    GFitsImageLongLong* clone(void) const;
  
 private:
     // Private methods
@@ -21,7 +21,7 @@
 /**
  * @file GFitsImageSByte.hpp
  * @brief GFitsImageSByte class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSIMAGESBYTE_HPP
@@ -61,6 +61,8 @@ public:
     const char&      operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void             clear(void);
+    GFitsImageSByte* clone(void) const;
     char&            at(const int& ix);
     char&            at(const int& ix, const int& iy);
     char&            at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double           pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*            pixels(void);
     int              type(void) const;
-    GFitsImageSByte* clone(void) const;
  
 private:
     // Private methods
@@ -21,7 +21,7 @@
 /**
  * @file GFitsImageShort.hpp
  * @brief GFitsImageShort class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSIMAGESHORT_HPP
@@ -61,6 +61,8 @@ public:
     const short&     operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void             clear(void);
+    GFitsImageShort* clone(void) const;
     short&           at(const int& ix);
     short&           at(const int& ix, const int& iy);
     short&           at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double           pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*            pixels(void);
     int              type(void) const;
-    GFitsImageShort* clone(void) const;
  
 private:
     // Private methods
@@ -21,7 +21,7 @@
 /**
  * @file GFitsImageULong.hpp
  * @brief GFitsImageULong class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSIMAGEULONG_HPP
@@ -61,6 +61,8 @@ public:
     const unsigned long& operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void                 clear(void);
+    GFitsImageULong*     clone(void) const;
     unsigned long&       at(const int& ix);
     unsigned long&       at(const int& ix, const int& iy);
     unsigned long&       at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double               pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*                pixels(void);
     int                  type(void) const;
-    GFitsImageULong*     clone(void) const;
  
 private:
     // Private methods
@@ -21,7 +21,7 @@
 /**
  * @file GFitsImageUShort.hpp
  * @brief GFitsImageUShort class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSIMAGEUSHORT_HPP
@@ -61,6 +61,8 @@ public:
     const unsigned short& operator() (const int& ix, const int& iy, const int& iz, const int& it) const;
  
     // Methods
+    void                  clear(void);
+    GFitsImageUShort*     clone(void) const;
     unsigned short&       at(const int& ix);
     unsigned short&       at(const int& ix, const int& iy);
     unsigned short&       at(const int& ix, const int& iy, const int& iz);
@@ -75,7 +77,6 @@ public:
     double                pixel(const int& ix, const int& iy, const int& iz, const int& it) const;
     void*                 pixels(void);
     int                   type(void) const;
-    GFitsImageUShort*     clone(void) const;
  
 private:
     // Private methods
 /***************************************************************************
  *             GFitsTable.hpp  - FITS table abstract base class            *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Juergen Knoedlseder                         *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,22 +21,17 @@
 /**
  * @file GFitsTable.hpp
  * @brief FITS table abstract base class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLE_HPP
 #define GFITSTABLE_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
-#include "GLog.hpp"
 #include "GFitsHDU.hpp"
 #include "GFitsTableCol.hpp"
  
  
-/* __ Structures _________________________________________________________ */
-
-
 /***********************************************************************//**
  * @class GFitsTable
  *
@@ -50,10 +45,6 @@
  ***************************************************************************/
 class GFitsTable : public GFitsHDU {
  
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GFitsTable& table);
-    friend GLog&         operator<< (GLog& log, const GFitsTable& table);
-
 public:
     // Constructors and destructors
     GFitsTable(void);
@@ -69,7 +60,9 @@ public:
     const GFitsTableCol& operator[](const std::string& colname) const;
  
     // Pure virtual methods
+    virtual void        clear(void) = 0;
     virtual GFitsTable* clone(void) const = 0;
+    virtual HDUType     exttype(void) const = 0;
  
     // Implemented Methods
     void        append_column(GFitsTableCol& column);
@@ -84,6 +77,9 @@ public:
  
 protected:
     // Protected methods
+    void  init_members(void);
+    void  copy_members(const GFitsTable& table);
+    void  free_members(void);
     void  data_open(void* vptr);
     void  data_save(void);
     void  data_close(void);
@@ -100,9 +96,6 @@ protected:
  
 private:
     // Private methods
-    void            init_members(void);
-    void            copy_members(const GFitsTable& table);
-    void            free_members(void);
     GFitsTableCol*  alloc_column(int typecode) const;
     GFitsTableCol*  ptr_column(const std::string& colname) const;
 };
 /***************************************************************************
  *            GFitsTableBitCol.hpp  - FITS table bit column class          *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableBitCol.hpp
  * @brief FITS table bit column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLEBITCOL_HPP
@@ -56,12 +56,14 @@ public:
     bool&             operator() (const int& row, const int& inx = 0);
     const bool&       operator() (const int& row, const int& inx = 0) const;
  
-    // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    // Implemented virtual methods
+    virtual void              clear(void);
+    virtual GFitsTableBitCol* clone(void) const;
+    virtual std::string       string(const int& row, const int& col = 0) const;
+    virtual double            real(const int& row, const int& col = 0) const;
+    virtual int               integer(const int& row, const int& col = 0) const;
+    virtual void              insert(const int& rownum, const int& nrows);
+    virtual void              remove(const int& rownum, const int& nrows);
  
     // Other methods
     unsigned char* data(void) { return m_data; }
@@ -75,7 +77,6 @@ private:
     void free_members(void);
  
     // Implemented pure virtual methods
-    virtual GFitsTableBitCol* clone(void) const;
     virtual std::string       ascii_format(void) const;
     virtual std::string       binary_format(void) const;
     virtual void              alloc_data(void);
 /***************************************************************************
  *        GFitsTableBoolCol.hpp  - FITS table boolean column class         *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableBoolCol.hpp
  * @brief FITS table Boolean column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLEBOOLCOL_HPP
@@ -58,11 +58,13 @@ public:
     const bool&        operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void               clear(void);
+    virtual GFitsTableBoolCol* clone(void) const;
+    virtual std::string        string(const int& row, const int& col = 0) const;
+    virtual double             real(const int& row, const int& col = 0) const;
+    virtual int                integer(const int& row, const int& col = 0) const;
+    virtual void               insert(const int& rownum, const int& nrows);
+    virtual void               remove(const int& rownum, const int& nrows);
  
     // Other methods
     bool* data(void) { return m_data; }
@@ -71,22 +73,21 @@ public:
  
 private:
     // Private methods
-    void               init_members(void);
-    void               copy_members(const GFitsTableBoolCol& column);
-    void               free_members(void);
-    void               save(void);
-    GFitsTableBoolCol* clone(void) const;
-    std::string        ascii_format(void) const;
-    std::string        binary_format(void) const;
-    void               alloc_data(void);
-    void               release_data(void);
-    void               alloc_nulval(const bool* value);
-    void               init_data(void);
-    void               fetch_data(void) const;
-    void               alloc_buffer(void);
-    void               free_buffer(void);
-    void*              ptr_data(void) { return m_buffer; }
-    void*              ptr_nulval(void) { return m_nulval; }
+    void        init_members(void);
+    void        copy_members(const GFitsTableBoolCol& column);
+    void        free_members(void);
+    void        save(void);
+    std::string ascii_format(void) const;
+    std::string binary_format(void) const;
+    void        alloc_data(void);
+    void        release_data(void);
+    void        alloc_nulval(const bool* value);
+    void        init_data(void);
+    void        fetch_data(void) const;
+    void        alloc_buffer(void);
+    void        free_buffer(void);
+    void*       ptr_data(void) { return m_buffer; }
+    void*       ptr_nulval(void) { return m_nulval; }
  
     // Private data area
     bool* m_data;       //!< Data area
 /***************************************************************************
  *         GFitsTableByteCol.hpp  - FITS table Byte column class           *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableByteCol.hpp
  * @brief FITS table Byte column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLEBYTECOL_HPP
@@ -55,11 +55,13 @@ public:
     const unsigned char& operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void               clear(void);
+    virtual GFitsTableByteCol* clone(void) const;
+    virtual std::string        string(const int& row, const int& col = 0) const;
+    virtual double             real(const int& row, const int& col = 0) const;
+    virtual int                integer(const int& row, const int& col = 0) const;
+    virtual void               insert(const int& rownum, const int& nrows);
+    virtual void               remove(const int& rownum, const int& nrows);
  
     // Other methods
     unsigned char* data(void) { return m_data; }
@@ -68,18 +70,17 @@ public:
  
 private:
     // Private methods
-    void               init_members(void);
-    void               copy_members(const GFitsTableByteCol& column);
-    void               free_members(void);
-    GFitsTableByteCol* clone(void) const;
-    std::string        ascii_format(void) const;
-    std::string        binary_format(void) const;
-    void               alloc_data(void);
-    void               release_data(void);
-    void               alloc_nulval(const unsigned char* value);
-    void               init_data(void);
-    void*              ptr_data(void) { return m_data; }
-    void*              ptr_nulval(void) { return m_nulval; }
+    void        init_members(void);
+    void        copy_members(const GFitsTableByteCol& column);
+    void        free_members(void);
+    std::string ascii_format(void) const;
+    std::string binary_format(void) const;
+    void        alloc_data(void);
+    void        release_data(void);
+    void        alloc_nulval(const unsigned char* value);
+    void        init_data(void);
+    void*       ptr_data(void) { return m_data; }
+    void*       ptr_nulval(void) { return m_nulval; }
  
     // Private data area
     unsigned char* m_data;       //!< Data vector
 /***************************************************************************
  *  GFitsTableCDoubleCol.hpp  - FITS table double precision complex column *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableCDoubleCol.hpp
  * @brief FITS table double complex column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLECDOUBLECOL_HPP
@@ -56,11 +56,13 @@ public:
     const GFits::cdouble& operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                  clear(void);
+    virtual GFitsTableCDoubleCol* clone(void) const;
+    virtual std::string           string(const int& row, const int& col = 0) const;
+    virtual double                real(const int& row, const int& col = 0) const;
+    virtual int                   integer(const int& row, const int& col = 0) const;
+    virtual void                  insert(const int& rownum, const int& nrows);
+    virtual void                  remove(const int& rownum, const int& nrows);
  
     // Other methods
     GFits::cdouble* data(void) { return m_data; }
@@ -69,18 +71,17 @@ public:
  
 private:
     // Private methods
-    void                  init_members(void);
-    void                  copy_members(const GFitsTableCDoubleCol& column);
-    void                  free_members(void);
-    GFitsTableCDoubleCol* clone(void) const;
-    std::string           ascii_format(void) const;
-    std::string           binary_format(void) const;
-    void                  alloc_data(void);
-    void                  release_data(void);
-    void                  alloc_nulval(const GFits::cdouble* value);
-    void                  init_data(void);
-    void*                 ptr_data(void) { return m_data; }
-    void*                 ptr_nulval(void) { return m_nulval; }
+    void        init_members(void);
+    void        copy_members(const GFitsTableCDoubleCol& column);
+    void        free_members(void);
+    std::string ascii_format(void) const;
+    std::string binary_format(void) const;
+    void        alloc_data(void);
+    void        release_data(void);
+    void        alloc_nulval(const GFits::cdouble* value);
+    void        init_data(void);
+    void*       ptr_data(void) { return m_data; }
+    void*       ptr_nulval(void) { return m_nulval; }
  
     // Private data area
     GFits::cdouble* m_data;       //!< Data vector
 /***************************************************************************
  *  GFitsTableCFloatCol.hpp  - FITS table single precision complex column  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableCFloatCol.hpp
  * @brief FITS table float complex column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLECFLOATCOL_HPP
@@ -56,11 +56,13 @@ public:
     const GFits::cfloat&  operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                 clear(void);
+    virtual GFitsTableCFloatCol* clone(void) const;
+    virtual std::string          string(const int& row, const int& col = 0) const;
+    virtual double               real(const int& row, const int& col = 0) const;
+    virtual int                  integer(const int& row, const int& col = 0) const;
+    virtual void                 insert(const int& rownum, const int& nrows);
+    virtual void                 remove(const int& rownum, const int& nrows);
  
     // Other methods
     GFits::cfloat* data(void) { return m_data; }
@@ -69,18 +71,17 @@ public:
  
 private:
     // Private methods
-    void                  init_members(void);
-    void                  copy_members(const GFitsTableCFloatCol& column);
-    void                  free_members(void);
-    GFitsTableCFloatCol* clone(void) const;
-    std::string           ascii_format(void) const;
-    std::string           binary_format(void) const;
-    void                  alloc_data(void);
-    void                  release_data(void);
-    void                  alloc_nulval(const GFits::cfloat* value);
-    void                  init_data(void);
-    void*                 ptr_data(void) { return m_data; }
-    void*                 ptr_nulval(void) { return m_nulval; }
+    void        init_members(void);
+    void        copy_members(const GFitsTableCFloatCol& column);
+    void        free_members(void);
+    std::string ascii_format(void) const;
+    std::string binary_format(void) const;
+    void        alloc_data(void);
+    void        release_data(void);
+    void        alloc_nulval(const GFits::cfloat* value);
+    void        init_data(void);
+    void*       ptr_data(void) { return m_data; }
+    void*       ptr_nulval(void) { return m_nulval; }
  
     // Private data area
     GFits::cfloat* m_data;       //!< Data vector
 /***************************************************************************
  *        GFitsTableCol.hpp  - FITS table column abstract base class       *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,17 +21,16 @@
 /**
  * @file GFitsTableCol.hpp
  * @brief FITS table column abstract base class definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLECOL_HPP
 #define GFITSTABLECOL_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
 #include <string>
 #include <vector>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -41,15 +40,11 @@
  *
  * This class implements a FITS table column. Vector columns are supported.
  ***************************************************************************/
-class GFitsTableCol {
+class GFitsTableCol : public GBase {
  
     // Friend classes
     friend class GFitsTable;
  
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GFitsTableCol& column);
-    friend GLog&         operator<< (GLog& log, const GFitsTableCol& column);
-
 public:
     // Constructors and destructors
     GFitsTableCol(void);
@@ -61,12 +56,14 @@ public:
     // Operators
     GFitsTableCol& operator= (const GFitsTableCol& column);
  
-    // Virtual Methods
-    virtual std::string string(const int& row, const int& inx = 0) const = 0;
-    virtual double      real(const int& row, const int& inx = 0) const = 0;
-    virtual int         integer(const int& row, const int& inx = 0) const = 0;
-    virtual void        insert(const int& rownum, const int& nrows) = 0;
-    virtual void        remove(const int& rownum, const int& nrows) = 0;
+    // Pure virtual Methods
+    virtual void           clear(void) = 0;
+    virtual GFitsTableCol* clone(void) const = 0;
+    virtual std::string    string(const int& row, const int& inx = 0) const = 0;
+    virtual double         real(const int& row, const int& inx = 0) const = 0;
+    virtual int            integer(const int& row, const int& inx = 0) const = 0;
+    virtual void           insert(const int& rownum, const int& nrows) = 0;
+    virtual void           remove(const int& rownum, const int& nrows) = 0;
  
     // Base class Methods
     void             name(const std::string& name);
@@ -105,24 +102,21 @@ protected:
     void*            m_fitsfile; //!< FITS file pointer associated with column
  
     // Protected pure virtual methods
-    virtual GFitsTableCol* clone(void) const = 0;
-    virtual std::string    ascii_format(void) const = 0;
-    virtual std::string    binary_format(void) const = 0;
-    virtual void           alloc_data(void) = 0;
-    virtual void           init_data(void) = 0;
-    virtual void*          ptr_data(void) = 0;
-    virtual void*          ptr_nulval(void) = 0;
+    virtual std::string ascii_format(void) const = 0;
+    virtual std::string binary_format(void) const = 0;
+    virtual void        alloc_data(void) = 0;
+    virtual void        init_data(void) = 0;
+    virtual void*       ptr_data(void) = 0;
+    virtual void*       ptr_nulval(void) = 0;
  
     // Protected virtual methods
-    virtual void           save(void);
-    virtual void           fetch_data(void) const;
-    virtual void           load_column(void);
-    virtual void           save_column(void);
-    virtual std::ostream&  dump_column(std::ostream& os) const;
-    virtual GLog&          dump_column(GLog& log) const;
-    virtual int            offset(const int& row, const int& inx) const;
+    virtual void        save(void);
+    virtual void        fetch_data(void) const;
+    virtual void        load_column(void);
+    virtual void        save_column(void);
+    virtual int         offset(const int& row, const int& inx) const;
  
-private:
+protected:
     // Private methods
     void init_members(void);
     void copy_members(const GFitsTableCol& column);
 /***************************************************************************
  *        GFitsTableDoubleCol.hpp  - FITS table double column class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableDoubleCol.hpp
  * @brief FITS table double column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLEDOUBLECOL_HPP
@@ -55,11 +55,13 @@ public:
     const double&        operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                 clear(void);
+    virtual GFitsTableDoubleCol* clone(void) const;
+    virtual std::string          string(const int& row, const int& col = 0) const;
+    virtual double               real(const int& row, const int& col = 0) const;
+    virtual int                  integer(const int& row, const int& col = 0) const;
+    virtual void                 insert(const int& rownum, const int& nrows);
+    virtual void                 remove(const int& rownum, const int& nrows);
  
     // Other methods
     double* data(void) { return m_data; }
@@ -71,7 +73,6 @@ private:
     void                 init_members(void);
     void                 copy_members(const GFitsTableDoubleCol& column);
     void                 free_members(void);
-    GFitsTableDoubleCol* clone(void) const;
     std::string          ascii_format(void) const;
     std::string          binary_format(void) const;
     void                 alloc_data(void);
 /***************************************************************************
  *         GFitsTableFloatCol.hpp  - FITS table float column class         *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -55,11 +55,13 @@ public:
     const float&        operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                clear(void);
+    virtual GFitsTableFloatCol* clone(void) const;
+    virtual std::string         string(const int& row, const int& col = 0) const;
+    virtual double              real(const int& row, const int& col = 0) const;
+    virtual int                 integer(const int& row, const int& col = 0) const;
+    virtual void                insert(const int& rownum, const int& nrows);
+    virtual void                remove(const int& rownum, const int& nrows);
  
     // Other methods
     float* data(void) { return m_data; }
@@ -71,7 +73,6 @@ private:
     void                init_members(void);
     void                copy_members(const GFitsTableFloatCol& column);
     void                free_members(void);
-    GFitsTableFloatCol* clone(void) const;
     std::string         ascii_format(void) const;
     std::string         binary_format(void) const;
     void                alloc_data(void);
@@ -55,11 +55,13 @@ public:
     const long&        operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void               clear(void);
+    virtual GFitsTableLongCol* clone(void) const;
+    virtual std::string        string(const int& row, const int& col = 0) const;
+    virtual double             real(const int& row, const int& col = 0) const;
+    virtual int                integer(const int& row, const int& col = 0) const;
+    virtual void               insert(const int& rownum, const int& nrows);
+    virtual void               remove(const int& rownum, const int& nrows);
  
     // Other methods
     long* data(void) { return m_data; }
@@ -71,7 +73,6 @@ private:
     void               init_members(void);
     void               copy_members(const GFitsTableLongCol& column);
     void               free_members(void);
-    GFitsTableLongCol* clone(void) const;
     std::string        ascii_format(void) const;
     std::string        binary_format(void) const;
     void               alloc_data(void);
 /***************************************************************************
  *     GFitsTableLongLongCol.hpp  - FITS table long long column class      *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableLongLongCol.hpp
  * @brief FITS table long long integer column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knodlseder
  */
  
 #ifndef GFITSTABLELONGLONGCOL_HPP
@@ -55,11 +55,13 @@ public:
     const long long&       operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                   clear(void);
+    virtual GFitsTableLongLongCol* clone(void) const;
+    virtual std::string            string(const int& row, const int& col = 0) const;
+    virtual double                 real(const int& row, const int& col = 0) const;
+    virtual int                    integer(const int& row, const int& col = 0) const;
+    virtual void                   insert(const int& rownum, const int& nrows);
+    virtual void                   remove(const int& rownum, const int& nrows);
  
     // Other methods
     long long*  data(void) { return m_data; }
@@ -71,7 +73,6 @@ private:
     void                   init_members(void);
     void                   copy_members(const GFitsTableLongLongCol& column);
     void                   free_members(void);
-    GFitsTableLongLongCol* clone(void) const;
     std::string            ascii_format(void) const;
     std::string            binary_format(void) const;
     void                   alloc_data(void);
 /***************************************************************************
  *         GFitsTableShortCol.hpp  - FITS table short column class         *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableShortCol.hpp
  * @brief FITS table short integer column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLESHORTCOL_HPP
@@ -55,11 +55,13 @@ public:
     const short&        operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                clear(void);
+    virtual GFitsTableShortCol* clone(void) const;
+    virtual std::string         string(const int& row, const int& col = 0) const;
+    virtual double              real(const int& row, const int& col = 0) const;
+    virtual int                 integer(const int& row, const int& col = 0) const;
+    virtual void                insert(const int& rownum, const int& nrows);
+    virtual void                remove(const int& rownum, const int& nrows);
  
     // Other methods
     short* data(void) { return m_data; }
@@ -71,7 +73,6 @@ private:
     void                init_members(void);
     void                copy_members(const GFitsTableShortCol& column);
     void                free_members(void);
-    GFitsTableShortCol* clone(void) const;
     std::string         ascii_format(void) const;
     std::string         binary_format(void) const;
     void                alloc_data(void);
 /***************************************************************************
  *        GFitsTableStringCol.hpp  - FITS table string column class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2010 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableStringCol.hpp
  * @brief FITS table string column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLESTRINGCOL_HPP
@@ -55,11 +55,13 @@ public:
     const std::string&    operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                 clear(void);
+    virtual GFitsTableStringCol* clone(void) const;
+    virtual std::string          string(const int& row, const int& col = 0) const;
+    virtual double               real(const int& row, const int& col = 0) const;
+    virtual int                  integer(const int& row, const int& col = 0) const;
+    virtual void                 insert(const int& rownum, const int& nrows);
+    virtual void                 remove(const int& rownum, const int& nrows);
  
     // Other methods
     std::string* data(void) { return m_data; }
@@ -72,7 +74,6 @@ private:
     void                 copy_members(const GFitsTableStringCol& column);
     void                 free_members(void);
     void                 save(void);
-    GFitsTableStringCol* clone(void) const;
     std::string          ascii_format(void) const;
     std::string          binary_format(void) const;
     void                 alloc_data(void);
 /***************************************************************************
  *     GFitsTableULongCol.hpp  - FITS table unsigned long column class     *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableULongCol.hpp
  * @brief FITS table unsigned long integer column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLEULONGCOL_HPP
@@ -55,11 +55,13 @@ public:
     const unsigned long& operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                clear(void);
+    virtual GFitsTableULongCol* clone(void) const;
+    virtual std::string         string(const int& row, const int& col = 0) const;
+    virtual double              real(const int& row, const int& col = 0) const;
+    virtual int                 integer(const int& row, const int& col = 0) const;
+    virtual void                insert(const int& rownum, const int& nrows);
+    virtual void                remove(const int& rownum, const int& nrows);
  
     // Other methods
     unsigned long* data(void) { return m_data; }
@@ -71,7 +73,6 @@ private:
     void                init_members(void);
     void                copy_members(const GFitsTableULongCol& column);
     void                free_members(void);
-    GFitsTableULongCol* clone(void) const;
     std::string         ascii_format(void) const;
     std::string         binary_format(void) const;
     void                alloc_data(void);
 /***************************************************************************
  *    GFitsTableUShortCol.hpp  - FITS table unsigned short column class    *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GFitsTableUShortCol.hpp
  * @brief FITS table unsigned short integer column class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GFITSTABLEUSHORTCOL_HPP
@@ -55,11 +55,13 @@ public:
     const unsigned short& operator() (const int& row, const int& inx = 0) const;
  
     // Implement virtual methods
-    virtual std::string string(const int& row, const int& col = 0) const;
-    virtual double      real(const int& row, const int& col = 0) const;
-    virtual int         integer(const int& row, const int& col = 0) const;
-    virtual void        insert(const int& rownum, const int& nrows);
-    virtual void        remove(const int& rownum, const int& nrows);
+    virtual void                 clear(void);
+    virtual GFitsTableUShortCol* clone(void) const;
+    virtual std::string          string(const int& row, const int& col = 0) const;
+    virtual double               real(const int& row, const int& col = 0) const;
+    virtual int                  integer(const int& row, const int& col = 0) const;
+    virtual void                 insert(const int& rownum, const int& nrows);
+    virtual void                 remove(const int& rownum, const int& nrows);
  
     // Other methods
     unsigned short* data(void) { return m_data; }
@@ -71,7 +73,6 @@ private:
     void                 init_members(void);
     void                 copy_members(const GFitsTableUShortCol& column);
     void                 free_members(void);
-    GFitsTableUShortCol* clone(void) const;
     std::string          ascii_format(void) const;
     std::string          binary_format(void) const;
     void                 alloc_data(void);
 /***************************************************************************
  *                 GGti.hpp  -  Good time interval class                   *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Juergen Knoedlseder                         *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GGti.hpp
  * @brief Good time interval class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GGTI_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GFits.hpp"
 #include "GFitsTable.hpp"
 #include "GTime.hpp"
@@ -44,11 +43,7 @@
  * This class holds a list of Good Time Intervals, i.e. time intervals that
  * are valid for science analysis. Times are stored using the GTime class.
  ***************************************************************************/
-class GGti {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GGti& gti);
-    friend GLog&         operator<< (GLog& log,        const GGti& gti);
+class GGti : public GBase {
  
 public:
     // Constructors and destructors
@@ -61,6 +56,7 @@ public:
  
     // Methods
     void        clear(void);
+    GGti*       clone(void) const;
     int         size(void) const { return m_num; }
     void        add(const GTime& tstart, const GTime& tstop);
     void        append(const GTime& tstart, const GTime& tstop);
@@ -88,7 +84,6 @@ protected:
     void  copy_members(const GGti& gti);
     void  free_members(void);
     void  set_attributes(void);
-    GGti* clone(void) const;
     void  insert_gti(int inx, const GTime& tstart, const GTime& tstop);
     void  merge_gtis(void);
  
 /***************************************************************************
  *         GInstDir.hpp  -  Instrument direction abstract base class       *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010 by Jurgen Knodlseder                                *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GInstDir.hpp
  * @brief GInstDir abstract base class definition.
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GINSTDIR_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -45,11 +44,7 @@
  * reconstructions for imaging devices or detector numbers etc. for
  * non-imaging devices.
  ***************************************************************************/
-class GInstDir {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GInstDir& dir);
-    friend GLog&         operator<< (GLog& log, const GInstDir& dir);
+class GInstDir : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *                  GIntegral.hpp  -  Integration class                    *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GIntegral.hpp
  * @brief Integration class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GINTEGRAL_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GIntegrand.hpp"
  
  
@@ -42,11 +41,7 @@
  * This class allows to perform integration using various methods. The
  * integrand is implemented by a derived class of GIntegrand.
  ***************************************************************************/
-class GIntegral {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GIntegral& integral);
-    friend GLog&         operator<<(GLog& log,        const GIntegral& integral);
+class GIntegral : public GBase {
  
 public:
  
@@ -29,8 +29,6 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
 #include "GMatrixBase.hpp"
  
 /* __ Forward declarations _______________________________________________ */
@@ -49,10 +47,6 @@ class GSparseMatrix;
  ***************************************************************************/
 class GMatrix : public GMatrixBase {
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GMatrix& matrix);
-    friend GLog&         operator<<(GLog& log,        const GMatrix& matrix);
-
     // Binary operator friends
     friend GMatrix operator*(const double& a,  const GMatrix& b);
     friend GMatrix operator*(const GMatrix& a, const double& b);
@@ -91,6 +85,7 @@ public:
  
     // Implemented pure virtual base class methods
     void        clear(void);
+    GMatrix*    clone(void) const;
     void        transpose(void);
     void        invert(void);
     void        add_col(const GVector& vector, const int& col);
@@ -179,7 +174,6 @@ GMatrix GMatrix::operator-(void) const
 /***************************************************************************
  *                              Inline methods                             *
  ***************************************************************************/
-inline void   GMatrix::clear(void) { set_all_elements(0.0); }
 inline double GMatrix::min(void) const { return get_min_element(); }
 inline double GMatrix::max(void) const { return get_max_element(); }
 inline double GMatrix::sum(void) const { return get_element_sum(); }
@@ -29,6 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
+#include "GBase.hpp"
 #include "GVector.hpp"
  
  
@@ -41,7 +42,7 @@
  * common interface of the matrix objects and provides some common services
  * to the derived classes.
  ***************************************************************************/
-class GMatrixBase {
+class GMatrixBase : public GBase {
  
 public:
     // Constructors and destructors
@@ -60,22 +61,23 @@ public:
     virtual bool          operator!=(const GMatrixBase& matrix) const;
  
     // Pure virtual methods
-    virtual void        clear() = 0;
-    virtual void        transpose() = 0;
-    virtual void        invert() = 0;
-    virtual void        add_col(const GVector& vector, const int& col) = 0;
-    virtual void        insert_col(const GVector& vector, const int& col) = 0;
-    virtual GVector     extract_row(const int& row) const = 0;
-    virtual GVector     extract_col(const int& col) const = 0;
-    virtual double      fill(void) const = 0;
-    virtual double      min(void) const = 0;
-    virtual double      max(void) const = 0;
-    virtual double      sum(void) const = 0;
-    virtual std::string print(void) const = 0;
+    virtual void         clear(void) = 0;
+    virtual GMatrixBase* clone(void) const = 0;
+    virtual void         transpose(void) = 0;
+    virtual void         invert(void) = 0;
+    virtual void         add_col(const GVector& vector, const int& col) = 0;
+    virtual void         insert_col(const GVector& vector, const int& col) = 0;
+    virtual GVector      extract_row(const int& row) const = 0;
+    virtual GVector      extract_col(const int& col) const = 0;
+    virtual double       fill(void) const = 0;
+    virtual double       min(void) const = 0;
+    virtual double       max(void) const = 0;
+    virtual double       sum(void) const = 0;
+    virtual std::string  print(void) const = 0;
  
     // Implemented base class methods
-    virtual int         cols(void) const { return m_cols; }
-    virtual int         rows(void) const { return m_rows; }
+    virtual int          cols(void) const { return m_cols; }
+    virtual int          rows(void) const { return m_rows; }
  
 protected:
     // Protected methods
 /***************************************************************************
  *              GModel.hpp - Abstract virtual model base class             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GModel.hpp
  * @brief Abstract model base class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODEL_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <vector>
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GModelPar.hpp"
 #include "GXmlElement.hpp"
 #include "GEnergy.hpp"
@@ -62,11 +61,7 @@ class GObservation;
  * model parameters. This will be done by the classes that actually
  * implement the model parameters.
  ***************************************************************************/
-class GModel {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GModel& model);
-    friend GLog&         operator<< (GLog& log, const GModel& model);
+class GModel : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *                  GModelPar.hpp  -  Model parameter class                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GModelPar.hpp
  * @brief Model parameter class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELPAR_HPP
@@ -29,9 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
-#include "GException.hpp"
+#include "GBase.hpp"
 #include "GXmlElement.hpp"
  
  
@@ -54,11 +52,7 @@
  * Each parameter has a name, and holds optionally information about its
  * gradient (if "hasgrad" is true).
  ***************************************************************************/
-class GModelPar {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelPar& par);
-    friend GLog&         operator<<(GLog& log,        const GModelPar& par);
+class GModelPar : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *     GModelRadialRegistry.hpp  -  Radial spatial model registry class    *
+ *          GModelRadialRegistry.hpp - Radial model registry class         *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GModelRadialRegistry.hpp
- * @brief Radial spatial model class interface definition
- * @author J. Knodlseder
+ * @brief Radial model registry class interface definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELRADIALREGISTRY_HPP
@@ -29,31 +29,28 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GRegistry.hpp"
 #include "GModelRadial.hpp"
  
  
 /***********************************************************************//**
  * @class GModelRadialRegistry
  *
- * @brief Radial spatial model registry class
+ * @brief Radial model registry class
  *
- * The registry class allows the registration of radial spatial models that
- * are not necessarily compiled into the GammaLib. It uses the static members
+ * The registry class allows the registration of radial models that are not
+ * necessarily compiled into the GammaLib. It uses the static members
  * m_number, m_names, and m_models which are allocated globally to keep track
- * of radial spatial models that are available throughout all linked
- * libraries. To register a radial spatial model it is sufficient to add
- *  const GModelRadialXXX      g_radial_XXX_seed;
- *  const GModelRadialRegistry g_radial_XXX_registry(&g_radial_XXX_seed);
- * at the top of the .cpp file of the radial spatial model. Here, XXX is a
- * unique name that describes the model.
+ * of radial models that are available throughout all linked libraries. To
+ * register a radial model it is sufficient to add
+ *
+ *     const GModelRadialXXX      g_radial_XXX_seed;
+ *     const GModelRadialRegistry g_radial_XXX_registry(&g_radial_XXX_seed);
+ *
+ * at the top of the .cpp file of the radial model. Here, XXX is a unique
+ * name that describes the model.
  ***************************************************************************/
-class GModelRadialRegistry {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelRadialRegistry& registry);
-    friend GLog&         operator<<(GLog& log,        const GModelRadialRegistry& registry);
+class GModelRadialRegistry : public GRegistry {
  
 public:
     // Constructors and destructors
@@ -67,7 +64,7 @@ public:
  
     // Methods
     int           size(void) const { return m_number; }
-    GModelRadial* alloc(const std::string& type) const;
+    GModelRadial* alloc(const std::string& name) const;
     std::string   name(const int& index) const;
     std::string   print(void) const;
  
 /***************************************************************************
- *               GModelRegistry.hpp  -  Model registry class               *
+ *                GModelRegistry.hpp - Model registry class                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GModelRegistry.hpp
- * @brief GModelRegistry class interface definition
- * @author J. Knodlseder
+ * @brief Model registry class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELREGISTRY_HPP
@@ -29,31 +29,28 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GRegistry.hpp"
 #include "GModel.hpp"
  
  
 /***********************************************************************//**
  * @class GModelRegistry
  *
- * @brief Interface definition for the model registry class.
+ * @brief Interface definition for the model registry class
  *
  * The registry class allows the registration of models that are not
  * necessarily compiled into the GammaLib. It uses the static members
  * m_number, m_names, and m_models which are allocated globally to keep track
  * of models that are available throughout all linked libraries. To register
  * a model it is sufficient to add
- *  const GModelXXX      g_XXX_seed;
- *  const GModelRegistry g_XXX_registry(&g_XXX_seed);
+ *
+ *     const GModelXXX      g_XXX_seed;
+ *     const GModelRegistry g_XXX_registry(&g_XXX_seed);
+ *
  * at the top of the .cpp file of the model. Here, XXX is a unique name that
  * describes the model.
  ***************************************************************************/
-class GModelRegistry {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelRegistry& registry);
-    friend GLog&         operator<<(GLog& log, const GModelRegistry& registry);
+class GModelRegistry : public GRegistry {
  
 public:
     // Constructors and destructors
@@ -67,7 +64,7 @@ public:
  
     // Methods
     int         size(void) const { return m_number; }
-    GModel*     alloc(const std::string& type) const;
+    GModel*     alloc(const std::string& name) const;
     std::string name(const int& index) const;
     std::string print(void) const;
  
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <string>
 #include <vector>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GModelPar.hpp"
 #include "GSkyDir.hpp"
 #include "GXmlElement.hpp"
@@ -47,11 +46,7 @@
  * source model. A typical example of a spatial component is a point source
  * (implemented by the derived class GModelSpatialPtsrc).
  ***************************************************************************/
-class GModelSpatial {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelSpatial& model);
-    friend GLog&         operator<<(GLog& log,        const GModelSpatial& model);
+class GModelSpatial : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *       GModelSpatialRegistry.hpp  -  Spatial model registry class        *
+ *        GModelSpatialRegistry.hpp - Spatial model registry class         *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GModelSpatialRegistry.hpp
- * @brief GModelSpatialRegistry class interface definition
- * @author J. Knodlseder
+ * @brief Spatial model registry class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELSPATIALREGISTRY_HPP
@@ -29,31 +29,28 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GRegistry.hpp"
 #include "GModelSpatial.hpp"
  
  
 /***********************************************************************//**
  * @class GModelSpatialRegistry
  *
- * @brief Interface definition for the spatial model registry class.
+ * @brief Interface definition for the spatial model registry class
  *
  * The registry class allows the registration of spatial models that are not
  * necessarily compiled into the GammaLib. It uses the static members
  * m_number, m_names, and m_models which are allocated globally to keep track
  * of spatial models that are available throughout all linked libraries. To
  * register a spatial model it is sufficient to add
- *  const GModelSpatialXXX      g_spatial_XXX_seed;
- *  const GModelSpatialRegistry g_spatial_XXX_registry(&g_spatial_XXX_seed);
+ *
+ *     const GModelSpatialXXX      g_spatial_XXX_seed;
+ *     const GModelSpatialRegistry g_spatial_XXX_registry(&g_spatial_XXX_seed);
+ *
  * at the top of the .cpp file of the spatial model. Here, XXX is a unique
  * name that describes the model.
  ***************************************************************************/
-class GModelSpatialRegistry {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelSpatialRegistry& registry);
-    friend GLog&         operator<<(GLog& log, const GModelSpatialRegistry& registry);
+class GModelSpatialRegistry : public GRegistry {
  
 public:
     // Constructors and destructors
@@ -67,7 +64,7 @@ public:
  
     // Methods
     int            size(void) const { return m_number; }
-    GModelSpatial* alloc(const std::string& type) const;
+    GModelSpatial* alloc(const std::string& name) const;
     std::string    name(const int& index) const;
     std::string    print(void) const;
  
 /***************************************************************************
  *        GModelSpectral.hpp  -  Abstract spectral model base class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GModelSpectral.hpp
  * @brief Abstract spectral model base class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELSPECTRAL_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <string>
 #include <vector>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GModelPar.hpp"
 #include "GEnergy.hpp"
 #include "GRan.hpp"
@@ -46,11 +45,7 @@
  * This class implements the spectral component of the factorised source
  * model.
  ***************************************************************************/
-class GModelSpectral {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelSpectral& model);
-    friend GLog&         operator<<(GLog& log,        const GModelSpectral& model);
+class GModelSpectral : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *      GModelSpectralRegistry.hpp  -  Spectral model registry class       *
+ *       GModelSpectralRegistry.hpp - Spectral model registry class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GModelSpectralRegistry.hpp
- * @brief GModelSpectralRegistry class interface definition
- * @author J. Knodlseder
+ * @brief Spectral model registry class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELSPECTRALREGISTRY_HPP
@@ -29,31 +29,28 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GRegistry.hpp"
 #include "GModelSpectral.hpp"
  
  
 /***********************************************************************//**
  * @class GModelSpectralRegistry
  *
- * @brief Interface definition for the spectral model registry class.
+ * @brief Interface definition for the spectral model registry class
  *
  * The registry class allows the registration of spectral models that are not
  * necessarily compiled into the GammaLib. It uses the static members
  * m_number, m_names, and m_models which are allocated globally to keep track
  * of spectral models that are available throughout all linked libraries. To
  * register a spectral model it is sufficient to add
- *  const GModelSpectralXXX      g_spectral_XXX_seed;
- *  const GModelSpectralRegistry g_spectral_XXX_registry(&g_spectral_XXX_seed);
+ *
+ *     const GModelSpectralXXX      g_spectral_XXX_seed;
+ *     const GModelSpectralRegistry g_spectral_XXX_registry(&g_spectral_XXX_seed);
+ *
  * at the top of the .cpp file of the spectral model. Here, XXX is a unique
  * name that describes the model.
  ***************************************************************************/
-class GModelSpectralRegistry {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelSpectralRegistry& registry);
-    friend GLog&         operator<<(GLog& log, const GModelSpectralRegistry& registry);
+class GModelSpectralRegistry : public GRegistry {
  
 public:
     // Constructors and destructors
@@ -67,7 +64,7 @@ public:
  
     // Methods
     int             size(void) const { return m_number; }
-    GModelSpectral* alloc(const std::string& type) const;
+    GModelSpectral* alloc(const std::string& name) const;
     std::string     name(const int& index) const;
     std::string     print(void) const;
  
 /***************************************************************************
  *        GModelTemporal.hpp  -  Abstract temporal model base class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GModelTemporal.hpp
  * @brief Abstract temporal model base class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELTEMPORAL_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <vector>
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GModelPar.hpp"
 #include "GTime.hpp"
 #include "GRan.hpp"
@@ -48,11 +47,7 @@
  * that is given by the spectral component. Normally, this model will have
  * a mean value of 1.
  ***************************************************************************/
-class GModelTemporal {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelTemporal& model);
-    friend GLog&         operator<<(GLog& log,        const GModelTemporal& model);
+class GModelTemporal : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *      GModelTemporalRegistry.hpp  -  Temporal model registry class       *
+ *       GModelTemporalRegistry.hpp - Temporal model registry class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GModelTemporalRegistry.hpp
- * @brief GModelTemporalRegistry class interface definition
- * @author J. Knodlseder
+ * @brief Temporal model registry class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELTEMPORALREGISTRY_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GRegistry.hpp"
 #include "GModelTemporal.hpp"
  
  
@@ -44,16 +43,14 @@
  * m_number, m_names, and m_models which are allocated globally to keep track
  * of temporal models that are available throughout all linked libraries. To
  * register a temporal model it is sufficient to add
- *  const GModelTemporalXXX      g_temporal_XXX_seed;
- *  const GModelTemporalRegistry g_temporal_XXX_registry(&g_spectral_XXX_seed);
+ *
+ *     const GModelTemporalXXX      g_temporal_XXX_seed;
+ *     const GModelTemporalRegistry g_temporal_XXX_registry(&g_spectral_XXX_seed);
+ *
  * at the top of the .cpp file of the temporal model. Here, XXX is a unique
  * name that describes the model.
  ***************************************************************************/
-class GModelTemporalRegistry {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModelTemporalRegistry& registry);
-    friend GLog&         operator<<(GLog& log, const GModelTemporalRegistry& registry);
+class GModelTemporalRegistry : public GRegistry {
  
 public:
     // Constructors and destructors
@@ -67,7 +64,7 @@ public:
  
     // Methods
     int             size(void) const { return m_number; }
-    GModelTemporal* alloc(const std::string& type) const;
+    GModelTemporal* alloc(const std::string& name) const;
     std::string     name(const int& index) const;
     std::string     print(void) const;
  
 /***************************************************************************
  *                    GModels.hpp  -  Model container class                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,15 +21,14 @@
 /**
  * @file GModels.hpp
  * @brief Model container class definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GMODELS_HPP
 #define GMODELS_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
-#include "GLog.hpp"
+#include <string>
 #include "GOptimizerPars.hpp"
 #include "GModel.hpp"
 #include "GXml.hpp"
@@ -47,13 +46,13 @@ class GObservation;
  * This container class collects models of gamma-ray data that are used
  * for maximum likelihood fitting. It derives from the optimizer parameter
  * class GOptimizerPars.
+ *
+ * @todo Add extend method to append a container to the container
+ * @todo Add insert method to insert a model into the container
+ * @todo Add pop method to delete a model from the container (default: last)
  ***************************************************************************/
 class GModels : public GOptimizerPars {
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GModels& models);
-    friend GLog&         operator<<(GLog& log,        const GModels& models);
-
 public:
     // Constructors and destructors
     GModels(void);
@@ -63,16 +62,18 @@ public:
  
     // Operators
     GModels&      operator=(const GModels& models);
-    GModel&       operator[](const int& index);
-    const GModel& operator[](const int& index) const;
-    GModel&       operator[](const std::string& name);
-    const GModel& operator[](const std::string& name) const;
+    GModel*       operator[](const int& index);
+    const GModel* operator[](const int& index) const;
+    GModel*       operator[](const std::string& name);
+    const GModel* operator[](const std::string& name) const;
  
     // Methods
     void          clear(void);
     GModels*      clone(void) const;
     int           size(void) const { return m_models.size(); }
     void          append(const GModel& model);
+    void          set(const int& index, const GModel& model);
+    void          set(const std::string& name, const GModel& model);
     void          load(const std::string& filename);
     void          save(const std::string& filename) const;
     void          read(const GXml& xml);
@@ -87,6 +88,7 @@ protected:
     void          copy_members(const GModels& models);
     void          free_members(void);
     void          set_pointers(void);
+    int           get_index(const std::string& name) const;
  
     // Proteced members
     std::vector<GModel*> m_models;  //!< List of models
@@ -21,7 +21,7 @@
 /**
  * @file GNodeArray.hpp
  * @brief Node array class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GNODEARRAY_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <vector>
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GVector.hpp"
  
  
@@ -53,11 +52,7 @@
  * wgt_left() and wgt_right().
  * If the nodes are equally spaced, interpolation is more rapid.
  ***************************************************************************/
-class GNodeArray {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GNodeArray& array);
-    friend GLog&         operator<<(GLog& log,        const GNodeArray& array);
+class GNodeArray : public GBase {
  
 public:
     // Constructors and destructors
+/***************************************************************************
+ *                    GNumerics.hpp  -  Numerical functions                *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2012 by Juergen Knoedlseder                              *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  This program is free software: you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  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 GNumerics.hpp
+ * @brief Numerical function definitions
+ * @author Juergen Knoedlseder
+ */
+
+#ifndef GNUMERICS_HPP
+#define GNUMERICS_HPP
+
+/* __ Includes ___________________________________________________________ */
+
+/* __ Namespaces _________________________________________________________ */
+
+/* __ Constants __________________________________________________________ */
+
+/* __ Prototypes _________________________________________________________ */
+double gammln(const double& x);
+
+#endif /* GNUMERICS_HPP */
@@ -21,7 +21,7 @@
 /**
  * @file GObservation.hpp
  * @brief Abstract observation base class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GOBSERVATION_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GEvents.hpp"
 #include "GResponse.hpp"
 #include "GPointing.hpp"
@@ -59,14 +58,7 @@
  * that implement instrument specific observations in order to optimize the
  * execution speed for data analysis.
  ***************************************************************************/
-class GObservation {
-
-    // Friend classes
-    //friend class GObservations;
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GObservation& obs);
-    friend GLog&         operator<< (GLog& log,        const GObservation& obs);
+class GObservation : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *         GObservationRegistry.hpp  -  Observation registry class         *
+ *          GObservationRegistry.hpp - Observation registry class          *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Juergen Knoedlseder                              *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GObservationRegistry.hpp
- * @brief GObservationRegistry class interface definition
- * @author J. Knoedlseder
+ * @brief Observation registry class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GOBSERVATIONREGISTRY_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GRegistry.hpp"
 #include "GObservation.hpp"
  
  
@@ -44,17 +43,15 @@
  * m_number, m_names, and m_obs which are allocated globally to keep track
  * of observations that are available throughout all linked libraries. To
  * register an observation it is sufficient to add
- *  const GXXXObservation      g_obs_XXX_seed;
- *  const GObservationRegistry g_obs_XXX_registry(&g_obs_XXX_seed);
+ *
+ *     const GXXXObservation      g_obs_XXX_seed;
+ *     const GObservationRegistry g_obs_XXX_registry(&g_obs_XXX_seed);
+ *
  * at the top of the .cpp file of the observation. Here, XXX is a unique
  * name that describes the instrument for which the observation class is
  * implemented.
  ***************************************************************************/
-class GObservationRegistry {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GObservationRegistry& registry);
-    friend GLog&         operator<<(GLog& log,        const GObservationRegistry& registry);
+class GObservationRegistry : public GRegistry {
  
 public:
     // Constructors and destructors
@@ -68,8 +65,8 @@ public:
  
     // Methods
     int           size(void) const { return m_number; }
-    GObservation* alloc(const std::string& instrument) const;
-    std::string   instrument(const int& index) const;
+    GObservation* alloc(const std::string& name) const;
+    std::string   name(const int& index) const;
     std::string   print(void) const;
  
 protected:
 /***************************************************************************
  *             GObservations.hpp  -  Observation container class           *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GObservations.hpp
  * @brief Observations container class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GOBSERVATIONS_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <string>
 #include <vector>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GObservation.hpp"
 #include "GEvent.hpp"
 #include "GOptimizer.hpp"
@@ -61,11 +60,7 @@
  * @todo Use std::vector for building a list of pointers to observations
  * instead of a proper memory handling implementation.
  ***************************************************************************/
-class GObservations {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GObservations& obs);
-    friend GLog&         operator<<(GLog& log,        const GObservations& obs);
+class GObservations : public GBase {
  
 public:
     // Constructors and destructors
@@ -80,19 +75,20 @@ public:
     const GObservation& operator[](const int& index) const;
  
     // Methods
-    void        clear(void);
-    int         size(void) const { return m_obs.size(); }
-    void        append(GObservation& obs);
-    void        load(const std::string& filename);
-    void        save(const std::string& filename) const;
-    void        read(const GXml& xml);
-    void        write(GXml& xml) const;
-    void        models(const GModels& models) { m_models=models;}
-    void        models(const std::string& filename);
-    GModels&    models(void) { return m_models; }
-    void        optimize(GOptimizer& opt);
-    double      npred(void) const { return m_npred; }
-    std::string print(void) const;
+    void           clear(void);
+    GObservations* clone(void) const;
+    int            size(void) const { return m_obs.size(); }
+    void           append(GObservation& obs);
+    void           load(const std::string& filename);
+    void           save(const std::string& filename) const;
+    void           read(const GXml& xml);
+    void           write(GXml& xml) const;
+    void           models(const GModels& models) { m_models=models;}
+    void           models(const std::string& filename);
+    GModels&       models(void) { return m_models; }
+    void           optimize(GOptimizer& opt);
+    double         npred(void) const { return m_npred; }
+    std::string    print(void) const;
  
     // Event iterator
     class iterator {
@@ -165,9 +161,9 @@ public:
  
 protected:
     // Protected methods
-    void           init_members(void);
-    void           copy_members(const GObservations& obs);
-    void           free_members(void);
+    void init_members(void);
+    void copy_members(const GObservations& obs);
+    void free_members(void);
  
     // Protected members
     std::vector<GObservation*> m_obs;      //!< List of observations
 /***************************************************************************
  *           GOptimizer.hpp  -  Abstract base class for optimizer          *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GOptimizer.hpp
  * @brief Optimizer abstract base class interface definition.
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GOPTIMIZER_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GOptimizerPars.hpp"
 #include "GOptimizerFunction.hpp"
 #include "GModels.hpp"
@@ -43,11 +42,7 @@
  *
  * This class defines the abstract interface for the optimizer class.
  ***************************************************************************/
-class GOptimizer {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GOptimizer& opt);
-    friend GLog&         operator<<(GLog& log,        const GOptimizer& opt);
+class GOptimizer : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *        GOptimizerPars.hpp  -  Optimizer parameter container class       *
+ *     GOptimizerPars.hpp  -  Optimizer parameters abstract base class     *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2009-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2009-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GOptimizerPars.hpp
- * @brief Optimizer parameter container class interface definition
- * @author J. Knodlseder
+ * @brief Optimizer parameters abstract base class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GOPTIMIZERPARS_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GModelPar.hpp"
  
  
@@ -53,11 +52,7 @@
  *       very clean. We should think about how we can make this a clean
  *       thing ...
  ***************************************************************************/
-class GOptimizerPars {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GOptimizerPars& pars);
-    friend GLog&         operator<<(GLog& log,        const GOptimizerPars& pars);
+class GOptimizerPars : public GBase {
  
 public:
     // Constructors and destructors
@@ -69,11 +64,13 @@ public:
     virtual GOptimizerPars& operator=(const GOptimizerPars& pars);
  
     // Methods
-    int              npars(void) const { return m_pars.size(); }
-    int              nfree(void) const;
-    GModelPar&       par(const int& index);
-    const GModelPar& par(const int& index) const;
-    std::string      print(void) const;
+    virtual void             clear(void);
+    virtual GOptimizerPars*  clone(void) const;
+    virtual int              npars(void) const { return m_pars.size(); }
+    virtual int              nfree(void) const;
+    virtual GModelPar&       par(const int& index);
+    virtual const GModelPar& par(const int& index) const;
+    virtual std::string      print(void) const;
  
 protected:
     // Protected methods
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -38,16 +37,12 @@
  *
  * @brief Application parameter class interface defintion.
  ***************************************************************************/
-class GPar {
+class GPar : public GBase {
  
     // Friend classes
     friend class GPars;
     friend class GApplication;
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GPar& par);
-    friend GLog&         operator<<(GLog& log,        const GPar& par);
-
 public:
     // Constructors and destructors
     GPar(void);
@@ -62,6 +57,7 @@ public:
     GPar& operator= (const GPar& par);
  
     // Methods
+    void        clear(void);
     GPar*       clone(void) const;
     void        type(const std::string& type);
     void        mode(const std::string& mode);
 /***************************************************************************
  *                   GPars.hpp - Application parameters                    *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GPars.hpp
  * @brief Application parameter container class definition
- * @author Jurgen Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GPARS_HPP
@@ -30,9 +30,8 @@
 /* __ Includes ___________________________________________________________ */
 #include <vector>
 #include <string>
-#include <iostream>
+#include "GBase.hpp"
 #include "GPar.hpp"
-#include "GLog.hpp"
  
  
 /***********************************************************************//**
@@ -42,15 +41,11 @@
  *
  * This class holds a collection of application parameters.
  ***************************************************************************/
-class GPars {
+class GPars : public GBase {
  
     // Friend classes
     friend class GApplication;
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GPars& pars);
-    friend GLog&         operator<<(GLog&        log, const GPars& pars);
-
 public:
     // Constructors and destructors
     GPars(void);
 /***************************************************************************
  *                        GPhoton.hpp - Photon class                       *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GPhoton.hpp
  * @brief Photon class definition.
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GPHOTON_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <vector>
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GSkyDir.hpp"
 #include "GEnergy.hpp"
 #include "GTime.hpp"
@@ -46,11 +45,7 @@
  * photon arrival direction, its energy and its arrival time. This class is
  * mainly used for Monte Carlo simulations.
  ***************************************************************************/
-class GPhoton {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GPhoton& ph);
-    friend GLog&         operator<< (GLog& log, const GPhoton& ph);
+class GPhoton : public GBase {
  
     // Operator friends
     friend bool operator== (const GPhoton &a, const GPhoton &b);
@@ -67,6 +62,7 @@ public:
  
     // Methods
     void           clear(void);
+    GPhoton*       clone(void) const;
     const GSkyDir& dir(void) const { return m_dir; }
     const GEnergy& energy(void) const { return m_energy; }
     const GTime&   time(void) const { return m_time; }
 /***************************************************************************
- *              GPointing.hpp  -  Pointing abstract base class             *
+ *                GPointing.hpp  -  Pointing interface class               *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GPointing.hpp
- * @brief Pointing abstract base class definition
- * @author J. Knodlseder
+ * @brief Pointing interface class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GPOINTING_HPP
@@ -29,25 +29,18 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GSkyDir.hpp"
-#include "GTime.hpp"
  
  
 /***********************************************************************//**
  * @class GPointing
  *
- * @brief Abstract interface for the pointing classes
+ * @brief Interface for the pointing classes
  *
- * The pointing class holds information about the time dependent telescope
- * pointing.
+ * The pointing class holds information about the telescope pointing.
  ***************************************************************************/
-class GPointing {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GPointing& pnt);
-    friend GLog&         operator<<(GLog& log,        const GPointing& pnt);
+class GPointing : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *                 GRan.hpp - Randon number generator class                *
+ *                 GRan.hpp - Random number generator class                *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GRan.hpp
- * @brief Randon number generator class definition.
- * @author J. Knodlseder
+ * @brief Random number generator class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GRAN_HPP
@@ -29,23 +29,17 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
-#include "GSkyDir.hpp"
-#include "GEnergy.hpp"
-#include "GTime.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
  * @class GRan
  *
  * @brief Random number generator class
+ *
+ * This class implements a random number generator.
  ***************************************************************************/
-class GRan {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GRan& ran);
-    friend GLog&         operator<< (GLog& log, const GRan& ran);
+class GRan : public GBase {
  
 public:
     // Constructors and destructors
@@ -65,6 +59,7 @@ public:
     unsigned long long int int64(void);
     double                 uniform(void);
     double                 exp(const double& lambda);
+    double                 poisson(const double& lambda);
     double                 chisq2(void);
     std::string            print(void) const;
  
@@ -79,6 +74,12 @@ protected:
     unsigned long long int m_u;     //!< u
     unsigned long long int m_v;     //!< v
     unsigned long long int m_w;     //!< w
+
+    // Poisson cache
+    double                 m_oldm;
+    double                 m_sq;
+    double                 m_alxm;
+    double                 m_g;
 };
  
 #endif /* GRAN_HPP */
+/***************************************************************************
+ *              GRegistry.hpp - Interface class for registries             *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2012 by Juergen Knoedlseder                              *
+ * ----------------------------------------------------------------------- *
+ *                                                                         *
+ *  This program is free software: you can redistribute it and/or modify   *
+ *  it under the terms of the GNU General Public License as published by   *
+ *  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 GRegistry.hpp
+ * @brief Interface class definition for registries
+ * @author Juergen Knoedlseder
+ */
+
+#ifndef GREGISTRY_HPP
+#define GREGISTRY_HPP
+
+/* __ Includes ___________________________________________________________ */
+#include <string>
+#include <iostream>
+#include "GLog.hpp"
+
+
+/***********************************************************************//**
+ * @class GRegistry
+ *
+ * @brief Interface class for registries
+ *
+ * This class defines the interface for registries. A registry is a
+ * container class that contains instance of derived classes. For example,
+ * if three different derived classes exist for a given base class, the
+ * registry will contain one instance for each derived class. Using the
+ * clone mechanism, the registry may thus provide a new instance of a given
+ * derived class, depending on the type of the derived class.
+ *
+ * The interface class requires the implementation of the following methods
+ * for all registry classes:
+ * 
+ * size(void) Number of elements in registry class
+ *
+ * name(const int& index) Name of registered class by index
+ *
+ * print() Print content of registry
+ ***************************************************************************/
+class GRegistry {
+
+public:
+    /// @brief Destructor
+    ///
+    /// Destroys class.
+    virtual ~GRegistry(void) {}
+ 
+    /// @brief Return number of classes in registry
+    ///
+    /// Returns the number of classes that have been registered in the
+    /// registry.
+    virtual int size(void) const = 0;
+
+    /// @brief Return name of registered class by index
+    ///
+    /// @param[in] index Class index [0,...,size()-1]
+    ///
+    /// Returns the name of a registered class, specified by its index in
+    /// the registry.
+    virtual std::string name(const int& index) const = 0;
+
+    /// @brief Print content of object
+    ///
+    /// @return String containing the content of the object.
+    ///
+    /// Formats the content in a standard way and puts this content in a
+    /// C++ string that is returned.
+    virtual std::string print(void) const = 0;
+};
+
+/* __ Prototypes _________________________________________________________ */
+std::ostream& operator<<(std::ostream& os, const GRegistry& registry);
+GLog&         operator<<(GLog& log,        const GRegistry& registry);
+
+#endif /* GREGISTRY_HPP */
@@ -21,7 +21,7 @@
 /**
  * @file GResponse.hpp
  * @brief Abstract response base class definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GRESPONSE_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GEvent.hpp"
 #include "GSkyDir.hpp"
 #include "GEnergy.hpp"
@@ -60,11 +59,7 @@ class GObservation;
  * The npred method returns the integral of the instrument response function
  * over the dataspace. This method is only required for unbinned analysis.
  ***************************************************************************/
-class GResponse {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GResponse& rsp);
-    friend GLog&         operator<< (GLog& log, const GResponse& rsp);
+class GResponse : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
- *           GRoi.hpp  -  Region of interest abstract base class           *
+ *             GRoi.hpp  -  Region of interest interface class             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GRoi.hpp
- * @brief Region of interest abstract base class definition
- * @author J. Knodlseder
+ * @brief Region of interest interface class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GROI_HPP
@@ -29,28 +29,23 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
  * @class GRoi
  *
- * @brief Abstract interface for the region of interest classes
+ * @brief Interface for the region of interest classes
  *
  * The region of interest class holds instrument specific information about
  * the spatial region in detector or telescopes coordinates that is used
  * for an analysis. In particular, the definition of a region of interest
  * is required for an unbinned analysis.
  ***************************************************************************/
-class GRoi {
+class GRoi : public GBase {
  
-  // Friend classes
-  friend class GObservation;
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GRoi& roi);
-    friend GLog&         operator<<(GLog& log,        const GRoi& roi);
+    // Friend classes
+    friend class GObservation;
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *          GSkyDir.hpp  -  Class that implements a sky direction          *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2008-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2008-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GSkyDir.hpp
  * @brief Sky direction class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GSKYDIR_HPP
@@ -29,10 +29,8 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GVector.hpp"
-#include "GMatrix.hpp"
  
  
 /***********************************************************************//**
@@ -49,11 +47,7 @@
  * if requested. Coordinates can be given and returned in radians or in
  * degrees. Note that the epoch for celestial coordinates is fixed to J2000.
  ***************************************************************************/
-class GSkyDir {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GSkyDir& dir);
-    friend GLog&         operator<<(GLog& log,        const GSkyDir& dir);
+class GSkyDir : public GBase {
  
     // Operator friends
     friend bool operator==(const GSkyDir &a, const GSkyDir &b);
@@ -70,6 +64,7 @@ public:
  
     // Methods
     void        clear(void);
+    GSkyDir*    clone(void) const;
     void        radec(const double& ra, const double& dec);
     void        radec_deg(const double& ra, const double& dec);
     void        lb(const double& l, const double& b);
 /***************************************************************************
  *       GSkyPixel.cpp  -  Class that implements a 2D sky pixel index      *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010 by Jurgen Knodlseder                                *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -20,8 +20,8 @@
  ***************************************************************************/
 /**
  * @file GSkyPixel.hpp
- * @brief GSkyPixel class definition.
- * @author J. Knodlseder
+ * @brief Sky pixel class definition
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GSKYPIXEL_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -38,11 +37,7 @@
  *
  * @brief GSkyPixel class interface defintion
  ***************************************************************************/
-class GSkyPixel {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GSkyPixel& pixel);
-    friend GLog&         operator<< (GLog& log, const GSkyPixel& pixel);
+class GSkyPixel : public GBase {
  
 public:
     // Constructors and destructors
@@ -55,6 +50,8 @@ public:
     GSkyPixel& operator= (const GSkyPixel& pixel);
  
     // Methods
+    void        clear(void);
+    GSkyPixel*  clone(void) const;
     void        x(const double& x);
     void        y(const double& y);
     double      x(void) const;
@@ -21,7 +21,7 @@
 /**
  * @file GSkymap.hpp
  * @brief Sky map class definition.
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GSKYMAP_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GWcs.hpp"
 #include "GSkyDir.hpp"
 #include "GSkyPixel.hpp"
@@ -61,11 +60,7 @@
  * index or sky pixel and the true physical sky direction are provided by the
  * pix2dir() and dir2pix() methods.
  ***************************************************************************/
-class GSkymap {
-
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GSkymap& map);
-    friend GLog&         operator<<(GLog& log, const GSkymap& map);
+class GSkymap : public GBase {
  
 public:
     // Constructors and destructors
@@ -29,8 +29,6 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
 #include "GMatrixBase.hpp"
  
 /* __ Definitions ________________________________________________________ */
@@ -63,10 +61,6 @@ class GSparseMatrix : public GMatrixBase {
     friend class GSparseSymbolic;
     friend class GSparseNumeric;
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GSparseMatrix& matrix);
-    friend GLog&         operator<<(GLog& log,        const GSparseMatrix& matrix);
-
     // Binary operator friends
     friend GSparseMatrix operator*(const double& a,  const GSparseMatrix& b);
     friend GSparseMatrix operator*(const GSparseMatrix& a, const double& b);
@@ -119,34 +113,35 @@ public:
     GSparseMatrix& operator/=(const double& scalar);
  
     // Implemented pure virtual base class methods
-    void        clear(void);
-    void        transpose(void);
-    void        invert(void);
-    void        add_col(const GVector& vector, const int& col);
-    void        insert_col(const GVector& vector, const int& col);
-    GVector     extract_row(const int& row) const;
-    GVector     extract_col(const int& col) const;
-    double      fill(void) const;
-    double      min(void) const;
-    double      max(void) const;
-    double      sum(void) const;
-    std::string print(void) const;
+    void           clear(void);
+    GSparseMatrix* clone(void) const;
+    void           transpose(void);
+    void           invert(void);
+    void           add_col(const GVector& vector, const int& col);
+    void           insert_col(const GVector& vector, const int& col);
+    GVector        extract_row(const int& row) const;
+    GVector        extract_col(const int& col) const;
+    double         fill(void) const;
+    double         min(void) const;
+    double         max(void) const;
+    double         sum(void) const;
+    std::string    print(void) const;
  
     // Other methods
-    void        add_col(const double* values, const int* rows,
-                        int number, const int& col);
-    void        insert_col(const double* values, const int* rows,
-                           int number, const int& col);
-    void        cholesky_decompose(bool compress = true);
-    GVector     cholesky_solver(const GVector& vector, bool compress = true);
-    void        cholesky_invert(bool compress = true);
-    void        set_mem_block(const int& block);
-    void        stack_init(const int& size = 0, const int& entries = 0);
-    int         stack_push_column(const GVector& vector, const int& col);
-    int         stack_push_column(const double* values, const int* rows,
-                                  const int& number, const int& col);
-    void        stack_flush(void);
-    void        stack_destroy(void);
+    void    add_col(const double* values, const int* rows,
+                    int number, const int& col);
+    void    insert_col(const double* values, const int* rows,
+                       int number, const int& col);
+    void    cholesky_decompose(bool compress = true);
+    GVector cholesky_solver(const GVector& vector, bool compress = true);
+    void    cholesky_invert(bool compress = true);
+    void    set_mem_block(const int& block);
+    void    stack_init(const int& size = 0, const int& entries = 0);
+    int     stack_push_column(const GVector& vector, const int& col);
+    int     stack_push_column(const double* values, const int* rows,
+                              const int& number, const int& col);
+    void    stack_flush(void);
+    void    stack_destroy(void);
  
 private:
     // Private methods
@@ -29,8 +29,6 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
 #include "GMatrixBase.hpp"
  
 /* __ Forward declarations _______________________________________________ */
@@ -49,10 +47,6 @@ class GSparseMatrix;
  ***************************************************************************/
 class GSymMatrix : public GMatrixBase {
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GSymMatrix& matrix);
-    friend GLog&         operator<<(GLog& log,        const GSymMatrix& matrix);
-
     // Binary operator friends
     friend GSymMatrix operator*(const double& a,  const GSymMatrix& b);
     friend GSymMatrix operator*(const GSymMatrix& a, const double& b);
@@ -91,6 +85,7 @@ public:
  
     // Implemented pure virtual base class methods
     virtual void        clear(void);
+    virtual GSymMatrix* clone(void) const;
     virtual void        transpose(void) { return; }
     virtual void        invert(void);
     virtual void        add_col(const GVector& vector, const int& col);
@@ -175,7 +170,6 @@ GSymMatrix GSymMatrix::operator-(void) const
 /***************************************************************************
  *                              Inline methods                             *
  ***************************************************************************/
-inline void   GSymMatrix::clear(void) { set_all_elements(0.0); }
 inline double GSymMatrix::min(void) const { return get_min_element(); }
 inline double GSymMatrix::max(void) const { return get_max_element(); }
  
@@ -28,8 +28,8 @@
 #define GTESTCASE_H
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
 #include <string>
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -44,7 +44,7 @@
  * Furthermore, the test case knows whether the test succeeded or failed,
  * and whether the test was an error or a failure test.
  ***************************************************************************/
-class GTestCase{
+class GTestCase : public GBase {
  
 public:
     // public enumerators
@@ -63,6 +63,8 @@ public:
     GTestCase&  operator= (const GTestCase& test);
  
     // Methods
+    void        clear(void);
+    GTestCase*  clone(void) const;
     std::string name(void) const;
     void        name(const std::string& name);
     std::string message(void) const;
@@ -34,7 +34,6 @@ class GTestSuite;
 typedef void (GTestSuite::*pfunction)(void);
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
 #include <vector>
 #include <string>
 #include "GLog.hpp"
@@ -73,7 +72,7 @@ public:
     virtual bool              run(void);
     std::string               name(void) const;
     void                      name(const std::string& name);
-    void                      cout(bool cout);
+    void                      cout(const bool& flag);
     void                      test_assert(bool               result,
                                           const std::string& name,
                                           const std::string& message="");
@@ -30,10 +30,10 @@
 /* __ Includes ___________________________________________________________ */
 #include <string>
 #include <vector>
+#include "GBase.hpp"
+#include "GLog.hpp"
 #include "GXml.hpp"
-#include "GTools.hpp"
 #include "GTestSuite.hpp"
-#include "GTestCase.hpp"
  
  
 /***********************************************************************//**
@@ -45,7 +45,7 @@
  *
  * @todo Detailed description
  ***************************************************************************/
-class GTestSuites {
+class GTestSuites : public GBase {
  
 public:
     // Constructors and destructors
@@ -60,19 +60,20 @@ public:
     const GTestSuite& operator[](const int& index) const;
  
     // Methods
-    void        clear(void);
-    int         size(void) const;
-    void        append(GTestSuite& suite);
-    bool        run(void);
-    void        save(const std::string& filename) const;
-    std::string name(void) const;
-    void        name(const std::string& name);
-    void        cout(bool cout);
-    int         errors(void) const;
-    int         failures(void) const;
-    int         tests(void) const;
-    time_t      timestamp(void) const;
-    std::string print(void) const;
+    void         clear(void);
+    GTestSuites* clone(void) const;
+    int          size(void) const;
+    void         append(GTestSuite& suite);
+    bool         run(void);
+    void         save(const std::string& filename) const;
+    std::string  name(void) const;
+    void         name(const std::string& name);
+    void         cout(const bool& flag);
+    int          errors(void) const;
+    int          failures(void) const;
+    int          tests(void) const;
+    time_t       timestamp(void) const;
+    std::string  print(void) const;
  
 protected:
     // Protected methods
 /***************************************************************************
  *                          GTime.hpp - Time class                         *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Juergen Knoedlseder                         *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GTime.hpp
  * @brief Time class interface definition
- * @author J. Knoedlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GTIME_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <vector>
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -44,11 +43,7 @@
  *
  * @todo Make use of MJD reference in operators.
  ***************************************************************************/
-class GTime {
-
-    // I/O friends
-    friend GLog&         operator<< (GLog& log,        const GTime& time);
-    friend std::ostream& operator<< (std::ostream& os, const GTime& time);
+class GTime : public GBase {
  
     // Operator friends
     friend GTime operator+ (const GTime &a, const GTime &b);
@@ -85,6 +80,7 @@ public:
  
     // Methods
     void        clear(void);
+    GTime*      clone(void) const;
     double      jd(void) const;
     double      mjd(void) const;
     double      met(void) const;
 /***************************************************************************
  *                         GVector.hpp  -  Vector class                    *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2006-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2006-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GVector.hpp
  * @brief Vector class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GVECTOR_HPP
@@ -30,8 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <cmath>
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GException.hpp"
  
  
@@ -44,11 +43,7 @@
  * is intended to be used for numerical computation (it is not ment to
  * replace the std::vector template class).
  ***************************************************************************/
-class GVector {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GVector& v);
-    friend GLog&         operator<<(GLog& log,        const GVector& v);
+class GVector : public GBase {
  
     // Operator friends
     friend GVector  operator+(const GVector &a, const GVector &b);
@@ -118,6 +113,7 @@ public:
  
     // Vector methods
     void        clear(void);
+    GVector*    clone(void) const;
     int         size(void) const;
     int         non_zeros(void) const;
     std::string print(void) const;
 /***************************************************************************
  *          GWcs.hpp  -  World Coordinate System virtual base class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GWcs.hpp
  * @brief World Coordinate System virtual base class definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GWCS_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GFitsHDU.hpp"
 #include "GSkyDir.hpp"
 #include "GSkyPixel.hpp"
@@ -41,16 +40,12 @@
  *
  * @brief GWcs virtual base class interface defintion
  ***************************************************************************/
-class GWcs {
+class GWcs : public GBase {
  
     // Operator friends
     friend bool operator== (const GWcs &a, const GWcs &b);
     friend bool operator!= (const GWcs &a, const GWcs &b);
  
-    // I/O friends
-    friend std::ostream& operator<< (std::ostream& os, const GWcs& wcs);
-    friend GLog&         operator<< (GLog& log, const GWcs& wcs);
-
 public:
     // Constructors and destructors
     GWcs(void);
 /***************************************************************************
- *     GWcsRegistry.hpp  -  World Coordinate Projection registry class     *
+ *      GWcsRegistry.hpp - World Coordinate Projection registry class      *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GWcsRegistry.hpp
  * @brief World Coordinate Projection registry class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GWCSREGISTRY_HPP
@@ -29,8 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include <iostream>
-#include "GLog.hpp"
+#include "GRegistry.hpp"
 #include "GWcslib.hpp"
  
  
@@ -44,16 +43,14 @@
  * m_number, m_codes, m_names, and m_prjs which are allocated globally to keep
  * track of projections that are available throughout all linked libraries. To
  * register a projection it is sufficient to add
- *  const GWcsXXX      g_wcs_XXX_seed;
- *  const GWcsRegistry g_wcs_XXX_registry(&g_wcs_XXX_seed);
+ *
+ *     const GWcsXXX      g_wcs_XXX_seed;
+ *     const GWcsRegistry g_wcs_XXX_registry(&g_wcs_XXX_seed);
+ *
  * at the top of the .cpp file of the projection. Here, XXX is a unique
  * code that describes the projection.
  ***************************************************************************/
-class GWcsRegistry {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GWcsRegistry& registry);
-    friend GLog&         operator<<(GLog& log,        const GWcsRegistry& registry);
+class GWcsRegistry : public GRegistry {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *                           GXml.hpp - XML class                          *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,16 +21,15 @@
 /**
  * @file GXml.hpp
  * @brief XML class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GXML_HPP
 #define GXML_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
 #include <string>
-#include "GLog.hpp"
+#include "GBase.hpp"
 #include "GXmlNode.hpp"
 #include "GXmlDocument.hpp"
 #include "GXmlElement.hpp"
@@ -47,17 +46,13 @@
  * This class implements an XML object. It holds the root node of the XML
  * document.
  ***************************************************************************/
-class GXml {
+class GXml : public GBase {
  
     // Friend classes
     friend class GXmlNode;
     friend class GXmlDocument;
     friend class GXmlText;
  
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GXml& xml);
-    friend GLog&         operator<<(GLog& log,        const GXml& xml);
-
 public:
     // Constructors and destructors
     GXml(void);
@@ -70,6 +65,7 @@ public:
  
     // Methods
     void         clear(void);
+    GXml*        clone(void) const;
     void         append(GXmlNode* node);
     void         load(const std::string& filename);
     void         save(const std::string& filename);
@@ -79,7 +75,8 @@ public:
     int          elements(const std::string& name) const;
     GXmlElement* element(int index) const;
     GXmlElement* element(const std::string& name, int index) const;
-    std::string  print(int indent = 0) const;
+    std::string  print(void) const;
+    std::string  print(int indent) const;
  
 protected:
     // Protected enumerators
 /***************************************************************************
  *           GXmlAttribute.hpp - XML attribute class definition            *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GXmlAttribute.hpp
  * @brief XML attribute class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GXMLATTRIBUTE_HPP
@@ -30,6 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <cstdio>             // FILE, std::fprintf
 #include <string>
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -41,7 +42,7 @@
  * consists of a name-value pair. Note that the hyphens are stored for the
  * attribute value. Allowed hyphens are " and '.
  ***************************************************************************/
-class GXmlAttribute {
+class GXmlAttribute : public GBase {
  
 public:
     // Constructors and destructors
 /***************************************************************************
  *                GXmlNode.hpp - Abstract XML node base class              *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2011 by Jurgen Knodlseder                           *
+ *  copyright (C) 2010-2012 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,17 +21,16 @@
 /**
  * @file GXmlNode.hpp
  * @brief Abstract XML node base class interface definition
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
  
 #ifndef GXMLNODE_HPP
 #define GXMLNODE_HPP
  
 /* __ Includes ___________________________________________________________ */
-#include <iostream>
 #include <string>
 #include <vector>
-#include "GLog.hpp"
+#include "GBase.hpp"
  
  
 /***********************************************************************//**
@@ -41,11 +40,7 @@
  *
  * This class defines an abstract node of a XML document.
  ***************************************************************************/
-class GXmlNode {
-
-    // I/O friends
-    friend std::ostream& operator<<(std::ostream& os, const GXmlNode& node);
-    friend GLog&         operator<<(GLog& log,        const GXmlNode& node);
+class GXmlNode : public GBase {
  
 public:
     // Constructors and destructors
@@ -72,8 +67,9 @@ public:
     virtual void        clear(void) = 0;
     virtual GXmlNode*   clone(void) const = 0;
     virtual void        write(FILE* fptr, int indent = 0) const = 0;
-    virtual std::string print(int indent = 0) const = 0;
     virtual NodeType    type(void) const = 0;
+    virtual std::string print(void) const;
+    virtual std::string print(int indent) const = 0;
  
     // Methods
     void      append(GXmlNode* node);
@@ -18,17 +18,24 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
  *                                                                         *
  ***************************************************************************/
+/**
+ * @file GammaLib.hpp
+ * @brief GammaLib definitions
+ * @author Juergen Knoedlseder
+ */
  
 #ifndef GAMMALIB_HPP
 #define GAMMALIB_HPP
  
-/* __ Includes ___________________________________________________________ */
-
  
 /***************************************************************************
  *                              Core services                              *
  ***************************************************************************/
  
+/* __ Interface classes __________________________________________________ */
+#include "GBase.hpp"
+#include "GRegistry.hpp"
+
 /* __ Common tools _______________________________________________________ */
 #include "GException.hpp"
 #include "GNodeArray.hpp"
@@ -45,6 +52,7 @@
 #include "GIntegrand.hpp"
 #include "GDerivative.hpp"
 #include "GFunction.hpp"
+#include "GNumerics.hpp"
  
 /* __ FITS module ________________________________________________________ */
 #include "GFits.hpp"
 # Define package included headers (to be installed)
 pkginclude_HEADERS = GammaLib.hpp \
+                     GBase.hpp \
+                     GRegistry.hpp \
                      GException.hpp \
                      GNodeArray.hpp \
                      GTools.hpp \
@@ -118,6 +120,7 @@ pkginclude_HEADERS = GammaLib.hpp \
                      GIntegrand.hpp \
                      GDerivative.hpp \
                      GFunction.hpp \
+                     GNumerics.hpp \
                      GOptimizer.hpp \
                      GOptimizerLM.hpp \
                      GOptimizerPars.hpp \
@@ -18,6 +18,15 @@ sources = src/GCTASupport.cpp \
           src/GCTAResponse.cpp \
           src/GCTAResponse_helpers.cpp \
           src/GCTAResponseTable.cpp \
+          src/GCTAAeff.cpp \
+          src/GCTAAeffPerfTable.cpp \
+          src/GCTAAeffArf.cpp \
+          src/GCTAAeff2D.cpp \
+          src/GCTAPsf.cpp \
+          src/GCTAPsfPerfTable.cpp \
+          src/GCTAPsfVector.cpp \
+          src/GCTAPsf2D.cpp \
+          src/GCTAEdisp.cpp \
           src/GCTAInstDir.cpp \
           src/GCTARoi.cpp \
           src/GCTAPointing.cpp \
@@ -41,6 +50,15 @@ pkginclude_HEADERS = include/GCTAException.hpp \
                      include/GCTARoi.hpp \
                      include/GCTAResponse.hpp \
                      include/GCTAResponseTable.hpp \
+                     include/GCTAAeff.hpp \
+                     include/GCTAAeffPerfTable.hpp \
+                     include/GCTAAeffArf.hpp \
+                     include/GCTAAeff2D.hpp \
+                     include/GCTAPsf.hpp \
+                     include/GCTAPsfPerfTable.hpp \
+                     include/GCTAPsfVector.hpp \
+                     include/GCTAPsf2D.hpp \
+                     include/GCTAEdisp.hpp \
                      include/GCTAModelRadialRegistry.hpp \
                      include/GCTAModelRadial.hpp \
                      include/GCTAModelRadialGauss.hpp \