Implement SPI unit tests

Jürgen Knödlseder
1 parent 9dc8a8dd
Showing 11 changed files with 300 additions and 47 deletions
inst/spi/include/GSPIEventBin.hpp
inst/spi/include/GSPILib.hpp
inst/spi/include/GSPIModelDataSpace.hpp
inst/spi/pyext/GSPIModelDataSpace.i
inst/spi/pyext/GSPIObservation.i
inst/spi/src/GSPIEventBin.cpp
inst/spi/src/GSPIModelDataSpace.cpp
inst/spi/src/GSPIObservation.cpp
inst/spi/test/test_SPI.cpp
inst/spi/test/test_SPI.hpp
inst/spi/test/test_SPI.py
@@ -102,20 +102,20 @@ protected:
     void free_members(void);
     // Protected members
-    bool           m_alloc;      //!< Signals proper memory allocation
-    int            m_index;      //!< Dataspace index
-    int            m_ipt;        //!< Pointing index
-    int            m_idir;       //!< Direction index
-    int            m_iebin;      //!< Energy bin index
-    int            m_num_models; //!< Number of models in bin
-    GSPIInstDir*   m_dir;        //!< Pointer to direction of bin
-    GTime*         m_time;       //!< Pointer to time of bin
-    GEnergy*       m_energy;     //!< Pointer to energy of bin
-    double*        m_counts;     //!< Pointer to number of counts
-    double*        m_ontime;     //!< Pointer to ontime of bin
-    double*        m_livetime;   //!< Pointer to livetime of bin
-    double*        m_size;       //!< Pointer to size of bin
-    double*        m_models;     //!< Pointer to models of bin
+    bool         m_alloc;      //!< Signals proper memory allocation
+    int          m_index;      //!< Dataspace index
+    int          m_ipt;        //!< Pointing index
+    int          m_idir;       //!< Direction index
+    int          m_iebin;      //!< Energy bin index
+    int          m_num_models; //!< Number of models in bin
+    GSPIInstDir* m_dir;        //!< Pointer to direction of bin
+    GTime*       m_time;       //!< Pointer to time of bin
+    GEnergy*     m_energy;     //!< Pointer to energy of bin
+    double*      m_counts;     //!< Pointer to number of counts
+    double*      m_ontime;     //!< Pointer to ontime of bin
+    double*      m_livetime;   //!< Pointer to livetime of bin
+    double*      m_size;       //!< Pointer to size of bin
+    double*      m_models;     //!< Pointer to models of bin
 };
@@ -31,11 +31,12 @@
 #include "GammaLib.hpp"
 /* __ INTEGRAL/SPI specific headers ___________________________________________ */
-#include "GSPITools.hpp"
-#include "GSPIObservation.hpp"
 #include "GSPIEventBin.hpp"
 #include "GSPIEventCube.hpp"
 #include "GSPIInstDir.hpp"
+#include "GSPIModelDataSpace.hpp"
+#include "GSPIObservation.hpp"
 #include "GSPIResponse.hpp"
+#include "GSPITools.hpp"
 #endif /* GSPILIB_HPP */
@@ -32,7 +32,6 @@
 #include <vector>
 #include "GModelData.hpp"
 #include "GModelPar.hpp"
-//#include "GSPIObservation.hpp"
 #include "GSPIEventCube.hpp"
 /* __ Forward declarations _______________________________________________ */
@@ -61,9 +60,9 @@ public:
     // Constructors and destructors
     GSPIModelDataSpace(void);
     GSPIModelDataSpace(const GSPIObservation& obs,
-                       const std::string& name,
-                       const std::string& method,
-                       const int& index);
+                       const std::string&     name,
+                       const std::string&     method,
+                       const int&             index);
     explicit GSPIModelDataSpace(const GXmlElement& xml);
     GSPIModelDataSpace(const GSPIModelDataSpace& model);
     virtual ~GSPIModelDataSpace(void);
