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

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

Ajout methode ThetaOfSlice() a l'interface SphericalMap et propagation , Reza 06/06/2006
File size: 10.8 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
72virtual uint_4 NbThetaSlices() const;
73virtual r_8 ThetaOfSlice(int_4 index) const;
74virtual void GetThetaSlice(int_4 index,r_8& theta,TVector<r_8>& phi,TVector<T>& value) const;
75virtual void GetThetaSlice(int_4 sliceIndex,r_8& theta, r_8& phi0, TVector<int_4>& pixelIndices,TVector<T>& value) const ;
76
77virtual bool ContainsSph(double theta, double phi) const;
78virtual int_4 PixIndexSph(double theta,double phi) const;
79
80virtual void PixThetaPhi(int_4 k,double& theta,double& phi) const;
81
82virtual T SetPixels(T v);
83
84/*! Pixel Solid angle (steradians)
85
86 All the pixels have the same solid angle. The dummy argument is
87 for compatibility with eventual pixelizations which would not
88 fulfil this requirement.
89*/
90inline virtual double PixSolAngle(int_4 dummy=0) const {return omeg_;}
91
92/* Acces to the DataBlock */
93inline NDataBlock<T>& DataBlock() {return pixels_;}
94inline const NDataBlock<T>& DataBlock() const {return pixels_;}
95
96// --------------- Specific methods
97
98virtual void Resize(int_4 m);
99
100/*!
101
102\return type of storage of the map : RING or NESTED
103
104at the moment, always RING
105*/
106inline virtual string TypeOfMap() const {return string("RING");};
107
108
109virtual T& PixValNest(int_4 k);
110virtual T const& PixValNest(int_4 k) const;
111
112virtual int_4 PixIndexSphNest(double theta,double phi) const;
113
114virtual void PixThetaPhiNest(int_4 k,double& theta,double& phi) const;
115
116void Pixelize(int_4);
117
118int_4 NestToRing(int_4) const;
119
120int_4 RingToNest(int_4) const;
121
122
123/*! \return value of healpix nside */
124inline virtual int_4 SizeIndex() const {return(nSide_);}
125
126void print(ostream& os) const;
127
128
129
130
131
132
133
134
135// Operations diverses = , +=, ...
136
137
138SphereHEALPix<T>& Set(const SphereHEALPix<T>& a);
139inline SphereHEALPix<T>& operator = (const SphereHEALPix<T>& a)
140 {return Set(a);}
141
142// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
143
144 //! Fill SphereHEALPix with all elements equal to \b x
145virtual SphereHEALPix<T>& SetT(T a);
146inline SphereHEALPix<T>& operator = (T a) {return SetT(a);}
147
148//! Add \b x to all elements
149virtual SphereHEALPix<T>& Add(T a);
150inline SphereHEALPix<T>& operator += (T x) { pixels_ += x; return *this; }
151//! Substract \b x to all elements
152virtual SphereHEALPix<T>& Sub(T a,bool fginv=false);
153inline SphereHEALPix<T>& operator -= (T x) { pixels_ -= x; return *this; }
154//! Multiply all elements by \b x
155virtual SphereHEALPix<T>& Mul(T a);
156inline SphereHEALPix<T>& operator *= (T x) {pixels_ *= x; return *this; }
157//! Divide all elements by \b x
158virtual SphereHEALPix<T>& Div(T a);
159inline SphereHEALPix<T>& operator /= (T x) {pixels_ /= x; return *this; }
160
161// A += -= (ajoute, soustrait element par element les deux spheres )
162 //! Operator SphereHEALPix += SphereHEALPix
163 virtual SphereHEALPix<T>& AddElt(const SphereHEALPix<T>& a);
164 inline SphereHEALPix<T>& operator += (const SphereHEALPix<T>& a) { return AddElt(a); }
165
166
167
168 virtual SphereHEALPix<T>& SubElt(const SphereHEALPix<T>& a);
169 //! Operator SphereHEALPix -= SphereHEALPix
170 inline SphereHEALPix<T>& operator -= (const SphereHEALPix<T>& a) { return SubElt(a); }
171// Multiplication, division element par element les deux SphereHEALPix
172 virtual SphereHEALPix<T>& MulElt(const SphereHEALPix<T>& a);
173 inline SphereHEALPix<T>& operator *= (const SphereHEALPix<T>& a) { return MulElt(a); }
174 virtual SphereHEALPix<T>& DivElt(const SphereHEALPix<T>& a);
175 inline SphereHEALPix<T>& operator /= (const SphereHEALPix<T>& a) { return DivElt(a); }
176
177
178 void CloneOrShare(const SphereHEALPix<T>& a);
179 void Share(const SphereHEALPix<T>& a);
180 SphereHEALPix<T>& CopyElt(const SphereHEALPix<T>& a);
181
182
183 // friend declaration for classes which handle persistence and FITS IO
184 friend class FIO_SphereHEALPix<T>;
185 friend class FITS_SphereHEALPix<T>;
186
187protected :
188
189// ------------- méthodes internes ----------------------
190void InitNul();
191void SetThetaSlices();
192
193inline void setParameters(int_4 nside, int_4 nbpixels, double solangle)
194 {
195 nSide_= nside;
196 nPix_= nbpixels;
197 omeg_= solangle;
198 }
199
200// ------------- variables internes -----------------------
201
202int_4 nSide_;
203int_4 nPix_;
204double omeg_;
205
206NDataBlock<T> pixels_;
207NDataBlock<int_4> sliceBeginIndex_; // Rationalisation Mac. D.Y.
208NDataBlock<int_4> sliceLenght_;
209
210};
211
212////////////////////////////////////////////////////////////////
213// Surcharge d'operateurs A (+,-,*,/) (T) x
214/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,T)
215 \brief Operator SphereHEALPix = SphereHEALPix + constant */
216template <class T> inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a, T b)
217 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
218 result.Add(b); return result;}
219/*! \ingroup SkyMap \fn operator+(T,const SphereHEALPix<T>&)
220 \brief Operator SphereHEALPix = constant + SphereHEALPix */
221template <class T> inline SphereHEALPix<T> operator + (T b,const SphereHEALPix<T>& a)
222 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
223 result.Add(b); return result;}
224
225
226/*! \ingroup SphereHEALPix\fn operator-(const SphereHEALPix<T>&,T)
227 \brief Operator SphereHEALPix = SphereHEALPix - constant */
228template <class T> inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a, T b)
229 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
230 result.Sub(b); return result;}
231
232/*! \ingroup \fn operator-(T,const SphereHEALPix<T>&)
233 \brief Operator SphereHEALPix = constant - SphereHEALPix */
234template <class T> inline SphereHEALPix<T> operator - (T b,const SphereHEALPix<T>& a)
235 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
236 result.Sub(b,true); return result;}
237
238/*! \ingroup SkyMap \fn operator*(const SphereHEALPix<T>&,T)
239 \brief Operator SphereHEALPix = SphereHEALPix * constant */
240template <class T> inline SphereHEALPix<T> operator * (const SphereHEALPix<T>& a, T b)
241 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
242 result.Mul(b); return result;}
243
244/*! \ingroup SkyMap \fn operator*(T,const SphereHEALPix<T>&)
245 \brief Operator SphereHEALPix = constant * SphereHEALPix */
246template <class T> inline SphereHEALPix<T> operator * (T b,const SphereHEALPix<T>& a)
247 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
248 result.Mul(b); return result;}
249
250/*! \ingroup SkyMap \fn operator/(const SphereHEALPix<T>&,T)
251 \brief Operator SphereHEALPix = SphereHEALPix / constant */
252template <class T> inline SphereHEALPix<T> operator / (const SphereHEALPix<T>& a, T b)
253 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
254 result.Div(b); return result;}
255
256/*! \ingroup SkyMap \fn operator/(T,const SphereHEALPix<T>&)
257 \brief Operator SphereHEALPix = constant / SphereHEALPix */
258template <class T> inline SphereHEALPix<T> operator / (T b, const SphereHEALPix<T>& a)
259 {SphereHEALPix<T> result; result.CloneOrShare(a); result.SetTemp(true);
260 result.Div(b, true); return result;}
261
262////////////////////////////////////////////////////////////////
263// Surcharge d'operateurs C = A (+,-) B
264
265/*! \ingroup SkyMap \fn operator+(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
266 \brief Operator SphereHEALPix = SphereHEALPix + SphereHEALPix */
267template <class T>
268inline SphereHEALPix<T> operator + (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
269 { SphereHEALPix<T> result; result.SetTemp(true);
270 if (b.IsTemp()) { result.Share(b); result.AddElt(a); }
271 else { result.CloneOrShare(a); result.AddElt(b); }
272 return result; }
273
274/*! \ingroup SkyMap \fn operator-(const SphereHEALPix<T>&,const SphereHEALPix<T>&)
275 \brief Operator SphereHEALPix = SphereHEALPix - SphereHEALPix */
276template <class T>
277inline SphereHEALPix<T> operator - (const SphereHEALPix<T>& a,const SphereHEALPix<T>& b)
278 { SphereHEALPix<T> result; result.SetTemp(true);
279 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 result.CloneOrShare(a); result.DivElt(b);
300 return result; }
301
302} // Fin du namespace
303
304#endif
Note: See TracBrowser for help on using the repository browser.