Domenico Tiziani / gammalib

Commit 7364643153c27855e4b1195fc3fc196fe481ea0d

Authored by Jürgen Knödlseder
1 parent 26cc8e40

Make Python objects pickle-able (#1938)

Inline Side-by-side
Showing 94 changed files with 1787 additions and 429 deletions
1 1 New Features and Important Changes in GammaLib 1.6.0
2 2  
3   -21 June 2018
  3 +22 June 2018
4 4  
5 5  
6 6 1. Introduction
... ... @@ -49,9 +49,20 @@ The following methods have been added:
49 49 - GPha::ancrfile()
50 50 - GFitsHeaderCard boolean constructor
51 51 - GFitsHDU::card(std::string&, bool&, std::string&)
  52 +- GObservation::has_events()
  53 +- GModelSpatialPointSource::type(std::string&)
  54 +- GModelSpectralPlaw::type(std::string&)
  55 +- GModelSpatialRadialProfileGauss(GSkyDir&, double&)
  56 +- GModelSpatialRadialProfileGauss::sigma()
  57 +- GXml::GXml(GXmlDocument&)
  58 +- GXml::root()
  59 +- GXmlElement::attributes()
  60 +- GXmlElement::attribute(int&)
  61 +- GXmlDocument::GXmlDocument(GFilename&, std::string&, std::string&, std::string&)
52 62 - GCTAInstDir::theta()
53 63 - GCTAInstDir::phi()
54 64 - GCTAEventAtom(GCTAInstDir&, GEnergy&, GTime&)
  65 +- GCTAEventAtom::index(int&)
55 66 - GCTABackground::rate_ebin()
56 67 - GCTABackgroundPerfTable::rate_ebin()
57 68 - GCTABackground3D::rate_ebin()
... ... @@ -62,8 +73,8 @@ The following methods have been added:
62 73 - GCTAModelRadialAcceptance::radial(GCTAModelRadial*)
63 74 - GCTAModelRadialAcceptance::spectral(GModelSpectral*)
64 75 - GCTAModelRadialAcceptance::temporal(GModelTemporal*)
65   -- GModelSpatialRadialProfileGauss(GSkyDir&, double&)
66   -- GModelSpatialRadialProfileGauss::sigma()
  76 +- GCTAModelIrfBackground::spectral(GModelSpectral*)
  77 +- GCTAModelIrfBackground::temporal(GModelTemporal*)
67 78  
68 79 The following methods have been removed:
69 80 - none
... ...
include/GModelSpatialComposite.hpp
  View file @7364643
... ... @@ -78,6 +78,7 @@ public:
78 78 virtual std::string print(const GChatter& chatter = NORMAL) const;
79 79  
80 80 // Other methods
  81 + void type(const std::string& type);
81 82 int components(void) const;
82 83 void append(const GModelSpatial& component,
83 84 const std::string& name = "",
... ... @@ -131,6 +132,21 @@ std::string GModelSpatialComposite::type(void) const
131 132  
132 133  
133 134 /***********************************************************************//**
  135 + * @brief Set model type
  136 + *
  137 + * @param[in] type Model type.
  138 + *
  139 + * Set the type of the spatial model.
  140 + ***************************************************************************/
  141 +inline
  142 +void GModelSpatialComposite::type(const std::string& type)
  143 +{
  144 + m_type = type;
  145 + return;
  146 +}
  147 +
  148 +
  149 +/***********************************************************************//**
134 150 * @brief Return class code
135 151 *
136 152 * @return GModelSpatialComposite.
... ...
include/GModelSpatialPointSource.hpp
  View file @7364643
... ... @@ -81,6 +81,7 @@ public:
81 81 virtual std::string print(const GChatter& chatter = NORMAL) const;
82 82  
83 83 // Other methods
  84 + void type(const std::string& type);
84 85 double ra(void) const;
85 86 double dec(void) const;
86 87 void ra(const double& ra);
... ... @@ -120,7 +121,7 @@ std::string GModelSpatialPointSource::classname(void) const
120 121 *
121 122 * @return Model type.
122 123 *
123   - * Returns the type of the spatial model.
  124 + * Returns the type of the spatial point source model.
124 125 ***************************************************************************/
125 126 inline
126 127 std::string GModelSpatialPointSource::type(void) const
... ... @@ -130,6 +131,21 @@ std::string GModelSpatialPointSource::type(void) const
130 131  
131 132  
132 133 /***********************************************************************//**
  134 + * @brief Set model type
  135 + *
  136 + * @param[in] type Model type.
  137 + *
  138 + * Set the type of the spatial point source model.
  139 + ***************************************************************************/
  140 +inline
  141 +void GModelSpatialPointSource::type(const std::string& type)
  142 +{
  143 + m_type = type;
  144 + return;
  145 +}
  146 +
  147 +
  148 +/***********************************************************************//**
133 149 * @brief Return class code
134 150 *
135 151 * @return GModelSpatialPointSource.
... ...
include/GModelSpectralBrokenPlaw.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralBrokenPlaw.hpp - Broken power law spectrum class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2013-2017 by Anneli Schulz *
  4 + * copyright (C) 2013-2018 by Anneli Schulz *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -104,6 +104,7 @@ public:
104 104 virtual std::string print(const GChatter& chatter = NORMAL) const;
105 105  
106 106 // Other methods
  107 + void type(const std::string& type);
107 108 double prefactor(void) const;
108 109 double index1(void) const;
109 110 double index2(void) const;
... ... @@ -176,6 +177,21 @@ std::string GModelSpectralBrokenPlaw::type(void) const
176 177  
177 178  
178 179 /***********************************************************************//**
  180 + * @brief Set model type
  181 + *
  182 + * @param[in] type Model type.
  183 + *
  184 + * Set the type of the spectral broken power law model.
  185 + ***************************************************************************/
  186 +inline
  187 +void GModelSpectralBrokenPlaw::type(const std::string& type)
  188 +{
  189 + m_type = type;
  190 + return;
  191 +}
  192 +
  193 +
  194 +/***********************************************************************//**
179 195 * @brief Return pre factor
180 196 *
181 197 * @return Pre factor (ph/cm2/s/MeV).
... ...
include/GModelSpectralConst.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralConst.hpp - Spectral constant model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2009-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2009-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -89,6 +89,7 @@ public:
89 89 virtual std::string print(const GChatter& chatter = NORMAL) const;
90 90  
91 91 // Other methods
  92 + void type(const std::string& type);
92 93 double value(void) const;
93 94 void value(const double& value);
94 95  
... ... @@ -131,6 +132,21 @@ std::string GModelSpectralConst::type(void) const
131 132  
132 133  
133 134 /***********************************************************************//**
  135 + * @brief Set model type
  136 + *
  137 + * @param[in] type Model type.
  138 + *
  139 + * Set the type of the constant spectral model.
  140 + ***************************************************************************/
  141 +inline
  142 +void GModelSpectralConst::type(const std::string& type)
  143 +{
  144 + m_type = type;
  145 + return;
  146 +}
  147 +
  148 +
  149 +/***********************************************************************//**
134 150 * @brief Return model value
135 151 *
136 152 * @return Model value (ph/cm2/s/MeV).
... ...
include/GModelSpectralExpInvPlaw.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralExpInvPlaw.hpp - Exponential cut off power law model *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2016 by Alexander Ziegler *
  4 + * copyright (C) 2016-2018 by Alexander Ziegler *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -106,6 +106,7 @@ public:
106 106 virtual std::string print(const GChatter& chatter = NORMAL) const;
107 107  
108 108 // Other methods
  109 + void type(const std::string& type);
109 110 double prefactor(void) const;
110 111 void prefactor(const double& prefactor);
111 112 double index(void) const;
... ... @@ -213,6 +214,21 @@ std::string GModelSpectralExpInvPlaw::type(void) const
213 214  
214 215  
215 216 /***********************************************************************//**
  217 + * @brief Set model type
  218 + *
  219 + * @param[in] type Model type.
  220 + *
  221 + * Set the type of the exponentially cut off power law model.
  222 + ***************************************************************************/
  223 +inline
  224 +void GModelSpectralExpInvPlaw::type(const std::string& type)
  225 +{
  226 + m_type = type;
  227 + return;
  228 +}
  229 +
  230 +
  231 +/***********************************************************************//**
216 232 * @brief Return pre factor
217 233 *
218 234 * @return Pre factor (ph/cm2/s/MeV).
... ...
include/GModelSpectralExpPlaw.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralExpPlaw.hpp - Exponential cut off power law model *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -102,6 +102,7 @@ public:
102 102 virtual std::string print(const GChatter& chatter = NORMAL) const;
103 103  
104 104 // Other methods
  105 + void type(const std::string& type);
105 106 double prefactor(void) const;
106 107 void prefactor(const double& prefactor);
107 108 double index(void) const;
... ... @@ -207,6 +208,21 @@ std::string GModelSpectralExpPlaw::type(void) const
207 208  
208 209  
209 210 /***********************************************************************//**
  211 + * @brief Set model type
  212 + *
  213 + * @param[in] type Model type.
  214 + *
  215 + * Set the type of the exponentially cut off power law model.
  216 + ***************************************************************************/
  217 +inline
  218 +void GModelSpectralExpPlaw::type(const std::string& type)
  219 +{
  220 + m_type = type;
  221 + return;
  222 +}
  223 +
  224 +
  225 +/***********************************************************************//**
210 226 * @brief Return pre factor
211 227 *
212 228 * @return Pre factor (ph/cm2/s/MeV).
... ...
include/GModelSpectralLogParabola.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralLogParabola.hpp - Log parabola spectral model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2012-2016 by Michael Mayer *
  4 + * copyright (C) 2012-2018 by Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -103,6 +103,7 @@ public:
103 103 virtual std::string print(const GChatter& chatter = NORMAL) const;
104 104  
105 105 // Other methods
  106 + void type(const std::string& type);
106 107 double prefactor(void) const;
107 108 void prefactor(const double& prefactor);
108 109 double index(void) const;
... ... @@ -207,7 +208,7 @@ std::string GModelSpectralLogParabola::classname(void) const
207 208 /***********************************************************************//**
208 209 * @brief Return model type
209 210 *
210   - * @return "LogParabola".
  211 + * @return Model type.
211 212 *
212 213 * Returns the type of the log parabola spectral model.
213 214 ***************************************************************************/
... ... @@ -219,6 +220,21 @@ std::string GModelSpectralLogParabola::type(void) const
219 220  
220 221  
221 222 /***********************************************************************//**
  223 + * @brief Set model type
  224 + *
  225 + * @param[in] type Model type.
  226 + *
  227 + * Set the type of the log parabola spectral model.
  228 + ***************************************************************************/
  229 +inline
  230 +void GModelSpectralLogParabola::type(const std::string& type)
  231 +{
  232 + m_type = type;
  233 + return;
  234 +}
  235 +
  236 +
  237 +/***********************************************************************//**
222 238 * @brief Return pre factor
223 239 *
224 240 * @return Pre factor (ph/cm2/s/MeV).
... ...
include/GModelSpectralPlaw.hpp
  View file @7364643
... ... @@ -96,6 +96,7 @@ public:
96 96 virtual std::string print(const GChatter& chatter = NORMAL) const;
97 97  
98 98 // Other methods
  99 + void type(const std::string& type);
99 100 double prefactor(void) const;
100 101 double index(void) const;
101 102 GEnergy pivot(void) const;
... ... @@ -160,6 +161,21 @@ std::string GModelSpectralPlaw::type(void) const
160 161  
161 162  
162 163 /***********************************************************************//**
  164 + * @brief Set model type
  165 + *
  166 + * @param[in] type Model type.
  167 + *
  168 + * Set the type of the spectral power law model.
  169 + ***************************************************************************/
  170 +inline
  171 +void GModelSpectralPlaw::type(const std::string& type)
  172 +{
  173 + m_type = type;
  174 + return;
  175 +}
  176 +
  177 +
  178 +/***********************************************************************//**
163 179 * @brief Return pre factor
164 180 *
165 181 * @return Pre factor (ph/cm2/s/MeV).
... ...
include/GModelSpectralPlawEnergyFlux.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralPlawEnergyFlux.hpp - Spectral power law model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2016 by Michael Mayer *
  4 + * copyright (C) 2016-2018 by Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -112,6 +112,7 @@ public:
112 112 virtual std::string print(const GChatter& chatter = NORMAL) const;
113 113  
114 114 // Other methods
  115 + void type(const std::string& type);
115 116 double eflux(void) const;
116 117 void eflux(const double& eflux);
117 118 double index(void) const;
... ... @@ -177,6 +178,21 @@ std::string GModelSpectralPlawEnergyFlux::type(void) const
177 178  
178 179  
179 180 /***********************************************************************//**
  181 + * @brief Set model type
  182 + *
  183 + * @param[in] type Model type.
  184 + *
  185 + * Set the type of the spectral power law model.
  186 + ***************************************************************************/
  187 +inline
  188 +void GModelSpectralPlawEnergyFlux::type(const std::string& type)
  189 +{
  190 + m_type = type;
  191 + return;
  192 +}
  193 +
  194 +
  195 +/***********************************************************************//**
180 196 * @brief Return energy flux
181 197 *
182 198 * @return Energy flux (erg/cm2/s).
... ...
include/GModelSpectralPlawPhotonFlux.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralPlawPhotonFlux.hpp - Spectral power law model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2011-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2011-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -112,6 +112,7 @@ public:
112 112 virtual std::string print(const GChatter& chatter = NORMAL) const;
113 113  
114 114 // Other methods
  115 + void type(const std::string& type);
115 116 double flux(void) const;
116 117 void flux(const double& flux);
117 118 double index(void) const;
... ... @@ -177,6 +178,21 @@ std::string GModelSpectralPlawPhotonFlux::type(void) const
177 178  
178 179  
179 180 /***********************************************************************//**
  181 + * @brief Set model type
  182 + *
  183 + * @param[in] type Model type.
  184 + *
  185 + * Set the type of the spectral power law model.
  186 + ***************************************************************************/
  187 +inline
  188 +void GModelSpectralPlawPhotonFlux::type(const std::string& type)
  189 +{
  190 + m_type = type;
  191 + return;
  192 +}
  193 +
  194 +
  195 +/***********************************************************************//**
180 196 * @brief Return photon flux
181 197 *
182 198 * @return Photon flux (ph/cm2/s).
... ...
include/GModelSpectralSmoothBrokenPlaw.hpp
  View file @7364643
... ... @@ -2,7 +2,7 @@
2 2 * GModelSpectralSmoothBrokenPlaw.hpp *
3 3 * Smoothly broken power law spectrum class *
4 4 * ----------------------------------------------------------------------- *
5   - * copyright (C) 2017 by Josh Cardenzana *
  5 + * copyright (C) 2017-2018 by Josh Cardenzana *
6 6 * ----------------------------------------------------------------------- *
7 7 * *
8 8 * This program is free software: you can redistribute it and/or modify *
... ... @@ -118,6 +118,7 @@ public:
118 118 virtual std::string print(const GChatter& chatter = NORMAL) const;
119 119  
120 120 // Other methods
  121 + void type(const std::string& type);
121 122 double prefactor(void) const;
122 123 double index1(void) const;
123 124 double index2(void) const;
... ... @@ -253,6 +254,21 @@ std::string GModelSpectralSmoothBrokenPlaw::type(void) const
253 254  
254 255  
255 256 /***********************************************************************//**
  257 + * @brief Set model type
  258 + *
  259 + * @param[in] type Model type.
  260 + *
  261 + * Set the type of the spectral smoothly broken power law model.
  262 + ***************************************************************************/
  263 +inline
  264 +void GModelSpectralSmoothBrokenPlaw::type(const std::string& type)
  265 +{
  266 + m_type = type;
  267 + return;
  268 +}
  269 +
  270 +
  271 +/***********************************************************************//**
256 272 * @brief Return pre factor
257 273 *
258 274 * @return Pre factor (ph/cm2/s/MeV).
... ...
include/GModelSpectralSuperExpPlaw.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralSuperExpPlaw.hpp - Super exp. cut off power law model *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2014-2016 by Michael Mayer *
  4 + * copyright (C) 2014-2018 by Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -107,6 +107,7 @@ public:
107 107 virtual std::string print(const GChatter& chatter = NORMAL) const;
108 108  
109 109 // Other methods
  110 + void type(const std::string& type);
110 111 double prefactor(void) const;
111 112 void prefactor(const double& prefactor);
112 113 double index1(void) const;
... ... @@ -213,7 +214,7 @@ std::string GModelSpectralSuperExpPlaw::classname(void) const
213 214 *
214 215 * @return "SuperExpCutoff".
215 216 *
216   - * Returns the type of the exponentially cut off power law model.
  217 + * Returns the type of the super exponentially cut off power law model.
217 218 ***************************************************************************/
218 219 inline
219 220 std::string GModelSpectralSuperExpPlaw::type(void) const
... ... @@ -223,6 +224,21 @@ std::string GModelSpectralSuperExpPlaw::type(void) const
223 224  
224 225  
225 226 /***********************************************************************//**
  227 + * @brief Set model type
  228 + *
  229 + * @param[in] type Model type.
  230 + *
  231 + * Set the type of the super exponentially cut off power law model.
  232 + ***************************************************************************/
  233 +inline
  234 +void GModelSpectralSuperExpPlaw::type(const std::string& type)
  235 +{
  236 + m_type = type;
  237 + return;
  238 +}
  239 +
  240 +
  241 +/***********************************************************************//**
226 242 * @brief Return pre factor
227 243 *
228 244 * @return Pre factor (ph/cm2/s/MeV).
... ...
include/GObservation.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GObservation.hpp - Abstract observation base class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2008-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2008-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -113,6 +113,7 @@ public:
113 113 const GModelPar& par) const;
114 114  
115 115 // Implemented methods
  116 + bool has_events(void) const;
116 117 void name(const std::string& name);
117 118 void id(const std::string& id);
118 119 void statistic(const std::string& statistic);
... ... @@ -215,6 +216,18 @@ protected:
215 216  
216 217  
217 218 /***********************************************************************//**
  219 + * @brief Signal if observation has events
  220 + *
  221 + * @return True if observation contains events.
  222 + ***************************************************************************/
  223 +inline
  224 +bool GObservation::has_events(void) const
  225 +{
  226 + return (m_events != NULL);
  227 +}
  228 +
  229 +
  230 +/***********************************************************************//**
218 231 * @brief Set observation name
219 232 *
220 233 * @param[in] name Observation name.
... ...
include/GOptimizerPar.hpp
  View file @7364643
... ... @@ -171,9 +171,9 @@ protected:
171 171 mutable double m_factor_gradient; //!< Function gradient factor
172 172 double m_scale; //!< Parameter scaling (true = factor * scale)
173 173 bool m_free; //!< Parameter is free
174   - bool m_has_min; //!< Parameter has minimum boundary
175   - bool m_has_max; //!< Parameter has maximum boundary
176   - bool m_has_grad; //!< Parameter has analytic gradient
  174 + bool m_has_min; //!< Parameter has minimum boundary
  175 + bool m_has_max; //!< Parameter has maximum boundary
  176 + bool m_has_grad; //!< Parameter has analytic gradient
177 177 };
178 178  
179 179  
... ...
include/GXml.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GXml.hpp - XML class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -181,6 +181,7 @@ public:
181 181 GXml(void);
182 182 GXml(const GXml& xml);
183 183 explicit GXml(const std::string& xml);
  184 + explicit GXml(const GXmlDocument& root);
184 185 virtual ~GXml(void);
185 186  
186 187 // Operators
... ... @@ -189,33 +190,35 @@ public:
189 190 const GXmlNode* operator[](const int& index) const;
190 191  
191 192 // Methods
192   - void clear(void);
193   - GXml* clone(void) const;
194   - std::string classname(void) const;
195   - int size(void) const;
196   - bool is_empty(void) const;
197   - GXmlNode* set(const int& index, const GXmlNode& node);
198   - GXmlNode* append(const GXmlNode& node);
199   - GXmlElement* append(const std::string& segment);
200   - GXmlNode* insert(const int& index, const GXmlNode& node);
201   - void remove(const int& index);
202   - void reserve(const int& num);
203   - void extend(const GXmlNode& node);
204   - int elements(void) const;
205   - int elements(const std::string& name) const;
206   - GXmlElement* element(const int& index);
207   - const GXmlElement* element(const int& index) const;
208   - GXmlElement* element(const std::string& name);
209   - const GXmlElement* element(const std::string& name) const;
210   - GXmlElement* element(const std::string& name, const int& index);
211   - const GXmlElement* element(const std::string& name, const int& index) const;
212   - void load(const GFilename& filename);
213   - void save(const GFilename& filename) const;
214   - void read(const GUrl& url);
215   - void write(GUrl& url, const int& indent = 0) const;
216   - std::string print(const GChatter& chatter = NORMAL) const;
217   - std::string print(const GChatter& chatter = NORMAL,
218   - const int& indent = 0) const;
  193 + void clear(void);
  194 + GXml* clone(void) const;
  195 + std::string classname(void) const;
  196 + int size(void) const;
  197 + bool is_empty(void) const;
  198 + GXmlNode* set(const int& index, const GXmlNode& node);
  199 + GXmlNode* append(const GXmlNode& node);
  200 + GXmlElement* append(const std::string& segment);
  201 + GXmlNode* insert(const int& index, const GXmlNode& node);
  202 + void remove(const int& index);
  203 + void reserve(const int& num);
  204 + void extend(const GXmlNode& node);
  205 + int elements(void) const;
  206 + int elements(const std::string& name) const;
  207 + GXmlElement* element(const int& index);
  208 + const GXmlElement* element(const int& index) const;
  209 + GXmlElement* element(const std::string& name);
  210 + const GXmlElement* element(const std::string& name) const;
  211 + GXmlElement* element(const std::string& name, const int& index);
  212 + const GXmlElement* element(const std::string& name, const int& index) const;
  213 + const GXmlDocument& root(void) const;
  214 + void root(const GXmlDocument& root);
  215 + void load(const GFilename& filename);
  216 + void save(const GFilename& filename) const;
  217 + void read(const GUrl& url);
  218 + void write(GUrl& url, const int& indent = 0) const;
  219 + std::string print(const GChatter& chatter = NORMAL) const;
  220 + std::string print(const GChatter& chatter = NORMAL,
  221 + const int& indent = 0) const;
219 222  
220 223 protected:
221 224 // Protected enumerators
... ... @@ -278,4 +281,29 @@ bool GXml::is_empty(void) const
278 281 return m_root.is_empty();
279 282 }
280 283  
  284 +
  285 +/***********************************************************************//**
  286 + * @brief Return document root
  287 + *
  288 + * @return Document root.
  289 + ***************************************************************************/
  290 +inline
  291 +const GXmlDocument& GXml::root(void) const
  292 +{
  293 + return m_root;
  294 +}
  295 +
  296 +
  297 +/***********************************************************************//**
  298 + * @brief Set document root
  299 + *
  300 + * @param[in] root Document root.
  301 + ***************************************************************************/
  302 +inline
  303 +void GXml::root(const GXmlDocument& root)
  304 +{
  305 + m_root = root;
  306 + return;
  307 +}
  308 +
281 309 #endif /* GXML_HPP */
... ...
include/GXmlDocument.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlDocument.hpp - XML document node class definition *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -53,6 +53,10 @@ class GXmlDocument : public GXmlNode {
53 53 public:
54 54 // Constructors and destructors
55 55 GXmlDocument(void);
  56 + GXmlDocument(const GFilename& filename,
  57 + const std::string& version,
  58 + const std::string& encoding,
  59 + const std::string& standalone);
56 60 GXmlDocument(const GXmlDocument& node);
57 61 virtual ~GXmlDocument(void);
58 62  
... ...
include/GXmlElement.hpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlElement.hpp - XML element node class definition *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -65,6 +65,8 @@ public:
65 65 virtual std::string classname(void) const;
66 66 const std::string& name(void) const;
67 67 void name(const std::string& name);
  68 + int attributes(void) const;
  69 + const GXmlAttribute* attribute(const int& index) const;
68 70 std::string attribute(const std::string& name) const;
69 71 void attribute(const std::string& name,
70 72 const std::string& value);
... ... @@ -138,4 +140,16 @@ GXmlNode::NodeType GXmlElement::type(void) const
138 140 return (NT_ELEMENT);
139 141 }
140 142  
  143 +
  144 +/***********************************************************************//**
  145 + * @brief Return number of attributes
  146 + *
  147 + * @return Number of attributes.
  148 + ***************************************************************************/
  149 +inline
  150 +int GXmlElement::attributes(void) const
  151 +{
  152 + return (m_attr.size());
  153 +}
  154 +
141 155 #endif /* GXMLELEMENT_HPP */
... ...
inst/cta/include/GCTAEventAtom.hpp
  View file @7364643
... ... @@ -75,6 +75,7 @@ public:
75 75 const unsigned long& event_id(void) const;
76 76 const int& mc_id(void) const;
77 77 const float& phase(void) const;
  78 + void index(const int& index);
78 79 void event_id(const unsigned long& id);
79 80 void mc_id(const int& id);
80 81 void phase(const float& phase);
... ... @@ -234,6 +235,19 @@ const float&amp; GCTAEventAtom::phase(void) const
234 235  
235 236  
236 237 /***********************************************************************//**
  238 + * @brief Set event index
  239 + *
  240 + * @param[in] index Event index.
  241 + ***************************************************************************/
  242 +inline
  243 +void GCTAEventAtom::index(const int& index)
  244 +{
  245 + m_index = index;
  246 + return;
  247 +}
  248 +
  249 +
  250 +/***********************************************************************//**
237 251 * @brief Set event identifier
238 252 *
239 253 * @param[in] id Event identifier.
... ...
inst/cta/include/GCTAModelIrfBackground.hpp
  View file @7364643
... ... @@ -77,6 +77,8 @@ public:
77 77 // Other methods
78 78 GModelSpectral* spectral(void) const;
79 79 GModelTemporal* temporal(void) const;
  80 + void spectral(const GModelSpectral* spectral);
  81 + void temporal(const GModelTemporal* temporal);
80 82  
81 83 private:
82 84 // Methods
... ...
inst/cta/pyext/GCTAModelIrfBackground.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GCTAModelIrfBackground.i - CTA IRF background model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2014-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2014-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -62,6 +62,8 @@ public:
62 62 // Other methods
63 63 GModelSpectral* spectral(void) const;
64 64 GModelTemporal* temporal(void) const;
  65 + void spectral(const GModelSpectral* spectral);
  66 + void temporal(const GModelTemporal* temporal);
65 67 };
66 68  
67 69 /***********************************************************************//**
... ... @@ -71,4 +73,14 @@ public:
71 73 GCTAModelIrfBackground copy() {
72 74 return (*self);
73 75 }
  76 +%pythoncode {
  77 + def __getstate__(self):
  78 + args = gammalib.GModelData.__getstate__(self), self.spectral(), \
  79 + self.temporal()
  80 + return args
  81 + def __setstate__(self, state):
  82 + gammalib.GModelData.__setstate__(self, state[0])
  83 + self.spectral(state[1])
  84 + self.temporal(state[2])
  85 +}
74 86 };
... ...
inst/cta/pyext/cta.i
  View file @7364643
... ... @@ -162,6 +162,66 @@
162 162 }
163 163 $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
164 164 }
  165 +%typemap(out) GModelSpatial* {
  166 + char classname[80];
  167 + strcpy(classname, "_p_");
  168 + strcat(classname, result->classname().c_str());
  169 + swig_type_info *myinfo = SWIGTYPE_p_GModelSpatial;
  170 + swig_cast_info *mycast = 0;
  171 + mycast = myinfo->cast;
  172 + while (mycast != 0) {
  173 + if (strcmp(classname, mycast->type->name) == 0) {
  174 + myinfo = mycast->type;
  175 + break;
  176 + }
  177 + mycast = mycast->next;
  178 + }
  179 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
  180 +}
  181 +%typemap(out) GModelSpectral* {
  182 + if ($1 == NULL) {
  183 + $result = Py_None;
  184 + Py_INCREF(Py_None); // Py_None is a singleton so increment its reference
  185 + }
  186 + else {
  187 + char classname[80];
  188 + strcpy(classname, "_p_");
  189 + strcat(classname, result->classname().c_str());
  190 + swig_type_info *myinfo = SWIGTYPE_p_GModelSpectral;
  191 + swig_cast_info *mycast = 0;
  192 + mycast = myinfo->cast;
  193 + while (mycast != 0) {
  194 + if (strcmp(classname, mycast->type->name) == 0) {
  195 + myinfo = mycast->type;
  196 + break;
  197 + }
  198 + mycast = mycast->next;
  199 + }
  200 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
  201 + }
  202 +}
  203 +%typemap(out) GModelTemporal* {
  204 + if ($1 == NULL) {
  205 + $result = Py_None;
  206 + Py_INCREF(Py_None); // Py_None is a singleton so increment its reference
  207 + }
  208 + else {
  209 + char classname[80];
  210 + strcpy(classname, "_p_");
  211 + strcat(classname, result->classname().c_str());
  212 + swig_type_info *myinfo = SWIGTYPE_p_GModelTemporal;
  213 + swig_cast_info *mycast = 0;
  214 + mycast = myinfo->cast;
  215 + while (mycast != 0) {
  216 + if (strcmp(classname, mycast->type->name) == 0) {
  217 + myinfo = mycast->type;
  218 + break;
  219 + }
  220 + mycast = mycast->next;
  221 + }
  222 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
  223 + }
  224 +}
165 225  
166 226 /* __ CTA ________________________________________________________________ */
167 227 %include "GCTAObservation.i"
... ...
inst/cta/src/GCTAModelIrfBackground.cpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GCTAModelIrfBackground.cpp - CTA IRF background model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2014-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2014-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -268,6 +268,60 @@ GCTAModelIrfBackground* GCTAModelIrfBackground::clone(void) const
268 268  
269 269  
270 270 /***********************************************************************//**
  271 + * @brief Set spectral model component
  272 + *
  273 + * @param[in] spectral Pointer to spectral model component.
  274 + *
  275 + * Sets the spectral model component of the model.
  276 + ***************************************************************************/
  277 +void GCTAModelIrfBackground::spectral(const GModelSpectral* spectral)
  278 +{
  279 + // Free spectral model component only if it differs from current
  280 + // component. This prevents unintential deallocation of the argument
  281 + if ((m_spectral != NULL) && (m_spectral != spectral)) {
  282 + delete m_spectral;
  283 + }
  284 +
  285 + // Clone spectral model component if it exists, otherwise set pointer
  286 + // to NULL
  287 + m_spectral = (spectral != NULL) ? spectral->clone() : NULL;
  288 +
  289 + // Set parameter pointers
  290 + set_pointers();
  291 +
  292 + // Return
  293 + return;
  294 +}
  295 +
  296 +
  297 +/***********************************************************************//**
  298 + * @brief Set temporal model component
  299 + *
  300 + * @param[in] temporal Pointer to temporal model component.
  301 + *
  302 + * Sets the temporal model component of the model.
  303 + ***************************************************************************/
  304 +void GCTAModelIrfBackground::temporal(const GModelTemporal* temporal)
  305 +{
  306 + // Free temporal model component only if it differs from current
  307 + // component. This prevents unintential deallocation of the argument
  308 + if ((m_temporal != NULL) && (m_temporal != temporal)) {
  309 + delete m_temporal;
  310 + }
  311 +
  312 + // Clone temporal model component if it exists, otherwise set pointer
  313 + // to NULL
  314 + m_temporal = (temporal != NULL) ? temporal->clone() : NULL;
  315 +
  316 + // Set parameter pointers
  317 + set_pointers();
  318 +
  319 + // Return
  320 + return;
  321 +}
  322 +
  323 +
  324 +/***********************************************************************//**
271 325 * @brief Evaluate function
272 326 *
273 327 * @param[in] event Observed event.
... ...
inst/cta/test/test_CTA.py
  View file @7364643
... ... @@ -342,6 +342,105 @@ class Test(gammalib.GPythonTestSuite):
342 342 # Return
343 343 return
344 344  
  345 + # Test class pickeling
  346 + def _test_pickeling(self):
  347 + """
  348 + Test class pickeling
  349 + """
  350 + # Perform pickeling tests of empty classes
  351 + #test_support._pickeling(self, gammalib.GCTAAeff2D())
  352 + #test_support._pickeling(self, gammalib.GCTAAeffArf())
  353 + #test_support._pickeling(self, gammalib.GCTAAeffPerfTable())
  354 + #test_support._pickeling(self, gammalib.GCTABackground3D())
  355 + #test_support._pickeling(self, gammalib.GCTABackgroundPerfTable())
  356 + #test_support._pickeling(self, gammalib.GCTACubeBackground())
  357 + #test_support._pickeling(self, gammalib.GCTACubeEdisp())
  358 + #test_support._pickeling(self, gammalib.GCTACubeExposure())
  359 + #test_support._pickeling(self, gammalib.GCTACubePsf())
  360 + #test_support._pickeling(self, gammalib.GCTACubeSourceDiffuse())
  361 + #test_support._pickeling(self, gammalib.GCTACubeSourcePoint())
  362 + #test_support._pickeling(self, gammalib.GCTAEdisp2D())
  363 + #test_support._pickeling(self, gammalib.GCTAEdispPerfTable())
  364 + #test_support._pickeling(self, gammalib.GCTAEdispRmf())
  365 + test_support._pickeling(self, gammalib.GCTAEventAtom())
  366 + #test_support._pickeling(self, gammalib.GCTAEventBin())
  367 + #test_support._pickeling(self, gammalib.GCTAEventCube())
  368 + #test_support._pickeling(self, gammalib.GCTAEventList())
  369 + test_support._pickeling(self, gammalib.GCTAInstDir())
  370 + #test_support._pickeling(self, gammalib.GCTAModelAeffBackground())
  371 + #test_support._pickeling(self, gammalib.GCTAModelCubeBackground())
  372 + test_support._pickeling(self, gammalib.GCTAModelIrfBackground())
  373 + #test_support._pickeling(self, gammalib.GCTAModelRadialAcceptance())
  374 + #test_support._pickeling(self, gammalib.GCTAModelRadialGauss())
  375 + #test_support._pickeling(self, gammalib.GCTAModelRadialPolynom())
  376 + #test_support._pickeling(self, gammalib.GCTAModelRadialProfile())
  377 + #test_support._pickeling(self, gammalib.GCTAObservation())
  378 + #test_support._pickeling(self, gammalib.GCTAOnOffObservation())
  379 + #test_support._pickeling(self, gammalib.GCTAPointing())
  380 + #test_support._pickeling(self, gammalib.GCTAPsf2D())
  381 + #test_support._pickeling(self, gammalib.GCTAPsfKing())
  382 + #test_support._pickeling(self, gammalib.GCTAPsfPerfTable())
  383 + #test_support._pickeling(self, gammalib.GCTAPsfTable())
  384 + #test_support._pickeling(self, gammalib.GCTAPsfVector())
  385 + #test_support._pickeling(self, gammalib.GCTAResponseCube())
  386 + #test_support._pickeling(self, gammalib.GCTAResponseIrf())
  387 + #test_support._pickeling(self, gammalib.GCTAResponseTable())
  388 + #test_support._pickeling(self, gammalib.GCTARoi())
  389 +
  390 + # Setup test
  391 + list = self._setup_eventlist()
  392 + atom = list[0]
  393 + dir = gammalib.GSkyDir()
  394 + instdir = gammalib.GCTAInstDir(dir)
  395 + pivot = gammalib.GEnergy(1.0,'TeV')
  396 + plaw = gammalib.GModelSpectralPlaw(1.0,-2.0,pivot)
  397 + instdir.detx(2.0)
  398 + instdir.dety(-3.0)
  399 +
  400 + # Perform pickeling tests of filled classes
  401 + #test_support._pickeling(self, gammalib.GCTAAeff2D())
  402 + #test_support._pickeling(self, gammalib.GCTAAeffArf())
  403 + #test_support._pickeling(self, gammalib.GCTAAeffPerfTable())
  404 + #test_support._pickeling(self, gammalib.GCTABackground3D())
  405 + #test_support._pickeling(self, gammalib.GCTABackgroundPerfTable())
  406 + #test_support._pickeling(self, gammalib.GCTACubeBackground())
  407 + #test_support._pickeling(self, gammalib.GCTACubeEdisp())
  408 + #test_support._pickeling(self, gammalib.GCTACubeExposure())
  409 + #test_support._pickeling(self, gammalib.GCTACubePsf())
  410 + #test_support._pickeling(self, gammalib.GCTACubeSourceDiffuse())
  411 + #test_support._pickeling(self, gammalib.GCTACubeSourcePoint())
  412 + #test_support._pickeling(self, gammalib.GCTAEdisp2D())
  413 + #test_support._pickeling(self, gammalib.GCTAEdispPerfTable())
  414 + #test_support._pickeling(self, gammalib.GCTAEdispRmf())
  415 + test_support._pickeling(self, gammalib.GCTAEventAtom(atom))
  416 + #test_support._pickeling(self, gammalib.GCTAEventBin())
  417 + #test_support._pickeling(self, gammalib.GCTAEventCube())
  418 + #test_support._pickeling(self, gammalib.GCTAEventList())
  419 + test_support._pickeling(self, gammalib.GCTAInstDir(instdir))
  420 + #test_support._pickeling(self, gammalib.GCTAModelAeffBackground())
  421 + #test_support._pickeling(self, gammalib.GCTAModelCubeBackground())
  422 + test_support._pickeling(self, gammalib.GCTAModelIrfBackground(plaw))
  423 + #test_support._pickeling(self, gammalib.GCTAModelRadialAcceptance())
  424 + #test_support._pickeling(self, gammalib.GCTAModelRadialGauss())
  425 + #test_support._pickeling(self, gammalib.GCTAModelRadialPolynom())
  426 + #test_support._pickeling(self, gammalib.GCTAModelRadialProfile())
  427 + #test_support._pickeling(self, gammalib.GCTAObservation())
  428 + #test_support._pickeling(self, gammalib.GCTAOnOffObservation())
  429 + #test_support._pickeling(self, gammalib.GCTAPointing())
  430 + #test_support._pickeling(self, gammalib.GCTAPsf2D())
  431 + #test_support._pickeling(self, gammalib.GCTAPsfKing())
  432 + #test_support._pickeling(self, gammalib.GCTAPsfPerfTable())
  433 + #test_support._pickeling(self, gammalib.GCTAPsfTable())
  434 + #test_support._pickeling(self, gammalib.GCTAPsfVector())
  435 + #test_support._pickeling(self, gammalib.GCTAResponseCube())
  436 + #test_support._pickeling(self, gammalib.GCTAResponseIrf())
  437 + #test_support._pickeling(self, gammalib.GCTAResponseTable())
  438 + #test_support._pickeling(self, gammalib.GCTARoi())
  439 +
  440 + # Return
  441 + return
  442 +
  443 +
345 444 # Set test functions
346 445 def set(self):
347 446 """
... ... @@ -358,6 +457,7 @@ class Test(gammalib.GPythonTestSuite):
358 457 self.append(self._test_edisp, 'Test CTA energy dispersion classes')
359 458 self.append(self._test_response, 'Test CTA response classes')
360 459 self.append(self._test_onoff, 'Test CTA On/Off analysis')
  460 + self.append(self._test_pickeling, 'Test pickeling of "cta" classes')
361 461  
362 462 # Return
363 463 return
... ...
pyext/GEbounds.i
  View file @7364643
... ... @@ -133,9 +133,9 @@ public:
133 133 }
134 134 %pythoncode {
135 135 def __getstate__(self):
136   - args = tuple([self.emin(i) for i in range(self.size())]), \
137   - tuple([self.emin(i) for i in range(self.size())])
138   - return args
  136 + state = tuple([self.emin(i) for i in range(self.size())]), \
  137 + tuple([self.emin(i) for i in range(self.size())])
  138 + return state
139 139 def __setstate__(self, state):
140 140 self.__init__()
141 141 size = len(state[0])
... ...
pyext/GEnergies.i
  View file @7364643
... ... @@ -137,12 +137,13 @@ public:
137 137 }
138 138 %pythoncode {
139 139 def __getstate__(self):
140   - args = tuple([x for x in self])
141   - return args
  140 + state = tuple([x for x in self]),
  141 + return state
142 142 def __setstate__(self, state):
143 143 self.__init__()
144   - self.reserve(len(state))
145   - for x in state:
  144 + size = len(state[0])
  145 + self.reserve(size)
  146 + for x in state[0]:
146 147 self.append(x)
147 148 }
148 149 };
... ...
pyext/GEnergy.i
  View file @7364643
... ... @@ -146,10 +146,10 @@ public:
146 146 }
147 147 %pythoncode {
148 148 def __getstate__(self):
149   - args = self.MeV()
150   - return args
  149 + state = self.MeV(),
  150 + return state
151 151 def __setstate__(self, state):
152 152 self.__init__()
153   - self.MeV(state)
  153 + self.MeV(state[0])
154 154 }
155 155 };
... ...
pyext/GEvents.i
  View file @7364643
... ... @@ -99,8 +99,8 @@ public:
99 99 }
100 100 %pythoncode {
101 101 def __getstate__(self):
102   - args = self.gti(), self.ebounds()
103   - return args
  102 + state = self.gti(), self.ebounds()
  103 + return state
104 104 def __setstate__(self, state):
105 105 self.__init__()
106 106 self.gti(state[0])
... ...
pyext/GFilename.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GFilename.i - Filename class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2015-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2015-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -91,4 +91,11 @@ public:
91 91 GFilename copy() {
92 92 return (*self);
93 93 }
  94 +%pythoncode {
  95 + def __getstate__(self):
  96 + state = (self.__repr__(),)
  97 + return state
  98 + def __setstate__(self, state):
  99 + self.__init__(state[0])
  100 +}
94 101 };
... ...
pyext/GGti.i
  View file @7364643
... ... @@ -119,10 +119,10 @@ public:
119 119 }
120 120 %pythoncode {
121 121 def __getstate__(self):
122   - args = tuple([self.tstart(i) for i in range(self.size())]), \
123   - tuple([self.tstop(i) for i in range(self.size())]), \
124   - self.reference()
125   - return args
  122 + state = tuple([self.tstart(i) for i in range(self.size())]), \
  123 + tuple([self.tstop(i) for i in range(self.size())]), \
  124 + self.reference()
  125 + return state
126 126 def __setstate__(self, state):
127 127 self.__init__()
128 128 size = len(state[0])
... ...
pyext/GModel.i
  View file @7364643
... ... @@ -108,4 +108,18 @@ public:
108 108 (*self)[name] = val;
109 109 return;
110 110 }
  111 +%pythoncode {
  112 + def __getstate__(self):
  113 + state = self.name(), self.instruments(), self.ids(), self.tscalc(), \
  114 + self.has_ts(), self.ts()
  115 + return state
  116 + def __setstate__(self, state):
  117 + self.__init__()
  118 + self.name(state[0])
  119 + self.instruments(state[1])
  120 + self.ids(state[2])
  121 + self.tscalc(state[3])
  122 + if state[4]:
  123 + self.ts(state[5])
  124 +}
111 125 };
... ...
pyext/GModelData.i
  View file @7364643
... ... @@ -64,4 +64,11 @@ public:
64 64 * @brief GModelData class extension
65 65 ***************************************************************************/
66 66 %extend GModelData {
  67 +%pythoncode {
  68 + def __getstate__(self):
  69 + state = gammalib.GModel.__getstate__(self)
  70 + return state
  71 + def __setstate__(self, state):
  72 + gammalib.GModel.__setstate__(self, state)
  73 +}
67 74 };
... ...
pyext/GModelPar.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelPar.i - Model parameter class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2009-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2009-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -59,4 +59,12 @@ public:
59 59 GModelPar copy() {
60 60 return (*self);
61 61 }
  62 +%pythoncode {
  63 + def __getstate__(self):
  64 + state = gammalib.GOptimizerPar.__getstate__(self)
  65 + return state
  66 + def __setstate__(self, state):
  67 + self.__init__()
  68 + gammalib.GOptimizerPar.__setstate__(self, state)
  69 +}
62 70 };
... ...
pyext/GModelSky.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSky.i - Sky model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2011-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2011-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -93,4 +93,19 @@ public:
93 93 GModelSky copy() {
94 94 return (*self);
95 95 }
  96 +%pythoncode {
  97 + def __getstate__(self):
  98 + state = (gammalib.GModel.__getstate__(self),
  99 + self.type(), self.spatial(), self.spectral(), self.temporal())
  100 + return state
  101 + def __setstate__(self, state):
  102 + self.__init__(state[1])
  103 + gammalib.GModel.__setstate__(self, state[0])
  104 + if state[2] != None:
  105 + self.spatial(state[2])
  106 + if state[3] != None:
  107 + self.spectral(state[3])
  108 + if state[4] != None:
  109 + self.temporal(state[4])
  110 +}
96 111 };
... ...
pyext/GModelSpatialComposite.i
  View file @7364643
