Make use of effective area classes in response.

The CTA response class makes now use of the GCTAAeff classes to handle the effective area response. The GCTAResponse::load_aeff() method automatically detects the response type, allocates the appropriate GCTAAeff derived class, and loads the response information. The GCTAObservation::read() and GCTAObservation::write() method also handle now transparently all 3 effective area response formats. Only the effective area correction for ARF response files is not yet implemented. This will be done once the response factorization has also be applied for the point spread function.

Make use of effective area classes in response.
The CTA response class makes now use of the GCTAAeff classes to handle the effective area response. The GCTAResponse::load_aeff() method automatically detects the response type, allocates the appropriate GCTAAeff derived class, and loads the response information. The GCTAObservation::read() and GCTAObservation::write() method also handle now transparently all 3 effective area response formats. Only the effective area correction for ARF response files is not yet implemented. This will be done once the response factorization has also be applied for the point spread function.
Jürgen Knödlseder
1 parent 19469fd7
Showing 15 changed files with 400 additions and 359 deletions
inst/cta/include/GCTAAeff.hpp
inst/cta/include/GCTAAeff2D.hpp
inst/cta/include/GCTAAeffArf.hpp
inst/cta/include/GCTAAeffPerfTable.hpp
inst/cta/include/GCTAResponse.hpp
inst/cta/pyext/GCTAAeff.i
inst/cta/pyext/GCTAAeff2D.i
inst/cta/pyext/GCTAAeffArf.i
inst/cta/pyext/GCTAAeffPerfTable.i
inst/cta/pyext/GCTAResponse.i
inst/cta/src/GCTAAeff2D.cpp
inst/cta/src/GCTAAeffArf.cpp
inst/cta/src/GCTAAeffPerfTable.cpp
inst/cta/src/GCTAObservation.cpp
inst/cta/src/GCTAResponse.cpp
@@ -52,6 +52,8 @@ public:
     virtual double operator()(const double& logE, 
                               const double& theta = 0.0, 
                               const double& phi = 0.0,
+                              const double& zenith = 0.0,
+                              const double& azimuth = 0.0,
                               const bool&   etrue = true) const = 0;
     // Operators
@@ -61,6 +63,7 @@ public:
     virtual void        clear(void) = 0;
     virtual GCTAAeff*   clone(void) const = 0;
     virtual void        load(const std::string& filename) = 0;
+    virtual std::string filename(void) const = 0;
     virtual std::string print(void) const = 0;
 protected:
@@ -56,12 +56,15 @@ public:
     double operator()(const double& logE, 
                       const double& theta = 0.0, 
                       const double& phi = 0.0,
+                      const double& zenith = 0.0,
+                      const double& azimuth = 0.0,
                       const bool&   etrue = true) const;
     // Implemented pure virtual methods
     void        clear(void);
     GCTAAeff2D* clone(void) const;
     void        load(const std::string& filename);
+    std::string filename(void) const;
     std::string print(void) const;
     // Methods
@@ -74,7 +77,8 @@ private:
     void free_members(void);
     // Members
-    GCTAResponseTable m_aeff;    //!< Aeff response table
+    std::string       m_filename;  //!< Name of Aeff response file
+    GCTAResponseTable m_aeff;      //!< Aeff response table
 };
 #endif /* GCTAAEFF2D_HPP */
@@ -58,18 +58,21 @@ public:
     double operator()(const double& logE, 
                       const double& theta = 0.0, 
                       const double& phi = 0.0,
+                      const double& zenith = 0.0,
+                      const double& azimuth = 0.0,
                       const bool&   etrue = true) const;
     // Implemented pure virtual methods
     void         clear(void);
     GCTAAeffArf* clone(void) const;
     void         load(const std::string& filename);
+    std::string  filename(void) const;
     std::string  print(void) const;
     // Methods
     int           size(void) const { return m_logE.size(); }
-    void          offset_sigma(const double& sigma) { m_offset_sigma=sigma; }
-    const double& offset_sigma(void) const { return m_offset_sigma; }
+    void          sigma(const double& sigma) { m_sigma=sigma; }
+    const double& sigma(void) const { return m_sigma; }
     void          thetacut(const double& thetacut) { m_thetacut=thetacut; }
     const double& thetacut(void) const { return m_thetacut; }
     void          scale(const double& scale) { m_scale=scale; }
@@ -83,11 +86,12 @@ private:
     void free_members(void);
     // Members
-    GNodeArray          m_logE;         //!< log(E) nodes for Aeff interpolation
-    std::vector<double> m_aeff;         //!< Effective area in cm2
-    double              m_offset_sigma; //!< Sigma for offset angle computation (0=none)
-    double              m_thetacut;     //!< Theta cut for ARF
-    double              m_scale;        //!< Scale for ARF
+    std::string         m_filename;  //!< Name of Aeff response file
+    GNodeArray          m_logE;      //!< log(E) nodes for Aeff interpolation
+    std::vector<double> m_aeff;      //!< Effective area in cm2
+    double              m_sigma;     //!< Sigma for offset angle computation (0=none)
+    double              m_thetacut;  //!< Theta cut for ARF
+    double              m_scale;     //!< Scale for ARF
 };
 #endif /* GCTAAEFFARF_HPP */
@@ -58,18 +58,21 @@ public:
     double operator()(const double& logE, 
                       const double& theta = 0.0, 
                       const double& phi = 0.0,
+                      const double& zenith = 0.0,
+                      const double& azimuth = 0.0,
                       const bool&   etrue = true) const;
     // Implemented pure virtual methods
     void               clear(void);
     GCTAAeffPerfTable* clone(void) const;
     void               load(const std::string& filename);
+    std::string        filename(void) const;
     std::string        print(void) const;
     // Methods
-    int            size(void) const { return m_logE.size(); }
-    void           offset_sigma(const double& sigma) { m_offset_sigma=sigma; }
-    const double&  offset_sigma(void) const { return m_offset_sigma; }
+    int           size(void) const { return m_logE.size(); }
+    void          sigma(const double& sigma) { m_sigma=sigma; }
+    const double& sigma(void) const { return m_sigma; }
 private:
     // Methods
@@ -78,9 +81,10 @@ private:
     void free_members(void);
     // Members
-    GNodeArray          m_logE;         //!< log(E) nodes for Aeff interpolation
-    std::vector<double> m_aeff;         //!< Effective area in cm2
-    double              m_offset_sigma; //!< Sigma for offset angle computation (0=none)
+    std::string         m_filename;  //!< Name of Aeff response file
+    GNodeArray          m_logE;      //!< log(E) nodes for Aeff interpolation
+    std::vector<double> m_aeff;      //!< Effective area in cm2
+    double              m_sigma;     //!< Sigma for offset angle computation (0=none)
 };
 #endif /* GCTAAEFFPERFTABLE_HPP */