@@ -43,9 +43,9 @@ public:
     // Constructors and destructors
     GSPIModelDataSpace(void);
     GSPIModelDataSpace(const GSPIObservation& obs,
-                       const std::string& name,
-                       const std::string& method,
-                       const int& index);
+                       const std::string&     name,
+                       const std::string&     method,
+                       const int&             index);
     explicit GSPIModelDataSpace(const GXmlElement& xml);
     GSPIModelDataSpace(const GSPIModelDataSpace& model);
     virtual ~GSPIModelDataSpace(void);
@@ -80,9 +80,14 @@ public:
     }
 %pythoncode {
     def __getstate__(self):
-        state = (self.classname()) # TODO: Replace by appropriate class members
+        xml = gammalib.GXmlElement()
+        self.write(xml)
+        state = (xml,)
         return state
     def __setstate__(self, state):
-        self.__init__()
+        if state[0][0].elements('parameter') == 0:
+            self.__init__()
+        else:
+            self.__init__(state[0][0])
 }
 };
@@ -77,9 +77,13 @@ public:
     }
 %pythoncode {
     def __getstate__(self):
-        state = (self.classname()) # TODO: Replace by appropriate class members
+        xml = gammalib.GXmlElement()
+        self.write(xml)
+        state = (xml,)
         return state
     def __setstate__(self, state):
         self.__init__()
+        if gammalib.xml_get_attr('GSPIObservation.__setstate__', state[0], 'ObservationGroup', 'file') != '':
+            self.read(state[0])
 }
 };
@@ -280,9 +280,10 @@ void GSPIEventBin::init_members(void)
     m_dir->clear();
     m_time->clear();
     m_energy->clear();
-    *m_counts = 0.0;
-    *m_ontime = 0.0;
-    *m_size   = 0.0;
+    *m_counts   = 0.0;
+    *m_ontime   = 0.0;
+    *m_livetime = 0.0;
+    *m_size     = 0.0;
     // Return
     return;
@@ -571,7 +571,7 @@ void GSPIModelDataSpace::write(GXmlElement&amp; xml) const
     write_attributes(*src);
     // Write method
-    xml.attribute("method", m_method);
+    src->attribute("method", m_method);
     // Return
     return;
@@ -310,9 +310,9 @@ void GSPIObservation::write(GXmlElement&amp; xml) const
     // Allocate XML element pointer
     GXmlElement* par;
-    // TODO: Write out all parameters. An example is shown below.
+    // Set ObservationGroup parameter
     par = gammalib::xml_need_par(G_WRITE, xml, "ObservationGroup");
-    par->attribute("ObservationGroup", gammalib::xml_file_reduce(xml, m_filename));
+    par->attribute("file", gammalib::xml_file_reduce(xml, m_filename));
     // Return
     return;
@@ -51,10 +51,20 @@ void TestGSPI::set(void)
     name("GSPI");
     // Append tests to test suite
+    append(static_cast<pfunction>(&TestGSPI::test_instdir),
+           "Test GSPIInstDir");
+    append(static_cast<pfunction>(&TestGSPI::test_eventbin),
+           "Test GSPIEventBin");
+    append(static_cast<pfunction>(&TestGSPI::test_eventcube),
+           "Test GSPIEventCube");
+    append(static_cast<pfunction>(&TestGSPI::test_modeldataspace),
+           "Test GSPIModelDataSpace");
     append(static_cast<pfunction>(&TestGSPI::test_obs),
            "Test GSPIObservation");
     append(static_cast<pfunction>(&TestGSPI::test_response),
            "Test GSPIResponse");
+    append(static_cast<pfunction>(&TestGSPI::test_tools),
+           "Test GSPITools");
     // Return
     return;