... ... @@ -62,6 +62,7 @@ public:
62 62 virtual void write(GXmlElement& xml) const;
63 63  
64 64 // Other methods
  65 + void type(const std::string& type);
65 66 int components(void) const;
66 67 void append(const GModelSpatial& component,
67 68 const std::string& name = "",
... ... @@ -80,4 +81,13 @@ public:
80 81 GModelSpatialComposite copy() {
81 82 return (*self);
82 83 }
  84 +%pythoncode {
  85 + def __getstate__(self):
  86 + xml = gammalib.GXmlElement()
  87 + self.write(xml)
  88 + state = xml,
  89 + return state
  90 + def __setstate__(self, state):
  91 + self.__init__(state[0])
  92 +}
83 93 };
... ...
pyext/GModelSpatialPointSource.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpatialPointSource.i - Spatial point source model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2009-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2009-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -64,6 +64,7 @@ public:
64 64 virtual GSkyRegion* region(void) const;
65 65  
66 66 // Other methods
  67 + void type(const std::string& type);
67 68 double ra(void) const;
68 69 double dec(void) const;
69 70 void ra(const double& ra);
... ... @@ -80,4 +81,14 @@ public:
80 81 GModelSpatialPointSource copy() {
81 82 return (*self);
82 83 }
  84 +%pythoncode {
  85 + def __getstate__(self):
  86 + state = self.type(), self[0], self[1]
  87 + return state
  88 + def __setstate__(self, state):
  89 + self.__init__()
  90 + self.type(state[0])
  91 + self[0] = state[1]
  92 + self[1] = state[2]
  93 +}
