source: Sophya/trunk/SophyaLib/SkyMap/spherethetaphi.h@ 3206

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

Ajout methodes RenewObjId() pour cartes spheriques et localmap - Reza 05/02/2007
File size: 12.4 KB
Line 
1#ifndef SPHERETHETAPHI_SEEN
2#define SPHERETHETAPHI_SEEN
3
4#include "sphericalmap.h"
5#include "ndatablock.h"
6#include "tvector.h"
7
8#include "anydataobj.h"
9#include "ppersist.h"
10
11namespace SOPHYA {
12
13
14
15template <class T>
16class FIO_SphereThetaPhi;
17
18template<class T>
19class FITS_SphereThetaPhi;
20
21
22// ***************** Class SphereThetaPhi *****************************
23template <class T>
24class SphereThetaPhi : public SphericalMap<T>
25{
26
27public :
28
29//! return the size index value corresponding to resolution \b res (in radian)
30static inline int_4 ResolToSizeIndex(double res)
31 { return (int_4)((M_PI/2./res)+0.5); }
32//! return the pixel resolution (in radian) for the size index \b m
33static inline double SizeIndexToResol(int_4 m)
34 { return (M_PI/(2.*(double)m)); }
35
36SphereThetaPhi();
37SphereThetaPhi(int_4 m);
38SphereThetaPhi(const SphereThetaPhi<T>& s, bool share);
39SphereThetaPhi(const SphereThetaPhi<T>& s);
40virtual ~SphereThetaPhi();
41
42 // Temporaire?
43inline virtual bool IsTemp(void) const {
44
45 if ( NPhi_.IsTemp() != pixels_.IsTemp() ||
46 TNphi_.IsTemp() != pixels_.IsTemp()||
47 Theta_.IsTemp() != pixels_.IsTemp() )
48 throw PException(" l'etat 'temporaire' de la spherethetaphi est incoherent");
49 return pixels_.IsTemp();
50}
51/*! Setting blockdata to temporary (see ndatablock documentation) */
52inline virtual void SetTemp(bool temp=false) const
53 {
54 NPhi_.SetTemp(temp);
55 TNphi_.SetTemp(temp);
56 Theta_.SetTemp(temp);
57 pixels_.SetTemp(temp);
58 };
59
60// ------------ Definition of PixelMap abstract methods -
61
62/* retourne le nombre de pixels */
63virtual int_4 NbPixels() const;
64
65/* retourne la valeur du pixel d'indice k */
66virtual T& PixVal(int_4 k);
67virtual T const& PixVal(int_4 k) const;
68
69/* Return true if teta,phi in map */
70virtual bool ContainsSph(double theta, double phi) const;
71/* retourne l'indice du pixel a (theta,phi) */
72/* Return index of the pixel corresponding to direction (theta, phi). */
73virtual int_4 PixIndexSph(double theta, double phi) const;
74
75/* retourne les coordonnees Spheriques du centre du pixel d'indice k */
76virtual void PixThetaPhi(int_4 k, double& theta, double& phi) const;
77
78/* Setting pixel values to a constant */
79virtual T SetPixels(T v);
80
81/* retourne/fixe l'angle Solide de Pixel (steradians) */
82virtual double PixSolAngle(int_4 dummy=0) const;
83
84/* retourne/fixe la valeur du parametre de decoupage m */
85//! Return the pixelisation parameter (number of slices in a hemisphere)
86inline virtual int_4 SizeIndex() const { return( NTheta_); }
87
88/* Acces to the DataBlock */
89//! Acces to the pixel data NDataBlock<T> object
90inline NDataBlock<T>& DataBlock() {return pixels_;}
91//! Acces to the pixel data NDataBlock<T> object (const version)
92inline const NDataBlock<T>& DataBlock() const {return pixels_;}
93
94// ------------- Specific methods ----------------------
95
96virtual void Resize(int_4 m);
97
98inline virtual string TypeOfMap() const {return string("TETAFI");};
99
100/* Valeurs de theta des paralleles et phi des meridiens limitant le pixel d'indice k */
101/* Return values of theta,phi which limit the pixel with index k */
102virtual void Limits(int_4 k,double& th1,double& th2,double& phi1,double& phi2);
103
104/* Nombre de tranches en theta */
105/* Return number of theta-slices on the sphere */
106uint_4 NbThetaSlices() const;
107
108/* Nombre de pixels en phi de la tranche d'indice kt */
109int_4 NPhi(int_4 kt) const;
110
111/* Renvoie dans t1,t2 les valeurs respectives de theta min et theta max */
112/* de la tranche d'indice kt */
113void Theta(int_4 kt, double& t1, double& t2) const;
114
115/* Renvoie dans p1,p2 les valeurs phimin et phimax du pixel d'indice jp */
116/* dans la tranche d'indice kt */
117void Phi(int_4 kt, int_4 jp, double& p1, double& p2) const;
118
119/* Renvoie l'indice k du pixel d'indice jp dans la tranche d'indice kt */
120/*! Return pixel index with sequence index jp in the slice kt */
121int_4 Index(int_4 kt, int_4 jp) const;
122
123/* Indice kt de la tranche et indice jp du pixel d'indice k */
124void ThetaPhiIndex(int_4 k,int_4& kt,int_4& jp);
125
126void Pixelize(int_4);
127
128virtual r_8 ThetaOfSlice(int_4 index) const;
129virtual int_4 GetSymThetaSliceIndex(int_4 idx) const;
130virtual bool HasSymThetaSlice() const;
131
132virtual void GetThetaSlice(int_4 index,r_8& theta,TVector<r_8>& phi,TVector<T>& value) const;
133virtual void GetThetaSlice(int_4 index, r_8& theta, r_8& phi0,TVector<int_4>& pixelIndices, TVector<T>& value) const ;
134virtual T* GetThetaSliceDataPtr(int_4 sliceIndex);
135
136
137//! ASCII dump (print) of the pixel map on stream \b os
138void print(ostream& os) const;
139//! ASCII dump (print) of the pixel map
140inline void Print(ostream& os) const { print(os); }
141//! ASCII dump (print) of the pixel map on cout
142inline void Print() const { print(cout); }
143
144
145
146// Operations diverses = , +=, ...
147
148
149SphereThetaPhi<T>& Set(const SphereThetaPhi<T>& a);
150inline SphereThetaPhi<T>& operator = (const SphereThetaPhi<T>& a)
151 {return Set(a);}
152
153// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
154
155 //! Fill SphereThetaPhi with all elements equal to \b x
156virtual SphereThetaPhi<T>& SetT(T a);
157inline SphereThetaPhi<T>& operator = (T a) {return SetT(a);}
158
159//! Add \b x to all elements
160virtual SphereThetaPhi<T>& Add(T a);
161inline SphereThetaPhi<T>& operator += (T x) { return Add(x); }
162//! Substract \b x to all elements
163virtual SphereThetaPhi<T>& Sub(T a,bool fginv=false);
164inline SphereThetaPhi<T>& operator -= (T x) { return Sub(x); }
165//! Multiply all elements by \b x
166virtual SphereThetaPhi<T>& Mul(T a);
167inline SphereThetaPhi<T>& operator *= (T x) { return Mul(x); }
168//! Divide all elements by \b x
169virtual SphereThetaPhi<T>& Div(T a);
170inline SphereThetaPhi<T>& operator /= (T x) { return Div(x); }
171
172// A += -= (ajoute, soustrait element par element les deux spheres )
173 //! Operator SphereThetaPhi += SphereThetaPhi
174 virtual SphereThetaPhi<T>& AddElt(const SphereThetaPhi<T>& a);
175 inline SphereThetaPhi<T>& operator += (const SphereThetaPhi<T>& a) { return AddElt(a); }
176
177
178
179 virtual SphereThetaPhi<T>& SubElt(const SphereThetaPhi<T>& a);
180 //! Operator SphereThetaPhi -= SphereThetaPhi
181 inline SphereThetaPhi<T>& operator -= (const SphereThetaPhi<T>& a) { return SubElt(a); }
182// Multiplication, division element par element les deux SphereThetaPhi
183 virtual SphereThetaPhi<T>& MulElt(const SphereThetaPhi<T>& a);
184 inline SphereThetaPhi<T>& operator *= (const SphereThetaPhi<T>& a) { return MulElt(a); }
185 virtual SphereThetaPhi<T>& DivElt(const SphereThetaPhi<T>& a);
186 inline SphereThetaPhi<T>& operator /= (const SphereThetaPhi<T>& a) { return DivElt(a); }
187
188
189 void CloneOrShare(const SphereThetaPhi<T>& a);
190 void Share(const SphereThetaPhi<T>& a);
191
192 SphereThetaPhi<T>& CopyElt(const SphereThetaPhi<T>& a);
193
194//! assign a new object Id (or DataRef Id) - useful for PPF write operations
195// Reza 02/2007 : Est-il suffisant de faire l'operation sur pixels_ ?
196 inline void RenewObjId() { pixels_.RenewObjId(); }
197
198
199 // friend declaration for classes which handle persistence and FITS IO
200 friend class FIO_SphereThetaPhi<T>;
201 friend class FITS_SphereThetaPhi<T>;
202
203protected :
204
205// ------------- méthodes internes ----------------------
206void InitNul();
207inline void setParameters( int nbThetaIndex, int nbpix, double omega)
208 {
209 NPix_= nbpix;
210 Omega_= omega;
211 NTheta_= nbThetaIndex;
212 }
213
214// ------------- variables internes ---------------------
215 int_4 NTheta_; // nombre de tranches en theta, pour une demi-sphere
216 int_4 NPix_; // nombre total de pixels
217 double Omega_; // angle solide constant pour chaque pixel
218 NDataBlock<int_4> NPhi_; // tableau donnant, pour chaque bande en theta,
219 //le nombre de pixels selon phi
220 NDataBlock<int_4> TNphi_; // tableau donnant ke nombre de pixels cumule,
221 // jusqu'au debut de chaque tranche
222 NDataBlock<r_8> Theta_;
223 NDataBlock<T> pixels_;
224};
225
226////////////////////////////////////////////////////////////////
227// Surcharge d'operateurs A (+,-,*,/) (T) x
228/*! \ingroup SkyMap \fn operator+(const SphereThetaPhi<T>&,T)
229 \brief Operator SphereThetaPhi = SphereThetaPhi + constant */
230template <class T> inline SphereThetaPhi<T> operator + (const SphereThetaPhi<T>& a, T b)
231 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
232 result.Add(b); return result;}
233/*! \ingroup SkyMap \fn operator+(T,const SphereThetaPhi<T>&)
234 \brief Operator SphereThetaPhi = constant + SphereThetaPhi */
235template <class T> inline SphereThetaPhi<T> operator + (T b,const SphereThetaPhi<T>& a)
236 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
237 result.Add(b); return result;}
238
239
240/*! \ingroup SphereThetaPhi\fn operator-(const SphereThetaPhi<T>&,T)
241 \brief Operator SphereThetaPhi = SphereThetaPhi - constant */
242template <class T> inline SphereThetaPhi<T> operator - (const SphereThetaPhi<T>& a, T b)
243 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
244 result.Sub(b); return result;}
245
246/*! \ingroup \fn operator-(T,const SphereThetaPhi<T>&)
247 \brief Operator SphereThetaPhi = constant - SphereThetaPhi */
248template <class T> inline SphereThetaPhi<T> operator - (T b,const SphereThetaPhi<T>& a)
249 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
250 result.Sub(b,true); return result;}
251
252/*! \ingroup SkyMap \fn operator*(const SphereThetaPhi<T>&,T)
253 \brief Operator SphereThetaPhi = SphereThetaPhi * constant */
254template <class T> inline SphereThetaPhi<T> operator * (const SphereThetaPhi<T>& a, T b)
255 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
256 result.Mul(b); return result;}
257
258/*! \ingroup SkyMap \fn operator*(T,const SphereThetaPhi<T>&)
259 \brief Operator SphereThetaPhi = constant * SphereThetaPhi */
260template <class T> inline SphereThetaPhi<T> operator * (T b,const SphereThetaPhi<T>& a)
261 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
262 result.Mul(b); return result;}
263
264/*! \ingroup SkyMap \fn operator/(const SphereThetaPhi<T>&,T)
265 \brief Operator SphereThetaPhi = SphereThetaPhi / constant */
266template <class T> inline SphereThetaPhi<T> operator / (const SphereThetaPhi<T>& a, T b)
267 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
268 result.Div(b); return result;}
269
270/*! \ingroup SkyMap \fn operator/(T,const SphereThetaPhi<T>&)
271 \brief Operator SphereThetaPhi = constant / SphereThetaPhi */
272template <class T> inline SphereThetaPhi<T> operator / (T b, const SphereThetaPhi<T>& a)
273 {SphereThetaPhi<T> result; result.CloneOrShare(a); result.SetTemp(true);
274 result.Div(b, true); return result;}
275
276////////////////////////////////////////////////////////////////
277// Surcharge d'operateurs C = A (+,-) B
278
279/*! \ingroup SkyMap \fn operator+(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
280 \brief Operator SphereThetaPhi = SphereThetaPhi + SphereThetaPhi */
281template <class T>
282inline SphereThetaPhi<T> operator + (const SphereThetaPhi<T>& a,const SphereThetaPhi<T>& b)
283 { SphereThetaPhi<T> result; result.SetTemp(true);
284 if (b.IsTemp()) { result.Share(b); result.AddElt(a); }
285 else { result.CloneOrShare(a); result.AddElt(b); }
286 return result; }
287
288/*! \ingroup SkyMap \fn operator-(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
289 \brief Operator SphereThetaPhi = SphereThetaPhi - SphereThetaPhi */
290template <class T>
291inline SphereThetaPhi<T> operator - (const SphereThetaPhi<T>& a,const SphereThetaPhi<T>& b)
292 { SphereThetaPhi<T> result; result.SetTemp(true);
293 result.CloneOrShare(a); result.SubElt(b);
294 return result; }
295
296////////////////////////////////////////////////////////////////
297// Surcharge d'operateurs C = A (*,/) B
298
299/*! \ingroup SkyMap \fn operator*(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
300 \brief Operator SphereThetaPhi = SphereThetaPhi * SphereThetaPhi (pixel by pixel multiply)*/
301template <class T>
302inline SphereThetaPhi<T> operator * (const SphereThetaPhi<T>& a,const SphereThetaPhi<T>& b)
303 { SphereThetaPhi<T> result; result.SetTemp(true);
304 if (b.IsTemp()) { result.Share(b); result.MulElt(a); }
305 else { result.CloneOrShare(a); result.MulElt(b); }
306 return result; }
307
308/*! \ingroup SkyMap \fn operator/(const SphereThetaPhi<T>&,const SphereThetaPhi<T>&)
309 \brief Operator SphereThetaPhi = SphereThetaPhi / SphereThetaPhi (pixel by pixel divide) */
310template <class T>
311inline SphereThetaPhi<T> operator / (const SphereThetaPhi<T>& a,const SphereThetaPhi<T>& b)
312 { SphereThetaPhi<T> result; result.SetTemp(true);
313 result.CloneOrShare(a); result.DivElt(b);
314 return result; }
315
316
317} // Fin du namespace
318
319#endif
Note: See TracBrowser for help on using the repository browser.