@@ -74,15 +84,215 @@ TestGSPI* TestGSPI::clone(void) const
 /***********************************************************************//**
+ * @brief Test GSPIInstDir class
+ ***************************************************************************/
+void TestGSPI::test_instdir(void)
+{
+    // Test content of void class
+    GSPIInstDir dir1;
+    test_value(dir1.classname(), "GSPIInstDir", "Void instance classname");
+    test_value(dir1.dir().ra_deg(), 0.0, "Void instance Right Ascension");
+    test_value(dir1.dir().dec_deg(), 0.0, "Void instance Declination");
+    test_value(dir1.detid(), 0, "Void instance detector identifier");
+
+    // Test content of filled class
+    GSkyDir dir;
+    dir.radec_deg(83.6331, 22.0145);
+    GSPIInstDir dir2(dir, 13);
+    test_value(dir2.dir().ra_deg(), 83.6331, "Filled instance Right Ascension");
+    test_value(dir2.dir().dec_deg(), 22.0145, "Filled instance Declination");
+    test_value(dir2.detid(), 13, "Filled instance detector identifier");
+
+    // Test content of copied class
+    GSPIInstDir dir3 = dir2;
+    test_value(dir3.dir().ra_deg(), 83.6331, "Copied instance Right Ascension");
+    test_value(dir3.dir().dec_deg(), 22.0145, "Copied instance Declination");
+    test_value(dir3.detid(), 13, "Copied instance detector identifier");
+
+    // Test content of copy-constructed class
+    GSPIInstDir dir4(dir3);
+    test_value(dir4.dir().ra_deg(), 83.6331, "Copied instance Right Ascension");
+    test_value(dir4.dir().dec_deg(), 22.0145, "Copied instance Declination");
+    test_value(dir4.detid(), 13, "Copied instance detector identifier");
+
+    // Test setters and getters
+    dir.radec_deg(299.5903, 35.2016);
+    dir4.dir(dir);
+    dir4.detid(1);
+    test_value(dir4.dir().ra_deg(), 299.5903, "Get Right Ascension");
+    test_value(dir4.dir().dec_deg(), 35.2016, "Get Declination");
+    test_value(dir4.detid(), 1, "Get detector identifier");
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Test GSPIEventBin class
+ ***************************************************************************/
+void TestGSPI::test_eventbin(void)
+{
+    // Test content of void bin
+    GSPIEventBin bin1;
+    test_value(bin1.classname(), "GSPIEventBin", "Void instance classname");
+    test_value(bin1.dir().dir().ra_deg(), 0.0, "Void instance Right Ascension");
+    test_value(bin1.dir().dir().dec_deg(), 0.0, "Void instance Declination");
+    test_value(bin1.dir().detid(), 0, "Void instance detector identifier");
+    test_value(bin1.energy().keV(), 0.0, "Void instance energy");
+    test_value(bin1.time().secs(), 0.0, "Void instance time");
+    test_value(bin1.counts(), 0.0, "Void instance counts");
+    test_value(bin1.error(), 0.0, "Void instance error");
+    test_value(bin1.ontime(), 0.0, "Void instance ontime");
+    test_value(bin1.livetime(), 0.0, "Void instance livetime");
+    test_value(bin1.index(), -1, "Void instance index");
+    test_value(bin1.ipt(), -1, "Void instance pointing index");
+    test_value(bin1.idir(), -1, "Void instance direction index");
+    test_value(bin1.iebin(), -1, "Void instance energy bin index");
+
+    // Test counts setter and getter
+    bin1.counts(41.0);
+    test_value(bin1.counts(), 41.0, "Counts getter");
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Test GSPIEventCube class
+ ***************************************************************************/
+void TestGSPI::test_eventcube(void)
+{
+    // Test content of void cube
+    GSPIEventCube cube1;
+    test_value(cube1.classname(), "GSPIEventCube", "Void instance classname");
+    test_value(cube1.size(), 0, "Void instance size");
+    test_value(cube1.dim(), 3, "Void instance dimensions");
+    test_value(cube1.naxis(0), 0, "Void instance pointings");
+    test_value(cube1.naxis(1), 0, "Void instance detectors");
+    test_value(cube1.naxis(2), 0, "Void instance energy bins");
+    test_value(cube1.number(), 0, "Void instance number of events");
+    test_value(cube1.ontime(), 0.0, "Void instance ontime");
+    test_value(cube1.livetime(), 0.0, "Void instance livetime");
+    test_value(cube1.models(), 0, "Void instance models");
+
+    // Test loading of Observation Group
+    cube1.load(og_dol);
+    test_value(cube1.size(), 16720, "Loaded instance size");
+    test_value(cube1.dim(), 3, "Loaded instance dimensions");
+    test_value(cube1.naxis(0), 88, "Loaded instance pointings");
+    test_value(cube1.naxis(1), 19, "Loaded instance detectors");
+    test_value(cube1.naxis(2), 10, "Loaded instance energy bins");
+    test_value(cube1.number(), 101269457, "Loaded instance number of events");
+    test_value(cube1.ontime(), 193966.8178673, "Loaded instance ontime");
+    test_value(cube1.livetime(), 170657.5371606, "Loaded instance livetime");
+    test_value(cube1.models(), 1, "Loaded instance models");
+    test_value(cube1.model_counts(0), 101269456.964783, "Loaded instance model counts");
+    test_value(cube1.ptid(7), "00440010.000000", "Loaded instance ptid(7)");
+    test_value(cube1.dir(11,9).dir().ra_deg(), 83.77876, "Loaded instance RA");
+    test_value(cube1.dir(11,9).dir().dec_deg(), 22.03696, "Loaded instance RA");
+    test_value(cube1.spi_x(11).ra_deg(), 83.77876, "Loaded instance RA_X");
+    test_value(cube1.spi_x(11).dec_deg(), 22.03696, "Loaded instance DEC_X");
+    test_value(cube1.spi_z(11).ra_deg(), 354.8671, "Loaded instance RA_Z");
+    test_value(cube1.spi_z(11).dec_deg(), -2.686594, "Loaded instance DEC_Z");
+
+    // Test one event bin
+    const GSPIEventBin* bin1 = cube1[45];
+    test_value(bin1->dir().dir().ra_deg(), 87.98045, "Bin[45] RA");
+    test_value(bin1->dir().dir().dec_deg(), 17.98266, "Bin[45] DEC");
+    test_value(bin1->dir().detid(), 4, "Bin[45] detector identifier");
+    test_value(bin1->energy().keV(), 262.5, "Bin[45] energy");
+    test_value(bin1->time().secs(), -216415756.731, "Bin[45] time");
+    test_value(bin1->counts(), 4766.0, "Bin[45] counts");
+    test_value(bin1->error(), 69.03622, "Bin[45] error");
+    test_value(bin1->ontime(), 2928.9207878, "Bin[45] ontime");
+    test_value(bin1->livetime(), 2578.60894906, "Bin[45] livetime");
+    test_value(bin1->index(), 45, "Bin[45] index");
+    test_value(bin1->ipt(), 0, "Bin[45] pointing index");
+    test_value(bin1->idir(), 4, "Bin[45] direction index");
+    test_value(bin1->iebin(), 5, "Bin[45] energy bin index");
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Test GSPIModelDataSpace class
+ ***************************************************************************/
+void TestGSPI::test_modeldataspace(void)
+{
+    // Test content of void model
+    GSPIModelDataSpace model1;
+    test_value(model1.classname(), "GSPIModelDataSpace", "Void instance classname");
+    test_value(model1.type(), "DataSpace", "Void instance type");
+    test_value(model1.size(), 0, "Void instance size");
+    test_value(model1.instruments(), "SPI", "Void instance instruments");
+    test_assert(model1.is_constant(), "Void instance is_constant");
+    GXmlElement xml;
+    model1.write(xml);
+    model1.read(*xml.element(0));
+    test_value(model1.type(), "DataSpace", "Void instance type");
+    test_value(model1.size(), 0, "Void instance size");
+    test_value(model1.instruments(), "SPI", "Void instance instruments");
+    test_assert(model1.is_constant(), "Void instance is_constant");
+
+    // Construct "orbit" model from OG
+    GSPIObservation obs(og_dol);
+    GSPIModelDataSpace model2(obs, "GEDSAT", "orbit", 0);
+    test_value(model2.type(), "DataSpace", "ORBIT instance type");
+    test_value(model2.size(), 1, "ORBIT instance size");
+    test_value(model2.instruments(), "SPI", "ORBIT instance instruments");
+    test_value(model2.name(), "GEDSAT", "ORBIT instance name");
+    test_value(model2[0].name(), "GEDSAT Rev0044", "ORBIT instance parameter");
+    xml.clear();
+    model2.write(xml);
+
+    // Construct "orbit" model from XML
+    GSPIModelDataSpace model3(*xml.element(0));
+    test_value(model3.type(), "DataSpace", "XML constructed instance type");
+    test_value(model3.size(), 1, "XML constructed ORBIT instance size");
+    test_value(model3.instruments(), "SPI", "XML constructed ORBIT instance instruments");
+    test_value(model3.name(), "GEDSAT", "ORBIT instance name");
+    test_value(model3[0].name(), "GEDSAT Rev0044", "XML constructed ORBIT instance parameter");
+
+    // Construct "orbit,dete" model from OG
+    GSPIModelDataSpace model4(obs, "GEDSAT", "orbit,dete", 0);
+    test_value(model4.type(), "DataSpace", "ORBIT,DETE instance type");
+    test_value(model4.size(), 19, "ORBIT,DETE instance size");
+    test_value(model4[1].name(), "GEDSAT D001 Rev0044", "ORBIT,DETE instance parameter");
+
+    // Construct "orbit,dete,ebin" model from OG
+    GSPIModelDataSpace model5(obs, "GEDSAT", "orbit,dete,ebin", 0);
+    test_value(model5.type(), "DataSpace", "ORBIT,DETE,EBIN instance type");
+    test_value(model5.size(), 190, "ORBIT,DETE,EBIN instance size");
+    test_value(model5[35].name(), "GEDSAT E005 D003 Rev0044", "ORBIT,DETE,EBIN instance parameter");
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
  * @brief Test GSPIObservation class
  ***************************************************************************/
 void TestGSPI::test_obs(void)
 {
-    // Test empty GSPIObservation instance
+    // Test content of void observation
     GSPIObservation obs1;
+    test_value(obs1.classname(), "GSPIObservation", "Void instance classname");
+    test_value(obs1.instrument(), "SPI", "Void instance instrument");
+    test_value(obs1.ontime(), 0.0, "Void instance ontime");
+    test_value(obs1.livetime(), 0.0, "Void instance livetime");
+    test_value(obs1.deadc(), 0.0, "Void instance deadc");
-    // Construct GSPIObservation instance from Observation group
+    // Test content of OG
     GSPIObservation obs2(og_dol);
+    test_value(obs2.instrument(), "SPI", "Void instance instrument");
+    test_value(obs2.ontime(), 193966.8178673, "Void instance ontime");
+    test_value(obs2.livetime(), 170657.5371606, "Void instance livetime");
+    test_value(obs2.deadc(), 0.87982851416, "Void instance deadc");
     // Return
     return;
@@ -94,6 +304,30 @@ void TestGSPI::test_obs(void)
  ***************************************************************************/
 void TestGSPI::test_response(void)
 {
+    // Set energy
+    GEnergy obsEnergy;
+
+    // Test content of void response
+    GSPIResponse rsp1;
+    test_value(rsp1.classname(), "GSPIResponse", "Void instance classname");
+    test_assert(!rsp1.use_edisp(), "Void instance use_edisp");
+    test_assert(!rsp1.use_tdisp(), "Void instance use_edisp");
+    test_assert(!rsp1.is_precomputed(), "Void instance is_precomputed");
+    
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Test GSPITools module
+ ***************************************************************************/
+void TestGSPI::test_tools(void)
+{
+    // Test methods
+    test_value(gammalib::spi_ijd2time(1500.0).utc(), "2004-02-08T23:58:56",
+               "spi_ijd2time");
+
     // Return
     return;
 }
@@ -49,8 +49,13 @@ public:
     virtual void        set(void);
     virtual TestGSPI*   clone(void) const;
     virtual std::string classname(void) const { return "TestGSPI"; }
+    void                test_instdir(void);
+    void                test_eventbin(void);
+    void                test_eventcube(void);
+    void                test_modeldataspace(void);
     void                test_obs(void);
     void                test_response(void);
+    void                test_tools(void);
 };
 #endif /* TEST_SPI_HPP */
@@ -38,8 +38,9 @@ class Test(gammalib.GPythonTestSuite):
         gammalib.GPythonTestSuite.__init__(self)
         # Set test directories
-        self._data  = os.environ['TEST_SPI_DATA']
-        self._caldb = self._data + '/../caldb'
+        self._data   = os.environ['TEST_SPI_DATA']
+        self._caldb  = self._data + '/../caldb'
+        self._og_dol = self._data + '/obs/og_spi.fits'
         # Return
         return
@@ -78,11 +79,8 @@ class Test(gammalib.GPythonTestSuite):
         """
         Test GSPIObservation class
         """
-        # Set Observation Group file name
-        og_dol = self._data + '/obs/og_spi.fits'
-
         # Load event cube
-        obs = gammalib.GSPIObservation(og_dol)
+        obs = gammalib.GSPIObservation(self._og_dol)
         self.test_value(obs.ontime(), 193966.8178673, 1.0e-6, 'Check ontime')
         self.test_value(obs.livetime(), 170657.5371606, 1.0e-6, 'Check livetime')
         self.test_value(obs.deadc(), 0.8798285, 1.0e-6, 'Check deadtime correction')
@@ -111,20 +109,26 @@ class Test(gammalib.GPythonTestSuite):
         test_support.pickeling(self, gammalib.GSPIEventBin())
         test_support.pickeling(self, gammalib.GSPIEventCube())
         test_support.pickeling(self, gammalib.GSPIInstDir())
+        test_support.pickeling(self, gammalib.GSPIModelDataSpace())
         test_support.pickeling(self, gammalib.GSPIObservation())
         test_support.pickeling(self, gammalib.GSPIResponse())
-        # Setup test (TODO: to be filled with meaningful values)
-        bin  = gammalib.GSPIEventBin()
-        cube = gammalib.GSPIEventCube()
-        dir  = gammalib.GSPIInstDir()
-        obs  = gammalib.GSPIObservation()
-        rsp  = gammalib.GSPIResponse()
+        # Setup test
+        dir = gammalib.GSkyDir()
+        dir.radec_deg(83.6331, 22.0145)
+        instdir = gammalib.GSPIInstDir(dir, 13)
+        obs = gammalib.GSPIObservation(self._og_dol)
+        model = gammalib.GSPIModelDataSpace(obs, 'GEDSAT', 'orbit', 0)
+        #
+        bin  = gammalib.GSPIEventBin()     # pickeling not yet implemented
+        cube = gammalib.GSPIEventCube()    # pickeling not yet implemented
+        rsp  = gammalib.GSPIResponse()     # pickeling not yet implemented
         # Perform pickeling tests of filled classes
         test_support.pickeling(self, gammalib.GSPIEventBin(bin))
         test_support.pickeling(self, gammalib.GSPIEventCube(cube))
-        test_support.pickeling(self, gammalib.GSPIInstDir(dir))
+        test_support.pickeling(self, gammalib.GSPIInstDir(instdir))
+        test_support.pickeling(self, gammalib.GSPIModelDataSpace(model))
         test_support.pickeling(self, gammalib.GSPIObservation(obs))
         test_support.pickeling(self, gammalib.GSPIResponse(rsp))