83 94 };
... ...
pyext/GModelSpectralBrokenPlaw.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralBrokenPlaw.i - Broken power law spectrum class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2013-2016 by Anneli Schulz *
  4 + * copyright (C) 2013-2018 by Anneli Schulz *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -71,6 +71,7 @@ public:
71 71 virtual void write(GXmlElement& xml) const;
72 72  
73 73 // Other methods
  74 + void type(const std::string& type);
74 75 double prefactor(void) const;
75 76 double index1(void) const;
76 77 double index2(void) const;
... ... @@ -89,4 +90,16 @@ public:
89 90 GModelSpectralBrokenPlaw copy() {
90 91 return (*self);
91 92 }
  93 +%pythoncode {
  94 + def __getstate__(self):
  95 + state = (self.type(), self[0], self[1], self[2], self[3])
  96 + return state
  97 + def __setstate__(self, state):
  98 + self.__init__()
  99 + self.type(state[0])
  100 + self[0] = state[1]
  101 + self[1] = state[2]
  102 + self[2] = state[3]
  103 + self[3] = state[4]
  104 +}
92 105 };
... ...
pyext/GModelSpectralComposite.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralComposite.i - Spectral composite model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2016 Michael Mayer *
  4 + * copyright (C) 2016-2018 Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -77,4 +77,13 @@ public:
77 77 GModelSpectralComposite copy() {
78 78 return (*self);
79 79 }
  80 +%pythoncode {
  81 + def __getstate__(self):
  82 + xml = gammalib.GXmlElement()
  83 + self.write(xml)
  84 + state = xml,
  85 + return state
  86 + def __setstate__(self, state):
  87 + self.__init__(state[0])
  88 +}
80 89 };
... ...
pyext/GModelSpectralConst.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralConst.i - Spectral constant model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2011-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2011-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -62,6 +62,7 @@ public:
62 62 virtual void write(GXmlElement& xml) const;
63 63  
64 64 // Other methods
  65 + void type(const std::string& type);
65 66 double value(void) const;
66 67 void value(const double& value);
67 68 };
... ... @@ -74,4 +75,13 @@ public:
74 75 GModelSpectralConst copy() {
75 76 return (*self);
76 77 }
  78 +%pythoncode {
  79 + def __getstate__(self):
  80 + state = (self.type(), self[0])
  81 + return state
  82 + def __setstate__(self, state):
  83 + self.__init__()
  84 + self.type(state[0])
  85 + self[0] = state[1]
  86 +}
77 87 };
... ...
pyext/GModelSpectralExpInvPlaw.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralExpInvPlaw.i - Exponential cut off power law model *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2016 by Alexander Ziegler *
  4 + * copyright (C) 2016-2018 by Alexander Ziegler *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -76,6 +76,7 @@ public:
76 76 virtual void write(GXmlElement& xml) const;
77 77  
78 78 // Other methods
  79 + void type(const std::string& type);
79 80 double prefactor(void) const;
80 81 void prefactor(const double& prefactor);
81 82 double index(void) const;
... ... @@ -96,4 +97,16 @@ public:
96 97 GModelSpectralExpInvPlaw copy() {
97 98 return (*self);
98 99 }
  100 +%pythoncode {
  101 + def __getstate__(self):
  102 + state = (self.type(), self[0], self[1], self[2], self[3])
  103 + return state
  104 + def __setstate__(self, state):
  105 + self.__init__()
  106 + self.type(state[0])
  107 + self[0] = state[1]
  108 + self[1] = state[2]
  109 + self[2] = state[3]
  110 + self[3] = state[4]
  111 +}
99 112 };
... ...
pyext/GModelSpectralExpPlaw.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralExpPlaw.i - Exponential cut off power law model *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2009-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2009-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -71,6 +71,7 @@ public:
71 71 virtual void write(GXmlElement& xml) const;
72 72  
73 73 // Other methods
  74 + void type(const std::string& type);
74 75 double prefactor(void) const;
75 76 void prefactor(const double& prefactor);
76 77 double index(void) const;
... ... @@ -89,4 +90,16 @@ public:
89 90 GModelSpectralExpPlaw copy() {
90 91 return (*self);
91 92 }
  93 +%pythoncode {
  94 + def __getstate__(self):
  95 + state = (self.type(), self[0], self[1], self[2], self[3])
  96 + return state
  97 + def __setstate__(self, state):
  98 + self.__init__()
  99 + self.type(state[0])
  100 + self[0] = state[1]
  101 + self[1] = state[2]
  102 + self[2] = state[3]
  103 + self[3] = state[4]
  104 +}
92 105 };
... ...
pyext/GModelSpectralFunc.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralFunc.i - Spectral function model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2011-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2011-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -78,4 +78,13 @@ public:
78 78 GModelSpectralFunc copy() {
79 79 return (*self);
80 80 }
  81 +%pythoncode {
  82 + def __getstate__(self):
  83 + xml = gammalib.GXmlElement()
  84 + self.write(xml)
  85 + state = xml,
  86 + return state
  87 + def __setstate__(self, state):
  88 + self.__init__(state[0])
  89 +}
