source: Sophya/trunk/SophyaLib/SkyMap/spherehealpix.h@ 2290

Last change on this file since 2290 was 2290, checked in by lemeur, 23 years ago

documentation
File size: 10.9 KB
Line 
1#ifndef SPHEREHEALPIX_SEEN
2#define SPHEREHEALPIX_SEEN
3
4#include "sphericalmap.h"
5#include "tvector.h"
6#include "ndatablock.h"
7
8#include "anydataobj.h"
9#include "ppersist.h"
10
11#include "HEALPixUtils.h"
12
13namespace SOPHYA {
14
15
16// ***************** CLASSE SphereHEALPix *****************************
17
18 /*! Class SphereHEALPix */
19
20
21template<class T>
22class FIO_SphereHEALPix;
23
24template<class T>
25class FITS_SphereHEALPix;
26
27template<class T>
28class SphereHEALPix : public SphericalMap<T>
29{
30public :
31// Static Methods to ease the use of HEALPix index <> angle conversion methods
32
33 static inline int_4 nest2ring(int_4 nside,int_4 ipnest)
34 { return HEALPix::nest2ring(nside, ipnest); }
35 static inline int_4 ring2nest(int_4 nside,int_4 ipring)
36 { return HEALPix::ring2nest(nside, ipring); }
37 static inline int_4 ang2pix_ring(int_4 nside,double theta,double phi)
38 { return HEALPix::ang2pix_ring(nside, theta, phi); }
39 static inline int_4 ang2pix_nest(int_4 nside,double theta,double phi)
40 { return HEALPix::ang2pix_nest(nside, theta, phi); }
41 static inline void pix2ang_ring(int_4 nside,int_4 ipix,double& theta,double& phi)
42 { HEALPix::pix2ang_ring(nside, ipix, theta, phi); }
43 static inline void pix2ang_nest(int_4 nside,int_4 ipix,double& theta,double& phi)
44 { HEALPix::pix2ang_nest(nside, ipix, theta, phi); }
45
46SphereHEALPix();
47SphereHEALPix(int_4 m);
48SphereHEALPix(const SphereHEALPix<T>& s, bool share);
49SphereHEALPix(const SphereHEALPix<T>& s);
50virtual ~SphereHEALPix();
51
52inline virtual bool IsTemp(void) const {
53
54 if (sliceBeginIndex_.IsTemp() != pixels_.IsTemp() || sliceLenght_.IsTemp() != pixels_.IsTemp() )
55 throw PException(" l'etat 'temporaire' de la spherehealpix est incoherent");
56 return pixels_.IsTemp();
57}
58
59inline virtual void SetTemp(bool temp=false) const
60 {
61 pixels_.SetTemp(temp);
62 sliceBeginIndex_.SetTemp(temp);
63 sliceLenght_.SetTemp(temp);
64 };
65// ------------------ Definition of PixelMap abstract methods
66
67virtual int_4 NbPixels() const;
68
69virtual T& PixVal(int_4 k);
70virtual T const& PixVal(int_4 k) const;
71
72uint_4 NbThetaSlices() const;
73virtual void GetThetaSlice(int_4 index,r_8& theta,TVector<r_8>& phi,TVector<T>& value) const;
74virtual void GetThetaSlice(int_4 sliceIndex,r_8& theta, r_8& phi0, TVector<int_4>& pixelIndices,TVector<T>& value) const ;
75
76virtual bool ContainsSph(double theta, double phi) const;
77virtual int_4 PixIndexSph(double theta,double phi) const;
78
79virtual void PixThetaPhi(int_4 k,double& theta,double& phi) const;
80
81virtual T SetPixels(T v);
82
83/*! Pixel Solid angle (steradians)
84
85 All the pixels have the same solid angle. The dummy argument is
86 for compatibility with eventual pixelizations which would not
87 fulfil this requirement.
88*/
89inline virtual double PixSolAngle(int_4 dummy=0) const {return omeg_;}
90
91/* Acces to the DataBlock */
92inline NDataBlock<T>& DataBlock() {return pixels_;}
93inline const NDataBlock<T>& DataBlock() const {return pixels_;}
94
95// --------------- Specific methods
96
97virtual void Resize(int_4 m);
98
99/*!
100
101\return type of storage of the map : RING or NESTED
102
103at the moment, always RING
104*/
105inline virtual string TypeOfMap() const {return string("RING");};
106
107
108virtual T& PixValNest(int_4 k);
109virtual T const& PixValNest(int_4 k) const;
110
111virtual int_4 PixIndexSphNest(double theta,double phi) const;
112
113virtual void PixThetaPhiNest(int_4 k,double& theta,double& phi) const;
114
115void Pixelize(int_4);
116
117int_4 NestToRing(int_4) const;
118
119int_4 RingToNest(int_4) const;
120
121
122/*! \return value of healpix nside */
123inline virtual int_4 SizeIndex() const {return(nSide_);}
124
125void print(ostream& os) const;
126
127
128
129
130
131
132
133
134// Operations diverses = , +=, ...
135
136
137SphereHEALPix<T>& Set(const SphereHEALPix<T>& a);
138inline SphereHEALPix<T>& operator = (const SphereHEALPix<T>& a)
139 {return Set(a);}
140
141// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
142
143 //! Fill SphereHEALPix with all elements equal to \b x
144virtual SphereHEALPix<T>& SetT(T a);
145inline SphereHEALPix<T>& operator = (T a) {return SetT(a);}
146
147//! Add \b x to all elements
148virtual SphereHEALPix<T>& Add(T a);
149inline SphereHEALPix<T>& operator += (T x) { pixels_ += x; return *this; }
150//! Substract \b x to all elements
151virtual SphereHEALPix<T>& Sub(T a,bool fginv=false);
152inline SphereHEALPix<T>& operator -= (T x) { pixels_ -= x; return *this; }
153//! Multiply all elements by \b x
154virtual SphereHEALPix<T>& Mul(T a);
155inline SphereHEALPix<T>& operator *= (T x) {pixels_ *= x; return *this; }
156//! Divide all elements by \b x
157virtual SphereHEALPix<T>& Div(T a);
158inline SphereHEALPix<T>& operator /= (T x) {pixels_ /= x; return *this; }
159
160// A += -= (ajoute, soustrait element par element les deux spheres )
161 //! Operator SphereHEALPix += SphereHEALPix
162 virtual SphereHEALPix<T>& AddElt(const SphereHEALPix<T>& a);
163 inline SphereHEALPix<T>& operator += (const SphereHEALPix<T>& a) { return AddElt(a); }
164
165
166
167 virtual SphereHEALPix<T>& SubElt(const SphereHEALPix<T>& a);
168 //! Operator SphereHEALPix -= SphereHEALPix
169 inline SphereHEALPix<T>& operator -= (const SphereHEALPix<T>& a) { return SubElt(a); }
170// Multiplication, division element par element les deux SphereHEALPix
171 virtual SphereHEALPix<T>& MulElt(const SphereHEALPix<T>& a);
172 inline SphereHEALPix<T>& operator *= (const SphereHEALPix<T>& a) { return MulElt(a); }
173 virtual SphereHEALPix<T>& DivElt(const SphereHEALPix<T>& a);
174 inline SphereHEALPix<T>& operator /= (const SphereHEALPix<T>& a) { return DivElt(a); }
175
176
177 void CloneOrShare(const SphereHEALPix<T>& a);
178 void Share(const SphereHEALPix<T>& a);
179 SphereHEALPix<T>& CopyElt(const SphereHEALPix<T>& a);
180
181
182 // friend declaration for classes which handle persistence and FITS IO
183 friend class FIO_SphereHEALPix<T>;
184 friend class FITS_SphereHEALPix<T>;
185
186protected :
187
188// ------------- méthodes internes ----------------------
189void InitNul();
190void SetThetaSlices();
191
192inline void setParameters(int_4 nside, int_4 nbpixels, double solangle)
193 {
194 nSide_= nside;
195 nPix_= nbpixels;
196 omeg_= solangle;
197 }
198
199// ------------- variables internes -----------------------
200
201int_4 nSide_;
202int_4 nPix_;
203double omeg_;
204
205NDataBlock<T> pixels_;
206NDataBlock<int_4> sliceBeginIndex_; // Rationalisation Mac. D.Y.
207NDataBlock<int_4> sliceLenght_;
208
209};
210
211////////////////////////////////////////////////////////////////
212// Surcharge d'operateurs A (+,-,*,/) (T) x
213/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,T)
214 \brief Operator SphereHEALPix = SphereHEALPix + constant */
215template <class T> inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a, T b)
216 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
217 result.Add(b); return result;}
218/*! \ingroup SkyMap \fn operator+(T,const SphereHEALPix<T>&)
219 \brief Operator SphereHEALPix = constant + SphereHEALPix */
220template <class T> inline SphereHEALPix<T> operator + (T b,const SphereHEALPix<T>& a)
221 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
222 result.Add(b); return result;}
223
224
225/*! \ingroup SphereHEALPix\fn operator-(const SphereHEALPix<T>&,T)
226 \brief Operator SphereHEALPix = SphereHEALPix - constant */
227template <class T> inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a, T b)
228 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
229 result.Sub(b); return result;}
230
231/*! \ingroup \fn operator-(T,const SphereHEALPix<T>&)
232 \brief Operator SphereHEALPix = constant - SphereHEALPix */
233template <class T> inline SphereHEALPix<T> operator - (T b,const SphereHEALPix<T>& a)
234 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
235 result.Sub(b,true); return result;}
236
237/*! \ingroup SkyMap \fn operator*(const SphereHEALPix<T>&,T)
238 \brief Operator SphereHEALPix = SphereHEALPix * constant */
239template <class T> inline SphereHEALPix<T> operator * (const SphereHEALPix<T>& a, T b)
240 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
241 result.Mul(b); return result;}
242
243/*! \ingroup SkyMap \fn operator*(T,const SphereHEALPix<T>&)
244 \brief Operator SphereHEALPix = constant * SphereHEALPix */
245template <class T> inline SphereHEALPix<T> operator * (T b,const SphereHEALPix<T>& a)
246 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
247 result.Mul(b); return result;}
248
249/*! \ingroup SkyMap \fn operator/(const SphereHEALPix<T>&,T)
250 \brief Operator SphereHEALPix = SphereHEALPix / constant */
251template <class T> inline SphereHEALPix<T> operator / (const SphereHEALPix<T>& a, T b)
252 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
253 result.Div(b); return result;}
254
255/*! \ingroup SkyMap \fn operator/(T,const SphereHEALPix<T>&)
256 \brief Operator SphereHEALPix = constant / SphereHEALPix */
257template <class T> inline SphereHEALPix<T> operator / (T b, const SphereHEALPix<T>& a)
258 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
259 result.Div(b, true); return result;}
260
261////////////////////////////////////////////////////////////////
262// Surcharge d'operateurs C = A (+,-) B
263
264/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
265 \brief Operator SphereHEALPix = SphereHEALPix + SphereHEALPix */
266template <class T>
267inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
268 { SphereHEALPix<T> result; result.SetTemp(true);
269 if (b.IsTemp()) { result.Share(b); result.AddElt(a); }
270 else { result.CloneOrShare(a); result.AddElt(b); }
271 return result; }
272
273/*! \ingroup SkyMap \fn operator-(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
274 \brief Operator SphereHEALPix = SphereHEALPix - SphereHEALPix */
275template <class T>
276inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
277 { SphereHEALPix<T> result; result.SetTemp(true);
278 if (b.IsTemp()) { result.Share(b); result.SubElt(a); }
279 else { result.CloneOrShare(a); result.SubElt(b); }
280 return result; }
281
282////////////////////////////////////////////////////////////////
283// Surcharge d'operateurs C = A (*,/) B
284
285/*! \ingroup SkyMap \fn operator*(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
286 \brief Operator SphereHEALPix = SphereHEALPix * SphereHEALPix (pixel by pixel multiply) */
287template <class T>
288inline SphereHEALPix<T> operator * (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
289 { SphereHEALPix<T> result; result.SetTemp(true);
290 if (b.IsTemp()) { result.Share(b); result.MulElt(a); }
291 else { result.CloneOrShare(a); result.MulElt(b); }
292 return result; }
293
294/*! \ingroup SkyMap \fn operator/(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
295 \brief Operator SphereHEALPix = SphereHEALPix / SphereHEALPix (pixel by pixel divide) */
296template <class T>
297inline SphereHEALPix<T> operator / (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
298 { SphereHEALPix<T> result; result.SetTemp(true);
299 if (b.IsTemp()) { result.Share(b); result.DivElt(a); }
300 else { result.CloneOrShare(a); result.DivElt(b); }
301 return result; }
302
303} // Fin du namespace
304
305#endif
Note: See TracBrowser for help on using the repository browser.