@@ -55,6 +55,7 @@
 #include "GCTAEventAtom.hpp"
 #include "GCTADir.hpp"
 #include "GCTAResponseTable.hpp"
+#include "GCTAAeff.hpp"
 /* __ Type definitions ___________________________________________________ */
 typedef std::vector<double> GCTAPsfPars;
@@ -136,26 +137,25 @@ public:
                                  const GObservation&        obs) const;
     // Other Methods
-    GCTAEventAtom* mc(const double& area, const GPhoton& photon,
-                      const GObservation& obs, GRan& ran) const;
-    void           caldb(const std::string& caldb);
-    std::string    caldb(void) const { return m_caldb; }
-    void           load(const std::string& rspname);
-    void           eps(const double& eps) { m_eps=eps; }
-    const double&  eps(void) const { return m_eps; }
-    void           offset_sigma(const double& sigma) { m_offset_sigma=sigma; }
-    const double&  offset_sigma(void) const { return m_offset_sigma; }
-    std::string    arffile(void) const { return m_arffile; }
-    std::string    rmffile(void) const { return m_rmffile; }
-    std::string    psffile(void) const { return m_psffile; }
-    double         arf_thetacut(void) const { return m_arf_thetacut; }
-    double         arf_scale(void) const { return m_arf_scale; }
-    void           arf_thetacut(const double& value) { m_arf_thetacut=value; }
-    void           arf_scale(const double& value) { m_arf_scale=value; }
-    void           load_arf(const std::string& filename);
-    void           load_psf(const std::string& filename);
-    void           read_arf(const GFitsTable* hdu);
-    void           read_psf(const GFitsTable* hdu);
+    GCTAEventAtom*  mc(const double& area, const GPhoton& photon,
+                       const GObservation& obs, GRan& ran) const;
+    void            caldb(const std::string& caldb);
+    std::string     caldb(void) const { return m_caldb; }
+    void            load(const std::string& rspname);
+    void            eps(const double& eps) { m_eps=eps; }
+    const double&   eps(void) const { return m_eps; }
+    void            offset_sigma(const double& sigma) { m_offset_sigma=sigma; }
+    const double&   offset_sigma(void) const { return m_offset_sigma; }
+    std::string     rmffile(void) const { return m_rmffile; }
+    std::string     psffile(void) const { return m_psffile; }
+    void            read_psf(const GFitsTable* hdu);
+    
+    // New factorisation
+    void            load_aeff(const std::string& filename);
+    void            load_psf(const std::string& filename);
+    void            load_edisp(const std::string& filename) {}
+    const GCTAAeff* aeff(void) const { return m_aeff; }
+    void            aeff(GCTAAeff* aeff) { m_aeff=aeff; }
     // Low-level response methods
     double aeff(const double& theta,
@@ -208,15 +208,10 @@ private:
     // Private data members
     std::string         m_caldb;        //!< Name of or path to the calibration database
     std::string         m_rspname;      //!< Name of the instrument response
-    std::string         m_arffile;      //!< Name of ARF file
     std::string         m_rmffile;      //!< Name of RMF file
     std::string         m_psffile;      //!< Name of PSF file
-    double              m_arf_thetacut; //!< Theta cut for ARF
-    double              m_arf_scale;    //!< Scale for ARF
     GNodeArray          m_psf_logE;     //!< log(E) nodes for PSF interpolation
-    GNodeArray          m_aeff_logE;    //!< log(E) nodes for Aeff interpolation
     std::vector<double> m_logE;         //!< log(E) = log10(E/TeV) - bin centre
-    std::vector<double> m_aeff;         //!< Effective area in cm2 after all cuts
     std::vector<double> m_r68;          //!< 68% containment radius of PSF post cuts in degrees
     std::vector<double> m_r80;          //!< 80% containment radius of PSF post cuts in degrees
     double              m_eps;          //!< Integration precision
@@ -225,6 +220,9 @@ private:
     // New PSF handling
     int                 m_psf_version;  //!< PSF version
     GCTAResponseTable   m_psf_table;    //!< PSF response table
+
+    // New PSF factorisation
+    GCTAAeff*           m_aeff;         //!< Effective area component
 };
 #endif /* GCTARESPONSE_HPP */
@@ -47,12 +47,15 @@ public:
     virtual double operator()(const double& logE, 
                               const double& theta = 0.0, 
                               const double& phi = 0.0,
+                              const double& zenith = 0.0,
+                              const double& azimuth = 0.0,
                               const bool&   etrue = true) const = 0;
     // Pure virtual methods
-    virtual void      clear(void) = 0;
-    virtual GCTAAeff* clone(void) const = 0;
-    virtual void      load(const std::string& filename) = 0;
+    virtual void        clear(void) = 0;
+    virtual GCTAAeff*   clone(void) const = 0;
+    virtual void        load(const std::string& filename) = 0;
+    virtual std::string filename(void) const = 0;
 };
@@ -49,12 +49,15 @@ public:
     double operator()(const double& logE, 
                       const double& theta = 0.0, 
                       const double& phi = 0.0,
+                      const double& zenith = 0.0,
+                      const double& azimuth = 0.0,
                       const bool&   etrue = true) const;
     // Implemented pure virtual methods
     void        clear(void);
     GCTAAeff2D* clone(void) const;
     void        load(const std::string& filename);
+    std::string filename(void) const;
     // Methods
     void read(const GFits* file);
@@ -49,17 +49,20 @@ public:
     double operator()(const double& logE, 
                       const double& theta = 0.0, 
                       const double& phi = 0.0,
+                      const double& zenith = 0.0,
+                      const double& azimuth = 0.0,
                       const bool&   etrue = true) const;
     // Implemented pure virtual methods
     void         clear(void);
     GCTAAeffArf* clone(void) const;
     void         load(const std::string& filename);
+    std::string  filename(void) const;
     // Methods
     int           size(void) const;
-    void          offset_sigma(const double& sigma);
-    const double& offset_sigma(void) const;
+    void          sigma(const double& sigma);
+    const double& sigma(void) const;
     void          thetacut(const double& thetacut);
     const double& thetacut(void) const;
     void          scale(const double& scale);
@@ -49,17 +49,20 @@ public:
     double operator()(const double& logE, 
                       const double& theta = 0.0, 
                       const double& phi = 0.0,
+                      const double& zenith = 0.0,
+                      const double& azimuth = 0.0,
                       const bool&   etrue = true) const;
     // Implemented pure virtual methods
     void               clear(void);
     GCTAAeffPerfTable* clone(void) const;
     void               load(const std::string& filename);