81 90 };
... ...
pyext/GModelSpectralGauss.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralGauss.i - Spectral gaussian model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2014-2016 by Christoph Deil & Ellis Owen *
  4 + * copyright (C) 2014-2018 by Christoph Deil & Ellis Owen *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -81,4 +81,14 @@ public:
81 81 GModelSpectralGauss copy() {
82 82 return (*self);
83 83 }
  84 +%pythoncode {
  85 + def __getstate__(self):
  86 + state = (self[0], self[1], self[2])
  87 + return state
  88 + def __setstate__(self, state):
  89 + self.__init__()
  90 + self[0] = state[0]
  91 + self[1] = state[1]
  92 + self[2] = state[2]
  93 +}
84 94 };
... ...
pyext/GModelSpectralLogParabola.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralLogParabola.i - Log parabola spectral model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2012-2016 by Michael Mayer *
  4 + * copyright (C) 2012-2018 by Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -71,6 +71,7 @@ public:
71 71 virtual void write(GXmlElement& xml) const;
72 72  
73 73 // Other methods
  74 + void type(const std::string& type);
74 75 double prefactor(void) const;
75 76 void prefactor(const double& prefactor);
76 77 double index(void) const;
... ... @@ -89,4 +90,16 @@ public:
89 90 GModelSpectralLogParabola copy() {
90 91 return (*self);
91 92 }
  93 +%pythoncode {
  94 + def __getstate__(self):
  95 + state = (self.type(), self[0], self[1], self[2], self[3])
  96 + return state
  97 + def __setstate__(self, state):
  98 + self.__init__()
  99 + self.type(state[0])
  100 + self[0] = state[1]
  101 + self[1] = state[2]
  102 + self[2] = state[3]
  103 + self[3] = state[4]
  104 +}
92 105 };
... ...
pyext/GModelSpectralMultiplicative.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralMultiplicative.i - Multiplicative spectral model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2016 Michael Mayer *
  4 + * copyright (C) 2016-2018 Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -76,4 +76,13 @@ public:
76 76 GModelSpectralMultiplicative copy() {
77 77 return (*self);
78 78 }
  79 +%pythoncode {
  80 + def __getstate__(self):
  81 + xml = gammalib.GXmlElement()
  82 + self.write(xml)
  83 + state = xml,
  84 + return state
  85 + def __setstate__(self, state):
  86 + self.__init__(state[0])
  87 +}
79 88 };
... ...
pyext/GModelSpectralNodes.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralNodes.i - Spectral nodes model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2012-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2012-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -84,4 +84,16 @@ public:
84 84 GModelSpectralNodes copy() {
85 85 return (*self);
86 86 }
  87 +%pythoncode {
  88 + def __getstate__(self):
  89 + xml = gammalib.GXmlElement()
  90 + self.write(xml)
  91 + state = xml,
  92 + return state
  93 + def __setstate__(self, state):
  94 + if state[0].elements('node') == 0:
  95 + self.__init__()
  96 + else:
  97 + self.__init__(state[0])
  98 +}
87 99 };
... ...
pyext/GModelSpectralPlaw.i
  View file @7364643
... ... @@ -69,6 +69,7 @@ public:
69 69 virtual void write(GXmlElement& xml) const;
70 70  
71 71 // Other methods
  72 + void type(const std::string& type);
72 73 double prefactor(void) const;
73 74 double index(void) const;
74 75 GEnergy pivot(void) const;
... ... @@ -85,4 +86,15 @@ public:
85 86 GModelSpectralPlaw copy() {
86 87 return (*self);
87 88 }
  89 +%pythoncode {
  90 + def __getstate__(self):
  91 + state = (self.type(), self[0], self[1], self[2])
  92 + return state
  93 + def __setstate__(self, state):
  94 + self.__init__()
  95 + self.type(state[0])
  96 + self[0] = state[1]
  97 + self[1] = state[2]
  98 + self[2] = state[3]
  99 +}
88 100 };
... ...
pyext/GModelSpectralPlawEnergyFlux.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralPlawEnergyFlux.i - Spectral power law model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2016 by Michael Mayer *
  4 + * copyright (C) 2016-2018 by Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -71,6 +71,7 @@ public:
71 71 virtual void write(GXmlElement& xml) const;
72 72  
73 73 // Other methods
  74 + void type(const std::string& type);
74 75 double eflux(void) const;
75 76 void eflux(const double& eflux);
76 77 double index(void) const;
... ... @@ -89,4 +90,16 @@ public:
89 90 GModelSpectralPlawEnergyFlux copy() {
90 91 return (*self);
91 92 }
  93 +%pythoncode {
  94 + def __getstate__(self):
  95 + state = (self.type(), self[0], self[1], self[2], self[3])
  96 + return state
  97 + def __setstate__(self, state):
  98 + self.__init__()
  99 + self.type(state[0])
  100 + self[0] = state[1]
  101 + self[1] = state[2]
  102 + self[2] = state[3]
  103 + self[3] = state[4]
  104 +}
92 105 };
... ...
pyext/GModelSpectralPlawPhotonFlux.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralPlawPhotonFlux.i - Spectral power law model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2011-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2011-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -71,6 +71,7 @@ public:
71 71 virtual void write(GXmlElement& xml) const;
72 72  
73 73 // Other methods
  74 + void type(const std::string& type);
74 75 double flux(void) const;
75 76 void flux(const double& flux);
76 77 double index(void) const;
... ... @@ -89,4 +90,16 @@ public:
89 90 GModelSpectralPlawPhotonFlux copy() {
90 91 return (*self);
91 92 }
  93 +%pythoncode {
  94 + def __getstate__(self):
  95 + state = (self.type(), self[0], self[1], self[2], self[3])
  96 + return state
  97 + def __setstate__(self, state):
  98 + self.__init__()
  99 + self.type(state[0])
  100 + self[0] = state[1]
  101 + self[1] = state[2]
  102 + self[2] = state[3]
  103 + self[3] = state[4]
  104 +}
92 105 };
... ...
pyext/GModelSpectralSmoothBrokenPlaw.i
  View file @7364643
... ... @@ -2,7 +2,7 @@
2 2 * GModelSpectralSmoothBrokenPlaw.i *
3 3 * Smoothly broken power law spectrum class *
4 4 * ----------------------------------------------------------------------- *
5   - * copyright (C) 2017 by Josh Cardenzana *
  5 + * copyright (C) 2017-2018 by Josh Cardenzana *
6 6 * ----------------------------------------------------------------------- *
7 7 * *
8 8 * This program is free software: you can redistribute it and/or modify *
... ... @@ -76,6 +76,7 @@ public:
76 76 virtual void write(GXmlElement& xml) const;
77 77  
78 78 // Other methods
  79 + void type(const std::string& type);
79 80 double prefactor(void) const;
80 81 double index1(void) const;
81 82 double index2(void) const;
... ... @@ -98,4 +99,18 @@ public:
98 99 GModelSpectralSmoothBrokenPlaw copy() {
99 100 return (*self);
100 101 }
  102 +%pythoncode {
  103 + def __getstate__(self):
  104 + state = (self.type(), self[0], self[1], self[2], self[3], self[4], self[5])
  105 + return state
  106 + def __setstate__(self, state):
  107 + self.__init__()
  108 + self.type(state[0])
  109 + self[0] = state[1]
  110 + self[1] = state[2]
  111 + self[2] = state[3]
  112 + self[3] = state[4]
  113 + self[4] = state[5]
  114 + self[5] = state[6]
  115 +}
101 116 };
... ...
pyext/GModelSpectralSuperExpPlaw.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelSpectralSuperExpPlaw.i - Super exp. cut off power law model *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2014-2016 by Michael Mayer *
  4 + * copyright (C) 2014-2018 by Michael Mayer *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -73,6 +73,7 @@ public:
73 73 virtual void write(GXmlElement& xml) const;
74 74  
75 75 // Other methods
  76 + void type(const std::string& type);
76 77 double prefactor(void) const;
77 78 void prefactor(const double& prefactor);
78 79 double index1(void) const;
... ... @@ -93,4 +94,17 @@ public:
93 94 GModelSpectralSuperExpPlaw copy() {
94 95 return (*self);
95 96 }
  97 +%pythoncode {
  98 + def __getstate__(self):
  99 + state = (self.type(), self[0], self[1], self[2], self[3], self[4])
  100 + return state
  101 + def __setstate__(self, state):
  102 + self.__init__()
  103 + self.type(state[0])
  104 + self[0] = state[1]
  105 + self[1] = state[2]
  106 + self[2] = state[3]
  107 + self[3] = state[4]
  108 + self[4] = state[5]
  109 +}
96 110 };
... ...
pyext/GModelTemporalConst.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelTemporalConst.i - Temporal constant model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2009-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2009-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -70,4 +70,12 @@ public:
70 70 GModelTemporalConst copy() {
71 71 return (*self);
72 72 }
  73 +%pythoncode {
  74 + def __getstate__(self):
  75 + state = self[0],
  76 + return state
  77 + def __setstate__(self, state):
  78 + self.__init__()
  79 + self[0] = state[0]
  80 +}
73 81 };
... ...
pyext/GModelTemporalLightCurve.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelTemporalLightCurve.i - Temporal light curve model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2017-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -72,4 +72,13 @@ public:
72 72 GModelTemporalLightCurve copy() {
73 73 return (*self);
74 74 }
  75 +%pythoncode {
  76 + def __getstate__(self):
  77 + xml = gammalib.GXmlElement()
  78 + self.write(xml)
  79 + state = xml,
  80 + return state
  81 + def __setstate__(self, state):
  82 + self.__init__(state[0])
  83 +}
75 84 };
... ...
pyext/GModelTemporalPhaseCurve.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelTemporalPhaseCurve.i - Temporal phase curve model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2017-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -91,4 +91,13 @@ public:
91 91 GModelTemporalPhaseCurve copy() {
92 92 return (*self);
93 93 }
  94 +%pythoncode {
  95 + def __getstate__(self):
  96 + xml = gammalib.GXmlElement()
  97 + self.write(xml)
  98 + state = xml,
  99 + return state
  100 + def __setstate__(self, state):
  101 + self.__init__(state[0])
  102 +}
94 103 };
... ...
pyext/GModels.i
  View file @7364643
... ... @@ -144,4 +144,15 @@ public:
144 144 GModels copy() {
145 145 return (*self);
146 146 }
  147 +%pythoncode {
  148 + def __getstate__(self):
  149 + state = tuple([x for x in self]),
  150 + return state
  151 + def __setstate__(self, state):
  152 + self.__init__()
  153 + size = len(state[0])
  154 + self.reserve(size)
  155 + for x in state[0]:
  156 + self.append(x)
  157 +}
147 158 };
... ...
pyext/GObservation.i
  View file @7364643
... ... @@ -92,6 +92,7 @@ public:
92 92 const GModelPar& par) const;
93 93  
94 94 // Implemented methods
  95 + bool has_events(void) const;
95 96 void name(const std::string& name);
96 97 void id(const std::string& id);
97 98 void statistic(const std::string& statistic);
... ... @@ -107,13 +108,18 @@ public:
107 108 %extend GObservation {
108 109 %pythoncode {
109 110 def __getstate__(self):
110   - args = (self.name(), self.id(), self.statistic(), self.events())
  111 + if self.has_events():
  112 + events = self.events()
  113 + else:
  114 + events = None
  115 + args = (self.name(), self.id(), self.statistic(), events)
111 116 return args
112 117 def __setstate__(self, state):
113 118 self.__init__()
114 119 self.name(state[0])
115 120 self.id(state[1])
116 121 self.statistic(state[2])
117   - self.events(state[3])
  122 + if state[3] != None:
  123 + self.events(state[3])
118 124 }
119 125 };
... ...
pyext/GObservations.i
  View file @7364643
... ... @@ -170,8 +170,8 @@ typedef GObservations::likelihood likelihood;
170 170 }
171 171 %pythoncode {
172 172 def __getstate__(self):
173   - args = self.models(), tuple([x for x in self])
174   - return args
  173 + state = self.models(), tuple([x for x in self])
  174 + return state
175 175 def __setstate__(self, state):
176 176 self.__init__()
177 177 self.models(state[0])
... ...
pyext/GOptimizerPar.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GOptimizerPar.i - Optimizer parameter class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2013-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2013-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -107,4 +107,30 @@ public:
107 107 GOptimizerPar copy() {
108 108 return (*self);
109 109 }
  110 +%pythoncode {
  111 + def __getstate__(self):
  112 + state = self.name(), self.unit(), \
  113 + self.factor_value(), self.factor_error(), self.factor_min(), \
  114 + self.factor_max(), self.factor_gradient(), self.scale(), \
  115 + self.is_free(), self.has_min(), self.has_max(), self.has_grad()
  116 + return state
  117 + def __setstate__(self, state):
  118 + self.__init__()
  119 + self.name(state[0])
  120 + self.unit(state[1])
  121 + self.scale(state[7])
  122 + self.factor_value(state[2])
  123 + self.factor_error(state[3])
  124 + if state[8]:
  125 + self.free()
  126 + else:
  127 + self.fix()
  128 + if state[9]:
  129 + self.factor_min(state[4])
  130 + if state[10]:
  131 + self.factor_max(state[5])
  132 + if state[11]:
  133 + self.factor_gradient(state[6])
  134 + self.has_grad(state[11])
  135 +}
110 136 };
... ...
pyext/GPhases.i
  View file @7364643
... ... @@ -97,9 +97,9 @@ public:
97 97 }
98 98 %pythoncode {
99 99 def __getstate__(self):
100   - args = tuple([self.pmin(i) for i in range(self.size())]), \
101   - tuple([self.pmax(i) for i in range(self.size())])
102   - return args
  100 + state = tuple([self.pmin(i) for i in range(self.size())]), \
  101 + tuple([self.pmax(i) for i in range(self.size())])
  102 + return state
103 103 def __setstate__(self, state):
104 104 self.__init__()
105 105 size = len(state[0])
... ...
pyext/GPhoton.i
  View file @7364643
... ... @@ -80,10 +80,6 @@ public:
80 80 args = self.dir(), self.energy(), self.time(), self.mc_id()
81 81 return args
82 82 def __setstate__(self, state):
83   - self.__init__()
84   - self.dir(state[0])
85   - self.energy(state[1])
86   - self.time(state[2])
87   - self.mc_id(state[3])
  83 + self.__init__(state[0], state[1], state[2], state[3])
88 84 }
89 85 };
... ...
pyext/GPhotons.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GPhotons.i - Photon container class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2012-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2012-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -117,4 +117,14 @@ public:
117 117 GPhotons copy() {
118 118 return (*self);
119 119 }
  120 +%pythoncode {
  121 + def __getstate__(self):
  122 + state = tuple([x for x in self]),
  123 + return state
  124 + def __setstate__(self, state):
  125 + self.__init__()
  126 + self.reserve(len(state[0]))
  127 + for x in state[0]:
  128 + self.append(x)
  129 +}
120 130 };
... ...
pyext/GSkyDir.i
  View file @7364643
... ... @@ -84,8 +84,8 @@ public:
84 84 }
85 85 %pythoncode {
86 86 def __getstate__(self):
87   - args = self.ra(), self.dec()
88   - return args
  87 + state = self.ra(), self.dec()
  88 + return state
89 89 def __setstate__(self, state):
90 90 self.__init__()
91 91 self.radec(state[0], state[1])
... ...
pyext/GSource.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GSource.i - Source class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2012-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2012-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -65,4 +65,17 @@ public:
65 65 GSource copy() {
66 66 return (*self);
67 67 }
  68 +%pythoncode {
  69 + def __getstate__(self):
  70 + state = (self.name(), self.model(), self.energy(), self.time())
  71 + return state
  72 + def __setstate__(self, state):
  73 + self.__init__()
  74 + self.name(state[0])
  75 + if state[1] != None:
  76 + self.__model = state[1].copy() ## Store a copy
  77 + self.model(self.__model)
  78 + self.energy(state[2])
  79 + self.time(state[3])
  80 +}
68 81 };
... ...
pyext/GTime.i
  View file @7364643
... ... @@ -124,10 +124,10 @@ public:
124 124 }
125 125 %pythoncode {
126 126 def __getstate__(self):
127   - args = self.secs()
128   - return args
  127 + state = self.secs(),
  128 + return state
129 129 def __setstate__(self, state):
130 130 self.__init__()
131   - self.secs(state)
  131 + self.secs(state[0])
132 132 }
133 133 };
... ...
pyext/GTimeReference.i
  View file @7364643
... ... @@ -87,8 +87,8 @@ public:
87 87 }
88 88 %pythoncode {
89 89 def __getstate__(self):
90   - args = (self.mjdref(), self.timeunit(), self.timesys(), self.timeref())
91   - return args
  90 + state = (self.mjdref(), self.timeunit(), self.timesys(), self.timeref())
  91 + return state
92 92 def __setstate__(self, state):
93 93 self.__init__(state[0], state[1], state[2], state[3])
94 94 }
... ...
pyext/GTimes.i
  View file @7364643
