Eirik Hatlen / gammalib

Commit 5d8d9eda847fcf23cf538dfcbd3c753c1f7f6cac

Authored by Jürgen Knödlseder
2 parents 12af9dd1 34382e85

Merge branch 'issue_1061' into integration

Inline Side-by-side
Showing 265 changed files with 931 additions and 934 deletions

Too many changes.
Reload with full diff Plain diff Email patch

To preserve performance only 100 of 265 files are displayed.

.gitignore
  View file @5d8d9ed
... ... @@ -40,7 +40,10 @@ m4/lt~obsolete.m4
40 40 *.xml~
41 41 *.ac~
42 42 *.am~
  43 +*.plist
  44 +clang_output_*
43 45 .gitignore~
  46 +sloccount.sc
44 47 Makefile
45 48 stamp-h1
46 49 Makefile.in
... ...
doc/source/coding/design.rst
  View file @5d8d9ed
... ... @@ -373,13 +373,7 @@ will remain open. Typically, these methods take a ``GFits*`` or a
373 373 ``GFitsHDU*`` pointer as argument.
374 374  
375 375 Methods that perform checks should return a bool type and should start
376   -with the prefix ``is`` or ``has``. Examples are:
377   -
378   -.. code-block:: cpp
379   -
380   - islong()
381   - isin()
382   - hasedisp()
  376 +with the prefix ``is_`` or ``has_``, e.g. ``is_empty()`` or ``has_min()``.
383 377  
384 378 Method const declarations
385 379 ^^^^^^^^^^^^^^^^^^^^^^^^^
... ...
doc/source/user_manual/glossary.rst
  View file @5d8d9ed
... ... @@ -21,7 +21,7 @@ Glossary
21 21  
22 22 - **HEASARC** (`<http://heasarc.gsfc.nasa.gov/>`_)
23 23  
24   - High Energy Astrophysics Science Archive Research Center.
  24 + High Energy Astrophysics Science Archive Research Centre.
25 25  
26 26 - **Python** (`<http://www.python.org/>`_)
27 27  
... ...
doc/source/user_manual/modules/support.rst
  View file @5d8d9ed
... ... @@ -217,13 +217,13 @@ Function Description
217 217 ``gammalib::fill`` Fill string with a number of replications of a string.
218 218 ``gammalib::left`` Left justify string to achieve a given length of characters.
219 219 ``gammalib::right`` Right justify string to achieve a given length of characters.
220   -``gammalib::center`` Center string to achieve a given length of characters.
  220 +``gammalib::centre`` Centre string to achieve a given length of characters.
221 221 ``gammalib::parformat`` Format string for parameter value display.
222 222 ``gammalib::plaw_photon_flux`` Compute photon flux under a power law.
223 223 ``gammalib::plaw_energy_flux`` Compute energy flux under a power law.
224 224 ``gammalib::file_exists`` Check whether a file exists.
225   -``gammalib::isinfinite`` Check whether a double precision value is infinite.
226   -``gammalib::isnotanumber`` Check whether a double precision value is not a number.
  225 +``gammalib::is_infinite`` Check whether a double precision value is infinite.
  226 +``gammalib::is_notanumber`` Check whether a double precision value is not a number.
227 227 ``gammalib::contains`` Check whether a string contains a sub-string.
228 228 ``gammalib::warning`` Dump warning in console.
229 229 ============================== ===========
... ...
include/GApplication.hpp
  View file @5d8d9ed
... ... @@ -39,7 +39,7 @@
39 39 /***********************************************************************//**
40 40 * @class GApplication
41 41 *
42   - * @brief GammaLib application interface defintion
  42 + * @brief GammaLib application interface definition
43 43 *
44 44 * This class provides the base class for ftools-like executables based on
45 45 * GammaLib. The ftools-like executables will be implemented as derived
... ... @@ -76,7 +76,7 @@ public:
76 76 bool logVerbose(void) const;
77 77 bool logDebug(void) const;
78 78 bool clobber(void) const;
79   - bool haspar(const std::string& name) const;
  79 + bool has_par(const std::string& name) const;
80 80 const std::string& par_filename(void) const;
81 81 const std::string& log_filename(void) const;
82 82 void log_header(void);
... ... @@ -162,7 +162,7 @@ const std::string&amp; GApplication::version(void) const
162 162 * @return True if an application parameter with the specified name exists.
163 163 ***************************************************************************/
164 164 inline
165   -bool GApplication::haspar(const std::string& name) const
  165 +bool GApplication::has_par(const std::string& name) const
166 166 {
167 167 return (m_pars.contains(name));
168 168 }
... ...
include/GContainer.hpp
  View file @5d8d9ed
... ... @@ -44,7 +44,7 @@
44 44 * clone - Clones container (inherited from GBase)
45 45 * print - Print container content (inherited from GBase)
46 46 * size - Returns number of objects is container
47   - * isempty - Checks if container is empty
  47 + * is_empty - Checks if container is empty
48 48 * remove - Removes an object from the container
49 49 * reserve - Reserves space in the container
50 50 ***************************************************************************/
... ... @@ -64,7 +64,7 @@ public:
64 64 /// @brief Checks if container is empty
65 65 ///
66 66 /// @return True if no objects are in container, false otherwise.
67   - virtual bool isempty(void) const = 0;
  67 + virtual bool is_empty(void) const = 0;
68 68  
69 69 /// @brief Remove object from container
70 70 ///
... ...
include/GDerivative.hpp
  View file @5d8d9ed
... ... @@ -221,7 +221,7 @@ const bool&amp; GDerivative::silent(void) const
221 221 *
222 222 * @param[in] function Function.
223 223 *
224   - * Sets the function for which the derivate should be determined.
  224 + * Sets the function for which the derivative should be determined.
225 225 ***************************************************************************/
226 226 inline
227 227 void GDerivative::function(GFunction* function)
... ...
include/GEbounds.hpp
  View file @5d8d9ed
... ... @@ -66,7 +66,7 @@ public:
66 66 void clear(void);
67 67 GEbounds* clone(void) const;
68 68 int size(void) const;
69   - bool isempty(void) const;
  69 + bool is_empty(void) const;
70 70 void append(const GEnergy& emin, const GEnergy& emax);
71 71 void insert(const GEnergy& emin, const GEnergy& emax);
72 72 void merge(void);
... ... @@ -74,8 +74,8 @@ public:
74 74 void remove(const int& index);
75 75 void reserve(const int& num);
76 76 void extend(const GEbounds& ebds);
77   - void setlin(const int& num, const GEnergy& emin, const GEnergy& emax);
78   - void setlog(const int& num, const GEnergy& emin, const GEnergy& emax);
  77 + void set_lin(const int& num, const GEnergy& emin, const GEnergy& emax);
  78 + void set_log(const int& num, const GEnergy& emin, const GEnergy& emax);