+    std::string        filename(void) const;
     // Methods
     int            size(void) const;
-    void           offset_sigma(const double& sigma);
-    const double&  offset_sigma(void) const;
+    void           sigma(const double& sigma);
+    const double&  sigma(void) const;
 };
@@ -85,26 +85,20 @@ public:
                                  const GObservation&        obs) const;
     // Other Methods
-    GCTAEventAtom* mc(const double& area, const GPhoton& photon,
-                      const GObservation& obs, GRan& ran) const;
-    void           caldb(const std::string& caldb);
-    std::string    caldb(void) const;
-    void           load(const std::string& rspname);
-    void           eps(const double& eps);
-    const double&  eps(void) const;
-    void           offset_sigma(const double& sigma);
-    const double&  offset_sigma(void) const;
-    std::string    arffile(void) const;
-    std::string    rmffile(void) const;
-    std::string    psffile(void) const;
-    double         arf_thetacut(void) const;
-    double         arf_scale(void) const;
-    void           arf_thetacut(const double& value);
-    void           arf_scale(const double& value);
-    void           load_arf(const std::string& filename);
-    void           load_psf(const std::string& filename);
-    void           read_arf(const GFitsTable* hdu);
-    void           read_psf(const GFitsTable* hdu);
+    GCTAEventAtom*  mc(const double& area, const GPhoton& photon,
+                       const GObservation& obs, GRan& ran) const;
+    void            caldb(const std::string& caldb);
+    std::string     caldb(void) const;
+    void            load(const std::string& rspname);
+    void            eps(const double& eps);
+    const double&   eps(void) const;
+    void            offset_sigma(const double& sigma);
+    const double&   offset_sigma(void) const;
+    void            load_aeff(const std::string& filename);
+    void            load_psf(const std::string& filename);
+    void            load_edisp(const std::string& filename);
+    const GCTAAeff* aeff(void) const;
+    void            aeff(GCTAAeff* aeff);
     // Low-level response methods
     double aeff(const double& theta,
@@ -28,7 +28,6 @@
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
-//#include <cmath>
 #include "GTools.hpp"
 #include "GFitsTable.hpp"
 #include "GCTAAeff2D.hpp"
@@ -155,8 +154,10 @@ GCTAAeff2D&amp; GCTAAeff2D::operator= (const GCTAAeff2D&amp; aeff)
  * @brief Return effective area in units of cm2
  *
  * @param[in] logE Log10 of the true photon energy (TeV).
- * @param[in] theta Offset angle (rad). Defaults to 0.0.
- * @param[in] phi Azimuth angle (rad). Not used in this method.
+ * @param[in] theta Offset angle in camera system (rad). Defaults to 0.0.
+ * @param[in] phi Azimuth angle in camera system (rad). Not used in this method.
+ * @param[in] zenith Zenith angle in Earth system (rad). Not used in this method.
+ * @param[in] azimuth Azimuth angle in Earth system (rad). Not used in this method.
  * @param[in] etrue Use true energy (true/false). Defaults to true.
  *
  * Returns the effective area in units of cm2 for a given energy and
@@ -172,6 +173,8 @@ GCTAAeff2D&amp; GCTAAeff2D::operator= (const GCTAAeff2D&amp; aeff)
 double GCTAAeff2D::operator()(const double& logE, 
                               const double& theta, 
                               const double& phi,
+                              const double& zenith,
+                              const double& azimuth,
                               const bool&   etrue) const
 {
     // Set parameter index
@@ -242,12 +245,30 @@ void GCTAAeff2D::load(const std::string&amp; filename)
     // Read effective area from file
     read(&fits);
+    // Close FITS file
+    fits.close();
+
+    // Store filename
+    m_filename = filename;
+
     // Return
     return;
 }
 /***********************************************************************//**
+ * @brief Return filename
+ *
+ * @return Returns filename from which effective area was loaded
+ ***************************************************************************/
+std::string GCTAAeff2D::filename(void) const
+{
+    // Return filename
+    return m_filename;
+}
+
+
+/***********************************************************************//**
  * @brief Read effective area from FITS file
  *
  * @param[in] fits FITS file pointer.
@@ -258,8 +279,8 @@ void GCTAAeff2D::load(const std::string&amp; filename)
  ***************************************************************************/
 void GCTAAeff2D::read(const GFits* fits)
 {
-    // Clear instance
-    clear();
+    // Clear response table
+    m_aeff.clear();
     // Get pointer to effective area HDU
     GFitsTable* hdu = fits->table("EFFECTIVE AREA");
@@ -302,6 +323,7 @@ std::string GCTAAeff2D::print(void) const
     // Append header
     result.append("=== GCTAAeff2D ===");
+    result.append("\n"+parformat("Filename")+m_filename);
     result.append("\n"+parformat("Number of energy bins")+str(m_aeff.axis(0)));
     result.append("\n"+parformat("Number of offset bins")+str(m_aeff.axis(1)));
     result.append("\n"+parformat("Log10(Energy) range"));
@@ -326,6 +348,7 @@ std::string GCTAAeff2D::print(void) const
 void GCTAAeff2D::init_members(void)
 {
     // Initialise members
+    m_filename.clear();
     m_aeff.clear();
     // Return
@@ -341,7 +364,8 @@ void GCTAAeff2D::init_members(void)
 void GCTAAeff2D::copy_members(const GCTAAeff2D& aeff)
 {
     // Copy members
-    m_aeff = aeff.m_aeff;
+    m_filename = aeff.m_filename;
+    m_aeff     = aeff.m_aeff;
     // Return
     return;
@@ -157,8 +157,10 @@ GCTAAeffArf&amp; GCTAAeffArf::operator= (const GCTAAeffArf&amp; aeff)
  * @brief Return effective area in units of cm2
  *
  * @param[in] logE Log10 of the true photon energy (TeV).
- * @param[in] theta Offset angle (rad). Defaults to 0.0.
- * @param[in] phi Azimuth angle (rad). Not used.
+ * @param[in] theta Offset angle in camera system (rad). Defaults to 0.0.
+ * @param[in] phi Azimuth angle in camera system (rad). Not used in this method.
+ * @param[in] zenith Zenith angle in Earth system (rad). Not used in this method.
+ * @param[in] azimuth Azimuth angle in Earth system (rad). Not used in this method.
  * @param[in] etrue Use true energy (true/false). Not used.
  *
  * Returns the effective area in units of cm2 for a given energy and
@@ -167,9 +169,11 @@ GCTAAeffArf&amp; GCTAAeffArf::operator= (const GCTAAeffArf&amp; aeff)
  * becomes negative.
  ***************************************************************************/
 double GCTAAeffArf::operator()(const double& logE, 
-                                     const double& theta, 
-                                     const double& phi,
-                                     const bool&   etrue) const
+                               const double& theta, 
+                               const double& phi,
+                               const double& zenith,
+                               const double& azimuth,
+                               const bool&   etrue) const
 {
     // Get effective area value in cm2
     double aeff = m_logE.interpolate(logE, m_aeff);
@@ -180,9 +184,9 @@ double GCTAAeffArf::operator()(const double&amp; logE,
     }
     // Optionally add in Gaussian offset angle dependence
-    if (m_offset_sigma != 0.0) {
+    if (m_sigma != 0.0) {
         double offset = theta * rad2deg;
-        double arg    = offset * offset / m_offset_sigma;
+        double arg    = offset * offset / m_sigma;
         double scale  = exp(-0.5 * arg * arg);
         aeff         *= scale;
     }
@@ -242,10 +246,6 @@ GCTAAeffArf* GCTAAeffArf::clone(void) const
  ***************************************************************************/
 void GCTAAeffArf::load(const std::string& filename)
 {
-    // Clear arrays
-    m_logE.clear();
-    m_aeff.clear();
-
     // Open ARF FITS file
     GFits file(filename);
@@ -258,12 +258,27 @@ void GCTAAeffArf::load(const std::string&amp; filename)
     // Close ARF FITS file
     file.close();
+    // Store filename
+    m_filename = filename;
+
     // Return
     return;
 }
 /***********************************************************************//**
+ * @brief Return filename
+ *
+ * @return Returns filename from which effective area was loaded
+ ***************************************************************************/
+std::string GCTAAeffArf::filename(void) const
+{
+    // Return filename
+    return m_filename;
+}
+
+
+/***********************************************************************//**
  * @brief Read CTA ARF vector
  *
  * @param[in] hdu FITS table pointer.
@@ -388,7 +403,7 @@ void GCTAAeffArf::read_arf(const GFitsTable* hdu)
     } // endfor: looped over nodes
     // Disable offset angle dependence
-    m_offset_sigma = 0.0;
+    m_sigma = 0.0;
     // Return
     return;
@@ -411,16 +426,17 @@ std::string GCTAAeffArf::print(void) const
     // Append information
     result.append("=== GCTAAeffArf ===");
+    result.append("\n"+parformat("Filename")+m_filename);
     result.append("\n"+parformat("Number of energy bins")+str(size()));
     result.append("\n"+parformat("Log10(Energy) range"));
     result.append(str(emin)+" - "+str(emax)+" TeV");
     // Append offset angle dependence
-    if (m_offset_sigma == 0) {
+    if (m_sigma == 0) {
         result.append("\n"+parformat("Offset angle dependence")+"none");
     }
     else {
-        std::string txt = "Fixed sigma="+str(m_offset_sigma);
+        std::string txt = "Fixed sigma="+str(m_sigma);
         result.append("\n"+parformat("Offset angle dependence")+txt);
     }
@@ -441,11 +457,12 @@ std::string GCTAAeffArf::print(void) const
 void GCTAAeffArf::init_members(void)
 {
     // Initialise members
+    m_filename.clear();
     m_logE.clear();
     m_aeff.clear();
-    m_offset_sigma = 3.0;
-    m_thetacut     = 0.0;
-    m_scale        = 1.0;
+    m_sigma    = 0.0;
+    m_thetacut = 0.0;
+    m_scale    = 1.0;
     // Return
     return;
@@ -460,11 +477,12 @@ void GCTAAeffArf::init_members(void)
 void GCTAAeffArf::copy_members(const GCTAAeffArf& aeff)
 {
     // Copy members
-    m_logE         = aeff.m_logE;
-    m_aeff         = aeff.m_aeff;
-    m_offset_sigma = aeff.m_offset_sigma;
-    m_thetacut     = aeff.m_thetacut;
-    m_scale        = aeff.m_scale;
+    m_filename = aeff.m_filename;
+    m_logE     = aeff.m_logE;
+    m_aeff     = aeff.m_aeff;
+    m_sigma    = aeff.m_sigma;
+    m_thetacut = aeff.m_thetacut;
+    m_scale    = aeff.m_scale;
     // Return
     return;
@@ -157,8 +157,10 @@ GCTAAeffPerfTable&amp; GCTAAeffPerfTable::operator= (const GCTAAeffPerfTable&amp; aeff)
  * @brief Return effective area in units of cm2
  *
  * @param[in] logE Log10 of the true photon energy (TeV).
- * @param[in] theta Offset angle (rad). Defaults to 0.0.
- * @param[in] phi Azimuth angle (rad). Not used.
+ * @param[in] theta Offset angle in camera system (rad). Defaults to 0.0.
+ * @param[in] phi Azimuth angle in camera system (rad). Not used in this method.
+ * @param[in] zenith Zenith angle in Earth system (rad). Not used in this method.
+ * @param[in] azimuth Azimuth angle in Earth system (rad). Not used in this method.
  * @param[in] etrue Use true energy (true/false). Not used.
  *
  * Returns the effective area in units of cm2 for a given energy and
@@ -169,6 +171,8 @@ GCTAAeffPerfTable&amp; GCTAAeffPerfTable::operator= (const GCTAAeffPerfTable&amp; aeff)
 double GCTAAeffPerfTable::operator()(const double& logE, 
                                      const double& theta, 
                                      const double& phi,
+                                     const double& zenith,
+                                     const double& azimuth,
                                      const bool&   etrue) const
 {
     // Get effective area value in cm2
@@ -180,9 +184,9 @@ double GCTAAeffPerfTable::operator()(const double&amp; logE,
     }
     // Optionally add in Gaussian offset angle dependence
-    if (m_offset_sigma != 0.0) {
+    if (m_sigma != 0.0) {
         double offset = theta * rad2deg;
-        double arg    = offset * offset / m_offset_sigma;
+        double arg    = offset * offset / m_sigma;
         double scale  = exp(-0.5 * arg * arg);
         aeff         *= scale;
     }
@@ -283,12 +287,27 @@ void GCTAAeffPerfTable::load(const std::string&amp; filename)
     } // endwhile: looped over lines
+    // Store filename
+    m_filename = filename;
+
     // Return
     return;
 }
 /***********************************************************************//**
+ * @brief Return filename
+ *
+ * @return Returns filename from which effective area was loaded
+ ***************************************************************************/
+std::string GCTAAeffPerfTable::filename(void) const
+{
+    // Return filename
+    return m_filename;
+}
+
+
+/***********************************************************************//**
  * @brief Print effective area information
  *
  * @return Content of effective area instance.
@@ -304,16 +323,17 @@ std::string GCTAAeffPerfTable::print(void) const
     // Append information
     result.append("=== GCTAAeffPerfTable ===");
+    result.append("\n"+parformat("Filename")+m_filename);
     result.append("\n"+parformat("Number of energy bins")+str(size()));
     result.append("\n"+parformat("Log10(Energy) range"));
     result.append(str(emin)+" - "+str(emax)+" TeV");
     // Append offset angle dependence
-    if (m_offset_sigma == 0) {
+    if (m_sigma == 0) {
         result.append("\n"+parformat("Offset angle dependence")+"none");
     }
     else {
-        std::string txt = "Fixed sigma="+str(m_offset_sigma);
+        std::string txt = "Fixed sigma="+str(m_sigma);
         result.append("\n"+parformat("Offset angle dependence")+txt);
     }
@@ -334,9 +354,10 @@ std::string GCTAAeffPerfTable::print(void) const
 void GCTAAeffPerfTable::init_members(void)
 {
     // Initialise members
+    m_filename.clear();
     m_logE.clear();
     m_aeff.clear();
-    m_offset_sigma = 3.0;
+    m_sigma = 3.0;
     // Return
     return;
@@ -351,9 +372,10 @@ void GCTAAeffPerfTable::init_members(void)
 void GCTAAeffPerfTable::copy_members(const GCTAAeffPerfTable& aeff)
 {
     // Copy members
-    m_logE         = aeff.m_logE;
-    m_aeff         = aeff.m_aeff;
-    m_offset_sigma = aeff.m_offset_sigma;
+    m_filename = aeff.m_filename;
+    m_logE     = aeff.m_logE;
+    m_aeff     = aeff.m_aeff;
+    m_sigma    = aeff.m_sigma;
     // Return
     return;
@@ -29,17 +29,21 @@
 #include <config.h>
 #endif
 #include "GObservationRegistry.hpp"
-#include "GCTAException.hpp"
-#include "GCTAObservation.hpp"
-#include "GCTAEventList.hpp"
-#include "GCTAEventCube.hpp"
-#include "GCTARoi.hpp"
 #include "GException.hpp"
 #include "GFits.hpp"
 #include "GTools.hpp"
 #include "GModelSpatialPtsrc.hpp"
 #include "GIntegral.hpp"
 #include "GIntegrand.hpp"
+#include "GCTAException.hpp"
+#include "GCTAObservation.hpp"
+#include "GCTAEventList.hpp"
+#include "GCTAEventCube.hpp"
+#include "GCTARoi.hpp"
+#include "GCTAAeff.hpp"
+#include "GCTAAeff2D.hpp"
+#include "GCTAAeffArf.hpp"
+#include "GCTAAeffPerfTable.hpp"
 /* __ Globals ____________________________________________________________ */
 const GCTAObservation      g_obs_cta_seed("CTA");
@@ -339,18 +343,18 @@ void GCTAObservation::pointing(const GCTAPointing&amp; pointing)
  * for a binned observation.
  *
  * @todo Still supports old ARF, PSF and RMF parameter names.
+ * @todo PSF correction for ARF not yet implemented.
  ***************************************************************************/
 void GCTAObservation::read(const GXmlElement& xml)
 {
     // Clear observation
     clear();
-    // Initialise response parameters
-    std::string aeff;
-    std::string psf;
-    std::string rmf;
-    double      thetacut = 0.0;
-    double      scale    = 1.0;
+    // Delete old response function
+    if (m_response != NULL) delete m_response;
+
+    // Allocate new CTA response function
+    m_response = new GCTAResponse;
     // Extract instrument name
     m_instrument = xml.attribute("instrument");
@@ -401,20 +405,53 @@ void GCTAObservation::read(const GXmlElement&amp; xml)
         else if ((par->attribute("name") == "EffectiveArea") ||
                  (par->attribute("name") == "ARF")) {
-            // Store filename
-            aeff = par->attribute("file");
+            // Get filename
+            std::string filename = par->attribute("file");
-            // Optionally extract thetacut (0.0 if no thetacut)
-            std::string s_thetacut = par->attribute("thetacut");
-            if (s_thetacut.length() > 0) {
-                thetacut = todouble(s_thetacut);
-            }
-
-            // Optionally extract scale factor (1.0 if no scale)
-            std::string s_scale = par->attribute("scale");
-            if (s_scale.length() > 0) {
-                scale = todouble(s_scale);
-            }
+            // If filename is not empty then load effective area
+            if (strip_whitespace(filename).length() > 0) {
+
+                // Load effective area
+                m_response->load_aeff(filename);
+
+                // Optional attributes
+                double thetacut = 0.0;
+                double scale    = 1.0;
+                double sigma    = 0.0;
+
+                // Optionally extract thetacut (0.0 if no thetacut)
+                std::string s_thetacut = par->attribute("thetacut");
+                if (s_thetacut.length() > 0) {
+                    thetacut = todouble(s_thetacut);
+                }
+
+                // Optionally extract scale factor (1.0 if no scale)
+                std::string s_scale = par->attribute("scale");
+                if (s_scale.length() > 0) {
+                    scale = todouble(s_scale);
+                }
+
+                // Optionally extract sigma (0.0 if no sigma)
+                std::string s_sigma = par->attribute("sigma");
+                if (s_sigma.length() > 0) {
+                    sigma = todouble(s_sigma);
+                }
+
+                // If we have an ARF then set attributes
+                GCTAAeffArf* arf = const_cast<GCTAAeffArf*>(dynamic_cast<const GCTAAeffArf*>(m_response->aeff()));
+                if (arf != NULL) {
+                    arf->thetacut(thetacut);
+                    arf->scale(scale);
+                    arf->sigma(sigma);
+                }
+
+                // If we have a performance table then set attributes
+                GCTAAeffPerfTable* perf = const_cast<GCTAAeffPerfTable*>(dynamic_cast<const GCTAAeffPerfTable*>(m_response->aeff()));
+                if (perf != NULL) {
+                    perf->sigma(sigma);
+                }
+
+            } // endif: effective area filename was valid
             // Increase number of parameters
             npar[1]++;
@@ -423,7 +460,16 @@ void GCTAObservation::read(const GXmlElement&amp; xml)
         // Handle PSF
         else if ((par->attribute("name") == "PointSpreadFunction") ||
                  (par->attribute("name") == "PSF")) {
-            psf = par->attribute("file");
+
+            // Get filename
+            std::string filename = par->attribute("file");
+
+            // If filename is not empty then load point spread function
+            if (strip_whitespace(filename).length() > 0) {
+                m_response->load_psf(filename);
+            }
+
+            // Increase number of parameters
             npar[2]++;
         }
@@ -431,7 +477,16 @@ void GCTAObservation::read(const GXmlElement&amp; xml)
         // Handle RMF
         else if ((par->attribute("name") == "EnergyDispersion") ||
                  (par->attribute("name") == "RMF")) {
-            rmf = par->attribute("file");
+
+            // Get filename
+            std::string filename = par->attribute("file");
+
+            // If filename is not empty then load energy dispersion
+            if (strip_whitespace(filename).length() > 0) {
+                m_response->load_edisp(filename);
+            }
+
+            // Increase number of parameters
             npar[3]++;
         }
@@ -444,22 +499,14 @@ void GCTAObservation::read(const GXmlElement&amp; xml)
               ", \"PointSpreadFunction\" and \"EnergyDispersion\" parameters.");
     }
-    // Delete old response function
-    if (m_response != NULL) delete m_response;
-
-    // Allocate new CTA response function
-    m_response = new GCTAResponse;
-
-    // Load PSF (need this before Aeff to handle thetacut)
-    if (strip_whitespace(psf).length() > 0) {
-        m_response->load_psf(psf);
-    }
-
-    // Load effective area
-    if (strip_whitespace(aeff).length() > 0) {
-        m_response->arf_thetacut(thetacut);
-        m_response->arf_scale(scale);
-        m_response->load_arf(aeff);
+    // If we have an ARF then apply effective area correction if necessary
+    GCTAAeffArf* arf = const_cast<GCTAAeffArf*>(dynamic_cast<const GCTAAeffArf*>(m_response->aeff()));
+    if (arf != NULL) {
+        if (arf->thetacut() > 0.0) {
+            // TODO
+            // Loop over all energies in ARF vector, determine PSF integral,
+            // and perform correction
+        }
     }
     // Return
@@ -554,23 +601,52 @@ void GCTAObservation::write(GXmlElement&amp; xml) const
             npar[0]++;
         }
-        // Handle ARF
+        // Handle effective area
         else if (par->attribute("name") == "EffectiveArea") {
-            std::string aeff     = "";
+
+            // Initialise attributes
+            std::string filename = "";
             double      thetacut = 0.0;
             double      scale    = 1.0;
+            double      sigma    = 0.0;
+
+            // Continue only if response and effective area are valid
             if (m_response != NULL) {
-                aeff     = m_response->arffile();
-                thetacut = m_response->arf_thetacut();
-                scale    = m_response->arf_scale();
-            }
-            par->attribute("file", aeff);
+                if (m_response->aeff() != NULL) {
+
+                    // Get filename
+                    filename = m_response->aeff()->filename();
+
+                    // Get optional ARF attributes
+                    const GCTAAeffArf* arf =
+                          dynamic_cast<const GCTAAeffArf*>(m_response->aeff());
+                    if (arf != NULL) {
+                        thetacut = arf->thetacut();
+                        scale    = arf->scale();
+                        sigma    = arf->sigma();
+                    }
+
+                    // Get optional performance table attributes
+                    const GCTAAeffPerfTable* perf =
+                          dynamic_cast<const GCTAAeffPerfTable*>(m_response->aeff());
+                    if (perf != NULL) {
+                        sigma    = arf->sigma();
+                    }
+                    
+                } // endif: effective area was valid
+            } // endif: response was valid
+
+            // Set attributes
+            par->attribute("file", filename);
             if (thetacut > 0.0) {
                 par->attribute("thetacut", str(thetacut));
             }
             if (scale != 1.0) {
                 par->attribute("scale", str(scale));
             }
+            if (sigma > 0.0) {
+                par->attribute("sigma", str(sigma));
+            }
             npar[1]++;
         }
@@ -47,6 +47,9 @@
 #include "GCTAException.hpp"
 #include "GCTASupport.hpp"
 #include "GCTADir.hpp"
+#include "GCTAAeff2D.hpp"
+#include "GCTAAeffArf.hpp"
+#include "GCTAAeffPerfTable.hpp"
 /* __ Method name definitions ____________________________________________ */
 #define G_CALDB                           "GCTAResponse::caldb(std::string&)"
@@ -587,6 +590,9 @@ void GCTAResponse::load(const std::string&amp; irfname)
     // Read performance table
     read_performance_table(filename);
+    // Read effective area
+    m_aeff = new GCTAAeffPerfTable(filename);
+
     // Store response name
     m_rspname = irfname;
@@ -599,29 +605,68 @@ void GCTAResponse::load(const std::string&amp; irfname)
 /***********************************************************************//**
- * @brief Load CTA ARF vector
+ * @brief Load effective area
  *
- * @param[in] filename FITS file name.
+ * @param[in] filename Effective area filename.
+ *
+ * This method allocates an effective area instance and load the effective
+ * area information from a response file. The following response file formats
+ * are supported:
+ *
+ * (1) A CTA performance table. This is an ASCII file which specifies the
+ *     on-axis effective area as function of energy.
+ *
+ * (2) A ARF FITS file. This is a FITS file which stores the effective area
+ *     in a vector.
+ *
+ * (3) A CTA response table. This is a FITS file which specifies the
+ *     effective area as function of energy and offset angle.
+ *
+ * This method examines the file, and depending on the detected format,
+ * allocates the appropriate effective area class and loads the data.
  *
- * This method loads a CTA ARF vector from a FITS file. See the
- * GCTAResponse::read_arf method for more information on ARF vector reading.
+ * First, the method checks whether the file is a FITS file or not. If the
+ * file is not a FITS file, it is assumed that the file is an ASCII
+ * performance table. If the file is a FITS file, the number of rows found
+ * in the table is used to distinguish between an ARF (multiple rows) and
+ * a CTA response table (single row).
+ *
+ * @todo Implement a method that checks if a file is a FITS file instead
+ *       of using try-catch.
  ***************************************************************************/
-void GCTAResponse::load_arf(const std::string& filename)
+void GCTAResponse::load_aeff(const std::string& filename)
 {
-    // Open ARF FITS file
-    GFits file(filename);
-
-    // Get ARF table
-    GFitsTable* table = file.table("SPECRESP");
+    // Free any existing effective area instance
+    if (m_aeff != NULL) delete m_aeff;
+    m_aeff = NULL;
+    
+    // Try opening the file as a FITS file
+    try {
+    
+        // Open FITS file
+        GFits file(filename);
+
+        // If file contains an "EFFECTIVE AREA" extension then load it
+        // as CTA response table
+        if (file.hashdu("EFFECTIVE AREA")) {
+            file.close();
+            m_aeff = new GCTAAeff2D(filename);
+        }
-    // Read ARF
-    read_arf(table);
+        // ... else if file contains a "SPECRESP" extension then load it
+        // as ARF
+        else if (file.hashdu("SPECRESP")) {
+            file.close();
+            m_aeff = new GCTAAeffArf(filename);
+        }
-    // Close ARF FITS file
-    file.close();
+    }
-    // Store filename
-    m_arffile = filename;
+    // If FITS file opening failed then assume that we have a performance
+    // table
+    catch (GException::fits_open_error &e) {
+        m_aeff = new GCTAAeffPerfTable(filename);
+    }
     // Return
     return;
@@ -697,137 +742,6 @@ void GCTAResponse::load_psf(const std::string&amp; filename)
 /***********************************************************************//**
- * @brief Read CTA ARF vector
- *
- * @param[in] hdu FITS table pointer.
- *
- * This method reads a CTA ARF vector from the FITS HDU. Note that the
- * energies are converted to TeV and the effective area is converted to cm2.
- * Conversion is done based on the units provided for the energy and
- * effective area columns. Units that are recognized are 'keV', 'MeV', 'GeV',
- * 'TeV', 'm^2', 'm2', 'cm^2' and 'cm^2' (case independent).
- *
- * @todo Assign appropriate theta angle for PSF. So far we use onaxis.
- *       For appropriate theta angle assignment, we would need this
- *       information in the response header.
- ***************************************************************************/
-void GCTAResponse::read_arf(const GFitsTable* hdu)
-{
-    // Clear arrays
-    m_aeff_logE.clear();
-    m_aeff.clear();
-
-    // Get pointers to table columns
-    const GFitsTableCol* energy_lo = &(*hdu)["ENERG_LO"];
-    const GFitsTableCol* energy_hi = &(*hdu)["ENERG_HI"];
-    const GFitsTableCol* specresp  = &(*hdu)["SPECRESP"];
-
-    // Determine unit conversion factors (default: TeV and cm^2)
-    std::string u_energy_lo = tolower(strip_whitespace(energy_lo->unit()));
-    std::string u_energy_hi = tolower(strip_whitespace(energy_hi->unit()));
-    std::string u_specresp  = tolower(strip_whitespace(specresp->unit()));
-    double c_energy_lo = 1.0;
-    double c_energy_hi = 1.0;
-    double c_specresp  = 1.0;
-    if (u_energy_lo == "kev") {
-        c_energy_lo = 1.0e-9;
-    }
-    else if (u_energy_lo == "mev") {
-        c_energy_lo = 1.0e-6;
-    }
-    else if (u_energy_lo == "gev") {
-        c_energy_lo = 1.0e-3;
-    }
-    if (u_energy_hi == "kev") {
-        c_energy_hi = 1.0e-9;
-    }
-    else if (u_energy_hi == "mev") {
-        c_energy_hi = 1.0e-6;
-    }
-    else if (u_energy_hi == "gev") {
-        c_energy_hi = 1.0e-3;
-    }
-    if (u_specresp == "m^2" || u_specresp == "m2") {
-        c_specresp = 10000.0;
-    }
-
-    // Extract number of energy bins
-    int num = energy_lo->length();
-
-    // Set nodes
-    for (int i = 0; i < num; ++i) {
-    
-        // Compute log10 mean energy in TeV
-        double e_min = energy_lo->real(i) * c_energy_lo;
-        double e_max = energy_hi->real(i) * c_energy_hi;
-        double logE  = 0.5 * (log10(e_min) + log10(e_max));
-
-        // Initialise scale factor
-        double scale = m_arf_scale;
-
-        // Optionally compute scaling factor from thetacut. This is done
-        // by computing the containment fraction for the specified thetacut.
-        if (m_arf_thetacut > 0.0) {
-
-            // Get PSF parameters for node energy and theta angle
-            //TODO: Implement theta angle computation
-            GCTAPsfPars pars = psf_dummy_sigma(logE, 0.0);
-
-            // Get maximum integration radius
-            double rmax = m_arf_thetacut * deg2rad;
-
-            // Setup integration kernel
-            cta_npsf_kern_rad_azsym integrand(this,
-                                              rmax,
-                                              0.0,
-                                              pars);
-
-            // Setup integration
-            GIntegral integral(&integrand);
-            integral.eps(m_eps);
-
-            // Perform integration
-            double fraction = integral.romb(0.0, rmax);
-
-            // Update scale factor
-            if (fraction > 0.0) {
-                scale /= fraction;
-                #if defined(G_DEBUG_READ_ARF)
-                std::cout << "GCTAResponse::read_arf:";
-                std::cout << " e_min=" << e_min;
-                std::cout << " e_max=" << e_max;
-                std::cout << " logE=" << logE;
-                std::cout << " scale=" << scale;
-                std::cout << " fraction=" << fraction;
-                std::cout << std::endl;
-                #endif
-            }
-            else {
-                std::cout << "WARNING: GCTAResponse::read_arf:";
-                std::cout << " Non-positive integral occured in";
-                std::cout << " PSF integration in GCTAResponse::read_arf.";
-                std::cout << std::endl;
-            }
-        }
-
-        // Compute effective area in cm2
-        double aeff = specresp->real(i) * c_specresp * scale;
-        
-        // Store log10 mean energy and effective area value
-        m_aeff_logE.append(logE);
-        m_aeff.push_back(aeff);
-
-    } // endfor: looped over nodes
-    
-    // Disable offset angle dependence
-    m_offset_sigma = 0.0;
-
-    // Return
-    return;
-}
-
-
-/***********************************************************************//**
  * @brief Read CTA PSF vector
  *
  * @param[in] hdu FITS table pointer.
@@ -925,25 +839,13 @@ std::string GCTAResponse::print(void) const
     result.append("=== GCTAResponse ===");
     result.append("\n"+parformat("Calibration database")+m_caldb);
     result.append("\n"+parformat("Response name")+m_rspname);
-    result.append("\n"+parformat("ARF file name")+m_arffile);
     result.append("\n"+parformat("RMF file name")+m_rmffile);
     result.append("\n"+parformat("PSF file name")+m_psffile);
-    result.append("\n"+parformat("ARF theta angle cut"));
-    if (m_arf_thetacut > 0) {
-        result.append(str(m_arf_thetacut));
-    }
-    else {
-        result.append("none");
-    }
-    result.append("\n"+parformat("ARF scaling")+str(m_arf_scale));
-    if (m_offset_sigma == 0) {
-        result.append("\n"+parformat("Offset angle dependence")+"none");
-    }
-    else {
-        std::string txt = "Fixed sigma="+str(m_offset_sigma);
-        result.append("\n"+parformat("Offset angle dependence")+txt);
+
+    // Append effective area information
+    if (m_aeff != NULL) {
+        result.append("\n"+m_aeff->print());
     }
-    result.append("\n"+parformat("Effective area nodes")+str(m_aeff_logE.size()));
     // Append PSF information
     result.append("\n"+parformat("PSF version"));
@@ -967,15 +869,6 @@ std::string GCTAResponse::print(void) const
         result.append("\n"+parformat("PSF nodes")+str(m_psf_logE.size()));
     }
-    // Debug option: Plot Aeff
-    #if defined(G_DEBUG_PRINT_AEFF)
-    result.append("\n"+parformat("Effective area"));
-    for (int i = 0; i < m_aeff_logE.size(); ++i) {
-        result.append("\n"+parformat("logE="+str(m_aeff_logE[i])));
-        result.append("Aeff="+str(m_aeff.at(i))+" m2");
-    }
-    #endif
-
     // Debug option: Plot PSF
     #if defined(G_DEBUG_PRINT_PSF)
     result.append("\n"+parformat("Point spread function"));
@@ -1547,14 +1440,10 @@ double GCTAResponse::npred_diffuse(const GModelDiffuseSource&amp; model,
  * @param[in] zenith Zenith angle of telescope pointing (radians).
  * @param[in] azimuth Azimuth angle of telescope pointing (radians).
  * @param[in] srcLogEng Log10 of true photon energy (E/TeV).
+ * @return Effective area in units fo cm2.
  *
- * A simple offset angle dependence has been implemented using a Gaussian
- * if theta^2 (similar to the radial acceptance model implemented for the
- * background). The width of the Gaussian is assumed independent of energy
- * and given by the fixed parameter m_offset_sigma.
- *
- * @todo Implement offset angle dependence from response file.
- * @todo So far the parameters phi, zenith, and azimuth are not used.
+ * Returns the effective area as function of position in the camera system
+ * and in the earth system.
  ***************************************************************************/
 double GCTAResponse::aeff(const double& theta,
                           const double& phi,
@@ -1562,19 +1451,10 @@ double GCTAResponse::aeff(const double&amp; theta,
                           const double& azimuth,
                           const double& srcLogEng) const
 {
-    // Interpolate effective area using node array
-    double aeff = m_aeff_logE.interpolate(srcLogEng, m_aeff);
-    if (aeff < 0) {
-        aeff = 0.0;
-    }
-    
-    // Optionally add in offset angle dependence
-    if (m_offset_sigma != 0.0) {
-        double offset = theta * rad2deg;
-        double arg    = offset * offset / m_offset_sigma;
-        double scale  = exp(-0.5 * arg * arg);
-        aeff         *= scale;
-    }
+    // Get effective area
+    double aeff = (m_aeff != NULL)
+                  ? (*m_aeff)(srcLogEng, theta, phi, zenith, azimuth)
+                  : 0.0;
     // Return effective area
     return aeff;
@@ -2043,23 +1923,21 @@ void GCTAResponse::init_members(void)
     // Initialise members
     m_caldb.clear();
     m_rspname.clear();
-    m_arffile.clear();
     m_rmffile.clear();
     m_psffile.clear();
     m_psf_logE.clear();
-    m_aeff_logE.clear();
     m_logE.clear();
-    m_aeff.clear();
     m_r68.clear();
     m_r80.clear();
     m_eps          = 1.0e-5; // Precision for Romberg integration
     m_offset_sigma = 3.0;    // Default value for now ...
-    m_arf_thetacut = 0.0;    // Default: no thetacut
-    m_arf_scale    = 1.0;    // Default: ARF is unscaled
     // Initialise PSF information
     m_psf_version = -99; // Unknown PSF version
     m_psf_table.clear();
+
+    // New factorisation
+    m_aeff = NULL;
     // Return
     return;
@@ -2076,24 +1954,22 @@ void GCTAResponse::copy_members(const GCTAResponse&amp; rsp)
     // Copy attributes
     m_caldb        = rsp.m_caldb;
     m_rspname      = rsp.m_rspname;
-    m_arffile      = rsp.m_arffile;
     m_rmffile      = rsp.m_rmffile;
     m_psffile      = rsp.m_psffile;
     m_psf_logE     = rsp.m_psf_logE;
-    m_aeff_logE    = rsp.m_aeff_logE;
     m_logE         = rsp.m_logE;
-    m_aeff         = rsp.m_aeff;
     m_r68          = rsp.m_r68;
     m_r80          = rsp.m_r80;
     m_eps          = rsp.m_eps;
     m_offset_sigma = rsp.m_offset_sigma;
-    m_arf_thetacut = rsp.m_arf_thetacut;
-    m_arf_scale    = rsp.m_arf_scale;
     // Copy PSF information
     m_psf_version = rsp.m_psf_version;
     m_psf_table   = rsp.m_psf_table;
+    // New factorisation
+    m_aeff = (rsp.m_aeff != NULL) ? rsp.m_aeff->clone() : NULL;
+
     // Return
     return;
 }
@@ -2104,6 +1980,12 @@ void GCTAResponse::copy_members(const GCTAResponse&amp; rsp)
  ***************************************************************************/
 void GCTAResponse::free_members(void)
 {
+    // Free memory
+    if (m_aeff != NULL) delete m_aeff;
+
+    // Initialise pointers
+    m_aeff = NULL;
+
     // Return
     return;
 }
@@ -2125,9 +2007,9 @@ void GCTAResponse::read_performance_table(const std::string&amp; filename)
 {
     // Clear arrays
     m_psf_logE.clear();
-    m_aeff_logE.clear();
+    //m_aeff_logE.clear();
     m_logE.clear();
-    m_aeff.clear();
+    //m_aeff.clear();
     m_r68.clear();
     m_r80.clear();
@@ -2164,7 +2046,7 @@ void GCTAResponse::read_performance_table(const std::string&amp; filename)
         // Push elements in vectors
         m_logE.push_back(todouble(elements[0]));
-        m_aeff.push_back(todouble(elements[1])*10000.0);
+        //m_aeff.push_back(todouble(elements[1])*10000.0);
         m_r68.push_back(todouble(elements[2]));
         m_r80.push_back(todouble(elements[3]));
@@ -2175,7 +2057,7 @@ void GCTAResponse::read_performance_table(const std::string&amp; filename)
     if (num > 0) {
         for (int i = 0; i < num; ++i) {
             m_psf_logE.append(m_logE.at(i));
-            m_aeff_logE.append(m_logE.at(i));
+            //m_aeff_logE.append(m_logE.at(i));
         }
     }