Add GRmf arithmetic operators

Jürgen Knödlseder
1 parent a2451996
Showing 10 changed files with 420 additions and 45 deletions
ChangeLog
NEWS
doc/source/admin/release_history/1.5.rst
include/GRmf.hpp
pyext/GRmf.i
src/sky/GSkyRegionMap.cpp
src/xspec/GArf.cpp
src/xspec/GRmf.cpp
test/test_GXspec.cpp
test/test_GXspec.py
@@ -5,6 +5,7 @@
         Add GPha arithmetic operators and scale access methods
         Add GArf arithmetic operators
+        Add GRmf arithmetic operators
         Add GEbounds equality and inequality operators
         Fix OpenMP segfault issue when fetching CTA events (#2192) 
         Correct GModelSpatialComposite::copy_members() bug.
@@ -66,6 +66,15 @@ The following methods have been added:
 - operator*(GArf&, double&)
 - operator*(double&, double&)
 - operator/(GArf&, double&)
+- GRmf::operator+=(GRmf&)
+- GRmf::operator-=(GRmf&)
+- GRmf::operator*=(double&)
+- GRmf::operator/=(double&)
+- operator+(GRmf&, GRmf&)
+- operator-(GRmf&, GRmf&)
+- operator*(GRmf&, double&)
+- operator*(double&, double&)
+- operator/(GRmf&, double&)
 The following methods have been removed:
 - n.a.
@@ -176,6 +185,9 @@ factors.
 Added arithmetic operatirs for GArf class to add, subtract, scale and divide
 Auxiliary Response Files. 
+Added arithmetic operatirs for GRmf class to add, subtract, scale and divide
+Redistribution Matrix Files.
+
 17. Test module
 ---------------
@@ -30,8 +30,10 @@ Bug fixes
 Improvements
 ------------
+* Add ``GPha`` arithmetic operators and scale access methods
+* Add ``GArf`` arithmetic operators
+* Add ``GRmf`` arithmetic operators
 * Add ``GEbounds`` equality and inequality operators
-* Add ``GPha`` arithmetic operators
 * Improve efficiency of ``GGti::contains()`` method
 * [`2191 <https://cta-redmine.irap.omp.eu/issues/2191>`_] -
   Add ``GFitsTableCol::scale()`` method
@@ -53,6 +53,13 @@ namespace gammalib {
  ***************************************************************************/
 class GRmf : public GBase {
+    // Operator friends
+    friend GRmf operator+(const GRmf& a,       const GRmf& b);
+    friend GRmf operator-(const GRmf& a,       const GRmf& b);
+    friend GRmf operator*(const GRmf& rmf,     const double& scale);
+    friend GRmf operator*(const double& scale, const GRmf& rmf);
+    friend GRmf operator/(const GRmf& rmf,     const double& scale);
+
 public:
     // Constructors and destructors
     GRmf(void);
@@ -63,6 +70,10 @@ public:
     // Operators
     GRmf&         operator=(const GRmf& rmf);
+    GRmf&         operator+=(const GRmf& rmf);
+    GRmf&         operator-=(const GRmf& rmf);
+    GRmf&         operator*=(const double& scale);
+    GRmf&         operator/=(const double& scale);
     double&       operator()(const int& itrue, const int& imeasured);
     const double& operator()(const int& itrue, const int& imeasured) const;
@@ -281,4 +292,84 @@ const GFilename&amp; GRmf::filename(void) const
     return (m_filename);
 }
+
+/***********************************************************************//**
+ * @brief Redistribution Matrix File addition operator friend
+ *
+ * @param[in] a First Redistribution Matrix File.
+ * @param[in] b Second Redistribution Matrix File.
+ * @return Sum of Redistribution Matrix Files.
+ ***************************************************************************/
+inline
+GRmf operator+(const GRmf& a, const GRmf& b)
+{
+    GRmf result = a;
+    result     += b;
+    return result;
+}
+
+
+/***********************************************************************//**
+ * @brief Redistribution Matrix File subtraction operator friend
+ *
+ * @param[in] a First Redistribution Matrix File.
+ * @param[in] b Second Redistribution Matrix File.
+ * @return Difference of Redistribution Matrix Files.
+ ***************************************************************************/
+inline
+GRmf operator-(const GRmf& a, const GRmf& b)
+{
+    GRmf result = a;
+    result     -= b;
+    return result;
+}
+
+
+/***********************************************************************//**
+ * @brief Redistribution Matrix File scaling operator friend
+ *
+ * @param[in] rmf Redistribution Matrix File.
+ * @param[in] scale Scale factor.
+ * @return Scaled Redistribution Matrix File.
+ ***************************************************************************/
+inline
+GRmf operator*(const GRmf& rmf, const double& scale)
+{
+    GRmf result = rmf;
+    result     *= scale;
+    return result;
+}
+
+
+/***********************************************************************//**
+ * @brief Redistribution Matrix File scaling operator friend
+ *
+ * @param[in] scale Scale factor.
+ * @param[in] rmf Redistribution Matrix File.
+ * @return Scaled Redistribution Matrix File.
+ ***************************************************************************/
+inline
+GRmf operator*(const double& scale, const GRmf& rmf)
+{
+    GRmf result = rmf;
+    result     *= scale;
+    return result;
+}
+
+
+/***********************************************************************//**
+ * @brief Redistribution Matrix File vision operator friend
+ *
+ * @param[in] rmf Redistribution Matrix File.
+ * @param[in] scale Division factor.
+ * @return Divided Redistribution Matrix File.
+ ***************************************************************************/
+inline
+GRmf operator/(const GRmf& rmf, const double& scale)
+{
+    GRmf result = rmf;
+    result     /= scale;
+    return result;
+}
+
 #endif /* GRMF_HPP */
 /***************************************************************************
  *             GRmf.i - XSPEC Redistribution Matrix File class             *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2013-2016 by Juergen Knoedlseder                         *
+ *  copyright (C) 2013-2017 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -46,6 +46,12 @@ public:
     GRmf(const GRmf& rmf);
     virtual ~GRmf(void);
+    // Operators
+    GRmf& operator=(const GRmf& rmf);
+    GRmf& operator+=(const GRmf& rmf);
+    GRmf& operator-=(const GRmf& rmf);
+    GRmf& operator*=(const double& scale);
+
     // Methods
     void                 clear(void);
     GRmf*                clone(void) const;
@@ -83,6 +89,31 @@ public:
     int __len__() {
         return (self->size());
     }
+    GRmf __add__(const GRmf& rmf) const {
+        return ((*self) + rmf);
+    }
+    GRmf __sub__(const GRmf& rmf) const {
+        return ((*self) - rmf);
+    }
+    GRmf __mul__(const double& scale) const {
+        return ((*self) * scale);
+    }
+    // Python 2.x
+    GRmf __div__(const double& scale) const {
+        return ((*self) / scale);
+    }
+    GRmf __idiv__(const double& scale) {
+        self->operator/=(scale);
+        return (*self);
+    }
+    // Python 3.x
+    GRmf __truediv__(const double& scale) const {
+        return ((*self) / scale);
+    }
+    GRmf __itruediv__(const double& scale) {
+        self->operator/=(scale);
+        return (*self);
+    }
     GRmf copy() {
         return (*self);
     }
@@ -455,7 +455,7 @@ void GSkyRegionMap::init_members(void)
 /***********************************************************************//**
  * @brief Copy class members
  *
- * @param[in] region Sky region map.
+ * @param[in] map Sky region map.
  ***************************************************************************/
 void GSkyRegionMap::copy_members(const GSkyRegionMap& map)
 {
@@ -39,6 +39,8 @@
 #include "GFitsTableFloatCol.hpp"
 /* __ Method name definitions ____________________________________________ */
+#define G_OPERATOR_PLUS                             "GArf::operator+=(GArf&)"
+#define G_OPERATOR_MINUS                            "GArf::operator-=(GArf&)"
 #define G_OPERATOR                           "GArf::operator[](std::string&)"
 #define G_AT1                                                "GArf::at(int&)"
 #define G_AT2                                          "GArf::at(int&, int&)"
@@ -187,11 +189,9 @@ GArf&amp; GArf::operator=(const GArf&amp; arf)
  * The operator only works if the provide Auxiliary Response File has the
  * same energy binning than the current Auxiliary Response File.
  ***************************************************************************/
-#define G_OPERATOR_PLUS                             "GArf::operator+=(GArf&)"
-#define G_OPERATOR_MINUS                            "GArf::operator-=(GArf&)"
 GArf& GArf::operator+=(const GArf& arf)
 {
-    // Throw an exception if the spectra are not compatible
+    // Throw an exception if the ARF are not compatible
     if (this->ebounds() != arf.ebounds()) {
         std::string msg = "Incompatible energy binning of Auxiliary "
                           "Response File.";
@@ -225,7 +225,7 @@ GArf&amp; GArf::operator+=(const GArf&amp; arf)
  ***************************************************************************/
 GArf& GArf::operator-=(const GArf& arf)
 {
-    // Throw an exception if the spectra are not compatible
+    // Throw an exception if the ARF are not compatible
     if (this->ebounds() != arf.ebounds()) {
         std::string msg = "Incompatible energy binning of Auxiliary "
                           "Response File.";
@@ -39,6 +39,8 @@
 #include "GFitsTableFloatCol.hpp"
 /* __ Method name definitions ____________________________________________ */
+#define G_OPERATOR_PLUS                             "GRmf::operator+=(GRmf&)"
+#define G_OPERATOR_MINUS                            "GRmf::operator-=(GRmf&)"
 #define G_AT                                           "GRmf::at(int&, int&)"
 /* __ Macros _____________________________________________________________ */
@@ -172,6 +174,133 @@ GRmf&amp; GRmf::operator=(const GRmf&amp; rmf)
 }
+/***********************************************************************//**
+ * @brief Add Redistribution Matrix File
+ *
+ * @param[in] rmf Redistribution Matrix File.
+ * @return Sum of Redistribution Matrix File.
+ *
+ * @exception GException::invalid_value
+ *            Incompatible Redistribution Matrix Files.
+ *
+ * Adds the RMF values of an Redistribution Matrix File to the current
+ * values.
+ *
+ * The operator only works if the provide Redistribution Matrix File has the
+ * same energy binning than the current Redistribution Matrix File.
+ ***************************************************************************/
+GRmf& GRmf::operator+=(const GRmf& rmf)
+{
+    // Throw an exception if the RMF are not compatible
+    if (this->etrue() != rmf.etrue()) {
+        std::string msg = "Incompatible true energy binning of "
+                          "Redistribution Matrix File.";
+        throw GException::invalid_value(G_OPERATOR_PLUS, msg);
+    }
+    if (this->emeasured() != rmf.emeasured()) {
+        std::string msg = "Incompatible measured energy binning of "
+                          "Redistribution Matrix File.";
+        throw GException::invalid_value(G_OPERATOR_PLUS, msg);
+    }
+    
+    // Add RMF values
+    for (int itrue = 0; itrue < ntrue(); ++itrue) {
+        for (int imeasured = 0; imeasured < nmeasured(); ++imeasured) {
+            m_matrix(itrue, imeasured) += rmf.m_matrix(itrue, imeasured);
+        }
+    }
+
+    // Return
+    return *this;
+}
+
+
+/***********************************************************************//**
+ * @brief Subtract Redistribution Matrix File
+ *
+ * @param[in] rmf Redistribution Matrix File.
+ * @return Difference of Redistribution Matrix File.
+ *
+ * @exception GException::invalid_value
+ *            Incompatible Redistribution Matrix Files.
+ *
+ * Subtracts the RMF values of an Redistribution Matrix File from the current
+ * values.
+ *
+ * The operator only works if the provide Redistribution Matrix File has the
+ * same energy binning than the current Redistribution Matrix File.
+ ***************************************************************************/
+GRmf& GRmf::operator-=(const GRmf& rmf)
+{
+    // Throw an exception if the RMF are not compatible
+    if (this->etrue() != rmf.etrue()) {
+        std::string msg = "Incompatible true energy binning of "
+                          "Redistribution Matrix File.";
+        throw GException::invalid_value(G_OPERATOR_MINUS, msg);
+    }
+    if (this->emeasured() != rmf.emeasured()) {
+        std::string msg = "Incompatible measured energy binning of "
+                          "Redistribution Matrix File.";
+        throw GException::invalid_value(G_OPERATOR_MINUS, msg);
+    }
+    
+    // Subtract RMF values
+    for (int itrue = 0; itrue < ntrue(); ++itrue) {
+        for (int imeasured = 0; imeasured < nmeasured(); ++imeasured) {
+            m_matrix(itrue, imeasured) -= rmf.m_matrix(itrue, imeasured);
+        }
+    }
+
+    // Return
+    return *this;
+}
+
+
+/***********************************************************************//**
+ * @brief Scale Redistribution Matrix File values
+ *
+ * @param[in] scale Scale factor.
+ * @return Scaled Redistribution Matrix File.
+ *
+ * Multiplies the values of the Redistribution Matrix File with a scale
+ * factor.
+ ***************************************************************************/
+GRmf& GRmf::operator*=(const double& scale)
+{
+    // Scale RMF values
+    for (int itrue = 0; itrue < ntrue(); ++itrue) {
+        for (int imeasured = 0; imeasured < nmeasured(); ++imeasured) {
+            m_matrix(itrue, imeasured) *= scale;
+        }
+    }
+
+    // Return
+    return *this;
+}
+
+
+/***********************************************************************//**
+ * @brief Divide Redistribution Matrix File values
+ *
+ * @param[in] scale Division factor.
+ * @return Divided Redistribution Matrix File.
+ *
+ * Divides the values of the Redistribution Matrix File by a division factor.
+ ***************************************************************************/
+GRmf& GRmf::operator/=(const double& scale)
+{
+    // Divide RMF values
+    for (int itrue = 0; itrue < ntrue(); ++itrue) {
+        for (int imeasured = 0; imeasured < nmeasured(); ++imeasured) {
+            m_matrix(itrue, imeasured) /= scale;
+        }
+    }
+
+    // Return
+    return *this;
+}
+
+
 /*==========================================================================
  =                                                                         =
  =                             Public methods                              =
@@ -194,36 +194,55 @@ void TestGXspec::test_GPha(void)
     test_value(pha6.overflow(),  2.0, 1.0e-6);
     test_value(pha6.outflow(),   0.0, 1.0e-6);
-    // Test unary addition operator
-    GPha pha7 = pha2;
-    pha7 += pha2;
-    test_value(pha7[0], 10.0, 1.0e-6);
-    test_value(pha7[1],  7.4, 1.0e-6);
-    test_value(pha7.counts(),   23.4, 1.0e-6);
-    test_value(pha7.underflow(), 2.0, 1.0e-6);
-    test_value(pha7.overflow(),  2.0, 1.0e-6);
+    // Test division operator
+    GPha pha7 = pha2 / 2.0;
+    test_value(pha7[0],  2.5, 1.0e-6);
+    test_value(pha7[1],  1.85, 1.0e-6);
+    test_value(pha7.counts(),   5.85, 1.0e-6);
+    test_value(pha7.underflow(), 0.5, 1.0e-6);
+    test_value(pha7.overflow(),  0.5, 1.0e-6);
     test_value(pha7.outflow(),   0.0, 1.0e-6);
-    // Test unary subtraction operator
+    // Test unary addition operator
     GPha pha8 = pha2;
-    pha8 -= pha2;
-    test_value(pha8[0], 0.0, 1.0e-6);
-    test_value(pha8[1], 0.0, 1.0e-6);
-    test_value(pha8.counts(),    0.0, 1.0e-6);
-    test_value(pha8.underflow(), 0.0, 1.0e-6);
-    test_value(pha8.overflow(),  0.0, 1.0e-6);
+    pha8 += pha2;
+    test_value(pha8[0], 10.0, 1.0e-6);
+    test_value(pha8[1],  7.4, 1.0e-6);
+    test_value(pha8.counts(),   23.4, 1.0e-6);
+    test_value(pha8.underflow(), 2.0, 1.0e-6);
+    test_value(pha8.overflow(),  2.0, 1.0e-6);
     test_value(pha8.outflow(),   0.0, 1.0e-6);
-    // Test unary scale operator
+    // Test unary subtraction operator
     GPha pha9 = pha2;
-    pha9 *= 2.0;
-    test_value(pha9[0], 10.0, 1.0e-6);
-    test_value(pha9[1],  7.4, 1.0e-6);
-    test_value(pha9.counts(),   23.4, 1.0e-6);
-    test_value(pha9.underflow(), 2.0, 1.0e-6);
-    test_value(pha9.overflow(),  2.0, 1.0e-6);
+    pha9 -= pha2;
+    test_value(pha9[0], 0.0, 1.0e-6);
+    test_value(pha9[1], 0.0, 1.0e-6);
+    test_value(pha9.counts(),    0.0, 1.0e-6);
+    test_value(pha9.underflow(), 0.0, 1.0e-6);
+    test_value(pha9.overflow(),  0.0, 1.0e-6);
     test_value(pha9.outflow(),   0.0, 1.0e-6);
+    // Test unary scale operator
+    GPha pha10 = pha2;
+    pha10 *= 2.0;
+    test_value(pha10[0], 10.0, 1.0e-6);
+    test_value(pha10[1],  7.4, 1.0e-6);
+    test_value(pha10.counts(),   23.4, 1.0e-6);
+    test_value(pha10.underflow(), 2.0, 1.0e-6);
+    test_value(pha10.overflow(),  2.0, 1.0e-6);
+    test_value(pha10.outflow(),   0.0, 1.0e-6);
+
+    // Test unary division operator
+    GPha pha11 = pha2;
+    pha11 /= 2.0;
+    test_value(pha11[0],  2.5, 1.0e-6);
+    test_value(pha11[1],  1.85, 1.0e-6);
+    test_value(pha11.counts(),   5.85, 1.0e-6);
+    test_value(pha11.underflow(), 0.5, 1.0e-6);
+    test_value(pha11.overflow(),  0.5, 1.0e-6);
+    test_value(pha11.outflow(),   0.0, 1.0e-6);
+
     // Return
     return;
 }
@@ -306,8 +325,55 @@ void TestGXspec::test_GArf(void)
         test_value(arf2.at(i), 0.0);
         test_value(arf2[i], 0.0);
     }
-    //std::cout << arf << std::endl;
-    //std::cout << arf2 << std::endl;
+
+    // Test addition operator
+    GArf arf3 = arf2 + arf2;
+    test_value(arf3[0], 10.0, 1.0e-6);
+    test_value(arf3[1],  7.4, 1.0e-6);
+
+    // Test subtraction operator
+    GArf arf4 = arf2 - arf2;
+    test_value(arf4[0], 0.0, 1.0e-6);
+    test_value(arf4[1], 0.0, 1.0e-6);
+
+    // Test scale operator
+    GArf arf5 = arf2 * 2.0;
+    test_value(arf5[0], 10.0, 1.0e-6);
+    test_value(arf5[1],  7.4, 1.0e-6);
+
+    // Test scale operator
+    GArf arf6 = 2.0 * arf2;
+    test_value(arf6[0], 10.0, 1.0e-6);
+    test_value(arf6[1],  7.4, 1.0e-6);
+
+    // Test division operator
+    GArf arf7 = arf2 / 2.0;
+    test_value(arf7[0], 2.5, 1.0e-6);
+    test_value(arf7[1], 1.85, 1.0e-6);
+
+    // Test unary addition operator
+    GArf arf8 = arf2;
+    arf8 += arf2;
+    test_value(arf8[0], 10.0, 1.0e-6);
+    test_value(arf8[1],  7.4, 1.0e-6);
+
+    // Test unary subtraction operator
+    GArf arf9 = arf2;
+    arf9 -= arf2;
+    test_value(arf9[0], 0.0, 1.0e-6);
+    test_value(arf9[1], 0.0, 1.0e-6);
+
+    // Test unary scale operator
+    GArf arf10 = arf2;
+    arf10 *= 2.0;
+    test_value(arf10[0], 10.0, 1.0e-6);
+    test_value(arf10[1],  7.4, 1.0e-6);
+
+    // Test unary divisison operator
+    GArf arf11 = arf2;
+    arf11 /= 2.0;
+    test_value(arf11[0], 2.5, 1.0e-6);
+    test_value(arf11[1], 1.85, 1.0e-6);
     // Return
     return;
@@ -381,14 +447,6 @@ void TestGXspec::test_GRmf(void)
     rmf.load("rmf.fits");
     test_assert(rmf.filename().url() == "rmf.fits",
                 "Unexpected filename \""+rmf.filename().url()+"\".");
-    /*
-    for (int i = 0; i < 9; ++i) {
-        for (int k = 0; k < 9; ++k) {
-            std::cout << rmf(i,k) << " ";
-        }
-        std::cout << std::endl;
-    }
-    */
     for (int i = 0; i < 9; ++i) {
         int k = 0;
         for (; k < i; ++k) {
@@ -424,8 +482,55 @@ void TestGXspec::test_GRmf(void)
             test_value(rmf(i,k),    0.0);
         }
     }
-    //std::cout << rmf << std::endl;
-    //std::cout << rmf2 << std::endl;
+
+    // Test addition operator
+    GRmf rmf3 = rmf2 + rmf2;
+    test_value(rmf3(0,0), 2.0, 1.0e-6);
+    test_value(rmf3(1,1), 2.0, 1.0e-6);
+
+    // Test subtraction operator
+    GRmf rmf4 = rmf2 - rmf2;
+    test_value(rmf4(0,0), 0.0, 1.0e-6);
+    test_value(rmf4(1,1), 0.0, 1.0e-6);
+
+    // Test scale operator
+    GRmf rmf5 = rmf2 * 2.0;
+    test_value(rmf5(0,0), 2.0, 1.0e-6);
+    test_value(rmf5(1,1), 2.0, 1.0e-6);
+
+    // Test scale operator
+    GRmf rmf6 = 2.0 * rmf2;
+    test_value(rmf6(0,0), 2.0, 1.0e-6);
+    test_value(rmf6(1,1), 2.0, 1.0e-6);
+
+    // Test division operator
+    GRmf rmf7 = rmf2 / 2.0;
+    test_value(rmf7(0,0), 0.5, 1.0e-6);
+    test_value(rmf7(1,1), 0.5, 1.0e-6);
+
+    // Test unary addition operator
+    GRmf rmf8 = rmf2;
+    rmf8 += rmf2;
+    test_value(rmf8(0,0), 2.0, 1.0e-6);
+    test_value(rmf8(1,1), 2.0, 1.0e-6);
+
+    // Test unary subtraction operator
+    GRmf rmf9 = rmf2;
+    rmf9 -= rmf2;
+    test_value(rmf9(0,0), 0.0, 1.0e-6);
+    test_value(rmf9(1,1), 0.0, 1.0e-6);
+
+    // Test unary scale operator
+    GRmf rmf10 = rmf2;
+    rmf10 *= 2.0;
+    test_value(rmf10(0,0), 2.0, 1.0e-6);
+    test_value(rmf10(1,1), 2.0, 1.0e-6);
+
+    // Test unary divisison operator
+    GRmf rmf11 = rmf2;
+    rmf11 /= 2.0;
+    test_value(rmf11(0,0), 0.5, 1.0e-6);
+    test_value(rmf11(1,1), 0.5, 1.0e-6);
     // Return
     return;
@@ -61,7 +61,8 @@ class Test(gammalib.GPythonTestSuite):
         """
         # Allocate GPha object and check its size
         nmeasured = 10
-        emeasured = gammalib.GEbounds(nmeasured, gammalib.GEnergy(1.0, "TeV"), gammalib.GEnergy(10.0, "TeV"))
+        emeasured = gammalib.GEbounds(nmeasured, gammalib.GEnergy(1.0, "TeV"),
+                                                 gammalib.GEnergy(10.0, "TeV"))
         pha       = gammalib.GPha(emeasured)
         self.test_value(pha.size(), nmeasured)
@@ -80,7 +81,8 @@ class Test(gammalib.GPythonTestSuite):
         """
         # Allocate GArf object and check its size
         nmeasured = 10
-        emeasured = gammalib.GEbounds(nmeasured, gammalib.GEnergy(1.0, "TeV"), gammalib.GEnergy(10.0, "TeV"))
+        emeasured = gammalib.GEbounds(nmeasured, gammalib.GEnergy(1.0, "TeV"),
+                                                 gammalib.GEnergy(10.0, "TeV"))
         arf       = gammalib.GArf(emeasured)
         self.test_value(arf.size(), nmeasured)
@@ -100,8 +102,10 @@ class Test(gammalib.GPythonTestSuite):
         # Allocate GRmf object and check its size
         ntrue     = 20
         nmeasured = 10
-        etrue     = gammalib.GEbounds(ntrue, gammalib.GEnergy(1.0, "TeV"), gammalib.GEnergy(10.0, "TeV"))
-        emeasured = gammalib.GEbounds(nmeasured, gammalib.GEnergy(1.0, "TeV"), gammalib.GEnergy(10.0, "TeV"))
+        etrue     = gammalib.GEbounds(ntrue, gammalib.GEnergy(1.0, "TeV"),
+                                             gammalib.GEnergy(10.0, "TeV"))
+        emeasured = gammalib.GEbounds(nmeasured, gammalib.GEnergy(1.0, "TeV"),
+                                                 gammalib.GEnergy(10.0, "TeV"))
         rmf       = gammalib.GRmf(etrue, emeasured)
         self.test_value(rmf.size(), ntrue*nmeasured)
         self.test_value(rmf.ntrue(), ntrue)