Change `isxxx` and `hasxxx` to `is_xxx` and `has_xxx` (issue 1061).

The coding and design conventions (CDC) document was also updated.

Change `isxxx` and `hasxxx` to `is_xxx` and `has_xxx` (issue 1061).
The coding and design conventions (CDC) document was also updated.
Christoph Deil
1 parent d56df314
Showing 223 changed files with 777 additions and 783 deletions
doc/source/coding/design.rst
doc/source/user_manual/modules/support.rst
include/GApplication.hpp
include/GContainer.hpp
include/GEbounds.hpp
include/GEnergies.hpp
include/GEvent.hpp
include/GEventAtom.hpp
include/GEventBin.hpp
include/GFits.hpp
include/GFitsHDU.hpp
include/GFitsHeader.hpp
include/GFitsTableBitCol.hpp
include/GFitsTableBoolCol.hpp
include/GFitsTableByteCol.hpp
include/GFitsTableCDoubleCol.hpp
include/GFitsTableCFloatCol.hpp
include/GFitsTableCol.hpp
include/GFitsTableDoubleCol.hpp
include/GFitsTableFloatCol.hpp
@@ -373,13 +373,7 @@ will remain open. Typically, these methods take a ``GFits*`` or a
 ``GFitsHDU*`` pointer as argument.
  
 Methods that perform checks should return a bool type and should start
-with the prefix ``is`` or ``has``. Examples are:
-
-.. code-block:: cpp
-
-    islong()
-    isin()
-    hasedisp()
+with the prefix ``is_`` or ``has_``, e.g. ``is_empty()`` or ``has_min()``.
  
 Method const declarations
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -216,8 +216,8 @@ Function                       Description
 ``gammalib::plaw_photon_flux`` Compute photon flux under a power law.
 ``gammalib::plaw_energy_flux`` Compute energy flux under a power law.
 ``gammalib::file_exists``      Check whether a file exists.
-``gammalib::isinfinite``       Check whether a double precision value is infinite.
-``gammalib::isnotanumber``     Check whether a double precision value is not a number.
+``gammalib::is_infinite``      Check whether a double precision value is infinite.
+``gammalib::is_notanumber``    Check whether a double precision value is not a number.
 ``gammalib::contains``         Check whether a string contains a sub-string.
 ``gammalib::warning``          Dump warning in console.
 ============================== ===========
@@ -76,7 +76,7 @@ public:
     bool               logVerbose(void) const;
     bool               logDebug(void) const;
     bool               clobber(void) const;
-    bool               haspar(const std::string& name) const;
+    bool               has_par(const std::string& name) const;
     const std::string& par_filename(void) const;
     const std::string& log_filename(void) const;
     void               log_header(void);
@@ -162,7 +162,7 @@ const std::string&amp; GApplication::version(void) const
  * @return True if an application parameter with the specified name exists.
  ***************************************************************************/
 inline
-bool GApplication::haspar(const std::string& name) const
+bool GApplication::has_par(const std::string& name) const
 {
     return (m_pars.contains(name));
 }
@@ -44,7 +44,7 @@
  *     clone      - Clones container (inherited from GBase)
  *     print      - Print container content (inherited from GBase)
  *     size       - Returns number of objects is container
- *     isempty    - Checks if container is empty
+ *     is_empty    - Checks if container is empty
  *     remove     - Removes an object from the container
  *     reserve    - Reserves space in the container
  ***************************************************************************/
@@ -64,7 +64,7 @@ public:
     /// @brief Checks if container is empty
     ///
     /// @return True if no objects are in container, false otherwise.
-    virtual bool isempty(void) const = 0;
+    virtual bool is_empty(void) const = 0;
  
     /// @brief Remove object from container
     ///
@@ -66,7 +66,7 @@ public:
     void           clear(void);
     GEbounds*      clone(void) const;
     int            size(void) const;
-    bool           isempty(void) const;
+    bool           is_empty(void) const;
     void           append(const GEnergy& emin, const GEnergy& emax);
     void           insert(const GEnergy& emin, const GEnergy& emax);
     void           merge(void);
@@ -74,8 +74,8 @@ public:
     void           remove(const int& index);
     void           reserve(const int& num);
     void           extend(const GEbounds& ebds);