... ... @@ -121,12 +121,12 @@ public:
121 121 }
122 122 %pythoncode {
123 123 def __getstate__(self):
124   - args = tuple([x for x in self])
125   - return args
  124 + state = tuple([x for x in self]),
  125 + return state
126 126 def __setstate__(self, state):
127 127 self.__init__()
128   - self.reserve(len(state))
129   - for x in state:
  128 + self.reserve(len(state[0]))
  129 + for x in state[0]:
130 130 self.append(x)
131 131 }
132 132 };
... ...
pyext/GXml.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXml.i - XML class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -42,30 +42,33 @@ public:
42 42 GXml(void);
43 43 GXml(const GXml& xml);
44 44 explicit GXml(const std::string& filename);
  45 + explicit GXml(const GXmlDocument& root);
45 46 virtual ~GXml(void);
46 47  
47 48 // Methods
48   - void clear(void);
49   - GXml* clone(void) const;
50   - std::string classname(void) const;
51   - int size(void) const;
52   - bool is_empty(void) const;
53   - GXmlNode* set(const int& index, const GXmlNode& node);
54   - GXmlNode* append(const GXmlNode& node);
55   - GXmlElement* append(const std::string& segment);
56   - GXmlNode* insert(const int& index, const GXmlNode& node);
57   - void remove(const int& index);
58   - void reserve(const int& num);
59   - void extend(const GXmlNode& node);
60   - int elements(void) const;
61   - int elements(const std::string& name) const;
62   - GXmlElement* element(const int& index);
63   - GXmlElement* element(const std::string& name);
64   - GXmlElement* element(const std::string& name, const int& index);
65   - void load(const GFilename& filename);
66   - void save(const GFilename& filename) const;
67   - void read(const GUrl& url);
68   - void write(GUrl& url, const int& indent = 0) const;
  49 + void clear(void);
  50 + GXml* clone(void) const;
  51 + std::string classname(void) const;
  52 + int size(void) const;
  53 + bool is_empty(void) const;
  54 + GXmlNode* set(const int& index, const GXmlNode& node);
  55 + GXmlNode* append(const GXmlNode& node);
  56 + GXmlElement* append(const std::string& segment);
  57 + GXmlNode* insert(const int& index, const GXmlNode& node);
  58 + void remove(const int& index);
  59 + void reserve(const int& num);
  60 + void extend(const GXmlNode& node);
  61 + int elements(void) const;
  62 + int elements(const std::string& name) const;
  63 + GXmlElement* element(const int& index);
  64 + GXmlElement* element(const std::string& name);
  65 + GXmlElement* element(const std::string& name, const int& index);
  66 + const GXmlDocument& root(void) const;
  67 + void root(const GXmlDocument& root);
  68 + void load(const GFilename& filename);
  69 + void save(const GFilename& filename) const;
  70 + void read(const GUrl& url);
  71 + void write(GUrl& url, const int& indent = 0) const;
69 72 };
70 73  
71 74  
... ... @@ -131,4 +134,11 @@ public:
131 134 GXml copy() {
132 135 return (*self);
133 136 }
  137 +%pythoncode {
  138 + def __getstate__(self):
  139 + state = (self.root(),)
  140 + return state
  141 + def __setstate__(self, state):
  142 + self.__init__(state[0])
  143 +}
134 144 };
... ...
pyext/GXmlAttribute.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlAttribute.i - XML attribute class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -61,4 +61,11 @@ public:
61 61 GXmlAttribute copy() {
62 62 return (*self);
63 63 }
  64 +%pythoncode {
  65 + def __getstate__(self):
  66 + state = (self.name(), self.value())
  67 + return state
  68 + def __setstate__(self, state):
  69 + self.__init__(state[0], state[1])
  70 +}
64 71 };
... ...
pyext/GXmlComment.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlComment.i - XML comment node class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -62,4 +62,12 @@ public:
62 62 GXmlComment copy() {
63 63 return (*self);
64 64 }
  65 +%pythoncode {
  66 + def __getstate__(self):
  67 + state = (self.comment(),)
  68 + return state
  69 + def __setstate__(self, state):
  70 + self.__init__()
  71 + self.comment(state[0])
  72 +}
65 73 };
... ...
pyext/GXmlDocument.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlDocument.i - XML document node class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -38,6 +38,10 @@ class GXmlDocument : public GXmlNode {
38 38 public:
39 39 // Constructors and destructors
40 40 GXmlDocument(void);
  41 + GXmlDocument(const GFilename& filename,
  42 + const std::string& version,
  43 + const std::string& encoding,
  44 + const std::string& standalone);
41 45 GXmlDocument(const GXmlDocument& node);
42 46 virtual ~GXmlDocument(void);
43 47  
... ... @@ -67,4 +71,15 @@ public:
67 71 GXmlDocument copy() {
68 72 return (*self);
69 73 }
  74 +%pythoncode {
  75 + def __getstate__(self):
  76 + state = (self.filename(), self.version(), self.encoding(), self.standalone())
  77 + return state
  78 + def __setstate__(self, state):
  79 + self.__init__()
  80 + self.filename(state[0])
  81 + self.version(state[1])
  82 + self.encoding(state[2])
  83 + self.standalone(state[3])
  84 +}
70 85 };
... ...
pyext/GXmlElement.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlElement.i - XML element node class definition *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -48,6 +48,8 @@ public:
48 48 virtual std::string classname(void) const;
49 49 const std::string& name(void) const;
50 50 void name(const std::string& name);
  51 + int attributes(void) const;
  52 + const GXmlAttribute* attribute(const int& index) const;
51 53 std::string attribute(const std::string& name) const;
52 54 void attribute(const std::string& name, const std::string& value);
53 55 bool has_attribute(const std::string& name) const;
... ... @@ -119,4 +121,18 @@ public:
119 121 GXmlElement copy() {
120 122 return (*self);
121 123 }
  124 +%pythoncode {
  125 + def __getstate__(self):
  126 + state = (gammalib.GXmlNode.__getstate__(self), self.name(),
  127 + tuple([self.attribute(i) for i in range(self.attributes())]))
  128 + return state
  129 + def __setstate__(self, state):
  130 + gammalib.GXmlNode.__setstate__(self, state[0])
  131 + self.__init__()
  132 + self.name(state[1])
  133 + for i in range(len(state[2])):
  134 + name = state[2][i].name()
  135 + value = state[2][i].value()
  136 + self.attribute(name, value)
  137 +}
122 138 };
... ...
pyext/GXmlNode.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlNode.i - Abstract XML node base class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -114,4 +114,16 @@ public:
114 114 throw GException::out_of_range("__setitem__(int)", index, self->size());
115 115 }
116 116 }
  117 +%pythoncode {
  118 + def __getstate__(self):
  119 + state = (self.parent(), tuple([x for x in self]))
  120 + return state
  121 + def __setstate__(self, state):
  122 + self.__init__()
  123 + self.reserve(len(state[1]))
  124 + if state[0] != None:
  125 + self.parent(state[0])
  126 + for x in state[1]:
  127 + self.append(x)
  128 +}
117 129 };
... ...
pyext/GXmlPI.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlPI.i - XML PI node class definition *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -62,4 +62,12 @@ public:
62 62 GXmlPI copy() {
63 63 return (*self);
64 64 }
  65 +%pythoncode {
  66 + def __getstate__(self):
  67 + state = (self.pi(),)
  68 + return state
  69 + def __setstate__(self, state):
  70 + self.__init__()
  71 + self.pi(state[0])
  72 +}
65 73 };
... ...
pyext/GXmlText.i
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlText.i - XML text node class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2015 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -62,4 +62,11 @@ public:
62 62 GXmlText copy() {
63 63 return (*self);
64 64 }
  65 +%pythoncode {
  66 + def __getstate__(self):
  67 + state = (self.text(),)
  68 + return state
  69 + def __setstate__(self, state):
  70 + self.__init__(state[0])
  71 +}
65 72 };
... ...
pyext/gammalib/model.i
  View file @7364643
1 1 /***************************************************************************
2 2 * model.i - Model module *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2011-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2011-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -76,52 +76,70 @@
76 76 $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
77 77 }
78 78 %typemap(out) GModelSpatial* {
79   - char classname[80];
80   - strcpy(classname, "_p_");
81   - strcat(classname, result->classname().c_str());
82   - swig_type_info *myinfo = SWIGTYPE_p_GModelSpatial;
83   - swig_cast_info *mycast = 0;
84   - mycast = myinfo->cast;
85   - while (mycast != 0) {
86   - if (strcmp(classname, mycast->type->name) == 0) {
87   - myinfo = mycast->type;
88   - break;
  79 + if ($1 == NULL) {
  80 + $result = Py_None;
  81 + Py_INCREF(Py_None); // Py_None is a singleton so increment its reference
  82 + }
  83 + else {
  84 + char classname[80];
  85 + strcpy(classname, "_p_");
  86 + strcat(classname, result->classname().c_str());
  87 + swig_type_info *myinfo = SWIGTYPE_p_GModelSpatial;
  88 + swig_cast_info *mycast = 0;
  89 + mycast = myinfo->cast;
  90 + while (mycast != 0) {
  91 + if (strcmp(classname, mycast->type->name) == 0) {
  92 + myinfo = mycast->type;
  93 + break;
  94 + }
  95 + mycast = mycast->next;
89 96 }
90   - mycast = mycast->next;
  97 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
91 98 }
92   - $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
93 99 }
94 100 %typemap(out) GModelSpectral* {
95   - char classname[80];
96   - strcpy(classname, "_p_");
97   - strcat(classname, result->classname().c_str());
98   - swig_type_info *myinfo = SWIGTYPE_p_GModelSpectral;
99   - swig_cast_info *mycast = 0;
100   - mycast = myinfo->cast;
101   - while (mycast != 0) {
102   - if (strcmp(classname, mycast->type->name) == 0) {
103   - myinfo = mycast->type;
104   - break;
  101 + if ($1 == NULL) {
  102 + $result = Py_None;
  103 + Py_INCREF(Py_None); // Py_None is a singleton so increment its reference
  104 + }
  105 + else {
  106 + char classname[80];
  107 + strcpy(classname, "_p_");
  108 + strcat(classname, result->classname().c_str());
  109 + swig_type_info *myinfo = SWIGTYPE_p_GModelSpectral;
  110 + swig_cast_info *mycast = 0;
  111 + mycast = myinfo->cast;
  112 + while (mycast != 0) {
  113 + if (strcmp(classname, mycast->type->name) == 0) {
  114 + myinfo = mycast->type;
  115 + break;
  116 + }
  117 + mycast = mycast->next;
105 118 }
106   - mycast = mycast->next;
  119 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
107 120 }
108   - $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
109 121 }
110 122 %typemap(out) GModelTemporal* {
111   - char classname[80];
112   - strcpy(classname, "_p_");
113   - strcat(classname, result->classname().c_str());
114   - swig_type_info *myinfo = SWIGTYPE_p_GModelTemporal;
115   - swig_cast_info *mycast = 0;
116   - mycast = myinfo->cast;
117   - while (mycast != 0) {
118   - if (strcmp(classname, mycast->type->name) == 0) {
119   - myinfo = mycast->type;
120   - break;
  123 + if ($1 == NULL) {
  124 + $result = Py_None;
  125 + Py_INCREF(Py_None); // Py_None is a singleton so increment its reference
  126 + }
  127 + else {
  128 + char classname[80];
  129 + strcpy(classname, "_p_");
  130 + strcat(classname, result->classname().c_str());
  131 + swig_type_info *myinfo = SWIGTYPE_p_GModelTemporal;
  132 + swig_cast_info *mycast = 0;
  133 + mycast = myinfo->cast;
  134 + while (mycast != 0) {
  135 + if (strcmp(classname, mycast->type->name) == 0) {
  136 + myinfo = mycast->type;
  137 + break;
  138 + }
  139 + mycast = mycast->next;
121 140 }
122   - mycast = mycast->next;
  141 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
123 142 }
124   - $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
125 143 }
126 144 %typemap(out) GSkyRegion* {
127 145 char classname[80];
... ... @@ -183,6 +201,7 @@
183 201 %include "GModelSpectralPlawPhotonFlux.i"
184 202 %include "GModelSpectralPlawEnergyFlux.i"
185 203 %include "GModelSpectralComposite.i"
  204 +%include "GModelSpectralMultiplicative.i"
186 205 %include "GModelTemporal.i"
187 206 %include "GModelTemporalRegistry.i"
188 207 %include "GModelTemporalConst.i"
... ...
pyext/gammalib/obs.i
  View file @7364643
... ... @@ -151,6 +151,28 @@
151 151 }
152 152 $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
153 153 }
  154 +%typemap(out) GModelSpatial* {
  155 + if ($1 == NULL) {
  156 + $result = Py_None;
  157 + Py_INCREF(Py_None); // Py_None is a singleton so increment its reference
  158 + }
  159 + else {
  160 + char classname[80];
  161 + strcpy(classname, "_p_");
  162 + strcat(classname, result->classname().c_str());
  163 + swig_type_info *myinfo = SWIGTYPE_p_GModelSpatial;
  164 + swig_cast_info *mycast = 0;
  165 + mycast = myinfo->cast;
  166 + while (mycast != 0) {
  167 + if (strcmp(classname, mycast->type->name) == 0) {
  168 + myinfo = mycast->type;
  169 + break;
  170 + }
  171 + mycast = mycast->next;
  172 + }
  173 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
  174 + }
  175 +}
154 176  
155 177 /* __ Observation handling _______________________________________________ */
156 178 %include "GEnergy.i"
... ...
pyext/gammalib/xml.i
  View file @7364643
1 1 /***************************************************************************
2 2 * xml.i - XML module *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2011-2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2011-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -52,20 +52,26 @@
52 52  
53 53 /* __ Typemaps ___________________________________________________________ */
54 54 %typemap(out) GXmlNode* {
55   - char classname[80];
56   - strcpy(classname, "_p_");
57   - strcat(classname, result->classname().c_str());
58   - swig_type_info *myinfo = SWIGTYPE_p_GXmlNode;
59   - swig_cast_info *mycast = 0;
60   - mycast = myinfo->cast;
61   - while (mycast != 0) {
62   - if (strcmp(classname, mycast->type->name) == 0) {
63   - myinfo = mycast->type;
64   - break;
  55 + if ($1 == NULL) {
  56 + $result = Py_None;
  57 + Py_INCREF(Py_None); // Py_None is a singleton so increment its reference
  58 + }
  59 + else {
  60 + char classname[80];
  61 + strcpy(classname, "_p_");
  62 + strcat(classname, result->classname().c_str());
  63 + swig_type_info *myinfo = SWIGTYPE_p_GXmlNode;
  64 + swig_cast_info *mycast = 0;
  65 + mycast = myinfo->cast;
  66 + while (mycast != 0) {
  67 + if (strcmp(classname, mycast->type->name) == 0) {
  68 + myinfo = mycast->type;
  69 + break;
  70 + }
  71 + mycast = mycast->next;
65 72 }
66   - mycast = mycast->next;
  73 + $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
67 74 }
68   - $result = SWIG_NewPointerObj(SWIG_as_voidptr($1), myinfo, 0 | 0);
69 75 }
70 76  
71 77 /* __ XML module _________________________________________________________ */
... ...
src/model/GModelSpatialComposite.cpp
  View file @7364643
... ... @@ -381,15 +381,23 @@ void GModelSpatialComposite::read(const GXmlElement&amp; xml)
381 381 }
382 382 }
383 383  
384   - // If there is a "scale_min" attribute set the minimum accordingly
  384 + // If there is a "scale_min" attribute set the minimum accordingly;
  385 + // otherwise remove minimum
385 386 if (spec->has_attribute("scale_min")) {
386 387 scale.min(gammalib::todouble(spec->attribute("scale_min")));
387 388 }
  389 + else {
  390 + scale.remove_min();
  391 + }
388 392  
389   - // If there is a "scale_max" attribute set the maximum accordingly
  393 + // If there is a "scale_max" attribute set the maximum accordingly;
  394 + // otherwise remove maximum
390 395 if (spec->has_attribute("scale_max")) {
391 396 scale.max(gammalib::todouble(spec->attribute("scale_max")));
392 397 }
  398 + else {
  399 + scale.remove_max();
  400 + }
393 401  
394 402 } // endif: there was a scale attribute
395 403  
... ... @@ -505,8 +513,12 @@ void GModelSpatialComposite::write(GXmlElement&amp; xml) const
505 513 if (m_scales[i]->is_free()) {
506 514 matching_model->attribute("scale_error",
507 515 gammalib::str(m_scales[i]->error()));
  516 + }
  517 + if (m_scales[i]->has_min()) {
508 518 matching_model->attribute("scale_min",
509 519 gammalib::str(m_scales[i]->min()));
  520 + }
  521 + if (m_scales[i]->has_max()) {
510 522 matching_model->attribute("scale_max",
511 523 gammalib::str(m_scales[i]->max()));
512 524 }
... ...
src/model/GModelSpectralFunc.cpp
  View file @7364643
