Healpix C++  3.50
alm_healpix_tools.cc
1 /*
2  * This file is part of Healpix_cxx.
3  *
4  * Healpix_cxx is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * Healpix_cxx is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with Healpix_cxx; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17  *
18  * For more information about HEALPix, see http://healpix.sourceforge.net
19  */
20 
21 /*
22  * Healpix_cxx is being developed at the Max-Planck-Institut fuer Astrophysik
23  * and financially supported by the Deutsches Zentrum fuer Luft- und Raumfahrt
24  * (DLR).
25  */
26 
27 /*
28  * Copyright (C) 2003-2017 Max-Planck-Society
29  * Author: Martin Reinecke
30  */
31 
32 #include "alm_healpix_tools.h"
33 #include "alm.h"
34 #include "healpix_map.h"
35 #include "xcomplex.h"
36 #include "sharp_cxx.h"
37 
38 using namespace std;
39 
40 namespace {
41 
42 void checkLmaxNside(tsize lmax, tsize nside)
43  {
44  if (lmax>4*nside)
45  cout << "\nWARNING: map analysis requested with lmax>4*nside...\n"
46  "is this really what you want?\n\n";
47  }
48 
49 }
50 
51 template<typename T> void map2alm (const Healpix_Map<T> &map,
52  Alm<xcomplex<T> > &alm, const arr<double> &weight, bool add_alm)
53  {
54  planck_assert (map.Scheme()==RING, "map2alm: map must be in RING scheme");
55  planck_assert (int(weight.size())>=2*map.Nside(),
56  "map2alm: weight array has too few entries");
57  planck_assert (map.fullyDefined(),"map contains undefined pixels");
58  checkLmaxNside(alm.Lmax(), map.Nside());
59 
60  sharp_cxxjob<T> job;
61  job.set_weighted_Healpix_geometry (map.Nside(),&weight[0]);
62  job.set_triangular_alm_info (alm.Lmax(), alm.Mmax());
63  job.map2alm(&map[0], &alm(0,0), add_alm);
64  }
65 
66 template void map2alm (const Healpix_Map<float> &map,
67  Alm<xcomplex<float> > &alm, const arr<double> &weight,
68  bool add_alm);
69 template void map2alm (const Healpix_Map<double> &map,
70  Alm<xcomplex<double> > &alm, const arr<double> &weight,
71  bool add_alm);
72 
73 template<typename T> void alm2map_adjoint (const Healpix_Map<T> &map,
74  Alm<xcomplex<T> > &alm, bool add_alm)
75  {
76  planck_assert (map.Scheme()==RING,
77  "alm2map_adjoint: map must be in RING scheme");
78  planck_assert (map.fullyDefined(),"map contains undefined pixels");
79  checkLmaxNside(alm.Lmax(), map.Nside());
80 
81  sharp_cxxjob<T> job;
82  job.set_Healpix_geometry (map.Nside());
83  job.set_triangular_alm_info (alm.Lmax(), alm.Mmax());
84  job.alm2map_adjoint(&map[0], &alm(0,0), add_alm);
85  }
86 
87 template void alm2map_adjoint (const Healpix_Map<float> &map,
88  Alm<xcomplex<float> > &alm, bool add_alm);
89 template void alm2map_adjoint (const Healpix_Map<double> &map,
90  Alm<xcomplex<double> > &alm, bool add_alm);
91 
92 template<typename T> void map2alm_iter (const Healpix_Map<T> &map,
93  Alm<xcomplex<T> > &alm, int num_iter, const arr<double> &weight)
94  {
95  map2alm(map,alm,weight);
96  for (int iter=1; iter<=num_iter; ++iter)
97  {
98  Healpix_Map<T> map2(map.Nside(),map.Scheme(),SET_NSIDE);
99  alm2map(alm,map2);
100  for (int m=0; m<map.Npix(); ++m)
101  map2[m] = map[m]-map2[m];
102  map2alm(map2,alm,weight,true);
103  }
104  }
105 
106 template void map2alm_iter (const Healpix_Map<float> &map,
107  Alm<xcomplex<float> > &alm, int num_iter,
108  const arr<double> &weight);
109 template void map2alm_iter (const Healpix_Map<double> &map,
110  Alm<xcomplex<double> > &alm, int num_iter,
111  const arr<double> &weight);
112 
113 template<typename T> void map2alm_iter2 (const Healpix_Map<T> &map,
114  Alm<xcomplex<T> > &alm, double err_abs, double err_rel)
115  {
116  double x_err_abs=1./err_abs, x_err_rel=1./err_rel;
117  arr<double> wgt(2*map.Nside());
118  wgt.fill(1);
119  Healpix_Map<T> map2(map);
120  alm.SetToZero();
121  while(true)
122  {
123  map2alm(map2,alm,wgt,true);
124  alm2map(alm,map2);
125  double errmeasure=0;
126  for (int m=0; m<map.Npix(); ++m)
127  {
128  double err = abs(map[m]-map2[m]);
129  double rel = (map[m]!=0) ? abs(err/map[m]) : 1e300;
130  errmeasure = max(errmeasure,min(err*x_err_abs,rel*x_err_rel));
131  map2[m] = map[m]-map2[m];
132  }
133 //cout << errmeasure << endl;
134  if (errmeasure<1) break;
135  }
136  }
137 
138 template void map2alm_iter2 (const Healpix_Map<double> &map,
139  Alm<xcomplex<double> > &alm, double err_abs, double err_rel);
140 
141 
142 template<typename T> void map2alm_spin
143  (const Healpix_Map<T> &map1, const Healpix_Map<T> &map2,
144  Alm<xcomplex<T> > &alm1, Alm<xcomplex<T> > &alm2,
145  int spin, const arr<double> &weight, bool add_alm)
146  {
147  planck_assert (map1.Scheme()==RING,
148  "map2alm_spin: maps must be in RING scheme");
149  planck_assert (map1.conformable(map2),
150  "map2alm_spin: maps are not conformable");
151  planck_assert (alm1.conformable(alm1),
152  "map2alm_spin: a_lm are not conformable");
153  planck_assert (int(weight.size())>=2*map1.Nside(),
154  "map2alm_spin: weight array has too few entries");
155  planck_assert (map1.fullyDefined()&&map2.fullyDefined(),
156  "map contains undefined pixels");
157  checkLmaxNside(alm1.Lmax(), map1.Nside());
158 
159  sharp_cxxjob<T> job;
160  job.set_weighted_Healpix_geometry (map1.Nside(),&weight[0]);
161  job.set_triangular_alm_info (alm1.Lmax(), alm1.Mmax());
162  job.map2alm_spin(&map1[0],&map2[0],&alm1(0,0),&alm2(0,0),spin,add_alm);
163  }
164 
165 template void map2alm_spin
166  (const Healpix_Map<float> &map1, const Healpix_Map<float> &map2,
167  Alm<xcomplex<float> > &alm1, Alm<xcomplex<float> > &alm2,
168  int spin, const arr<double> &weight, bool add_alm);
169 template void map2alm_spin
170  (const Healpix_Map<double> &map1, const Healpix_Map<double> &map2,
171  Alm<xcomplex<double> > &alm1, Alm<xcomplex<double> > &alm2,
172  int spin, const arr<double> &weight, bool add_alm);
173 
174 template<typename T> void alm2map_spin_adjoint
175  (const Healpix_Map<T> &map1, const Healpix_Map<T> &map2,
176  Alm<xcomplex<T> > &alm1, Alm<xcomplex<T> > &alm2,
177  int spin, bool add_alm)
178  {
179  planck_assert (map1.Scheme()==RING,
180  "alm2map_spin_adjoint: maps must be in RING scheme");
181  planck_assert (map1.conformable(map2),
182  "alm2map_spin_adjoint: maps are not conformable");
183  planck_assert (alm1.conformable(alm1),
184  "alm2map_spin_adjoint: a_lm are not conformable");
185  planck_assert (map1.fullyDefined()&&map2.fullyDefined(),
186  "map contains undefined pixels");
187  checkLmaxNside(alm1.Lmax(), map1.Nside());
188 
189  sharp_cxxjob<T> job;
190  job.set_Healpix_geometry (map1.Nside());
191  job.set_triangular_alm_info (alm1.Lmax(), alm1.Mmax());
192  job.alm2map_spin_adjoint(&map1[0],&map2[0],&alm1(0,0),&alm2(0,0),spin,
193  add_alm);
194  }
195 
196 template void alm2map_spin_adjoint
197  (const Healpix_Map<float> &map1, const Healpix_Map<float> &map2,
198  Alm<xcomplex<float> > &alm1, Alm<xcomplex<float> > &alm2,
199  int spin, bool add_alm);
200 template void alm2map_spin_adjoint
201  (const Healpix_Map<double> &map1, const Healpix_Map<double> &map2,
202  Alm<xcomplex<double> > &alm1, Alm<xcomplex<double> > &alm2,
203  int spin, bool add_alm);
204 
205 template<typename T> void map2alm_spin_iter2
206  (const Healpix_Map<T> &map1, const Healpix_Map<T> &map2,
207  Alm<xcomplex<T> > &alm1, Alm<xcomplex<T> > &alm2,
208  int spin, double err_abs, double err_rel)
209  {
210  arr<double> wgt(2*map1.Nside());
211  wgt.fill(1);
212  Healpix_Map<T> map1b(map1), map2b(map2);
213  alm1.SetToZero(); alm2.SetToZero();
214  while(true)
215  {
216  map2alm_spin(map1b,map2b,alm1,alm2,spin,wgt,true);
217  alm2map_spin(alm1,alm2,map1b,map2b,spin);
218  double errmeasure=0;
219  for (int m=0; m<map1.Npix(); ++m)
220  {
221  double err = abs(map1[m]-map1b[m]);
222  double rel = (map1[m]!=0) ? abs(err/map1[m]) : 1e300;
223  errmeasure = max(errmeasure,min(err/err_abs,rel/err_rel));
224  map1b[m] = map1[m]-map1b[m];
225  err = abs(map2[m]-map2b[m]);
226  rel = (map2[m]!=0) ? abs(err/map2[m]) : 1e300;
227  errmeasure = max(errmeasure,min(err/err_abs,rel/err_rel));
228  map2b[m] = map2[m]-map2b[m];
229  }
230 //cout << errmeasure << endl;
231  if (errmeasure<1) break;
232  }
233  }
234 
235 template void map2alm_spin_iter2
236  (const Healpix_Map<double> &map1, const Healpix_Map<double> &map2,
237  Alm<xcomplex<double> > &alm1, Alm<xcomplex<double> > &alm2,
238  int spin, double err_abs, double err_rel);
239 
240 template<typename T> void map2alm_pol
241  (const Healpix_Map<T> &mapT,
242  const Healpix_Map<T> &mapQ,
243  const Healpix_Map<T> &mapU,
244  Alm<xcomplex<T> > &almT,
245  Alm<xcomplex<T> > &almG,
246  Alm<xcomplex<T> > &almC,
247  const arr<double> &weight,
248  bool add_alm)
249  {
250  planck_assert (mapT.Scheme()==RING,
251  "map2alm_pol: maps must be in RING scheme");
252  planck_assert (mapT.conformable(mapQ) && mapT.conformable(mapU),
253  "map2alm_pol: maps are not conformable");
254  planck_assert (almT.conformable(almG) && almT.conformable(almC),
255  "map2alm_pol: a_lm are not conformable");
256  planck_assert (int(weight.size())>=2*mapT.Nside(),
257  "map2alm_pol: weight array has too few entries");
258  planck_assert (mapT.fullyDefined()&&mapQ.fullyDefined()&&mapU.fullyDefined(),
259  "map contains undefined pixels");
260  checkLmaxNside(almT.Lmax(), mapT.Nside());
261 
262  sharp_cxxjob<T> job;
263  job.set_weighted_Healpix_geometry (mapT.Nside(),&weight[0]);
264  job.set_triangular_alm_info (almT.Lmax(), almT.Mmax());
265  job.map2alm(&mapT[0], &almT(0,0), add_alm);
266  job.map2alm_spin(&mapQ[0],&mapU[0],&almG(0,0),&almC(0,0),2,add_alm);
267  }
268 
269 template void map2alm_pol
270  (const Healpix_Map<float> &mapT,
271  const Healpix_Map<float> &mapQ,
272  const Healpix_Map<float> &mapU,
273  Alm<xcomplex<float> > &almT,
274  Alm<xcomplex<float> > &almG,
275  Alm<xcomplex<float> > &almC,
276  const arr<double> &weight,
277  bool add_alm);
278 template void map2alm_pol
279  (const Healpix_Map<double> &mapT,
280  const Healpix_Map<double> &mapQ,
281  const Healpix_Map<double> &mapU,
282  Alm<xcomplex<double> > &almT,
283  Alm<xcomplex<double> > &almG,
284  Alm<xcomplex<double> > &almC,
285  const arr<double> &weight,
286  bool add_alm);
287 
288 template<typename T> void alm2map_pol_adjoint
289  (const Healpix_Map<T> &mapT,
290  const Healpix_Map<T> &mapQ,
291  const Healpix_Map<T> &mapU,
292  Alm<xcomplex<T> > &almT,
293  Alm<xcomplex<T> > &almG,
294  Alm<xcomplex<T> > &almC,
295  bool add_alm)
296  {
297  planck_assert (mapT.Scheme()==RING,
298  "alm2map_pol_adjoint: maps must be in RING scheme");
299  planck_assert (mapT.conformable(mapQ) && mapT.conformable(mapU),
300  "alm2map_pol_adjoint: maps are not conformable");
301  planck_assert (almT.conformable(almG) && almT.conformable(almC),
302  "alm2map_pol_adjoint: a_lm are not conformable");
303  planck_assert (mapT.fullyDefined()&&mapQ.fullyDefined()&&mapU.fullyDefined(),
304  "map contains undefined pixels");
305  checkLmaxNside(almT.Lmax(), mapT.Nside());
306 
307  sharp_cxxjob<T> job;
308  job.set_Healpix_geometry (mapT.Nside());
309  job.set_triangular_alm_info (almT.Lmax(), almT.Mmax());
310  job.alm2map_adjoint(&mapT[0], &almT(0,0), add_alm);
311  job.alm2map_spin_adjoint(&mapQ[0],&mapU[0],&almG(0,0),&almC(0,0),2,add_alm);
312  }
313 
314 template void alm2map_pol_adjoint
315  (const Healpix_Map<float> &mapT,
316  const Healpix_Map<float> &mapQ,
317  const Healpix_Map<float> &mapU,
318  Alm<xcomplex<float> > &almT,
319  Alm<xcomplex<float> > &almG,
320  Alm<xcomplex<float> > &almC,
321  bool add_alm);
322 template void alm2map_pol_adjoint
323  (const Healpix_Map<double> &mapT,
324  const Healpix_Map<double> &mapQ,
325  const Healpix_Map<double> &mapU,
326  Alm<xcomplex<double> > &almT,
327  Alm<xcomplex<double> > &almG,
328  Alm<xcomplex<double> > &almC,
329  bool add_alm);
330 
331 template<typename T> void map2alm_pol_iter
332  (const Healpix_Map<T> &mapT,
333  const Healpix_Map<T> &mapQ,
334  const Healpix_Map<T> &mapU,
335  Alm<xcomplex<T> > &almT,
336  Alm<xcomplex<T> > &almG,
337  Alm<xcomplex<T> > &almC,
338  int num_iter,
339  const arr<double> &weight)
340  {
341  map2alm_pol(mapT,mapQ,mapU,almT,almG,almC,weight);
342  for (int iter=1; iter<=num_iter; ++iter)
343  {
344  Healpix_Map<T> mapT2(mapT.Nside(),mapT.Scheme(),SET_NSIDE),
345  mapQ2(mapT.Nside(),mapT.Scheme(),SET_NSIDE),
346  mapU2(mapT.Nside(),mapT.Scheme(),SET_NSIDE);
347 
348  alm2map_pol(almT,almG,almC,mapT2,mapQ2,mapU2);
349  for (int m=0; m<mapT.Npix(); ++m)
350  {
351  mapT2[m] = mapT[m]-mapT2[m];
352  mapQ2[m] = mapQ[m]-mapQ2[m];
353  mapU2[m] = mapU[m]-mapU2[m];
354  }
355  map2alm_pol(mapT2,mapQ2,mapU2,almT,almG,almC,weight,true);
356  }
357  }
358 
359 template void map2alm_pol_iter
360  (const Healpix_Map<float> &mapT,
361  const Healpix_Map<float> &mapQ,
362  const Healpix_Map<float> &mapU,
363  Alm<xcomplex<float> > &almT,
364  Alm<xcomplex<float> > &almG,
365  Alm<xcomplex<float> > &almC,
366  int num_iter,
367  const arr<double> &weight);
368 template void map2alm_pol_iter
369  (const Healpix_Map<double> &mapT,
370  const Healpix_Map<double> &mapQ,
371  const Healpix_Map<double> &mapU,
372  Alm<xcomplex<double> > &almT,
373  Alm<xcomplex<double> > &almG,
374  Alm<xcomplex<double> > &almC,
375  int num_iter,
376  const arr<double> &weight);
377 
378 template<typename T> void map2alm_pol_iter2
379  (const Healpix_Map<T> &mapT,
380  const Healpix_Map<T> &mapQ,
381  const Healpix_Map<T> &mapU,
382  Alm<xcomplex<T> > &almT,
383  Alm<xcomplex<T> > &almG,
384  Alm<xcomplex<T> > &almC,
385  double err_abs, double err_rel)
386  {
387  arr<double> wgt(2*mapT.Nside());
388  wgt.fill(1);
389  Healpix_Map<T> mapT2(mapT), mapQ2(mapQ), mapU2(mapU);
390  almT.SetToZero(); almG.SetToZero(); almC.SetToZero();
391  while(true)
392  {
393  map2alm_pol(mapT2,mapQ2,mapU2,almT,almG,almC,wgt,true);
394  alm2map_pol(almT,almG,almC,mapT2,mapQ2,mapU2);
395  double errmeasure=0;
396  for (int m=0; m<mapT.Npix(); ++m)
397  {
398  double err = abs(mapT[m]-mapT2[m]);
399  double rel = (mapT[m]!=0) ? abs(err/mapT[m]) : 1e300;
400  errmeasure = max(errmeasure,min(err/err_abs,rel/err_rel));
401  mapT2[m] = mapT[m]-mapT2[m];
402  err = abs(mapQ[m]-mapQ2[m]);
403  rel = (mapQ[m]!=0) ? abs(err/mapQ[m]) : 1e300;
404  errmeasure = max(errmeasure,min(err/err_abs,rel/err_rel));
405  mapQ2[m] = mapQ[m]-mapQ2[m];
406  err = abs(mapU[m]-mapU2[m]);
407  rel = (mapU[m]!=0) ? abs(err/mapU[m]) : 1e300;
408  errmeasure = max(errmeasure,min(err/err_abs,rel/err_rel));
409  mapU2[m] = mapU[m]-mapU2[m];
410  }
411 //cout << errmeasure << endl;
412  if (errmeasure<1) break;
413  }
414  }
415 
416 template void map2alm_pol_iter2
417  (const Healpix_Map<double> &mapT,
418  const Healpix_Map<double> &mapQ,
419  const Healpix_Map<double> &mapU,
420  Alm<xcomplex<double> > &almT,
421  Alm<xcomplex<double> > &almG,
422  Alm<xcomplex<double> > &almC,
423  double err_abs, double err_rel);
424 
425 
426 template<typename T> void alm2map (const Alm<xcomplex<T> > &alm,
427  Healpix_Map<T> &map, bool add_map)
428  {
429  planck_assert (map.Scheme()==RING, "alm2map: map must be in RING scheme");
430 
431  sharp_cxxjob<T> job;
432  job.set_Healpix_geometry (map.Nside());
433  job.set_triangular_alm_info (alm.Lmax(), alm.Mmax());
434  job.alm2map(&alm(0,0), &map[0], add_map);
435  }
436 
437 template void alm2map (const Alm<xcomplex<double> > &alm,
438  Healpix_Map<double> &map, bool add_map);
439 template void alm2map (const Alm<xcomplex<float> > &alm,
440  Healpix_Map<float> &map, bool add_map);
441 
442 template<typename T> void alm2map_spin
443  (const Alm<xcomplex<T> > &alm1, const Alm<xcomplex<T> > &alm2,
444  Healpix_Map<T> &map1, Healpix_Map<T> &map2, int spin, bool add_map)
445  {
446  planck_assert (map1.Scheme()==RING,
447  "alm2map_spin: maps must be in RING scheme");
448  planck_assert (map1.conformable(map2),
449  "alm2map_spin: maps are not conformable");
450  planck_assert (alm1.conformable(alm2),
451  "alm2map_spin: a_lm are not conformable");
452 
453  sharp_cxxjob<T> job;
454  job.set_Healpix_geometry (map1.Nside());
455  job.set_triangular_alm_info (alm1.Lmax(), alm1.Mmax());
456  job.alm2map_spin(&alm1(0,0),&alm2(0,0),&map1[0],&map2[0],spin,add_map);
457  }
458 
459 template void alm2map_spin
460  (const Alm<xcomplex<double> > &alm1, const Alm<xcomplex<double> > &alm2,
461  Healpix_Map<double> &map, Healpix_Map<double> &map2, int spin, bool add_map);
462 template void alm2map_spin
463  (const Alm<xcomplex<float> > &alm1, const Alm<xcomplex<float> > &alm2,
464  Healpix_Map<float> &map, Healpix_Map<float> &map2, int spin, bool add_map);
465 
466 
467 template<typename T> void alm2map_pol
468  (const Alm<xcomplex<T> > &almT,
469  const Alm<xcomplex<T> > &almG,
470  const Alm<xcomplex<T> > &almC,
471  Healpix_Map<T> &mapT,
472  Healpix_Map<T> &mapQ,
473  Healpix_Map<T> &mapU,
474  bool add_map)
475  {
476  planck_assert (mapT.Scheme()==RING,
477  "alm2map_pol: maps must be in RING scheme");
478  planck_assert (mapT.conformable(mapQ) && mapT.conformable(mapU),
479  "alm2map_pol: maps are not conformable");
480  planck_assert (almT.conformable(almG) && almT.conformable(almC),
481  "alm2map_pol: a_lm are not conformable");
482 
483  sharp_cxxjob<T> job;
484  job.set_Healpix_geometry (mapT.Nside());
485  job.set_triangular_alm_info (almT.Lmax(), almT.Mmax());
486  job.alm2map(&almT(0,0), &mapT[0], add_map);
487  job.alm2map_spin(&almG(0,0), &almC(0,0), &mapQ[0], &mapU[0], 2, add_map);
488  }
489 
490 template void alm2map_pol (const Alm<xcomplex<double> > &almT,
491  const Alm<xcomplex<double> > &almG,
492  const Alm<xcomplex<double> > &almC,
493  Healpix_Map<double> &mapT,
494  Healpix_Map<double> &mapQ,
495  Healpix_Map<double> &mapU,
496  bool add_map);
497 
498 template void alm2map_pol (const Alm<xcomplex<float> > &almT,
499  const Alm<xcomplex<float> > &almG,
500  const Alm<xcomplex<float> > &almC,
501  Healpix_Map<float> &mapT,
502  Healpix_Map<float> &mapQ,
503  Healpix_Map<float> &mapU,
504  bool add_map);
505 
506 
507 template<typename T> void alm2map_der1
508  (const Alm<xcomplex<T> > &alm,
509  Healpix_Map<T> &map,
510  Healpix_Map<T> &mapdth,
511  Healpix_Map<T> &mapdph)
512  {
513  planck_assert (map.Scheme()==RING,
514  "alm2map_der1: maps must be in RING scheme");
515  planck_assert (map.conformable(mapdth) && map.conformable(mapdph),
516  "alm2map_der1: maps are not conformable");
517 
518  sharp_cxxjob<T> job;
519  job.set_Healpix_geometry (map.Nside());
520  job.set_triangular_alm_info (alm.Lmax(), alm.Mmax());
521  job.alm2map(&alm(0,0), &map[0], false);
522  job.alm2map_der1(&alm(0,0), &mapdth[0], &mapdph[0], false);
523  }
524 
525 template void alm2map_der1 (const Alm<xcomplex<double> > &alm,
526  Healpix_Map<double> &map,
527  Healpix_Map<double> &map_dth,
528  Healpix_Map<double> &map_dph);
529 
530 template void alm2map_der1 (const Alm<xcomplex<float> > &alm,
531  Healpix_Map<float> &map,
532  Healpix_Map<float> &map_dth,
533  Healpix_Map<float> &map_dph);
bool fullyDefined() const
Definition: healpix_map.h:296
void alm2map_der1(const Alm< xcomplex< T > > &alm, Healpix_Map< T > &map, Healpix_Map< T > &mapdth, Healpix_Map< T > &mapdph)
I Nside() const
Definition: healpix_base.h:427
void fill(const double &val)
Definition: alm.h:88
void map2alm_pol(const Healpix_Map< T > &mapT, const Healpix_Map< T > &mapQ, const Healpix_Map< T > &mapU, Alm< xcomplex< T > > &almT, Alm< xcomplex< T > > &almG, Alm< xcomplex< T > > &almC, const arr< double > &weight, bool add_alm)
void map2alm(const Healpix_Map< T > &map, Alm< xcomplex< T > > &alm, const arr< double > &weight, bool add_alm)
void map2alm_pol_iter(const Healpix_Map< T > &mapT, const Healpix_Map< T > &mapQ, const Healpix_Map< T > &mapU, Alm< xcomplex< T > > &almT, Alm< xcomplex< T > > &almG, Alm< xcomplex< T > > &almC, int num_iter, const arr< double > &weight)
void alm2map_pol(const Alm< xcomplex< T > > &almT, const Alm< xcomplex< T > > &almG, const Alm< xcomplex< T > > &almC, Healpix_Map< T > &mapT, Healpix_Map< T > &mapQ, Healpix_Map< T > &mapU, bool add_map)
std::size_t tsize
void alm2map_adjoint(const Healpix_Map< T > &map, Alm< xcomplex< T > > &alm, bool add_alm)
Healpix_Ordering_Scheme Scheme() const
Definition: healpix_base.h:431
void map2alm_iter(const Healpix_Map< T > &map, Alm< xcomplex< T > > &alm, int num_iter, const arr< double > &weight)
void alm2map(const Alm< xcomplex< T > > &alm, Healpix_Map< T > &map, bool add_map)
#define planck_assert(testval, msg)
bool conformable(const T_Healpix_Base &other) const
Definition: healpix_base.h:435
tsize size() const
I Npix() const
Definition: healpix_base.h:429

Generated on Mon Dec 10 2018 10:24:22 for Healpix C++