79 79 void load(const std::string& filename,
80 80 const std::string& extname = "EBOUNDS");
81 81 void save(const std::string& filename,
... ... @@ -130,7 +130,7 @@ int GEbounds::size(void) const
130 130 * @return True if there are no energy boundaries.
131 131 ***************************************************************************/
132 132 inline
133   -bool GEbounds::isempty(void) const
  133 +bool GEbounds::is_empty(void) const
134 134 {
135 135 return (m_num == 0);
136 136 }
... ...
include/GEnergies.hpp
  View file @5d8d9ed
... ... @@ -65,7 +65,7 @@ public:
65 65 GEnergy& at(const int& index);
66 66 const GEnergy& at(const int& index) const;
67 67 int size(void) const;
68   - bool isempty(void) const;
  68 + bool is_empty(void) const;
69 69 GEnergy& append(const GEnergy& energy);
70 70 GEnergy& insert(const int& index, const GEnergy& energy);
71 71 void remove(const int& index);
... ... @@ -141,14 +141,14 @@ int GEnergies::size(void) const
141 141 * Signals if the energy container does not contain any energy.
142 142 ***************************************************************************/
143 143 inline
144   -bool GEnergies::isempty(void) const
  144 +bool GEnergies::is_empty(void) const
145 145 {
146 146 return (m_energies.empty());
147 147 }
148 148  
149 149  
150 150 /***********************************************************************//**
151   - * @brief Reserves space for energues in container
  151 + * @brief Reserves space for energies in container
152 152 *
153 153 * @param[in] num Number of energies.
154 154 *
... ...
include/GEvent.hpp
  View file @5d8d9ed
... ... @@ -41,10 +41,10 @@
41 41 * @brief Abstract interface for the event classes.
42 42 *
43 43 * This class provides an abstract interface to an event. An event can be
44   - * either a physical event occuring in the instrument (called an event
  44 + * either a physical event occurring in the instrument (called an event
45 45 * atom) or a collection of events with similar properties (called an
46 46 * event bin). While event atoms are used for unbinned analysis, event bins
47   - * are used for binned analysis. The methods isatom() and isbin() inform
  47 + * are used for binned analysis. The methods is_atom() and is_bin() inform
48 48 * whether an event is an atom or a bin.
49 49 *
50 50 * Each event has 3 attributes: energy, instrument direction and time.
... ... @@ -88,8 +88,8 @@ public:
88 88 virtual const GTime& time(void) const = 0;
89 89 virtual double counts(void) const = 0;
90 90 virtual double error(void) const = 0;
91   - virtual bool isatom(void) const = 0;
92   - virtual bool isbin(void) const = 0;
  91 + virtual bool is_atom(void) const = 0;
  92 + virtual bool is_bin(void) const = 0;
93 93 virtual std::string print(const GChatter& chatter = NORMAL) const = 0;
94 94  
95 95 protected:
... ...
include/GEventAtom.hpp
  View file @5d8d9ed
... ... @@ -40,7 +40,7 @@
40 40 *
41 41 * @brief Abstract interface for the event atom class.
42 42 *
43   - * An event atom is a single event occuring in an instrument. Event atoms
  43 + * An event atom is a single event occurring in an instrument. Event atoms
44 44 * are used for unbinned analysis.
45 45 *
46 46 * Each event has 3 attributes: energy, instrument direction and time.
... ... @@ -85,8 +85,8 @@ public:
85 85 virtual std::string print(const GChatter& chatter = NORMAL) const = 0;
86 86  
87 87 // Other methods
88   - bool isatom(void) const;
89   - bool isbin(void) const;
  88 + bool is_atom(void) const;
  89 + bool is_bin(void) const;
90 90  
91 91 protected:
92 92 // Protected methods
... ... @@ -143,7 +143,7 @@ double GEventAtom::error(void) const
143 143 * @return True.
144 144 ***************************************************************************/
145 145 inline
146   -bool GEventAtom::isatom(void) const
  146 +bool GEventAtom::is_atom(void) const
147 147 {
148 148 return (true);
149 149 }
... ... @@ -155,7 +155,7 @@ bool GEventAtom::isatom(void) const
155 155 * @return False.
156 156 ***************************************************************************/
157 157 inline
158   -bool GEventAtom::isbin(void) const
  158 +bool GEventAtom::is_bin(void) const
159 159 {
160 160 return (false);
161 161 }
... ...
include/GEventBin.hpp
  View file @5d8d9ed
... ... @@ -88,8 +88,8 @@ public:
88 88 virtual std::string print(const GChatter& chatter = NORMAL) const = 0;
89 89  
90 90 // Other methods
91   - bool isatom(void) const;
92   - bool isbin(void) const;
  91 + bool is_atom(void) const;
  92 + bool is_bin(void) const;
93 93  
94 94 protected:
95 95 // Protected methods
... ... @@ -105,7 +105,7 @@ protected:
105 105 * @return False.
106 106 ***************************************************************************/
107 107 inline
108   -bool GEventBin::isatom(void) const
  108 +bool GEventBin::is_atom(void) const
109 109 {
110 110 return (false);
111 111 }
... ... @@ -117,7 +117,7 @@ bool GEventBin::isatom(void) const
117 117 * @return True.
118 118 ***************************************************************************/
119 119 inline
120   -bool GEventBin::isbin(void) const
  120 +bool GEventBin::is_bin(void) const
121 121 {
122 122 return (true);
123 123 }
... ...
include/GException.hpp
  View file @5d8d9ed
... ... @@ -20,7 +20,7 @@
20 20 ***************************************************************************/
21 21 /**
22 22 * @file GException.hpp
23   - * @brief Exception handler interface definiton.
  23 + * @brief Exception handler interface definition.
24 24 * @author Juergen Knoedlseder
25 25 */
26 26  
... ...
include/GFits.hpp
  View file @5d8d9ed
... ... @@ -91,7 +91,7 @@ public:
91 91 GFitsTable* table(const std::string& extname);
92 92 const GFitsTable* table(const std::string& extname) const;
93 93 int size(void) const;
94   - bool isempty(void) const;
  94 + bool is_empty(void) const;
95 95 GFitsHDU* set(const int& extno, const GFitsHDU& hdu);
96 96 GFitsHDU* set(const std::string& extname, const GFitsHDU& hdu);
97 97 GFitsHDU* append(const GFitsHDU& hdu);
... ... @@ -230,7 +230,7 @@ int GFits::size(void) const
230 230 * Signals if the FITS file does not contain any HDUs.
231 231 ***************************************************************************/
232 232 inline
233   -bool GFits::isempty(void) const
  233 +bool GFits::is_empty(void) const
234 234 {
235 235 return (m_hdu.empty());
236 236 }
... ...
include/GFitsHDU.hpp
  View file @5d8d9ed
... ... @@ -83,8 +83,8 @@ public:
83 83 void extno(const int& extno);
84 84 GFitsHeader& header(void);
85 85 const GFitsHeader& header(void) const;
86   - bool hascard(const int& cardno) const;
87   - bool hascard(const std::string& keyname) const;
  86 + bool has_card(const int& cardno) const;
  87 + bool has_card(const std::string& keyname) const;
88 88 GFitsHeaderCard& card(const int& cardno);
89 89 const GFitsHeaderCard& card(const int& cardno) const;
90 90 GFitsHeaderCard& card(const std::string& keyname);
... ... @@ -222,7 +222,7 @@ const GFitsHeader&amp; GFitsHDU::header(void) const
222 222 * @return True if card with specified card number @p cardno exists in header.
223 223 ***************************************************************************/
224 224 inline
225   -bool GFitsHDU::hascard(const int& cardno) const
  225 +bool GFitsHDU::has_card(const int& cardno) const
226 226 {
227 227 return m_header.contains(cardno);
228 228 }
... ... @@ -235,7 +235,7 @@ bool GFitsHDU::hascard(const int&amp; cardno) const
235 235 * @return True if card with specified @p keyname exists in header.
236 236 ***************************************************************************/
237 237 inline
238   -bool GFitsHDU::hascard(const std::string& keyname) const
  238 +bool GFitsHDU::has_card(const std::string& keyname) const
239 239 {
240 240 return (m_header.contains(keyname));
241 241 }
... ...
include/GFitsHeader.hpp
  View file @5d8d9ed
... ... @@ -74,7 +74,7 @@ public:
74 74 int integer(const int& cardno) const;
75 75 int integer(const std::string& keyname) const;
76 76 int size(void) const;
77   - bool isempty(void) const;
  77 + bool is_empty(void) const;
78 78 GFitsHeaderCard& append(const GFitsHeaderCard& card);
79 79 GFitsHeaderCard& insert(const int& cardno, const GFitsHeaderCard& card);
80 80 GFitsHeaderCard& insert(const std::string& keyname, const GFitsHeaderCard& card);
... ... @@ -174,7 +174,7 @@ int GFitsHeader::size(void) const
174 174 * Signals if there are no cards in the FITS header.
175 175 ***************************************************************************/
176 176 inline
177   -bool GFitsHeader::isempty(void) const
  177 +bool GFitsHeader::is_empty(void) const
178 178 {
179 179 return (m_cards.empty());
180 180 }
... ...
include/GFitsImage.hpp
  View file @5d8d9ed
... ... @@ -157,7 +157,7 @@ const int&amp; GFitsImage::naxis(void) const
157 157  
158 158  
159 159 /***********************************************************************//**
160   - * @brief Return number of nul values envountered during loading
  160 + * @brief Return number of nul values encountered during loading
161 161 ***************************************************************************/
162 162 inline
163 163 const int& GFitsImage::anynul(void) const
... ...
include/GFitsTableBitCol.hpp
  View file @5d8d9ed
... ... @@ -39,7 +39,7 @@
39 39 *
40 40 * This class implements a FITS table Bit column. Bits are stored internally
41 41 * in an array of type char and is transferred to the file in junks of
42   - * 8 Bits (using the cfitsio type TBYTE).
  42 + * 8 Bits (using the CFITSIO type TBYTE).
43 43 ***************************************************************************/
44 44 class GFitsTableBitCol : public GFitsTableCol {
45 45  
... ... @@ -64,7 +64,7 @@ public:
64 64 virtual int integer(const int& row, const int& col = 0) const;
65 65 virtual void insert(const int& row, const int& nrows);
66 66 virtual void remove(const int& row, const int& nrows);
67   - virtual bool isloaded(void) const;
  67 + virtual bool is_loaded(void) const;
68 68  
69 69 // Other methods
70 70 unsigned char* data(void);
... ... @@ -115,7 +115,7 @@ private:
115 115 * @return True if column has been loaded, false otherwise
116 116 ***************************************************************************/
117 117 inline
118   -bool GFitsTableBitCol::isloaded(void) const
  118 +bool GFitsTableBitCol::is_loaded(void) const
119 119 {
120 120 return (m_data != NULL);
121 121 }
... ...
include/GFitsTableBoolCol.hpp
  View file @5d8d9ed
... ... @@ -65,7 +65,7 @@ public:
65 65 virtual int integer(const int& row, const int& col = 0) const;
66 66 virtual void insert(const int& row, const int& nrows);
67 67 virtual void remove(const int& row, const int& nrows);
68   - virtual bool isloaded(void) const;
  68 + virtual bool is_loaded(void) const;
69 69  
70 70 // Other methods
71 71 bool* data(void);
... ... @@ -107,7 +107,7 @@ private:
107 107 * @return True if column has been loaded, false otherwise
108 108 ***************************************************************************/
109 109 inline
110   -bool GFitsTableBoolCol::isloaded(void) const
  110 +bool GFitsTableBoolCol::is_loaded(void) const
111 111 {
112 112 return (m_data != NULL);
113 113 }
... ...
include/GFitsTableByteCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 unsigned char* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableByteCol::isloaded(void) const
  101 +bool GFitsTableByteCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GFitsTableCDoubleCol.hpp
  View file @5d8d9ed
... ... @@ -63,7 +63,7 @@ public:
63 63 virtual int integer(const int& row, const int& col = 0) const;
64 64 virtual void insert(const int& row, const int& nrows);
65 65 virtual void remove(const int& row, const int& nrows);
66   - virtual bool isloaded(void) const;
  66 + virtual bool is_loaded(void) const;
67 67  
68 68 // Other methods
69 69 GFits::cdouble* data(void);
... ... @@ -99,7 +99,7 @@ private:
99 99 * @return True if column has been loaded, false otherwise
100 100 ***************************************************************************/
101 101 inline
102   -bool GFitsTableCDoubleCol::isloaded(void) const
  102 +bool GFitsTableCDoubleCol::is_loaded(void) const
103 103 {
104 104 return (m_data != NULL);
105 105 }
... ...
include/GFitsTableCFloatCol.hpp
  View file @5d8d9ed
... ... @@ -63,7 +63,7 @@ public:
63 63 virtual int integer(const int& row, const int& col = 0) const;
64 64 virtual void insert(const int& row, const int& nrows);
65 65 virtual void remove(const int& row, const int& nrows);
66   - virtual bool isloaded(void) const;
  66 + virtual bool is_loaded(void) const;
67 67  
68 68 // Other methods
69 69 GFits::cfloat* data(void);
... ... @@ -99,7 +99,7 @@ private:
99 99 * @return True if column has been loaded, false otherwise
100 100 ***************************************************************************/
101 101 inline
102   -bool GFitsTableCFloatCol::isloaded(void) const
  102 +bool GFitsTableCFloatCol::is_loaded(void) const
103 103 {
104 104 return (m_data != NULL);
105 105 }
... ...
include/GFitsTableCol.hpp
  View file @5d8d9ed
... ... @@ -67,7 +67,7 @@ public:
67 67 virtual int integer(const int& row, const int& inx = 0) const = 0;
68 68 virtual void insert(const int& row, const int& nrows) = 0;
69 69 virtual void remove(const int& row, const int& nrows) = 0;
70   - virtual bool isloaded(void) const = 0;
  70 + virtual bool is_loaded(void) const = 0;
71 71  
72 72 // Other methods
73 73 void name(const std::string& name);
... ... @@ -90,8 +90,8 @@ public:
90 90 int elements(const int& row) const;
91 91 void length(const int& length);
92 92 const int& length(void) const;
93   - void isvariable(const bool& variable);
94   - const bool& isvariable(void) const;
  93 + void is_variable(const bool& variable);
  94 + const bool& is_variable(void) const;
95 95 void anynul(const int& anynul);
96 96 const int& anynul(void) const;
97 97 std::string tform_binary(void) const;
... ... @@ -132,7 +132,7 @@ protected:
132 132 //!< This parameter is used to signal if a
133 133 //!< table column corresponds to a FITS file
134 134 //!< column. If it is set to 0 there is no
135   - //!< correspondance.
  135 + //!< correspondence.
136 136 int m_type; //!< Column type
137 137 int m_repeat; //!< Repeat value of column
138 138 int m_width; //!< Width of single column element
... ... @@ -140,7 +140,7 @@ protected:
140 140 //!< m_number = m_repeat / m_width
141 141 int m_length; //!< Length of column (number of rows)
142 142 bool m_variable; //!< Signals if column is variable length
143   - int m_varlen; //!< Maximum number of elements in variable-lgth
  143 + int m_varlen; //!< Maximum number of elements in variable-length
144 144 std::vector<int> m_rowstart; //!< Start index of each row
145 145 mutable int m_size; //!< Size of allocated data area (0 if not loaded)
146 146 int m_anynul; //!< Number of NULLs encountered
... ... @@ -437,7 +437,7 @@ const int&amp; GFitsTableCol::length(void) const
437 437 * @param[in] variable Variable-length flag.
438 438 ***************************************************************************/
439 439 inline
440   -void GFitsTableCol::isvariable(const bool& variable)
  440 +void GFitsTableCol::is_variable(const bool& variable)
441 441 {
442 442 // Set variable-length flag
443 443 m_variable = variable;
... ... @@ -453,7 +453,7 @@ void GFitsTableCol::isvariable(const bool&amp; variable)
453 453 * @return True if column is a variable length column
454 454 ***************************************************************************/
455 455 inline
456   -const bool& GFitsTableCol::isvariable(void) const
  456 +const bool& GFitsTableCol::is_variable(void) const
457 457 {
458 458 // Return variable-length flag
459 459 return m_variable;
... ...
include/GFitsTableDoubleCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 double* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableDoubleCol::isloaded(void) const
  101 +bool GFitsTableDoubleCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GFitsTableFloatCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 float* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableFloatCol::isloaded(void) const
  101 +bool GFitsTableFloatCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GFitsTableLongCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 long* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableLongCol::isloaded(void) const
  101 +bool GFitsTableLongCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GFitsTableLongLongCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 long long* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableLongLongCol::isloaded(void) const
  101 +bool GFitsTableLongLongCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GFitsTableShortCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 short* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableShortCol::isloaded(void) const
  101 +bool GFitsTableShortCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GFitsTableStringCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 std::string* data(void);
... ... @@ -104,7 +104,7 @@ private:
104 104 * @return True if column has been loaded, false otherwise
105 105 ***************************************************************************/
106 106 inline
107   -bool GFitsTableStringCol::isloaded(void) const
  107 +bool GFitsTableStringCol::is_loaded(void) const
108 108 {
109 109 return (m_data != NULL);
110 110 }
... ...
include/GFitsTableULongCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 unsigned long* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableULongCol::isloaded(void) const
  101 +bool GFitsTableULongCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GFitsTableUShortCol.hpp
  View file @5d8d9ed
... ... @@ -62,7 +62,7 @@ public:
62 62 virtual int integer(const int& row, const int& col = 0) const;
63 63 virtual void insert(const int& row, const int& nrows);
64 64 virtual void remove(const int& row, const int& nrows);
65   - virtual bool isloaded(void) const;
  65 + virtual bool is_loaded(void) const;
66 66  
67 67 // Other methods
68 68 unsigned short* data(void);
... ... @@ -98,7 +98,7 @@ private:
98 98 * @return True if column has been loaded, false otherwise
99 99 ***************************************************************************/
100 100 inline
101   -bool GFitsTableUShortCol::isloaded(void) const
  101 +bool GFitsTableUShortCol::is_loaded(void) const
102 102 {
103 103 return (m_data != NULL);
104 104 }
... ...
include/GGti.hpp
  View file @5d8d9ed
... ... @@ -66,7 +66,7 @@ public:
66 66 void clear(void);
67 67 GGti* clone(void) const;
68 68 int size(void) const;
69   - bool isempty(void) const;
  69 + bool is_empty(void) const;
70 70 void append(const GTime& tstart, const GTime& tstop);
71 71 void insert(const GTime& tstart, const GTime& tstop);
72 72 void merge(void);
... ... @@ -132,7 +132,7 @@ int GGti::size(void) const
132 132 * @return True if there are no Good Time Intervals.
133 133 ***************************************************************************/
134 134 inline
135   -bool GGti::isempty(void) const
  135 +bool GGti::is_empty(void) const
136 136 {
137 137 return (m_num == 0);
138 138 }
... ...
include/GHealpix.hpp
  View file @5d8d9ed
... ... @@ -37,7 +37,7 @@
37 37 /***********************************************************************//**
38 38 * @class GHealpix
39 39 *
40   - * @brief HealPix projection class interface defintion
  40 + * @brief HealPix projection class interface definition
41 41 *
42 42 * The HealPix projection class has been implemented by adapting code from
43 43 * the HealPix library (version 2.1). For more information about HEALPix, see
... ...
include/GIntegral.hpp
  View file @5d8d9ed
... ... @@ -36,7 +36,7 @@
36 36 /***********************************************************************//**
37 37 * @class GIntegral
38 38 *
39   - * @brief GIntegral class interface defintion.
  39 + * @brief GIntegral class interface definition.
40 40 *
41 41 * This class allows to perform integration using various methods. The
42 42 * integrand is implemented by a derived class of GIntegrand.
... ...
include/GLog.hpp
  View file @5d8d9ed
... ... @@ -38,7 +38,7 @@
38 38 /***********************************************************************//**
39 39 * @class GLog
40 40 *
41   - * @brief Information logger interface defintion.
  41 + * @brief Information logger interface definition.
42 42 *
43 43 * This class implements an interface for logging of text messages to the
44 44 * standard output and/or error streams and into an ASCII log file. It
... ...
include/GMatrix.hpp
  View file @5d8d9ed
... ... @@ -40,9 +40,9 @@ class GVector;
40 40 /***********************************************************************//**
41 41 * @class GMatrix
42 42 *
43   - * @brief Generic matrix class defintion
  43 + * @brief Generic matrix class definition
44 44 *
45   - * This class implements a generic matrix. The class is a non-spezialized
  45 + * This class implements a generic matrix. The class is a non-specialized
46 46 * representation of a matrix, and all other matrix storage classes can be
47 47 * converted into that class.
48 48 *
... ... @@ -59,7 +59,7 @@ class GVector;
59 59 * where @p rows and @p columns specify the number of rows and columns of
60 60 * the matrix. Storage conversion constructors exist that allow allocating
61 61 * a generic matrix by copying from a sparse matrix of type GMatrixSparse
62   - * and a symmetrix matrix of type GMatrixSymmetric.
  62 + * and a symmetric matrix of type GMatrixSymmetric.
63 63 *
64 64 * To support using the GMatrix for coordinate transformations, methods
65 65 * are available to compute matrices for the three Euler angles:
... ...
include/GMatrixBase.hpp
  View file @5d8d9ed
... ... @@ -36,7 +36,7 @@
36 36 /***********************************************************************//**
37 37 * @class GMatrixBase
38 38 *
39   - * @brief Abstract matrix base class interface defintion
  39 + * @brief Abstract matrix base class interface definition
40 40 *
41 41 * This class provides the abstract interface for all matrix classes. A
42 42 * GammaLib matrix is a two dimensional array of double precision values
... ...
include/GMatrixSparse.hpp
  View file @5d8d9ed
... ... @@ -48,7 +48,7 @@ class GSparseNumeric;
48 48 /***********************************************************************//**
49 49 * @class GMatrixSparse
50 50 *
51   - * @brief Sparse matrix class interface defintion
  51 + * @brief Sparse matrix class interface definition
52 52 *
53 53 * This class implements a sparse matrix. The class only stores non-zero
54 54 * elements, which can considerably reduce the memory requirements for large
... ... @@ -123,7 +123,7 @@ class GSparseNumeric;
123 123 * the matrix and @p elements is the size of the memory that should be
124 124 * pre-allocated for matrix storage (optional). Storage conversion
125 125 * constructors exist that allow allocating a sparse matrix by copying from
126   - * a general matrix of type GMatrix and a symmetrix matrix of type
  126 + * a general matrix of type GMatrix and a symmetric matrix of type
127 127 * GMatrixSymmetric.
128 128 *
129 129 * Because the location of a specific matrix element is not necessarily known
... ... @@ -167,7 +167,7 @@ class GSparseNumeric;
167 167 * 512 is used. If @p entries is set to 0 (the default value), the number of
168 168 * matrix columns is taken as default @p entries value. Note that a too large
169 169 * number of elements will produce some overhead due to fill stack
170   - * management, hence @p entries should not exceeed a value of the order of
  170 + * management, hence @p entries should not exceed a value of the order of
171 171 * 10-100.
172 172 *
173 173 * The stack_flush() method flushes the stack, which is mandatory before any
... ...
include/GMatrixSymmetric.hpp
  View file @5d8d9ed
... ... @@ -40,7 +40,7 @@ class GVector;
40 40 /***********************************************************************//**
41 41 * @class GMatrixSymmetric
42 42 *
43   - * @brief Symmetric matrix class interface defintion
  43 + * @brief Symmetric matrix class interface definition
44 44 *
45 45 * This class implements a symmetric matrix. The class stores only a triangle
46 46 * physically, imposing thus strict matrix symmetry.
... ...
include/GModel.hpp
  View file @5d8d9ed
... ... @@ -69,7 +69,7 @@ class GObservation;
69 69 * handling does not actual depend on the value of this text string.
70 70 *
71 71 * The model @p instruments is a list of text strings that specifies the
72   - * instruments to which the model applies. The isvalid() method will check
  72 + * instruments to which the model applies. The is_valid() method will check
73 73 * a given instrument name against that list to verify if the model applies
74 74 * to an instrument. The instruments() method returns a comma separated
75 75 * list of all instruments. Another instance of this method allows setting
... ... @@ -78,7 +78,7 @@ class GObservation;
78 78 *
79 79 * The model @p ids is a list of text strings that specifies the observation
80 80 * identifiers to which the model applies. This allows specifying of models
81   - * for a specific list of observations. The isvalid() method will check
  81 + * for a specific list of observations. The is_valid() method will check
82 82 * a given observation identifier against that list to verify if the model
83 83 * applies. The ids() method returns a comma separated list of all
84 84 * observation identifiers. Another instance of this method allows setting
... ... @@ -115,7 +115,7 @@ public:
115 115 virtual void clear(void) = 0;
116 116 virtual GModel* clone(void) const = 0;
117 117 virtual std::string type(void) const = 0;
118   - virtual bool isconstant(void) const = 0;
  118 + virtual bool is_constant(void) const = 0;
119 119 virtual double eval(const GEvent& event,
120 120 const GObservation& obs) const = 0;
121 121 virtual double eval_gradients(const GEvent& event,
... ... @@ -130,7 +130,7 @@ public:
130 130 int size(void) const;
131 131 GModelPar& at(const int& index);
132 132 const GModelPar& at(const int& index) const;
133   - bool haspar(const std::string& name) const;
  133 + bool has_par(const std::string& name) const;
134 134 const std::string& name(void) const;
135 135 void name(const std::string& name);
136 136 std::string instruments(void) const;
... ... @@ -139,7 +139,7 @@ public:
139 139 void scale(const GModelPar& par);
140 140 std::string ids(void) const;
141 141 void ids(const std::string& ids);
142   - bool isvalid(const std::string& instruments,
  142 + bool is_valid(const std::string& instruments,
143 143 const std::string& ids) const;
144 144  
145 145 protected:
... ...
include/GModelData.hpp
  View file @5d8d9ed
... ... @@ -66,7 +66,7 @@ public:
66 66 virtual void clear(void) = 0;
67 67 virtual GModelData* clone(void) const = 0;
68 68 virtual std::string type(void) const = 0;
69   - virtual bool isconstant(void) const = 0;
  69 + virtual bool is_constant(void) const = 0;
70 70 virtual double eval(const GEvent& event,
71 71 const GObservation& obs) const = 0;
72 72 virtual double eval_gradients(const GEvent& event,
... ...
include/GModelPar.hpp
  View file @5d8d9ed
... ... @@ -54,7 +54,7 @@
54 54 * value of a parameter.
55 55 *
56 56 * The minimum and maximum values are optional, and existence of these
57   - * attributes is tested using the hasmin() and hasmax() methods,
  57 + * attributes is tested using the has_min() and has_max() methods,
58 58 * respectively. The minimum value, maximum value are removed using the
59 59 * remove_min() and remove_max() methods. Simultaneous removal of minimum
60 60 * and maximum values is done using the remove_range() method.
... ... @@ -65,8 +65,8 @@
65 65 * analytically (true) or numerically (false)
66 66 *
67 67 * The parameter property @p free is set using the free() and fix()
68   - * methods and it is retrieved using the isfree() and isfixed() methods.
69   - * The attribute @p grad is set and retrieved using the has hasgrad()
  68 + * methods and it is retrieved using the is_free() and is_fixed() methods.
  69 + * The attribute @p grad is set and retrieved using the has has_grad()
70 70 * methods.
71 71 *
72 72 * Each model parameter is factorized into a @p factor and a @p scale
... ...
include/GModelSky.hpp
  View file @5d8d9ed
... ... @@ -146,7 +146,7 @@ public:
146 146 virtual void clear(void);
147 147 virtual GModelSky* clone(void) const;
148 148 virtual std::string type(void) const;
149   - virtual bool isconstant(void) const;
  149 + virtual bool is_constant(void) const;
150 150 virtual double eval(const GEvent& event,
151 151 const GObservation& obs) const;
152 152 virtual double eval_gradients(const GEvent& event,
... ... @@ -226,7 +226,7 @@ std::string GModelSky::type(void) const
226 226 * model is a model that has a temporal component of type "Constant".
227 227 ***************************************************************************/
228 228 inline
229   -bool GModelSky::isconstant(void) const
  229 +bool GModelSky::is_constant(void) const
230 230 {
231 231 return (m_temporal != NULL && m_temporal->type() == "Constant");
232 232 }
... ...
include/GModels.hpp
  View file @5d8d9ed
... ... @@ -51,12 +51,12 @@ class GObservation;
51 51 *
52 52 * The GModels class provides methods to manage and to access the models
53 53 * in the container. The number of models in the container is retrieved
54   - * using the size() method. The isempty() method can be used to check
  54 + * using the size() method. The is_empty() method can be used to check
55 55 * whether the container is empty or whether it contains models:
56 56 *
57 57 * GModels models; // Allocate container
58 58 * int n = models.size(); // Number of models in container
59   - * if (models.isempty()) // Check for emptiness
  59 + * if (models.is_empty()) // Check for emptiness
60 60 * std::cout << "Empty container";
61 61 *
62 62 * Access operators exist for accessing of models by index or by name:
... ... @@ -164,7 +164,7 @@ public:
164 164 GModel* at(const int& index);
165 165 const GModel* at(const int& index) const;
166 166 int size(void) const;
167   - bool isempty(void) const;
  167 + bool is_empty(void) const;
168 168 GModel* set(const int& index, const GModel& model);
169 169 GModel* set(const std::string& name, const GModel& model);
170 170 GModel* append(const GModel& model);
... ... @@ -247,7 +247,7 @@ int GModels::size(void) const
247 247 * Signals if the model container does not contain any model.
248 248 ***************************************************************************/
249 249 inline
250   -bool GModels::isempty(void) const
  250 +bool GModels::is_empty(void) const
251 251 {
252 252 return (m_models.empty());
253 253 }
... ...
include/GNodeArray.hpp
  View file @5d8d9ed
... ... @@ -74,7 +74,7 @@ public:
74 74 double& at(const int& index);
75 75 const double& at(const int& index) const;
76 76 int size(void) const;
77   - bool isempty(void) const;
  77 + bool is_empty(void) const;
78 78 void append(const double& node);
79 79 void insert(const int& index, const double& node);
80 80 void remove(const int& index);
... ... @@ -173,7 +173,7 @@ int GNodeArray::size(void) const
173 173 * Signals if the node array does not contain any node.
174 174 ***************************************************************************/
175 175 inline
176   -bool GNodeArray::isempty(void) const
  176 +bool GNodeArray::is_empty(void) const
177 177 {
178 178 return (m_node.empty());
179 179 }
... ...
include/GObservation.hpp
  View file @5d8d9ed
... ... @@ -47,7 +47,7 @@
47 47 *
48 48 * This class provides an abstract interface for an observation. The
49 49 * observation collects information about the instrument, holds the measured
50   - * events, and provides information about the analysis definiton.
  50 + * events, and provides information about the analysis definition.
51 51 * The method model() returns the probability for an event to be measured
52 52 * with a given instrument direction, a given energy and at a given time,
53 53 * given a source model and an instrument pointing direction.
... ...
include/GObservations.hpp
  View file @5d8d9ed
... ... @@ -80,7 +80,7 @@
80 80 *
81 81 * Based on the list of models, the optimize() method will optimize all
82 82 * model parameters that are marked as free in the list of models. The
83   - * npred() method returns the total number of events that are prediced
  83 + * npred() method returns the total number of events that are predicted
84 84 * by all models after optimization.
85 85 *
86 86 * GObservations also provides an optimizer class that is derived from
... ... @@ -107,7 +107,7 @@ public:
107 107 GObservation* at(const int& index);
108 108 const GObservation* at(const int& index) const;
109 109 int size(void) const;
110   - bool isempty(void) const;
  110 + bool is_empty(void) const;
111 111 GObservation* set(const int& index, const GObservation& obs);
112 112 GObservation* append(const GObservation& obs);
113 113 GObservation* insert(const int& index, const GObservation& obs);
... ... @@ -232,7 +232,7 @@ int GObservations::size(void) const
232 232 * Signals if the observation container does not contain any observation.
233 233 ***************************************************************************/
234 234 inline
235   -bool GObservations::isempty(void) const
  235 +bool GObservations::is_empty(void) const
236 236 {
237 237 return (m_obs.empty());
238 238 }
... ...
include/GOptimizerLM.hpp
  View file @5d8d9ed
... ... @@ -83,7 +83,7 @@ public:
83 83 int max_boundary_hits(void) const { return m_max_hit; } //!< @brief Return maximum number of boundary hits
84 84 const double& lambda_start(void) const { return m_lambda_start; } //!< @brief Return lambda start value
85 85 const double& lambda_inc(void) const { return m_lambda_inc; } //!< @brief Return lambda increment
86   - const double& lambda_dec(void) const { return m_lambda_dec; } //!< @brief Return lambda derement
  86 + const double& lambda_dec(void) const { return m_lambda_dec; } //!< @brief Return lambda decrement
87 87 const double& lambda(void) const { return m_lambda; } //!< @brief Return lambda value
88 88 const double& eps(void) const { return m_eps; } //!< @brief Return convergence precision
89 89  
... ...
include/GOptimizerPar.hpp
  View file @5d8d9ed
... ... @@ -55,7 +55,7 @@
55 55 * value of a parameter.
56 56 *
57 57 * The minimum and maximum values are optional, and existence of these
58   - * attributes is tested using the hasmin() and hasmax() methods,
  58 + * attributes is tested using the has_min() and has_max() methods,
59 59 * respectively. The minimum value, maximum value are removed using the
60 60 * remove_min() and remove_max() methods. Simultaneous removal of minimum
61 61 * and maximum values is done using the remove_range() method.
... ... @@ -66,8 +66,8 @@
66 66 * analytically (true) or numerically (false)
67 67 *
68 68 * The parameter property @p free is set using the free() and fix()
69   - * methods and it is retrieved using the isfree() and isfixed() methods.
70   - * The attribute @p grad is set and retrieved using the has hasgrad()
  69 + * methods and it is retrieved using the is_free() and is_fixed() methods.
  70 + * The attribute @p grad is set and retrieved using the has has_grad()
71 71 * methods.
72 72 *
73 73 * Each function parameter is factorized into a @p factor and a @p scale
... ... @@ -128,20 +128,20 @@ public:
128 128 void scale(const double& scale);
129 129  
130 130 // Boundary methods
131   - bool hasmin(void) const;
132   - bool hasmax(void) const;
133   - bool hasrange(void) const;
  131 + bool has_min(void) const;
  132 + bool has_max(void) const;
  133 + bool has_range(void) const;
134 134 void remove_min(void);
135 135 void remove_max(void);
136 136 void remove_range(void);
137 137  
138 138 // Property methods
139   - bool isfree(void) const;
140   - bool isfixed(void) const;
141   - bool hasgrad(void) const;
  139 + bool is_free(void) const;
  140 + bool is_fixed(void) const;
  141 + bool has_grad(void) const;
142 142 void free(void);
143 143 void fix(void);
144   - void hasgrad(const bool& grad);
  144 + void has_grad(const bool& grad);
145 145  
146 146 // Other methods
147 147 void clear(void);
... ... @@ -169,9 +169,9 @@ protected:
169 169 double m_factor_max; //!< Parameter maximum factor
170 170 double m_scale; //!< Parameter scaling (true = factor * scale)
171 171 bool m_free; //!< Parameter is free
172   - bool m_hasmin; //!< Parameter has minimum boundary
173   - bool m_hasmax; //!< Parameter has maximum boundary
174   - bool m_hasgrad; //!< Parameter has analytic gradient
  172 + bool m_has_min; //!< Parameter has minimum boundary
  173 + bool m_has_max; //!< Parameter has maximum boundary
  174 + bool m_has_grad; //!< Parameter has analytic gradient
175 175 };
176 176  
177 177  
... ... @@ -372,9 +372,9 @@ void GOptimizerPar::factor_gradient(const double&amp; gradient)
372 372 * Signals if the parameter has a minimum boundary.
373 373 ***************************************************************************/
374 374 inline
375   -bool GOptimizerPar::hasmin(void) const
  375 +bool GOptimizerPar::has_min(void) const
376 376 {
377   - return m_hasmin;
  377 + return m_has_min;
378 378 }
379 379  
380 380  
... ... @@ -386,9 +386,9 @@ bool GOptimizerPar::hasmin(void) const
386 386 * Signals if the parameter has a maximum boundary.
387 387 ***************************************************************************/
388 388 inline
389   -bool GOptimizerPar::hasmax(void) const
  389 +bool GOptimizerPar::has_max(void) const
390 390 {
391   - return m_hasmax;
  391 + return m_has_max;
392 392 }
393 393  
394 394  
... ... @@ -401,9 +401,9 @@ bool GOptimizerPar::hasmax(void) const
401 401 * Signals if the parameter has a minimum and a maximum boundary.
402 402 ***************************************************************************/
403 403 inline
404   -bool GOptimizerPar::hasrange(void) const
  404 +bool GOptimizerPar::has_range(void) const
405 405 {
406   - return (m_hasmin && m_hasmax);
  406 + return (m_has_min && m_has_max);
407 407 }
408 408  
409 409  
... ... @@ -415,7 +415,7 @@ bool GOptimizerPar::hasrange(void) const
415 415 inline
416 416 void GOptimizerPar::remove_min(void)
417 417 {
418   - m_hasmin = false;
  418 + m_has_min = false;
419 419 return;
420 420 }
421 421  
... ... @@ -428,7 +428,7 @@ void GOptimizerPar::remove_min(void)
428 428 inline
429 429 void GOptimizerPar::remove_max(void)
430 430 {
431   - m_hasmax = false;
  431 + m_has_max = false;
432 432 return;
433 433 }
434 434  
... ... @@ -441,8 +441,8 @@ void GOptimizerPar::remove_max(void)
441 441 inline
442 442 void GOptimizerPar::remove_range(void)
443 443 {
444   - m_hasmin = false;
445   - m_hasmax = false;
  444 + m_has_min = false;
  445 + m_has_max = false;
446 446 return;
447 447 }
448 448  
... ... @@ -456,7 +456,7 @@ void GOptimizerPar::remove_range(void)
456 456 * parameter optimization process.
457 457 ***************************************************************************/
458 458 inline
459   -bool GOptimizerPar::isfree(void) const
  459 +bool GOptimizerPar::is_free(void) const
460 460 {
461 461 return m_free;
462 462 }
... ... @@ -471,7 +471,7 @@ bool GOptimizerPar::isfree(void) const
471 471 * parameter optimization process.
472 472 ***************************************************************************/
473 473 inline
474   -bool GOptimizerPar::isfixed(void) const
  474 +bool GOptimizerPar::is_fixed(void) const
475 475 {
476 476 return (!m_free);
477 477 }
... ... @@ -488,9 +488,9 @@ bool GOptimizerPar::isfixed(void) const
488 488 * which gradients need to be computed numerically.
489 489 ***************************************************************************/
490 490 inline
491   -bool GOptimizerPar::hasgrad(void) const
  491 +bool GOptimizerPar::has_grad(void) const
492 492 {
493   - return m_hasgrad;
  493 + return m_has_grad;
494 494 }
495 495  
496 496  
... ... @@ -533,9 +533,9 @@ void GOptimizerPar::fix(void)
533 533 * numerically.
534 534 ***************************************************************************/
535 535 inline
536   -void GOptimizerPar::hasgrad(const bool& grad)
  536 +void GOptimizerPar::has_grad(const bool& grad)
537 537 {
538   - m_hasgrad = grad;
  538 + m_has_grad = grad;
539 539 return;
540 540 }
541 541  
... ...
include/GOptimizerPars.hpp
  View file @5d8d9ed
... ... @@ -70,7 +70,7 @@ public:
70 70 GOptimizerPar* at(const int& index);
71 71 const GOptimizerPar* at(const int& index) const;
72 72 int size(void) const;
73   - bool isempty(void) const;
  73 + bool is_empty(void) const;
74 74 int nfree(void) const;
75 75 GOptimizerPar* set(const int& index, const GOptimizerPar& par);
76 76 GOptimizerPar* set(const std::string& name, const GOptimizerPar& par);
... ... @@ -151,7 +151,7 @@ int GOptimizerPars::size(void) const
151 151 * Signals if the parameters container does not contain any parameter.
152 152 ***************************************************************************/
153 153 inline
154   -bool GOptimizerPars::isempty(void) const
  154 +bool GOptimizerPars::is_empty(void) const
155 155 {
156 156 return (m_pars.empty());
157 157 }
... ...
include/GPar.hpp
  View file @5d8d9ed
... ... @@ -79,12 +79,12 @@ public:
79 79 const std::string& min(void) const;
80 80 const std::string& max(void) const;
81 81 const std::string& prompt(void) const;
82   - bool islearn(void) const;
83   - bool isquery(void) const;
84   - bool isfilename(void) const;
85   - bool isvalid(void);
86   - bool isundefined(void);
87   - bool isnotanumber(void);
  82 + bool is_learn(void) const;
  83 + bool is_query(void) const;
  84 + bool is_filename(void) const;
  85 + bool is_valid(void);
  86 + bool is_undefined(void);
  87 + bool is_notanumber(void);
88 88 std::string print(const GChatter& chatter = NORMAL) const;
89 89  
90 90 protected:
... ...
include/GPars.hpp
  View file @5d8d9ed
... ... @@ -68,7 +68,7 @@ public:
68 68 GPar& at(const int& index);
69 69 const GPar& at(const int& index) const;
70 70 int size(void) const;
71   - bool isempty(void) const;
  71 + bool is_empty(void) const;
72 72 GPar& append(const GPar& par);
73 73 void append_standard(void);
74 74 GPar& insert(const int& index, const GPar& par);
... ... @@ -158,7 +158,7 @@ int GPars::size(void) const
158 158 * Signals if the parameter container does not contain any parameter.
159 159 ***************************************************************************/
160 160 inline
161   -bool GPars::isempty(void) const
  161 +bool GPars::is_empty(void) const
162 162 {
163 163 return (m_pars.empty());
164 164 }
... ...
include/GPhotons.hpp
  View file @5d8d9ed
... ... @@ -59,7 +59,7 @@ public:
59 59 void clear(void);
60 60 GPhotons* clone(void) const;
61 61 int size(void) const;
62   - bool isempty(void) const;
  62 + bool is_empty(void) const;
63 63 void append(const GPhoton& photon);
64 64 void insert(const int& index, const GPhoton& photon);
65 65 void remove(const int& index);
... ... @@ -96,7 +96,7 @@ int GPhotons::size(void) const
96 96 * @return True if there are no photons.
97 97 ***************************************************************************/
98 98 inline
99   -bool GPhotons::isempty(void) const
  99 +bool GPhotons::is_empty(void) const
100 100 {
101 101 return m_photons.empty();
102 102 }
... ...
include/GResponse.hpp
  View file @5d8d9ed
... ... @@ -72,8 +72,8 @@ public:
72 72 // Pure virtual methods
73 73 virtual void clear(void) = 0;
74 74 virtual GResponse* clone(void) const = 0;
75   - virtual bool hasedisp(void) const = 0;
76   - virtual bool hastdisp(void) const = 0;
  75 + virtual bool has_edisp(void) const = 0;
  76 + virtual bool has_tdisp(void) const = 0;
77 77 virtual double irf(const GEvent& event,
78 78 const GPhoton& photon,
79 79 const GObservation& obs) const = 0;
... ...
include/GSkyPixel.hpp
  View file @5d8d9ed
... ... @@ -62,13 +62,13 @@
62 62 * int index = GSkyPixel(1); // Retrieve integer index
63 63 * double dindex = GSkyPixel(1.0); // Retrieve double precision index
64 64 *
65   - * The dimensionality of a pixel is checked using the is1D() and is2D()
  65 + * The dimensionality of a pixel is checked using the is_1D() and is_2D()
66 66 * methods. The size() method returns 1 for 1D pixels and 2 for 2D pixels.
67 67 * If a pixel is not initialised, e.g.
68 68 *
69 69 * GSkyPixel pixel; // Not initialised
70 70 *
71   - * the is1D() and is2D() methods return false and the size() method returns
  71 + * the is_1D() and is_2D() methods return false and the size() method returns
72 72 * 0.
73 73 ***************************************************************************/
74 74 class GSkyPixel : public GBase {
... ... @@ -92,8 +92,8 @@ public:
92 92 void clear(void);
93 93 GSkyPixel* clone(void) const;
94 94 int size(void) const;
95   - bool is1D(void) const;
96   - bool is2D(void) const;
  95 + bool is_1D(void) const;
  96 + bool is_2D(void) const;
97 97 void index(const double& index);
98 98 void x(const double& x);
99 99 void y(const double& y);
... ... @@ -137,7 +137,7 @@ int GSkyPixel::size(void) const
137 137 * @return True if pixel is 1D.
138 138 ***************************************************************************/
139 139 inline
140   -bool GSkyPixel::is1D(void) const
  140 +bool GSkyPixel::is_1D(void) const
141 141 {
142 142 return (m_size == 1);
143 143 }
... ... @@ -149,7 +149,7 @@ bool GSkyPixel::is1D(void) const
149 149 * @return True if pixel is 2D.
150 150 ***************************************************************************/
151 151 inline
152   -bool GSkyPixel::is2D(void) const
  152 +bool GSkyPixel::is_2D(void) const
153 153 {
154 154 return (m_size == 2);
155 155 }
... ...
include/GSkyRegions.hpp
  View file @5d8d9ed
... ... @@ -72,7 +72,7 @@ public:
72 72 GSkyRegion* at(const int& index);
73 73 const GSkyRegion* at(const int& index) const;
74 74 int size(void) const;
75   - bool isempty(void) const;
  75 + bool is_empty(void) const;
76 76 GSkyRegion* set(const int& index, const GSkyRegion& region);
77 77 GSkyRegion* set(const std::string& name, const GSkyRegion& region);
78 78 GSkyRegion* append(const GSkyRegion& region);
... ... @@ -83,7 +83,7 @@ public:
83 83 void reserve(const int& num);
84 84 void extend(const GSkyRegions& regions);
85 85 bool contains(const std::string& name) const;
86   - bool contains(const GSkyDir& dir) const;
  86 + bool contains(const GSkyDir& dir) const;
87 87 bool overlaps(const GSkyRegion& reg) const;
88 88 void load(const std::string& filename);
89 89 void save(const std::string& filename) const;
... ... @@ -153,7 +153,7 @@ int GSkyRegions::size(void) const
153 153 * Signals if the region container does not contain any region.
154 154 ***************************************************************************/
155 155 inline
156   -bool GSkyRegions::isempty(void) const
  156 +bool GSkyRegions::is_empty(void) const
157 157 {
158 158 return (m_regions.empty());
159 159 }
... ...
include/GTestCase.hpp
  View file @5d8d9ed
... ... @@ -73,8 +73,8 @@ public:
73 73 void type( const std::string& type);
74 74 const ErrorKind& kind(void) const;
75 75 void kind(const ErrorKind& kind);
76   - const bool& passed(void) const;
77   - void passed(const bool& passed);
  76 + const bool& has_passed(void) const;
  77 + void has_passed(const bool& has_passed);
78 78 const double& duration(void) const;
79 79 void duration(const double& duration);
80 80 std::string print(const GChatter& chatter = NORMAL) const;
... ... @@ -86,12 +86,12 @@ protected:
86 86 void free_members(void);
87 87  
88 88 // Private members
89   - std::string m_name; //!< Test name
90   - std::string m_message; //!< Test message
91   - std::string m_type; //!< Test type
92   - bool m_passed; //!< Boolean to check test success
93   - ErrorKind m_kind; //!< Kind of test case (failure or error test)
94   - double m_duration; //!< Test duration
  89 + std::string m_name; //!< Test name
  90 + std::string m_message; //!< Test message
  91 + std::string m_type; //!< Test type
  92 + bool m_has_passed; //!< Boolean to check test success
  93 + ErrorKind m_kind; //!< Kind of test case (failure or error test)
  94 + double m_duration; //!< Test duration
95 95 };
96 96  
97 97  
... ... @@ -209,21 +209,21 @@ void GTestCase::kind(const ErrorKind&amp; kind)
209 209 * This method returns true if the test has passed, false otherwise.
210 210 ***************************************************************************/
211 211 inline
212   -const bool& GTestCase::passed(void) const
  212 +const bool& GTestCase::has_passed(void) const
213 213 {
214   - return m_passed;
  214 + return m_has_passed;
215 215 }
216 216  
217 217  
218 218 /***********************************************************************//**
219 219 * @brief Set if test passed
220 220 *
221   - * @param[in] passed Test passed (true or false)
  221 + * @param[in] has_passed Test passed (true or false)
222 222 ***************************************************************************/
223 223 inline
224   -void GTestCase::passed(const bool& passed)
  224 +void GTestCase::has_passed(const bool& has_passed)
225 225 {
226   - m_passed = passed;
  226 + m_has_passed = has_passed;
227 227 return;
228 228 }
229 229  
... ...
include/GTestSuites.hpp
  View file @5d8d9ed
... ... @@ -20,7 +20,7 @@
20 20 ***************************************************************************/
21 21 /**
22 22 * @file GTestSuites.hpp
23   - * @brief Test suite container class interface defintion
  23 + * @brief Test suite container class interface definition
24 24 * @author Jean-Baptiste Cayrou
25 25 */
26 26  
... ... @@ -67,7 +67,7 @@ public:
67 67 GTestSuite* at(const int& index);
68 68 const GTestSuite* at(const int& index) const;
69 69 int size(void) const;
70   - bool isempty(void) const;
  70 + bool is_empty(void) const;
71 71 GTestSuite* set(const int& index, const GTestSuite& suite);
72 72 GTestSuite* append(const GTestSuite& suite);
73 73 GTestSuite* insert(const int& index, const GTestSuite& suite);
... ... @@ -154,7 +154,7 @@ int GTestSuites::size(void) const
154 154 * Signals if the container does not contain any test suite.
155 155 ***************************************************************************/
156 156 inline
157   -bool GTestSuites::isempty(void) const
  157 +bool GTestSuites::is_empty(void) const
158 158 {
159 159 return (m_testsuites.empty());
160 160 }
... ...
include/GTimes.hpp
  View file @5d8d9ed
... ... @@ -59,7 +59,7 @@ public:
59 59 void clear(void);
60 60 GTimes* clone(void) const;
61 61 int size(void) const;
62   - bool isempty(void) const;
  62 + bool is_empty(void) const;
63 63 void append(const GTime& time);
64 64 void insert(const int& index, const GTime& time);
65 65 void remove(const int& index);
... ... @@ -96,7 +96,7 @@ int GTimes::size(void) const
96 96 * @return True if there are no times.
97 97 ***************************************************************************/
98 98 inline
99   -bool GTimes::isempty(void) const
  99 +bool GTimes::is_empty(void) const
100 100 {
101 101 return m_times.empty();
102 102 }
... ...
include/GTools.hpp
  View file @5d8d9ed
... ... @@ -76,7 +76,7 @@ namespace gammalib {
76 76 const char& c = ' ');
77 77 std::string right(const std::string& s, const int& n,
78 78 const char& c = ' ');
79   - std::string center(const std::string& s, const int& n,
  79 + std::string centre(const std::string& s, const int& n,
80 80 const char& c = ' ');
81 81 std::string parformat(const std::string& s, const int& indent = 0);
82 82 double plaw_photon_flux(const double& emin,
... ... @@ -88,9 +88,9 @@ namespace gammalib {
88 88 const double& epivot,
89 89 const double& gamma);
90 90 bool file_exists(const std::string& filename);
91   - bool isinfinite(const double& x);
92   - bool isnotanumber(const double& x);
93   - bool contains(const std::string& str,
  91 + bool is_infinite(const double& x);
  92 + bool is_notanumber(const double& x);
  93 + bool contains(const std::string& str,
94 94 const std::string& substring);
95 95 void warning(const std::string& origin,
96 96 const std::string& message);
... ... @@ -107,7 +107,7 @@ namespace gammalib {
107 107 * This function has been copied from gnulib.
108 108 ***************************************************************************/
109 109 inline
110   -bool gammalib::isinfinite(const double& x)
  110 +bool gammalib::is_infinite(const double& x)
111 111 {
112 112 return (x < -DBL_MAX || x > DBL_MAX);
113 113 }
... ... @@ -121,10 +121,10 @@ bool gammalib::isinfinite(const double&amp; x)
121 121 *
122 122 * Signals if the argument @p x is not a number.
123 123 *
124   - * This function is a very simple kluge. It may not work on all systems.
  124 + * This function is a very simple kludge. It may not work on all systems.
125 125 ***************************************************************************/
126 126 inline
127   -bool gammalib::isnotanumber(const double& x)
  127 +bool gammalib::is_notanumber(const double& x)
128 128 {
129 129 return (x != x);
130 130 }
... ...
include/GUrl.hpp
  View file @5d8d9ed
... ... @@ -59,8 +59,8 @@ public:
59 59 virtual void close(void) = 0;
60 60 virtual int read(void* buffer, const int& nbyte) = 0;
61 61 virtual int write(const void* buffer, const int& nbyte) = 0;
62   - virtual int getchar(void) const = 0;
63   - virtual void putchar(const int& character) = 0;
  62 + virtual int get_char(void) const = 0;
  63 + virtual void put_char(const int& character) = 0;
64 64 virtual void scanf(const char* format, ...) = 0;
65 65 virtual void printf(const char* format, ...) = 0;
66 66 virtual std::string print(const GChatter& chatter = NORMAL) const = 0;
... ...
include/GUrlFile.hpp
  View file @5d8d9ed
... ... @@ -57,8 +57,8 @@ public:
57 57 virtual void close(void);
58 58 virtual int read(void* buffer, const int& nbyte);
59 59 virtual int write(const void* buffer, const int& nbyte);
60   - virtual int getchar(void) const;
61   - virtual void putchar(const int& character);
  60 + virtual int get_char(void) const;
  61 + virtual void put_char(const int& character);
62 62 virtual void scanf(const char* format, ...);
63 63 virtual void printf(const char* format, ...);
64 64 virtual std::string print(const GChatter& chatter = NORMAL) const;
... ...
include/GUrlString.hpp
  View file @5d8d9ed
... ... @@ -58,8 +58,8 @@ public:
58 58 virtual void close(void);
59 59 virtual int read(void* buffer, const int& nbyte);
60 60 virtual int write(const void* buffer, const int& nbyte);
61   - virtual int getchar(void) const;
62   - virtual void putchar(const int& character);
  61 + virtual int get_char(void) const;
  62 + virtual void put_char(const int& character);
63 63 virtual void scanf(const char* format, ...);
64 64 virtual void printf(const char* format, ...);
65 65 virtual std::string print(const GChatter& chatter = NORMAL) const;
... ...
include/GVOClient.hpp
  View file @5d8d9ed
... ... @@ -65,8 +65,8 @@ public:
65 65 GVOClient* clone(void) const;
66 66 void connect(void);
67 67 void disconnect(void);
68   - bool hashub(void) const;
69   - bool isconnected(void) const;
  68 + bool has_hub(void) const;
  69 + bool is_connected(void) const;
70 70 GXml response(void) const;
71 71 std::string print(const GChatter& chatter = NORMAL) const;
72 72  
... ...
include/GVector.hpp
  View file @5d8d9ed
... ... @@ -40,7 +40,7 @@
40 40 * @brief Vector class
41 41 *
42 42 * This class implement a double precision floating point vector class that
43   - * is intended to be used for numerical computation (it is not ment to
  43 + * is intended to be used for numerical computation (it is not meant to
44 44 * replace the std::vector template class).
45 45 ***************************************************************************/
46 46 class GVector : public GBase {
... ...
include/GXml.hpp
  View file @5d8d9ed
... ... @@ -115,14 +115,14 @@
115 115 * and to load and save the document from a URL. GXml derives from GContainer
116 116 * as it behaves like a container class. It does, however, not contain an
117 117 * explicit list, as the only data member of the class is a single instance
118   - * of GXmlDocument. GXmlDocument contains the hierachical list of all XML
  118 + * of GXmlDocument. GXmlDocument contains the hierarchical list of all XML
119 119 * nodes.
120 120 *
121 121 * To manipulate the child nodes of GXmlDocument, the usual container class
122 122 * methods are available. size() returns the number of child nodes that
123 123 * exist in the XML document root (in the above example there would be two
124 124 * child elements with name @p element). The child nodes are accessed using
125   - * the operator[]. The isempty() method checks whether the document root has
  125 + * the operator[]. The is_empty() method checks whether the document root has
126 126 * no children.
127 127 *
128 128 * The set() method allows to set a specific child node, the append() method
... ... @@ -191,7 +191,7 @@ public:
191 191 void clear(void);
192 192 GXml* clone(void) const;
193 193 int size(void) const { return m_root.size(); }
194   - bool isempty(void) const { return m_root.isempty(); }
  194 + bool is_empty(void) const { return m_root.is_empty(); }
195 195 GXmlNode* set(const int& index, const GXmlNode& node);
196 196 GXmlNode* append(const GXmlNode& node);
197 197 GXmlElement* append(const std::string& segment);
... ...
include/GXmlNode.hpp
  View file @5d8d9ed
... ... @@ -82,7 +82,7 @@ public:
82 82 virtual void clear(void) = 0;
83 83 virtual GXmlNode* clone(void) const = 0;
84 84 virtual int size(void) const { return m_nodes.size(); }
85   - virtual bool isempty(void) const { return m_nodes.empty(); }
  85 + virtual bool is_empty(void) const { return m_nodes.empty(); }
86 86 virtual GXmlNode* set(const int& index, const GXmlNode& node);
87 87 virtual GXmlNode* append(const GXmlNode& node);
88 88 virtual GXmlElement* append(const std::string& segment);
... ...
inst/com/include/GCOMModelDRBFitting.hpp
  View file @5d8d9ed
... ... @@ -64,7 +64,7 @@ public:
64 64 virtual void clear(void);
65 65 virtual GCOMModelDRBFitting* clone(void) const;
66 66 virtual std::string type(void) const;
67   - virtual bool isconstant(void) const;
  67 + virtual bool is_constant(void) const;
68 68 virtual double eval(const GEvent& event,
69 69 const GObservation& obs) const;
70 70 virtual double eval_gradients(const GEvent& event,
... ... @@ -121,7 +121,7 @@ std::string GCOMModelDRBFitting::type(void) const
121 121 * model is always temporally constant.
122 122 ***************************************************************************/
123 123 inline
124   -bool GCOMModelDRBFitting::isconstant(void) const
  124 +bool GCOMModelDRBFitting::is_constant(void) const
125 125 {
126 126 return (true);
127 127 }
... ...
inst/com/include/GCOMResponse.hpp
  View file @5d8d9ed
... ... @@ -59,8 +59,8 @@ public:
59 59 // Implement pure virtual base class methods
60 60 virtual void clear(void);
61 61 virtual GCOMResponse* clone(void) const;
62   - virtual bool hasedisp(void) const { return false; }
63   - virtual bool hastdisp(void) const { return false; }
  62 + virtual bool has_edisp(void) const { return false; }
  63 + virtual bool has_tdisp(void) const { return false; }
64 64 virtual double irf(const GEvent& event,
65 65 const GPhoton& photon,
66 66 const GObservation& obs) const;
... ...
inst/com/pyext/GCOMModelDRBFitting.i
  View file @5d8d9ed
... ... @@ -46,7 +46,7 @@ public:
46 46 virtual void clear(void);
47 47 virtual GCOMModelDRBFitting* clone(void) const;
48 48 virtual std::string type(void) const;
49   - virtual bool isconstant(void) const;
  49 + virtual bool is_constant(void) const;
50 50 virtual double eval(const GEvent& event,
51 51 const GObservation& obs) const;
52 52 virtual double eval_gradients(const GEvent& event,
... ...
inst/com/pyext/GCOMResponse.i
  View file @5d8d9ed
... ... @@ -45,8 +45,8 @@ public:
45 45 // Implement pure virtual base class methods
46 46 virtual void clear(void);
47 47 virtual GCOMResponse* clone(void) const;
48   - virtual bool hasedisp(void) const;
49   - virtual bool hastdisp(void) const;
  48 + virtual bool has_edisp(void) const;
  49 + virtual bool has_tdisp(void) const;
50 50 virtual double irf(const GEvent& event,
51 51 const GPhoton& photon,
52 52 const GObservation& obs) const;
... ...
inst/com/src/GCOMEventCube.cpp
  View file @5d8d9ed
... ... @@ -693,7 +693,7 @@ void GCOMEventCube::set_scatter_directions(void)
693 693 // Throw an error if we have no sky pixels
694 694 if (npix() < 1) {
695 695 throw GCOMException::no_sky(G_SET_SCATTER_DIRECTIONS,
696   - "Every COMPTEL event cube needs a definiton of sky pixels.");
  696 + "Every COMPTEL event cube needs a definition of sky pixels.");
697 697 }
698 698  
699 699 // Clear vectors
... ... @@ -760,7 +760,7 @@ void GCOMEventCube::set_energies(void)
760 760 // Throw an error if GTI is empty
761 761 if (m_ebounds.size() < 1) {
762 762 throw GCOMException::no_ebds(G_SET_ENERGIES, "Every COMPTEL event"
763   - " cube needs a definiton of the energy boundaries.");
  763 + " cube needs a definition of the energy boundaries.");
764 764 }
765 765  
766 766 // Compute the logarithmic mean energy
... ...
inst/com/src/GCOMModelDRBFitting.cpp
  View file @5d8d9ed
... ... @@ -299,7 +299,7 @@ double GCOMModelDRBFitting::eval(const GEvent&amp; event,
299 299  
300 300 // Compile option: Check for NaN/Inf
301 301 #if defined(G_NAN_CHECK)
302   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  302 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
303 303 std::cout << "*** ERROR: GCOMModelDRBFitting::eval";
304 304 std::cout << "(index=" << index << "):";
305 305 std::cout << " NaN/Inf encountered";
... ... @@ -375,7 +375,7 @@ double GCOMModelDRBFitting::eval_gradients(const GEvent&amp; event,
375 375 scale = m_values[0].value();
376 376  
377 377 // Compute partial derivative
378   - double grad = (m_values[0].isfree()) ? value * m_values[0].scale() : 0.0;
  378 + double grad = (m_values[0].is_free()) ? value * m_values[0].scale() : 0.0;
379 379  
380 380 // Set gradient (circumvent const correctness)
381 381 const_cast<GCOMModelDRBFitting*>(this)->m_values[0].factor_gradient(grad);
... ... @@ -405,13 +405,13 @@ double GCOMModelDRBFitting::eval_gradients(const GEvent&amp; event,
405 405 m_values[inx_right].value() * wgt_right;
406 406  
407 407 // Gradient for left node
408   - if (m_values[inx_left].isfree()) {
  408 + if (m_values[inx_left].is_free()) {
409 409 double grad = wgt_left * value * m_values[inx_left].scale();
410 410 const_cast<GCOMModelDRBFitting*>(this)->m_values[inx_left].factor_gradient(grad);
411 411 }
412 412  
413 413 // Gradient for right node
414   - if (m_values[inx_right].isfree()) {
  414 + if (m_values[inx_right].is_free()) {
415 415 double grad = wgt_right * value * m_values[inx_right].scale();
416 416 const_cast<GCOMModelDRBFitting*>(this)->m_values[inx_right].factor_gradient(grad);
417 417 }
... ... @@ -423,7 +423,7 @@ double GCOMModelDRBFitting::eval_gradients(const GEvent&amp; event,
423 423  
424 424 // Compile option: Check for NaN/Inf
425 425 #if defined(G_NAN_CHECK)
426   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  426 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
427 427 std::cout << "*** ERROR: GCOMModelDRBFitting::eval_gradients";
428 428 std::cout << "(index=" << index << "):";
429 429 std::cout << " NaN/Inf encountered";
... ... @@ -579,12 +579,12 @@ void GCOMModelDRBFitting::read(const GXmlElement&amp; xml)
579 579 // Set Phibar attributes
580 580 phibar.name(phibar_name);
581 581 phibar.unit("deg");
582   - phibar.hasgrad(false);
  582 + phibar.has_grad(false);
583 583  
584 584 // Set normalization attributes
585 585 normalization.name(normalization_name);
586 586 normalization.unit("");
587   - normalization.hasgrad(true);
  587 + normalization.has_grad(true);
588 588  
589 589 // Push node parameters on list
590 590 m_phibars.push_back(phibar);
... ... @@ -858,10 +858,10 @@ void GCOMModelDRBFitting::set_pointers(void)
858 858 for (int i = 0; i < nodes; ++i) {
859 859  
860 860 // Signal that Phibar values have no gradients
861   - m_phibars[i].hasgrad(false);
  861 + m_phibars[i].has_grad(false);
862 862  
863 863 // Signal that values have gradients
864   - m_values[i].hasgrad(true);
  864 + m_values[i].has_grad(true);
865 865  
866 866 // Set pointer
867 867 m_pars.push_back(&(m_phibars[i]));
... ... @@ -904,7 +904,7 @@ void GCOMModelDRBFitting::set_cache(void) const
904 904 double phibar = m_phibars[i].value();
905 905 m_nodes.append(phibar);
906 906 m_old_phibars.push_back(phibar);
907   - if (m_phibars[i].isfree()) {
  907 + if (m_phibars[i].is_free()) {
908 908 m_fixed = false;
909 909 }
910 910 }
... ...
inst/com/src/GCOMObservation.cpp
  View file @5d8d9ed
... ... @@ -841,8 +841,8 @@ void GCOMObservation::read_attributes(const GFitsHDU* hdu)
841 841 if (hdu != NULL) {
842 842  
843 843 // Read observation information
844   - m_obs_id = (hdu->hascard("OBS_ID")) ? hdu->real("OBS_ID") : 0;
845   - m_name = (hdu->hascard("OBJECT")) ? hdu->string("OBJECT") : "unknown";
  844 + m_obs_id = (hdu->has_card("OBS_ID")) ? hdu->real("OBS_ID") : 0;
  845 + m_name = (hdu->has_card("OBJECT")) ? hdu->string("OBJECT") : "unknown";
846 846  
847 847 // Compute ontime
848 848 double tstart = hdu->real("TSTART");
... ...
inst/com/src/GCOMResponse.cpp
  View file @5d8d9ed
... ... @@ -320,7 +320,7 @@ double GCOMResponse::irf(const GEvent&amp; event,
320 320  
321 321 // Compile option: Check for NaN/Inf
322 322 #if defined(G_NAN_CHECK)
323   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  323 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
324 324 std::cout << "*** ERROR: GCOMResponse::irf:";
325 325 std::cout << " NaN/Inf encountered";
326 326 std::cout << " (irf=" << irf;
... ... @@ -354,7 +354,7 @@ double GCOMResponse::npred(const GPhoton&amp; photon,
354 354  
355 355 // Compile option: Check for NaN/Inf
356 356 #if defined(G_NAN_CHECK)
357   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  357 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
358 358 std::cout << "*** ERROR: GCOMResponse::npred:";
359 359 std::cout << " NaN/Inf encountered";
360 360 std::cout << " (";
... ...
inst/com/src/GCOMSupport.cpp
  View file @5d8d9ed
... ... @@ -59,7 +59,7 @@ void com_wcs_mer2car(GSkymap&amp; map)
59 59 // Apply kluge only if the skymap is in Mercator's projection
60 60 if (wcs != NULL && wcs->code() == "MER") {
61 61  
62   - // Extract original WCS definiton
  62 + // Extract original WCS definition
63 63 double crval1 = wcs->crval(0);
64 64 double crval2 = wcs->crval(1);
65 65 double crpix1 = wcs->crpix(0);
... ...
inst/cta/include/GCTAAeffArf.hpp
  View file @5d8d9ed
... ... @@ -45,7 +45,7 @@ class GCTAResponse;
45 45 * @brief CTA ARF effective area class
46 46 *
47 47 * This class implements the CTA effective area response that is defined by
48   - * an auxilliary response function (ARF) file.
  48 + * an auxiliary response function (ARF) file.
49 49 ***************************************************************************/
50 50 class GCTAAeffArf : public GCTAAeff {
51 51  
... ... @@ -159,7 +159,7 @@ const double&amp; GCTAAeffArf::sigma(void) const
159 159 *
160 160 * Sets the theta cut angle which defines the energy independent cut that
161 161 * has been assumed in deriving the ARF values. If @p thetacut os 0 (which
162   - * is the default avlue), not thetacut will be applied.
  162 + * is the default value), not thetacut will be applied.
163 163 ***************************************************************************/
164 164 inline
165 165 void GCTAAeffArf::thetacut(const double& thetacut)
... ...
inst/cta/include/GCTAEventBin.hpp
  View file @5d8d9ed
... ... @@ -38,7 +38,7 @@
38 38 /***********************************************************************//**
39 39 * @class GCTAEventBin
40 40 *
41   - * @brief GCTAEventBin class interface defintion
  41 + * @brief GCTAEventBin class interface definition
42 42 *
43 43 * This class implements a CTA event bin. The event bin is a collection of
44 44 * pointers that points to the relevant information in memory. The class
... ...
inst/cta/include/GCTAModelBackground.hpp
  View file @5d8d9ed
... ... @@ -67,7 +67,7 @@ public:
67 67 virtual void clear(void);
68 68 virtual GCTAModelBackground* clone(void) const;
69 69 virtual std::string type(void) const;
70   - virtual bool isconstant(void) const;
  70 + virtual bool is_constant(void) const;
71 71 virtual double eval(const GEvent& event,
72 72 const GObservation& obs) const;
73 73 virtual double eval_gradients(const GEvent& event,
... ... @@ -192,7 +192,7 @@ std::string GCTAModelBackground::type(void) const
192 192 * model is a model that has a temporal component of type "Constant".
193 193 ***************************************************************************/
194 194 inline
195   -bool GCTAModelBackground::isconstant(void) const
  195 +bool GCTAModelBackground::is_constant(void) const
196 196 {
197 197 return (m_temporal != NULL && m_temporal->type() == "Constant");
198 198 }
... ...
inst/cta/include/GCTAModelRadialAcceptance.hpp
  View file @5d8d9ed
... ... @@ -67,7 +67,7 @@ public:
67 67 virtual void clear(void);
68 68 virtual GCTAModelRadialAcceptance* clone(void) const;
69 69 virtual std::string type(void) const;
70   - virtual bool isconstant(void) const;
  70 + virtual bool is_constant(void) const;
71 71 virtual double eval(const GEvent& event,
72 72 const GObservation& obs) const;
73 73 virtual double eval_gradients(const GEvent& event,
... ... @@ -146,7 +146,7 @@ std::string GCTAModelRadialAcceptance::type(void) const
146 146 * is a model that has a temporal component of type "Constant".
147 147 ***************************************************************************/
148 148 inline
149   -bool GCTAModelRadialAcceptance::isconstant(void) const
  149 +bool GCTAModelRadialAcceptance::is_constant(void) const
150 150 {
151 151 return (m_temporal != NULL && m_temporal->type() == "Constant");
152 152 }
... ...
inst/cta/include/GCTAOnOffObservations.hpp
  View file @5d8d9ed
... ... @@ -63,7 +63,7 @@ public:
63 63 GCTAOnOffObservation* at(const int& index);
64 64 const GCTAOnOffObservation* at(const int& index) const;
65 65 int size(void) const;
66   - bool isempty(void) const;
  66 + bool is_empty(void) const;
67 67 GCTAOnOffObservation* set(const int& index, const GCTAOnOffObservation& obs);
68 68 GCTAOnOffObservation* append(const GCTAOnOffObservation& obs);
69 69 GCTAOnOffObservation* insert(const int& index, const GCTAOnOffObservation& obs);
... ... @@ -157,7 +157,7 @@ int GCTAOnOffObservations::size(void) const
157 157 * Signals if the observation container does not contain any observation.
158 158 ***************************************************************************/
159 159 inline
160   -bool GCTAOnOffObservations::isempty(void) const
  160 +bool GCTAOnOffObservations::is_empty(void) const
161 161 {
162 162 return (m_obs.empty());
163 163 }
... ...
inst/cta/include/GCTAResponse.hpp
  View file @5d8d9ed
... ... @@ -72,8 +72,8 @@ public:
72 72 // Implement pure virtual base class methods
73 73 virtual void clear(void);
74 74 virtual GCTAResponse* clone(void) const;
75   - virtual bool hasedisp(void) const;
76   - virtual bool hastdisp(void) const;
  75 + virtual bool has_edisp(void) const;
  76 + virtual bool has_tdisp(void) const;
77 77 virtual double irf(const GEvent& event,
78 78 const GPhoton& photon,
79 79 const GObservation& obs) const;
... ... @@ -190,7 +190,7 @@ private:
190 190 * @return False.
191 191 ***************************************************************************/
192 192 inline
193   -bool GCTAResponse::hasedisp(void) const
  193 +bool GCTAResponse::has_edisp(void) const
194 194 {
195 195 return false;
196 196 }
... ... @@ -202,7 +202,7 @@ bool GCTAResponse::hasedisp(void) const
202 202 * @return False.
203 203 ***************************************************************************/
204 204 inline
205   -bool GCTAResponse::hastdisp(void) const
  205 +bool GCTAResponse::has_tdisp(void) const
206 206 {
207 207 return false;
208 208 }
... ... @@ -246,9 +246,9 @@ const double&amp; GCTAResponse::eps(void) const
246 246  
247 247  
248 248 /***********************************************************************//**
249   - * @brief Return Redestribution Matrix File name
  249 + * @brief Return Redistribution Matrix File name
250 250 *
251   - * @return Redestribution Matrix File name.
  251 + * @return Redistribution Matrix File name.
252 252 ***************************************************************************/
253 253 inline
254 254 const std::string& GCTAResponse::rmffile(void) const
... ...
inst/cta/pyext/GCTAModelBackground.i
  View file @5d8d9ed
... ... @@ -49,7 +49,7 @@ class GCTAModelBackground : public GModelData {
49 49 virtual void clear(void);
50 50 virtual GCTAModelBackground* clone(void) const;
51 51 virtual std::string type(void) const;
52   - virtual bool isconstant(void) const;
  52 + virtual bool is_constant(void) const;
53 53 virtual double eval(const GEvent& event,
54 54 const GObservation& obs) const;
55 55 virtual double eval_gradients(const GEvent& event,
... ...
inst/cta/pyext/GCTAModelRadialAcceptance.i
  View file @5d8d9ed
... ... @@ -50,7 +50,7 @@ public:
50 50 virtual void clear(void);
51 51 virtual GCTAModelRadialAcceptance* clone(void) const;
52 52 virtual std::string type(void) const;
53   - virtual bool isconstant(void) const;
  53 + virtual bool is_constant(void) const;
54 54 virtual double eval(const GEvent& event,
55 55 const GObservation& obs) const;
56 56 virtual double eval_gradients(const GEvent& event,
... ...
inst/cta/pyext/GCTAOnOffObservations.i
  View file @5d8d9ed
... ... @@ -47,7 +47,7 @@ public:
47 47 GCTAOnOffObservations* clone(void) const;
48 48 GCTAOnOffObservation* at(const int& index);
49 49 int size(void) const;
50   - bool isempty(void) const;
  50 + bool is_empty(void) const;
51 51 GCTAOnOffObservation* set(const int& index, const GCTAOnOffObservation& obs);
52 52 GCTAOnOffObservation* append(const GCTAOnOffObservation& obs);
53 53 GCTAOnOffObservation* insert(const int& index, const GCTAOnOffObservation& obs);
... ...
inst/cta/pyext/GCTAResponse.i
  View file @5d8d9ed
... ... @@ -45,8 +45,8 @@ public:
45 45 // Implement pure virtual base class methods
46 46 virtual void clear(void);
47 47 virtual GCTAResponse* clone(void) const;
48   - virtual bool hasedisp(void) const;
49   - virtual bool hastdisp(void) const;
  48 + virtual bool has_edisp(void) const;
  49 + virtual bool has_tdisp(void) const;
50 50 virtual double irf(const GEvent& event,
51 51 const GPhoton& photon,
52 52 const GObservation& obs) const;
... ...
inst/cta/src/GCTAEventCube.cpp
  View file @5d8d9ed
... ... @@ -651,7 +651,7 @@ void GCTAEventCube::set_directions(void)
651 651 // Throw an error if we have no sky pixels
652 652 if (npix() < 1) {
653 653 throw GCTAException::no_sky(G_SET_DIRECTIONS, "Every CTA event cube"
654   - " needs a definiton of the sky pixels.");
  654 + " needs a definition of the sky pixels.");
655 655 }
656 656  
657 657 // Clear old pixel directions and solid angle
... ... @@ -697,7 +697,7 @@ void GCTAEventCube::set_energies(void)
697 697 // Throw an error if we have no energy bins
698 698 if (ebins() < 1) {
699 699 throw GCTAException::no_ebds(G_SET_ENERGIES, "Every CTA event cube"
700   - " needs a definiton of the energy boundaries.");
  700 + " needs a definition of the energy boundaries.");
701 701 }
702 702  
703 703 // Clear old bin energies and energy widths
... ...
inst/cta/src/GCTAEventList.cpp
  View file @5d8d9ed
... ... @@ -848,7 +848,7 @@ void GCTAEventList::read_ds_ebounds(const GFitsHDU&amp; hdu)
848 848  
849 849 // Get number of data selection keywords (default to 0 if keyword is
850 850 // not found)
851   - int ndskeys = (hdu.hascard("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
  851 + int ndskeys = (hdu.has_card("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
852 852  
853 853 // Loop over all data selection keys
854 854 for (int i = 1; i <= ndskeys; ++i) {
... ... @@ -859,7 +859,7 @@ void GCTAEventList::read_ds_ebounds(const GFitsHDU&amp; hdu)
859 859 std::string value_key = "DSVAL"+gammalib::str(i);
860 860  
861 861 // Continue only if type_key is found and if this key is ENERGY
862   - if (hdu.hascard(type_key) && hdu.string(type_key) == "ENERGY") {
  862 + if (hdu.has_card(type_key) && hdu.string(type_key) == "ENERGY") {
863 863  
864 864 // Extract energy boundaries
865 865 std::string value = hdu.string(value_key);
... ... @@ -912,7 +912,7 @@ void GCTAEventList::read_ds_roi(const GFitsHDU&amp; hdu)
912 912  
913 913 // Get number of data selection keywords (default to 0 if keyword is
914 914 // not found)
915   - int ndskeys = (hdu.hascard("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
  915 + int ndskeys = (hdu.has_card("NDSKEYS")) ? hdu.integer("NDSKEYS") : 0;
916 916  
917 917 // Loop over all data selection keys
918 918 for (int i = 1; i <= ndskeys; ++i) {
... ... @@ -923,7 +923,7 @@ void GCTAEventList::read_ds_roi(const GFitsHDU&amp; hdu)
923 923 std::string value_key = "DSVAL"+gammalib::str(i);
924 924  
925 925 // Continue only if type_key is found and if this key is POS(RA,DEC)
926   - if (hdu.hascard(type_key) && hdu.string(type_key) == "POS(RA,DEC)") {
  926 + if (hdu.has_card(type_key) && hdu.string(type_key) == "POS(RA,DEC)") {
927 927  
928 928 // ...
929 929 //std::string unit = gammalib::toupper(hdu.string(unit_key));
... ...
inst/cta/src/GCTAModelBackground.cpp
  View file @5d8d9ed
... ... @@ -570,7 +570,7 @@ double GCTAModelBackground::npred(const GEnergy&amp; obsEng,
570 570  
571 571 // Debug: Check for NaN
572 572 #if defined(G_NAN_CHECK)
573   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  573 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
574 574 std::cout << "*** ERROR: GCTAModelBackground::npred:";
575 575 std::cout << " NaN/Inf encountered";
576 576 std::cout << " (npred=" << npred;
... ... @@ -1196,7 +1196,7 @@ GModelTemporal* GCTAModelBackground::xml_temporal(const GXmlElement&amp; temporal) c
1196 1196 /***********************************************************************//**
1197 1197 * @brief Kernel for zenith angle Npred integration of background model
1198 1198 *
1199   - * @param[in] theta Offset angle from ROI center (radians).
  1199 + * @param[in] theta Offset angle from ROI centre (radians).
1200 1200 *
1201 1201 * Computes
1202 1202 *
... ... @@ -1255,7 +1255,7 @@ double GCTAModelBackground::npred_roi_kern_theta::eval(const double&amp; theta)
1255 1255  
1256 1256 // Debug: Check for NaN
1257 1257 #if defined(G_NAN_CHECK)
1258   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  1258 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
1259 1259 std::cout << "*** ERROR: GCTAModelBackground::npred_roi_kern_theta::eval";
1260 1260 std::cout << "(theta=" << theta << "):";
1261 1261 std::cout << " NaN/Inf encountered";
... ... @@ -1314,7 +1314,7 @@ double GCTAModelBackground::npred_roi_kern_phi::eval(const double&amp; phi)
1314 1314  
1315 1315 // Debug: Check for NaN
1316 1316 #if defined(G_NAN_CHECK)
1317   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  1317 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
1318 1318 std::cout << "*** ERROR: GCTAModelBackground::npred_roi_kern_phi::eval";
1319 1319 std::cout << "(phi=" << phi << "):";
1320 1320 std::cout << " NaN/Inf encountered";
... ...
inst/cta/src/GCTAModelRadialGauss.cpp
  View file @5d8d9ed
... ... @@ -237,7 +237,7 @@ double GCTAModelRadialGauss::eval(const double&amp; offset) const
237 237  
238 238 // Compile option: Check for NaN/Inf
239 239 #if defined(G_NAN_CHECK)
240   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  240 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
241 241 std::cout << "*** ERROR: GCTAModelRadialGauss::eval";
242 242 std::cout << "(offset=" << offset << "): NaN/Inf encountered";
243 243 std::cout << " (value=" << value;
... ... @@ -289,7 +289,7 @@ double GCTAModelRadialGauss::eval_gradients(const double&amp; offset) const
289 289  
290 290 // Compile option: Check for NaN/Inf
291 291 #if defined(G_NAN_CHECK)
292   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  292 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
293 293 std::cout << "*** ERROR: GCTAModelRadialGauss::eval";
294 294 std::cout << "(offset=" << offset << "): NaN/Inf encountered";
295 295 std::cout << " (value=" << value;
... ... @@ -442,7 +442,7 @@ void GCTAModelRadialGauss::read(const GXmlElement&amp; xml)
442 442 throw GException::model_invalid_parvalue(G_READ, xml,
443 443 "\"Sigma\" parameter is required to be positive.");
444 444 }
445   - if (!m_sigma.hasmin() || m_sigma.min() <= 0.0) {
  445 + if (!m_sigma.has_min() || m_sigma.min() <= 0.0) {
446 446 throw GException::model_invalid_parlimit(G_READ, xml,
447 447 "\"Sigma\" parameter requires positive minimum boundary.");
448 448 }
... ... @@ -580,7 +580,7 @@ void GCTAModelRadialGauss::init_members(void)
580 580 m_sigma.free();
581 581 m_sigma.scale(1.0);
582 582 m_sigma.gradient(0.0);
583   - m_sigma.hasgrad(true);
  583 + m_sigma.has_grad(true);
584 584  
585 585 // Set parameter pointer(s)
586 586 m_pars.clear();
... ...
inst/cta/src/GCTAModelRadialPolynom.cpp
  View file @5d8d9ed
... ... @@ -101,7 +101,7 @@ GCTAModelRadialPolynom::GCTAModelRadialPolynom(const std::vector&lt;double&gt;&amp; coeffs
101 101 par.free();
102 102 par.scale(1.0);
103 103 par.gradient(0.0);
104   - par.hasgrad(true);
  104 + par.has_grad(true);
105 105  
106 106 // Push coefficient on list
107 107 m_coeffs.push_back(par);
... ... @@ -272,7 +272,7 @@ double GCTAModelRadialPolynom::eval(const double&amp; offset) const
272 272  
273 273 // Compile option: Check for NaN/Inf
274 274 #if defined(G_NAN_CHECK)
275   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  275 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
276 276 std::cout << "*** ERROR: GCTAModelRadialPolynom::eval";
277 277 std::cout << "(offset=" << offset << "): NaN/Inf encountered";
278 278 std::cout << " (value=" << value;
... ... @@ -350,7 +350,7 @@ double GCTAModelRadialPolynom::eval_gradients(const double&amp; offset) const
350 350  
351 351 // Compile option: Check for NaN/Inf
352 352 #if defined(G_NAN_CHECK)
353   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  353 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
354 354 std::cout << "*** ERROR: GCTAModelRadialPolynom::eval_gradients";
355 355 std::cout << "(offset=" << offset << "): NaN/Inf encountered";
356 356 std::cout << " (value=" << value;
... ... @@ -811,7 +811,7 @@ void GCTAModelRadialPolynom::update_pars(void)
811 811 for (int i = 0; i < ncoeffs; ++i) {
812 812  
813 813 // Signal that we have gradients
814   - m_coeffs[i].hasgrad(true);
  814 + m_coeffs[i].has_grad(true);
815 815  
816 816 // Set pointer
817 817 m_pars.push_back(&(m_coeffs[i]));
... ...
inst/cta/src/GCTAModelRadialProfile.cpp
  View file @5d8d9ed
... ... @@ -245,7 +245,7 @@ double GCTAModelRadialProfile::eval(const double&amp; offset) const
245 245  
246 246 // Compile option: Check for NaN/Inf
247 247 #if defined(G_NAN_CHECK)
248   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  248 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
249 249 std::cout << "*** ERROR: GCTAModelRadialProfile::eval";
250 250 std::cout << "(offset=" << offset << "): NaN/Inf encountered";
251 251 std::cout << " (value=" << value;
... ... @@ -423,7 +423,7 @@ void GCTAModelRadialProfile::read(const GXmlElement&amp; xml)
423 423 throw GException::model_invalid_parvalue(G_READ, xml,
424 424 "\"Width\" parameter is required to be positive.");
425 425 }
426   - if (!m_width.hasmin() || m_width.min() <= 0.0) {
  426 + if (!m_width.has_min() || m_width.min() <= 0.0) {
427 427 throw GException::model_invalid_parlimit(G_READ, xml,
428 428 "\"Width\" parameter requires positive minimum boundary.");
429 429 }
... ... @@ -437,7 +437,7 @@ void GCTAModelRadialProfile::read(const GXmlElement&amp; xml)
437 437 throw GException::model_invalid_parvalue(G_READ, xml,
438 438 "\"Core\" parameter is required to be positive.");
439 439 }
440   - if (!m_core.hasmin() || m_core.min() <= 0.0) {
  440 + if (!m_core.has_min() || m_core.min() <= 0.0) {
441 441 throw GException::model_invalid_parlimit(G_READ, xml,
442 442 "\"Core\" parameter requires positive minimum boundary.");
443 443 }
... ... @@ -451,7 +451,7 @@ void GCTAModelRadialProfile::read(const GXmlElement&amp; xml)
451 451 throw GException::model_invalid_parvalue(G_READ, xml,
452 452 "\"Core\" parameter is required to be positive.");
453 453 }
454   - if (!m_tail.hasmin() || m_tail.min() <= 0.0) {
  454 + if (!m_tail.has_min() || m_tail.min() <= 0.0) {
455 455 throw GException::model_invalid_parlimit(G_READ, xml,
456 456 "\"Core\" parameter requires positive minimum boundary.");
457 457 }
... ... @@ -601,7 +601,7 @@ void GCTAModelRadialProfile::init_members(void)
601 601 m_width.min(0.1); // min: 0.1 deg
602 602 m_width.free();
603 603 m_width.gradient(0.0);
604   - m_width.hasgrad(false);
  604 + m_width.has_grad(false);
605 605  
606 606 // Initialise core parameter
607 607 m_core.clear();
... ... @@ -611,7 +611,7 @@ void GCTAModelRadialProfile::init_members(void)
611 611 m_core.min(1.0); // min: 1.0 (could even be larger)
612 612 m_core.free();
613 613 m_core.gradient(0.0);
614   - m_core.hasgrad(false);
  614 + m_core.has_grad(false);
615 615  
616 616 // Initialise tail parameter
617 617 m_tail.clear();
... ... @@ -621,7 +621,7 @@ void GCTAModelRadialProfile::init_members(void)
621 621 m_tail.min(1.0); // min: 1.0
622 622 m_tail.fix();
623 623 m_tail.gradient(0.0);
624   - m_tail.hasgrad(false);
  624 + m_tail.has_grad(false);
625 625  
626 626 // Set parameter pointer(s)
627 627 m_pars.clear();
... ...
inst/cta/src/GCTAObservation.cpp
  View file @5d8d9ed
... ... @@ -895,17 +895,17 @@ void GCTAObservation::read_attributes(const GFitsHDU&amp; hdu)
895 895 // Read mandatory attributes
896 896 double ra_pnt = hdu.real("RA_PNT");
897 897 double dec_pnt = hdu.real("DEC_PNT");
898   - m_ontime = (hdu.hascard("ONTIME")) ? hdu.real("ONTIME") : 0.0;
899   - m_livetime = (hdu.hascard("LIVETIME")) ? hdu.real("LIVETIME") : 0.0;
  898 + m_ontime = (hdu.has_card("ONTIME")) ? hdu.real("ONTIME") : 0.0;
  899 + m_livetime = (hdu.has_card("LIVETIME")) ? hdu.real("LIVETIME") : 0.0;
900 900  
901 901 // Read optional attributes
902   - m_name = (hdu.hascard("OBJECT")) ? hdu.string("OBJECT") : "unknown";
903   - m_deadc = (hdu.hascard("DEADC")) ? hdu.real("DEADC") : 0.0;
904   - m_ra_obj = (hdu.hascard("RA_OBJ")) ? hdu.real("RA_OBJ") : 0.0;
905   - m_dec_obj = (hdu.hascard("DEC_OBJ")) ? hdu.real("DEC_OBJ") : 0.0;
906   - m_obs_id = (hdu.hascard("OBS_ID")) ? hdu.integer("OBS_ID") : 0;
907   - //double alt = (hdu.hascard("ALT_PNT")) ? hdu.real("ALT_PNT") : 0.0;
908   - //double az = (hdu.hascard("AZ_PNT")) ? hdu.real("AZ_PNT") : 0.0;
  902 + m_name = (hdu.has_card("OBJECT")) ? hdu.string("OBJECT") : "unknown";
  903 + m_deadc = (hdu.has_card("DEADC")) ? hdu.real("DEADC") : 0.0;
  904 + m_ra_obj = (hdu.has_card("RA_OBJ")) ? hdu.real("RA_OBJ") : 0.0;
  905 + m_dec_obj = (hdu.has_card("DEC_OBJ")) ? hdu.real("DEC_OBJ") : 0.0;
  906 + m_obs_id = (hdu.has_card("OBS_ID")) ? hdu.integer("OBS_ID") : 0;
  907 + //double alt = (hdu.has_card("ALT_PNT")) ? hdu.real("ALT_PNT") : 0.0;
  908 + //double az = (hdu.has_card("AZ_PNT")) ? hdu.real("AZ_PNT") : 0.0;
909 909  
910 910 // Kluge: compute DEADC from livetime and ontime instead of using the
911 911 // keyword value as the original event lists had this values badly
... ...
inst/cta/src/GCTAOnOffObservations.cpp
  View file @5d8d9ed
... ... @@ -342,7 +342,7 @@ GCTAOnOffObservation* GCTAOnOffObservations::insert(const int&amp; index, const GCTA
342 342 {
343 343 // Compile option: raise exception if index is out of range
344 344 #if defined(G_RANGE_CHECK)
345   - if (isempty()) {
  345 + if (is_empty()) {
346 346 if (index > 0) {
347 347 throw GException::out_of_range(G_INSERT, index, 0, size()-1);
348 348 }
... ... @@ -421,7 +421,7 @@ void GCTAOnOffObservations::remove(const int&amp; index)
421 421 void GCTAOnOffObservations::extend(const GCTAOnOffObservations& obs)
422 422 {
423 423 // Do nothing if observation container is empty
424   - if (!obs.isempty()) {
  424 + if (!obs.is_empty()) {
425 425  
426 426 // Get size. Note that we extract the size first to avoid an
427 427 // endless loop that arises when a container is appended to
... ...
inst/cta/src/GCTAResponse.cpp
  View file @5d8d9ed
... ... @@ -327,7 +327,7 @@ double GCTAResponse::irf(const GEvent&amp; event,
327 327 irf *= psf(delta, theta, phi, zenith, azimuth, srcLogEng);
328 328  
329 329 // Multiply-in energy dispersion
330   - if (hasedisp() && irf > 0) {
  330 + if (has_edisp() && irf > 0) {
331 331  
332 332 // Get log10(E/TeV) of measured photon energy.
333 333 double obsLogEng = obsEng.log10TeV();
... ... @@ -346,7 +346,7 @@ double GCTAResponse::irf(const GEvent&amp; event,
346 346  
347 347 // Compile option: Check for NaN/Inf
348 348 #if defined(G_NAN_CHECK)
349   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  349 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
350 350 std::cout << "*** ERROR: GCTAResponse::irf:";
351 351 std::cout << " NaN/Inf encountered";
352 352 std::cout << " (irf=" << irf;
... ... @@ -404,7 +404,7 @@ double GCTAResponse::npred(const GPhoton&amp; photon,
404 404 npred *= npsf(srcDir, srcLogEng, srcTime, pnt, roi);
405 405  
406 406 // Multiply-in energy dispersion
407   - if (hasedisp() && npred > 0.0) {
  407 + if (has_edisp() && npred > 0.0) {
408 408  
409 409 // Get energy dispersion
410 410 npred *= nedisp(srcDir, srcEng, srcTime, pnt, cta.events()->ebounds());
... ... @@ -418,7 +418,7 @@ double GCTAResponse::npred(const GPhoton&amp; photon,
418 418  
419 419 // Compile option: Check for NaN/Inf
420 420 #if defined(G_NAN_CHECK)
421   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  421 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
422 422 std::cout << "*** ERROR: GCTAResponse::npred:";
423 423 std::cout << " NaN/Inf encountered";
424 424 std::cout << " (npred=" << npred;
... ... @@ -989,7 +989,7 @@ double GCTAResponse::irf_radial(const GEvent&amp; event,
989 989  
990 990 // Compile option: Check for NaN/Inf
991 991 #if defined(G_NAN_CHECK)
992   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  992 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
993 993 std::cout << "*** ERROR: GCTAResponse::irf_radial:";
994 994 std::cout << " NaN/Inf encountered";
995 995 std::cout << " (irf=" << irf;
... ... @@ -1157,7 +1157,7 @@ double GCTAResponse::irf_elliptical(const GEvent&amp; event,
1157 1157  
1158 1158 // Compile option: Check for NaN/Inf
1159 1159 #if defined(G_NAN_CHECK)
1160   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  1160 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
1161 1161 std::cout << "*** ERROR: GCTAResponse::irf_elliptical:";
1162 1162 std::cout << " NaN/Inf encountered";
1163 1163 std::cout << " (irf=" << irf;
... ... @@ -1328,7 +1328,7 @@ double GCTAResponse::irf_diffuse(const GEvent&amp; event,
1328 1328  
1329 1329 // Compile option: Check for NaN/Inf
1330 1330 #if defined(G_NAN_CHECK)
1331   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  1331 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
1332 1332 std::cout << "*** ERROR: GCTAResponse::irf_diffuse:";
1333 1333 std::cout << " NaN/Inf encountered";
1334 1334 std::cout << " (irf=" << irf;
... ... @@ -1512,7 +1512,7 @@ double GCTAResponse::npred_radial(const GSource&amp; source,
1512 1512  
1513 1513 // Debug: Check for NaN
1514 1514 #if defined(G_NAN_CHECK)
1515   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  1515 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
1516 1516 std::cout << "*** ERROR: GCTAResponse::npred_radial:";
1517 1517 std::cout << " NaN/Inf encountered";
1518 1518 std::cout << " (npred=" << npred;
... ... @@ -1675,7 +1675,7 @@ double GCTAResponse::npred_elliptical(const GSource&amp; source,
1675 1675  
1676 1676 // Debug: Check for NaN
1677 1677 #if defined(G_NAN_CHECK)
1678   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  1678 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
1679 1679 std::cout << "*** ERROR: GCTAResponse::npred_elliptical:";
1680 1680 std::cout << " NaN/Inf encountered";
1681 1681 std::cout << " (npred=" << npred;
... ... @@ -1853,7 +1853,7 @@ double GCTAResponse::npred_diffuse(const GSource&amp; source,
1853 1853  
1854 1854 // Debug: Check for NaN
1855 1855 #if defined(G_NAN_CHECK)
1856   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  1856 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
1857 1857 std::cout << "*** ERROR: GCTAResponse::npred_diffuse:";
1858 1858 std::cout << " NaN/Inf encountered";
1859 1859 std::cout << " (npred=" << npred;
... ... @@ -2093,7 +2093,7 @@ double GCTAResponse::npsf(const GSkyDir&amp; srcDir,
2093 2093  
2094 2094 // Compile option: Check for NaN/Inf
2095 2095 #if defined(G_NAN_CHECK)
2096   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  2096 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
2097 2097 std::cout << "*** ERROR: GCTAResponse::npsf:";
2098 2098 std::cout << " NaN/Inf encountered";
2099 2099 std::cout << " (value=" << value;
... ...
inst/cta/src/GCTAResponse_helpers.cpp
  View file @5d8d9ed
... ... @@ -94,7 +94,7 @@ double cta_npsf_kern_rad_azsym::eval(const double&amp; delta)
94 94  
95 95 // Compile option: Check for NaN/Inf
96 96 #if defined(G_NAN_CHECK)
97   - if (gammalib::isnotanumber(value) || gammalib::isinfinite(value)) {
  97 + if (gammalib::is_notanumber(value) || gammalib::is_infinite(value)) {
98 98 std::cout << "*** ERROR: cta_npsf_kern_rad_azsym::eval";
99 99 std::cout << " NaN/Inf encountered";
100 100 std::cout << " (value=" << value;
... ... @@ -186,7 +186,7 @@ double cta_irf_radial_kern_rho::eval(const double&amp; rho)
186 186  
187 187 // Compile option: Check for NaN/Inf
188 188 #if defined(G_NAN_CHECK)
189   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  189 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
190 190 std::cout << "*** ERROR: cta_irf_radial_kern_rho";
191 191 std::cout << "(rho=" << rho << "):";
192 192 std::cout << " NaN/Inf encountered";
... ... @@ -259,13 +259,13 @@ double cta_irf_radial_kern_omega::eval(const double&amp; omega)
259 259 m_rsp.psf(delta, offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
260 260  
261 261 // Optionally take energy dispersion into account
262   - if (m_rsp.hasedisp() && irf > 0.0) {
  262 + if (m_rsp.has_edisp() && irf > 0.0) {
263 263 irf *= m_rsp.edisp(m_obsLogEng, offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
264 264 }
265 265  
266 266 // Compile option: Check for NaN/Inf
267 267 #if defined(G_NAN_CHECK)
268   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  268 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
269 269 std::cout << "*** ERROR: cta_irf_radial_kern_omega::eval";
270 270 std::cout << "(omega=" << omega << "):";
271 271 std::cout << " NaN/Inf encountered";
... ... @@ -343,7 +343,7 @@ double cta_npred_radial_kern_rho::eval(const double&amp; rho)
343 343  
344 344 // Debug: Check for NaN
345 345 #if defined(G_NAN_CHECK)
346   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  346 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
347 347 std::cout << "*** ERROR: cta_npred_radial_kern_rho::eval";
348 348 std::cout << "(rho=" << rho << "):";
349 349 std::cout << " NaN/Inf encountered";
... ... @@ -393,7 +393,7 @@ double cta_npred_radial_kern_omega::eval(const double&amp; omega)
393 393  
394 394 // Debug: Check for NaN
395 395 #if defined(G_NAN_CHECK)
396   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  396 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
397 397 std::cout << "*** ERROR: cta_npred_radial_kern_omega::eval";
398 398 std::cout << "(omega=" << omega << "):";
399 399 std::cout << " NaN/Inf encountered";
... ... @@ -482,7 +482,7 @@ double cta_irf_elliptical_kern_rho::eval(const double&amp; rho)
482 482  
483 483 // Compile option: Check for NaN/Inf
484 484 #if defined(G_NAN_CHECK)
485   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  485 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
486 486 std::cout << "*** ERROR: cta_irf_elliptical_kern_rho";
487 487 std::cout << "(rho=" << rho << "):";
488 488 std::cout << " NaN/Inf encountered";
... ... @@ -561,14 +561,14 @@ double cta_irf_elliptical_kern_omega::eval(const double&amp; omega)
561 561 model;
562 562  
563 563 // Optionally take energy dispersion into account
564   - if (m_rsp.hasedisp() && irf > 0.0) {
  564 + if (m_rsp.has_edisp() && irf > 0.0) {
565 565 irf *= m_rsp.edisp(m_obsLogEng, theta, phi,
566 566 m_zenith, m_azimuth, m_srcLogEng);
567 567 }
568 568  
569 569 // Compile option: Check for NaN/Inf
570 570 #if defined(G_NAN_CHECK)
571   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  571 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
572 572 std::cout << "*** ERROR: cta_irf_elliptical_kern_omega::eval";
573 573 std::cout << "(omega=" << omega << "):";
574 574 std::cout << " NaN/Inf encountered";
... ... @@ -647,7 +647,7 @@ double cta_npred_elliptical_kern_rho::eval(const double&amp; rho)
647 647  
648 648 // Debug: Check for NaN
649 649 #if defined(G_NAN_CHECK)
650   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  650 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
651 651 std::cout << "*** ERROR: cta_npred_elliptical_kern_rho::eval";
652 652 std::cout << "(rho=" << rho << "):";
653 653 std::cout << " NaN/Inf encountered";
... ... @@ -708,7 +708,7 @@ double cta_npred_elliptical_kern_omega::eval(const double&amp; omega)
708 708  
709 709 // Debug: Check for NaN
710 710 #if defined(G_NAN_CHECK)
711   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  711 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
712 712 std::cout << "*** ERROR: cta_npred_elliptical_kern_omega::eval";
713 713 std::cout << "(omega=" << omega << "):";
714 714 std::cout << " NaN/Inf encountered";
... ... @@ -802,7 +802,7 @@ double cta_irf_diffuse_kern_theta::eval(const double&amp; theta)
802 802  
803 803 // Compile option: Check for NaN/Inf
804 804 #if defined(G_NAN_CHECK)
805   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  805 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
806 806 std::cout << "*** ERROR: cta_irf_diffuse_kern_theta";
807 807 std::cout << "(theta=" << theta << "):";
808 808 std::cout << " NaN/Inf encountered";
... ... @@ -890,14 +890,14 @@ double cta_irf_diffuse_kern_phi::eval(const double&amp; phi)
890 890 m_rsp.aeff(offset, azimuth, m_zenith, m_azimuth, m_srcLogEng);
891 891  
892 892 // Optionally take energy dispersion into account
893   - if (m_rsp.hasedisp() && irf > 0.0) {
  893 + if (m_rsp.has_edisp() && irf > 0.0) {
894 894 irf *= m_rsp.edisp(m_obsLogEng, offset, azimuth,
895 895 m_zenith, m_azimuth, m_srcLogEng);
896 896 }
897 897  
898 898 // Compile option: Check for NaN/Inf
899 899 #if defined(G_NAN_CHECK)
900   - if (gammalib::isnotanumber(irf) || gammalib::isinfinite(irf)) {
  900 + if (gammalib::is_notanumber(irf) || gammalib::is_infinite(irf)) {
901 901 std::cout << "*** ERROR: cta_irf_diffuse_kern_phi::eval";
902 902 std::cout << "(phi=" << phi << "):";
903 903 std::cout << " NaN/Inf encountered";
... ... @@ -971,7 +971,7 @@ double cta_npred_diffuse_kern_theta::eval(const double&amp; theta)
971 971  
972 972 // Debug: Check for NaN
973 973 #if defined(G_NAN_CHECK)
974   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  974 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
975 975 std::cout << "*** ERROR: cta_npred_radial_kern_theta::eval";
976 976 std::cout << "(theta=" << theta << "):";
977 977 std::cout << " NaN/Inf encountered";
... ... @@ -1034,7 +1034,7 @@ double cta_npred_diffuse_kern_phi::eval(const double&amp; phi)
1034 1034  
1035 1035 // Debug: Check for NaN
1036 1036 #if defined(G_NAN_CHECK)
1037   - if (gammalib::isnotanumber(npred) || gammalib::isinfinite(npred)) {
  1037 + if (gammalib::is_notanumber(npred) || gammalib::is_infinite(npred)) {
1038 1038 std::cout << "*** ERROR: cta_npred_diffuse_kern_phi::eval";
1039 1039 std::cout << "(phi=" << phi << "):";
1040 1040 std::cout << " NaN/Inf encountered";
... ...
inst/cta/src/GCTASupport.cpp
  View file @5d8d9ed
... ... @@ -96,8 +96,8 @@ double gammalib::cta_roi_arclength(const double&amp; rad, const double&amp; dist,
96 96 double cosang = (cosroi - cosdist*cosrad) / (sindist*sinrad);
97 97 arclength = 2.0 * gammalib::acos(cosang);
98 98 #if G_CHECK_FOR_NAN
99   - if (gammalib::isinfinite(arclength) ||
100   - gammalib::isnotanumber(arclength)) {
  99 + if (gammalib::is_infinite(arclength) ||
  100 + gammalib::is_notanumber(arclength)) {
101 101 std::cout << "cta_roi_arclength: NaN occured";
102 102 std::cout << " rad=" << rad;
103 103 std::cout << " sinrad=" << sinrad;
... ...
inst/cta/test/test_CTA.cpp
  View file @5d8d9ed
... ... @@ -362,7 +362,7 @@ void TestGCTAResponse::test_response_irf_diffuse(void)
362 362 GEnergy emax(100.0, "TeV");
363 363 GEbounds ebounds(nebins, emin, emax);
364 364  
365   - // Setup event cube centered on Cen A
  365 + // Setup event cube centreed on Cen A
366 366 GCTAEventCube cube(map, ebounds, gti);
367 367  
368 368 // Setup dummy CTA observation
... ... @@ -515,7 +515,7 @@ void TestGCTAModelBackground::test_modelbg_npred(void)
515 515 const GModelSpectralPlaw* spec = dynamic_cast<const GModelSpectralPlaw*>(bck->spectral());
516 516 const GModelSpatialRadialGauss* spat = dynamic_cast<const GModelSpatialRadialGauss*>(bck->spatial());
517 517  
518   - // Get Integration center for ROI position
  518 + // Get Integration centre for ROI position
519 519 double src_ra = spat->ra();
520 520 double src_dec = spat->dec();
521 521 double sigma = spat->sigma();
... ...
inst/cta/test/test_irf_offset.py
  View file @5d8d9ed
... ... @@ -57,11 +57,11 @@ def shell_model(ra=0.3, dec=0.3, radius=0.3, width=0.1):
57 57 Set shell model.
58 58 """
59 59 # Set shell centre
60   - center = GSkyDir()
61   - center.radec_deg(ra, dec)
  60 + centre = GSkyDir()
  61 + centre.radec_deg(ra, dec)
62 62  
63 63 # Set radial model
64   - radial = GModelRadialShell(center, radius, width, False)
  64 + radial = GModelRadialShell(centre, radius, width, False)
65 65  
66 66 # Set spectral model
67 67 spectral = GModelSpectralPlaw(1.0, -2.0)
... ... @@ -81,11 +81,11 @@ def disk_model(ra=359.6, dec=-0.2, radius=0.4):
81 81 Set disk model.
82 82 """
83 83 # Set disk centre
84   - center = GSkyDir()
85   - center.radec_deg(ra, dec)
  84 + centre = GSkyDir()
  85 + centre.radec_deg(ra, dec)
86 86  
87 87 # Set radial model
88   - radial = GModelRadialDisk(center, radius)
  88 + radial = GModelRadialDisk(centre, radius)
89 89  
90 90 # Set spectral model
91 91 spectral = GModelSpectralPlaw(1.0, -2.0)
... ... @@ -105,11 +105,11 @@ def gauss_model(ra=359.6, dec=+0.1, sigma=0.2):
105 105 Set Gaussian model.
106 106 """
107 107 # Set Gaussian centre
108   - center = GSkyDir()
109   - center.radec_deg(ra, dec)
  108 + centre = GSkyDir()
  109 + centre.radec_deg(ra, dec)
110 110  
111 111 # Set radial model
112   - radial = GModelRadialGauss(center, sigma)
  112 + radial = GModelRadialGauss(centre, sigma)
113 113  
114 114 # Set spectral model
115 115 spectral = GModelSpectralPlaw(1.0, -2.0)
... ... @@ -147,7 +147,7 @@ def observation(ra=0.0, dec=0.0, binsz=0.05, npix=200, ebins=10):
147 147 emax = GEnergy()
148 148 emin.TeV(0.1)
149 149 emax.TeV(100.0)
150   - ebounds.setlog(emin, emax, ebins)
  150 + ebounds.set_log(emin, emax, ebins)
151 151 gti = GGti()
152 152 tmin = GTime(0.0)
153 153 tmax = GTime(1800.0)
... ...
inst/cta/test/test_model.py
  View file @5d8d9ed
... ... @@ -53,11 +53,11 @@ def shell_model(ra=0.3, dec=0.3, radius=0.3, width=0.1):
53 53 Set shell model.
54 54 """
55 55 # Set shell centre
56   - center = GSkyDir()
57   - center.radec_deg(ra, dec)
  56 + centre = GSkyDir()
  57 + centre.radec_deg(ra, dec)
58 58  
59 59 # Set radial model
60   - radial = GModelSpatialRadialShell(center, radius, width, False)
  60 + radial = GModelSpatialRadialShell(centre, radius, width, False)
61 61  
62 62 # Set spectral model
63 63 spectral = GModelSpectralPlaw(1.0, -2.0, GEnergy(100.0, "MeV"))
... ... @@ -77,11 +77,11 @@ def disk_model(ra=359.6, dec=-0.2, radius=0.4):
77 77 Set disk model.
78 78 """
79 79 # Set disk centre
80   - center = GSkyDir()
81   - center.radec_deg(ra, dec)
  80 + centre = GSkyDir()
  81 + centre.radec_deg(ra, dec)
82 82  
83 83 # Set radial model
84   - radial = GModelSpatialRadialDisk(center, radius)
  84 + radial = GModelSpatialRadialDisk(centre, radius)
85 85  
86 86 # Set spectral model
87 87 spectral = GModelSpectralPlaw(1.0, -2.0, GEnergy(100.0, "MeV"))
... ... @@ -101,11 +101,11 @@ def gauss_model(ra=359.6, dec=+0.1, sigma=0.2):
101 101 Set Gaussian model.
102 102 """
103 103 # Set Gaussian centre
104   - center = GSkyDir()
105   - center.radec_deg(ra, dec)
  104 + centre = GSkyDir()
  105 + centre.radec_deg(ra, dec)
106 106  
107 107 # Set radial model
108   - radial = GModelSpatialRadialGauss(center, sigma)
  108 + radial = GModelSpatialRadialGauss(centre, sigma)
109 109  
110 110 # Set spectral model
111 111 spectral = GModelSpectralPlaw(1.0, -2.0, GEnergy(100.0, "MeV"))
... ...