... ... @@ -823,62 +823,67 @@ void GModelSpectralFunc::load_nodes(const GFilename&amp; filename)
823 823 // Set filename
824 824 m_filename = filename;
825 825  
826   - // Load file
827   - GCsv csv = GCsv(filename.url());
  826 + // Continue only if filename is not empty
  827 + if (!filename.is_empty()) {
828 828  
829   - // Check if there are at least 2 nodes
830   - if (csv.nrows() < 2) {
831   - throw GException::file_function_data(G_LOAD_NODES, filename.url(),
832   - csv.nrows());
833   - }
834   -
835   - // Check if there are at least 2 columns
836   - if (csv.ncols() < 2) {
837   - throw GException::file_function_columns(G_LOAD_NODES, filename.url(),
838   - csv.ncols());
839   - }
  829 + // Load file
  830 + GCsv csv = GCsv(filename.url());
840 831  
841   - // Setup nodes
842   - double last_energy = 0.0;
843   - for (int i = 0; i < csv.nrows(); ++i) {
844   -
845   - // Get log10 of node energy and value. Make sure they are valid.
846   - double log10energy;
847   - double log10value;
848   - if (csv.real(i,0) > 0) {
849   - log10energy = std::log10(csv.real(i,0));
850   - }
851   - else {
852   - throw GException::file_function_value(G_LOAD_NODES, filename.url(),
853   - csv.real(i,0), "Energy value must be positive.");
854   - }
855   - if (csv.real(i,1) > 0) {
856   - log10value = std::log10(csv.real(i,1));
857   - }
858   - else {
859   - throw GException::file_function_value(G_LOAD_NODES, filename.url(),
860   - csv.real(i,1), "Intensity value must be positive.");
  832 + // Check if there are at least 2 nodes
  833 + if (csv.nrows() < 2) {
  834 + throw GException::file_function_data(G_LOAD_NODES, filename.url(),
  835 + csv.nrows());
861 836 }
862 837  
863   - // Make sure that energies are increasing
864   - if (csv.real(i,0) <= last_energy) {
865   - throw GException::file_function_value(G_LOAD_NODES, filename.url(),
866   - csv.real(i,0), "Energy values must be monotonically increasing.");
  838 + // Check if there are at least 2 columns
  839 + if (csv.ncols() < 2) {
  840 + throw GException::file_function_columns(G_LOAD_NODES, filename.url(),
  841 + csv.ncols());
867 842 }
868 843  
869   - // Append log10 of node energy and value
870   - m_lin_nodes.append(csv.real(i,0));
871   - m_log_nodes.append(log10energy);
872   - m_lin_values.push_back(csv.real(i,1));
873   - m_log_values.push_back(log10value);
  844 + // Setup nodes
  845 + double last_energy = 0.0;
  846 + for (int i = 0; i < csv.nrows(); ++i) {
  847 +
  848 + // Get log10 of node energy and value. Make sure they are valid.
  849 + double log10energy;
  850 + double log10value;
  851 + if (csv.real(i,0) > 0) {
  852 + log10energy = std::log10(csv.real(i,0));
  853 + }
  854 + else {
  855 + throw GException::file_function_value(G_LOAD_NODES, filename.url(),
  856 + csv.real(i,0), "Energy value must be positive.");
  857 + }
  858 + if (csv.real(i,1) > 0) {
  859 + log10value = std::log10(csv.real(i,1));
  860 + }
  861 + else {
  862 + throw GException::file_function_value(G_LOAD_NODES, filename.url(),
  863 + csv.real(i,1), "Intensity value must be positive.");
  864 + }
  865 +
  866 + // Make sure that energies are increasing
  867 + if (csv.real(i,0) <= last_energy) {
  868 + throw GException::file_function_value(G_LOAD_NODES, filename.url(),
  869 + csv.real(i,0), "Energy values must be monotonically increasing.");
  870 + }
  871 +
  872 + // Append log10 of node energy and value
  873 + m_lin_nodes.append(csv.real(i,0));
  874 + m_log_nodes.append(log10energy);
  875 + m_lin_values.push_back(csv.real(i,1));
  876 + m_log_values.push_back(log10value);
  877 +
  878 + // Store last energy for monotonically increasing check
  879 + last_energy = csv.real(i,0);
874 880  
875   - // Store last energy for monotonically increasing check
876   - last_energy = csv.real(i,0);
  881 + } // endfor: looped over nodes
877 882  
878   - } // endfor: looped over nodes
  883 + // Set pre-computation cache
  884 + set_cache();
879 885  
880   - // Set pre-computation cache
881   - set_cache();
  886 + } // endif: filename was not empty
882 887  
883 888 // Return
884 889 return;
... ...
src/model/GModelTemporalLightCurve.cpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelTemporalLightCurve.cpp - Temporal light curve model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2017-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -601,86 +601,91 @@ void GModelTemporalLightCurve::load_nodes(const GFilename&amp; filename)
601 601 // Set filename
602 602 m_filename = filename;
603 603  
604   - // Load FITS file
605   - GFits fits = GFits(filename);
  604 + // Continue only if filename is not empty
  605 + if (!filename.is_empty()) {
606 606  
607   - // Extract binary table (so far always load extension 1 as table)
608   - GFitsTable* table = fits.table(1);
  607 + // Load FITS file
  608 + GFits fits = GFits(filename);
609 609  
610   - // Read time reference from binary table
611   - m_timeref.read(*table);
  610 + // Extract binary table (so far always load extension 1 as table)
  611 + GFitsTable* table = fits.table(1);
612 612  
613   - // Extract columns
614   - GFitsTableCol* time_col = (*table)["TIME"];
615   - GFitsTableCol* norm_col = (*table)["NORM"];
  613 + // Read time reference from binary table
  614 + m_timeref.read(*table);
616 615  
617   - // Check that there are at least two nodes in table
618   - if (time_col->nrows() < 2) {
619   - std::string msg = "\"TIME\" column contains "+
620   - gammalib::str(time_col->nrows())+" rows but at "
621   - "least two rows are required. Please specify a valid "
622   - "temporal file function.";
623   - throw GException::invalid_value(G_LOAD_NODES, msg);
624   - }
625   -
626   - // Check that both columns are consistent
627   - if (time_col->nrows() != norm_col->nrows()) {
628   - std::string msg = "\"TIME\" and \"NORM\" columns have inconsistent "
629   - "number of rows ("+
630   - gammalib::str(time_col->nrows())+", "+
631   - gammalib::str(norm_col->nrows())+"). Please "
632   - "specify a valid temporal file function.";
633   - throw GException::invalid_value(G_LOAD_NODES, msg);
634   - }
  616 + // Extract columns
  617 + GFitsTableCol* time_col = (*table)["TIME"];
  618 + GFitsTableCol* norm_col = (*table)["NORM"];
635 619  
636   - // Set number of nodes
637   - int nodes = time_col->nrows();
638   -
639   - // Check that time values are in ascending order and that no node is
640   - // larger than 1
641   - double last_time = -1.0;
642   - for (int i = 0; i < nodes; ++i) {
643   -
644   - // Check if time has increased
645   - if (last_time >= 0.0 && time_col->real(i) <= last_time) {
646   - std::string msg = "Time "+gammalib::str(time_col->real(i))+
647   - " in row "+gammalib::str(i+1)+" of \"TIME\" "
648   - "column is equal to or smaller than preceeding "
649   - "value. Please provide a light curve file with "
650   - "monotonically increasing times.";
  620 + // Check that there are at least two nodes in table
  621 + if (time_col->nrows() < 2) {
  622 + std::string msg = "\"TIME\" column contains "+
  623 + gammalib::str(time_col->nrows())+" rows but at "
  624 + "least two rows are required. Please specify a valid "
  625 + "temporal file function.";
651 626 throw GException::invalid_value(G_LOAD_NODES, msg);
652 627 }
653 628  
654   - // Check if value is smaller than maximum allowed normalisation
655   - if (norm_col->real(i) > max_norm) {
656   - std::string msg = "Value "+gammalib::str(norm_col->real(i))+" at "
657   - "time "+gammalib::str(time_col->real(i))+" is "
658   - "larger than 1. Please provide a light curve file "
659   - "with normalizations not exceeding 1.";
  629 + // Check that both columns are consistent
  630 + if (time_col->nrows() != norm_col->nrows()) {
  631 + std::string msg = "\"TIME\" and \"NORM\" columns have inconsistent "
  632 + "number of rows ("+
  633 + gammalib::str(time_col->nrows())+", "+
  634 + gammalib::str(norm_col->nrows())+"). Please "
  635 + "specify a valid temporal file function.";
660 636 throw GException::invalid_value(G_LOAD_NODES, msg);
661 637 }
  638 +
  639 + // Set number of nodes
  640 + int nodes = time_col->nrows();
  641 +
  642 + // Check that time values are in ascending order and that no node is
  643 + // larger than 1
  644 + double last_time = -1.0;
  645 + for (int i = 0; i < nodes; ++i) {
  646 +
  647 + // Check if time has increased
  648 + if (last_time >= 0.0 && time_col->real(i) <= last_time) {
  649 + std::string msg = "Time "+gammalib::str(time_col->real(i))+
  650 + " in row "+gammalib::str(i+1)+" of \"TIME\" "
  651 + "column is equal to or smaller than preceeding "
  652 + "value. Please provide a light curve file with "
  653 + "monotonically increasing times.";
  654 + throw GException::invalid_value(G_LOAD_NODES, msg);
  655 + }
  656 +
  657 + // Check if value is smaller than maximum allowed normalisation
  658 + if (norm_col->real(i) > max_norm) {
  659 + std::string msg = "Value "+gammalib::str(norm_col->real(i))+" at "
  660 + "time "+gammalib::str(time_col->real(i))+" is "
  661 + "larger than 1. Please provide a light curve file "
  662 + "with normalizations not exceeding 1.";
  663 + throw GException::invalid_value(G_LOAD_NODES, msg);
  664 + }
662 665  
663   - } // endfor: looped over nodes
  666 + } // endfor: looped over nodes
664 667  
665   - // Extract nodes
666   - for (int i = 0; i < nodes; ++i) {
667   - m_nodes.append(time_col->real(i));
668   - m_values.push_back(norm_col->real(i));
669   - }
  668 + // Extract nodes
  669 + for (int i = 0; i < nodes; ++i) {
  670 + m_nodes.append(time_col->real(i));
  671 + m_values.push_back(norm_col->real(i));
  672 + }
670 673  
671   - // Make sure that no node exceeds 1
672   - for (int i = 0; i < m_values.size(); ++i) {
673   - if (m_values[i] > 1.0) {
674   - m_values[i] = 1.0;
  674 + // Make sure that no node exceeds 1
  675 + for (int i = 0; i < m_values.size(); ++i) {
  676 + if (m_values[i] > 1.0) {
  677 + m_values[i] = 1.0;
  678 + }
675 679 }
676   - }
677 680  
678   - // Set minimum and maximum times (assumes that times are ordered)
679   - m_tmin.set(time_col->real(0), m_timeref);
680   - m_tmax.set(time_col->real(time_col->nrows()-1), m_timeref);
  681 + // Set minimum and maximum times (assumes that times are ordered)
  682 + m_tmin.set(time_col->real(0), m_timeref);
  683 + m_tmax.set(time_col->real(time_col->nrows()-1), m_timeref);
  684 +
  685 + // Close FITS file
  686 + fits.close();
681 687  
682   - // Close FITS file
683   - fits.close();
  688 + } // endif: filename was not empty
684 689  
685 690 // Return
686 691 return;
... ...
src/model/GModelTemporalPhaseCurve.cpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GModelTemporalPhaseCurve.cpp - Temporal phase curve model class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2017 by Juergen Knoedlseder *
  4 + * copyright (C) 2017-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -764,109 +764,114 @@ void GModelTemporalPhaseCurve::load_nodes(const GFilename&amp; filename)
764 764 // Set filename
765 765 m_filename = filename;
766 766  
767   - // Load FITS file
768   - GFits fits = GFits(filename);
  767 + // Continue only if filename is not empty
  768 + if (!filename.is_empty()) {
769 769  
770   - // Extract binary table (so far always load extension 1 as table)
771   - GFitsTable* table = fits.table(1);
  770 + // Load FITS file
  771 + GFits fits = GFits(filename);
772 772  
773   - // Extract columns
774   - GFitsTableCol* phase_col = (*table)["PHASE"];
775   - GFitsTableCol* norm_col = (*table)["NORM"];
  773 + // Extract binary table (so far always load extension 1 as table)
  774 + GFitsTable* table = fits.table(1);
776 775  
777   - // Check that there are at least two nodes in table
778   - if (phase_col->nrows() < 2) {
779   - std::string msg = "\"PHASE\" column contains "+
780   - gammalib::str(phase_col->nrows())+" rows but at "
781   - "least two rows are required. Please specify a valid "
782   - "phase curve file.";
783   - throw GException::invalid_value(G_LOAD_NODES, msg);
784   - }
785   -
786   - // Check that both columns are consistent
787   - if (phase_col->nrows() != norm_col->nrows()) {
788   - std::string msg = "\"PHASE\" and \"NORM\" columns have inconsistent "
789   - "number of rows ("+
790   - gammalib::str(phase_col->nrows())+", "+
791   - gammalib::str(norm_col->nrows())+"). Please "
792   - "specify a valid phase curve file.";
793   - throw GException::invalid_value(G_LOAD_NODES, msg);
794   - }
  776 + // Extract columns
  777 + GFitsTableCol* phase_col = (*table)["PHASE"];
  778 + GFitsTableCol* norm_col = (*table)["NORM"];
795 779  
796   - // Set number of nodes
797   - int nodes = phase_col->nrows();
798   -
799   - // Check that phase values are in ascending order and comprised between
800   - // 0 and 1, and that no node is larger than 1
801   - double last_phase = -1.0;
802   - for (int i = 0; i < nodes; ++i) {
803   -
804   - // Check if phase has increased
805   - if (last_phase >= 0.0 && phase_col->real(i) <= last_phase) {
806   - std::string msg = "Phase value "+gammalib::str(phase_col->real(i))+
807   - " in row "+gammalib::str(i+1)+" of \"PHASE\" "
808   - "column is equal to or smaller than preceeding "
809   - "value. Please provide a phase curve file with "
810   - "monotonically increasing phase values.";
  780 + // Check that there are at least two nodes in table
  781 + if (phase_col->nrows() < 2) {
  782 + std::string msg = "\"PHASE\" column contains "+
  783 + gammalib::str(phase_col->nrows())+" rows but at "
  784 + "least two rows are required. Please specify a valid "
  785 + "phase curve file.";
811 786 throw GException::invalid_value(G_LOAD_NODES, msg);
812 787 }
813 788  
814   - // Check if phase is within [0,1]
815   - if (phase_col->real(i) < 0.0 || phase_col->real(i) > 1.0) {
816   - std::string msg = "Phase value "+gammalib::str(phase_col->real(i))+
817   - " outside range [0,1]. Please provide a phase "
818   - "curve file with phase values comprised in the "
819   - "interval [0,1].";
  789 + // Check that both columns are consistent
  790 + if (phase_col->nrows() != norm_col->nrows()) {
  791 + std::string msg = "\"PHASE\" and \"NORM\" columns have inconsistent "
  792 + "number of rows ("+
  793 + gammalib::str(phase_col->nrows())+", "+
  794 + gammalib::str(norm_col->nrows())+"). Please "
  795 + "specify a valid phase curve file.";
820 796 throw GException::invalid_value(G_LOAD_NODES, msg);
821 797 }
822 798  
823   - // Check if value is smaller than maximum allowed normalisation
824   - if (norm_col->real(i) > max_norm) {
825   - std::string msg = "Value "+gammalib::str(norm_col->real(i))+" at "
826   - "phase "+gammalib::str(phase_col->real(i))+" is "
827   - "larger than 1. Please provide a phase curve file "
828   - "with normalizations not exceeding 1.";
829   - throw GException::invalid_value(G_LOAD_NODES, msg);
830   - }
  799 + // Set number of nodes
  800 + int nodes = phase_col->nrows();
  801 +
  802 + // Check that phase values are in ascending order and comprised between
  803 + // 0 and 1, and that no node is larger than 1
  804 + double last_phase = -1.0;
  805 + for (int i = 0; i < nodes; ++i) {
  806 +
  807 + // Check if phase has increased
  808 + if (last_phase >= 0.0 && phase_col->real(i) <= last_phase) {
  809 + std::string msg = "Phase value "+gammalib::str(phase_col->real(i))+
  810 + " in row "+gammalib::str(i+1)+" of \"PHASE\" "
  811 + "column is equal to or smaller than preceeding "
  812 + "value. Please provide a phase curve file with "
  813 + "monotonically increasing phase values.";
  814 + throw GException::invalid_value(G_LOAD_NODES, msg);
  815 + }
  816 +
  817 + // Check if phase is within [0,1]
  818 + if (phase_col->real(i) < 0.0 || phase_col->real(i) > 1.0) {
  819 + std::string msg = "Phase value "+gammalib::str(phase_col->real(i))+
  820 + " outside range [0,1]. Please provide a phase "
  821 + "curve file with phase values comprised in the "
  822 + "interval [0,1].";
  823 + throw GException::invalid_value(G_LOAD_NODES, msg);
  824 + }
  825 +
  826 + // Check if value is smaller than maximum allowed normalisation
  827 + if (norm_col->real(i) > max_norm) {
  828 + std::string msg = "Value "+gammalib::str(norm_col->real(i))+" at "
  829 + "phase "+gammalib::str(phase_col->real(i))+" is "
  830 + "larger than 1. Please provide a phase curve file "
  831 + "with normalizations not exceeding 1.";
  832 + throw GException::invalid_value(G_LOAD_NODES, msg);
  833 + }
831 834  
832   - } // endfor: looped over nodes
833   -
834   - // If first phase is larger than zero then add last node with phase-1 as
835   - // first node. This makes sure that a valid normalization exists for
836   - // phase=0.
837   - if (phase_col->real(0) > 0.0) {
838   - m_nodes.append(phase_col->real(nodes-1)-1.0);
839   - m_values.push_back(norm_col->real(nodes-1));
840   - }
  835 + } // endfor: looped over nodes
  836 +
  837 + // If first phase is larger than zero then add last node with phase-1 as
  838 + // first node. This makes sure that a valid normalization exists for
  839 + // phase=0.
  840 + if (phase_col->real(0) > 0.0) {
  841 + m_nodes.append(phase_col->real(nodes-1)-1.0);
  842 + m_values.push_back(norm_col->real(nodes-1));
  843 + }
841 844  
842   - // Extract nodes
843   - for (int i = 0; i < nodes; ++i) {
844   - m_nodes.append(phase_col->real(i));
845   - m_values.push_back(norm_col->real(i));
846   - }
  845 + // Extract nodes
  846 + for (int i = 0; i < nodes; ++i) {
  847 + m_nodes.append(phase_col->real(i));
  848 + m_values.push_back(norm_col->real(i));
  849 + }
847 850  
848   - // If last node is smaller than one then add first node with phase+1 as
849   - // last node. This makes sure that a valid normalization exists for
850   - // phase=1.
851   - if (phase_col->real(nodes-1) < 1.0) {
852   - m_nodes.append(phase_col->real(0)+1.0);
853   - m_values.push_back(norm_col->real(0));
854   - }
  851 + // If last node is smaller than one then add first node with phase+1 as
  852 + // last node. This makes sure that a valid normalization exists for
  853 + // phase=1.
  854 + if (phase_col->real(nodes-1) < 1.0) {
  855 + m_nodes.append(phase_col->real(0)+1.0);
  856 + m_values.push_back(norm_col->real(0));
  857 + }
855 858  
856   - // Make sure that no node exceeds 1
857   - for (int i = 0; i < m_values.size(); ++i) {
858   - if (m_values[i] > 1.0) {
859   - m_values[i] = 1.0;
  859 + // Make sure that no node exceeds 1
  860 + for (int i = 0; i < m_values.size(); ++i) {
  861 + if (m_values[i] > 1.0) {
  862 + m_values[i] = 1.0;
  863 + }
860 864 }
861   - }
862 865  
863   - // Close FITS file
864   - fits.close();
  866 + // Close FITS file
  867 + fits.close();
865 868  
866   - // Optionally normalize nodes
867   - if (m_normalize) {
868   - normalize_nodes();
869   - }
  869 + // Optionally normalize nodes
  870 + if (m_normalize) {
  871 + normalize_nodes();
  872 + }
  873 +
  874 + } // endif: filename was not empty
870 875  
871 876 // Return
872 877 return;
... ...
src/model/GModels.cpp
  View file @7364643
... ... @@ -416,8 +416,8 @@ GModel* GModels::append(const GModel&amp; model)
416 416 std::string msg =
417 417 "Attempt to append model with name \""+model.name()+"\" to model"
418 418 " container, but a model with the same name exists already at"
419   - " index "+gammalib::str(inx)+" in the container.\n"
420   - "Every model in the model container needs a unique name.";
  419 + " index "+gammalib::str(inx)+" in the container."
  420 + " Every model in the model container needs a unique name.";
421 421 throw GException::invalid_value(G_APPEND, msg);
422 422 }
423 423  
... ...
src/obs/GSource.cpp
  View file @7364643
... ... @@ -203,7 +203,12 @@ std::string GSource::print(const GChatter&amp; chatter) const
203 203 // Build photon string
204 204 result.append("GSource(");
205 205 result.append(m_name);
206   - result.append(", "+m_model->type());
  206 + if (m_model != NULL) {
  207 + result.append(", "+m_model->type());
  208 + }
  209 + else {
  210 + result.append(", None");
  211 + }
207 212 result.append(", E="+m_energy.print(chatter));
208 213 result.append(", MET="+m_time.print(chatter));
209 214 result.append(")");
... ...
src/obs/GTimeReference.cpp
  View file @7364643
... ... @@ -672,7 +672,7 @@ void GTimeReference::init_members(void)
672 672 m_mjdref = 0.0;
673 673 m_timeunit = "secs";
674 674 m_timesys = "TT";
675   - m_timeref = "local";
  675 + m_timeref = "LOCAL";
676 676 m_unit_sec = true;
677 677  
678 678 // Return
... ...
src/xml/GXml.cpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GXml.cpp - XML class *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -123,6 +123,24 @@ GXml::GXml(const std::string&amp; xml)
123 123  
124 124  
125 125 /***********************************************************************//**
  126 + * @brief Document constructor
  127 + *
  128 + * @param[in] root Root document.
  129 + ***************************************************************************/
  130 +GXml::GXml(const GXmlDocument& root)
  131 +{
  132 + // Initialise members
  133 + init_members();
  134 +
  135 + // Set document root
  136 + this->root(root);
  137 +
  138 + // Return
  139 + return;
  140 +}
  141 +
  142 +
  143 +/***********************************************************************//**
126 144 * @brief Destructor
127 145 ***************************************************************************/
128 146 GXml::~GXml(void)
... ...
src/xml/GXmlDocument.cpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlDocument.cpp - XML document node class implementation *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -51,7 +51,7 @@
51 51 ***************************************************************************/
52 52 GXmlDocument::GXmlDocument(void) : GXmlNode()
53 53 {
54   - // Initialise private members for clean destruction
  54 + // Initialise private members
55 55 init_members();
56 56  
57 57 // Return
... ... @@ -60,6 +60,33 @@ GXmlDocument::GXmlDocument(void) : GXmlNode()
60 60  
61 61  
62 62 /***********************************************************************//**
  63 + * @brief Constructor
  64 + *
  65 + * @param[in] filename Filename.
  66 + * @param[in] version Version string.
  67 + * @param[in] encoding Encoding string.
  68 + * @param[in] standalone Standalone string.
  69 + ***************************************************************************/
  70 +GXmlDocument::GXmlDocument(const GFilename& filename,
  71 + const std::string& version,
  72 + const std::string& encoding,
  73 + const std::string& standalone) : GXmlNode()
  74 +{
  75 + // Initialise private members
  76 + init_members();
  77 +
  78 + // Set members
  79 + this->filename(filename);
  80 + this->version(version);
  81 + this->encoding(encoding);
  82 + this->standalone(standalone);
  83 +
  84 + // Return
  85 + return;
  86 +}
  87 +
  88 +
  89 +/***********************************************************************//**
63 90 * @brief Copy constructor
64 91 *
65 92 * @param[in] node XML document.
... ...
src/xml/GXmlElement.cpp
  View file @7364643
1 1 /***************************************************************************
2 2 * GXmlElement.cpp - XML element node class implementation *
3 3 * ----------------------------------------------------------------------- *
4   - * copyright (C) 2010-2016 by Juergen Knoedlseder *
  4 + * copyright (C) 2010-2018 by Juergen Knoedlseder *
5 5 * ----------------------------------------------------------------------- *
6 6 * *
7 7 * This program is free software: you can redistribute it and/or modify *
... ... @@ -35,6 +35,7 @@
35 35 #include "GXmlElement.hpp"
36 36  
37 37 /* __ Method name definitions ____________________________________________ */
  38 +#define G_ATTRIBUTE "GXmlElement::attribute(int&)"
38 39 #define G_PARSE_START "GXmlElement::parse_start(std::string&)"
39 40 #define G_PARSE_STOP "GXmlElement::parse_stop(std::string&)"
40 41 #define G_PARSE_ATTRIBUTE "GXmlElement::parse_attribute(size_t*, "\
... ... @@ -197,6 +198,26 @@ GXmlElement* GXmlElement::clone(void) const
197 198  
198 199  
199 200 /***********************************************************************//**
  201 + * @brief Return attribute
  202 + *
  203 + * @param[in] index Attribute index.
  204 + * @return Pointer to attribute.
  205 + ***************************************************************************/
  206 +const GXmlAttribute* GXmlElement::attribute(const int& index) const
  207 +{
  208 + // Compile option: raise exception if index is out of range
  209 + #if defined(G_RANGE_CHECK)
  210 + if (index < 0 || index >= attributes()) {
  211 + throw GException::out_of_range(G_ATTRIBUTE, index, attributes());
  212 + }
  213 + #endif
  214 +
  215 + // Return pointer to attribute
  216 + return (m_attr[index]);
  217 +}
  218 +
  219 +
  220 +/***********************************************************************//**
200 221 * @brief Return attribute value
201 222 *
202 223 * @param[in] name Attribute name.
... ...
test/test_GModel.py
  View file @7364643
1 1 # ==========================================================================
2 2 # This module performs unit tests for the GammaLib model module
3 3 #
4   -# Copyright (C) 2012-2017 Juergen Knoedlseder
  4 +# Copyright (C) 2012-2018 Juergen Knoedlseder
5 5 #
6 6 # This program is free software: you can redistribute it and/or modify
7 7 # it under the terms of the GNU General Public License as published by
... ... @@ -17,6 +17,7 @@
17 17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18 18 #
19 19 # ==========================================================================
  20 +import os
20 21 import gammalib
21 22 import test_support
22 23  
... ... @@ -106,6 +107,110 @@ class Test(gammalib.GPythonTestSuite):
106 107 # Return
107 108 return
108 109  
  110 + # Test class pickeling
  111 + def _test_pickeling(self):
  112 + """
  113 + Test class pickeling
  114 + """
  115 + # Perform pickeling tests of empty classes
  116 + test_support._pickeling(self, gammalib.GModelPar())
  117 + test_support._pickeling(self, gammalib.GModels())
  118 + test_support._pickeling(self, gammalib.GModelSky())
  119 + test_support._pickeling(self, gammalib.GModelSpatialComposite())
  120 + #test_support._pickeling(self, gammalib.GModelSpatialDiffuseConst())
  121 + #test_support._pickeling(self, gammalib.GModelSpatialDiffuseCube())
  122 + #test_support._pickeling(self, gammalib.GModelSpatialDiffuseMap())
  123 + #test_support._pickeling(self, gammalib.GModelSpatialEllipticalDisk())
  124 + #test_support._pickeling(self, gammalib.GModelSpatialEllipticalGauss())
  125 + test_support._pickeling(self, gammalib.GModelSpatialPointSource())
  126 + #test_support._pickeling(self, gammalib.GModelSpatialRadialDisk())
  127 + #test_support._pickeling(self, gammalib.GModelSpatialRadialGauss())
  128 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileDMBurkert())
  129 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileDMEinasto())
  130 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileDMZhao())
  131 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileGauss())
  132 + #test_support._pickeling(self, gammalib.GModelSpatialRadialShell())
  133 + test_support._pickeling(self, gammalib.GModelSpectralBrokenPlaw())
  134 + test_support._pickeling(self, gammalib.GModelSpectralComposite())
  135 + test_support._pickeling(self, gammalib.GModelSpectralConst())
  136 + test_support._pickeling(self, gammalib.GModelSpectralExpInvPlaw())
  137 + test_support._pickeling(self, gammalib.GModelSpectralExpPlaw())
  138 + test_support._pickeling(self, gammalib.GModelSpectralFunc())
  139 + test_support._pickeling(self, gammalib.GModelSpectralGauss())
  140 + test_support._pickeling(self, gammalib.GModelSpectralLogParabola())
  141 + test_support._pickeling(self, gammalib.GModelSpectralMultiplicative())
  142 + test_support._pickeling(self, gammalib.GModelSpectralNodes())
  143 + test_support._pickeling(self, gammalib.GModelSpectralPlaw())
  144 + test_support._pickeling(self, gammalib.GModelSpectralPlawEnergyFlux())
  145 + test_support._pickeling(self, gammalib.GModelSpectralPlawPhotonFlux())
  146 + test_support._pickeling(self, gammalib.GModelSpectralSmoothBrokenPlaw())
  147 + test_support._pickeling(self, gammalib.GModelSpectralSuperExpPlaw())
  148 + test_support._pickeling(self, gammalib.GModelTemporalConst())
  149 + test_support._pickeling(self, gammalib.GModelTemporalLightCurve())
  150 + test_support._pickeling(self, gammalib.GModelTemporalPhaseCurve())
  151 +
  152 + # Setup for tests
  153 + time = gammalib.GTime(1.0,'sec')
  154 + pivot = gammalib.GEnergy(1.0,'TeV')
  155 + ptsrc = gammalib.GModelSpatialPointSource(1.0,2.0)
  156 + plaw = gammalib.GModelSpectralPlaw(1.0,-2.0,pivot)
  157 + cnst = gammalib.GModelTemporalConst(3.0)
  158 + sky = gammalib.GModelSky(ptsrc, plaw, cnst)
  159 + engs = gammalib.GEnergies(10,pivot,gammalib.GEnergy(10.0,'TeV'))
  160 + spacom = gammalib.GModelSpatialComposite()
  161 + spacom.append(ptsrc, 'Src1')
  162 + spacom.append(ptsrc, 'Src2')
  163 + specom = gammalib.GModelSpectralComposite()
  164 + specom.append(plaw, 'Src1')
  165 + specom.append(plaw, 'Src2')
  166 + spemul = gammalib.GModelSpectralMultiplicative()
  167 + spemul.append(plaw, 'Src1')
  168 + spemul.append(plaw, 'Src2')
  169 + nodes = gammalib.GModelSpectralNodes(plaw, engs)
  170 + fct = gammalib.GFilename(os.environ['TEST_DATA']+'/filefunction.txt')
  171 + lcrv = gammalib.GFilename(os.environ['TEST_DATA']+'/model_temporal_lightcurve.fits')
  172 + pcrv = gammalib.GFilename(os.environ['TEST_DATA']+'/model_temporal_phasecurve.fits')
  173 +
  174 + # Perform pickeling tests of filled classes
  175 + test_support._pickeling(self, gammalib.GModelPar('Par',2.0,5.0))
  176 + test_support._pickeling(self, gammalib.GModels(self._setup_models()))
  177 + test_support._pickeling(self, gammalib.GModelSky(sky))
  178 + test_support._pickeling(self, gammalib.GModelSpatialComposite(spacom))
  179 + #test_support._pickeling(self, gammalib.GModelSpatialDiffuseConst())
  180 + #test_support._pickeling(self, gammalib.GModelSpatialDiffuseCube())
  181 + #test_support._pickeling(self, gammalib.GModelSpatialDiffuseMap())
  182 + #test_support._pickeling(self, gammalib.GModelSpatialEllipticalDisk())
  183 + #test_support._pickeling(self, gammalib.GModelSpatialEllipticalGauss())
  184 + test_support._pickeling(self, gammalib.GModelSpatialPointSource(ptsrc))
  185 + #test_support._pickeling(self, gammalib.GModelSpatialRadialDisk())
  186 + #test_support._pickeling(self, gammalib.GModelSpatialRadialGauss())
  187 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileDMBurkert())
  188 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileDMEinasto())
  189 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileDMZhao())
  190 + #test_support._pickeling(self, gammalib.GModelSpatialRadialProfileGauss())
  191 + #test_support._pickeling(self, gammalib.GModelSpatialRadialShell())
  192 + test_support._pickeling(self, gammalib.GModelSpectralBrokenPlaw(1.0,-2.0,pivot,-2.1))
  193 + test_support._pickeling(self, gammalib.GModelSpectralComposite(specom))
  194 + test_support._pickeling(self, gammalib.GModelSpectralConst(3.0))
  195 + test_support._pickeling(self, gammalib.GModelSpectralExpInvPlaw(1.0,-2.0,pivot,0.9))
  196 + test_support._pickeling(self, gammalib.GModelSpectralExpPlaw(1.0,-2.0,pivot,pivot))
  197 + test_support._pickeling(self, gammalib.GModelSpectralFunc(fct, 2.0))
  198 + test_support._pickeling(self, gammalib.GModelSpectralGauss(1.0,pivot,pivot))
  199 + test_support._pickeling(self, gammalib.GModelSpectralLogParabola(1.0,-2.0,pivot,0.9))
  200 + test_support._pickeling(self, gammalib.GModelSpectralMultiplicative(spemul))
  201 + test_support._pickeling(self, gammalib.GModelSpectralNodes(nodes))
  202 + test_support._pickeling(self, gammalib.GModelSpectralPlaw(plaw))
  203 + test_support._pickeling(self, gammalib.GModelSpectralPlawEnergyFlux(1.0,-2.0,pivot,pivot))
  204 + test_support._pickeling(self, gammalib.GModelSpectralPlawPhotonFlux(1.0,-2.0,pivot,pivot))
  205 + test_support._pickeling(self, gammalib.GModelSpectralSmoothBrokenPlaw(1.0,-2.0,pivot,-2.1,pivot,0.9))
  206 + test_support._pickeling(self, gammalib.GModelSpectralSuperExpPlaw(1.0,-2.0,pivot,pivot,0.9))
  207 + test_support._pickeling(self, gammalib.GModelTemporalConst(cnst))
  208 + test_support._pickeling(self, gammalib.GModelTemporalLightCurve(lcrv, 2.0))
  209 + test_support._pickeling(self, gammalib.GModelTemporalPhaseCurve(pcrv, time, 0.5, 1.0, 1.0, 1.0, 2.0))
  210 +
  211 + # Return
  212 + return
  213 +
109 214 # Set test functions
110 215 def set(self):
111 216 """
... ... @@ -117,6 +222,7 @@ class Test(gammalib.GPythonTestSuite):
117 222 # Append tests
118 223 self.append(self._test_models_access, 'Test GModels model access')
119 224 self.append(self._test_models_slicing, 'Test GModels slicing')
  225 + self.append(self._test_pickeling, 'Test pickeling of "model" classes')
120 226  
121 227 # Return
122 228 return
... ...
test/test_GObservation.py
  View file @7364643
1 1 # ==========================================================================
2 2 # This module performs unit tests for the GammaLib observation module.
3 3 #
4   -# Copyright (C) 2012-2017 Juergen Knoedlseder
  4 +# Copyright (C) 2012-2018 Juergen Knoedlseder
5 5 #
6 6 # This program is free software: you can redistribute it and/or modify
7 7 # it under the terms of the GNU General Public License as published by
... ... @@ -729,6 +729,58 @@ class Test(gammalib.GPythonTestSuite):
729 729 # Return
730 730 return
731 731  
  732 + # Test class pickeling
  733 + def _test_pickeling(self):
  734 + """
  735 + Test class pickeling
  736 + """
  737 + # Perform pickeling tests of empty classes
  738 + #test_support._pickeling(self, gammalib.GCaldb())
  739 + test_support._pickeling(self, gammalib.GEbounds())
  740 + test_support._pickeling(self, gammalib.GEnergy())
  741 + test_support._pickeling(self, gammalib.GEnergies())
  742 + test_support._pickeling(self, gammalib.GGti())
  743 + test_support._pickeling(self, gammalib.GObservations())
  744 + test_support._pickeling(self, gammalib.GPhases())
  745 + test_support._pickeling(self, gammalib.GPhoton())
  746 + test_support._pickeling(self, gammalib.GPhotons())
  747 + test_support._pickeling(self, gammalib.GSource())
  748 + test_support._pickeling(self, gammalib.GTime())
  749 + test_support._pickeling(self, gammalib.GTimes())
  750 + test_support._pickeling(self, gammalib.GTimeReference())
  751 +
  752 + # Setup for tests
  753 + dir = gammalib.GSkyDir()
  754 + emin = gammalib.GEnergy(1.0,'TeV')
  755 + emax = gammalib.GEnergy(100.0,'TeV')
  756 + tmin = gammalib.GTime(1.0,'sec')
  757 + tmax = gammalib.GTime(10.0,'sec')
  758 + model = gammalib.GModelSpatialPointSource()
  759 + photons = gammalib.GPhotons()
  760 + photons.append(gammalib.GPhoton())
  761 + photons.append(gammalib.GPhoton())
  762 + times = gammalib.GTimes()
  763 + times.append(tmin)
  764 + times.append(tmax)
  765 +
  766 + # Perform pickeling tests of filled classes
  767 + #test_support._pickeling(self, gammalib.GCaldb())
  768 + test_support._pickeling(self, gammalib.GEbounds(10, emin, emax))
  769 + test_support._pickeling(self, gammalib.GEnergy(emin))
  770 + test_support._pickeling(self, gammalib.GEnergies(10, emin, emax))
  771 + test_support._pickeling(self, gammalib.GGti(tmin, tmax))
  772 + test_support._pickeling(self, gammalib.GObservations(self._setup_obs()))
  773 + test_support._pickeling(self, gammalib.GPhases(0.3, 0.7))
  774 + test_support._pickeling(self, gammalib.GPhoton(dir, emin, tmin))
  775 + test_support._pickeling(self, gammalib.GPhotons(photons))
  776 + test_support._pickeling(self, gammalib.GSource('Crab', model, emin, tmin))
  777 + test_support._pickeling(self, gammalib.GTime(tmin))
  778 + test_support._pickeling(self, gammalib.GTimes(times))
  779 + test_support._pickeling(self, gammalib.GTimeReference(12.345,'sec','utc','local'))
  780 +
  781 + # Return
  782 + return
  783 +
732 784 # Set test functions
733 785 def set(self):
734 786 """
... ... @@ -751,6 +803,7 @@ class Test(gammalib.GPythonTestSuite):
751 803 self.append(self._test_times_slicing, 'Test GTimes slicing')
752 804 self.append(self._test_photons_slicing, 'Test GPhotons slicing')
753 805 self.append(self._test_observations_slicing, 'Test GObservations slicing')
  806 + self.append(self._test_pickeling, 'Test pickeling of "obs" classes')
754 807  
755 808 # Return
756 809 return
... ...
test/test_GOptimizer.py
  View file @7364643
1 1 # ==========================================================================
2 2 # This module performs unit tests for the GammaLib optimizer module.
3 3 #
4   -# Copyright (C) 2012-2017 Juergen Knoedlseder
  4 +# Copyright (C) 2012-2018 Juergen Knoedlseder
5 5 #
6 6 # This program is free software: you can redistribute it and/or modify
7 7 # it under the terms of the GNU General Public License as published by
... ... @@ -98,17 +98,31 @@ class Test(gammalib.GPythonTestSuite):
98 98 # Return
99 99 return
100 100  
  101 + # Test class pickeling
  102 + def _test_pickeling(self):
  103 + """
  104 + Test class pickeling
  105 + """
  106 + # Perform pickeling tests
  107 + #test_support._pickeling(self, gammalib.GOptimizerLM())
  108 + test_support._pickeling(self, gammalib.GOptimizerPar())
  109 + #test_support._pickeling(self, gammalib.GOptimizerPars())
  110 +
  111 + # Return
  112 + return
  113 +
101 114 # Set test functions
102 115 def set(self):
103 116 """
104   - Set all test functions.
  117 + Set all test functions
105 118 """
106 119 # Set test name
107 120 self.name('opt')
108 121  
109 122 # Append tests
110   - self.append(self._test_pars_access, "Test GOptimizerPars parameter access")
111   - self.append(self._test_pars_slicing, "Test GOptimizerPars slicing")
  123 + self.append(self._test_pars_access, 'Test GOptimizerPars parameter access')
  124 + self.append(self._test_pars_slicing, 'Test GOptimizerPars slicing')
  125 + self.append(self._test_pickeling, 'Test pickeling of "opt" classes')
112 126  
113 127 # Return
114 128 return
... ...
test/test_GSky.py
  View file @7364643
1 1 # ==========================================================================
2 2 # This module performs unit tests for the GammaLib sky module.
3 3 #
4   -# Copyright (C) 2012-2017 Juergen Knoedlseder
  4 +# Copyright (C) 2012-2018 Juergen Knoedlseder
5 5 #
6 6 # This program is free software: you can redistribute it and/or modify
7 7 # it under the terms of the GNU General Public License as published by
... ... @@ -550,30 +550,49 @@ class Test(gammalib.GPythonTestSuite):
550 550 # Return
551 551 return
552 552  
  553 + # Test class pickeling
  554 + def _test_pickeling(self):
  555 + """
  556 + Test class pickeling
  557 + """
  558 + # Perform pickeling tests of empty classes
  559 + test_support._pickeling(self, gammalib.GSkyDir())
  560 +
  561 + # Setup test
  562 + dir = gammalib.GSkyDir()
  563 + dir.lb_deg(1.0, 2.0)
  564 +
  565 + # Perform pickeling tests of filled classes
  566 + test_support._pickeling(self, gammalib.GSkyDir(dir))
  567 +
  568 + # Return
  569 + return
  570 +
553 571 def set(self):
554 572 """
555 573 Set all test functions.
556 574 """
557 575 # Set test name
558   - self.name("sky")
  576 + self.name('sky')
559 577  
560 578 # Append tests
561   - self.append(self._test_methods, "Test sky map methods")
562   - self.append(self._test_friend_methods, "Test sky map friend methods")
563   - self.append(self._test_operators, "Test sky map operators")
564   - self.append(self._test_skymap_healpix, "Test HEALPix map")
565   - self.append(self._test_skymap_ait, "Test AIT projection map")
566   - self.append(self._test_skymap_azp, "Test AZP projection map")
567   - self.append(self._test_skymap_car, "Test CAR projection map")
568   - self.append(self._test_skymap_gls, "Test GLS projection map")
569   - self.append(self._test_skymap_mer, "Test MER projection map")
570   - self.append(self._test_skymap_mol, "Test MOL projection map")
571   - self.append(self._test_skymap_sfl, "Test SFL projection map")
572   - self.append(self._test_skymap_sin, "Test SIN projection map")
573   - self.append(self._test_skymap_stg, "Test STG projection map")
574   - self.append(self._test_skymap_tan, "Test TAN projection map")
575   - self.append(self._test_regions_access, "Test GSkyRegions region access")
576   - self.append(self._test_regions_slicing, "Test GSkyRegions slicing")
  579 + self.append(self._test_methods, 'Test sky map methods')
  580 + self.append(self._test_friend_methods, 'Test sky map friend methods')
  581 + self.append(self._test_operators, 'Test sky map operators')
  582 + self.append(self._test_skymap_healpix, 'Test HEALPix map')
  583 + self.append(self._test_skymap_ait, 'Test AIT projection map')
  584 + self.append(self._test_skymap_azp, 'Test AZP projection map')
  585 + self.append(self._test_skymap_car, 'Test CAR projection map')
  586 + self.append(self._test_skymap_gls, 'Test GLS projection map')
  587 + self.append(self._test_skymap_mer, 'Test MER projection map')
  588 + self.append(self._test_skymap_mol, 'Test MOL projection map')
  589 + self.append(self._test_skymap_sfl, 'Test SFL projection map')
  590 + self.append(self._test_skymap_sin, 'Test SIN projection map')
  591 + self.append(self._test_skymap_stg, 'Test STG projection map')
  592 + self.append(self._test_skymap_tan, 'Test TAN projection map')
  593 + self.append(self._test_regions_access, 'Test GSkyRegions region access')
  594 + self.append(self._test_regions_slicing, 'Test GSkyRegions slicing')
  595 + self.append(self._test_pickeling, 'Test pickeling of "sky" classes')
577 596  
578 597 # Return
579 598 return
... ...
test/test_GSupport.py
  View file @7364643
1 1 # ==========================================================================
2 2 # This module performs unit tests for the GammaLib support module.
3 3 #
4   -# Copyright (C) 2012-2017 Juergen Knoedlseder
  4 +# Copyright (C) 2012-2018 Juergen Knoedlseder
5 5 #
6 6 # This program is free software: you can redistribute it and/or modify
7 7 # it under the terms of the GNU General Public License as published by
... ... @@ -19,6 +19,7 @@
19 19 # ==========================================================================
20 20 import gammalib
21 21 import math
  22 +import test_support
22 23  
23 24  
24 25 # =============================== #
... ... @@ -279,6 +280,34 @@ class Test(gammalib.GPythonTestSuite):
279 280 # Return
280 281 return
281 282  
  283 + # Test class pickeling
  284 + def _test_pickeling(self):
  285 + """
  286 + Test class pickeling
  287 + """
  288 + # Perform pickeling tests of empty classes
  289 + #test_support._pickeling(self, gammalib.GBilinear())
  290 + #test_support._pickeling(self, gammalib.GCsv())
  291 + test_support._pickeling(self, gammalib.GFilename())
  292 + #test_support._pickeling(self, gammalib.GNodeArray())
  293 + #test_support._pickeling(self, gammalib.GRan())
  294 + #test_support._pickeling(self, gammalib.GUrl())
  295 + #test_support._pickeling(self, gammalib.GUrlFile())
  296 + #test_support._pickeling(self, gammalib.GUrlString())
  297 +
  298 + # Perform pickeling tests of filled classes
  299 + #test_support._pickeling(self, gammalib.GBilinear())
  300 + #test_support._pickeling(self, gammalib.GCsv())
  301 + test_support._pickeling(self, gammalib.GFilename('test.fits[URL]'))
  302 + #test_support._pickeling(self, gammalib.GNodeArray())
  303 + #test_support._pickeling(self, gammalib.GRan())
  304 + #test_support._pickeling(self, gammalib.GUrl())
  305 + #test_support._pickeling(self, gammalib.GUrlFile())
  306 + #test_support._pickeling(self, gammalib.GUrlString())
  307 +
  308 + # Return
  309 + return
  310 +
282 311 # Set all test functions
283 312 def set(self):
284 313 """
... ... @@ -295,6 +324,7 @@ class Test(gammalib.GPythonTestSuite):
295 324 self.append(self._test_url_string, 'Test GUrlString')
296 325 self.append(self._test_filename, 'Test GFilename')
297 326 self.append(self._test_csv, 'Test GCsv')
  327 + self.append(self._test_pickeling, 'Test pickeling of "support" classes')
298 328  
299 329 # Return
300 330 return
... ...
test/test_GXml.py
  View file @7364643
1 1 # ==========================================================================
2 2 # This module performs unit tests for the GammaLib xml module.
3 3 #
4   -# Copyright (C) 2012-2017 Juergen Knoedlseder
  4 +# Copyright (C) 2012-2018 Juergen Knoedlseder
5 5 #
6 6 # This program is free software: you can redistribute it and/or modify
7 7 # it under the terms of the GNU General Public License as published by
... ... @@ -157,6 +157,32 @@ class Test(gammalib.GPythonTestSuite):
157 157 # Return
158 158 return
159 159  
  160 + # Test class pickeling
  161 + def _test_pickeling(self):
  162 + """
  163 + Test class pickeling
  164 + """
  165 + # Perform pickeling tests of empty classes
  166 + test_support._pickeling(self, gammalib.GXml())
  167 + test_support._pickeling(self, gammalib.GXmlAttribute())
  168 + test_support._pickeling(self, gammalib.GXmlComment())
  169 + test_support._pickeling(self, gammalib.GXmlDocument())
  170 + test_support._pickeling(self, gammalib.GXmlElement())
  171 + test_support._pickeling(self, gammalib.GXmlPI())
  172 + test_support._pickeling(self, gammalib.GXmlText())
  173 +
  174 + # Perform pickeling tests of filled classes
  175 + test_support._pickeling(self, gammalib.GXml('<?xml version="1.0" standalone="no"?><a>Text</a>'))
  176 + test_support._pickeling(self, gammalib.GXmlAttribute('name','value'))
  177 + test_support._pickeling(self, gammalib.GXmlComment('comment'))
  178 + test_support._pickeling(self, gammalib.GXmlDocument('test.xml','a','b','c'))
  179 + test_support._pickeling(self, gammalib.GXmlElement('a file="x"'))
  180 + test_support._pickeling(self, gammalib.GXmlPI('<?PI?>'))
  181 + test_support._pickeling(self, gammalib.GXmlText('Text'))
  182 +
  183 + # Return
  184 + return
  185 +
160 186 # Set test functions
161 187 def set(self):
162 188 """
... ... @@ -170,6 +196,7 @@ class Test(gammalib.GPythonTestSuite):
170 196 self.append(self._test_xml_slicing, 'Test GXml slicing')
171 197 self.append(self._test_elements_access, 'Test GXmlElement parameter access')
172 198 self.append(self._test_elements_slicing, 'Test GXmlElement slicing')
  199 + self.append(self._test_pickeling, 'Test pickeling of "xml" classes')
173 200  
174 201 # Return
175 202 return
... ...
test/test_support.py
  View file @7364643
1 1 # ==========================================================================
2 2 # This module provides support functions for the Python unit tests
3 3 #
4   -# Copyright (C) 2017 Juergen Knoedlseder
  4 +# Copyright (C) 2017-2018 Juergen Knoedlseder
5 5 #
6 6 # This program is free software: you can redistribute it and/or modify
7 7 # it under the terms of the GNU General Public License as published by
... ... @@ -17,6 +17,7 @@
17 17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
18 18 #
19 19 # ==========================================================================
  20 +import pickle
20 21  
21 22  
22 23 # ============================== #
... ... @@ -235,3 +236,40 @@ def _energy_container_slicing(testsuite, container):
235 236  
236 237 # Return
237 238 return
  239 +
  240 +
  241 +# ============== #
  242 +# Test pickeling #
  243 +# ============== #
  244 +def _pickeling(testsuite, object):
  245 + """
  246 + Test class pickeling
  247 +
  248 + Parameters
  249 + ----------
  250 + testsuite : `~gammalib.GPythonTestSuite`
  251 + Test suite class
  252 + container : `~gammalib.GBase`
  253 + GammaLib class
  254 + """
  255 + # Get class name
  256 + name = object.classname()
  257 +
  258 + # Start exception catching
  259 + testsuite.test_try('Test pickeling of "%s" class.' % name)
  260 +
  261 + # Test if pickling results in an exception
  262 + try:
  263 + dump = pickle.dumps(object)
  264 + obj = pickle.loads(dump)
  265 + dump_again = pickle.dumps(obj)
  266 + testsuite.test_assert(dump == dump_again,
  267 + 'Check pickled dump of "%s\n%s\n%s"' %
  268 + (name, str(object), str(obj)))
  269 + testsuite.test_try_success()
  270 + except Exception as e:
  271 + testsuite.test_try_failure('Error in pickeling "%s" (%s).' %
  272 + (name, str(e)))
  273 +
  274 + # Return
  275 + return
... ...