-    void           setlin(const int& num, const GEnergy& emin, const GEnergy& emax);
-    void           setlog(const int& num, const GEnergy& emin, const GEnergy& emax);
+    void           set_lin(const int& num, const GEnergy& emin, const GEnergy& emax);
+    void           set_log(const int& num, const GEnergy& emin, const GEnergy& emax);
     void           load(const std::string& filename,
                         const std::string& extname = "EBOUNDS");
     void           save(const std::string& filename,
@@ -130,7 +130,7 @@ int GEbounds::size(void) const
  * @return True if there are no energy boundaries.
  ***************************************************************************/
 inline
-bool GEbounds::isempty(void) const
+bool GEbounds::is_empty(void) const
 {
     return (m_num == 0);
 }
@@ -65,7 +65,7 @@ public:
     GEnergy&       at(const int& index);
     const GEnergy& at(const int& index) const;
     int            size(void) const;
-    bool           isempty(void) const;
+    bool           is_empty(void) const;
     GEnergy&       append(const GEnergy& energy);
     GEnergy&       insert(const int& index, const GEnergy& energy);
     void           remove(const int& index);
@@ -141,7 +141,7 @@ int GEnergies::size(void) const
  * Signals if the energy container does not contain any energy.
  ***************************************************************************/
 inline
-bool GEnergies::isempty(void) const
+bool GEnergies::is_empty(void) const
 {
     return (m_energies.empty());
 }
@@ -44,7 +44,7 @@
  * either a physical event occuring in the instrument (called an event
  * atom) or a collection of events with similar properties (called an
  * event bin). While event atoms are used for unbinned analysis, event bins
- * are used for binned analysis. The methods isatom() and isbin() inform
+ * are used for binned analysis. The methods is_atom() and is_bin() inform
  * whether an event is an atom or a bin.
  *
  * Each event has 3 attributes: energy, instrument direction and time.
@@ -88,8 +88,8 @@ public:
     virtual const GTime&    time(void) const = 0;
     virtual double          counts(void) const = 0;
     virtual double          error(void) const = 0;
-    virtual bool            isatom(void) const = 0;
-    virtual bool            isbin(void) const = 0;
+    virtual bool            is_atom(void) const = 0;
+    virtual bool            is_bin(void) const = 0;
     virtual std::string     print(const GChatter& chatter = NORMAL) const = 0;
  
 protected:
@@ -85,8 +85,8 @@ public:
     virtual std::string     print(const GChatter& chatter = NORMAL) const = 0;
  
     // Other methods
-    bool isatom(void) const;
-    bool isbin(void) const;
+    bool is_atom(void) const;
+    bool is_bin(void) const;
  
 protected:
     // Protected methods
@@ -143,7 +143,7 @@ double GEventAtom::error(void) const
  * @return True.
  ***************************************************************************/
 inline
-bool GEventAtom::isatom(void) const
+bool GEventAtom::is_atom(void) const
 {
     return (true);
 }
@@ -155,7 +155,7 @@ bool GEventAtom::isatom(void) const
  * @return False.
  ***************************************************************************/
 inline
-bool GEventAtom::isbin(void) const
+bool GEventAtom::is_bin(void) const
 {
     return (false);
 }
@@ -88,8 +88,8 @@ public:
     virtual std::string     print(const GChatter& chatter = NORMAL) const = 0;
  
     // Other methods
-    bool isatom(void) const;
-    bool isbin(void) const;
+    bool is_atom(void) const;
+    bool is_bin(void) const;
  
 protected:
     // Protected methods
@@ -105,7 +105,7 @@ protected:
  * @return False.
  ***************************************************************************/
 inline
-bool GEventBin::isatom(void) const
+bool GEventBin::is_atom(void) const
 {
     return (false);
 }
@@ -117,7 +117,7 @@ bool GEventBin::isatom(void) const
  * @return True.
  ***************************************************************************/
 inline
-bool GEventBin::isbin(void) const
+bool GEventBin::is_bin(void) const
 {
     return (true);
 }
@@ -91,7 +91,7 @@ public:
     GFitsTable*        table(const std::string& extname);
     const GFitsTable*  table(const std::string& extname) const;
     int                size(void) const;
-    bool               isempty(void) const;
+    bool               is_empty(void) const;
     GFitsHDU*          set(const int& extno, const GFitsHDU& hdu);
     GFitsHDU*          set(const std::string& extname, const GFitsHDU& hdu);
     GFitsHDU*          append(const GFitsHDU& hdu);
@@ -230,7 +230,7 @@ int GFits::size(void) const
  * Signals if the FITS file does not contain any HDUs.
  ***************************************************************************/
 inline
-bool GFits::isempty(void) const
+bool GFits::is_empty(void) const
 {
     return (m_hdu.empty());
 }
@@ -83,8 +83,8 @@ public:
     void                   extno(const int& extno);
     GFitsHeader&           header(void);
     const GFitsHeader&     header(void) const;
-    bool                   hascard(const int& cardno) const;
-    bool                   hascard(const std::string& keyname) const;
+    bool                   has_card(const int& cardno) const;
+    bool                   has_card(const std::string& keyname) const;
     GFitsHeaderCard&       card(const int& cardno);
     const GFitsHeaderCard& card(const int& cardno) const;
     GFitsHeaderCard&       card(const std::string& keyname);
@@ -222,7 +222,7 @@ const GFitsHeader&amp; GFitsHDU::header(void) const
  * @return True if card with specified card number @p cardno exists in header.
  ***************************************************************************/
 inline
-bool GFitsHDU::hascard(const int& cardno) const
+bool GFitsHDU::has_card(const int& cardno) const
 {
     return m_header.contains(cardno);
 }
@@ -235,7 +235,7 @@ bool GFitsHDU::hascard(const int&amp; cardno) const
  * @return True if card with specified @p keyname exists in header.
  ***************************************************************************/
 inline
-bool GFitsHDU::hascard(const std::string& keyname) const
+bool GFitsHDU::has_card(const std::string& keyname) const
 {
     return (m_header.contains(keyname));
 }
@@ -74,7 +74,7 @@ public:
     int                    integer(const int& cardno) const;
     int                    integer(const std::string& keyname) const;
     int                    size(void) const;
-    bool                   isempty(void) const;
+    bool                   is_empty(void) const;
     GFitsHeaderCard&       append(const GFitsHeaderCard& card);
     GFitsHeaderCard&       insert(const int& cardno, const GFitsHeaderCard& card);
     GFitsHeaderCard&       insert(const std::string& keyname, const GFitsHeaderCard& card);
@@ -174,7 +174,7 @@ int GFitsHeader::size(void) const
  * Signals if there are no cards in the FITS header.
  ***************************************************************************/
 inline
-bool GFitsHeader::isempty(void) const
+bool GFitsHeader::is_empty(void) const
 {
     return (m_cards.empty());
 }
@@ -64,7 +64,7 @@ public:
     virtual int               integer(const int& row, const int& col = 0) const;
     virtual void              insert(const int& row, const int& nrows);
     virtual void              remove(const int& row, const int& nrows);
-    virtual bool              isloaded(void) const;
+    virtual bool              is_loaded(void) const;
  
     // Other methods
     unsigned char* data(void);
@@ -115,7 +115,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableBitCol::isloaded(void) const
+bool GFitsTableBitCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -65,7 +65,7 @@ public:
     virtual int                integer(const int& row, const int& col = 0) const;
     virtual void               insert(const int& row, const int& nrows);
     virtual void               remove(const int& row, const int& nrows);
-    virtual bool               isloaded(void) const;
+    virtual bool               is_loaded(void) const;
  
     // Other methods
     bool* data(void);
@@ -107,7 +107,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableBoolCol::isloaded(void) const
+bool GFitsTableBoolCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                integer(const int& row, const int& col = 0) const;
     virtual void               insert(const int& row, const int& nrows);
     virtual void               remove(const int& row, const int& nrows);
-    virtual bool               isloaded(void) const;
+    virtual bool               is_loaded(void) const;
  
     // Other methods
     unsigned char* data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableByteCol::isloaded(void) const
+bool GFitsTableByteCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -63,7 +63,7 @@ public:
     virtual int                   integer(const int& row, const int& col = 0) const;
     virtual void                  insert(const int& row, const int& nrows);
     virtual void                  remove(const int& row, const int& nrows);
-    virtual bool                  isloaded(void) const;
+    virtual bool                  is_loaded(void) const;
  
     // Other methods
     GFits::cdouble* data(void);
@@ -99,7 +99,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableCDoubleCol::isloaded(void) const
+bool GFitsTableCDoubleCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -63,7 +63,7 @@ public:
     virtual int                  integer(const int& row, const int& col = 0) const;
     virtual void                 insert(const int& row, const int& nrows);
     virtual void                 remove(const int& row, const int& nrows);
-    virtual bool                 isloaded(void) const;
+    virtual bool                 is_loaded(void) const;
  
     // Other methods
     GFits::cfloat* data(void);
@@ -99,7 +99,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableCFloatCol::isloaded(void) const
+bool GFitsTableCFloatCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -67,7 +67,7 @@ public:
     virtual int             integer(const int& row, const int& inx = 0) const = 0;
     virtual void            insert(const int& row, const int& nrows) = 0;
     virtual void            remove(const int& row, const int& nrows) = 0;
-    virtual bool            isloaded(void) const = 0;
+    virtual bool            is_loaded(void) const = 0;
  
     // Other methods
     void                    name(const std::string& name);
@@ -90,8 +90,8 @@ public:
     int                     elements(const int& row) const;
     void                    length(const int& length);
     const int&              length(void) const;
-    void                    isvariable(const bool& variable);
-    const bool&             isvariable(void) const;
+    void                    is_variable(const bool& variable);
+    const bool&             is_variable(void) const;
     void                    anynul(const int& anynul);
     const int&              anynul(void) const;
     std::string             tform_binary(void) const;
@@ -437,7 +437,7 @@ const int&amp; GFitsTableCol::length(void) const
  * @param[in] variable Variable-length flag.
  ***************************************************************************/
 inline
-void GFitsTableCol::isvariable(const bool& variable)
+void GFitsTableCol::is_variable(const bool& variable)
 {
     // Set variable-length flag
     m_variable = variable;
@@ -453,7 +453,7 @@ void GFitsTableCol::isvariable(const bool&amp; variable)
  * @return True if column is a variable length column
  ***************************************************************************/
 inline
-const bool& GFitsTableCol::isvariable(void) const
+const bool& GFitsTableCol::is_variable(void) const
 {
     // Return variable-length flag
     return m_variable;
@@ -62,7 +62,7 @@ public:
     virtual int                  integer(const int& row, const int& col = 0) const;
     virtual void                 insert(const int& row, const int& nrows);
     virtual void                 remove(const int& row, const int& nrows);
-    virtual bool                 isloaded(void) const;
+    virtual bool                 is_loaded(void) const;
  
     // Other methods
     double* data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableDoubleCol::isloaded(void) const
+bool GFitsTableDoubleCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                 integer(const int& row, const int& col = 0) const;
     virtual void                insert(const int& row, const int& nrows);
     virtual void                remove(const int& row, const int& nrows);
-    virtual bool                isloaded(void) const;
+    virtual bool                is_loaded(void) const;
  
     // Other methods
     float* data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableFloatCol::isloaded(void) const
+bool GFitsTableFloatCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                integer(const int& row, const int& col = 0) const;
     virtual void               insert(const int& row, const int& nrows);
     virtual void               remove(const int& row, const int& nrows);
-    virtual bool               isloaded(void) const;
+    virtual bool               is_loaded(void) const;
  
     // Other methods
     long* data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableLongCol::isloaded(void) const
+bool GFitsTableLongCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                    integer(const int& row, const int& col = 0) const;
     virtual void                   insert(const int& row, const int& nrows);
     virtual void                   remove(const int& row, const int& nrows);
-    virtual bool                   isloaded(void) const;
+    virtual bool                   is_loaded(void) const;
  
     // Other methods
     long long*  data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableLongLongCol::isloaded(void) const
+bool GFitsTableLongLongCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                 integer(const int& row, const int& col = 0) const;
     virtual void                insert(const int& row, const int& nrows);
     virtual void                remove(const int& row, const int& nrows);
-    virtual bool                isloaded(void) const;
+    virtual bool                is_loaded(void) const;
  
     // Other methods
     short* data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableShortCol::isloaded(void) const
+bool GFitsTableShortCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                  integer(const int& row, const int& col = 0) const;
     virtual void                 insert(const int& row, const int& nrows);
     virtual void                 remove(const int& row, const int& nrows);
-    virtual bool                 isloaded(void) const;
+    virtual bool                 is_loaded(void) const;
  
     // Other methods
     std::string* data(void);
@@ -104,7 +104,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableStringCol::isloaded(void) const
+bool GFitsTableStringCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                 integer(const int& row, const int& col = 0) const;
     virtual void                insert(const int& row, const int& nrows);
     virtual void                remove(const int& row, const int& nrows);
-    virtual bool                isloaded(void) const;
+    virtual bool                is_loaded(void) const;
  
     // Other methods
     unsigned long* data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableULongCol::isloaded(void) const
+bool GFitsTableULongCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -62,7 +62,7 @@ public:
     virtual int                  integer(const int& row, const int& col = 0) const;
     virtual void                 insert(const int& row, const int& nrows);
     virtual void                 remove(const int& row, const int& nrows);
-    virtual bool                 isloaded(void) const;
+    virtual bool                 is_loaded(void) const;
  
     // Other methods
     unsigned short* data(void);
@@ -98,7 +98,7 @@ private:
  * @return True if column has been loaded, false otherwise
  ***************************************************************************/
 inline
-bool GFitsTableUShortCol::isloaded(void) const
+bool GFitsTableUShortCol::is_loaded(void) const
 {
     return (m_data != NULL);
 }
@@ -66,7 +66,7 @@ public:
     void                  clear(void);
     GGti*                 clone(void) const;
     int                   size(void) const;
-    bool                  isempty(void) const;
+    bool                  is_empty(void) const;
     void                  append(const GTime& tstart, const GTime& tstop);
     void                  insert(const GTime& tstart, const GTime& tstop);
     void                  merge(void);
@@ -132,7 +132,7 @@ int GGti::size(void) const
  * @return True if there are no Good Time Intervals.
  ***************************************************************************/
 inline
-bool GGti::isempty(void) const
+bool GGti::is_empty(void) const
 {
     return (m_num == 0);
 }
@@ -40,9 +40,9 @@ class GVector;
 /***********************************************************************//**
  * @class GMatrix
  *
- * @brief Generic matrix class defintion
+ * @brief Generic matrix class definition
  *
- * This class implements a generic matrix. The class is a non-spezialized
+ * This class implements a generic matrix. The class is a non-specialized
  * representation of a matrix, and all other matrix storage classes can be
  * converted into that class.
  *
@@ -59,7 +59,7 @@ class GVector;
  * where @p rows and @p columns specify the number of rows and columns of
  * the matrix. Storage conversion constructors exist that allow allocating
  * a generic matrix by copying from a sparse matrix of type GMatrixSparse
- * and a symmetrix matrix of type GMatrixSymmetric.
+ * and a symmetric matrix of type GMatrixSymmetric.
  *
  * To support using the GMatrix for coordinate transformations, methods
  * are available to compute matrices for the three Euler angles:
@@ -36,7 +36,7 @@
 /***********************************************************************//**
  * @class GMatrixBase
  *
- * @brief Abstract matrix base class interface defintion
+ * @brief Abstract matrix base class interface definition
  *
  * This class provides the abstract interface for all matrix classes. A
  * GammaLib matrix is a two dimensional array of double precision values
@@ -48,7 +48,7 @@ class GSparseNumeric;
 /***********************************************************************//**
  * @class GMatrixSparse
  *
- * @brief Sparse matrix class interface defintion
+ * @brief Sparse matrix class interface definition
  *
  * This class implements a sparse matrix. The class only stores non-zero
  * elements, which can considerably reduce the memory requirements for large
@@ -123,7 +123,7 @@ class GSparseNumeric;
  * the matrix and @p elements is the size of the memory that should be
  * pre-allocated for matrix storage (optional). Storage conversion
  * constructors exist that allow allocating a sparse matrix by copying from
- * a general matrix of type GMatrix and a symmetrix matrix of type
+ * a general matrix of type GMatrix and a symmetric matrix of type
  * GMatrixSymmetric.
  *
  * Because the location of a specific matrix element is not necessarily known
@@ -167,7 +167,7 @@ class GSparseNumeric;
  * 512 is used. If @p entries is set to 0 (the default value), the number of
  * matrix columns is taken as default @p entries value. Note that a too large
  * number of elements will produce some overhead due to fill stack
- * management, hence @p entries should not exceeed a value of the order of
+ * management, hence @p entries should not exceed a value of the order of
  * 10-100.
  *
  * The stack_flush() method flushes the stack, which is mandatory before any
@@ -69,7 +69,7 @@ class GObservation;
  * handling does not actual depend on the value of this text string.
  *
  * The model @p instruments is a list of text strings that specifies the
- * instruments to which the model applies. The isvalid() method will check
+ * instruments to which the model applies. The is_valid() method will check
  * a given instrument name against that list to verify if the model applies
  * to an instrument. The instruments() method returns a comma separated
  * list of all instruments. Another instance of this method allows setting
@@ -78,7 +78,7 @@ class GObservation;
  *
  * The model @p ids is a list of text strings that specifies the observation
  * identifiers to which the model applies. This allows specifying of models
- * for a specific list of observations. The isvalid() method will check
+ * for a specific list of observations. The is_valid() method will check
  * a given observation identifier against that list to verify if the model
  * applies. The ids() method returns a comma separated list of all
  * observation identifiers. Another instance of this method allows setting
@@ -115,7 +115,7 @@ public:
     virtual void        clear(void) = 0;
     virtual GModel*     clone(void) const = 0;
     virtual std::string type(void) const = 0;
-    virtual bool        isconstant(void) const = 0;
+    virtual bool        is_constant(void) const = 0;
     virtual double      eval(const GEvent& event,
                              const GObservation& obs) const = 0;
     virtual double      eval_gradients(const GEvent& event,
@@ -130,7 +130,7 @@ public:
     int                 size(void) const;
     GModelPar&          at(const int& index);
     const GModelPar&    at(const int& index) const;
-    bool                haspar(const std::string& name) const;
+    bool                has_par(const std::string& name) const;
     const std::string&  name(void) const;
     void                name(const std::string& name);
     std::string         instruments(void) const;
@@ -139,7 +139,7 @@ public:
     void                scale(const GModelPar& par);
     std::string         ids(void) const;
     void                ids(const std::string& ids);
-    bool                isvalid(const std::string& instruments,
+    bool                is_valid(const std::string& instruments,
                                 const std::string& ids) const;
  
 protected:
@@ -66,7 +66,7 @@ public:
     virtual void        clear(void) = 0;
     virtual GModelData* clone(void) const = 0;
     virtual std::string type(void) const = 0;
-    virtual bool        isconstant(void) const = 0;
+    virtual bool        is_constant(void) const = 0;
     virtual double      eval(const GEvent& event,
                              const GObservation& obs) const = 0;
     virtual double      eval_gradients(const GEvent& event,
@@ -54,7 +54,7 @@
  * value of a parameter.
  *
  * The minimum and maximum values are optional, and existence of these
- * attributes is tested using the hasmin() and hasmax() methods,
+ * attributes is tested using the has_min() and has_max() methods,
  * respectively. The minimum value, maximum value are removed using the
  * remove_min() and remove_max() methods. Simultaneous removal of minimum
  * and maximum values is done using the remove_range() method.
@@ -65,8 +65,8 @@
  *      analytically (true) or numerically (false)
  *
  * The parameter property @p free is set using the free() and fix()
- * methods and it is retrieved using the isfree() and isfixed() methods.
- * The attribute @p grad is set and retrieved using the has hasgrad()
+ * methods and it is retrieved using the is_free() and is_fixed() methods.
+ * The attribute @p grad is set and retrieved using the has has_grad()
  * methods.
  *
  * Each model parameter is factorized into a @p factor and a @p scale
@@ -146,7 +146,7 @@ public:
     virtual void        clear(void);
     virtual GModelSky*  clone(void) const;
     virtual std::string type(void) const;
-    virtual bool        isconstant(void) const;
+    virtual bool        is_constant(void) const;
     virtual double      eval(const GEvent& event,
                              const GObservation& obs) const;
     virtual double      eval_gradients(const GEvent& event,
@@ -226,7 +226,7 @@ std::string GModelSky::type(void) const
  * model is a model that has a temporal component of type "Constant".
  ***************************************************************************/
 inline
-bool GModelSky::isconstant(void) const
+bool GModelSky::is_constant(void) const
 {
     return (m_temporal != NULL && m_temporal->type() == "Constant");
 }
@@ -51,12 +51,12 @@ class GObservation;
  *
  * The GModels class provides methods to manage and to access the models
  * in the container. The number of models in the container is retrieved
- * using the size() method. The isempty() method can be used to check
+ * using the size() method. The is_empty() method can be used to check
  * whether the container is empty or whether it contains models:
  *
  *     GModels models;                 // Allocate container
  *     int n = models.size();          // Number of models in container
- *     if (models.isempty())           // Check for emptiness
+ *     if (models.is_empty())           // Check for emptiness
  *         std::cout << "Empty container";
  *
  * Access operators exist for accessing of models by index or by name:
@@ -164,7 +164,7 @@ public:
     GModel*        at(const int& index);
     const GModel*  at(const int& index) const;
     int            size(void) const;
-    bool           isempty(void) const;
+    bool           is_empty(void) const;
     GModel*        set(const int& index, const GModel& model);
     GModel*        set(const std::string& name, const GModel& model);
     GModel*        append(const GModel& model);
@@ -247,7 +247,7 @@ int GModels::size(void) const
  * Signals if the model container does not contain any model.
  ***************************************************************************/
 inline
-bool GModels::isempty(void) const
+bool GModels::is_empty(void) const
 {
     return (m_models.empty());
 }
@@ -74,7 +74,7 @@ public:
     double&       at(const int& index);
     const double& at(const int& index) const;
     int           size(void) const;
-    bool          isempty(void) const;
+    bool          is_empty(void) const;
     void          append(const double& node);
     void          insert(const int& index, const double& node);
     void          remove(const int& index);
@@ -173,7 +173,7 @@ int GNodeArray::size(void) const
  * Signals if the node array does not contain any node.
  ***************************************************************************/
 inline
-bool GNodeArray::isempty(void) const
+bool GNodeArray::is_empty(void) const
 {
     return (m_node.empty());
 }
@@ -107,7 +107,7 @@ public:
     GObservation*       at(const int& index);
     const GObservation* at(const int& index) const;
     int                 size(void) const;
-    bool                isempty(void) const;
+    bool                is_empty(void) const;
     GObservation*       set(const int& index, const GObservation& obs);
     GObservation*       append(const GObservation& obs);
     GObservation*       insert(const int& index, const GObservation& obs);
@@ -232,7 +232,7 @@ int GObservations::size(void) const
  * Signals if the observation container does not contain any observation.
  ***************************************************************************/
 inline
-bool GObservations::isempty(void) const
+bool GObservations::is_empty(void) const
 {
     return (m_obs.empty());
 }
@@ -55,7 +55,7 @@
  * value of a parameter.
  *
  * The minimum and maximum values are optional, and existence of these
- * attributes is tested using the hasmin() and hasmax() methods,
+ * attributes is tested using the has_min() and has_max() methods,
  * respectively. The minimum value, maximum value are removed using the
  * remove_min() and remove_max() methods. Simultaneous removal of minimum
  * and maximum values is done using the remove_range() method.
@@ -66,8 +66,8 @@
  *      analytically (true) or numerically (false)
  *
  * The parameter property @p free is set using the free() and fix()
- * methods and it is retrieved using the isfree() and isfixed() methods.
- * The attribute @p grad is set and retrieved using the has hasgrad()
+ * methods and it is retrieved using the is_free() and is_fixed() methods.
+ * The attribute @p grad is set and retrieved using the has has_grad()
  * methods.
  *
  * Each function parameter is factorized into a @p factor and a @p scale
@@ -128,20 +128,20 @@ public:
     void          scale(const double& scale);
  
     // Boundary methods
-    bool hasmin(void) const;
-    bool hasmax(void) const;
-    bool hasrange(void) const;
+    bool has_min(void) const;
+    bool has_max(void) const;
+    bool has_range(void) const;
     void remove_min(void);
     void remove_max(void);
     void remove_range(void);
  
     // Property methods
-    bool isfree(void) const;
-    bool isfixed(void) const;
-    bool hasgrad(void) const;
+    bool is_free(void) const;
+    bool is_fixed(void) const;
+    bool has_grad(void) const;
     void free(void);
     void fix(void);
-    void hasgrad(const bool& grad);
+    void has_grad(const bool& grad);
  
     // Other methods
     void               clear(void);
@@ -169,9 +169,9 @@ protected:
     double      m_factor_max;      //!< Parameter maximum factor
     double      m_scale;           //!< Parameter scaling (true = factor * scale)
     bool        m_free;            //!< Parameter is free
-    bool        m_hasmin;          //!< Parameter has minimum boundary
-    bool        m_hasmax;          //!< Parameter has maximum boundary
-    bool        m_hasgrad;         //!< Parameter has analytic gradient
+    bool        m_has_min;          //!< Parameter has minimum boundary
+    bool        m_has_max;          //!< Parameter has maximum boundary
+    bool        m_has_grad;         //!< Parameter has analytic gradient
 };
  
  
@@ -372,9 +372,9 @@ void GOptimizerPar::factor_gradient(const double&amp; gradient)
  * Signals if the parameter has a minimum boundary.
  ***************************************************************************/
 inline
-bool GOptimizerPar::hasmin(void) const
+bool GOptimizerPar::has_min(void) const
 {
-    return m_hasmin;
+    return m_has_min;
 }
  
  
@@ -386,9 +386,9 @@ bool GOptimizerPar::hasmin(void) const
  * Signals if the parameter has a maximum boundary.
  ***************************************************************************/
 inline
-bool GOptimizerPar::hasmax(void) const
+bool GOptimizerPar::has_max(void) const
 {
-    return m_hasmax;
+    return m_has_max;
 }
  
  
@@ -401,9 +401,9 @@ bool GOptimizerPar::hasmax(void) const
  * Signals if the parameter has a minimum and a maximum boundary.
  ***************************************************************************/
 inline
-bool GOptimizerPar::hasrange(void) const
+bool GOptimizerPar::has_range(void) const
 {
-    return (m_hasmin && m_hasmax);
+    return (m_has_min && m_has_max);
 }
  
  
@@ -415,7 +415,7 @@ bool GOptimizerPar::hasrange(void) const
 inline
 void GOptimizerPar::remove_min(void)
 {
-    m_hasmin = false;
+    m_has_min = false;
     return;
 }
  
@@ -428,7 +428,7 @@ void GOptimizerPar::remove_min(void)
 inline
 void GOptimizerPar::remove_max(void)
 {
-    m_hasmax = false;
+    m_has_max = false;
     return;
 }
  
@@ -441,8 +441,8 @@ void GOptimizerPar::remove_max(void)
 inline
 void GOptimizerPar::remove_range(void)
 {
-    m_hasmin = false;
-    m_hasmax = false;
+    m_has_min = false;
+    m_has_max = false;
     return;
 }
  
@@ -456,7 +456,7 @@ void GOptimizerPar::remove_range(void)
  * parameter optimization process.
  ***************************************************************************/
 inline
-bool GOptimizerPar::isfree(void) const
+bool GOptimizerPar::is_free(void) const
 {
     return m_free;
 }
@@ -471,7 +471,7 @@ bool GOptimizerPar::isfree(void) const
  * parameter optimization process.
  ***************************************************************************/
 inline
-bool GOptimizerPar::isfixed(void) const
+bool GOptimizerPar::is_fixed(void) const
 {
     return (!m_free);
 }
@@ -488,9 +488,9 @@ bool GOptimizerPar::isfixed(void) const
  * which gradients need to be computed numerically.
  ***************************************************************************/
 inline
-bool GOptimizerPar::hasgrad(void) const
+bool GOptimizerPar::has_grad(void) const
 {
-    return m_hasgrad;
+    return m_has_grad;
 }
  
  
@@ -533,9 +533,9 @@ void GOptimizerPar::fix(void)
  * numerically.
  ***************************************************************************/
 inline
-void GOptimizerPar::hasgrad(const bool& grad)
+void GOptimizerPar::has_grad(const bool& grad)
 {
-    m_hasgrad = grad;
+    m_has_grad = grad;
     return;
 }
  
@@ -70,7 +70,7 @@ public:
     GOptimizerPar*       at(const int& index);
     const GOptimizerPar* at(const int& index) const;
     int                  size(void) const;
-    bool                 isempty(void) const;
+    bool                 is_empty(void) const;
     int                  nfree(void) const;
     GOptimizerPar*       set(const int& index, const GOptimizerPar& par);
     GOptimizerPar*       set(const std::string& name, const GOptimizerPar& par);
@@ -151,7 +151,7 @@ int GOptimizerPars::size(void) const
  * Signals if the parameters container does not contain any parameter.
  ***************************************************************************/
 inline
-bool GOptimizerPars::isempty(void) const
+bool GOptimizerPars::is_empty(void) const
 {
     return (m_pars.empty());
 }
@@ -79,12 +79,12 @@ public:
     const std::string& min(void) const;
     const std::string& max(void) const;
     const std::string& prompt(void) const;
-    bool               islearn(void) const;
-    bool               isquery(void) const;
-    bool               isfilename(void) const;
-    bool               isvalid(void);
-    bool               isundefined(void);
-    bool               isnotanumber(void);
+    bool               is_learn(void) const;
+    bool               is_query(void) const;
+    bool               is_filename(void) const;
+    bool               is_valid(void);
+    bool               is_undefined(void);
+    bool               is_notanumber(void);
     std::string        print(const GChatter& chatter = NORMAL) const;
  
 protected:
@@ -68,7 +68,7 @@ public:
     GPar&       at(const int& index);
     const GPar& at(const int& index) const;
     int         size(void) const;
-    bool        isempty(void) const;
+    bool        is_empty(void) const;
     GPar&       append(const GPar& par);
     void        append_standard(void);
     GPar&       insert(const int& index, const GPar& par);
@@ -158,7 +158,7 @@ int GPars::size(void) const
  * Signals if the parameter container does not contain any parameter.
  ***************************************************************************/
 inline
-bool GPars::isempty(void) const
+bool GPars::is_empty(void) const
 {
     return (m_pars.empty());
 }
@@ -59,7 +59,7 @@ public:
     void           clear(void);
     GPhotons*      clone(void) const;
     int            size(void) const;
-    bool           isempty(void) const;
+    bool           is_empty(void) const;
     void           append(const GPhoton& photon);
     void           insert(const int& index, const GPhoton& photon);
     void           remove(const int& index);
@@ -96,7 +96,7 @@ int GPhotons::size(void) const
  * @return True if there are no photons.
  ***************************************************************************/
 inline
-bool GPhotons::isempty(void) const
+bool GPhotons::is_empty(void) const
 {
     return m_photons.empty();
 }
@@ -72,8 +72,8 @@ public:
     // Pure virtual methods
     virtual void        clear(void) = 0;
     virtual GResponse*  clone(void) const = 0;
-    virtual bool        hasedisp(void) const = 0;
-    virtual bool        hastdisp(void) const = 0;
+    virtual bool        has_edisp(void) const = 0;
+    virtual bool        has_tdisp(void) const = 0;
     virtual double      irf(const GEvent&       event,
                             const GPhoton&      photon,
                             const GObservation& obs) const = 0;
@@ -62,13 +62,13 @@
  *    int    index  = GSkyPixel(1);       // Retrieve integer index
  *    double dindex = GSkyPixel(1.0);     // Retrieve double precision index
  *
- * The dimensionality of a pixel is checked using the is1D() and is2D()
+ * The dimensionality of a pixel is checked using the is_1D() and is_2D()
  * methods. The size() method returns 1 for 1D pixels and 2 for 2D pixels.
  * If a pixel is not initialised, e.g.
  *
  *    GSkyPixel pixel;                    // Not initialised
  *
- * the is1D() and is2D() methods return false and the size() method returns
+ * the is_1D() and is_2D() methods return false and the size() method returns
  * 0.
  ***************************************************************************/
 class GSkyPixel : public GBase {
@@ -92,8 +92,8 @@ public:
     void          clear(void);
     GSkyPixel*    clone(void) const;
     int           size(void) const;
-    bool          is1D(void) const;
-    bool          is2D(void) const;
+    bool          is_1D(void) const;
+    bool          is_2D(void) const;
     void          index(const double& index);
     void          x(const double& x);
     void          y(const double& y);
@@ -137,7 +137,7 @@ int GSkyPixel::size(void) const
  * @return True if pixel is 1D.
  ***************************************************************************/
 inline
-bool GSkyPixel::is1D(void) const
+bool GSkyPixel::is_1D(void) const
 {
     return (m_size == 1);
 }
@@ -149,7 +149,7 @@ bool GSkyPixel::is1D(void) const
  * @return True if pixel is 2D.
  ***************************************************************************/
 inline
-bool GSkyPixel::is2D(void) const
+bool GSkyPixel::is_2D(void) const
 {
     return (m_size == 2);
 }
@@ -72,7 +72,7 @@ public:
     GSkyRegion*        at(const int& index);
     const GSkyRegion*  at(const int& index) const;
     int                size(void) const;
-    bool               isempty(void) const;
+    bool               is_empty(void) const;
     GSkyRegion*        set(const int& index, const GSkyRegion& region);
     GSkyRegion*        set(const std::string& name, const GSkyRegion& region);
     GSkyRegion*        append(const GSkyRegion& region);
@@ -83,7 +83,7 @@ public:
     void               reserve(const int& num);
     void               extend(const GSkyRegions& regions);
     bool               contains(const std::string& name) const;
-	bool               contains(const GSkyDir& dir) const;
+    bool               contains(const GSkyDir& dir) const;
     bool               overlaps(const GSkyRegion& reg) const;
     void               load(const std::string& filename);
     void               save(const std::string& filename) const;
@@ -153,7 +153,7 @@ int GSkyRegions::size(void) const
  * Signals if the region container does not contain any region.
  ***************************************************************************/
 inline
-bool GSkyRegions::isempty(void) const
+bool GSkyRegions::is_empty(void) const
 {
     return (m_regions.empty());
 }
@@ -67,7 +67,7 @@ public:
     GTestSuite*        at(const int& index);
     const GTestSuite*  at(const int& index) const;
     int                size(void) const;
-    bool               isempty(void) const;
+    bool               is_empty(void) const;
     GTestSuite*        set(const int& index, const GTestSuite& suite);
     GTestSuite*        append(const GTestSuite& suite);
     GTestSuite*        insert(const int& index, const GTestSuite& suite);
@@ -154,7 +154,7 @@ int GTestSuites::size(void) const
  * Signals if the container does not contain any test suite.
  ***************************************************************************/
 inline
-bool GTestSuites::isempty(void) const
+bool GTestSuites::is_empty(void) const
 {
     return (m_testsuites.empty());
 }
@@ -59,7 +59,7 @@ public:
     void        clear(void);
     GTimes*     clone(void) const;
     int         size(void) const;
-    bool        isempty(void) const;
+    bool        is_empty(void) const;
     void        append(const GTime& time);
     void        insert(const int& index, const GTime& time);
     void        remove(const int& index);
@@ -96,7 +96,7 @@ int GTimes::size(void) const
  * @return True if there are no times.
  ***************************************************************************/
 inline
-bool GTimes::isempty(void) const
+bool GTimes::is_empty(void) const
 {
     return m_times.empty();
 }
@@ -88,9 +88,9 @@ namespace gammalib {
                                               const double& epivot,
                                               const double& gamma);
     bool                     file_exists(const std::string& filename);
-    bool                     isinfinite(const double& x);
-    bool                     isnotanumber(const double& x);
-    bool 					 contains(const std::string& str,
+    bool                     is_infinite(const double& x);
+    bool                     is_notanumber(const double& x);
+    bool                     contains(const std::string& str,
                                       const std::string& substring);
     void                     warning(const std::string& origin,
                                      const std::string& message);
@@ -107,7 +107,7 @@ namespace gammalib {
  * This function has been copied from gnulib.
  ***************************************************************************/
 inline
-bool gammalib::isinfinite(const double& x)
+bool gammalib::is_infinite(const double& x)
 {
   return (x < -DBL_MAX || x > DBL_MAX);
 }
@@ -124,7 +124,7 @@ bool gammalib::isinfinite(const double&amp; x)
  * This function is a very simple kluge. It may not work on all systems.
  ***************************************************************************/
 inline
-bool gammalib::isnotanumber(const double& x)
+bool gammalib::is_notanumber(const double& x)
 {
   return (x != x);
 }
@@ -59,8 +59,8 @@ public:
     virtual void        close(void) = 0;
     virtual int         read(void* buffer, const int& nbyte) = 0;
     virtual int         write(const void* buffer, const int& nbyte) = 0;
-    virtual int         getchar(void) const = 0;
-    virtual void        putchar(const int& character) = 0;
+    virtual int         get_char(void) const = 0;
+    virtual void        put_char(const int& character) = 0;
     virtual void        scanf(const char* format, ...) = 0;
     virtual void        printf(const char* format, ...) = 0;
     virtual std::string print(const GChatter& chatter = NORMAL) const = 0;
@@ -57,8 +57,8 @@ public:
     virtual void        close(void);
     virtual int         read(void* buffer, const int& nbyte);
     virtual int         write(const void* buffer, const int& nbyte);
-    virtual int         getchar(void) const;
-    virtual void        putchar(const int& character);
+    virtual int         get_char(void) const;
+    virtual void        put_char(const int& character);
     virtual void        scanf(const char* format, ...);
     virtual void        printf(const char* format, ...);
     virtual std::string print(const GChatter& chatter = NORMAL) const;
@@ -58,8 +58,8 @@ public:
     virtual void        close(void);
     virtual int         read(void* buffer, const int& nbyte);
     virtual int         write(const void* buffer, const int& nbyte);
-    virtual int         getchar(void) const;
-    virtual void        putchar(const int& character);
+    virtual int         get_char(void) const;
+    virtual void        put_char(const int& character);
     virtual void        scanf(const char* format, ...);
     virtual void        printf(const char* format, ...);
     virtual std::string print(const GChatter& chatter = NORMAL) const;
@@ -65,8 +65,8 @@ public:
     GVOClient*  clone(void) const;
     void        connect(void);
     void        disconnect(void);
-    bool        hashub(void) const;
-    bool        isconnected(void) const;
+    bool        has_hub(void) const;
+    bool        is_connected(void) const;
     GXml        response(void) const;
     std::string print(const GChatter& chatter = NORMAL) const;
  
@@ -122,7 +122,7 @@
  * methods are available. size() returns the number of child nodes that
  * exist in the XML document root (in the above example there would be two
  * child elements with name @p element). The child nodes are accessed using
- * the operator[]. The isempty() method checks whether the document root has
+ * the operator[]. The is_empty() method checks whether the document root has
  * no children.
  *
  * The set() method allows to set a specific child node, the append() method
@@ -191,7 +191,7 @@ public:
     void               clear(void);
     GXml*              clone(void) const;
     int                size(void) const { return m_root.size(); }
-    bool               isempty(void) const { return m_root.isempty(); }
+    bool               is_empty(void) const { return m_root.is_empty(); }
     GXmlNode*          set(const int& index, const GXmlNode& node);
     GXmlNode*          append(const GXmlNode& node);
     GXmlElement*       append(const std::string& segment);
@@ -82,7 +82,7 @@ public:
     virtual void               clear(void) = 0;
     virtual GXmlNode*          clone(void) const = 0;
     virtual int                size(void) const { return m_nodes.size(); }
-    virtual bool               isempty(void) const { return m_nodes.empty(); }
+    virtual bool               is_empty(void) const { return m_nodes.empty(); }
     virtual GXmlNode*          set(const int& index, const GXmlNode& node);
     virtual GXmlNode*          append(const GXmlNode& node);
     virtual GXmlElement*       append(const std::string& segment);
@@ -64,7 +64,7 @@ public:
     virtual void                 clear(void);
     virtual GCOMModelDRBFitting* clone(void) const;
     virtual std::string          type(void) const;
-    virtual bool                 isconstant(void) const;
+    virtual bool                 is_constant(void) const;
     virtual double               eval(const GEvent& event,
                                       const GObservation& obs) const;
     virtual double               eval_gradients(const GEvent& event,
@@ -121,7 +121,7 @@ std::string GCOMModelDRBFitting::type(void) const
  * model is always temporally constant.
  ***************************************************************************/
 inline
-bool GCOMModelDRBFitting::isconstant(void) const
+bool GCOMModelDRBFitting::is_constant(void) const
 {
     return (true);
 }
@@ -59,8 +59,8 @@ public:
     // Implement pure virtual base class methods
     virtual void          clear(void);
     virtual GCOMResponse* clone(void) const;
-    virtual bool          hasedisp(void) const { return false; }
-    virtual bool          hastdisp(void) const { return false; }
+    virtual bool          has_edisp(void) const { return false; }
+    virtual bool          has_tdisp(void) const { return false; }
     virtual double        irf(const GEvent&       event,
                               const GPhoton&      photon,
                               const GObservation& obs) const;
@@ -46,7 +46,7 @@ public:
     virtual void                 clear(void);
     virtual GCOMModelDRBFitting* clone(void) const;
     virtual std::string          type(void) const;
-    virtual bool                 isconstant(void) const;
+    virtual bool                 is_constant(void) const;
     virtual double               eval(const GEvent& event,
                                       const GObservation& obs) const;
     virtual double               eval_gradients(const GEvent& event,
@@ -45,8 +45,8 @@ public:
     // Implement pure virtual base class methods
     virtual void          clear(void);
     virtual GCOMResponse* clone(void) const;
-    virtual bool          hasedisp(void) const;
-    virtual bool          hastdisp(void) const;
+    virtual bool          has_edisp(void) const;
+    virtual bool          has_tdisp(void) const;
     virtual double        irf(const GEvent&       event,
                               const GPhoton&      photon,
                               const GObservation& obs) const;
@@ -299,7 +299,7 @@ double GCOMModelDRBFitting::eval(const GEvent&amp;       event,
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+        if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
             std::cout << "*** ERROR: GCOMModelDRBFitting::eval";
             std::cout << "(index=" << index << "):";
             std::cout << " NaN/Inf encountered";
@@ -375,7 +375,7 @@ double GCOMModelDRBFitting::eval_gradients(const GEvent&amp;       event,
             scale = m_values[0].value();
  
             // Compute partial derivative
-            double grad = (m_values[0].isfree()) ? value * m_values[0].scale() : 0.0;
+            double grad = (m_values[0].is_free()) ? value * m_values[0].scale() : 0.0;
  
             // Set gradient (circumvent const correctness)
             const_cast<GCOMModelDRBFitting*>(this)->m_values[0].factor_gradient(grad);
@@ -405,13 +405,13 @@ double GCOMModelDRBFitting::eval_gradients(const GEvent&amp;       event,
                     m_values[inx_right].value() * wgt_right;
  
             // Gradient for left node
-            if (m_values[inx_left].isfree()) {
+            if (m_values[inx_left].is_free()) {
                 double grad = wgt_left * value * m_values[inx_left].scale();
                 const_cast<GCOMModelDRBFitting*>(this)->m_values[inx_left].factor_gradient(grad);
             }
  
             // Gradient for right node
-            if (m_values[inx_right].isfree()) {
+            if (m_values[inx_right].is_free()) {
                 double grad = wgt_right * value * m_values[inx_right].scale();
                 const_cast<GCOMModelDRBFitting*>(this)->m_values[inx_right].factor_gradient(grad);
             }
@@ -423,7 +423,7 @@ double GCOMModelDRBFitting::eval_gradients(const GEvent&amp;       event,
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+        if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
             std::cout << "*** ERROR: GCOMModelDRBFitting::eval_gradients";
             std::cout << "(index=" << index << "):";
             std::cout << " NaN/Inf encountered";
@@ -579,12 +579,12 @@ void GCOMModelDRBFitting::read(const GXmlElement&amp; xml)
         // Set Phibar attributes
         phibar.name(phibar_name);
         phibar.unit("deg");
-        phibar.hasgrad(false);
+        phibar.has_grad(false);
  
         // Set normalization attributes
         normalization.name(normalization_name);
         normalization.unit("");
-        normalization.hasgrad(true);
+        normalization.has_grad(true);
  
         // Push node parameters on list
         m_phibars.push_back(phibar);
@@ -858,10 +858,10 @@ void GCOMModelDRBFitting::set_pointers(void)
     for (int i = 0; i < nodes; ++i) {
  
         // Signal that Phibar values have no gradients
-        m_phibars[i].hasgrad(false);
+        m_phibars[i].has_grad(false);
  
         // Signal that values have gradients
-        m_values[i].hasgrad(true);
+        m_values[i].has_grad(true);
  
         // Set pointer
         m_pars.push_back(&(m_phibars[i]));
@@ -904,7 +904,7 @@ void GCOMModelDRBFitting::set_cache(void) const
             double phibar = m_phibars[i].value();
             m_nodes.append(phibar);
             m_old_phibars.push_back(phibar);
-            if (m_phibars[i].isfree()) {
+            if (m_phibars[i].is_free()) {
                 m_fixed = false;
             }
         }
@@ -841,8 +841,8 @@ void GCOMObservation::read_attributes(const GFitsHDU* hdu)
     if (hdu != NULL) {
  
         // Read observation information
-        m_obs_id = (hdu->hascard("OBS_ID")) ? hdu->real("OBS_ID") : 0;
-        m_name   = (hdu->hascard("OBJECT")) ? hdu->string("OBJECT") : "unknown";
+        m_obs_id = (hdu->has_card("OBS_ID")) ? hdu->real("OBS_ID") : 0;
+        m_name   = (hdu->has_card("OBJECT")) ? hdu->string("OBJECT") : "unknown";
  
         // Compute ontime
         double tstart = hdu->real("TSTART");
@@ -320,7 +320,7 @@ double GCOMResponse::irf(const GEvent&amp;       event,
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+    if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
         std::cout << "*** ERROR: GCOMResponse::irf:";
         std::cout << " NaN/Inf encountered";
         std::cout << " (irf=" << irf;
@@ -354,7 +354,7 @@ double GCOMResponse::npred(const GPhoton&amp;      photon,
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+    if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
         std::cout << "*** ERROR: GCOMResponse::npred:";
         std::cout << " NaN/Inf encountered";
         std::cout << " (";
@@ -67,7 +67,7 @@ public:
     virtual void                 clear(void);
     virtual GCTAModelBackground* clone(void) const;
     virtual std::string          type(void) const;
-    virtual bool                 isconstant(void) const;
+    virtual bool                 is_constant(void) const;
     virtual double               eval(const GEvent& event,
                                       const GObservation& obs) const;
     virtual double               eval_gradients(const GEvent& event,
@@ -192,7 +192,7 @@ std::string GCTAModelBackground::type(void) const
  * model is a model that has a temporal component of type "Constant".
  ***************************************************************************/
 inline
-bool GCTAModelBackground::isconstant(void) const
+bool GCTAModelBackground::is_constant(void) const
 {
     return (m_temporal != NULL && m_temporal->type() == "Constant");
 }
@@ -67,7 +67,7 @@ public:
     virtual void                       clear(void);
     virtual GCTAModelRadialAcceptance* clone(void) const;
     virtual std::string                type(void) const;
-    virtual bool                       isconstant(void) const;
+    virtual bool                       is_constant(void) const;
     virtual double                     eval(const GEvent& event,
                                             const GObservation& obs) const;
     virtual double                     eval_gradients(const GEvent& event,
@@ -146,7 +146,7 @@ std::string GCTAModelRadialAcceptance::type(void) const
  * is a model that has a temporal component of type "Constant".
  ***************************************************************************/
 inline
-bool GCTAModelRadialAcceptance::isconstant(void) const
+bool GCTAModelRadialAcceptance::is_constant(void) const
 {
     return (m_temporal != NULL && m_temporal->type() == "Constant");
 }
@@ -63,7 +63,7 @@ public:
     GCTAOnOffObservation*       at(const int& index);
     const GCTAOnOffObservation* at(const int& index) const;
     int                         size(void) const;
-    bool                        isempty(void) const;
+    bool                        is_empty(void) const;
     GCTAOnOffObservation*       set(const int& index, const GCTAOnOffObservation& obs);
     GCTAOnOffObservation*       append(const GCTAOnOffObservation& obs);
     GCTAOnOffObservation*       insert(const int& index, const GCTAOnOffObservation& obs);
@@ -157,7 +157,7 @@ int GCTAOnOffObservations::size(void) const
  * Signals if the observation container does not contain any observation.
  ***************************************************************************/
 inline
-bool GCTAOnOffObservations::isempty(void) const
+bool GCTAOnOffObservations::is_empty(void) const
 {
     return (m_obs.empty());
 }
@@ -72,8 +72,8 @@ public:
     // Implement pure virtual base class methods
     virtual void          clear(void);
     virtual GCTAResponse* clone(void) const;
-    virtual bool          hasedisp(void) const;
-    virtual bool          hastdisp(void) const;
+    virtual bool          has_edisp(void) const;
+    virtual bool          has_tdisp(void) const;
     virtual double        irf(const GEvent&       event,
                               const GPhoton&      photon,
                               const GObservation& obs) const;
@@ -190,7 +190,7 @@ private:
  * @return False.
  ***************************************************************************/
 inline
-bool GCTAResponse::hasedisp(void) const
+bool GCTAResponse::has_edisp(void) const
 {
     return false;
 }
@@ -202,7 +202,7 @@ bool GCTAResponse::hasedisp(void) const
  * @return False.
  ***************************************************************************/
 inline
-bool GCTAResponse::hastdisp(void) const
+bool GCTAResponse::has_tdisp(void) const
 {
     return false;
 }
@@ -49,7 +49,7 @@ class GCTAModelBackground : public GModelData {
     virtual void                       clear(void);
     virtual GCTAModelBackground* clone(void) const;
     virtual std::string                type(void) const;
-    virtual bool                       isconstant(void) const;
+    virtual bool                       is_constant(void) const;
     virtual double                     eval(const GEvent& event,
                                             const GObservation& obs) const;
     virtual double                     eval_gradients(const GEvent& event,
@@ -50,7 +50,7 @@ public:
     virtual void                       clear(void);
     virtual GCTAModelRadialAcceptance* clone(void) const;
     virtual std::string                type(void) const;
-    virtual bool                       isconstant(void) const;
+    virtual bool                       is_constant(void) const;
     virtual double                     eval(const GEvent& event,
                                             const GObservation& obs) const;
     virtual double                     eval_gradients(const GEvent& event,
@@ -47,7 +47,7 @@ public:
     GCTAOnOffObservations* clone(void) const;
     GCTAOnOffObservation*  at(const int& index);
     int                    size(void) const;
-    bool                   isempty(void) const;
+    bool                   is_empty(void) const;
     GCTAOnOffObservation*  set(const int& index, const GCTAOnOffObservation& obs);
     GCTAOnOffObservation*  append(const GCTAOnOffObservation& obs);
     GCTAOnOffObservation*  insert(const int& index, const GCTAOnOffObservation& obs);
@@ -45,8 +45,8 @@ public:
     // Implement pure virtual base class methods
     virtual void          clear(void);
     virtual GCTAResponse* clone(void) const;
-    virtual bool          hasedisp(void) const;
-    virtual bool          hastdisp(void) const;
+    virtual bool          has_edisp(void) const;
+    virtual bool          has_tdisp(void) const;
     virtual double        irf(const GEvent&       event,
                               const GPhoton&      photon,
                               const GObservation& obs) const;
@@ -848,7 +848,7 @@ void GCTAEventList::read_ds_ebounds(const GFitsHDU&amp; hdu)
  
     // Get number of data selection keywords (default to 0 if keyword is
     // not found)
-    int ndskeys = (hdu.hascard("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
+    int ndskeys = (hdu.has_card("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
  
     // Loop over all data selection keys
     for (int i = 1; i <= ndskeys; ++i) {
@@ -859,7 +859,7 @@ void GCTAEventList::read_ds_ebounds(const GFitsHDU&amp; hdu)
         std::string value_key = "DSVAL"+gammalib::str(i);
  
         // Continue only if type_key is found and if this key is ENERGY
-        if (hdu.hascard(type_key) && hdu.string(type_key) == "ENERGY") {
+        if (hdu.has_card(type_key) && hdu.string(type_key) == "ENERGY") {
  
             // Extract energy boundaries
             std::string value                = hdu.string(value_key);
@@ -912,7 +912,7 @@ void GCTAEventList::read_ds_roi(const GFitsHDU&amp; hdu)
  
     // Get number of data selection keywords (default to 0 if keyword is
     // not found)
-    int ndskeys = (hdu.hascard("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
+    int ndskeys = (hdu.has_card("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
  
     // Loop over all data selection keys
     for (int i = 1; i <= ndskeys; ++i) {
@@ -923,7 +923,7 @@ void GCTAEventList::read_ds_roi(const GFitsHDU&amp; hdu)
         std::string value_key = "DSVAL"+gammalib::str(i);
  
         // Continue only if type_key is found and if this key is POS(RA,DEC)
-        if (hdu.hascard(type_key) && hdu.string(type_key) == "POS(RA,DEC)") {
+        if (hdu.has_card(type_key) && hdu.string(type_key) == "POS(RA,DEC)") {
  
             // ...
             //std::string unit              = gammalib::toupper(hdu.string(unit_key));
@@ -570,7 +570,7 @@ double GCTAModelBackground::npred(const GEnergy&amp;      obsEng,
  
 	        // Debug: Check for NaN
 	        #if defined(G_NAN_CHECK)
-	        if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+	        if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
 	            std::cout << "*** ERROR: GCTAModelBackground::npred:";
 	            std::cout << " NaN/Inf encountered";
 	            std::cout << " (npred=" << npred;
@@ -1255,7 +1255,7 @@ double GCTAModelBackground::npred_roi_kern_theta::eval(const double&amp; theta)
  
 			// Debug: Check for NaN
 			#if defined(G_NAN_CHECK)
-			if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+			if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
 				std::cout << "*** ERROR: GCTAModelBackground::npred_roi_kern_theta::eval";
 				std::cout << "(theta=" << theta << "):";
 				std::cout << " NaN/Inf encountered";
@@ -1314,7 +1314,7 @@ double GCTAModelBackground::npred_roi_kern_phi::eval(const double&amp; phi)
  
 	// Debug: Check for NaN
 	#if defined(G_NAN_CHECK)
-	if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+	if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
 		std::cout << "*** ERROR: GCTAModelBackground::npred_roi_kern_phi::eval";
 		std::cout << "(phi=" << phi << "):";
 		std::cout << " NaN/Inf encountered";
@@ -237,7 +237,7 @@ double GCTAModelRadialGauss::eval(const double&amp; offset) const
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+    if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
         std::cout << "*** ERROR: GCTAModelRadialGauss::eval";
         std::cout << "(offset=" << offset << "): NaN/Inf encountered";
         std::cout << " (value=" << value;
@@ -289,7 +289,7 @@ double GCTAModelRadialGauss::eval_gradients(const double&amp; offset) const
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+    if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
         std::cout << "*** ERROR: GCTAModelRadialGauss::eval";
         std::cout << "(offset=" << offset << "): NaN/Inf encountered";
         std::cout << " (value=" << value;
@@ -442,7 +442,7 @@ void GCTAModelRadialGauss::read(const GXmlElement&amp; xml)
                 throw GException::model_invalid_parvalue(G_READ, xml,
                       "\"Sigma\" parameter is required to be positive.");
             }
-            if (!m_sigma.hasmin() || m_sigma.min() <= 0.0) {
+            if (!m_sigma.has_min() || m_sigma.min() <= 0.0) {
                 throw GException::model_invalid_parlimit(G_READ, xml,
                       "\"Sigma\" parameter requires positive minimum boundary.");
             }
@@ -580,7 +580,7 @@ void GCTAModelRadialGauss::init_members(void)
     m_sigma.free();
     m_sigma.scale(1.0);
     m_sigma.gradient(0.0);
-    m_sigma.hasgrad(true);
+    m_sigma.has_grad(true);
  
     // Set parameter pointer(s)
     m_pars.clear();
@@ -101,7 +101,7 @@ GCTAModelRadialPolynom::GCTAModelRadialPolynom(const std::vector&lt;double&gt;&amp; coeffs
         par.free();
         par.scale(1.0);
         par.gradient(0.0);
-        par.hasgrad(true);
+        par.has_grad(true);
  
         // Push coefficient on list
         m_coeffs.push_back(par);
@@ -272,7 +272,7 @@ double GCTAModelRadialPolynom::eval(const double&amp; offset) const
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+    if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
         std::cout << "*** ERROR: GCTAModelRadialPolynom::eval";
         std::cout << "(offset=" << offset << "): NaN/Inf encountered";
         std::cout << " (value=" << value;
@@ -350,7 +350,7 @@ double GCTAModelRadialPolynom::eval_gradients(const double&amp; offset) const
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+    if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
         std::cout << "*** ERROR: GCTAModelRadialPolynom::eval_gradients";
         std::cout << "(offset=" << offset << "): NaN/Inf encountered";
         std::cout << " (value=" << value;
@@ -811,7 +811,7 @@ void GCTAModelRadialPolynom::update_pars(void)
     for (int i = 0; i < ncoeffs; ++i) {
  
         // Signal that we have gradients
-        m_coeffs[i].hasgrad(true);
+        m_coeffs[i].has_grad(true);
  
         // Set pointer
         m_pars.push_back(&(m_coeffs[i]));
@@ -245,7 +245,7 @@ double GCTAModelRadialProfile::eval(const double&amp; offset) const
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+    if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
         std::cout << "*** ERROR: GCTAModelRadialProfile::eval";
         std::cout << "(offset=" << offset << "): NaN/Inf encountered";
         std::cout << " (value=" << value;
@@ -423,7 +423,7 @@ void GCTAModelRadialProfile::read(const GXmlElement&amp; xml)
                 throw GException::model_invalid_parvalue(G_READ, xml,
                       "\"Width\" parameter is required to be positive.");
             }
-            if (!m_width.hasmin() || m_width.min() <= 0.0) {
+            if (!m_width.has_min() || m_width.min() <= 0.0) {
                 throw GException::model_invalid_parlimit(G_READ, xml,
                       "\"Width\" parameter requires positive minimum boundary.");
             }
@@ -437,7 +437,7 @@ void GCTAModelRadialProfile::read(const GXmlElement&amp; xml)
                 throw GException::model_invalid_parvalue(G_READ, xml,
                       "\"Core\" parameter is required to be positive.");
             }
-            if (!m_core.hasmin() || m_core.min() <= 0.0) {
+            if (!m_core.has_min() || m_core.min() <= 0.0) {
                 throw GException::model_invalid_parlimit(G_READ, xml,
                       "\"Core\" parameter requires positive minimum boundary.");
             }
@@ -451,7 +451,7 @@ void GCTAModelRadialProfile::read(const GXmlElement&amp; xml)
                 throw GException::model_invalid_parvalue(G_READ, xml,
                       "\"Core\" parameter is required to be positive.");
             }
-            if (!m_tail.hasmin() || m_tail.min() <= 0.0) {
+            if (!m_tail.has_min() || m_tail.min() <= 0.0) {
                 throw GException::model_invalid_parlimit(G_READ, xml,
                       "\"Core\" parameter requires positive minimum boundary.");
             }
@@ -601,7 +601,7 @@ void GCTAModelRadialProfile::init_members(void)
     m_width.min(0.1);            // min:     0.1 deg
     m_width.free();
     m_width.gradient(0.0);
-    m_width.hasgrad(false);
+    m_width.has_grad(false);
  
     // Initialise core parameter
     m_core.clear();
@@ -611,7 +611,7 @@ void GCTAModelRadialProfile::init_members(void)
     m_core.min(1.0);             // min:     1.0 (could even be larger)
     m_core.free();
     m_core.gradient(0.0);
-    m_core.hasgrad(false);
+    m_core.has_grad(false);
  
     // Initialise tail parameter
     m_tail.clear();
@@ -621,7 +621,7 @@ void GCTAModelRadialProfile::init_members(void)
     m_tail.min(1.0);             // min:     1.0
     m_tail.fix();
     m_tail.gradient(0.0);
-    m_tail.hasgrad(false);
+    m_tail.has_grad(false);
  
     // Set parameter pointer(s)
     m_pars.clear();
@@ -895,17 +895,17 @@ void GCTAObservation::read_attributes(const GFitsHDU&amp; hdu)
     // Read mandatory attributes
     double ra_pnt  = hdu.real("RA_PNT");
     double dec_pnt = hdu.real("DEC_PNT");
-    m_ontime   = (hdu.hascard("ONTIME"))   ? hdu.real("ONTIME") : 0.0;
-    m_livetime = (hdu.hascard("LIVETIME")) ? hdu.real("LIVETIME") : 0.0;
+    m_ontime   = (hdu.has_card("ONTIME"))   ? hdu.real("ONTIME") : 0.0;
+    m_livetime = (hdu.has_card("LIVETIME")) ? hdu.real("LIVETIME") : 0.0;
  
     // Read optional attributes
-    m_name     = (hdu.hascard("OBJECT"))   ? hdu.string("OBJECT") : "unknown";
-    m_deadc    = (hdu.hascard("DEADC"))    ? hdu.real("DEADC") : 0.0;
-    m_ra_obj   = (hdu.hascard("RA_OBJ"))   ? hdu.real("RA_OBJ") : 0.0;
-    m_dec_obj  = (hdu.hascard("DEC_OBJ"))  ? hdu.real("DEC_OBJ") : 0.0;
-    m_obs_id   = (hdu.hascard("OBS_ID"))   ? hdu.integer("OBS_ID") : 0;
-    //double alt = (hdu.hascard("ALT_PNT"))  ? hdu.real("ALT_PNT") : 0.0;
-    //double az  = (hdu.hascard("AZ_PNT"))   ? hdu.real("AZ_PNT") : 0.0;
+    m_name     = (hdu.has_card("OBJECT"))   ? hdu.string("OBJECT") : "unknown";
+    m_deadc    = (hdu.has_card("DEADC"))    ? hdu.real("DEADC") : 0.0;
+    m_ra_obj   = (hdu.has_card("RA_OBJ"))   ? hdu.real("RA_OBJ") : 0.0;
+    m_dec_obj  = (hdu.has_card("DEC_OBJ"))  ? hdu.real("DEC_OBJ") : 0.0;
+    m_obs_id   = (hdu.has_card("OBS_ID"))   ? hdu.integer("OBS_ID") : 0;
+    //double alt = (hdu.has_card("ALT_PNT"))  ? hdu.real("ALT_PNT") : 0.0;
+    //double az  = (hdu.has_card("AZ_PNT"))   ? hdu.real("AZ_PNT") : 0.0;
  
     // Kluge: compute DEADC from livetime and ontime instead of using the
     // keyword value as the original event lists had this values badly
@@ -342,7 +342,7 @@ GCTAOnOffObservation* GCTAOnOffObservations::insert(const int&amp; index, const GCTA
 {
     // Compile option: raise exception if index is out of range
     #if defined(G_RANGE_CHECK)
-    if (isempty()) {
+    if (is_empty()) {
         if (index > 0) {
             throw GException::out_of_range(G_INSERT, index, 0, size()-1);
         }
@@ -421,7 +421,7 @@ void GCTAOnOffObservations::remove(const int&amp; index)
 void GCTAOnOffObservations::extend(const GCTAOnOffObservations& obs)
 {
     // Do nothing if observation container is empty
-    if (!obs.isempty()) {
+    if (!obs.is_empty()) {
  
         // Get size. Note that we extract the size first to avoid an
         // endless loop that arises when a container is appended to
@@ -327,7 +327,7 @@ double GCTAResponse::irf(const GEvent&amp;       event,
             irf *= psf(delta, theta, phi, zenith, azimuth, srcLogEng);
  
             // Multiply-in energy dispersion
-            if (hasedisp() && irf > 0) {
+            if (has_edisp() && irf > 0) {
  
                 // Get log10(E/TeV) of measured photon energy.
                 double obsLogEng = obsEng.log10TeV();
@@ -346,7 +346,7 @@ double GCTAResponse::irf(const GEvent&amp;       event,
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+    if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
         std::cout << "*** ERROR: GCTAResponse::irf:";
         std::cout << " NaN/Inf encountered";
         std::cout << " (irf=" << irf;
@@ -404,7 +404,7 @@ double GCTAResponse::npred(const GPhoton&amp;      photon,
         npred *= npsf(srcDir, srcLogEng, srcTime, pnt, roi);
  
         // Multiply-in energy dispersion
-        if (hasedisp() && npred > 0.0) {
+        if (has_edisp() && npred > 0.0) {
  
             // Get energy dispersion
             npred *= nedisp(srcDir, srcEng, srcTime, pnt, cta.events()->ebounds());
@@ -418,7 +418,7 @@ double GCTAResponse::npred(const GPhoton&amp;      photon,
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+    if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
         std::cout << "*** ERROR: GCTAResponse::npred:";
         std::cout << " NaN/Inf encountered";
         std::cout << " (npred=" << npred;
@@ -989,7 +989,7 @@ double GCTAResponse::irf_radial(const GEvent&amp;       event,
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+        if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
             std::cout << "*** ERROR: GCTAResponse::irf_radial:";
             std::cout << " NaN/Inf encountered";
             std::cout << " (irf=" << irf;
@@ -1157,7 +1157,7 @@ double GCTAResponse::irf_elliptical(const GEvent&amp;       event,
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+        if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
             std::cout << "*** ERROR: GCTAResponse::irf_elliptical:";
             std::cout << " NaN/Inf encountered";
             std::cout << " (irf=" << irf;
@@ -1328,7 +1328,7 @@ double GCTAResponse::irf_diffuse(const GEvent&amp;       event,
  
             // Compile option: Check for NaN/Inf
             #if defined(G_NAN_CHECK)
-            if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+            if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
                 std::cout << "*** ERROR: GCTAResponse::irf_diffuse:";
                 std::cout << " NaN/Inf encountered";
                 std::cout << " (irf=" << irf;
@@ -1512,7 +1512,7 @@ double GCTAResponse::npred_radial(const GSource&amp; source,
  
     // Debug: Check for NaN
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+    if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
         std::cout << "*** ERROR: GCTAResponse::npred_radial:";
         std::cout << " NaN/Inf encountered";
         std::cout << " (npred=" << npred;
@@ -1675,7 +1675,7 @@ double GCTAResponse::npred_elliptical(const GSource&amp; source,
  
     // Debug: Check for NaN
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+    if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
         std::cout << "*** ERROR: GCTAResponse::npred_elliptical:";
         std::cout << " NaN/Inf encountered";
         std::cout << " (npred=" << npred;
@@ -1853,7 +1853,7 @@ double GCTAResponse::npred_diffuse(const GSource&amp; source,
  
         // Debug: Check for NaN
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+        if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
             std::cout << "*** ERROR: GCTAResponse::npred_diffuse:";
             std::cout << " NaN/Inf encountered";
             std::cout << " (npred=" << npred;
@@ -2093,7 +2093,7 @@ double GCTAResponse::npsf(const GSkyDir&amp;      srcDir,
  
             // Compile option: Check for NaN/Inf
             #if defined(G_NAN_CHECK)
-            if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+            if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
                 std::cout << "*** ERROR: GCTAResponse::npsf:";
                 std::cout << " NaN/Inf encountered";
                 std::cout << " (value=" << value;
@@ -94,7 +94,7 @@ double cta_npsf_kern_rad_azsym::eval(const double&amp; delta)
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
+        if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
             std::cout << "*** ERROR: cta_npsf_kern_rad_azsym::eval";
             std::cout << " NaN/Inf encountered";
             std::cout << " (value=" << value;
@@ -186,7 +186,7 @@ double cta_irf_radial_kern_rho::eval(const double&amp; rho)
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+        if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
             std::cout << "*** ERROR: cta_irf_radial_kern_rho";
             std::cout << "(rho=" << rho << "):";
             std::cout << " NaN/Inf encountered";
@@ -259,13 +259,13 @@ double cta_irf_radial_kern_omega::eval(const double&amp; omega)
                  m_rsp.psf(delta, offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
  
     // Optionally take energy dispersion into account
-    if (m_rsp.hasedisp() && irf > 0.0) {
+    if (m_rsp.has_edisp() && irf > 0.0) {
         irf *= m_rsp.edisp(m_obsLogEng, offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
     }
  
     // Compile option: Check for NaN/Inf
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+    if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
         std::cout << "*** ERROR: cta_irf_radial_kern_omega::eval";
         std::cout << "(omega=" << omega << "):";
         std::cout << " NaN/Inf encountered";
@@ -343,7 +343,7 @@ double cta_npred_radial_kern_rho::eval(const double&amp; rho)
  
         // Debug: Check for NaN
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+        if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
             std::cout << "*** ERROR: cta_npred_radial_kern_rho::eval";
             std::cout << "(rho=" << rho << "):";
             std::cout << " NaN/Inf encountered";
@@ -393,7 +393,7 @@ double cta_npred_radial_kern_omega::eval(const double&amp; omega)
  
     // Debug: Check for NaN
     #if defined(G_NAN_CHECK)
-    if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+    if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
         std::cout << "*** ERROR: cta_npred_radial_kern_omega::eval";
         std::cout << "(omega=" << omega << "):";
         std::cout << " NaN/Inf encountered";
@@ -482,7 +482,7 @@ double cta_irf_elliptical_kern_rho::eval(const double&amp; rho)
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+        if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
             std::cout << "*** ERROR: cta_irf_elliptical_kern_rho";
             std::cout << "(rho=" << rho << "):";
             std::cout << " NaN/Inf encountered";
@@ -561,14 +561,14 @@ double cta_irf_elliptical_kern_omega::eval(const double&amp; omega)
               model;
  
         // Optionally take energy dispersion into account
-        if (m_rsp.hasedisp() && irf > 0.0) {
+        if (m_rsp.has_edisp() && irf > 0.0) {
             irf *= m_rsp.edisp(m_obsLogEng, theta, phi, 
                                m_zenith, m_azimuth, m_srcLogEng);
         }
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+        if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
             std::cout << "*** ERROR: cta_irf_elliptical_kern_omega::eval";
             std::cout << "(omega=" << omega << "):";
             std::cout << " NaN/Inf encountered";
@@ -647,7 +647,7 @@ double cta_npred_elliptical_kern_rho::eval(const double&amp; rho)
  
         // Debug: Check for NaN
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+        if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
             std::cout << "*** ERROR: cta_npred_elliptical_kern_rho::eval";
             std::cout << "(rho=" << rho << "):";
             std::cout << " NaN/Inf encountered";
@@ -708,7 +708,7 @@ double cta_npred_elliptical_kern_omega::eval(const double&amp; omega)
  
         // Debug: Check for NaN
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+        if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
             std::cout << "*** ERROR: cta_npred_elliptical_kern_omega::eval";
             std::cout << "(omega=" << omega << "):";
             std::cout << " NaN/Inf encountered";
@@ -802,7 +802,7 @@ double cta_irf_diffuse_kern_theta::eval(const double&amp; theta)
  
             // Compile option: Check for NaN/Inf
             #if defined(G_NAN_CHECK)
-            if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+            if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
                 std::cout << "*** ERROR: cta_irf_diffuse_kern_theta";
                 std::cout << "(theta=" << theta << "):";
                 std::cout << " NaN/Inf encountered";
@@ -890,14 +890,14 @@ double cta_irf_diffuse_kern_phi::eval(const double&amp; phi)
               m_rsp.aeff(offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
  
         // Optionally take energy dispersion into account
-        if (m_rsp.hasedisp() && irf > 0.0) {
+        if (m_rsp.has_edisp() && irf > 0.0) {
             irf *= m_rsp.edisp(m_obsLogEng, offset, azimuth,
                                m_zenith, m_azimuth, m_srcLogEng);
         }
  
         // Compile option: Check for NaN/Inf
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
+        if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
             std::cout << "*** ERROR: cta_irf_diffuse_kern_phi::eval";
             std::cout << "(phi=" << phi << "):";
             std::cout << " NaN/Inf encountered";
@@ -971,7 +971,7 @@ double cta_npred_diffuse_kern_theta::eval(const double&amp; theta)
  
         // Debug: Check for NaN
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+        if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
             std::cout << "*** ERROR: cta_npred_radial_kern_theta::eval";
             std::cout << "(theta=" << theta << "):";
             std::cout << " NaN/Inf encountered";
@@ -1034,7 +1034,7 @@ double cta_npred_diffuse_kern_phi::eval(const double&amp; phi)
  
         // Debug: Check for NaN
         #if defined(G_NAN_CHECK)
-        if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
+        if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
             std::cout << "*** ERROR: cta_npred_diffuse_kern_phi::eval";
             std::cout << "(phi=" << phi << "):";
             std::cout << " NaN/Inf encountered";
@@ -96,8 +96,8 @@ double gammalib::cta_roi_arclength(const double&amp; rad,     const double&amp; dist,
                 double cosang = (cosroi - cosdist*cosrad) / (sindist*sinrad);
                 arclength     = 2.0 * gammalib::acos(cosang);
                 #if G_CHECK_FOR_NAN
-                if (gammalib::isinfinite(arclength) ||
-                    gammalib::isnotanumber(arclength)) {
+                if (gammalib::is_infinite(arclength) ||
+                    gammalib::is_notanumber(arclength)) {
                     std::cout << "cta_roi_arclength: NaN occured";
                     std::cout << " rad=" << rad;
                     std::cout << " sinrad=" << sinrad;
@@ -147,7 +147,7 @@ def observation(ra=0.0, dec=0.0, binsz=0.05, npix=200, ebins=10):
     emax    = GEnergy()
     emin.TeV(0.1)
     emax.TeV(100.0)
-    ebounds.setlog(emin, emax, ebins)
+    ebounds.set_log(emin, emax, ebins)
     gti  = GGti()
     tmin = GTime(0.0)
     tmax = GTime(1800.0)
@@ -77,8 +77,8 @@ public:
     int           ncostheta(void) const;
     const double& costhetamin(void) const;
     void          costhetamin(const double& ctheta);
-    bool          hasphi(void) const;
-    bool          hasefficiency(void) const;
+    bool          has_phi(void) const;
+    bool          has_efficiency(void) const;
     double        efficiency_factor1(const GEnergy& srcEng) const;
     double        efficiency_factor2(const GEnergy& srcEng) const;
     std::string   print(const GChatter& chatter = NORMAL) const;
@@ -171,7 +171,7 @@ void GLATAeff::costhetamin(const double&amp; ctheta)
  * @return True if effective area has Phi dependence.
  ***************************************************************************/
 inline
-bool GLATAeff::hasphi(void) const
+bool GLATAeff::has_phi(void) const
 {
     return false;
 }
@@ -71,7 +71,7 @@ public:
     int          ncostheta(void) const;
     //double       costhetamin(void) const { return m_min_ctheta; }
     //void         costhetamin(const double& ctheta);
-    bool         hasphi(void) const { return false; }
+    bool         has_phi(void) const { return false; }
     std::string  print(const GChatter& chatter = NORMAL) const;
  
 private:
@@ -74,7 +74,7 @@ public:
     void           write(GFits& file) const;
     const int&     ncostheta(void) const;
     const int&     nphi(void) const;
-    bool           hasphi(void) const;
+    bool           has_phi(void) const;
     double         costheta(const int& index) const;
     double         phi(const int& index) const;
     const double&  costhetamin(void) const;
@@ -126,7 +126,7 @@ const int&amp; GLATLtCubeMap::nphi(void) const
  * @return True if livetime cube map has phi dependence.
  ***************************************************************************/
 inline
-bool GLATLtCubeMap::hasphi(void) const
+bool GLATLtCubeMap::has_phi(void) const
 {
     return (m_num_phi != 0);
 }
@@ -80,7 +80,7 @@ public:
     int         ncostheta(void) const;
     double      costhetamin(void) const;
     void        costhetamin(const double& ctheta);
-    bool        hasphi(void) const;
+    bool        has_phi(void) const;
     bool        isfront(void) const;
     bool        isback(void) const;
     int         version(void) const;
@@ -73,7 +73,7 @@ public:
     int           ncostheta(void) const;
     const double& costhetamin(void) const;
     void          costhetamin(const double& ctheta);
-    bool          hasphi(void) const;
+    bool          has_phi(void) const;
     const bool&   front(void) const;
     void          front(const bool& front);
     const double& scale_par1(void) const;
@@ -164,7 +164,7 @@ void GLATPsfBase::costhetamin(const double&amp; ctheta)
  * @return True if point spread function has Phi dependence.
  ***************************************************************************/
 inline
-bool GLATPsfBase::hasphi(void) const
+bool GLATPsfBase::has_phi(void) const
 {
     return false;
 }
@@ -61,8 +61,8 @@ public:
     // Implemented pure virtual methods
     virtual void          clear(void);
     virtual GLATResponse* clone(void) const;
-    virtual bool          hasedisp(void) const;
-    virtual bool          hastdisp(void) const;
+    virtual bool          has_edisp(void) const;
+    virtual bool          has_tdisp(void) const;
     virtual double        irf(const GEvent&       event,
                               const GPhoton&      photon,
                               const GObservation& obs) const;
@@ -105,8 +105,8 @@ private:
     // Private members
     std::string               m_caldb;      //!< Name of or path to the calibration database
     std::string               m_rspname;    //!< Name of the instrument response
-    bool                      m_hasfront;   //!< Front IRF loaded?
-    bool                      m_hasback;    //!< Back IRF loaded?
+    bool                      m_has_front;   //!< Front IRF loaded?
+    bool                      m_has_back;    //!< Back IRF loaded?
     bool                      m_force_mean; //!< Use mean PSF in any case
     std::vector<GLATAeff*>    m_aeff;       //!< Effective areas
     std::vector<GLATPsf*>     m_psf;        //!< Point spread functions
@@ -121,7 +121,7 @@ private:
  * @return True if response supports energy dispersion.
  ***************************************************************************/
 inline
-bool GLATResponse::hasedisp(void) const
+bool GLATResponse::has_edisp(void) const
 {
     return false;
 }
@@ -133,7 +133,7 @@ bool GLATResponse::hasedisp(void) const
  * @return True if response supports time dispersion.
  ***************************************************************************/
 inline
-bool GLATResponse::hastdisp(void) const
+bool GLATResponse::has_tdisp(void) const
 {
     return false;
 }
@@ -61,8 +61,8 @@ public:
     int          ncostheta(void) const;
     double       costhetamin(void) const;
     void         costhetamin(const double& ctheta);
-    bool         hasphi(void) const;
-    bool         hasefficiency(void) const;
+    bool         has_phi(void) const;
+    bool         has_efficiency(void) const;
     double       efficiency_factor1(const GEnergy& srcEng) const;
     double       efficiency_factor2(const GEnergy& srcEng) const;
 };
@@ -59,7 +59,7 @@ public:
     int          ncostheta(void) const;
     //double       costhetamin(void) const;
     //void         costhetamin(const double& ctheta);
-    bool         hasphi(void) const;
+    bool         has_phi(void) const;
 };
  
  
@@ -60,7 +60,7 @@ public:
     int      ncostheta(void) const;
     double   costhetamin(void) const;
     void     costhetamin(const double& ctheta);
-    bool     hasphi(void) const;
+    bool     has_phi(void) const;
     bool     isfront(void) const;
     bool     isback(void) const;
     int      version(void) const;
@@ -44,8 +44,8 @@ public:
     // Implemented pure virtual methods
     virtual void          clear(void);
     virtual GLATResponse* clone(void) const;
-    virtual bool          hasedisp(void) const;
-    virtual bool          hastdisp(void) const;
+    virtual bool          has_edisp(void) const;
+    virtual bool          has_tdisp(void) const;
     virtual double        irf(const GEvent&       event,
                               const GPhoton&      photon,
                               const GObservation& obs) const;
@@ -358,7 +358,7 @@ void GLATAeff::write(GFits&amp; fits) const
  * The method returns true if both efficiency factor functors exist, false
  * otherwise.
  ***************************************************************************/
-bool GLATAeff::hasefficiency(void) const
+bool GLATAeff::has_efficiency(void) const
 {
     // Return
     return (m_eff_func1 != NULL && m_eff_func2 != NULL);
@@ -456,7 +456,7 @@ std::string GLATAeff::print(const GChatter&amp; chatter) const
             result.append("unknown");
         }
         result.append("\n"+gammalib::parformat("Efficiency factors"));
-        if (hasefficiency()) {
+        if (has_efficiency()) {
             result.append("present");
         }
         else {
@@ -555,7 +555,7 @@ void GLATEventList::read_events(const GFitsTable&amp; table)
                 std::sprintf(keyword, "DIFRSP%d", k);
  
                 // Get DIFRSP label
-                if (table.hascard(std::string(keyword))) {
+                if (table.has_card(std::string(keyword))) {
                     m_difrsp_label.push_back(table.string(std::string(keyword)));
                 }
                 else {
@@ -616,7 +616,7 @@ void GLATEventList::read_ds_keys(const GFitsHDU&amp; hdu)
  
             // Get DSTYPnn
             std::sprintf(keyword, "DSTYP%d", i+1);
-            if (hdu.hascard(std::string(keyword))) {
+            if (hdu.has_card(std::string(keyword))) {
                 m_ds_type.push_back(hdu.string(std::string(keyword)));
             }
             else {
@@ -625,7 +625,7 @@ void GLATEventList::read_ds_keys(const GFitsHDU&amp; hdu)
  
             // Get DSUNInn
             std::sprintf(keyword, "DSUNI%d", i+1);
-            if (hdu.hascard(std::string(keyword))) {
+            if (hdu.has_card(std::string(keyword))) {
                 m_ds_unit.push_back(hdu.string(std::string(keyword)));
             }
             else {
@@ -634,7 +634,7 @@ void GLATEventList::read_ds_keys(const GFitsHDU&amp; hdu)
  
             // Get DSVALnn
             std::sprintf(keyword, "DSVAL%d", i+1);
-            if (hdu.hascard(std::string(keyword))) {
+            if (hdu.has_card(std::string(keyword))) {
                 m_ds_value.push_back(hdu.string(std::string(keyword)));
             }
             else {
@@ -643,7 +643,7 @@ void GLATEventList::read_ds_keys(const GFitsHDU&amp; hdu)
  
             // Get DSREFnn
             std::sprintf(keyword, "DSREF%d", i+1);
-            if (hdu.hascard(std::string(keyword))) {
+            if (hdu.has_card(std::string(keyword))) {
                 m_ds_reference.push_back(hdu.string(std::string(keyword)));
             }
             else {
@@ -173,7 +173,7 @@ double GLATLtCube::operator()(const GSkyDir&amp; dir, const GEnergy&amp; energy,
     // Optionally compute livetime factors for trigger rate- and
     // energy-dependent efficiency corrections
     /*
-    if (aeff.hasefficiency()) {
+    if (aeff.has_efficiency()) {
  
         // Compute correction factors
         double f1 = aeff.efficiency_factor1(energy);
@@ -225,7 +225,7 @@ double GLATLtCube::operator()(const GSkyDir&amp; dir, const GEnergy&amp; energy,
     // Optionally compute livetime factors for trigger rate- and
     // energy-dependent efficiency corrections
     /*
-    if (aeff.hasefficiency()) {
+    if (aeff.has_efficiency()) {
  
         // Compute correction factors
         double f1 = aeff.efficiency_factor1(energy);
@@ -271,7 +271,7 @@ double GLATLtCube::operator()(const GSkyDir&amp; dir, const GEnergy&amp; energy,
  
     // Optionally compute livetime factors for trigger rate- and
     // energy-dependent efficiency corrections
-    if (aeff.hasefficiency()) {
+    if (aeff.has_efficiency()) {
  
         // Compute correction factors
         double f1 = aeff.efficiency_factor1(energy);
@@ -324,7 +324,7 @@ double GLATLtCube::operator()(const GSkyDir&amp; dir, const GEnergy&amp; energy,
  
     // Optionally compute livetime factors for trigger rate- and
     // energy-dependent efficiency corrections
-    if (aeff.hasefficiency()) {
+    if (aeff.has_efficiency()) {
  
         // Compute correction factors
         double f1 = aeff.efficiency_factor1(energy);
@@ -246,7 +246,7 @@ double GLATLtCubeMap::operator()(const GSkyDir&amp; dir, const GEnergy&amp; energy,
     // zenith and azimuth. Note that the map index starts with m_num_ctheta
     // as the first m_num_ctheta maps correspond to an evaluation without
     // any phi-dependence.
-    if (hasphi() && aeff.hasphi()) {
+    if (has_phi() && aeff.has_phi()) {
         for (int iphi = 0, i = m_num_ctheta; iphi < m_num_phi; ++iphi) {
             double p = phi(iphi);
             for (int itheta = 0; itheta < m_num_ctheta; ++itheta, ++i) {
@@ -311,7 +311,7 @@ double GLATLtCubeMap::operator()(const GSkyDir&amp; dir, const GEnergy&amp; energy,
     // zenith and azimuth. Note that the map index starts with m_num_ctheta
     // as the first m_num_ctheta maps correspond to an evaluation without
     // any phi-dependence.
-    if (hasphi() && aeff.hasphi()) {
+    if (has_phi() && aeff.has_phi()) {
         for (int iphi = 0, i = m_num_ctheta; iphi < m_num_phi; ++iphi) {
             double p = phi(iphi);
             for (int itheta = 0; itheta < m_num_ctheta; ++itheta, ++i) {
@@ -284,7 +284,7 @@ void GLATPsf::read(const GFits&amp; fits)
     const GFitsTable& hdu_scale = *fits.table("PSF_SCALING_PARAMS");
  
     // Determine PSF version (default version is version 1)
-    int version = (hdu_rpsf.hascard("PSFVER")) ? hdu_rpsf.integer("PSFVER") : 1;
+    int version = (hdu_rpsf.has_card("PSFVER")) ? hdu_rpsf.integer("PSFVER") : 1;
  
     // Determine PSF type
     bool        front  = true;
@@ -451,7 +451,7 @@ void GLATPsf::costhetamin(const double&amp; ctheta)
  *
  * @todo Implement phi dependence
  ***************************************************************************/
-bool GLATPsf::hasphi(void) const
+bool GLATPsf::has_phi(void) const
 {
     // Return
     return false;
@@ -304,7 +304,7 @@ double GLATResponse::irf(const GEvent&amp;       event,
 {
     // Get IRF value
     double rsp;
-    if (event.isatom()) {
+    if (event.is_atom()) {
         rsp = irf(static_cast<const GLATEventAtom&>(event), source, obs);
     }
     else {
@@ -539,16 +539,16 @@ void GLATResponse::load(const std::string&amp; rspname)
     std::vector<std::string> array = gammalib::split(rspname, "::");
     if (array.size() == 1) {
         m_rspname  = array[0];
-        m_hasfront = true;
-        m_hasback  = true;
+        m_has_front = true;
+        m_has_back  = true;
     }
     else if (array.size() == 2) {
         m_rspname = array[0];
         if (gammalib::strip_whitespace(gammalib::tolower(array[1])) == "front") {
-            m_hasfront = true;
+            m_has_front = true;
         }
         else if (gammalib::strip_whitespace(gammalib::tolower(array[1])) == "back") {
-            m_hasback  = true;
+            m_has_back  = true;
         }
         else {
             throw GException::rsp_invalid_type(G_LOAD, array[1]);
@@ -562,7 +562,7 @@ void GLATResponse::load(const std::string&amp; rspname)
     caldb += "/data/glast/lat/bcf/";
  
     // Load front IRF if requested
-    if (m_hasfront) {
+    if (m_has_front) {
         std::string aeffname  = caldb + "ea/aeff_"  + m_rspname + "_front.fits";
         std::string psfname   = caldb + "psf/psf_"   + m_rspname + "_front.fits";
         std::string edispname = caldb + "edisp/edisp_" + m_rspname + "_front.fits";
@@ -575,7 +575,7 @@ void GLATResponse::load(const std::string&amp; rspname)
     }
  
     // Load back IRF if requested
-    if (m_hasback) {
+    if (m_has_back) {
         std::string aeffname  = caldb + "ea/aeff_"  + m_rspname + "_back.fits";
         std::string psfname   = caldb + "psf/psf_"   + m_rspname + "_back.fits";
         std::string edispname = caldb + "edisp/edisp_" + m_rspname + "_back.fits";
@@ -710,13 +710,13 @@ std::string GLATResponse::print(const GChatter&amp; chatter) const
         result.append("\n"+gammalib::parformat("Calibration database")+m_caldb);
         result.append("\n"+gammalib::parformat("Response name")+m_rspname);
         result.append("\n"+gammalib::parformat("Section(s)"));
-        if (m_hasfront && m_hasback) {
+        if (m_has_front && m_has_back) {
             result.append("front & back");
         }
-        else if (m_hasfront) {
+        else if (m_has_front) {
             result.append("front");
         }
-        else if (m_hasback) {
+        else if (m_has_back) {
             result.append("back");
         }
         else {
@@ -756,8 +756,8 @@ void GLATResponse::init_members(void)
     // Initialise members
     m_caldb.clear();
     m_rspname.clear();
-    m_hasfront   = false;
-    m_hasback    = false;
+    m_has_front   = false;
+    m_has_back    = false;
     m_force_mean = false;
     m_aeff.clear();
     m_psf.clear();
@@ -785,8 +785,8 @@ void GLATResponse::copy_members(const GLATResponse&amp; rsp)
     // Copy members
     m_caldb      = rsp.m_caldb;
     m_rspname    = rsp.m_rspname;
-    m_hasfront   = rsp.m_hasfront;
-    m_hasback    = rsp.m_hasback;
+    m_has_front   = rsp.m_has_front;
+    m_has_back    = rsp.m_has_back;
     m_force_mean = rsp.m_force_mean;
  
     // Clone Aeff
@@ -45,7 +45,7 @@ def set_ebds(ebins=20):
     emin.MeV(100.0)
     emax.MeV(20000.0)
     ebds = GEbounds()
-    ebds.setlog(emin, emax, ebins)
+    ebds.set_log(emin, emax, ebins)
  
     # Return energy boundaries
     return ebds
@@ -57,8 +57,8 @@ public:
     // Implemented pure virtual methods
     virtual void          clear(void);
     virtual GMWLResponse* clone(void) const;
-    virtual bool          hasedisp(void) const;
-    virtual bool          hastdisp(void) const;
+    virtual bool          has_edisp(void) const;
+    virtual bool          has_tdisp(void) const;
     virtual double        irf(const GEvent&       event,
                               const GPhoton&      photon,
                               const GObservation& obs) const;
@@ -80,7 +80,7 @@ protected:
  * @return True if response supports energy dispersion.
  ***************************************************************************/
 inline
-bool GMWLResponse::hasedisp(void) const
+bool GMWLResponse::has_edisp(void) const
 {
     return false;
 }
@@ -92,7 +92,7 @@ bool GMWLResponse::hasedisp(void) const
  * @return True if response supports time dispersion.
  ***************************************************************************/
 inline
-bool GMWLResponse::hastdisp(void) const
+bool GMWLResponse::has_tdisp(void) const
 {
     return false;
 }
@@ -679,7 +679,7 @@ void GMWLSpectrum::read_fits(const GFitsTable&amp; table)
     }
  
     // Get telescope name
-    if (table.hascard("TELESCOP")) {
+    if (table.has_card("TELESCOP")) {
         m_telescope = table.string("TELESCOP");
     }
     else {
@@ -687,7 +687,7 @@ void GMWLSpectrum::read_fits(const GFitsTable&amp; table)
     }
  
     // Get instrument name
-    if (table.hascard("INSTRUME")) {
+    if (table.has_card("INSTRUME")) {
         m_instrument = table.string("INSTRUME");
     }
     else {
@@ -63,7 +63,7 @@ public:
     bool               logVerbose(void) const;
     bool               logDebug(void) const;
     bool               clobber(void) const;
-    bool               haspar(const std::string& name) const;
+    bool               has_par(const std::string& name) const;
     const std::string& par_filename(void) const;
     const std::string& log_filename(void) const;
     void               log_header(void);