Implement skeleton for general CTA background model (#2694)

Jürgen Knödlseder
1 parent 642d66bb
Showing 16 changed files with 2373 additions and 43 deletions
inst/cta/Makefile.am
inst/cta/include/GCTALib.hpp
inst/cta/include/GCTAModelBackground.hpp
inst/cta/include/GCTAModelRadial.hpp
inst/cta/include/GCTAModelSpatial.hpp
inst/cta/include/GCTAModelSpatialRegistry.hpp
inst/cta/src/GCTAModelBackground.cpp
inst/cta/src/GCTAModelRadial.cpp
inst/cta/src/GCTAModelRadialGauss.cpp
inst/cta/src/GCTAModelRadialPolynom.cpp
inst/cta/src/GCTAModelRadialProfile.cpp
inst/cta/src/GCTAModelSpatial.cpp
inst/cta/src/GCTAModelSpatialRegistry.cpp
inst/cta/test/data/cta_model_bgd_rad_gauss.xml
inst/cta/test/test_CTA.cpp
inst/cta/test/test_CTA.hpp
@@ -74,6 +74,9 @@ sources = src/GCTASupport.cpp \
           src/GCTAInstDir.cpp \
           src/GCTARoi.cpp \
           src/GCTAPointing.cpp \
+          src/GCTAModelBackground.cpp \
+          src/GCTAModelSpatial.cpp \
+          src/GCTAModelSpatialRegistry.cpp \
           src/GCTAModelCubeBackground.cpp \
           src/GCTAModelIrfBackground.cpp \
           src/GCTAModelAeffBackground.cpp \
@@ -124,6 +127,9 @@ pkginclude_HEADERS = include/GCTATypemaps.hpp \
                      include/GCTACubeSource.hpp \
                      include/GCTACubeSourcePoint.hpp \
                      include/GCTACubeSourceDiffuse.hpp \
+                     include/GCTAModelBackground.hpp \
+                     include/GCTAModelSpatial.hpp \
+                     include/GCTAModelSpatialRegistry.hpp \
                      include/GCTAModelCubeBackground.hpp \
                      include/GCTAModelIrfBackground.hpp \
                      include/GCTAModelAeffBackground.hpp \
 /***************************************************************************
  *                 GCTALib.hpp - CTA Support Header files                  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2010-2016 by Juergen Knoedlseder                         *
+ *  copyright (C) 2010-2018 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -72,6 +72,9 @@
 #include "GCTACubeSource.hpp"
 #include "GCTACubeSourcePoint.hpp"
 #include "GCTACubeSourceDiffuse.hpp"
+#include "GCTAModelBackground.hpp"
+#include "GCTAModelSpatial.hpp"
+#include "GCTAModelSpatialRegistry.hpp"
 #include "GCTAModelCubeBackground.hpp"
 #include "GCTAModelIrfBackground.hpp"
 #include "GCTAModelAeffBackground.hpp"
+/***************************************************************************
+ *           GCTAModelBackground.hpp - Background model class              *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2018 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 GCTAModelBackground.hpp
+ * @brief Background model class interface definition
+ * @author Juergen Knoedlseder
+ */
+
+#ifndef GCTAMODELBACKGROUND_HPP
+#define GCTAMODELBACKGROUND_HPP
+
+/* __ Includes ___________________________________________________________ */
+#include <string>
+#include <cmath>
+#include "GModelData.hpp"
+#include "GModelSpectral.hpp"
+#include "GModelTemporal.hpp"
+#include "GFunction.hpp"
+#include "GCTAModelSpatial.hpp"
+#include "GCTAEventList.hpp"
+
+/* __ Forward declarations _______________________________________________ */
+class GEvent;
+class GObservation;
+class GModelPar;
+class GXmlElement;
+
+
+/***********************************************************************//**
+ * @class GCTAModelBackground
+ *
+ * @brief Background model class
+ *
+ * This class implements a background model for CTA.
+ ***************************************************************************/
+class GCTAModelBackground : public GModelData {
+
+public:
+    // Constructors and destructors
+    GCTAModelBackground(void);
+    explicit GCTAModelBackground(const GXmlElement& xml);
+    GCTAModelBackground(const GCTAModelSpatial& spatial,
+                        const GModelSpectral&   spectral);
+    GCTAModelBackground(const GCTAModelSpatial& spatial,
+                        const GModelSpectral&   spectral,
+                        const GModelTemporal&   temporal);
+    GCTAModelBackground(const GCTAModelBackground& model);
+    virtual ~GCTAModelBackground(void);
+
+    // Operators
+    virtual GCTAModelBackground& operator=(const GCTAModelBackground& model);
+
+    // Implemented pure virtual methods
+    virtual void                 clear(void);
+    virtual GCTAModelBackground* clone(void) const;
+    virtual std::string          classname(void) const;
+    virtual std::string          type(void) const;
+    virtual bool                 is_constant(void) const;
+    virtual double               eval(const GEvent&       event,
+                                      const GObservation& obs,
+                                      const bool&         gradients = false) const;
+    virtual double               npred(const GEnergy&      obsEng,
+                                       const GTime&        obsTime,
+                                       const GObservation& obs) const;
+    virtual GCTAEventList*       mc(const GObservation& obs, GRan& ran) const;
+    virtual void                 read(const GXmlElement& xml);
+    virtual void                 write(GXmlElement& xml) const;
+    virtual std::string          print(const GChatter& chatter = NORMAL) const;
+
+    // Other methods
+    GCTAModelSpatial* spatial(void) const;
+    GModelSpectral*   spectral(void) const;
+    GModelTemporal*   temporal(void) const;
+    void              spatial(const GCTAModelSpatial* spatial);
+    void              spectral(const GModelSpectral* spectral);
+    void              temporal(const GModelTemporal* temporal);
+
+protected:
+    // Protected methods
+    void              init_members(void);
+    void              copy_members(const GCTAModelBackground& model);
+    void              free_members(void);
+    void              set_pointers(void);
+    GCTAModelSpatial* xml_spatial(const GXmlElement& spatial) const;
+    GModelSpectral*   xml_spectral(const GXmlElement& spectral) const;
+    GModelTemporal*   xml_temporal(const GXmlElement& temporal) const;
+    bool              valid_model(void) const;
+
+    // ROI integration kernel
+    class roi_kern : public GFunction {
+    public:
+        roi_kern(const GCTAModelSpatial* parent, const double& roi, const double& dist) :
+                 m_parent(parent),
+                 m_roi(roi),
+                 m_cosroi(std::cos(roi)),
+                 m_dist(dist),
+                 m_cosdist(std::cos(dist)),
+                 m_sindist(std::sin(dist)) { }
+        double eval(const double& r);
+    protected:
+        const GCTAModelSpatial* m_parent;   //!< Pointer to radial model
+        double                  m_roi;      //!< ROI radius in radians
+        double                  m_cosroi;   //!< Cosine of ROI radius
+        double                  m_dist;     //!< Distance between pointing and ROI centre in radians
+        double                  m_cosdist;  //!< Cosine of distance
+        double                  m_sindist;  //!< Sinus of distance
+    };
+
+    // Proteced data members
+    GCTAModelSpatial* m_spatial;      //!< Spatial model
+    GModelSpectral*   m_spectral;     //!< Spectral model
+    GModelTemporal*   m_temporal;     //!< Temporal model
+};
+
+
+/***********************************************************************//**
+ * @brief Return class name
+ *
+ * @return String containing the class name ("GCTAModelBackground").
+ ***************************************************************************/
+inline
+std::string GCTAModelBackground::classname(void) const
+{
+    return ("GCTAModelBackground");
+}
+
+
+/***********************************************************************//**
+ * @brief Return model type
+ *
+ * @return Model type.
+ *
+ * Returns "CTABackground" as the type of the model.
+ ***************************************************************************/
+inline
+std::string GCTAModelBackground::type(void) const
+{
+    return ("CTABackground");
+}
+
+
+/***********************************************************************//**
+ * @brief Signals if model is temporally constant
+ *
+ * @return True if model is temporally constant, false otherwise.
+ *
+ * Signals if the model is temporally constant. A temporally constant model
+ * is a model that has a temporal component of type "Constant".
+ ***************************************************************************/
+inline
+bool GCTAModelBackground::is_constant(void) const
+{
+    return (m_temporal != NULL && m_temporal->type() == "Constant");
+}
+
+
+/***********************************************************************//**
+ * @brief Return spatial model component
+ *
+ * @return Pointer to spatial model component.
+ *
+ * Returns a pointer to the spatial model component of the model. The pointer
+ * is of type GCTAModelSpatial. Note that a NULL pointer may be returned if
+ * the model has no spatial model component.
+ ***************************************************************************/
+inline
+GCTAModelSpatial* GCTAModelBackground::spatial(void) const
+{
+    return (m_spatial);
+}
+
+
+/***********************************************************************//**
+ * @brief Return spectral model component
+ *
+ * @return Pointer to spectral model component.
+ *
+ * Returns a pointer to the spectral model component of the model. The
+ * pointer is of type GModelSpectral. Note that a NULL pointer may be
+ * returned if the model has no spectral model component.
+ ***************************************************************************/
+inline
+GModelSpectral* GCTAModelBackground::spectral(void) const
+{
+    return (m_spectral);
+}
+
+
+/***********************************************************************//**
+ * @brief Return temporal model component
+ *
+ * @return Pointer to temporal model component.
+ *
+ * Returns a pointer to the temporal model component of the model. The
+ * pointer is of type GModelTemporal. Note that a NULL pointer may be
+ * returned if the model has no temporal model component.
+ ***************************************************************************/
+inline
+GModelTemporal* GCTAModelBackground::temporal(void) const
+{
+    return (m_temporal);
+}
+
+#endif /* GCTAMODELBACKGROUND_HPP */
@@ -29,11 +29,13 @@
 /* __ Includes ___________________________________________________________ */
 #include <string>
-#include "GBase.hpp"
+#include "GCTAModelSpatial.hpp"
 #include "GModelPar.hpp"
-#include "GXmlElement.hpp"
-#include "GRan.hpp"
-#include "GCTAInstDir.hpp"
+
+/* __ Forward declarations _______________________________________________ */
+class GRan;
+class GXmlElement;
+class GCTAInstDir;
 /***********************************************************************//**
@@ -44,7 +46,7 @@
  * This class implements the radial component of the CTA radial acceptance
  * model.
  ***************************************************************************/
-class GCTAModelRadial : public GBase {
+class GCTAModelRadial : public GCTAModelSpatial {
 public:
     // Constructors and destructors
@@ -59,19 +61,30 @@ public:
     virtual GModelPar&       operator[](const std::string& name);
     virtual const GModelPar& operator[](const std::string& name) const;
+    // Implemented virtual methods
+    virtual double            eval(const GCTAInstDir& dir,
+                                   const GEnergy&     energy,
+                                   const GTime&       time,
+                                   const bool&        gradients = false) const;
+    virtual GCTAInstDir       mc(const GEnergy& energy,
+                                 const GTime&   time,
+                                 GRan& ran) const;
+
     // Pure virtual methods
     virtual void             clear(void) = 0;
     virtual GCTAModelRadial* clone(void) const = 0;
     virtual std::string      classname(void) const = 0;
     virtual std::string      type(void) const = 0;
-    virtual double           eval(const double& offset,
-                                  const bool&   gradients = false) const = 0;
-    virtual GCTAInstDir      mc(const GCTAInstDir& dir, GRan& ran) const = 0;
     virtual double           omega(void) const = 0;
     virtual void             read(const GXmlElement& xml) = 0;
     virtual void             write(GXmlElement& xml) const = 0;
     virtual std::string      print(const GChatter& chatter = NORMAL) const = 0;
+    // Derived class pure virtual methods
+    virtual double           eval(const double& offset,
+                                  const bool&   gradients = false) const = 0;
+    virtual GCTAInstDir      mc(const GCTAInstDir& dir, GRan& ran) const = 0;
+
     // Methods
     int size(void) const;
+/***************************************************************************
+ *         GCTAModelSpatial.hpp - Spatial model abstract base class        *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2018 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 GCTAModelSpatial.hpp
+ * @brief Abstract spatial model class interface definition
+ * @author Juergen Knoedlseder
+ */
+
+#ifndef GCTAMODELSPATIAL_HPP
+#define GCTAMODELSPATIAL_HPP
+
+/* __ Includes ___________________________________________________________ */
+#include <string>
+#include "GBase.hpp"
+#include "GModelPar.hpp"
+
+/* __ Forward declarations _______________________________________________ */
+class GRan;
+class GTime;
+class GXmlElement;
+class GCTAInstDir;
+
+
+/***********************************************************************//**
+ * @class GCTAModelSpatial
+ *
+ * @brief Abstract spatial model class
+ *
+ * This class implements the spatial component of the CTA background model.
+ ***************************************************************************/
+class GCTAModelSpatial : public GBase {
+
+public:
+    // Constructors and destructors
+    GCTAModelSpatial(void);
+    GCTAModelSpatial(const GCTAModelSpatial& model);
+    virtual ~GCTAModelSpatial(void);
+
+    // Operators
+    virtual GCTAModelSpatial& operator=(const GCTAModelSpatial& model);
+    virtual GModelPar&        operator[](const int& index);
+    virtual const GModelPar&  operator[](const int& index) const;
+    virtual GModelPar&        operator[](const std::string& name);
+    virtual const GModelPar&  operator[](const std::string& name) const;
+
+    // Pure virtual methods
+    virtual void              clear(void) = 0;
+    virtual GCTAModelSpatial* clone(void) const = 0;
+    virtual std::string       classname(void) const = 0;
+    virtual std::string       type(void) const = 0;
+    virtual double            eval(const GCTAInstDir& dir,
+                                   const GEnergy&     energy,
+                                   const GTime&       time,
+                                   const bool&        gradients = false) const = 0;
+    virtual GCTAInstDir       mc(const GEnergy& energy,
+                                 const GTime&   time,
+                                 GRan& ran) const = 0;
+    virtual double            omega(void) const = 0;
+    virtual void              read(const GXmlElement& xml) = 0;
+    virtual void              write(GXmlElement& xml) const = 0;
+    virtual std::string       print(const GChatter& chatter = NORMAL) const = 0;
+
+    // Methods
+    int size(void) const;
+
+protected:
+    // Protected methods
+    void init_members(void);
+    void copy_members(const GCTAModelSpatial& model);
+    void free_members(void);
+
+    // Proteced members
+    std::vector<GModelPar*> m_pars;  //!< Parameter pointers
+};
+
+
+/***********************************************************************//**
+ * @brief Return number of model parameters
+ *
+ * @return Number of model parameters.
+ ***************************************************************************/
+inline
+int GCTAModelSpatial::size(void) const
+{
+    return ((int)m_pars.size());
+}
+
+#endif /* GCTAMODELSPATIAL_HPP */
+/***************************************************************************
+ *        GCTAModelSpatialRegistry.hpp - Spatial model registry class      *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2018 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 GCTAModelSpatialRegistry.hpp
+ * @brief Spatial model registry class definition
+ * @author Juergen Knoedlseder
+ */
+
+#ifndef GCTAMODELSPATIALREGISTRY_HPP
+#define GCTAMODELSPATIALREGISTRY_HPP
+
+/* __ Includes ___________________________________________________________ */
+#include <string>
+#include "GRegistry.hpp"
+
+/* __ Forward declarations _______________________________________________ */
+class GXmlElement;
+class GCTAModelSpatial;
+
+
+/***********************************************************************//**
+ * @class GCTAModelSpatialRegistry
+ *
+ * @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 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 GCTAModelSpatialXXX      g_spatial_XXX_seed;
+ *     const GCTAModelSpatialRegistry 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 GCTAModelSpatialRegistry : public GRegistry {
+
+public:
+    // Constructors and destructors
+    GCTAModelSpatialRegistry(void);
+    GCTAModelSpatialRegistry(const GCTAModelSpatial* model);
+    GCTAModelSpatialRegistry(const GCTAModelSpatialRegistry& registry);
+    virtual ~GCTAModelSpatialRegistry(void);
+
+    // Operators
+    GCTAModelSpatialRegistry& operator=(const GCTAModelSpatialRegistry& registry);
+
+    // Methods
+    std::string       classname(void) const;
+    int               size(void) const;
+    GCTAModelSpatial* alloc(const GXmlElement& xml) const;
+    std::string       name(const int& index) const;
+    std::string       print(const GChatter& chatter = NORMAL) const;
+
+protected:
+    // Protected methods
+    void init_members(void);
+    void copy_members(const GCTAModelSpatialRegistry& registry);
+    void free_members(void);
+
+private:
+    // Private members (the private members have been implement as static
+    // methods to avoid the static initialization order fiasco of static
+    // members; using static methods we follow the "construct on first use
+    // idiom")
+    // Number of models in registry
+    static int& number() {
+        static int m_number = 0;
+        return m_number;
+    };
+    // Pointer to seed models
+    static GRegistryPointer<const GCTAModelSpatial*>& models() {
+        static GRegistryPointer<const GCTAModelSpatial*> m_models;
+        return m_models;
+    };
+};
+
+
+/***********************************************************************//**
+ * @brief Return class name
+ *
+ * @return String containing the class name ("GCTAModelSpatialRegistry").
+ ***************************************************************************/
+inline
+std::string GCTAModelSpatialRegistry::classname(void) const
+{
+    return ("GCTAModelSpatialRegistry");
+}
+
+
+/***********************************************************************//**
+ * @brief Return number of registered models
+ *
+ * @return Number of registered models.
+ *
+ * Returns the number of registered model.
+ ***************************************************************************/
+inline
+int GCTAModelSpatialRegistry::size(void) const
+{
+    return number();
+}
+
+#endif /* GCTAMODELSPATIALREGISTRY_HPP */
+/***************************************************************************
+ *           GCTAModelBackground.cpp - Background model class              *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2018 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 GCTAModelBackground.cpp
+ * @brief Background model class implementation
+ * @author Juergen Knoedlseder
+ */
+
+/* __ Includes ___________________________________________________________ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "GException.hpp"
+#include "GTools.hpp"
+#include "GMath.hpp"
+#include "GModelRegistry.hpp"
+#include "GModelSpectralRegistry.hpp"
+#include "GModelTemporalRegistry.hpp"
+#include "GModelTemporalConst.hpp"
+#include "GIntegral.hpp"
+#include "GCTAModelSpatialRegistry.hpp"
+#include "GCTAModelBackground.hpp"
+#include "GCTAObservation.hpp"
+#include "GCTAPointing.hpp"
+#include "GCTAInstDir.hpp"
+#include "GCTARoi.hpp"
+#include "GCTAException.hpp"
+#include "GCTASupport.hpp"
+
+/* __ Constants __________________________________________________________ */
+
+/* __ Globals ____________________________________________________________ */
+const GCTAModelBackground g_cta_background_seed;
+const GModelRegistry      g_cta_background_registry(&g_cta_background_seed);
+
+/* __ Method name definitions ____________________________________________ */
+#define G_EVAL     "GCTAModelBackground::eval(GEvent&, GObservation&, bool&)"
+#define G_NPRED "GCTAModelBackground::npred(GEnergy&, GTime&, GObservation&)"
+#define G_MC                  "GCTAModelBackground::mc(GObservation&, GRan&)"
+#define G_XML_SPATIAL        "GCTAModelBackground::xml_spatial(GXmlElement&)"
+#define G_XML_SPECTRAL      "GCTAModelBackground::xml_spectral(GXmlElement&)"
+#define G_XML_TEMPORAL      "GCTAModelBackground::xml_temporal(GXmlElement&)"
+
+/* __ Macros _____________________________________________________________ */
+
+/* __ Coding definitions _________________________________________________ */
+
+/* __ Debug definitions __________________________________________________ */
+//#define G_DUMP_MC                                  //!< Dump MC information
+
+
+/*==========================================================================
+ =                                                                         =
+ =                        Constructors/destructors                         =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Void constructor
+ *
+ * Constructs an empty background model.
+ ***************************************************************************/
+GCTAModelBackground::GCTAModelBackground(void) : GModelData()
+{
+    // Initialise members
+    init_members();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief XML constructor
+ *
+ * @param[in] xml XML element.
+ *
+ * Constructs a background model from the information that is found in a XML
+ * element. Please refer to the read() method to learn about the expected
+ * structure of the XML element.
+ ***************************************************************************/
+GCTAModelBackground::GCTAModelBackground(const GXmlElement& xml) :
+                     GModelData(xml)
+{
+    // Initialise members
+    init_members();
+
+    // Read XML
+    read(xml);
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Construct from spatial and spectral components
+ *
+ * @param[in] spatial Spatial model component.
+ * @param[in] spectral Spectral model component.
+ *
+ * Constructs a background model from a @p spatial and a @p spectral model
+ * component. The temporal component is assumed to be constant.
+ ***************************************************************************/
+GCTAModelBackground::GCTAModelBackground(const GCTAModelSpatial& spatial,
+                                         const GModelSpectral&   spectral) :
+                     GModelData()
+{
+    // Initialise members
+    init_members();
+
+    // Allocate temporal constant model
+    GModelTemporalConst temporal;
+
+    // Clone model components
+    m_spatial  = spatial.clone();
+    m_spectral = spectral.clone();
+    m_temporal = temporal.clone();
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Construct from model components
+ *
+ * @param[in] spatial Spatial model component.
+ * @param[in] spectral Spectral model component.
+ * @param[in] temporal Temporal model component.
+ *
+ * Constructs a background model from a @p spatial, a @p spectral and a
+ * @p temporal model component.
+ ***************************************************************************/
+GCTAModelBackground::GCTAModelBackground(const GCTAModelSpatial& spatial,
+                                         const GModelSpectral&   spectral,
+                                         const GModelTemporal&   temporal) :
+                     GModelData()
+{
+    // Initialise members
+    init_members();
+
+    // Clone model components
+    m_spatial  = spatial.clone();
+    m_spectral = spectral.clone();
+    m_temporal = temporal.clone();
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy constructor
+ *
+ * @param[in] model Background model.
+ *
+ * Constructs a background model by copying information from an existing
+ * model. Note that the copy is a deep copy, so the original object can be
+ * destroyed after the copy without any loss of information.
+ ***************************************************************************/
+GCTAModelBackground::GCTAModelBackground(const GCTAModelBackground& model) :
+                     GModelData(model)
+{
+    // Initialise private members for clean destruction
+    init_members();
+
+    // Copy members
+    copy_members(model);
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Destructor
+ *
+ * Destroys a background model.
+ ***************************************************************************/
+GCTAModelBackground::~GCTAModelBackground(void)
+{
+    // Free members
+    free_members();
+
+    // Return
+    return;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                               Operators                                 =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Assignment operator
+ *
+ * @param[in] model Background model.
+ *
+ * Assigns the information from a background model to instance. Note that a
+ * deep copy of the information is performed, so the original instance can be
+ * destroyed after the assignment without any loss of information.
+ ***************************************************************************/
+GCTAModelBackground& GCTAModelBackground::operator=(const GCTAModelBackground& model)
+{
+    // Execute only if object is not identical
+    if (this != &model) {
+
+        // Copy base class members
+        this->GModelData::operator=(model);
+
+        // Free members
+        free_members();
+
+        // Initialise members
+        init_members();
+
+        // Copy members (this method also sets the parameter pointers)
+        copy_members(model);
+
+    } // endif: object was not identical
+
+    // Return
+    return *this;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                            Public methods                               =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Clear instance
+ *
+ * Resets the instance to a clean initial state. All information that resided
+ * in the object will be lost.
+ ***************************************************************************/
+void GCTAModelBackground::clear(void)
+{
+    // Free class members (base and derived classes, derived class first)
+    free_members();
+    this->GModelData::free_members();
+    this->GModel::free_members();
+
+    // Initialise members
+    this->GModel::init_members();
+    this->GModelData::init_members();
+    init_members();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Clone instance
+ *
+ * @return Pointer to deep copy of background model.
+ ***************************************************************************/
+GCTAModelBackground* GCTAModelBackground::clone(void) const
+{
+    return new GCTAModelBackground(*this);
+}
+
+
+/***********************************************************************//**
+ * @brief Set spatial model component
+ *
+ * @param[in] spatial Pointer to spatial model component.
+ *
+ * Sets the spatial model component of the model.
+ ***************************************************************************/
+void GCTAModelBackground::spatial(const GCTAModelSpatial* spatial)
+{
+    // Free spatial model component only if it differs from current
+    // component. This prevents unintentional deallocation of the argument
+    if ((m_spatial != NULL) && (m_spatial != spatial)) {
+        delete m_spatial;
+    }
+
+    // Clone spatial model component if it exists, otherwise set pointer
+    // to NULL
+    m_spatial = (spatial != NULL) ? spatial->clone() : NULL;
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Set spectral model component
+ *
+ * @param[in] spectral Pointer to spectral model component.
+ *
+ * Sets the spectral model component of the model.
+ ***************************************************************************/
+void GCTAModelBackground::spectral(const GModelSpectral* spectral)
+{
+    // Free spectral model component only if it differs from current
+    // component. This prevents unintential deallocation of the argument
+    if ((m_spectral != NULL) && (m_spectral != spectral)) {
+        delete m_spectral;
+    }
+
+    // Clone spectral model component if it exists, otherwise set pointer
+    // to NULL
+    m_spectral = (spectral != NULL) ? spectral->clone() : NULL;
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Set temporal model component
+ *
+ * @param[in] temporal Pointer to temporal model component.
+ *
+ * Sets the temporal model component of the model.
+ ***************************************************************************/
+void GCTAModelBackground::temporal(const GModelTemporal* temporal)
+{
+    // Free temporal model component only if it differs from current
+    // component. This prevents unintential deallocation of the argument
+    if ((m_temporal != NULL) && (m_temporal != temporal)) {
+        delete m_temporal;
+    }
+
+    // Clone temporal model component if it exists, otherwise set pointer
+    // to NULL
+    m_temporal = (temporal != NULL) ? temporal->clone() : NULL;
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Evaluate function
+ *
+ * @param[in] event Observed event.
+ * @param[in] obs Observation.
+ * @param[in] gradients Compute gradients?
+ * @return Function value.
+ *
+ * Evaluates the background model which is a factorization of a spatial,
+ * spectral and temporal model component. This method also applies a deadtime
+ * correction factor, so that the normalization of the model is a real rate
+ * (counts/exposure time).
+ *
+ * If the @p gradients flag is true the method will also set the parameter
+ * gradients of the model parameters.
+ *
+ * @todo Add bookkeeping of last value and evaluate only if argument
+ *       changed
+ * @todo Verify that CTA instrument direction pointer is valid, or better,
+ *       add an offset method to GCTAPointing. Ideally, we should precompute
+ *       all offset angles (for an event cube this may only be done easily
+ *       if the pointing has been fixed; otherwise we need a structure
+ *       similar to the Fermi/LAT livetime cube that provides the effective
+ *       sky exposure as function of offset angle).
+ ***************************************************************************/
+double GCTAModelBackground::eval(const GEvent&       event,
+                                 const GObservation& obs,
+                                 const bool&         gradients) const
+{
+    // Get reference on CTA pointing from observation and reference on CTA
+    // instrument direction from event
+    const GCTAPointing& pnt = gammalib::cta_pnt(G_EVAL, obs);
+    const GCTAInstDir&  dir = gammalib::cta_dir(G_EVAL, event);
+
+    // Compute offset angle (in degrees)
+    //double offset = dir.dir().dist_deg(pnt.dir());
+
+    // Evaluate function and gradients
+    double spat = (spatial() != NULL)
+                  ? spatial()->eval(dir, event.energy(), event.time(), gradients) : 1.0;
+    double spec = (spectral() != NULL)
+                  ? spectral()->eval(event.energy(), event.time(), gradients)
+                  : 1.0;
+    double temp = (temporal() != NULL)
+                  ? temporal()->eval(event.time(), gradients) : 1.0;
+
+    // Compute value
+    double value = spat * spec * temp;
+
+    // Apply deadtime correction
+    double deadc = obs.deadc(event.time());
+    value       *= deadc;
+
+    // Optionally compute partial derivatives
+    if (gradients) {
+
+        // Multiply factors to radial gradients
+        if (spatial() != NULL) {
+            double fact = spec * temp * deadc;
+            if (fact != 1.0) {
+                for (int i = 0; i < spatial()->size(); ++i)
+                    (*spatial())[i].factor_gradient((*spatial())[i].factor_gradient() * fact);
+            }
+        }
+
+        // Multiply factors to spectral gradients
+        if (spectral() != NULL) {
+            double fact = spat * temp * deadc;
+            if (fact != 1.0) {
+                for (int i = 0; i < spectral()->size(); ++i)
+                    (*spectral())[i].factor_gradient((*spectral())[i].factor_gradient() * fact);
+            }
+        }
+
+        // Multiply factors to temporal gradients
+        if (temporal() != NULL) {
+            double fact = spat * spec * deadc;
+            if (fact != 1.0) {
+                for (int i = 0; i < temporal()->size(); ++i)
+                    (*temporal())[i].factor_gradient((*temporal())[i].factor_gradient() * fact);
+            }
+        }
+
+    } // endif: computed partial derivatives
+
+    // Return
+    return value;
+}
+
+
+/***********************************************************************//**
+ * @brief Return spatially integrated data model
+ *
+ * @param[in] obsEng Measured event energy.
+ * @param[in] obsTime Measured event time.
+ * @param[in] obs Observation.
+ *
+ * @exception GException::no_list
+ *            No valid CTA event list found in observation
+ * @exception GCTAException::no_pointing
+ *            No valid CTA pointing found in observation
+ *
+ * Spatially integrates the data model for a given measured event energy and
+ * event time. This method also applies a deadtime correction factor, so that
+ * the normalization of the model is a real rate (counts/exposure time).
+ ***************************************************************************/
+double GCTAModelBackground::npred(const GEnergy&      obsEng,
+                                  const GTime&        obsTime,
+                                  const GObservation& obs) const
+{
+    // Initialise result
+    double npred = 0.0;
+
+    // Evaluate only if model is valid
+    if (valid_model()) {
+
+        // Retrieve CTA pointing and event list
+        const GCTAPointing&  pnt    = gammalib::cta_pnt(G_NPRED, obs);
+        const GCTAEventList& events = gammalib::cta_event_list(G_NPRED, obs);
+
+        // Get ROI radius in radians
+        double roi_radius = events.roi().radius() * gammalib::deg2rad;
+
+        // Get distance from ROI centre in radians
+        double roi_distance = events.roi().centre().dir().dist(pnt.dir());
+
+        // Setup integration function
+        /*
+        GCTAModelBackground::roi_kern integrand(radial(), roi_radius, roi_distance);
+
+        // Setup integrator
+        GIntegral integral(&integrand);
+
+        // Setup integration boundaries
+        double rmin = (roi_distance > roi_radius) ? roi_distance-roi_radius : 0.0;
+        double rmax = roi_radius + roi_distance;
+
+        // Spatially integrate radial component
+        npred = integral.romberg(rmin, rmax);
+
+        // Multiply in spectral and temporal components
+        npred *= spectral()->eval(obsEng, obsTime);
+        npred *= temporal()->eval(obsTime);
+
+        // Apply deadtime correction
+        npred *= obs.deadc(obsTime);
+        */
+
+    } // endif: model was valid
+
+    // Return
+    return npred;
+}
+
+
+/***********************************************************************//**
+ * @brief Return simulated list of events
+ *
+ * @param[in] obs Observation.
+ * @param[in] ran Random number generator.
+ *
+ * @exception GCTAException::no_pointing
+ *            No CTA pointing found in observation.
+ *
+ * Draws a sample of events from the background model using a Monte Carlo
+ * simulation. The pointing information, the energy boundaries and the good
+ * time interval for the sampling will be extracted from the observation
+ * argument that is passed to the method. The method also requires a random
+ * number generator of type GRan which is passed by reference, hence the
+ * state of the random number generator will be changed by the method.
+ *
+ * The method also applies a deadtime correction using a Monte Carlo process,
+ * taking into account temporal deadtime variations. For this purpose, the
+ * method makes use of the time dependent GObservation::deadc method.
+ ***************************************************************************/
+GCTAEventList* GCTAModelBackground::mc(const GObservation& obs, 
+                                       GRan& ran) const
+{
+    // Initialise new event list
+    GCTAEventList* list = new GCTAEventList;
+
+    // Continue only if model is valid)
+    if (valid_model()) {
+
+        // Retrieve CTA pointing
+        const GCTAPointing& pnt = gammalib::cta_pnt(G_NPRED, obs);
+
+        // Convert CTA pointing direction in instrument system
+        GCTAInstDir pnt_dir(pnt.dir());
+
+        // Loop over all energy boundaries
+        for (int ieng = 0; ieng < obs.events()->ebounds().size(); ++ieng) {
+
+            // Compute the on-axis background rate in model within the
+            // energy boundaries from spectral component (units: cts/s/sr)
+            double flux = spectral()->flux(obs.events()->ebounds().emin(ieng),
+                                           obs.events()->ebounds().emax(ieng));
+
+            // Compute solid angle used for normalization
+            double area = spatial()->omega(); //TODO: Check if this is reasonable
+
+            // Derive expecting rate (units: cts/s). Note that the time here
+            // is good time. Deadtime correction will be done later.
+            double rate = flux * area;
+
+            // Debug option: dump rate
+            #if defined(G_DUMP_MC)
+            std::cout << "GCTAModelBackground::mc(\"" << name() << "\": ";
+            std::cout << "flux=" << flux << " cts/s/sr, ";
+            std::cout << "area=" << area << " sr, ";
+            std::cout << "rate=" << rate << " cts/s)" << std::endl;
+            #endif
+
+            // Loop over all good time intervals
+            for (int itime = 0; itime < obs.events()->gti().size(); ++itime) {
+
+                // Get event arrival times from temporal model
+                GTimes times = m_temporal->mc(rate,
+                                              obs.events()->gti().tstart(itime),
+                                              obs.events()->gti().tstop(itime),
+                                              ran);
+
+                // Get number of events
+                int n_events = times.size();
+
+                // Reserve space for events
+                if (n_events > 0) {
+                    list->reserve(n_events);
+                }
+
+                // Loop over events
+                for (int i = 0; i < n_events; ++i) {
+
+                    // Apply deadtime correction
+                    double deadc = obs.deadc(times[i]);
+                    if (deadc < 1.0) {
+                        if (ran.uniform() > deadc) {
+                            continue;
+                        }
+                    }
+
+                    // Set event energy
+                    GEnergy energy = spectral()->mc(obs.events()->ebounds().emin(ieng),
+                                                    obs.events()->ebounds().emax(ieng),
+                                                    times[i],
+                                                    ran);
+
+                    // Set event direction (only DETX and DETY are set)
+                    GCTAInstDir dir = spatial()->mc(energy, times[i], ran);
+
+                    // Compute RA/DEC
+                    //TODO
+
+                    // Allocate event
+                    GCTAEventAtom event;
+
+                    // Set event attributes
+                    event.dir(dir);
+                    event.energy(energy);
+                    event.time(times[i]);
+
+                    // Append event to list
+                    list->append(event);
+
+                } // endfor: looped over all events
+
+            } // endfor: looped over all GTIs
+
+        } // endfor: looped over all energy boundaries
+
+    } // endif: model was valid
+
+    // Return
+    return list;
+}
+
+
+/***********************************************************************//**
+ * @brief Read model from XML element
+ *
+ * @param[in] xml XML element.
+ *
+ * Reads the sky model from an XML element. The XML element is expected to
+ * respect the following format:
+ *
+ *     <source name=".." type=".." instrument=".." id="..">
+ *       <spectrum type="..">
+ *         ..
+ *       </spectrum>
+ *       <spatialModel type="..">
+ *         ..
+ *       </spatialModel>
+ *       <temporal type="..">
+ *         ..
+ *       </temporal>
+ *     </source>
+ *
+ * The temporal element is optional. In no temporal element is specified a
+ * constant component with unity normalization will be assumed.
+ ***************************************************************************/
+void GCTAModelBackground::read(const GXmlElement& xml)
+{
+    // Clear model
+    clear();
+
+    // Get pointers on spatial and spectral model components
+    const GXmlElement* spat = xml.element("spatialModel", 0);
+    const GXmlElement* spec = xml.element("spectrum", 0);
+
+    // Set spatial and spectral model components
+    m_spatial  = xml_spatial(*spat);
+    m_spectral = xml_spectral(*spec);
+
+    // Handle optional temporal model
+    if (xml.elements("temporal") > 0) {
+        const GXmlElement* temp = xml.element("temporal", 0);
+        m_temporal = xml_temporal(*temp);
+    }
+    else {
+        GModelTemporalConst temporal;
+        m_temporal = temporal.clone();
+    }
+
+    // Read model attributes
+    read_attributes(xml);
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Write model into XML element
+ *
+ * @param[in] xml XML element.
+ *
+ * Writes the sky model into an XML source library. The format written to
+ * the @p xml element is as follows:
+ *
+ *     <source name=".." type=".." instrument=".." id="..">
+ *       <spectrum type="..">
+ *         ..
+ *       </spectrum>
+ *       <spatialModel type="..">
+ *         ..
+ *       </spatialModel>
+ *       <temporal type="..">
+ *         ..
+ *       </temporal>
+ *     </source>
+ *
+ * For compatibility reasons the temporal element will only be written if it
+ * is a non-constant component or a constant component with a normalization
+ * that differs from unity.
+ ***************************************************************************/
+void GCTAModelBackground::write(GXmlElement& xml) const
+{
+    // Initialise pointer on source
+    GXmlElement* src = NULL;
+
+    // Search corresponding source
+    int n = xml.elements("source");
+    for (int k = 0; k < n; ++k) {
+        GXmlElement* element = xml.element("source", k);
+        if (element->attribute("name") == name()) {
+            src = element;
+            break;
+        }
+    }
+
+    // If the temporal model is not a constant with unit normalization then
+    // set cons to a NULL pointer
+    GModelTemporalConst* cons = dynamic_cast<GModelTemporalConst*>(temporal());
+    if (cons != NULL) {
+        if (cons->norm() != 1.0) {
+            cons = NULL;
+        }
+    }
+
+    // If no source with corresponding name was found then append one
+    if (src == NULL) {
+        src = xml.append("source");
+        if (spatial()  != NULL) src->append(GXmlElement("spatialModel"));
+        if (spectral() != NULL) src->append(GXmlElement("spectrum"));
+        if (temporal() != NULL && cons == NULL) src->append(GXmlElement("temporal"));
+    }
+
+    // Write spatial model
+    if (spatial() != NULL) {
+        GXmlElement* spat = src->element("spatialModel", 0);
+        spatial()->write(*spat);
+    }
+
+    // Write spectral model
+    if (spectral() != NULL) {
+        GXmlElement* spec = src->element("spectrum", 0);
+        spectral()->write(*spec);
+    }
+
+    // Write temporal model (only if not a constant with unit normalization
+    // factor)
+    if (temporal() != NULL && cons == NULL) {
+        GXmlElement* temp = src->element("temporal", 0);
+        temporal()->write(*temp);
+    }
+
+    // Write model attributes
+    write_attributes(*src);
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Print model information
+ *
+ * @param[in] chatter Chattiness.
+ * @return String containing model information.
+ ***************************************************************************/
+std::string GCTAModelBackground::print(const GChatter& chatter) const
+{
+    // Initialise result string
+    std::string result;
+
+    // Continue only if chatter is not silent
+    if (chatter != SILENT) {
+
+        // Append header
+        result.append("=== GCTAModelBackground ===");
+
+        // Determine number of parameters per type
+        int n_spatial  = (spatial()  != NULL) ? spatial()->size()  : 0;
+        int n_spectral = (spectral() != NULL) ? spectral()->size() : 0;
+        int n_temporal = (temporal() != NULL) ? temporal()->size() : 0;
+
+        // Append attributes
+        result.append("\n"+print_attributes());
+
+        // Append model type
+        result.append("\n"+gammalib::parformat("Model type")+type());
+
+        // Append model type
+        result.append("\n"+gammalib::parformat("Model components"));
+        if (n_spatial > 0) {
+            result.append("\""+spatial()->type()+"\"");
+            if (n_spectral > 0 || n_temporal > 0) {
+                result.append(" * ");
+            }
+        }
+        if (n_spectral > 0) {
+            result.append("\""+spectral()->type()+"\"");
+            if (n_temporal > 0) {
+                result.append(" * ");
+            }
+        }
+        if (n_temporal > 0) {
+            result.append("\""+temporal()->type()+"\"");
+        }
+
+        // Append parameters
+        result.append("\n"+gammalib::parformat("Number of parameters") +
+                      gammalib::str(size()));
+        result.append("\n"+gammalib::parformat("Number of spatial par's") +
+                      gammalib::str(n_spatial));
+        for (int i = 0; i < n_spatial; ++i) {
+            result.append("\n"+(*spatial())[i].print());
+        }
+        result.append("\n"+gammalib::parformat("Number of spectral par's") +
+                      gammalib::str(n_spectral));
+        for (int i = 0; i < n_spectral; ++i) {
+            result.append("\n"+(*spectral())[i].print());
+        }
+        result.append("\n"+gammalib::parformat("Number of temporal par's") +
+                      gammalib::str(n_temporal));
+        for (int i = 0; i < n_temporal; ++i) {
+            result.append("\n"+(*temporal())[i].print());
+        }
+
+    } // endif: chatter was not silent
+
+    // Return result
+    return result;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                            Private methods                              =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Initialise class members
+ ***************************************************************************/
+void GCTAModelBackground::init_members(void)
+{
+    // Initialise members
+    m_spatial  = NULL;
+    m_spectral = NULL;
+    m_temporal = NULL;
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy class members
+ *
+ * @param[in] model Background model.
+ ***************************************************************************/
+void GCTAModelBackground::copy_members(const GCTAModelBackground& model)
+{
+    // Clone radial, spectral and temporal model components
+    m_spatial  = (model.m_spatial  != NULL) ? model.m_spatial->clone()  : NULL;
+    m_spectral = (model.m_spectral != NULL) ? model.m_spectral->clone() : NULL;
+    m_temporal = (model.m_temporal != NULL) ? model.m_temporal->clone() : NULL;
+
+    // Set parameter pointers
+    set_pointers();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Delete class members
+ ***************************************************************************/
+void GCTAModelBackground::free_members(void)
+{
+    // Free memory
+    if (m_spatial  != NULL) delete m_spatial;
+    if (m_spectral != NULL) delete m_spectral;
+    if (m_temporal != NULL) delete m_temporal;
+
+    // Signal free pointers
+    m_spatial  = NULL;
+    m_spectral = NULL;
+    m_temporal = NULL;
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Set pointers
+ *
+ * Set pointers to all model parameters. The pointers are stored in a vector
+ * that is member of the GModelData base class.
+ ***************************************************************************/
+void GCTAModelBackground::set_pointers(void)
+{
+    // Clear parameters
+    m_pars.clear();
+
+    // Determine the number of parameters
+    int n_spatial  = (spatial()  != NULL) ? spatial()->size()  : 0;
+    int n_spectral = (spectral() != NULL) ? spectral()->size() : 0;
+    int n_temporal = (temporal() != NULL) ? temporal()->size() : 0;
+    int n_pars     = n_spatial + n_spectral + n_temporal;
+
+    // Continue only if there are parameters
+    if (n_pars > 0) {
+
+        // Gather spatial parameter pointers
+        for (int i = 0; i < n_spatial; ++i) {
+            m_pars.push_back(&((*spatial())[i]));
+        }
+
+        // Gather spectral parameters
+        for (int i = 0; i < n_spectral; ++i) {
+            m_pars.push_back(&((*spectral())[i]));
+        }
+
+        // Gather temporal parameters
+        for (int i = 0; i < n_temporal; ++i) {
+            m_pars.push_back(&((*temporal())[i]));
+        }
+
+    }
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Return pointer to spatial model from XML element
+ *
+ * @param[in] spatial XML element.
+ * @return Pointer to spatial model.
+ *
+ * Returns pointer to a radial model that is defined in an XML element.
+ ***************************************************************************/
+GCTAModelSpatial* GCTAModelBackground::xml_spatial(const GXmlElement& spatial) const
+{
+    // Get radial model
+    GCTAModelSpatialRegistry registry;
+    GCTAModelSpatial*        ptr = registry.alloc(spatial);
+
+    // Return pointer
+    return ptr;
+}
+
+
+/***********************************************************************//**
+ * @brief Return pointer to spectral model from XML element
+ *
+ * @param[in] spectral XML element.
+ * @return Pointer to spectral model.
+ *
+ * Returns pointer to spectral model that is defined in an XML element.
+ ***************************************************************************/
+GModelSpectral* GCTAModelBackground::xml_spectral(const GXmlElement& spectral) const
+{
+    // Get spectral model
+    GModelSpectralRegistry registry;
+    GModelSpectral*        ptr = registry.alloc(spectral);
+
+    // Return pointer
+    return ptr;
+}
+
+
+/***********************************************************************//**
+ * @brief Return pointer to temporal model from XML element
+ *
+ * @param[in] temporal XML element.
+ * @return Pointer to temporal model.
+ *
+ * Returns pointer to temporal model that is defined in an XML element.
+ ***************************************************************************/
+GModelTemporal* GCTAModelBackground::xml_temporal(const GXmlElement& temporal) const
+{
+    // Get temporal model
+    GModelTemporalRegistry registry;
+    GModelTemporal*        ptr = registry.alloc(temporal);
+
+    // Return pointer
+    return ptr;
+}
+
+
+/***********************************************************************//**
+ * @brief Verifies if model has all components
+ *
+ * Returns 'true' if models has a spatial, a spectral and a temporal
+ * component. Otherwise returns 'false'.
+ ***************************************************************************/
+bool GCTAModelBackground::valid_model(void) const
+{
+    // Set result
+    bool result = ((spatial()  != NULL) &&
+                   (spectral() != NULL) &&
+                   (temporal() != NULL));
+
+    // Return result
+    return result;
+}
+
+
+/***********************************************************************//**
+ * @brief Integration kernel for the Npred method
+ *
+ * @param[in] offset Offset angle (radians).
+ *
+ * Computes
+ * \f[N_{\rm pred} = \int_{\rm ROI} r(\theta) \sin \theta {\rm d}\phi\f]
+ * where
+ * \f$r(\theta)\f$ is the radial acceptance function,
+ * \f$\theta\f$ is the measured offset angle from the pointing direction
+ * in radians, and
+ * \f$\phi\f$ is the measured azimuth angle. The integration is done over
+ * the arc of the azimuth angle that lies within the ROI. This integration
+ * is done analytically using the "cta_roi_arclength" support function.
+ ***************************************************************************/
+double GCTAModelBackground::roi_kern::eval(const double& offset)
+{
+    // Circumvent const correctness
+    GCTAModelSpatial* spatial = const_cast<GCTAModelSpatial*>(m_parent);
+
+    // Initialise Npred value
+    double value = 0.0;
+
+    /*
+    // Continue only if offset > 0
+    if (offset > 0.0) {
+
+        // Get arclength for given radius in radians.
+        double phi = gammalib::cta_roi_arclength(offset,
+                                                 m_dist,
+                                                 m_cosdist,
+                                                 m_sindist,
+                                                 m_roi,
+                                                 m_cosroi);
+
+        // Get kernel value if phi > 0
+        if (phi > 0.0) {
+            value = radial->eval(offset*gammalib::rad2deg) * phi *
+                    std::sin(offset);
+        }
+
+    } // endif: offset was positive
+    */
+    
+    // Return
+    return value;
+}
 /***************************************************************************
  *         GCTAModelRadial.cpp  -  Abstract radial model base class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011 by Jurgen Knodlseder                                *
+ *  copyright (C) 2011-2018 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -21,7 +21,7 @@
 /**
  * @file GCTAModelRadial.cpp
  * @brief Abstract radial acceptance model class implementation
- * @author J. Knodlseder
+ * @author Juergen Knoedlseder
  */
 /* __ Includes ___________________________________________________________ */
@@ -31,6 +31,7 @@
 #include "GException.hpp"
 #include "GTools.hpp"
 #include "GCTAModelRadial.hpp"
+#include "GCTAInstDir.hpp"
 /* __ Method name definitions ____________________________________________ */
 #define G_ACCESS1                           "GModelSpatial::operator[](int&)"
@@ -225,6 +226,46 @@ const GModelPar&amp; GCTAModelRadial::operator[](const std::string&amp; name) const
  =                                                                         =
  ==========================================================================*/
+/***********************************************************************//**
+ * @brief Evaluate function
+ *
+ * @param[in] dir Event direction.
+ * @param[in] energy Event energy.
+ * @param[in] time Event time.
+ * @param[in] gradients Compute gradients?
+ * @return Function value
+ *
+ * @todo Implement method
+ ***************************************************************************/
+double GCTAModelRadial::eval(const GCTAInstDir& dir,
+                             const GEnergy&     energy,
+                             const GTime&       time,
+                             const bool&        gradients) const
+{
+    // Return
+    return 0.0;
+}
+
+
+/***********************************************************************//**
+ * @brief Returns MC instrument direction
+ *
+ * @param[in] energy Event energy.
+ * @param[in] time Event time.
+ * @param[in,out] ran Random number generator.
+ * @return Instrument direction
+ *
+ * @todo Implement method
+ ***************************************************************************/
+GCTAInstDir GCTAModelRadial::mc(const GEnergy& energy,
+                                const GTime&   time,
+                                GRan&          ran) const
+{
+    // Return
+    return GCTAInstDir();
+}
+
+
 /*==========================================================================
  =                                                                         =
  =                             Private methods                             =
 /***************************************************************************
  *       GCTAModelRadialGauss.cpp - Radial Gaussian CTA model class        *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011-2016 by Juergen Knoedlseder                         *
+ *  copyright (C) 2011-2018 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -32,15 +32,18 @@
 #include "GException.hpp"
 #include "GTools.hpp"
 #include "GMath.hpp"
+#include "GRan.hpp"
 #include "GIntegral.hpp"
 #include "GCTAModelRadialGauss.hpp"
 #include "GCTAModelRadialRegistry.hpp"
+#include "GCTAModelSpatialRegistry.hpp"
 /* __ Constants __________________________________________________________ */
 /* __ Globals ____________________________________________________________ */
-const GCTAModelRadialGauss    g_cta_radial_gauss_seed;
-const GCTAModelRadialRegistry g_cta_radial_gauss_registry(&g_cta_radial_gauss_seed);
+const GCTAModelRadialGauss     g_cta_radial_gauss_seed;
+const GCTAModelRadialRegistry  g_cta_radial_gauss_registry(&g_cta_radial_gauss_seed);
+const GCTAModelSpatialRegistry g_cta_radial_gauss_spatial_registry(&g_cta_radial_gauss_seed);
 /* __ Method name definitions ____________________________________________ */
 #define G_READ                     "GCTAModelRadialGauss::read(GXmlElement&)"
 /***************************************************************************
  *       GCTAModelRadialPolynom.cpp - Radial Polynom CTA model class       *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011-2016 by Juergen Knoedlseder                         *
+ *  copyright (C) 2011-2018 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -32,16 +32,19 @@
 #include "GException.hpp"
 #include "GTools.hpp"
 #include "GMath.hpp"
+#include "GRan.hpp"
 #include "GIntegral.hpp"
 #include "GCTAModelRadialPolynom.hpp"
 #include "GCTAModelRadialRegistry.hpp"
+#include "GCTAModelSpatialRegistry.hpp"
 /* __ Constants __________________________________________________________ */
 const double g_cta_radial_polynom_offset_max = 4.0;
 /* __ Globals ____________________________________________________________ */
-const GCTAModelRadialPolynom  g_cta_radial_polynom_seed;
-const GCTAModelRadialRegistry g_cta_radial_polynom_registry(&g_cta_radial_polynom_seed);
+const GCTAModelRadialPolynom   g_cta_radial_polynom_seed;
+const GCTAModelRadialRegistry  g_cta_radial_polynom_registry(&g_cta_radial_polynom_seed);
+const GCTAModelSpatialRegistry g_cta_radial_polynom_spatial_registry(&g_cta_radial_polynom_seed);
 /* __ Method name definitions ____________________________________________ */
 #define G_READ                   "GCTAModelRadialPolynom::read(GXmlElement&)"
 /***************************************************************************
  *       GCTAModelRadialProfile.cpp - Radial Profile CTA model class       *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2011-2016 by Juergen Knoedlseder                         *
+ *  copyright (C) 2011-2018 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -32,15 +32,18 @@
 #include "GException.hpp"
 #include "GTools.hpp"
 #include "GMath.hpp"
+#include "GRan.hpp"
 #include "GIntegral.hpp"
 #include "GCTAModelRadialProfile.hpp"
 #include "GCTAModelRadialRegistry.hpp"
+#include "GCTAModelSpatialRegistry.hpp"
 /* __ Constants __________________________________________________________ */
 /* __ Globals ____________________________________________________________ */
-const GCTAModelRadialProfile  g_cta_radial_profile_seed;
-const GCTAModelRadialRegistry g_cta_radial_profile_registry(&g_cta_radial_profile_seed);
+const GCTAModelRadialProfile   g_cta_radial_profile_seed;
+const GCTAModelRadialRegistry  g_cta_radial_profile_registry(&g_cta_radial_profile_seed);
+const GCTAModelSpatialRegistry g_cta_radial_profile_spatial_registry(&g_cta_radial_profile_seed);
 /* __ Method name definitions ____________________________________________ */
 #define G_READ                   "GCTAModelRadialProfile::read(GXmlElement&)"
+/***************************************************************************
+ *         GCTAModelSpatial.cpp - Spatial model abstract base class        *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2018 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 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 GCTAModelSpatial.cpp
+ * @brief Abstract spatial model class implementation
+ * @author Juergen Knoedlseder
+ */
+
+/* __ Includes ___________________________________________________________ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "GException.hpp"
+#include "GTools.hpp"
+#include "GCTAModelSpatial.hpp"
+
+/* __ Method name definitions ____________________________________________ */
+#define G_ACCESS1                           "GModelSpatial::operator[](int&)"
+#define G_ACCESS2                   "GModelSpatial::operator[](std::string&)"
+
+/* __ Macros _____________________________________________________________ */
+
+/* __ Coding definitions _________________________________________________ */
+
+/* __ Debug definitions __________________________________________________ */
+
+
+/*==========================================================================
+ =                                                                         =
+ =                        Constructors/destructors                         =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Void constructor
+ ***************************************************************************/
+GCTAModelSpatial::GCTAModelSpatial(void)
+{
+    // Initialise members
+    init_members();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy constructor
+ *
+ * @param[in] model Spatial model.
+ ***************************************************************************/
+GCTAModelSpatial::GCTAModelSpatial(const GCTAModelSpatial& model)
+{
+    // Initialise members
+    init_members();
+
+    // Copy members
+    copy_members(model);
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Destructor
+ ***************************************************************************/
+GCTAModelSpatial::~GCTAModelSpatial(void)
+{
+    // Free members
+    free_members();
+
+    // Return
+    return;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                                Operators                                =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Assignment operator
+ *
+ * @param[in] model Spatial model.
+ ***************************************************************************/
+GCTAModelSpatial& GCTAModelSpatial::operator=(const GCTAModelSpatial& model)
+{
+    // Execute only if object is not identical
+    if (this != &model) {
+
+        // Free members
+        free_members();
+
+        // Initialise members
+        init_members();
+
+        // Copy members
+        copy_members(model);
+
+    } // endif: object was not identical
+
+    // Return
+    return *this;
+}
+
+
+/***********************************************************************//**
+ * @brief Returns model parameter
+ *
+ * @param[in] index Parameter index [0,...,size()-1].
+ *
+ * @exception GException::out_of_range
+ *            Parameter index is out of range.
+ ***************************************************************************/
+GModelPar& GCTAModelSpatial::operator[](const int& index)
+{
+    // Compile option: raise exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_ACCESS1, "Spatial parameter index",
+                                       index, size());
+    }
+    #endif
+
+    // Return reference
+    return *(m_pars[index]);
+}
+
+
+/***********************************************************************//**
+ * @brief Returns model parameter (const version)
+ *
+ * @param[in] index Parameter index [0,...,size()-1].
+ *
+ * @exception GException::out_of_range
+ *            Parameter index is out of range.
+ ***************************************************************************/
+const GModelPar& GCTAModelSpatial::operator[](const int& index) const
+{
+    // Compile option: raise exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_ACCESS1, "Spatial parameter index",
+                                       index, size());
+    }
+    #endif
+
+    // Return reference
+    return *(m_pars[index]);
+}
+
+
+/***********************************************************************//**
+ * @brief Returns reference to model parameter
+ *
+ * @param[in] name Parameter name.
+ *
+ * @exception GException::invalid_argument
+ *            Parameter with specified name not found in container.
+ ***************************************************************************/
+GModelPar& GCTAModelSpatial::operator[](const std::string& name)
+{
+    // Get parameter index
+    int index = 0;
+    for (; index < size(); ++index) {
+        if (m_pars[index]->name() == name)
+            break;
+    }
+
+    // Throw exception if parameter name was not found
+    if (index >= size()) {
+        std::string msg = "Parameter \""+name+"\" not found in spatial "
+                          "component of background model.";
+        throw GException::invalid_argument(G_ACCESS2, msg);
+    }
+
+    // Return reference
+    return *(m_pars[index]);
+}
+
+
+/***********************************************************************//**
+ * @brief Returns reference to model parameter (const version)
+ *
+ * @param[in] name Parameter name.
+ *
+ * @exception GException::invalid_argument
+ *            Parameter with specified name not found in container.
+ ***************************************************************************/
+const GModelPar& GCTAModelSpatial::operator[](const std::string& name) const
+{
+    // Get parameter index
+    int index = 0;
+    for (; index < size(); ++index) {
+        if (m_pars[index]->name() == name)
+            break;
+    }
+
+    // Throw exception if parameter name was not found
+    if (index >= size()) {
+        std::string msg = "Parameter \""+name+"\" not found in spatial "
+                          "component of background model.";
+        throw GException::invalid_argument(G_ACCESS2, msg);
+    }
+
+    // Return reference
+    return *(m_pars[index]);
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                             Public methods                              =
+ =                                                                         =
+ ==========================================================================*/
+
+/*==========================================================================
+ =                                                                         =
+ =                             Private methods                             =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Initialise class members
+ ***************************************************************************/
+void GCTAModelSpatial::init_members(void)
+{
+    // Initialise members
+    m_pars.clear();
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy class members
+ *
+ * @param[in] model Spatial acceptance model.
+ ***************************************************************************/
+void GCTAModelSpatial::copy_members(const GCTAModelSpatial& model)
+{
+    // Copy members
+    m_pars = model.m_pars;
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Delete class members
+ ***************************************************************************/
+void GCTAModelSpatial::free_members(void)
+{
+    // Return
+    return;
+}
+/***************************************************************************
+ *       GCTAModelSpatialRegistry.cpp - Spatial model registry class       *
+ * ----------------------------------------------------------------------- *
+ *  copyright (C) 2018 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 GCTAModelSpatialRegistry.cpp
+ * @brief Spatial model registry class implemenation
+ * @author Juergen Knoedlseder
+ */
+
+/* __ Includes ___________________________________________________________ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "GModelPar.hpp"
+#include "GCTAModelSpatial.hpp"
+#include "GCTAModelSpatialRegistry.hpp"
+#include "GException.hpp"
+#include "GTools.hpp"
+
+/* __ Method name definitions ____________________________________________ */
+#define G_ALLOC               "GCTAModelSpatialRegistry::alloc(GXmlElement&)"
+#define G_NAME                         "GCTAModelSpatialRegistry::name(int&)"
+
+/* __ Macros _____________________________________________________________ */
+
+/* __ Coding definitions _________________________________________________ */
+
+/* __ Debug definitions __________________________________________________ */
+//#define G_DEBUG_REGISTRY        //!< Dump registry
+
+
+/*==========================================================================
+ =                                                                         =
+ =                        Constructors/destructors                         =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Void constructor
+ ***************************************************************************/
+GCTAModelSpatialRegistry::GCTAModelSpatialRegistry(void)
+{
+    // Initialise private members for clean destruction
+    init_members();
+
+    // Debug option: Show actual registry
+    #if defined(G_DEBUG_REGISTRY)
+    std::cout << "GCTAModelSpatialRegistry(void): ";
+    for (int i = 0; i < size(); ++i) {
+        std::cout << "\"" << models()[i]->type() << "\" ";
+    }
+    std::cout << std::endl;
+    #endif
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Model constructor
+ *
+ * @param[in] model Model.
+ *
+ * Construct registry by adding a model to the registry. This is the standard
+ * constructor that is used to register a new model to GammaLib.
+ ***************************************************************************/
+GCTAModelSpatialRegistry::GCTAModelSpatialRegistry(const GCTAModelSpatial* model)
+{
+    // Initialise private members for clean destruction
+    init_members();
+
+    // Debug option: Notify new registry
+    #if defined(G_DEBUG_REGISTRY)
+    std::cout << "GCTAModelSpatialRegistry(const GCTAModelSpatial*): ";
+    std::cout << "add \"" << model->type() << "\" to registry." << std::endl;
+    #endif
+
+    // Allocate new registry
+    const GCTAModelSpatial** new_models = new const GCTAModelSpatial*[size()+1];
+
+    // Save old registry
+    for (int i = 0; i < size(); ++i) {
+        new_models[i] = models()[i];
+    }
+
+    // Add new model to registry
+    new_models[size()] = model;
+
+    // Set pointers on new registry
+    models().assign(new_models);
+
+    // Increment number of models in registry
+    number()++;
+
+    // Debug option: Show actual registry
+    #if defined(G_DEBUG_REGISTRY)
+    std::cout << "GCTAModelSpatialRegistry(const GCTAModelSpatial*): ";
+    for (int i = 0; i < size(); ++i) {
+        std::cout << "\"" << models()[i]->type() << "\" ";
+    }
+    std::cout << std::endl;
+    #endif
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy constructor
+ *
+ * @param[in] registry Registry.
+ ***************************************************************************/
+GCTAModelSpatialRegistry::GCTAModelSpatialRegistry(const GCTAModelSpatialRegistry& registry)
+{
+    // Initialise private members
+    init_members();
+
+    // Copy members
+    copy_members(registry);
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Destructor
+ ***************************************************************************/
+GCTAModelSpatialRegistry::~GCTAModelSpatialRegistry(void)
+{
+    // Free members
+    free_members();
+
+    // Return
+    return;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                                Operators                                =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Assignment operator
+ *
+ * @param[in] registry Registry.
+ * @return Reference to registry.
+ ***************************************************************************/
+GCTAModelSpatialRegistry& GCTAModelSpatialRegistry::operator=(const GCTAModelSpatialRegistry& registry)
+{
+    // Execute only if object is not identical
+    if (this != &registry) {
+
+        // Free members
+        free_members();
+
+        // Initialise private members
+        init_members();
+
+        // Copy members
+        copy_members(registry);
+
+    } // endif: object was not identical
+
+    // Return
+    return *this;
+}
+
+
+/*==========================================================================
+ =                                                                         =
+ =                             Public methods                              =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Allocate spatial model that is found in XML element
+ *
+ * @param[in] xml XML element.
+ * @return Pointer to spatial model.
+ *
+ * @exception GException::invalid_value
+ *            No appropriate spatial model found in XML element.
+ *
+ * Returns a pointer to a spatial model instance that corresponds to the
+ * type found in an XML element. If no appropriate model is found the method
+ * will throw an exception.
+ ***************************************************************************/
+GCTAModelSpatial* GCTAModelSpatialRegistry::alloc(const GXmlElement& xml) const
+{
+    // Initialise spatial model
+    GCTAModelSpatial* model = NULL;
+
+    // Search for model type in registry
+    for (int i = 0; i < size(); ++i) {
+        if (models()[i]->type() == xml.attribute("type")) {
+            model = models()[i]->clone();
+            break;
+        }
+    }
+
+    // If no model has been found then throw an exception
+    if (model == NULL) {
+        std::string msg = "Spatial model of type \""+xml.attribute("type")+
+                          "\" not found in registry. Possible spatial model "
+                          "types are:";
+        for (int i = 0; i < size(); ++i) {
+            msg += " \""+models()[i]->type()+"\"";
+        }
+        msg += ".";
+        throw GException::invalid_value(G_ALLOC, msg);
+    }
+
+    // Read model from XML element
+    model->read(xml);
+
+    // Return spectral model
+    return model;
+}
+
+
+/***********************************************************************//**
+ * @brief Returns model name
+ *
+ * @param[in] index Model index [0,...,size()-1].
+ * @return Model name.
+ *
+ * @exception GException::out_of_range
+ *            Model index is out of range.
+ ***************************************************************************/
+std::string GCTAModelSpatialRegistry::name(const int& index) const
+{
+    // Compile option: raise exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_NAME, "Spatial model index", index,
+                                       size());
+    }
+    #endif
+
+    // Return name
+    return (models()[index]->type());
+}
+
+
+/***********************************************************************//**
+ * @brief Print registry information
+ *
+ * @param[in] chatter Chattiness (defaults to NORMAL).
+ * @return Registry content.
+ ***************************************************************************/
+std::string GCTAModelSpatialRegistry::print(const GChatter& chatter) const
+{
+    // Initialise result string
+    std::string result;
+
+    // Continue only if chatter is not silent
+    if (chatter != SILENT) {
+
+        // Append header
+        result.append("=== GCTAModelSpatialRegistry ===");
+
+        // Append information
+        result.append("\n"+gammalib::parformat("Number of models"));
+        result.append(gammalib::str(size()));
+
+        // NORMAL: Append models
+        if (chatter >= NORMAL) {
+            for (int i = 0; i < size(); ++i) {
+                result.append("\n"+gammalib::parformat(models()[i]->type()));
+                for (int k = 0; k < models()[i]->size(); ++k) {
+                    if (k > 0) {
+                        result.append(", ");
+                    }
+                    result.append("\"");
+                    result.append((*(models()[i]))[k].name());
+                    result.append("\"");
+                }
+            }
+        }
+
+    } // endif: chatter was not silent
+
+    // Return result
+    return result;
+}
+
+/*==========================================================================
+ =                                                                         =
+ =                             Private methods                             =
+ =                                                                         =
+ ==========================================================================*/
+
+/***********************************************************************//**
+ * @brief Initialise class members
+ ***************************************************************************/
+void GCTAModelSpatialRegistry::init_members(void)
+{
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Copy class members
+ *
+ * @param[in] registry Registry.
+ ***************************************************************************/
+void GCTAModelSpatialRegistry::copy_members(const GCTAModelSpatialRegistry& registry)
+{
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Delete class members
+ ***************************************************************************/
+void GCTAModelSpatialRegistry::free_members(void)
+{
+    // Return
+    return;
+}
+<?xml version="1.0" standalone="no"?>
+<source_library title="source library">
+  <source name="My model" type="CTABackground" instrument="CTA">
+    <spectrum type="PowerLaw">
+       <parameter name="Prefactor"   scale="1e-6" value="61.8" min="0.0"  max="1000.0" free="1"/>
+       <parameter name="Index"       scale="-1"   value="1.85" min="0.0"  max="+5.0"   free="1"/>
+       <parameter name="PivotEnergy" scale="1e6"  value="1.0"  min="0.01" max="1000.0" free="0"/>
+    </spectrum>
+    <spatialModel type="Gaussian">
+       <parameter name="Sigma" scale="1.0" value="3.0" min="0.01" max="10.0" free="1"/>
+    </spatialModel>
+  </source>
+</source_library>
@@ -47,29 +47,30 @@
 /* __ Globals ____________________________________________________________ */
 /* __ Constants __________________________________________________________ */
-const std::string datadir           = std::getenv("TEST_CTA_DATA");
-const std::string caldbdir          = datadir + "/../caldb";
-const std::string cta_caldb         = datadir + "/../../caldb";
-const std::string cta_irf           = "cta_dummy_irf";
-const std::string cta_events        = datadir+"/crab_events.fits";
-const std::string cta_events_gti    = datadir+"/crab_events_gti.fits[EVENTS2]";
-const std::string cta_cntmap        = datadir+"/crab_cntmap.fits";
-const std::string cta_bin_xml       = datadir+"/obs_binned.xml";
-const std::string cta_unbin_xml     = datadir+"/obs_unbinned.xml";
-const std::string cta_model_xml     = datadir+"/crab.xml";
-const std::string cta_rsp_xml       = datadir+"/rsp_models.xml";
-const std::string cta_cube_bgd_xml  = datadir+"/cta_model_cube_bgd.xml";
-const std::string cta_irf_bgd_xml   = datadir+"/cta_model_irf_bgd.xml";
-const std::string cta_aeff_bgd_xml  = datadir+"/cta_model_aeff_bgd.xml";
-const std::string cta_caldb_king    = cta_caldb+"/data/cta/e/bcf/IFAE20120510_50h_King";
-const std::string cta_irf_king      = "irf_file.fits";
-const std::string cta_psf_table     = caldbdir+"/psf_table.fits[PSF_2D_TABLE]";
-const std::string cta_perf_table    = caldbdir+"/cta_dummy_irf.dat";
-const std::string cta_edisp_rmf     = caldbdir+"/dc1/rmf.fits";
-const std::string cta_edisp_2D      = caldbdir+"/edisp_matrix.fits";
-const std::string cta_bgd_3D        = caldbdir+"/edisp_matrix.fits";
-const std::string cta_modbck_fit    = datadir+"/bg_test.fits";
-const std::string cta_point_table   = datadir+"/crab_pointing.fits";
+const std::string datadir               = std::getenv("TEST_CTA_DATA");
+const std::string caldbdir              = datadir + "/../caldb";
+const std::string cta_caldb             = datadir + "/../../caldb";
+const std::string cta_irf               = "cta_dummy_irf";
+const std::string cta_events            = datadir+"/crab_events.fits";
+const std::string cta_events_gti        = datadir+"/crab_events_gti.fits[EVENTS2]";
+const std::string cta_cntmap            = datadir+"/crab_cntmap.fits";
+const std::string cta_bin_xml           = datadir+"/obs_binned.xml";
+const std::string cta_unbin_xml         = datadir+"/obs_unbinned.xml";
+const std::string cta_model_xml         = datadir+"/crab.xml";
+const std::string cta_rsp_xml           = datadir+"/rsp_models.xml";
+const std::string cta_bgd_rad_gauss_xml = datadir+"/cta_model_bgd_rad_gauss.xml";
+const std::string cta_cube_bgd_xml      = datadir+"/cta_model_cube_bgd.xml";
+const std::string cta_irf_bgd_xml       = datadir+"/cta_model_irf_bgd.xml";
+const std::string cta_aeff_bgd_xml      = datadir+"/cta_model_aeff_bgd.xml";
+const std::string cta_caldb_king        = cta_caldb+"/data/cta/e/bcf/IFAE20120510_50h_King";
+const std::string cta_irf_king          = "irf_file.fits";
+const std::string cta_psf_table         = caldbdir+"/psf_table.fits[PSF_2D_TABLE]";
+const std::string cta_perf_table        = caldbdir+"/cta_dummy_irf.dat";
+const std::string cta_edisp_rmf         = caldbdir+"/dc1/rmf.fits";
+const std::string cta_edisp_2D          = caldbdir+"/edisp_matrix.fits";
+const std::string cta_bgd_3D            = caldbdir+"/edisp_matrix.fits";
+const std::string cta_modbck_fit        = datadir+"/bg_test.fits";
+const std::string cta_point_table       = datadir+"/crab_pointing.fits";
 /* __ Test files for stacked analysis (based on Prod2::South_0.5h) _______ */
 const std::string cta_stacked_xml       = datadir+"/stacked_obs.xml";
@@ -172,6 +173,8 @@ void TestGCTAModel::set(void)
     name("Test CTA models");
     // Append tests to test suite
+    append(static_cast<pfunction>(&TestGCTAModel::test_model_bgd),
+           "Test CTA background model");
     append(static_cast<pfunction>(&TestGCTAModel::test_model_cube_bgd),
            "Test CTA cube background model");
     append(static_cast<pfunction>(&TestGCTAModel::test_model_irf_bgd),
@@ -1453,6 +1456,78 @@ void TestGCTAResponse::test_edisp_integration(const GCTAEdisp&amp; edisp,
 /***********************************************************************//**
+ * @brief Test CTA background
+ ***************************************************************************/
+void TestGCTAModel::test_model_bgd(void)
+{
+    // Test void constuctor
+    test_try("Test void constuctor");
+    try {
+        GCTAModelBackground model;
+        test_try_success();
+    }
+    catch (std::exception &e) {
+        test_try_failure(e);
+    }
+
+    // Test XML constuctor
+    test_try("Test XML constuctor");
+    try {
+        GXml xml(cta_bgd_rad_gauss_xml);
+        const GXmlElement& lib = *xml.element("source_library", 0);
+        const GXmlElement& src = *lib.element("source", 0);
+        GCTAModelBackground model(src);
+        test_value(model["Prefactor"].value(), 61.8e-6);
+        test_value(model["Index"].value(), -1.85);
+        test_value(model["PivotEnergy"].value(), 1.0e6);
+        test_assert(model.is_constant(), "Model is expected to be constant.");
+        test_try_success();
+    }
+    catch (std::exception &e) {
+        test_try_failure(e);
+    }
+
+    // Test spectral constuctor
+    /*
+    test_try("Test spectral constuctor");
+    try {
+        GModelSpectralPlaw plaw(1.0, 0.0, GEnergy(1.0, "TeV"));
+        GCTAModelBackground model(plaw);
+        test_value(model["Prefactor"].value(), 1.0);
+        test_value(model["Index"].value(), 0.0);
+        test_value(model["PivotEnergy"].value(), 1.0e6);
+        test_assert(model.is_constant(), "Model is expected to be constant.");
+        test_try_success();
+    }
+    catch (std::exception &e) {
+        test_try_failure(e);
+    }
+    */
+
+    // Test XML loading of cube background
+    GModels models(cta_bgd_rad_gauss_xml);
+    GModel* model = models["My model"];
+    test_value((*model)["Prefactor"].value(), 61.8e-6);
+    test_value((*model)["Index"].value(), -1.85);
+    test_value((*model)["PivotEnergy"].value(), 1.0e6);
+    test_assert(model->is_constant(), "Model is expected to be constant.");
+
+    // Test XML saving and reloading of cube background
+    models.save("test.xml");
+    models.load("test.xml");
+    model = models["My model"];
+    test_value((*model)["Prefactor"].value(), 61.8e-6);
+    test_value((*model)["Index"].value(), -1.85);
+    test_value((*model)["PivotEnergy"].value(), 1.0e6);
+    test_assert(model->is_constant(), "Model is expected to be constant.");
+
+    // Return
+    return;
+
+}
+
+
+/***********************************************************************//**
  * @brief Test CTA cube background
  ***************************************************************************/
 void TestGCTAModel::test_model_cube_bgd(void)
@@ -118,6 +118,7 @@ public:
     virtual void           set(void);
     virtual TestGCTAModel* clone(void) const { return new TestGCTAModel(*this); }
     virtual std::string    classname(void) const { return "TestGCTAModel"; }
+    void                   test_model_bgd(void);
     void                   test_model_cube_bgd(void);
     void                   test_model_irf_bgd(void);
     void                   test_model_aeff_bgd(void);