Debian Codegraph @

gov/fnal/eag/healpix/test/PixToolsStaticTest.java

raw
1 package gov.fnal.eag.healpix.test;
2
3
4 import java.io.File;
5 import java.io.FileNotFoundException;
6 import java.io.OutputStream;
7 import java.io.PrintStream;
8 import java.util.ArrayList;
9 import gov.fnal.eag.healpix.BitManipulation;
10 import gov.fnal.eag.healpix.PixTools;
11
12 import javax.vecmath.Vector3d;
13
14 import junit.framework.TestCase;
15
16 /**
17 * test suit for PixTools using static constructor
18 *
19 * @author N. Kuropatkin
20 *
21 */
22
23 public class PixToolsStaticTest extends TestCase {
24 private static PixTools pixTools = new PixTools();
25
26 /**
27 * test MODULO function
28 */
29 public void testMODULO() {
30 //
31 double A = 8.;
32 double B = 5.;
33 double res = BitManipulation.MODULO(A, B);
34 assertEquals("modulo = " + res, 3., res, 1e-10);
35 A = -8.;
36 B = 5.;
37 res = BitManipulation.MODULO(A, B);
38 assertEquals("modulo = " + res, 2., res, 1e-10);
39 A = 8.;
40 B = -5.;
41 res = BitManipulation.MODULO(A, B);
42 assertEquals("modulo = " + res, -2., res, 1e-10);
43 A = -8.;
44 B = -5.;
45 res = BitManipulation.MODULO(A, B);
46 assertEquals("modulo = " + res, -3., res, 1e-10);
47 System.out.println(" test MODULO is done");
48 }
49
50 /**
51 * tests angular distance calculation
52 * @throws Exception
53 */
54 public void testAngDist() throws Exception {
55 Vector3d v1 = new Vector3d(1.5, 1.6, 2.0);
56 Vector3d v2 = new Vector3d(1.2, 1.0, 1.5);
57
58 double res1 = pixTools.AngDist(v1, v2);
59 double res2 = v1.angle(v2);
60 System.out.println("res1 = " + res1 + " res2=" + res2);
61 assertEquals("angular Distance=" + res2, 1.0, res1 / res2, 1e-10);
62
63
64 Vector3d v3 = new Vector3d(1.5, 1.6, 0.);
65 Vector3d v4 = new Vector3d(1.5, 1.601, 0.);
66 double res3 = pixTools.AngDist(v3, v4);
67 double res4 = v3.angle(v4);
68 //
69 System.out.println("res3 = " + res3 + " res4=" + res4);
70 assertEquals("angular Distance=" + res4, 1., res3/ res4, 1e-3);
71 Vector3d v5 = new Vector3d(1.5, 1.6, 0.);
72 Vector3d v6 = new Vector3d(-1.5, -1.75, 0.);
73 double res5 = pixTools.AngDist(v5, v6);
74 double res6 = v5.angle(v6);
75 System.out.println("res5 = " + res5 + " res6=" + res6);
76 assertEquals("angular Distance=" + res6, 1.0, res5 / res6, 1e-10);
77 System.out.println(" test of AngDist is done");
78 }
79
80 /**
81 * @throws Exception
82 */
83 public void testSurfaceTriangle() throws Exception {
84 Vector3d v1 = new Vector3d(1.0, 0.0, 0.0);
85 Vector3d v2 = new Vector3d(0.0, 1.0, 0.0);
86 Vector3d v3 = new Vector3d(0.0, 0.0, 1.0);
87 PixTools pt = new PixTools();
88 double res = pixTools.SurfaceTriangle(v1, v2, v3);
89 System.out.println("Triangle surface is=" + res / Math.PI
90 + " steredians");
91 assertEquals("Triangle surface=" + res, 0.5, res / Math.PI, 1e-10);
92 System.out.println(" test of SurfaceTriangle is done");
93 }
94
95 /**
96 * tests calculation of npixels from nside
97 */
98 public void testNside2Npix() {
99 int nside = 1;
100 int npix = 0;
101 npix = (int) pixTools.Nside2Npix(nside);
102 assertEquals("Npix=" + npix, 12, npix, 1e-10);
103 nside = 2;
104 npix = (int) pixTools.Nside2Npix(nside);
105 assertEquals("Npix=" + npix, 48, npix, 1e-10);
106 }
107
108 /**
109 * tests calculation of nsides from npixels
110 */
111 public void testNpix2Nside() {
112 int npix = 12;
113 int nside = 0;
114 nside = (int) pixTools.Npix2Nside(npix);
115
116 double pixSize1 = pixTools.PixRes(65536);
117 long nside1 = pixTools.GetNSide(pixSize1);
118 assertEquals("Nside=" + nside1, 65536, nside1, 1e-10);
119
120 assertEquals("Nside=" + nside, 1, nside, 1e-10);
121
122 }
123
124 /**
125 * test of directional angles calculation
126 */
127 public void testVec2Ang() {
128 double PI = Math.PI;
129 Vector3d v = new Vector3d(0.0, 1.0, 0.0);
130 double[] ang_tup = { 0., 0. };
131 ang_tup = pixTools.Vect2Ang(v);
132 System.out.println(" Theta=" + ang_tup[0] / PI + " Phi=" + ang_tup[1]
133 / PI);
134 assertEquals("Theta=" + ang_tup[0], 0.5, ang_tup[0] / PI, 1e-10);
135 assertEquals("Phi=" + ang_tup[1], 0.5, ang_tup[1] / PI, 1e-10);
136 v = new Vector3d(1.0, 0.0, 0.0);
137 ang_tup = pixTools.Vect2Ang(v);
138 assertEquals("phi=" + ang_tup[1], 0., ang_tup[1] / PI, 1e-10);
139 System.out.println(" test Vect2Ang is done");
140 }
141
142 /**
143 * tests calculation of pixel from polar angles
144 * in ring schema of pixalization
145 * @throws Exception
146 */
147 public void testAng2Pix() throws Exception {
148 System.out.println(" Test ang2pix_ring ___________________");
149 double PI = Math.PI;
150 long pix = -1;
151 double theta = PI / 2. - 0.2;
152 double phi = PI / 2. ;
153 long nside = 4;
154 try {
155 pix = pixTools.ang2pix_ring(nside,theta, phi);
156 } catch (Exception e) {
157 e.printStackTrace();
158 }
159 Vector3d v = pixTools.Ang2Vec(theta,phi);
160 long pix1 = pixTools.vect2pix_ring(nside,v);
161 assertEquals("pix=" + pix, pix1, pix, 1e-10);
162 assertEquals("pix=" + pix, 76, pix, 1e-10);
163
164 long pix2 = pixTools.ang2pix_nest(nside,theta,phi);
165 long pix3 = pixTools.vect2pix_nest(nside,v);
166 assertEquals("pix2=" + pix2, pix3, pix2, 1e-10);
167 assertEquals("pix2=" + pix2, 92, pix2, 1e-10);
168
169
170 double[] radec = pixTools.pix2ang_ring(nside,76);
171 assertEquals("theta=" + theta, theta, radec[0], 4e-2);
172 assertEquals("phi=" + phi, radec[1], phi, 1e-2);
173 double[] radec1 = pixTools.pix2ang_nest(nside,92);
174 System.out.println("theta="+radec1[0]+" phi="+radec1[1]);
175 assertEquals("theta=" + theta, theta, radec1[0], 4e-2);
176 assertEquals("phi=" + phi, radec1[1], phi, 1e-2);
177 System.out.println(" test Ang2Pix is done");
178 }
179
180 /**
181 * tests calculation of unit vector from polar angles
182 * @throws Exception
183 */
184 public void testAng2Vect() throws Exception {
185 System.out.println(" Start test Ang2Vect----------------");
186 double PI = Math.PI;
187 double theta = PI / 2.;
188 double phi = PI / 2;
189 Vector3d v = pixTools.Ang2Vec(theta, phi);
190 System.out.println("Vector x=" + v.x + " y=" + v.y + " z=" + v.z);
191 assertEquals("x=" + v.x, 0., v.x, 1e-10);
192 assertEquals("y=" + v.y, 1., v.y, 1e-10);
193 assertEquals("z=" + v.z, 0., v.z, 1e-10);
194 System.out.println(" test Ang2Vect is done");
195 }
196
197 /**
198 * tests calculation of ring number from z coordinate
199 * @throws Exception
200 */
201 public void testRingNum() throws Exception {
202 double z = 0.25;
203 int nside = 1;
204 System.out.println("Start test RingNum !!!!!!!!!!!!!!!!!!!!");
205 int nring = (int) pixTools.RingNum(nside, z);
206 System.out.println("z=" + z + " ring number =" + nring);
207 assertEquals("z=" + z, 2, nring, 1e-10);
208 z = -0.25;
209 nring = (int) pixTools.RingNum(nside, z);
210 assertEquals("z=" + z, 2, nring, 1e-10);
211 z = 0.8;
212 nring = (int) pixTools.RingNum(nside, z);
213 assertEquals("z=" + z, 1, nring, 1e-10);
214 z = -0.8;
215 nring = (int) pixTools.RingNum(nside, z);
216 assertEquals("z=" + z, 3, nring, 1e-10);
217 System.out.println(" test RingNum is done");
218 nside = 4;
219 int pix = 3;
220 Vector3d v = pixTools.pix2vect_ring(nside, pix);
221 z = v.z;
222 nring = (int) pixTools.RingNum(nside, z);
223 assertEquals("z=" + z, 1, nring, 1e-10);
224 pix = 11;
225 v = pixTools.pix2vect_ring(nside, pix);
226 z = v.z;
227 nring = (int) pixTools.RingNum(nside, z);
228 assertEquals("z=" + z, 2, nring, 1e-10);
229 pix = 23;
230 v = pixTools.pix2vect_ring(nside, pix);
231 z = v.z;
232 nring = (int) pixTools.RingNum(nside, z);
233 assertEquals("z=" + z, 3, nring, 1e-10);
234 pix = 39;
235 v = pixTools.pix2vect_ring(nside, pix);
236 z = v.z;
237 nring = (int) pixTools.RingNum(nside, z);
238 assertEquals("z=" + z, 4, nring, 1e-10);
239 pix = 55;
240 v = pixTools.pix2vect_ring(nside, pix);
241 z = v.z;
242 nring = (int) pixTools.RingNum(nside, z);
243 assertEquals("z=" + z, 5, nring, 1e-10);
244 pix = 71;
245 v = pixTools.pix2vect_ring(nside, pix);
246 z = v.z;
247 nring = (int) pixTools.RingNum(nside, z);
248 assertEquals("z=" + z, 6, nring, 1e-10);
249 pix = 87;
250 v = pixTools.pix2vect_ring(nside, pix);
251 z = v.z;
252 nring = (int) pixTools.RingNum(nside, z);
253 assertEquals("z=" + z, 7, nring, 1e-10);
254 pix = 103;
255 v = pixTools.pix2vect_ring(nside, pix);
256 z = v.z;
257 nring = (int) pixTools.RingNum(nside, z);
258 assertEquals("z=" + z, 8, nring, 1e-10);
259 pix = 119;
260 v = pixTools.pix2vect_ring(nside, pix);
261 z = v.z;
262 nring = (int) pixTools.RingNum(nside, z);
263 assertEquals("z=" + z, 9, nring, 1e-10);
264 pix = 135;
265 v = pixTools.pix2vect_ring(nside, pix);
266 z = v.z;
267 nring = (int) pixTools.RingNum(nside, z);
268 assertEquals("z=" + z, 10, nring, 1e-10);
269 pix = 151;
270 v = pixTools.pix2vect_ring(nside, pix);
271 z = v.z;
272 nring = (int) pixTools.RingNum(nside, z);
273 assertEquals("z=" + z, 11, nring, 1e-10);
274 pix = 167;
275 v = pixTools.pix2vect_ring(nside, pix);
276 z = v.z;
277 nring = (int) pixTools.RingNum(nside, z);
278 assertEquals("z=" + z, 12, nring, 1e-10);
279 pix = 169;
280 v = pixTools.pix2vect_ring(nside, pix);
281 z = v.z;
282 nring = (int) pixTools.RingNum(nside, z);
283 assertEquals("z=" + z, 13, nring, 1e-10);
284 pix = 180;
285 v = pixTools.pix2vect_ring(nside, pix);
286 z = v.z;
287 nring = (int) pixTools.RingNum(nside, z);
288 assertEquals("z=" + z, 14, nring, 1e-10);
289 System.out.println("End test RingNum");
290 }
291
292 /**
293 * tests conversion from nest schema pixel to ring schema pixel
294 * @throws Exception
295 */
296 public void testNest2Ring() throws Exception {
297 int ipnest = 3;
298 int nside = 2;
299 int ipring = (int) pixTools.nest2ring(nside, ipnest);
300 assertEquals("ipring=" + ipring, 0, ipring, 1e-10);
301 ipnest = 0;
302 nside = 2;
303 ipring = (int) pixTools.nest2ring(nside, ipnest);
304 assertEquals("ipring=" + ipring, 13, ipring, 1e-10);
305 ipnest = 18;
306 nside = 2;
307 ipring = (int) pixTools.nest2ring(nside, ipnest);
308 assertEquals("ipring=" + ipring, 27, ipring, 1e-10);
309 ipnest = 23;
310 nside = 2;
311 ipring = (int) pixTools.nest2ring(nside, ipnest);
312 assertEquals("ipring=" + ipring, 14, ipring, 1e-10);
313 ipnest = 5;
314 nside = 4;
315 ipring = (int) pixTools.nest2ring(nside, ipnest);
316 assertEquals("ipring = " + ipring, 27, ipring, 1e-10);
317 System.out.println(" test Nest2Ring is done");
318 }
319
320 /**
321 * tests conversion from ring schema pixel to nest schema pixel
322 * @throws Exception
323 */
324 public void testRing2Nest() throws Exception {
325 System.out.println(" start test Ring2Nest !!!!!!!!!!!!!!!!!!!!!!");
326 int ipring = 0;
327 int nside = 2;
328
329 int ipnest = (int) pixTools.ring2nest(nside, ipring);
330 assertEquals("ipnest=" + ipnest, 3, ipnest, 1e-10);
331 ipring = 13;
332 nside = 2;
333 ipnest = (int) pixTools.ring2nest(nside, ipring);
334 assertEquals("ipnest=" + ipnest, 0, ipnest, 1e-10);
335 ipring = 27;
336 nside = 2;
337 ipnest = (int) pixTools.ring2nest(nside, ipring);
338 assertEquals("ipnest=" + ipnest, 18, ipnest, 1e-10);
339 ipring = 14;
340 nside = 2;
341 ipnest = (int) pixTools.ring2nest(nside, ipring);
342 assertEquals("ipnest=" + ipnest, 23, ipnest, 1e-10);
343 ipring = 27;
344 nside = 4;
345 ipnest = (int) pixTools.ring2nest(nside, ipring);
346 assertEquals("ipnest = " + ipnest, 5, ipnest, 1e-10);
347 ipring = 83;
348 nside = 4;
349 ipnest = (int) pixTools.ring2nest(nside, ipring);
350 assertEquals("ipnest = " + ipnest, 123, ipnest, 1e-10);
351 System.out.println(" test Ring2Nest is done");
352 }
353
354 /**
355 * tests Next_In_Line method for the nest schema
356 * @throws Exception
357 */
358 public void testNext_In_Line_Nest() throws Exception {
359 int ipix = 0;
360 int nside = 2;
361 int ipnext = (int) pixTools.next_in_line_nest(nside, ipix);
362 assertEquals("ipnext=" + ipnext, 23, ipnext, 1e-10);
363 ipix = 1;
364 nside = 2;
365 ipnext = (int) pixTools.next_in_line_nest(nside, ipix);
366 assertEquals("ipnext=" + ipnext, 6, ipnext, 1e-10);
367 ipix = 4;
368 nside = 2;
369 ipnext = (int) pixTools.next_in_line_nest(nside, ipix);
370 assertEquals("ipnext=" + ipnext, 27, ipnext, 1e-10);
371 ipix = 27;
372 nside = 2;
373 ipnext = (int) pixTools.next_in_line_nest(nside, ipix);
374 assertEquals("ipnext=" + ipnext, 8, ipnext, 1e-10);
375 ipix = 12;
376 nside = 2;
377 ipnext = (int) pixTools.next_in_line_nest(nside, ipix);
378 assertEquals("ipnext=" + ipnext, 19, ipnext, 1e-10);
379 ipix = 118;
380 nside = 4;
381 ipnext = (int) pixTools.next_in_line_nest(nside, ipix);
382 assertEquals("ipnext = " + ipnext, 117, ipnext, 1e-10);
383 System.out.println(" test next_in_line_nest is done");
384 }
385
386 /**
387 * tests InRing method
388 * @throws Exception
389 */
390 public void testInRing() throws Exception {
391 System.out.println(" Start test InRing !!!!!!!!!!!!!!!!!!!!!!!!!");
392 int[] nestComp = { 19, 0, 23, 4, 27, 8, 31, 12 };
393 long[] ringHi = {17, 18, 19, 12, 13 };
394 long[] nestHi = { 8, 31, 12, 19, 0 };
395 long[] ringLow = {19, 12, 13, 14, 15 };
396 long[] nestLow = { 12, 19, 0, 23, 4 };
397 double PI = Math.PI;
398 int nside = 2;
399 boolean nest = false;
400 int iz = 3;
401 double phi = PI;
402 double dphi = PI;
403 ArrayList ring = pixTools.InRing(nside, iz, phi, dphi, nest);
404 for (int i = 0; i < ring.size(); i++) {
405 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
406 i + 12, ((Long) ring.get(i)).longValue(), 1e-10);
407 }
408 Vector3d v = new Vector3d(1., 0., 0.);
409 double[] ang_tup = { 0., 0. };
410 ang_tup = pixTools.Vect2Ang(v);
411 phi = ang_tup[1]/PI;
412 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
413 for (int i = 0; i < ring.size(); i++) {
414 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
415 i + 12, ((Long) ring.get(i)).longValue(), 1e-10);
416 }
417 Vector3d v1 = new Vector3d(-1., 0., 0.);
418
419 ang_tup = pixTools.Vect2Ang(v1);
420 phi = ang_tup[1]/PI;
421 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
422 for (int i = 0; i < ring.size(); i++) {
423 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
424 i + 12, ((Long) ring.get(i)).longValue(), 1e-10);
425 }
426 phi = 1.75*PI;
427 dphi = 0.5*PI;
428 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
429 for (int i = 0; i < ring.size(); i++) {
430 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
431 ringHi[i], ((Long) ring.get(i)).longValue(), 1e-10);
432
433 }
434
435 phi = 1.75*PI;
436 dphi = 0.5*PI;
437 nest = true;
438 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
439 for (int i = 0; i < ring.size(); i++) {
440 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
441 nestHi[i], ((Long) ring.get(i)).longValue(), 1e-10);
442
443 }
444 phi = 0.25*PI;
445 dphi = 0.5*PI;
446 nest = false;
447 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
448 for (int i = 0; i < ring.size(); i++) {
449 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
450 ringLow[i], ((Long) ring.get(i)).longValue(), 1e-10);
451
452 }
453 phi = 0.25*PI;
454 dphi = 0.5*PI;
455 nest = true;
456 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
457 for (int i = 0; i < ring.size(); i++) {
458 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
459 nestLow[i], ((Long) ring.get(i)).longValue(), 1e-10);
460
461 }
462
463 nest = true;
464 dphi = PI;
465 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
466 for (int i = 0; i < ring.size(); i++) {
467 assertEquals("ipnext = " + ((Long) ring.get(i)).longValue(),
468 nestComp[i], ((Long) ring.get(i)).longValue(), 1e-10);
469 }
470 nest = false;
471 nside = 4;
472 phi = 2.1598449493429825;
473 iz = 8;
474 dphi = 0.5890486225480867;
475 // System.out.println(" iz="+iz+" phi="+phi+" dphi="+dphi);
476 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
477 // for (int i = 0; i<ring.size(); i++) {
478 // System.out.println("ipnext = "+ ((Integer)ring.get(i)).intValue());
479 // }
480 nest = false;
481 nside = 4;
482 dphi = 0. * PI;
483 iz = 8;
484 phi = 2.1598449493429825;
485 // System.out.println(" iz="+iz+" phi="+phi+" dphi="+dphi);
486 ring = pixTools.InRing(nside, iz, phi, dphi, nest);
487 // for (int i = 0; i<ring.size(); i++) {
488 // System.out.println("ipnext = "+ ((Integer)ring.get(i)).intValue());
489 // }
490 System.out.println(" test InRing is done");
491 }
492
493 /**
494 * tests Neighbour's method for nest schema of the pixelization
495 * @throws Exception
496 */
497 public void testNeighbours_Nest() throws Exception {
498 System.out.println(" Start test Neighbours_Nest !!!!!!!!!!!!!!!!!");
499 long nside = 2;
500 long ipix = 25;
501 long[] test17 = { 34, 16, 18, 19, 2, 0, 22, 35 };
502 long[] test32 = { 40, 44, 45, 34, 35, 33, 38, 36 };
503 long[] test3 = { 0, 2, 13, 15, 11, 7, 6, 1 };
504 long[] test25 = { 42, 24, 26, 27, 10, 8, 30, 43 };
505 //
506 ArrayList npixList = new ArrayList();
507 npixList = pixTools.neighbours_nest(nside, ipix);
508 for (int i = 0; i < npixList.size(); i++) {
509 assertEquals("ip = " + ((Long) npixList.get( i)).longValue(),
510 test25[ i], ((Long) npixList.get( i)).longValue(), 1e-10);
511 }
512 ipix = 17;
513
514 npixList = pixTools.neighbours_nest(nside, ipix);
515 for (int i = 0; i < npixList.size(); i++) {
516 assertEquals("ip = " + ((Long) npixList.get(i)).longValue(),
517 test17[i], ((Long) npixList.get(i)).longValue(), 1e-10);
518 }
519 ipix = 32;
520
521 npixList = pixTools.neighbours_nest(nside, ipix);
522 for (int i = 0; i < npixList.size(); i++) {
523 assertEquals("ip = " + ((Long) npixList.get(i)).longValue(),
524 test32[i], ((Long) npixList.get(i)).longValue(), 1e-10);
525 }
526 ipix = 3;
527
528 npixList = pixTools.neighbours_nest(nside, ipix);
529 for (int i = 0; i < npixList.size(); i++) {
530 assertEquals("ip = " + ((Long) npixList.get(i)).longValue(),
531 test3[i], ((Long) npixList.get(i)).longValue(), 1e-10);
532 }
533 System.out.println(" test NeighboursNest is done");
534 }
535
536 /**
537 * tests intrs_intrv method
538 * @throws Exception
539 */
540 public void testIntrs_Intrv() throws Exception {
541 System.out.println(" test intrs_intrv !!!!!!!!!!!!!!!!!!!!!!!!!!!");
542 double[] d1 = { 1.0, 9.0 };
543 double[] d2 = { 3.0, 16.0 };
544 double[] di;
545 // System.out.println("Case "+d1[0]+" "+d1[1]+" | "+d2[0]+" "+d2[1]);
546 di = pixTools.intrs_intrv(d1, d2);
547 // System.out.println("Result "+di[0]+" - "+di[1]);
548 int n12 = di.length / 2;
549 assertEquals("n12 = " + n12, 1, n12, 1e-6);
550 assertEquals("di[0] = " + di[0], 3.0, di[0], 1e-6);
551 assertEquals("di[1] = " + di[1], 9.0, di[1], 1e-6);
552 d1 = new double[] { 0.537, 4.356 };
553 d2 = new double[] { 3.356, 0.8 };
554 // System.out.println("Case "+d1[0]+" "+d1[1]+" | "+d2[0]+" "+d2[1]);
555 di = pixTools.intrs_intrv(d1, d2);
556 n12 = di.length / 2;
557 assertEquals("n12 = " + n12, 2, n12, 1e-6);
558 assertEquals("di[0] = " + di[0], 0.537, di[0], 1e-6);
559 assertEquals("di[1] = " + di[1], 0.8, di[1], 1e-6);
560 assertEquals("di[2] = " + di[2], 3.356, di[2], 1e-6);
561 assertEquals("di[1] = " + di[3], 4.356, di[3], 1e-6);
562
563 d1 = new double[] { 2.356194490092345, 2.356194490292345 };
564 d2 = new double[] { 1.251567, 4.17 };
565 // System.out.println("Case "+d1[0]+" "+d1[1]+" | "+d2[0]+" "+d2[1]);
566 di = pixTools.intrs_intrv(d1, d2);
567 n12 = di.length / 2;
568 assertEquals("n12 = " + n12, 1, n12, 1e-6);
569 assertEquals("di[0] = " + di[0], 2.35619449009, di[0], 1e-6);
570 assertEquals("di[1] = " + di[1], 2.35619449029, di[1], 1e-6);
571
572 System.out.println(" test intrs_intrv is done");
573 }
574
575 /**
576 * tests conversion from pixel number to vector
577 * @throws Exception
578 */
579 public void testPix2Vect_ring() throws Exception {
580 System.out.println("Start test Pix2Vect_ring !!!!!!!!!!!!!!!!!!!");
581 double TWOPI = 2.0 * Math.PI;
582 int nside = 2;
583 int ipix = 0;
584 Vector3d v1 = new Vector3d(0., 0., 0.);
585 v1 = pixTools.pix2vect_ring(nside, ipix);
586 assertEquals("v1.z = " + v1.z, 1.0, v1.z, 1e-1);
587
588 ipix = 20;
589 Vector3d v2 = new Vector3d(0., 0., 0.);
590 v2 = pixTools.pix2vect_ring(nside, ipix);
591 assertEquals("v2.x = " + v2.x, 1.0, v2.x, 1e-1);
592 assertEquals("v2.z = " + v2.z, 0.0, v2.z, 1e-1);
593 ipix = 22;
594 Vector3d v3 = new Vector3d();
595 v3 = pixTools.pix2vect_ring(nside, ipix);
596 assertEquals("v3.y = " + v3.y, 1.0, v3.y, 1e-1);
597 assertEquals("v3.z = " + v3.z, 0.0, v3.z, 1e-1);
598 // System.out.println("Vector3 x="+v3.x+" y="+v3.y+" z="+v3.z);
599 ipix = 95;
600 nside = 4;
601 v1 = pixTools.pix2vect_ring(nside, ipix);
602 v1.normalize();
603 double phi1 = Math.atan2(v1.y, v1.x);
604 double[] tetphi = new double[2];
605 tetphi = pixTools.pix2ang_ring(nside, ipix);
606 assertEquals("phi = " + phi1, 0.0, Math.abs(phi1 - tetphi[1]), 1e-10);
607 ipix = 26;
608 nside = 4;
609 v1 = pixTools.pix2vect_ring(nside, ipix);
610 v1.normalize();
611 phi1 = Math.atan2(v1.y, v1.x);
612 if (phi1 < 0.)
613 phi1 += TWOPI;
614 tetphi = new double[2];
615 tetphi = pixTools.pix2ang_ring(nside, ipix);
616 assertEquals("phi = " + phi1, 0.0, Math.abs(phi1 - tetphi[1]), 1e-10);
617 System.out.println("------------------------------------------");
618 System.out.println(" test pix2vect_ring is done");
619 }
620
621 /**
622 * tests conversion from pixel number to vector
623 * @throws Exception
624 */
625 public void testPix2Vect_nest() throws Exception {
626 double TWOPI = 2.0 * Math.PI;
627 int nside = 2;
628 int ipix = 3;
629 System.out.println(" Start test Pix2Vect_nest !!!!!!!!!!!!!!");
630 Vector3d v1 = new Vector3d(0., 0., 0.);
631 v1 = pixTools.pix2vect_nest(nside, ipix);
632 assertEquals("v1.z = " + v1.z, 1.0, v1.z, 1e-1);
633 ipix = 17;
634 Vector3d v2 = new Vector3d(0., 0., 0.);
635 v2 = pixTools.pix2vect_nest(nside, ipix);
636 assertEquals("v2.x = " + v2.x, 1.0, v2.x, 1e-1);
637 assertEquals("v2.z = " + v2.z, 0.0, v2.z, 1e-1);
638
639 ipix = 21;
640 Vector3d v3 = new Vector3d();
641 v3 = pixTools.pix2vect_nest(nside, ipix);
642 assertEquals("v3.y = " + v3.y, 1.0, v3.y, 1e-1);
643 assertEquals("v3.z = " + v3.z, 0.0, v3.z, 1e-1);
644 nside = 4;
645 ipix = 105;
646 v1 = pixTools.pix2vect_nest(nside, ipix);
647 v1.normalize();
648 double phi1 = Math.atan2(v1.y, v1.x);
649 if (phi1 < 0.)
650 phi1 += TWOPI;
651 double[] tetphi = new double[2];
652 tetphi = pixTools.pix2ang_nest(nside, ipix);
653 assertEquals("phi = " + phi1, 0.0, Math.abs(phi1 - tetphi[1]), 1e-10);
654 nside = 4;
655 ipix = 74;
656 v1 = pixTools.pix2vect_nest(nside, ipix);
657 v1.normalize();
658 phi1 = Math.atan2(v1.y, v1.x);
659 if (phi1 < 0.)
660 phi1 += TWOPI;
661 tetphi = new double[2];
662 tetphi = pixTools.pix2ang_nest(nside, ipix);
663 assertEquals("phi = " + phi1, 0.0, Math.abs(phi1 - tetphi[1]), 1e-10);
664
665 System.out.println(" test pix2vect_nest is done");
666 System.out.println("-------------------------------------------");
667 }
668
669 /**
670 * tests conversion from vector to pixel number
671 * @throws Exception
672 */
673 public void testVect2Pix_ring() throws Exception {
674 System.out.println("Start test Vect2Pix_ring !!!!!!!!!!!!!!!!!!!");
675
676 long nside = 4;
677 long ipix = 83;
678 long respix = 0;
679 Vector3d v1 = new Vector3d(0., 0., 0.);
680 v1 = pixTools.pix2vect_ring(nside, ipix);
681 respix = (int) pixTools.vect2pix_ring(nside, v1);
682 assertEquals("respix = " + respix, 83, respix, 1e-10);
683 // Hi resolution test
684 long nside1 = 1 << 20;
685 long maxpix= pixTools.Nside2Npix(nside1);
686 System.out.println("nside="+nside1+" maxpix="+maxpix);
687 Vector3d v2 = new Vector3d( -0.704, 0.580, 0.408);
688 respix = pixTools.vect2pix_ring(nside1, v2); // ring pixel
689 long respixN = pixTools.ring2nest(nside1, respix); // convert to nest
690 long respixNC = pixTools.vect2pix_nest(nside1,v2); // nest pixel from the same vector
691 long respixR = pixTools.nest2ring(nside1, respixN); // convert pixel
692 System.out.println(" orig="+respix+" doubleT="+respixR+" nest="+respixN+" correct nest="+respixNC);
693 assertEquals("ringpix = " + respix, respix, respixR);
694 assertEquals("nestpix = " + respixNC, respixNC, respixN);
695 System.out.println("------------------------------------------");
696 System.out.println(" test vect2pix_ring is done");
697 }
698
699 /**
700 * tests conversion from vector to pixel number
701 * @throws Exception
702 */
703 public void testVect2Pix_nest() throws Exception {
704 System.out.println("Start test Vect2Pix_nest !!!!!!!!!!!!!!!!!!!");
705 long nside = 4;
706 long ipix = 83;
707 long respix = 0;
708 Vector3d v1 = new Vector3d(0., 0., 0.);
709 v1 = pixTools.pix2vect_ring(nside, ipix);
710 respix = (int) pixTools.vect2pix_nest(nside, v1);
711 assertEquals("respix = " + respix, 123, respix, 1e-10);
712 //
713 long nside1 = 1 << 20;
714 long maxpix= pixTools.Nside2Npix(nside1);
715 System.out.println("nside="+nside1+" maxpix="+maxpix);
716 Vector3d v2 = new Vector3d( -0.704, 0.580, 0.408);
717 respix = pixTools.vect2pix_nest(nside1, v2);
718 long respixRC = pixTools.vect2pix_ring(nside1, v2);
719 long respixR = pixTools.nest2ring(nside1, respix);
720 long respixN = pixTools.ring2nest(nside1, respixRC);
721 System.out.println(" orig="+respix+" doubleT="+respixN+" ring="+respixR+" correct ring="+respixRC);
722 assertEquals("ringpix = " + respixRC, respixRC, respixR);
723 assertEquals("nestpix = " + respix, respix, respixN);
724 System.out.println("------------------------------------------");
725 System.out.println(" test vect2pix_nest is done");
726 }
727
728 /**
729 * tests Query_Strip method
730 * @throws Exception
731 */
732 public void testQuery_Strip() throws Exception {
733 System.out.println(" Start test query Strip !!!!!!!!!!!!!!!!");
734 int[] pixel1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
735 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
736 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
737 48, 49, 50, 51, 52, 53, 54, 55 };
738 int nside = 4;
739 int nest = 0;
740 double theta1 = 0.0;
741 double theta2 = Math.PI / 4.0 + 0.2;
742 ArrayList pixlist;
743 pixlist = pixTools.query_strip(nside, theta1, theta2, nest);
744 int nlist = pixlist.size();
745 for (int i = 0; i < nlist; i++) {
746 long ipix = ((Long) pixlist.get(i)).longValue();
747 assertEquals("pixel = " + ipix, pixel1[i], ipix, 1e-10);
748 }
749
750 System.out.println(" test query_strip is done");
751
752 }
753
754 /**
755 * tests Query_Disc method
756 * @throws Exception
757 */
758 public void testQuery_Disc() throws Exception {
759 System.out.println(" Start test query_disc !!!!!!!!!!!!!!!!!!!!!");
760 long nside = 4;
761 int nest = 0;
762 long ipix = 0;
763
764
765 int[] pixel1 = { 45, 46, 60, 61, 62, 77, 78, 92, 93, 94,
766 109, 110, 124, 125, 126, 141, 142
767 };
768
769
770
771 int[] pixel2 = { 24, 19, 93, 18, 17, 87, 16,86, 85,
772 106, 84, 159, 81, 158, 157, 155, 156
773 };
774
775
776 int[] pixel3 = {52, 79, 49, 78, 77, 75, 76, 74, 73, 70,
777 72, 67, 189, 66, 65, 183, 64
778 };
779 int inclusive = 1;
780 double radius = Math.PI / 8.0;
781 Vector3d v = pixTools.pix2vect_ring(nside, 93);
782 ArrayList pixlist;
783 pixlist = pixTools.query_disc(nside, v, radius, nest, inclusive);
784
785 int nlist = pixlist.size();
786
787 for (int i = 0; i < nlist; i++) {
788 ipix = ((Long) pixlist.get(i)).longValue();
789 // System.out.println("i="+i+"pixel="+ipix+" pixel1="+pixel1[i]);
790 assertEquals("pixel = " + ipix, pixel1[i], ipix, 1e-10);
791 }
792 radius = Math.PI/2.0;
793 nest = 0;
794 v = new Vector3d(1.0,0.0,0.0);
795 ArrayList pixlistT = pixTools.query_disc(2, v, radius, nest, inclusive);
796
797 radius = Math.PI / 8.0;
798 v = pixTools.pix2vect_ring(nside, 93);
799 nest = 1;
800 ArrayList pixlist2 = pixTools.query_disc(nside, v, radius, nest, inclusive);
801
802 int nlist2 = pixlist2.size();
803 assertEquals("npix="+nlist, nlist, nlist2, 1e-10);
804 for (int i = 0; i < nlist2; i++) {
805 ipix = ((Long) pixlist2.get(i)).longValue();
806
807 assertEquals("pixel = " + ipix, pixel2[i], ipix, 1e-10);
808
809 }
810
811 v = pixTools.pix2vect_ring(nside, 103);
812 nest = 1;
813 inclusive = 1;
814 ArrayList pixlist3 = pixTools.query_disc(nside, v, radius, nest, inclusive);
815 nlist = pixlist3.size();
816 assertEquals("npix="+nlist, nlist, pixel3.length, 1e-10);
817
818 for (int i = 0; i < pixlist3.size(); i++) {
819 ipix = ((Long) pixlist3.get(i)).longValue();
820
821 assertEquals("pixel = " + ipix, pixel3[i], ipix, 1e-10);
822 }
823
824
825 for (int i=0; i<pixel1.length; i++) {
826 long ipixR = pixel1[i];
827 long ipixT = pixTools.ring2nest(nside, ipixR);
828 assertEquals("pixel="+ipixT, ipixT, pixel2[i], 1e-10);
829 long ipixN = pixTools.nest2ring(nside, ipixT);
830 assertEquals("pixel="+ipixN, ipixN, pixel1[i], 1e-10);
831 }
832 System.out.println(" End query_disk test ______________________________");
833 }
834
835 /**
836 * tests Query_Triangle method
837 * @throws Exception
838 */
839 public void testQuery_Triangle() throws Exception {
840 long nside = 4;
841 int nest = 0;
842 long ipix = 0;
843 int[] pixel1 = { 57, 58, 59, 60, 61, 62, 74, 75, 76, 77, 78, 90, 91,
844 92, 93, 107, 108, 109, 123, 124, 140 };
845 int[] pixel2 = { 88, 89, 90, 91, 105, 106, 107, 108, 121, 122, 123,
846 138, 139, 154 };
847 int[] pixel3 = { 49, 64, 80, 81, 95, 96, 112, 113,
848 127, 128, 142, 143, 144, 145 };
849 int[] pixel4 = { 36, 52, 53, 67, 68, 69, 83, 84, 85, 86, 98, 99, 100,
850 101, 102, 114, 115, 116, 117, 118, 119, 129, 130, 131, 132,
851 133, 134, 135 };
852 int[] pixel5 = { 58, 127, 56, 126, 125, 50, 123, 124, 119, 48, 122,
853 121, 118, 117, 74, 175, 120, 115, 116, 191, 72, 174, 173, 114,
854 113, 190, 189, 66 };
855 int[] pixel6 = { 110, 123, 124, 125, 140, 141, 156 };
856 int[] pixel7 = { 53, 68, 69 };
857 long pix1 = 62;
858 long pix2 = 57;
859 long pix3 = 140;
860 System.out.println("Start test Query Triangle !!!!!!!!!!!!!!!!!!!!");
861 Vector3d v11 = pixTools.pix2vect_ring(nside, pix1);
862
863 Vector3d v22 = pixTools.pix2vect_ring(nside, pix2);
864
865 Vector3d v33 = pixTools.pix2vect_ring(nside, pix3);
866
867 // System.out.println("nside="+nside+" triangle pixels "+pix1+" "+pix2+"
868 // "+pix3);
869 int inclusive = 0;
870
871 ArrayList pixlist;
872 pixlist = pixTools.query_triangle(nside, v11, v22, v33, nest, inclusive);
873
874 int nlist = pixlist.size();
875
876 for (int i = 0; i < nlist; i++) {
877 ipix = ((Long) pixlist.get(i)).longValue();
878
879 assertEquals("pixel = " + ipix, pixel1[i], ipix, 1e-10);
880 }
881 pix1 = 92;
882 pix2 = 88;
883 pix3 = 154;
884 v11 = pixTools.pix2vect_ring(nside, pix1);
885 v22 = pixTools.pix2vect_ring(nside, pix2);
886 v33 = pixTools.pix2vect_ring(nside, pix3);
887
888 inclusive = 0;
889 ArrayList pixlist1;
890 pixlist1 = pixTools.query_triangle(nside, v11, v22, v33, nest, inclusive);
891
892 nlist = pixlist1.size();
893
894 for (int i = 0; i < nlist; i++) {
895 ipix = ((Long) pixlist1.get(i)).longValue();
896 // System.out.println(ipix);
897 assertEquals("pixel = " + ipix, pixel2[i], ipix, 1e-10);
898 }
899 pix1 = 49;
900 pix2 = 142;
901 pix3 = 145;
902 v11 = pixTools.pix2vect_ring(nside, pix1);
903 v22 = pixTools.pix2vect_ring(nside, pix2);
904 v33 = pixTools.pix2vect_ring(nside, pix3);
905
906 inclusive = 0;
907 ArrayList pixlist2;
908 pixlist2 = pixTools.query_triangle(nside, v11, v22, v33, nest, inclusive);
909
910 nlist = pixlist2.size();
911
912 for (int i = 0; i < nlist; i++) {
913 ipix = ((Long) pixlist2.get(i)).longValue();
914 // System.out.println(ipix);
915 assertEquals("pixel = " + ipix, pixel3[i], ipix, 1e-10);
916 }
917 pix1 = 36;
918 pix2 = 129;
919 pix3 = 135;
920 v11 = pixTools.pix2vect_ring(nside, pix1);
921 v22 = pixTools.pix2vect_ring(nside, pix2);
922 v33 = pixTools.pix2vect_ring(nside, pix3);
923
924 inclusive = 0;
925
926 pixlist2 = pixTools.query_triangle(nside, v11, v22, v33, nest, inclusive);
927
928 nlist = pixlist2.size();
929
930 for (int i = 0; i < nlist; i++) {
931 ipix = ((Long) pixlist2.get(i)).longValue();
932 assertEquals("pixel = " + ipix, pixel4[i], ipix, 1e-10);
933 }
934 pix1 = 36;
935 pix2 = 129;
936 pix3 = 135;
937 nest = 1;
938 v11 = pixTools.pix2vect_ring(nside, pix1);
939 v22 = pixTools.pix2vect_ring(nside, pix2);
940 v33 = pixTools.pix2vect_ring(nside, pix3);
941 inclusive = 0;
942
943 pixlist2 = pixTools.query_triangle(nside, v11, v22, v33, nest, inclusive);
944
945 nlist = pixlist2.size();
946
947 for (int i = 0; i < nlist; i++) {
948 ipix = ((Long) pixlist2.get(i)).longValue();
949 // System.out.println("ipix="+ipix);
950 assertEquals("pixel = " + ipix, pixel5[i], ipix, 1e-10);
951 }
952 pix1 = 123;
953 pix2 = 156;
954 pix3 = 110;
955 nest = 0;
956 v11 = pixTools.pix2vect_ring(nside, pix1);
957 v22 = pixTools.pix2vect_ring(nside, pix2);
958 v33 = pixTools.pix2vect_ring(nside, pix3);
959 inclusive = 0;
960
961 pixlist2 = pixTools.query_triangle(nside, v11, v22, v33, nest, inclusive);
962
963 nlist = pixlist2.size();
964
965 for (int i = 0; i < nlist; i++) {
966 ipix = ((Long) pixlist2.get(i)).longValue();
967 assertEquals("pixel = " + ipix, pixel6[i], ipix, 1e-10);
968 // System.out.println("i="+i+" pixel#="+ipix);
969 }
970 pix1 = 69;
971 pix2 = 53;
972 pix3 = 68;
973 nest = 0;
974 v11 = pixTools.pix2vect_ring(nside, pix1);
975 v22 = pixTools.pix2vect_ring(nside, pix2);
976 v33 = pixTools.pix2vect_ring(nside, pix3);
977 inclusive = 0;
978
979 pixlist2 = pixTools.query_triangle(nside, v11, v22, v33, nest, inclusive);
980
981 nlist = pixlist2.size();
982
983 for (int i = 0; i < nlist; i++) {
984 ipix = ((Long) pixlist2.get(i)).longValue();
985 assertEquals("pixel = " + ipix, pixel7[i], ipix, 1e-10);
986 // System.out.println("i="+i+" pixel#="+ipix);
987 }
988 System.out.println(" test query_triangle is done");
989
990 }
991
992 /**
993 * tests Query_Poligon method
994 * @throws Exception
995 */
996 public void testQuery_Polygon() throws Exception {
997 long nside = 4;
998 int nest = 0;
999 long ipix = 0;
1000 int inclusive = 0;
1001 int[] result = { 51, 52, 53, 66, 67, 68, 69, 82, 83, 84, 85, 86, 98,
1002 99, 100, 101, 115, 116, 117 };
1003 int[] result1 = { 55, 70, 71, 87 };
1004 int[] result2 = { 137, 152, 153, 168 };
1005 int[] result3 = { 27, 43, 44, 58, 59, 60, 74, 75, 76, 77, 89, 90, 91,
1006 92, 93, 105, 106, 107, 108, 109, 110, 121, 122, 123, 124, 125,
1007 138, 139, 140, 141, 154, 156 };
1008
1009
1010 System.out.println("Start test query_polygon !!!!!!!!!!!!!!!!!!!!!!");
1011 ArrayList vlist = new ArrayList();
1012 Vector3d v = pixTools.pix2vect_ring(nside, 53);
1013 vlist.add( v);
1014 v = pixTools.pix2vect_ring(nside, 51);
1015 vlist.add( v);
1016 v = pixTools.pix2vect_ring(nside, 82);
1017 vlist.add( v);
1018 v = pixTools.pix2vect_ring(nside, 115);
1019 vlist.add( v);
1020 v = pixTools.pix2vect_ring(nside, 117);
1021 vlist.add( v);
1022 v = pixTools.pix2vect_ring(nside, 86);
1023 vlist.add( v);
1024
1025 ArrayList pixlist;
1026 pixlist = pixTools.query_polygon(nside, vlist, nest, inclusive);
1027 // System.out.println(" List size="+pixlist.size());
1028 int nlist = pixlist.size();
1029 // System.out.println(" Pixel list:");
1030 for (int i = 0; i < nlist; i++) {
1031 ipix = ((Long) pixlist.get(i)).longValue();
1032 assertEquals("pixel = " + ipix, result[i], ipix, 1e-10);
1033 // System.out.println("i="+i+" pixel # "+ipix);
1034 }
1035
1036 /* Yet another test */
1037
1038 ArrayList vlist1 = new ArrayList();
1039 v = pixTools.pix2vect_ring(nside, 71);
1040 vlist1.add( v);
1041 v = pixTools.pix2vect_ring(nside, 55);
1042 vlist1.add( v);
1043 v = pixTools.pix2vect_ring(nside, 70);
1044 vlist1.add( v);
1045 v = pixTools.pix2vect_ring(nside, 87);
1046 vlist1.add( v);
1047 pixlist = pixTools.query_polygon(nside, vlist1, nest, inclusive);
1048
1049 nlist = pixlist.size();
1050
1051 for (int i = 0; i < nlist; i++) {
1052 ipix = ((Long) pixlist.get(i)).longValue();
1053 // System.out.println("i="+i+" pixel # "+ipix);
1054 assertEquals("pixel = " + ipix, result1[i], ipix, 1e-10);
1055 }
1056
1057 /* Yet another test */
1058 ArrayList vlist2 = new ArrayList();
1059 v = pixTools.pix2vect_ring(nside, 153);
1060 vlist2.add( v);
1061 v = pixTools.pix2vect_ring(nside, 137);
1062 vlist2.add( v);
1063 v = pixTools.pix2vect_ring(nside, 152);
1064 vlist2.add( v);
1065 v = pixTools.pix2vect_ring(nside, 168);
1066 vlist2.add( v);
1067 pixlist = pixTools.query_polygon(nside, vlist2, nest, inclusive);
1068
1069 nlist = pixlist.size();
1070
1071 for (int i = 0; i < nlist; i++) {
1072 ipix = ((Long) pixlist.get(i)).longValue();
1073 assertEquals("pixel = " + ipix, result2[i], ipix, 1e-10);
1074 // System.out.println("i="+i+" pixel # "+ipix);
1075 }
1076 /* Yet another test */
1077
1078 ArrayList vlist3 = new ArrayList();
1079 v = pixTools.pix2vect_ring(nside, 110);
1080 vlist3.add( v);
1081 v = pixTools.pix2vect_ring(nside, 27);
1082 vlist3.add( v);
1083 v = pixTools.pix2vect_ring(nside, 105);
1084 vlist3.add( v);
1085 v = pixTools.pix2vect_ring(nside, 154);
1086 vlist3.add( v);
1087 v = pixTools.pix2vect_ring(nside, 123);
1088 vlist3.add( v);
1089 v = pixTools.pix2vect_ring(nside, 156);
1090 vlist3.add( v);
1091 pixlist = pixTools.query_polygon(nside, vlist3, nest, inclusive);
1092
1093 nlist = pixlist.size();
1094
1095 for (int i = 0; i < nlist; i++) {
1096 ipix = ((Long) pixlist.get(i)).longValue();
1097 assertEquals("pixel = " + ipix, result3[i], ipix, 1e-10);
1098 // System.out.println("i="+i+" pixel # "+ipix);
1099 }
1100 System.out.println(" test query_polygon is done");
1101
1102 }
1103 /**
1104 * tests MaxResolution method
1105 */
1106 public void testMaxResolution() {
1107 System.out.println(" Start test MaxRes !!!!!!!!!!!!!!!!!!!!!");
1108
1109 long nside = 1048576;
1110 double res = pixTools.PixRes(nside);
1111 System.out.println("Minimum size of the pixel side is "+res+" arcsec.");
1112 assertEquals("res = " + res, 0.2, res, 1e-1);
1113 long nsideR = pixTools.GetNSide(res);
1114 assertEquals("nside = " + nside, nside, nsideR, 1e-1);
1115 System.out.println(" End of MaxRes test _______________________");
1116 }
1117 /**
1118 * tests QueryDiscResolution method
1119 * @throws Exception
1120 */
1121 public void testQueryDiscRes() throws Exception {
1122 System.out.println(" Start test DiscRes !!!!!!!!!!!!!!!!!!!!!");
1123
1124 int nest = 0;
1125 long ipix = 0;
1126
1127 int inclusive = 0;
1128 double theta= Math.PI;
1129 double phi = Math.PI;
1130 double radius = Math.toRadians(0.2/3600.); // One arcse
1131 long nside = pixTools.GetNSide(radius);
1132 System.out.println(" calculated nside="+nside);
1133 long cpix = pixTools.ang2pix_ring(nside,theta,phi);
1134 Vector3d vc = pixTools.pix2vect_ring(nside, cpix);
1135 ArrayList pixlist;
1136 pixlist = pixTools.query_disc(nside, vc, radius, nest, inclusive);
1137
1138 int nlist = pixlist.size();
1139 for (int i = 0; i < nlist; i++) {
1140 ipix = ((Long) pixlist.get(i)).longValue();
1141 Vector3d v = pixTools.pix2vect_ring(nside,ipix);
1142 double dist = pixTools.AngDist(v,vc);
1143 assertTrue(dist<=2.*radius);
1144 }
1145 cpix = pixTools.ang2pix_nest(nside,theta,phi);
1146 Vector3d vc1 = pixTools.pix2vect_nest(nside, cpix);
1147 ArrayList pixlist1;
1148 nest = 1;
1149 radius *=4;
1150 pixlist1 = pixTools.query_disc(nside, vc1, radius, nest, inclusive);
1151 int nlist1 = pixlist1.size();
1152 for (int i = 0; i < nlist1; i++) {
1153 ipix = ((Long) pixlist1.get(i)).longValue();
1154 Vector3d v = pixTools.pix2vect_nest(nside,ipix);
1155 double dist = pixTools.AngDist(v,vc1);
1156 assertTrue(dist<=2.*radius);
1157 }
1158 System.out.println(" test query disk is done -------------------");
1159 }
1160 /**
1161 * test Query_disk check for consistency in the query for RING/NESTED
1162 */
1163 public void testQuery_disk2() {
1164 System.out.println(" Start test query_disk HiRes!!!!!!!!!!!!!!!!!!!!!!!!");
1165 long nside = 1 << 20 ;
1166 double res = pixTools.PixRes(nside);
1167 System.out.println("nside="+nside+" sresolution="+res);
1168 double radius = Math.toRadians(res/3600.)/2.;
1169 System.out.println("radius="+radius);
1170 Vector3d v1 = new Vector3d(-0.704, 0.580, 0.408);
1171 System.out.println("!!!!!!!!!!!!! NESTED !!!!!!!!!!!");
1172 ArrayList diskQ = pixTools.query_disc(nside,
1173 v1,
1174 radius, 1,1); // inclusive query at vector point
1175 assertEquals("npixels = " + diskQ.size(), 8, diskQ.size() , 1e-1);
1176 long pix1 = pixTools.vect2pix_nest(nside, v1);
1177 Vector3d v2 = pixTools.pix2vect_nest(nside, pix1); // vector to pix center
1178 //
1179 ArrayList diskQ2 = pixTools.query_disc(nside,
1180 v2,
1181 radius, 1,1); // inclusive with point at pixel center
1182 assertEquals("npixels = " + diskQ2.size(), 9, diskQ2.size() , 1e-1);
1183
1184 //
1185 ArrayList diskQ3 = pixTools.query_disc(nside,
1186 v2,
1187 radius, 1,0); // exclusive with point at pixel center
1188 assertEquals("npixels = " + diskQ3.size(), 1, diskQ3.size() , 1e-1);
1189
1190 // RING schema
1191 System.out.println("!!!!!!!!!!!!! RING !!!!!!!!!!!");
1192 ArrayList diskQ4 = pixTools.query_disc(nside,
1193 v1,
1194 radius, 0,1); // inclusiv at vector point
1195 assertEquals("npixels = " + diskQ4.size(), 8, diskQ4.size() , 1e-1);
1196 //
1197
1198 ArrayList diskQ5 = pixTools.query_disc(nside,
1199 v2,
1200 radius, 0, 1); // inclusive at pixel center
1201 assertEquals("npixels = " + diskQ5.size(), 9, diskQ5.size() , 1e-1);
1202
1203 // System.out.println("n pixels in disk5 ="+diskQ5.size());
1204 ArrayList diskQ6 = pixTools.query_disc(nside,
1205 v2,
1206 radius, 0,0); // exclusive at pixel center
1207 assertEquals("npixels = " + diskQ6.size(), 1, diskQ6.size() , 1e-1);
1208 //
1209 // test HiRes conversions
1210 //
1211 Vector3d pos = new Vector3d( -0.704, 0.580, 0.408 );
1212
1213 nside = 1 << 20;
1214 System.out.println("HiRes transformation tests: nside="+nside);
1215 ArrayList nestPixels = pixTools.query_disc(nside, pos, radius, 1, 1);
1216 ArrayList ringPixels = pixTools.query_disc(nside, pos, radius, 0, 1);
1217 assertEquals(nestPixels.size(), ringPixels.size());
1218 for(int i=0; i< ringPixels.size(); i++) {
1219 long iring = ((Number)ringPixels.get(i)).longValue();
1220 Vector3d cv = pixTools.pix2vect_ring(nside, iring);
1221 long inest = pixTools.ring2nest(nside, iring);
1222 long inestC = ((Number)nestPixels.get(i)).longValue();
1223 Vector3d cvN = pixTools.pix2vect_nest(nside, inestC);
1224 long iringT = pixTools.nest2ring(nside, inestC);
1225 assertEquals(iring,iringT);
1226 assertEquals(inest,inestC);
1227 assertEquals(" Xv="+cv.x,cv.x,cvN.x,1.e-10);
1228 assertEquals(" Yv="+cv.y,cv.y,cvN.y,1.e-10);
1229 assertEquals(" Zv="+cv.z,cv.z,cvN.z,1.e-10);
1230 // System.out.println(" inest orig="+inestC+" transformed="+inest+" iring orig="+iring+" transf="+iringT);
1231 // System.out.println("Vector cv vs cvN x="+cv.x+" cvN.x="+cvN.x);
1232 // System.out.println("Vector cv vs cvN y="+cv.y+" cvN.y="+cvN.y);
1233 // System.out.println("Vector cv vs cvN z="+cv.z+" cvN.z="+cvN.z);
1234 double[] tetphiR = pixTools.pix2ang_ring(nside, iring);
1235 double[] tetphiN= pixTools.pix2ang_nest(nside, inestC);
1236 assertEquals(" theta="+tetphiR[0],tetphiR[0],tetphiN[0],1.e-10);
1237 assertEquals(" phi="+tetphiR[1],tetphiR[1],tetphiN[1],1.e-10);
1238 // System.out.println("theta R vs N "+tetphiR[0]+" "+tetphiN[0]);
1239 // System.out.println("phi R vs N "+tetphiR[1]+" "+tetphiN[1]);
1240 }
1241
1242 System.out.println(" End test of query_disc2____________________________");
1243
1244 }
1245 /**
1246 * tests GetNside method
1247 */
1248 public void testGetNside() {
1249 System.out.println(" Start test GetNside !!!!!!!!!!!!!!!!!!!!!");
1250
1251 double pixsize = 0.3;
1252 long nside = pixTools.GetNSide(pixsize);
1253 System.out.println("Requared nside is "+nside);
1254 assertEquals("nside = " + nside, 1048576, nside, 1e-1);
1255 System.out.println(" End of GetNSide test _______________________");
1256 }
1257
1258 /**
1259 * test conversion of Ra Dec to polar coordinates
1260 */
1261 public void testRaDecToPolar() {
1262 System.out.println(" Start test RaDecToPolar !!!!!!!!!!!!!!!!!!!!!");
1263 double [] radec = new double[2];
1264 radec[0] = 312.115456;
1265 radec[1] = -1.153759;
1266 double[] polar = pixTools.RaDecToPolar(radec);
1267 assertEquals("theta = " + polar[0], 1.5909332201194137, polar[0], 1e-10);
1268 assertEquals("phi = " + polar[1], 5.447442353563491, polar[1], 1e-10);
1269 System.out.println("End test RaDecToPolar__________________________");
1270
1271 }
1272 }
1273