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

Last change on this file since 2985 was 2985, checked in by ansari, 19 years ago

1/ Suite codage HEALPix-NEST , test avec transforme Ylm OK
2/ Petites modifs et corrections diverses (ajout SizeIndex2Resol() par exemple)

Reza 21 Juin 2006
File size: 11.6 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
46 //! return the size index (=nside) corresponding to resolution res (in radian)
47 static inline int_4 ResolToSizeIndex(double res)
48 { return HEALPix::ResolToSizeIndex(res); }
49
50 //! return the size index (=nside) corresponding to resolution res (in radian)
51 static inline int_4 ResolToNSide(double res)
52 { return HEALPix::ResolToSizeIndex(res); }
53 //! return the pixel resolution (in radian) for the size index (=nside) m
54 static inline double SizeIndexToResol(int_4 m)
55 { return HEALPix::SizeIndexToResol(m); }
56 //! return the pixel resolution (in radian) for the size index (=nside) m
57 static inline double NSideToResol(int_4 m)
58 { return HEALPix::SizeIndexToResol(m); }
59
60SphereHEALPix(bool fgring=true);
61SphereHEALPix(int_4 m, bool fgring=true);
62SphereHEALPix(const SphereHEALPix<T>& s, bool share);
63SphereHEALPix(const SphereHEALPix<T>& s);
64virtual ~SphereHEALPix();
65
66inline virtual bool IsTemp(void) const {
67
68 if (sliceBeginIndex_.IsTemp() != pixels_.IsTemp() || sliceLenght_.IsTemp() != pixels_.IsTemp() )
69 throw PException(" l'etat 'temporaire' de la spherehealpix est incoherent");
70 return pixels_.IsTemp();
71}
72
73inline virtual void SetTemp(bool temp=false) const
74 {
75 pixels_.SetTemp(temp);
76 sliceBeginIndex_.SetTemp(temp);
77 sliceLenght_.SetTemp(temp);
78 };
79// ------------------ Definition of PixelMap abstract methods
80
81virtual int_4 NbPixels() const;
82
83virtual T& PixVal(int_4 k);
84virtual T const& PixVal(int_4 k) const;
85
86virtual uint_4 NbThetaSlices() const;
87virtual r_8 ThetaOfSlice(int_4 index) const;
88virtual bool HasSymThetaSlice() const;
89virtual int_4 GetSymThetaSliceIndex(int_4 idx) const;
90
91virtual void GetThetaSlice(int_4 index,r_8& theta,TVector<r_8>& phi,TVector<T>& value) const;
92virtual void GetThetaSlice(int_4 sliceIndex,r_8& theta, r_8& phi0, TVector<int_4>& pixelIndices,TVector<T>& value) const ;
93
94virtual bool ContainsSph(double theta, double phi) const;
95virtual int_4 PixIndexSph(double theta,double phi) const;
96
97virtual void PixThetaPhi(int_4 k,double& theta,double& phi) const;
98
99virtual T SetPixels(T v);
100
101/*! \brief Pixel Solid angle (steradians)
102
103 All the pixels have the same solid angle. The dummy argument is
104 for compatibility with eventual pixelizations which would not
105 fulfil this requirement.
106*/
107inline virtual double PixSolAngle(int_4 dummy=0) const {return omeg_;}
108
109/* Acces to the DataBlock */
110inline NDataBlock<T>& DataBlock() {return pixels_;}
111inline const NDataBlock<T>& DataBlock() const {return pixels_;}
112
113// --------------- Specific methods
114
115virtual void Resize(int_4 m);
116virtual string TypeOfMap() const;
117
118inline bool IfRING() const { return fgring_; }
119inline bool IfNESTED() const { return ( (fgring_) ? false : true ); }
120
121
122void Pixelize(int_4);
123
124int_4 NestToRing(int_4) const;
125
126int_4 RingToNest(int_4) const;
127
128
129/*! \return value of healpix nside */
130inline virtual int_4 SizeIndex() const {return(nSide_);}
131
132void print(ostream& os) const;
133inline void Print(ostream& os) const { print(os); }
134
135//--------------------- Operations diverses = , +=, ...
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 bool fgring)
194{
195 nSide_= nside;
196 nPix_= nbpixels;
197 omeg_= solangle;
198 fgring_ = fgring;
199}
200
201// ------------- variables internes -----------------------
202
203int_4 nSide_;
204int_4 nPix_;
205double omeg_;
206bool fgring_; // true -> RING pixelisation , false -> NESTED
207
208NDataBlock<T> pixels_;
209NDataBlock<int_4> sliceBeginIndex_; // Indices in RING scheme
210NDataBlock<int_4> sliceLenght_;
211
212};
213
214////////////////////////////////////////////////////////////////
215// Surcharge d'operateurs A (+,-,*,/) (T) x
216/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,T)
217 \brief Operator SphereHEALPix = SphereHEALPix + constant */
218template <class T> inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a, T b)
219 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
220 result.Add(b); return result;}
221/*! \ingroup SkyMap \fn operator+(T,const SphereHEALPix<T>&)
222 \brief Operator SphereHEALPix = constant + SphereHEALPix */
223template <class T> inline SphereHEALPix<T> operator + (T b,const SphereHEALPix<T>& a)
224 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
225 result.Add(b); return result;}
226
227
228/*! \ingroup SphereHEALPix\fn operator-(const SphereHEALPix<T>&,T)
229 \brief Operator SphereHEALPix = SphereHEALPix - constant */
230template <class T> inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a, T b)
231 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
232 result.Sub(b); return result;}
233
234/*! \ingroup \fn operator-(T,const SphereHEALPix<T>&)
235 \brief Operator SphereHEALPix = constant - SphereHEALPix */
236template <class T> inline SphereHEALPix<T> operator - (T b,const SphereHEALPix<T>& a)
237 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
238 result.Sub(b,true); return result;}
239
240/*! \ingroup SkyMap \fn operator*(const SphereHEALPix<T>&,T)
241 \brief Operator SphereHEALPix = SphereHEALPix * constant */
242template <class T> inline SphereHEALPix<T> operator * (const SphereHEALPix<T>& a, T b)
243 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
244 result.Mul(b); return result;}
245
246/*! \ingroup SkyMap \fn operator*(T,const SphereHEALPix<T>&)
247 \brief Operator SphereHEALPix = constant * SphereHEALPix */
248template <class T> inline SphereHEALPix<T> operator * (T b,const SphereHEALPix<T>& a)
249 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
250 result.Mul(b); return result;}
251
252/*! \ingroup SkyMap \fn operator/(const SphereHEALPix<T>&,T)
253 \brief Operator SphereHEALPix = SphereHEALPix / constant */
254template <class T> inline SphereHEALPix<T> operator / (const SphereHEALPix<T>& a, T b)
255 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
256 result.Div(b); return result;}
257
258/*! \ingroup SkyMap \fn operator/(T,const SphereHEALPix<T>&)
259 \brief Operator SphereHEALPix = constant / SphereHEALPix */
260template <class T> inline SphereHEALPix<T> operator / (T b, const SphereHEALPix<T>& a)
261 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
262 result.Div(b, true); return result;}
263
264////////////////////////////////////////////////////////////////
265// Surcharge d'operateurs C = A (+,-) B
266
267/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
268 \brief Operator SphereHEALPix = SphereHEALPix + SphereHEALPix */
269template <class T>
270inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
271 { SphereHEALPix<T> result; result.SetTemp(true);
272 if (b.IsTemp()) { result.Share(b); result.AddElt(a); }
273 else { result.CloneOrShare(a); result.AddElt(b); }
274 return result; }
275
276/*! \ingroup SkyMap \fn operator-(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
277 \brief Operator SphereHEALPix = SphereHEALPix - SphereHEALPix */
278template <class T>
279inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
280 { SphereHEALPix<T> result; result.SetTemp(true);
281 result.CloneOrShare(a); result.SubElt(b);
282 return result; }
283
284////////////////////////////////////////////////////////////////
285// Surcharge d'operateurs C = A (*,/) B
286
287/*! \ingroup SkyMap \fn operator*(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
288 \brief Operator SphereHEALPix = SphereHEALPix * SphereHEALPix (pixel by pixel multiply) */
289template <class T>
290inline SphereHEALPix<T> operator * (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
291 { SphereHEALPix<T> result; result.SetTemp(true);
292 if (b.IsTemp()) { result.Share(b); result.MulElt(a); }
293 else { result.CloneOrShare(a); result.MulElt(b); }
294 return result; }
295
296/*! \ingroup SkyMap \fn operator/(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
297 \brief Operator SphereHEALPix = SphereHEALPix / SphereHEALPix (pixel by pixel divide) */
298template <class T>
299inline SphereHEALPix<T> operator / (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
300 { SphereHEALPix<T> result; result.SetTemp(true);
301 result.CloneOrShare(a); result.DivElt(b);
302 return result; }
303
304} // Fin du namespace
305
306#endif
Note: See TracBrowser for help on using the repository browser.