GammaLib  1.7.0.dev
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
GSkyMap.hpp
Go to the documentation of this file.
1 /***************************************************************************
2  * GSkyMap.hpp - Sky map class *
3  * ----------------------------------------------------------------------- *
4  * copyright (C) 2010-2019 by Juergen Knoedlseder *
5  * ----------------------------------------------------------------------- *
6  * *
7  * This program is free software: you can redistribute it and/or modify *
8  * it under the terms of the GNU General Public License as published by *
9  * the Free Software Foundation, either version 3 of the License, or *
10  * (at your option) any later version. *
11  * *
12  * This program is distributed in the hope that it will be useful, *
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15  * GNU General Public License for more details. *
16  * *
17  * You should have received a copy of the GNU General Public License *
18  * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19  * *
20  ***************************************************************************/
21 /**
22  * @file GSkyMap.hpp
23  * @brief Sky map class definition
24  * @author Juergen Knoedlseder
25  */
26 
27 #ifndef GSKYMAP_HPP
28 #define GSKYMAP_HPP
29 
30 /* __ Includes ___________________________________________________________ */
31 #include <string>
32 #include <vector>
33 #include "GBase.hpp"
34 #include "GSkyDir.hpp"
35 #include "GSkyPixel.hpp"
36 #include "GSkyProjection.hpp"
37 #include "GBilinear.hpp"
38 #include "GNdarray.hpp"
39 
40 /* __ Forward declarations _______________________________________________ */
41 class GFilename;
42 class GFits;
43 class GFitsHDU;
44 class GFitsTable;
45 class GFitsBinTable;
46 class GFitsImage;
47 class GFitsImageDouble;
48 class GMatrix;
49 class GVector;
50 class GSkyRegion;
51 class GSkyRegionCircle;
52 class GSkyRegions;
53 
54 
55 /***********************************************************************//**
56  * @class GSkyMap
57  *
58  * @brief Sky map class
59  *
60  * This class implements a sky maps. Sky maps are collections of pixels that
61  * define a quantity as function of pixel location. Typical quantities are
62  * gamma-ray intensities, but may also be the number of measured counts.
63  *
64  * Sky map pixels may be arranged in a 2-dimensional grid or in a linear
65  * 1-dimensional sequence. The link between pixel index and sky direction
66  * on the celestial sphere is established using a projection, implemented
67  * by the GSkyProjection class. 2-dimensional grids are represented by
68  * World Coordinate Systems. All World Coordinate Systems derive from GWcs
69  * and are registered in GWcsRegistry. The Healpix pixelisation, implemented
70  * by the GHealpix class, is the only 1-dimensional grid that is so far
71  * available.
72  *
73  * Sky map pixels may be accessed by their linear index, by pixel or by
74  * sky direction. While the index and pixel access return the sky map value
75  * at the pixel centre, the sky direction access operator performs an
76  * interpolation to the exact sky direction.
77  *
78  * Conversion methods exist to convert between the linear index, the pixel
79  * and the sky direction:
80  *
81  * GSkyPixel pixel = map.inx2pix(index); // Index to pixel
82  * GSkyDir dir = map.inx2dir(index); // Index to sky direction
83  * GSkyDir dir = map.pix2dir(pixel); // Pixel to sky direction
84  * int index = map.pix2inx(pixel); // Pixel to index
85  * int index = map.dir2inx(dir); // Sky direction to index
86  * GSkyPixel pixel = map.dir2pix(dir); // Sky direction to pixel
87  *
88  ***************************************************************************/
89 class GSkyMap : public GBase {
90 
91  friend GSkyMap sqrt(const GSkyMap& map);
92  friend GSkyMap log(const GSkyMap& map);
93  friend GSkyMap log10(const GSkyMap& map);
94  friend GSkyMap abs(const GSkyMap& map);
95  friend GSkyMap sign(const GSkyMap& map);
96  friend GSkyMap clip(const GSkyMap& map, const double& thresh);
97 
98 public:
99  // Constructors and destructors
100  GSkyMap(void);
101  explicit GSkyMap(const GFilename& filename);
102  explicit GSkyMap(const GFitsHDU& hdu);
103  GSkyMap(const std::string& coords,
104  const int& nside,
105  const std::string& order,
106  const int& nmaps = 1);
107  GSkyMap(const std::string& wcs,
108  const std::string& coords,
109  const double& x,
110  const double& y,
111  const double& dx,
112  const double& dy,
113  const int& nx,
114  const int& ny,
115  const int& nmaps = 1);
116  GSkyMap(const GSkyMap& map);
117  virtual ~GSkyMap(void);
118 
119  // Operators
120  GSkyMap& operator=(const GSkyMap& map);
121  GSkyMap& operator=(const double& value);
122  GSkyMap& operator+=(const GSkyMap& map);
123  GSkyMap& operator+=(const double& value);
124  GSkyMap& operator-=(const GSkyMap& map);
125  GSkyMap& operator-=(const double& value);
126  GSkyMap& operator*=(const GSkyMap& map);
127  GSkyMap& operator*=(const double& factor);
128  GSkyMap& operator/=(const GSkyMap& map);
129  GSkyMap& operator/=(const double& factor);
130  GSkyMap operator+(const GSkyMap& map) const;
131  GSkyMap operator-(const GSkyMap& map) const;
132  GSkyMap operator*(const GSkyMap& map) const;
133  GSkyMap operator/(const GSkyMap& map) const;
134  double& operator()(const int& index, const int& map = 0);
135  const double& operator()(const int& index, const int& map = 0) const;
136  double& operator()(const GSkyPixel& pixel, const int& map = 0);
137  const double& operator()(const GSkyPixel& pixel, const int& map = 0) const;
138  double operator()(const GSkyDir& dir, const int& map = 0) const;
139 
140  // Methods
141  void clear(void);
142  GSkyMap* clone(void) const;
143  std::string classname(void) const;
144  bool is_empty(void) const;
145  const int& npix(void) const;
146  const int& nx(void) const;
147  const int& ny(void) const;
148  const int& nmaps(void) const;
149  void nmaps(const int& nmaps);
150  const std::vector<int>& shape(void) const;
151  void shape(const int& s1);
152  void shape(const int& s1, const int& s2);
153  void shape(const int& s1, const int& s2, const int& s3);
154  void shape(const std::vector<int>& shape);
155  int ndim(void) const;
156  GSkyPixel inx2pix(const int& index) const;
157  GSkyDir inx2dir(const int& index) const;
158  GSkyDir pix2dir(const GSkyPixel& pixel) const;
159  int pix2inx(const GSkyPixel& pixel) const;
160  int dir2inx(const GSkyDir& dir) const;
161  GSkyPixel dir2pix(const GSkyDir& dir) const;
162  GNdarray counts(void) const;
163  double flux(const int& index, const int& map = 0) const;
164  double flux(const GSkyPixel& pixel, const int& map = 0) const;
165  GNdarray flux(void) const;
166  double solidangle(const int& index) const;
167  double solidangle(const GSkyPixel& pixel) const;
168  bool contains(const GSkyDir& dir) const;
169  bool contains(const GSkyPixel& pixel) const;
170  bool overlaps(const GSkyRegion& region) const;
171  void smooth(const std::string& kernel, const double& par);
172  const GSkyProjection* projection(void) const;
173  void projection(const GSkyProjection& proj);
174  const double* pixels(void) const;
175  GSkyMap extract(const int& map, const int& nmaps = 1) const;
176  GSkyMap extract(const int& startx, const int& stopx,
177  const int& starty, const int& stopy) const;
178  GSkyMap extract(const GSkyRegions& inclusions) const;
179  void stack_maps(void);
180  void load(const GFilename& filename);
181  void save(const GFilename& filename,
182  const bool& clobber = false) const;
183  void read(const GFitsHDU& hdu);
184  GFitsHDU* write(GFits& file,
185  const std::string& extname = "") const;
186  void publish(const std::string& name = "") const;
187  std::string print(const GChatter& chatter = NORMAL) const;
188 
189 private:
190  // Private methods
191  void init_members(void);
192  void copy_members(const GSkyMap& map);
193  void free_members(void);
194  void set_wcs(const std::string& wcs, const std::string& coords,
195  const double& crval1, const double& crval2,
196  const double& crpix1, const double& crpix2,
197  const double& cdelt1, const double& cdelt2,
198  const GMatrix& cd, const GVector& pv2);
199  void read_healpix(const GFitsTable& table);
200  void read_wcs(const GFitsImage& image);
201  void alloc_wcs(const GFitsImage& image);
202  GFitsBinTable* create_healpix_hdu(void) const;
203  GFitsImageDouble* create_wcs_hdu(void) const;
204  double solidangle(const GSkyDir& dir1, const GSkyDir& dir2,
205  const GSkyDir& dir3) const;
206  double solidangle(const GSkyDir& dir1, const GSkyDir& dir2,
207  const GSkyDir& dir3, const GSkyDir& dir4) const;
208  bool overlaps_circle(const GSkyRegionCircle& region) const;
209  bool is_healpix(const GFitsHDU& hdu) const;
210  bool is_wcs(const GFitsHDU& hdu) const;
211  bool is_same(const GSkyMap& map) const;
212  GNdarray smooth_kernel(const std::string& kernel,
213  const double& par) const;
214 
215  // Private data area
216  int m_num_pixels; //!< Number of pixels (used for pixel allocation)
217  int m_num_maps; //!< Number of maps (used for pixel allocation)
218  int m_num_x; //!< Number of pixels in x direction (only 2D)
219  int m_num_y; //!< Number of pixels in y direction (only 2D)
220  std::vector<int> m_shape; //!< Shape of the maps
221  GSkyProjection* m_proj; //!< Pointer to sky projection
222  GNdarray m_pixels; //!< Skymap pixels
223 
224  // Computation cache
225  mutable bool m_hascache; //!< Cache is valid
226  mutable bool m_contained; //!< Sky direction is contained in map
227  mutable GSkyDir m_last_dir; //!< Last sky direction
228  mutable GBilinear m_interpol; //!< Bilinear interpolator
229 };
230 
231 
232 /***********************************************************************//**
233  * @brief Binary sky map addition
234  *
235  * @param[in] map Sky map.
236  * @return Sky map to which @p map was added.
237  *
238  * Returns the sum of two sky maps.
239  ***************************************************************************/
240 inline
242 {
243  GSkyMap result = *this;
244  result += map;
245  return result;
246 }
247 
248 
249 /***********************************************************************//**
250  * @brief Binary sky map subtraction
251  *
252  * @param[in] map Sky map.
253  * @return Sky map to which @p map was added.
254  *
255  * Returns the difference of two sky maps.
256  ***************************************************************************/
257 inline
259 {
260  GSkyMap result = *this;
261  result -= map;
262  return result;
263 }
264 
265 
266 /***********************************************************************//**
267  * @brief Binary sky map multiplication
268  *
269  * @param[in] map Sky map.
270  * @return Sky map multiplied by @p map.
271  *
272  * Returns the product of two sky maps.
273  ***************************************************************************/
274 inline
276 {
277  GSkyMap result = *this;
278  result *= map;
279  return result;
280 }
281 
282 
283 /***********************************************************************//**
284  * @brief Binary sky map division
285  *
286  * @param[in] map Sky map.
287  * @return Sky map divided by @p map.
288  *
289  * Returns the ratio of two sky maps.
290  ***************************************************************************/
291 inline
293 {
294  GSkyMap result = *this;
295  result /= map;
296  return result;
297 }
298 
299 
300 /***********************************************************************//**
301  * @brief Return class name
302  *
303  * @return String containing the class name ("GSkyMap").
304  ***************************************************************************/
305 inline
306 std::string GSkyMap::classname(void) const
307 {
308  return ("GSkyMap");
309 }
310 
311 
312 /***********************************************************************//**
313  * @brief Signals if sky map is empty
314  *
315  * @return True if sky map is empty, false otherwise.
316  *
317  * Signals if a sky map has no pixels or maps.
318  ***************************************************************************/
319 inline
320 bool GSkyMap::is_empty(void) const
321 {
322  return ((m_num_pixels == 0) || (m_num_maps == 0));
323 }
324 
325 
326 /***********************************************************************//**
327  * @brief Returns number of pixels
328  *
329  * @return Number of pixels in one sky map.
330  *
331  * Returns the number of pixels in one sky map.
332  ***************************************************************************/
333 inline
334 const int& GSkyMap::npix(void) const
335 {
336  return m_num_pixels;
337 }
338 
339 
340 /***********************************************************************//**
341  * @brief Returns number of pixels in x coordinate
342  *
343  * @return Number of pixels in the X direction.
344  *
345  * Returns the number of pixels in the X direction. If the sky map is a
346  * one dimensional array (which is the case for the Healpix projection),
347  * the method returns 0.
348  ***************************************************************************/
349 inline
350 const int& GSkyMap::nx(void) const
351 {
352  return m_num_x;
353 }
354 
355 
356 /***********************************************************************//**
357  * @brief Returns number of pixels in y coordinate
358  *
359  * @return Number of pixels in the Y direction.
360  *
361  * Returns the number of pixels in the Y direction. If the sky map is a
362  * one dimensional array (which is the case for the Healpix projection),
363  * the method returns 0.
364  ***************************************************************************/
365 inline
366 const int& GSkyMap::ny(void) const
367 {
368  return m_num_y;
369 }
370 
371 
372 /***********************************************************************//**
373  * @brief Returns number of maps
374  *
375  * @return Number of maps in the sky map object.
376  ***************************************************************************/
377 inline
378 const int& GSkyMap::nmaps(void) const
379 {
380  return m_num_maps;
381 }
382 
383 
384 /***********************************************************************//**
385  * @brief Returns shape of maps
386  *
387  * @return Shape of maps in the sky map object.
388  ***************************************************************************/
389 inline
390 const std::vector<int>& GSkyMap::shape(void) const
391 {
392  return m_shape;
393 }
394 
395 
396 /***********************************************************************//**
397  * @brief Returns dimension of maps
398  *
399  * @return Number of map dimensions.
400  ***************************************************************************/
401 inline
402 int GSkyMap::ndim(void) const
403 {
404  return (int)m_shape.size();
405 }
406 
407 
408 /***********************************************************************//**
409  * @brief Returns pointer to sky projection
410  *
411  * @return Pointer to sky projection (NULL if no projection is defined).
412  ***************************************************************************/
413 inline
415 {
416  return m_proj;
417 }
418 
419 
420 /***********************************************************************//**
421  * @brief Returns pointer to pixel data
422  *
423  * @return Pointer to pixel data.
424  ***************************************************************************/
425 inline
426 const double* GSkyMap::pixels(void) const
427 {
428  return (m_pixels.data());
429 }
430 
431 #endif /* GSKYMAP_HPP */
friend GSkyMap log(const GSkyMap &map)
Computes the natural logarithm of sky map elements.
Definition: GSkyMap.cpp:3667
bool is_same(const GSkyMap &map) const
Check if map is the same.
Definition: GSkyMap.cpp:3441
GSkyMap(void)
Void constructor.
Definition: GSkyMap.cpp:113
void stack_maps(void)
Stack all maps into a single map.
Definition: GSkyMap.cpp:2235
GSkyMap & operator=(const GSkyMap &map)
Assignment operator.
Definition: GSkyMap.cpp:331
Sky map class.
Definition: GSkyMap.hpp:89
Abstract FITS image base class.
Definition: GFitsImage.hpp:43
GSkyMap & operator*=(const GSkyMap &map)
Multiplication operator.
Definition: GSkyMap.cpp:572
const int & ny(void) const
Returns number of pixels in y coordinate.
Definition: GSkyMap.hpp:366
GSkyPixel inx2pix(const int &index) const
Converts pixel index into sky map pixel.
Definition: GSkyMap.cpp:1291
int pix2inx(const GSkyPixel &pixel) const
Converts sky map pixel into pixel index.
Definition: GSkyMap.cpp:1397
const GSkyProjection * projection(void) const
Returns pointer to sky projection.
Definition: GSkyMap.hpp:414
GNdarray counts(void) const
Returns array with total number of counts for count maps.
Definition: GSkyMap.cpp:1486
GSkyMap * clone(void) const
Clone sky map.
Definition: GSkyMap.cpp:1108
GSkyMap extract(const int &map, const int &nmaps=1) const
Extract maps into a new sky map object.
Definition: GSkyMap.cpp:2036
int m_num_maps
Number of maps (used for pixel allocation)
Definition: GSkyMap.hpp:217
int m_num_pixels
Number of pixels (used for pixel allocation)
Definition: GSkyMap.hpp:216
void read_healpix(const GFitsTable &table)
Read Healpix data from FITS table.
Definition: GSkyMap.cpp:2774
GSkyMap operator+(const GSkyMap &map) const
Binary sky map addition.
Definition: GSkyMap.hpp:241
Sky direction class interface definition.
std::vector< int > m_shape
Shape of the maps.
Definition: GSkyMap.hpp:220
Abstract FITS extension base class.
Definition: GFitsHDU.hpp:51
bool overlaps(const GSkyRegion &region) const
Checks whether a region overlaps with this map.
Definition: GSkyMap.cpp:1944
int m_num_x
Number of pixels in x direction (only 2D)
Definition: GSkyMap.hpp:218
void set_wcs(const std::string &wcs, const std::string &coords, const double &crval1, const double &crval2, const double &crpix1, const double &crpix2, const double &cdelt1, const double &cdelt2, const GMatrix &cd, const GVector &pv2)
Set World Coordinate System.
Definition: GSkyMap.cpp:2720
Definition of interface for all GammaLib classes.
GSkyProjection * m_proj
Pointer to sky projection.
Definition: GSkyMap.hpp:221
Abstract sky projection base class definition.
int m_num_y
Number of pixels in y direction (only 2D)
Definition: GSkyMap.hpp:219
GSkyMap & operator+=(const GSkyMap &map)
Map addition operator.
Definition: GSkyMap.cpp:392
friend GSkyMap abs(const GSkyMap &map)
Computes the absolute value of sky map elements.
Definition: GSkyMap.cpp:3747
FITS file class.
Definition: GFits.hpp:63
Interface for the circular sky region class.
friend GSkyMap log10(const GSkyMap &map)
Computes the base 10 logarithm of sky map elements.
Definition: GSkyMap.cpp:3707
void read(const GFitsHDU &hdu)
Read skymap from FITS HDU.
Definition: GSkyMap.cpp:2434
GSkyMap & operator-=(const GSkyMap &map)
Map subtraction operator.
Definition: GSkyMap.cpp:482
const std::vector< int > & shape(void) const
Returns shape of maps.
Definition: GSkyMap.hpp:390
bool is_empty(void) const
Signals if sky map is empty.
Definition: GSkyMap.hpp:320
void publish(const std::string &name="") const
Publish sky map.
Definition: GSkyMap.cpp:2520
bool is_healpix(const GFitsHDU &hdu) const
Check if HDU contains HEALPix data.
Definition: GSkyMap.cpp:3390
std::string print(const GChatter &chatter=NORMAL) const
Print sky map.
Definition: GSkyMap.cpp:2557
friend GSkyMap sign(const GSkyMap &map)
Computes the sign value of sky map elements.
Definition: GSkyMap.cpp:3783
Sky map pixel class.
Definition: GSkyPixel.hpp:74
void copy_members(const GSkyMap &map)
Copy class members.
Definition: GSkyMap.cpp:2654
GSkyDir pix2dir(const GSkyPixel &pixel) const
Returns sky direction of pixel.
Definition: GSkyMap.cpp:1350
double & operator()(const int &index, const int &map=0)
Pixel index access operator.
Definition: GSkyMap.cpp:783
Abstract interface for the sky region class.
Definition: GSkyRegion.hpp:57
const int & nmaps(void) const
Returns number of maps.
Definition: GSkyMap.hpp:378
GSkyDir inx2dir(const int &index) const
Returns sky direction of pixel.
Definition: GSkyMap.cpp:1321
Double precision FITS image class.
GFitsImageDouble * create_wcs_hdu(void) const
Create FITS HDU containing WCS image.
Definition: GSkyMap.cpp:3095
GFitsHDU * write(GFits &file, const std::string &extname="") const
Write sky map into FITS file.
Definition: GSkyMap.cpp:2467
Filename class.
Definition: GFilename.hpp:62
N-dimensional array class interface definition.
Interface class for all GammaLib classes.
Definition: GBase.hpp:52
GNdarray m_pixels
Skymap pixels.
Definition: GSkyMap.hpp:222
Bilinear interpolator class.
Definition: GBilinear.hpp:40
friend GSkyMap sqrt(const GSkyMap &map)
Computes square root of sky map elements.
Definition: GSkyMap.cpp:3627
bool m_contained
Sky direction is contained in map.
Definition: GSkyMap.hpp:226
bool contains(const GSkyDir &dir) const
Checks if sky direction falls in map.
Definition: GSkyMap.cpp:1879
const double * data(void) const
Data access method (const version)
Definition: GNdarray.hpp:388
Abstract interface for FITS table.
Definition: GFitsTable.hpp:44
GSkyMap operator*(const GSkyMap &map) const
Binary sky map multiplication.
Definition: GSkyMap.hpp:275
GChatter
Definition: GTypemaps.hpp:33
void alloc_wcs(const GFitsImage &image)
Allocate WCS class.
Definition: GSkyMap.cpp:2994
friend GSkyMap clip(const GSkyMap &map, const double &thresh)
Clips map at given value.
Definition: GSkyMap.cpp:3825
void clear(void)
Clear instance.
Definition: GSkyMap.cpp:1090
N-dimensional array class.
Definition: GNdarray.hpp:44
GSkyMap operator-(const GSkyMap &map) const
Binary sky map subtraction.
Definition: GSkyMap.hpp:258
Sky region container class.
Definition: GSkyRegions.hpp:56
void free_members(void)
Delete class members.
Definition: GSkyMap.cpp:2681
bool m_hascache
Cache is valid.
Definition: GSkyMap.hpp:225
GSkyDir m_last_dir
Last sky direction.
Definition: GSkyMap.hpp:227
GSkyMap & operator/=(const GSkyMap &map)
Division operator.
Definition: GSkyMap.cpp:666
GSkyPixel dir2pix(const GSkyDir &dir) const
Returns sky map pixel for a given sky direction.
Definition: GSkyMap.cpp:1462
GBilinear m_interpol
Bilinear interpolator.
Definition: GSkyMap.hpp:228
GFitsBinTable * create_healpix_hdu(void) const
Create FITS HDU containing Healpix data.
Definition: GSkyMap.cpp:3034
int ndim(void) const
Returns dimension of maps.
Definition: GSkyMap.hpp:402
bool is_wcs(const GFitsHDU &hdu) const
Check if HDU contains WCS data.
Definition: GSkyMap.cpp:3416
void read_wcs(const GFitsImage &image)
Read WCS image from FITS HDU.
Definition: GSkyMap.cpp:2903
Bilinear interpolator class interface definition.
FITS binary table class.
bool overlaps_circle(const GSkyRegionCircle &region) const
Checks whether a circular region overlaps with this map.
Definition: GSkyMap.cpp:3327
const int & nx(void) const
Returns number of pixels in x coordinate.
Definition: GSkyMap.hpp:350
void save(const GFilename &filename, const bool &clobber=false) const
Save sky map into FITS file.
Definition: GSkyMap.cpp:2381
void smooth(const std::string &kernel, const double &par)
Smooth sky map.
Definition: GSkyMap.cpp:1978
Generic matrix class definition.
Definition: GMatrix.hpp:79
Vector class.
Definition: GVector.hpp:46
double solidangle(const int &index) const
Returns solid angle of pixel.
Definition: GSkyMap.cpp:1770
Abstract sky projection base class.
virtual ~GSkyMap(void)
Destructor.
Definition: GSkyMap.cpp:307
std::string classname(void) const
Return class name.
Definition: GSkyMap.hpp:306
void load(const GFilename &filename)
Load skymap from FITS file.
Definition: GSkyMap.cpp:2281
const int & npix(void) const
Returns number of pixels.
Definition: GSkyMap.hpp:334
Sky map pixel class definition.
void init_members(void)
Initialise class members.
Definition: GSkyMap.cpp:2627
Sky direction class.
Definition: GSkyDir.hpp:62
int dir2inx(const GSkyDir &dir) const
Returns pixel index for a given sky direction.
Definition: GSkyMap.cpp:1435
GNdarray smooth_kernel(const std::string &kernel, const double &par) const
Return smoothing kernel.
Definition: GSkyMap.cpp:3511
GNdarray flux(void) const
Returns array with total flux for sky maps.
Definition: GSkyMap.cpp:1732
const double * pixels(void) const
Returns pointer to pixel data.
Definition: GSkyMap.hpp:426
GSkyMap operator/(const GSkyMap &map) const
Binary sky map division.
Definition: GSkyMap.hpp:292