CppEphem
test_CECoordinates.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * test_CECoordinates.cpp: CppEphem *
3  * ----------------------------------------------------------------------- *
4  * Copyright © 2018 JCardenzana *
5  * ----------------------------------------------------------------------- *
6  * *
7  * This program is free software: you can redistribute it and/or modify *
8  * it under the terms of the GNU General Public License as published by *
9  * the Free Software Foundation, either version 3 of the License, or *
10  * (at your option) any later version. *
11  * *
12  * This program is distributed in the hope that it will be useful, *
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15  * GNU General Public License for more details. *
16  * *
17  * You should have received a copy of the GNU General Public License *
18  * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19  * *
20  ***************************************************************************/
21 
22 #include "test_CECoordinates.h"
23 #include "CEObserver.h"
24 #include "CENamespace.h"
25 
26 
27 /**********************************************************************/
30 test_CECoordinates::test_CECoordinates() :
31  CETestSuite()
32 {
33  // Interpolate the correction terms
34  CppEphem::CorrectionsInterp(true);
35 
36  // Lets use the Crab Nebula (M1) for our testing
37 
38  // The following coordinates are derived from Astopy using the script:
39  // cppephem/test/astropy_scripts/test_cecoordinates_setup.py
40  base_icrs_ = CECoordinates(CEAngle::Deg(83.633), CEAngle::Deg(22.0145),
41  CECoordinateType::ICRS);
42  base_cirs_ = CECoordinates(CEAngle::Deg(83.63843844654943),
43  CEAngle::Deg(22.012942530431776),
44  CECoordinateType::CIRS);
45  base_gal_ = CECoordinates(CEAngle::Deg(184.55741630955762),
46  CEAngle::Deg(-5.784421958594916),
47  CECoordinateType::GALACTIC);
48  base_obs_ = CECoordinates(CEAngle::Deg(35.598599384274294),
49  CEAngle::Deg(152.55068501449307),
50  CECoordinateType::OBSERVED);
51 
52  // Create the date object
53  base_date_ = CEDate(CppEphem::julian_date_J2000(), CEDateType::JD);
54  // Interpret the date object as a julian date
55  base_date_.SetReturnType(CEDateType::JD);
56 
57  // Setup the observer object for observed coordinates
58  base_observer_ = CEObserver(0.0, 0.0, 0.0, CEAngleType::DEGREES);
59  base_observer_.SetTemperature_C(0.0);
60  base_observer_.SetPressure_hPa(0.0);
61  base_observer_.SetRelativeHumidity(0.0);
62  base_observer_.SetWavelength_um(0.0);
63 }
64 
65 
66 /**********************************************************************/
69 test_CECoordinates::~test_CECoordinates()
70 {}
71 
72 
73 /**********************************************************************/
78 bool test_CECoordinates::runtests()
79 {
80  std::cout << "\nTesting CECoordinates:\n";
81 
82  // Test constructions
83  test_construct();
84  test_copy();
85  test_HmsDms2Angle();
86 
87  // Conversion tests
88  test_Convert2Cirs();
89  test_Convert2Icrs();
90  test_Convert2Galactic();
91  test_Convert2Observed();
92 
93  // Test dedicated methods
94  test_AngularSeparation();
95  test_ConvertTo();
96 
97  return pass();
98 }
99 
100 /**********************************************************************/
103 bool test_CECoordinates::test_construct()
104 {
105  // Test the default constructor
106  CECoordinates test1;
107  test_double(test1.XCoordinate_Rad(), 0.0, __func__, __LINE__);
108  test_double(test1.XCoord(), 0.0, __func__, __LINE__);
109  test_double(test1.YCoordinate_Rad(), 0.0, __func__, __LINE__);
110  test_double(test1.YCoord(), 0.0, __func__, __LINE__);
111 
112  // Test constructor from CEAngle objects
113  CEAngle testx = CEAngle::Deg(83.633);
114  CEAngle testy = CEAngle::Deg(22.0145);
115  CECoordinates test2(testx, testy, CECoordinateType::ICRS);
116  test_double(test2.XCoordinate_Rad(), testx, __func__, __LINE__);
117  test_double(test2.YCoordinate_Rad(), testy, __func__, __LINE__);
118 
119  // Test constructor from vector objects
120  CECoordinates test3a(testx.HmsVect(), testy.DmsVect(),
121  CECoordinateType::ICRS);
122  test_double(test3a.XCoordinate_Rad(), testx, __func__, __LINE__);
123  test_double(test3a.YCoordinate_Rad(), testy, __func__, __LINE__);
124  CECoordinates test3b(testx.DmsVect(), testy.DmsVect(),
125  CECoordinateType::GALACTIC);
126  test_double(test3b.XCoordinate_Rad(), testx, __func__, __LINE__);
127  test_double(test3b.YCoordinate_Rad(), testy, __func__, __LINE__);
128 
129  // Test copy constructor
130  CECoordinates test4(test2);
131  test_double(test4.XCoordinate_Rad(), testx, __func__, __LINE__);
132  test_double(test4.YCoordinate_Rad(), testy, __func__, __LINE__);
133  test_int(int(test4.GetCoordSystem()), int(test2.GetCoordSystem()), __func__, __LINE__);
134 
135  // Test constructor from coordinate type
136  CECoordinates test5(CECoordinateType::GALACTIC);
137  test_int(int(test5.GetCoordSystem()), int(CECoordinateType::GALACTIC), __func__, __LINE__);
138 
139  // Test print of constructed coordinates
140  test_greaterthan(test4.print().size(), 0, __func__, __LINE__);
141 
142  return pass();
143 }
144 
145 /**********************************************************************/
148 bool test_CECoordinates::test_copy()
149 {
150  // Make sure the equals and not-equals operators work properly
151  test_bool((base_icrs_ == base_icrs_), true, __func__, __LINE__);
152  test_bool((base_icrs_ != base_icrs_), false, __func__, __LINE__);
153  test_bool((base_icrs_ == base_gal_), false, __func__, __LINE__);
154  test_bool((base_icrs_ != base_gal_), true, __func__, __LINE__);
155 
156  // Copy CIRS
157  CECoordinates cirs = base_cirs_;
158  test((cirs == base_cirs_), __func__, __LINE__);
159 
160  // Copy ICRS
161  CECoordinates icrs = base_icrs_;
162  test((icrs == base_icrs_), __func__, __LINE__);
163 
164  // Copy Galactic
165  CECoordinates gal = base_gal_;
166  test((gal == base_gal_), __func__, __LINE__);
167 
168  // Copy Observed
169  CECoordinates obs = base_obs_;
170  test((obs == base_obs_), __func__, __LINE__);
171 
172  // Copy coordinates directly
173  gal.SetCoordinates(icrs);
174  test((gal == icrs), __func__, __LINE__);
175 
176  return pass();
177 }
178 
179 
180 /**********************************************************************/
183 bool test_CECoordinates::test_Convert2Cirs()
184 {
185  double ra(0.0);
186  double dec(0.0);
187 
188  // CIRS -> CIRS
189  CECoordinates cirs2cirs = base_cirs_.ConvertToCIRS();
190  test_coords(cirs2cirs, base_cirs_, __func__, __LINE__);
191 
192  // ICRS -> CIRS
193  CECoordinates icrs2cirs = base_icrs_.ConvertToCIRS(base_date_);
194  test_coords(icrs2cirs, base_cirs_, __func__, __LINE__);
195 
196  CECoordinates::ICRS2CIRS(base_icrs_.XCoordinate_Deg(),
197  base_icrs_.YCoordinate_Deg(),
198  &ra, &dec, base_date_, CEAngleType::DEGREES);
199  icrs2cirs.SetCoordinates(CEAngle::Deg(ra), CEAngle::Deg(dec),
200  CECoordinateType::CIRS);
201  test_coords(icrs2cirs, base_cirs_, __func__, __LINE__);
202 
203  // Galactic -> CIRS
204  CECoordinates gal2cirs = base_gal_.ConvertToCIRS(base_date_);
205  test_coords(gal2cirs, base_cirs_, __func__, __LINE__);
206 
207  ra = 0.0;
208  dec = 0.0;
209  CECoordinates::Galactic2CIRS(base_gal_.XCoordinate_Deg(),
210  base_gal_.YCoordinate_Deg(),
211  &ra, &dec, base_date_, CEAngleType::DEGREES);
212  icrs2cirs.SetCoordinates(CEAngle::Deg(ra), CEAngle::Deg(dec),
213  CECoordinateType::CIRS);
214  test_coords(icrs2cirs, base_cirs_, __func__, __LINE__);
215 
216  // Observed -> CIRS
217  CECoordinates obs2cirs = base_obs_.ConvertToCIRS(
218  base_date_, // date
219  base_observer_.Longitude_Rad(),
220  base_observer_.Latitude_Rad(),
221  base_observer_.Elevation_m(),
222  base_observer_.Pressure_hPa(),
223  base_observer_.Temperature_C(),
224  base_observer_.RelativeHumidity(),
225  base_date_.dut1(),
226  base_date_.xpolar(),
227  base_date_.ypolar(),
228  base_observer_.Wavelength_um());
229  test_coords(obs2cirs, base_cirs_, __func__, __LINE__);
230 
231  // Observed -> CIRS (direct v1)
232  ra = 0.0;
233  dec = 0.0;
234  CECoordinates::Observed2CIRS(base_obs_.XCoordinate_Deg(),
235  base_obs_.YCoordinate_Deg(),
236  &ra, &dec, base_date_, base_observer_,
237  CEAngleType::DEGREES);
238  obs2cirs.SetCoordinates(CEAngle::Deg(ra), CEAngle::Deg(dec),
239  CECoordinateType::CIRS);
240  test_coords(obs2cirs, base_cirs_, __func__, __LINE__);
241 
242  // Observed -> CIRS (direct v2)
243  ra = 0.0;
244  dec = 0.0;
245  CECoordinates::Observed2CIRS(base_obs_.XCoordinate_Rad(),
246  base_obs_.YCoordinate_Rad(),
247  &ra, &dec, base_date_.JD(),
248  base_observer_.Longitude_Rad(),
249  base_observer_.Latitude_Rad(),
250  base_observer_.Elevation_m(),
251  base_observer_.Pressure_hPa(),
252  base_observer_.Temperature_C(),
253  base_observer_.RelativeHumidity(),
254  base_date_.dut1(),
255  base_date_.xpolar(),
256  base_date_.ypolar(),
257  base_observer_.Wavelength_um());
258  obs2cirs.SetCoordinates(CEAngle::Rad(ra), CEAngle::Rad(dec),
259  CECoordinateType::CIRS);
260  test_coords(obs2cirs, base_cirs_, __func__, __LINE__);
261 
262  return pass();
263 }
264 
265 
266 /**********************************************************************/
269 bool test_CECoordinates::test_Convert2Icrs()
270 {
271  // CIRS -> ICRS
272  CECoordinates cirs2icrs = base_cirs_.ConvertToICRS(base_date_);
273  test_coords(cirs2icrs, base_icrs_, __func__, __LINE__);
274 
275  double ra(0.0), dec(0.0);
276  CECoordinates::CIRS2ICRS(base_cirs_.XCoord().Deg(), base_cirs_.YCoord().Deg(),
277  &ra, &dec, base_date_, CEAngleType::DEGREES);
278  cirs2icrs.SetCoordinates(CEAngle::Deg(ra), CEAngle::Deg(dec),
279  CECoordinateType::ICRS);
280  test_coords(cirs2icrs, base_icrs_, __func__, __LINE__);
281 
282  // ICRS -> ICRS
283  CECoordinates icrs2icrs = base_icrs_.ConvertToICRS();
284  test_coords(icrs2icrs, base_icrs_, __func__, __LINE__);
285 
286  // Galactic -> ICRS
287  CECoordinates gal2icrs = base_gal_.ConvertToICRS();
288  test_coords(gal2icrs, base_icrs_, __func__, __LINE__);
289 
290  ra = 0.0;
291  dec = 0.0;
292  CECoordinates::Galactic2ICRS(base_gal_.XCoord().Deg(), base_gal_.YCoord().Deg(),
293  &ra, &dec, CEAngleType::DEGREES);
294  gal2icrs.SetCoordinates(CEAngle::Deg(ra), CEAngle::Deg(dec),
295  CECoordinateType::ICRS);
296  test_coords(gal2icrs, base_icrs_, __func__, __LINE__);
297 
298  // Observed -> ICRS (raw values)
299  CECoordinates obs2icrs = base_obs_.ConvertToICRS(
300  base_date_, // date
301  base_observer_.Longitude_Rad(),
302  base_observer_.Latitude_Rad(),
303  base_observer_.Elevation_m(),
304  base_observer_.Pressure_hPa(),
305  base_observer_.Temperature_C(),
306  base_observer_.RelativeHumidity(),
307  base_date_.dut1(),
308  base_date_.xpolar(),
309  base_date_.ypolar(),
310  base_observer_.Wavelength_um());
311  test_coords(obs2icrs, base_icrs_, __func__, __LINE__);
312 
313  // Observed -> ICRS (CEObserver object)
314  CECoordinates::Observed2ICRS(base_obs_.XCoord().Deg(),
315  base_obs_.YCoord().Deg(),
316  &ra, &dec,
317  base_date_, base_observer_,
318  CEAngleType::DEGREES);
319  obs2icrs = CECoordinates(CEAngle::Deg(ra), CEAngle::Deg(dec),
320  CECoordinateType::ICRS);
321  test_coords(obs2icrs, base_icrs_, __func__, __LINE__);
322 
323  return pass();
324 }
325 
326 /**********************************************************************/
329 bool test_CECoordinates::test_Convert2Galactic()
330 {
331  double glon(0.0), glat(0.0);
332 
333  // CIRS -> Galactic
334  CECoordinates cirs2gal = base_cirs_.ConvertToGalactic(base_date_);
335  test_coords(cirs2gal, base_gal_, __func__, __LINE__);
336 
337  glon = 0.0;
338  glat = 0.0;
339  CECoordinates::CIRS2Galactic(base_cirs_.XCoord().Deg(), base_cirs_.YCoord().Deg(),
340  &glon, &glat, base_date_, CEAngleType::DEGREES);
341  cirs2gal.SetCoordinates(CEAngle::Deg(glon), CEAngle::Deg(glat),
342  CECoordinateType::GALACTIC);
343  test_coords(cirs2gal, base_gal_, __func__, __LINE__);
344 
345  // ICRS -> Galactic
346  CECoordinates icrs2gal = base_icrs_.ConvertToGalactic();
347  test_coords(icrs2gal, base_gal_, __func__, __LINE__);
348 
349  glon = 0.0;
350  glat = 0.0;
351  CECoordinates::ICRS2Galactic(base_icrs_.XCoord().Deg(), base_icrs_.YCoord().Deg(),
352  &glon, &glat, CEAngleType::DEGREES);
353  icrs2gal.SetCoordinates(CEAngle::Deg(glon), CEAngle::Deg(glat),
354  CECoordinateType::GALACTIC);
355  test_coords(icrs2gal, base_gal_, __func__, __LINE__);
356 
357  // Galactic -> Galactic
358  CECoordinates gal2gal = base_gal_.ConvertToGalactic();
359  test_coords(gal2gal, base_gal_, __func__, __LINE__);
360 
361  // Observed -> Galactic (raw values)
362  CECoordinates obs2gal = base_obs_.ConvertToGalactic(
363  base_date_, // date
364  base_observer_.Longitude_Rad(),
365  base_observer_.Latitude_Rad(),
366  base_observer_.Elevation_m(),
367  base_observer_.Pressure_hPa(),
368  base_observer_.Temperature_C(),
369  base_observer_.RelativeHumidity(),
370  base_date_.dut1(),
371  base_date_.xpolar(),
372  base_date_.ypolar(),
373  base_observer_.Wavelength_um());
374  test_coords(obs2gal, base_gal_, __func__, __LINE__);
375 
376  // Observed -> Galactic (CEObserver values)
377  CECoordinates::Observed2Galactic(base_obs_.XCoord().Deg(),
378  base_obs_.YCoord().Deg(),
379  &glon, &glat,
380  base_date_, base_observer_,
381  CEAngleType::DEGREES);
382  obs2gal = CECoordinates(CEAngle::Deg(glon), CEAngle::Deg(glat),
383  CECoordinateType::GALACTIC);
384  test_coords(obs2gal, base_gal_, __func__, __LINE__);
385 
386  return pass();
387 }
388 
389 
390 /**********************************************************************/
393 bool test_CECoordinates::test_Convert2Observed()
394 {
395  // preliminary variables for observer based conversion
396  double az(0.0);
397  double zen(0.0);
398  CECoordinates testobs;
399 
400  // CIRS -> Observed
401  CECoordinates cirs2obs = base_cirs_.ConvertToObserved(
402  base_date_, // date
403  base_observer_.Longitude_Rad(),
404  base_observer_.Latitude_Rad(),
405  base_observer_.Elevation_m(),
406  base_observer_.Pressure_hPa(),
407  base_observer_.Temperature_C(),
408  base_observer_.RelativeHumidity(),
409  base_date_.dut1(),
410  base_date_.xpolar(),
411  base_date_.ypolar(),
412  base_observer_.Wavelength_um());
413  test_coords(cirs2obs, base_obs_, __func__, __LINE__);
414  // 'GetObservedCoords' method
415  cirs2obs = base_cirs_.GetObservedCoords(base_date_, base_observer_);
416  test_coords(cirs2obs, base_obs_, __func__, __LINE__);
417  // Test the 'CEObserver' based approach
418  CECoordinates::CIRS2Observed(base_cirs_.XCoordinate_Deg(),
419  base_cirs_.YCoordinate_Deg(),
420  &az, &zen,
421  base_date_, base_observer_,
422  CEAngleType::DEGREES,
423  base_observer_.Wavelength_um());
424  testobs.SetCoordinates(CEAngle::Deg(az), CEAngle::Deg(zen),
425  CECoordinateType::OBSERVED);
426  test_coords(testobs, base_obs_, __func__, __LINE__);
427 
428  // ICRS -> Observed
429  CECoordinates icrs2obs = base_icrs_.ConvertToObserved(
430  base_date_, // date
431  base_observer_.Longitude_Rad(),
432  base_observer_.Latitude_Rad(),
433  base_observer_.Elevation_m(),
434  base_observer_.Pressure_hPa(),
435  base_observer_.Temperature_C(),
436  base_observer_.RelativeHumidity(),
437  base_date_.dut1(),
438  base_date_.xpolar(),
439  base_date_.ypolar(),
440  base_observer_.Wavelength_um());
441  test_coords(icrs2obs, base_obs_, __func__, __LINE__);
442  // 'GetObservedCoords' method
443  icrs2obs = base_icrs_.GetObservedCoords(base_date_, base_observer_);
444  test_coords(icrs2obs, base_obs_, __func__, __LINE__);
445  // Test the 'CEObserver' based approach
446  CECoordinates::ICRS2Observed(base_icrs_.XCoordinate_Deg(),
447  base_icrs_.YCoordinate_Deg(),
448  &az, &zen,
449  base_date_, base_observer_,
450  CEAngleType::DEGREES,
451  base_observer_.Wavelength_um());
452  testobs.SetCoordinates(CEAngle::Deg(az), CEAngle::Deg(zen),
453  CECoordinateType::OBSERVED);
454  test_coords(testobs, base_obs_, __func__, __LINE__);
455 
456  // Galactic -> Observed
457  CECoordinates gal2obs = base_gal_.ConvertToObserved(
458  base_date_, // date
459  base_observer_.Longitude_Rad(),
460  base_observer_.Latitude_Rad(),
461  base_observer_.Elevation_m(),
462  base_observer_.Pressure_hPa(),
463  base_observer_.Temperature_C(),
464  base_observer_.RelativeHumidity(),
465  base_date_.dut1(),
466  base_date_.xpolar(),
467  base_date_.ypolar(),
468  base_observer_.Wavelength_um());
469  test_coords(gal2obs, base_obs_, __func__, __LINE__);
470  // 'GetObservedCoords' method
471  gal2obs = base_gal_.GetObservedCoords(base_date_, base_observer_);
472  test_coords(gal2obs, base_obs_, __func__, __LINE__);
473  // Test the 'CEObserver' based approach
474  CECoordinates::Galactic2Observed(base_gal_.XCoordinate_Deg(),
475  base_gal_.YCoordinate_Deg(),
476  &az, &zen,
477  base_date_, base_observer_,
478  CEAngleType::DEGREES,
479  base_observer_.Wavelength_um());
480  testobs.SetCoordinates(CEAngle::Deg(az), CEAngle::Deg(zen),
481  CECoordinateType::OBSERVED);
482  test_coords(testobs, base_obs_, __func__, __LINE__);
483 
484  // Observed -> Observed
485  try {
486  CECoordinates obs2obs = base_obs_.ConvertToObserved();
487  test(false, __func__, __LINE__);
488  } catch (std::exception &e) {
489  test(true, __func__, __LINE__);
490  }
491  // 'GetObservedCoords' method
492  CECoordinates obs2obs = base_obs_.GetObservedCoords(base_date_, base_observer_);
493  test_coords(obs2obs, base_obs_, __func__, __LINE__);
494 
495  return pass();
496 }
497 
498 
499 /**********************************************************************/
502 bool test_CECoordinates::test_HmsDms2Angle(void)
503 {
504  // Create some variables for testing
505  double ang_var(45.50833333333333);
506  double ang_rad = CEAngle::Deg(ang_var).Rad();
507  std::vector<double> ang_vec = {45, 30, 30, 0.0};
508  std::vector<double> hrs_vec = {3.0, 2.0, 2.0, 0.0};
509 
510  // Increase the acceptable tolerance
511  double tol_old(DblTol());
512  SetDblTol(1.0e-11);
513 
514  // Test angle -> DMS
515  std::vector<double> test1 = CECoordinates::GetDMS(ang_var, CEAngleType::DEGREES);
516  test_vect(test1, ang_vec, __func__, __LINE__);
517 
518  // Test DMS -> angle
519  double test2a(CECoordinates::DMSToAngle(ang_vec, CEAngleType::DEGREES));
520  test_double(test2a, ang_var, __func__, __LINE__);
521  double test2b(CECoordinates::DMSToAngle(ang_vec, CEAngleType::RADIANS));
522  test_double(test2b, ang_rad, __func__, __LINE__);
523 
524  // Test angle -> HMS
525  std::vector<double> test3 = CECoordinates::GetHMS(ang_var, CEAngleType::DEGREES);
526  test_vect(test3, hrs_vec, __func__, __LINE__);
527 
528  // Test HMS -> angle
529  double test4a(CECoordinates::HMSToAngle(hrs_vec, CEAngleType::DEGREES));
530  test_double(test4a, ang_var, __func__, __LINE__);
531  double test4b(CECoordinates::HMSToAngle(hrs_vec, CEAngleType::RADIANS));
532  test_double(test4b, ang_rad, __func__, __LINE__);
533 
534  // Reset the tolerance
535  SetDblTol(tol_old);
536 
537  return pass();
538 }
539 
540 
541 /**********************************************************************/
544 bool test_CECoordinates::test_AngularSeparation(void)
545 {
546  // Establish the preliminary variables that will be used
547  CEAngle test1_x = CEAngle::Deg(0.0);
548  CEAngle test1_y = CEAngle::Deg(-1.0);
549  CEAngle test2_x = CEAngle::Deg(0.0);
550  CEAngle test2_y = CEAngle::Deg(1.0);
551  CECoordinates test1(test1_x, test1_y, CECoordinateType::ICRS);
552  CECoordinates test2(test2_x, test2_y, CECoordinateType::ICRS);
553 
554  // Test the default coordinate separation
555  CEAngle angsep = test1.AngularSeparation(test2);
556  test_double(angsep.Deg(), 2.0, __func__, __LINE__);
557  angsep = CECoordinates::AngularSeparation(test1, test2);
558  test_double(angsep.Deg(), 2.0, __func__, __LINE__);
559  angsep = CECoordinates::AngularSeparation(test1_x, test1_y,
560  test2_x, test2_y);
561  test_double(angsep.Deg(), 2.0, __func__, __LINE__);
562 
563  // Test that the two coordinates are not equal
564  test((test1 != test2), __func__, __LINE__);
565 
566  return pass();
567 }
568 
569 
570 /**********************************************************************/
573 bool test_CECoordinates::test_ConvertTo(void)
574 {
575  // Create an observer object
576  CEObserver observer(0.0, 0.0, 0.0, CEAngleType::DEGREES);
577  observer.SetTemperature_C(0.0);
578  observer.SetPressure_hPa(0.0);
579  observer.SetWavelength_um(0.0);
580  observer.SetRelativeHumidity(0.0);
581 
582  // Create a date object
583  CEDate date(CppEphem::julian_date_J2000(), CEDateType::JD);
584 
585  /* ---------------------------*
586  * ConvertTo basic form
587  * ---------------------------*/
588  CECoordinates test_icrs = base_icrs_.ConvertTo(CECoordinateType::ICRS,
589  observer, date);
590  test_coords(test_icrs, base_icrs_, __func__, __LINE__);
591  CECoordinates test_cirs = base_icrs_.ConvertTo(CECoordinateType::CIRS,
592  observer, date);
593  test_coords(test_cirs, base_cirs_, __func__, __LINE__);
594  CECoordinates test_gal = base_icrs_.ConvertTo(CECoordinateType::GALACTIC,
595  observer, date);
596  test_coords(test_gal, base_gal_, __func__, __LINE__);
597  CECoordinates test_obs = base_icrs_.ConvertTo(CECoordinateType::OBSERVED,
598  observer, date);
599  test_coords(test_obs, base_obs_, __func__, __LINE__);
600 
601  return pass();
602 }
603 
604 
605 /**********************************************************************/
608 bool test_CECoordinates::test_coords(const CECoordinates& test,
609  const CECoordinates& expected,
610  const std::string& func,
611  const int& line)
612 {
613  // Test if the coordinates are equal
614  bool pass = test_bool((test == expected), true, func, line);
615  if (!pass) {
616  std::printf(" CoordSys (1 v 2): %d v %d\n",
617  int(test.GetCoordSystem()), int(expected.GetCoordSystem()));
618  std::printf(" XCoords: %3.15e : %3.15e (deg), diff = %e arcsec\n",
619  test.XCoordinate_Deg(), expected.XCoordinate_Deg(),
620  (test.XCoordinate_Deg()-expected.XCoordinate_Deg())*3600.0);
621  std::printf(" YCoords: %3.15e : %3.15e (deg), diff = %e arcsec\n",
622  test.YCoordinate_Deg(), expected.YCoordinate_Deg(),
623  (test.YCoordinate_Deg()-expected.YCoordinate_Deg())*3600.0);
624  std::printf(" AngSep: %e arcsec\n",
625  test.AngularSeparation(expected).Deg()*3600.0);
626  }
627  return pass;
628 }
629 
630 
631 /**********************************************************************/
634 int main(int argc, char** argv)
635 {
636  test_CECoordinates tester;
637  return (!tester.runtests());
638 }
CEObserver::Elevation_m
double Elevation_m() const
Return altitude in meters above sea level.
Definition: CEObserver.h:166
CECoordinates::DMSToAngle
static double DMSToAngle(const std::vector< double > &angle, const CEAngleType &return_type=CEAngleType::DEGREES)
Convert a given angle vector from {degrees, minutes, seconds} to an angle.
Definition: CECoordinates.cpp:1662
test_CECoordinates::base_obs_
CECoordinates base_obs_
Definition: test_CECoordinates.h:77
main
int main(int argc, char **argv)
Main method that actually runs the tests.
Definition: test_CECoordinates.cpp:634
CECoordinates::Observed2Galactic
static int Observed2Galactic(double az, double zen, double *glon, double *glat, const CEDate &date, const CEObserver &observer, const CEAngleType &angle_type=CEAngleType::RADIANS)
Convert Observed -> Galactic coordinates.
Definition: CECoordinates.cpp:653
test_CECoordinates::test_CECoordinates
test_CECoordinates()
Default constructor.
Definition: test_CECoordinates.cpp:30
CECoordinates::AngularSeparation
virtual CEAngle AngularSeparation(const CECoordinates &coords) const
Get the angular separation between the coordinates represented by this object and another coordinate ...
Definition: CECoordinates.cpp:1169
test_CECoordinates::test_Convert2Cirs
virtual bool test_Convert2Cirs(void)
Test ability to set coordinates as CIRS.
Definition: test_CECoordinates.cpp:183
CENamespace.h
CECoordinateType::GALACTIC
Galacitc longitude, latitude.
CEAngle::DmsVect
std::vector< double > DmsVect(void) const
Return vector of doubles representing the {degrees, arcmin, arcsec, arcsec-fraction}.
Definition: CEAngle.cpp:291
CEDate
Definition: CEDate.h:43
CECoordinates::CIRS2Galactic
static void CIRS2Galactic(double ra, double dec, double *glon, double *glat, const CEDate &date=CEDate(), const CEAngleType &angle_type=CEAngleType::RADIANS)
CIRS -> Galactic coordinate conversion.
Definition: CECoordinates.cpp:181
CEObserver::Temperature_C
double Temperature_C() const
Return temperature in degrees Celsius.
Definition: CEObserver.h:186
test_CECoordinates::test_copy
virtual bool test_copy(void)
Test ability to copy coordinates.
Definition: test_CECoordinates.cpp:148
CECoordinates::ICRS2Galactic
static void ICRS2Galactic(double ra, double dec, double *glon, double *glat, const CEAngleType &angle_type=CEAngleType::RADIANS)
ICRS -> Galactic coordinate conversion (uses the SOFA 'iauIcrs2g' function)
Definition: CECoordinates.cpp:336
CECoordinates::XCoordinate_Deg
virtual double XCoordinate_Deg(double jd=CppEphem::julian_date_J2000()) const
Returns x coordinate at given julian date in degrees.
Definition: CECoordinates.h:450
CECoordinates::ConvertToICRS
CECoordinates ConvertToICRS(double jd=CEDate::CurrentJD(), double longitude=0.0, double latitude=0.0, double elevation_m=0.0, double pressure_hPa=-1.0, double temperature_celsius=-1000, double relative_humidity=0.0, double dut1=0.0, double xp=0.0, double yp=0.0, double wavelength_um=0.5)
Convert these coordinates to ICRS coordinates.
Definition: CECoordinates.cpp:1418
test_CECoordinates::test_HmsDms2Angle
virtual bool test_HmsDms2Angle(void)
Test conversions between HMS and DMS to angle and back.
Definition: test_CECoordinates.cpp:502
CECoordinates::GetObservedCoords
virtual CECoordinates GetObservedCoords(const double &julian_date, const double &longitude, const double &latitude, const double &elevation_m=0.0, const double &pressure_hPa=-1.0, const double &temperature_celsius=-1000, const double &relative_humidity=0.0, const double &dut1=0.0, const double &xp=0.0, const double &yp=0.0, const double &wavelength_um=0.5) const
Return the local sky coordinates of this object as a CECoordinates object.
Definition: CECoordinates.cpp:1087
CECoordinates::CIRS2ICRS
static void CIRS2ICRS(double input_ra, double input_dec, double *return_ra, double *return_dec, const CEDate &date=CEDate(), const CEAngleType &angle_type=CEAngleType::RADIANS)
CIRS -> ICRS coordinate conversion.
Definition: CECoordinates.cpp:144
test_CECoordinates
Definition: test_CECoordinates.h:29
CECoordinates::Observed2CIRS
static int Observed2CIRS(double az, double zen, double *ra, double *dec, const CEDate &date, const CEObserver &observer, const CEAngleType &angle_type=CEAngleType::RADIANS)
Convert Observed -> CIRS coordinates.
Definition: CECoordinates.cpp:566
CEObserver.h
CECoordinates::YCoord
virtual CEAngle YCoord(const double &jd=CppEphem::julian_date_J2000()) const
Return y coordinate at given Julian date.
Definition: CECoordinates.h:424
CECoordinates::XCoordinate_Rad
virtual double XCoordinate_Rad(double jd=CppEphem::julian_date_J2000()) const
Return x coordinate at given Julian date in radians.
Definition: CECoordinates.h:437
CECoordinates::ConvertToGalactic
CECoordinates ConvertToGalactic(double jd=CEDate::CurrentJD(), double longitude=0.0, double latitude=0.0, double elevation_m=0.0, double pressure_hPa=-1.0, double temperature_celsius=-1000, double relative_humidity=0.0, double dut1=0.0, double xp=0.0, double yp=0.0, double wavelength_um=0.5)
Convert these coordinates to GALACTIC coordinates.
Definition: CECoordinates.cpp:1471
CEObserver::RelativeHumidity
double RelativeHumidity() const
Return relative humidity.
Definition: CEObserver.h:216
test_CECoordinates::~test_CECoordinates
virtual ~test_CECoordinates()
Destructor.
Definition: test_CECoordinates.cpp:69
CEObserver::Longitude_Rad
double Longitude_Rad() const
Return observer geographic longitude in radians.
Definition: CEObserver.h:126
test_CECoordinates::runtests
virtual bool runtests()
Run tests.
Definition: test_CECoordinates.cpp:78
test_CECoordinates.h
CEObserver::SetRelativeHumidity
void SetRelativeHumidity(const double &humidity=0.0)
Set the observer's relative humidity.
Definition: CEObserver.h:349
CECoordinates::YCoordinate_Deg
virtual double YCoordinate_Deg(double jd=CppEphem::julian_date_J2000()) const
Returns y coordinate at given Julian date in degrees.
Definition: CECoordinates.h:475
CECoordinateType::ICRS
RA, Dec (referenced at the barycenter of the solarsystem)
test_CECoordinates::base_icrs_
CECoordinates base_icrs_
Definition: test_CECoordinates.h:75
CECoordinates::ConvertTo
CECoordinates ConvertTo(CECoordinateType output_coord_type, const CEObserver &observer, const CEDate &date=CEDate::CurrentJD())
Convert these coordinates to another coordinate system NOTE: If this object is not OBSERVED coordinat...
Definition: CECoordinates.cpp:1261
CEObserver::SetWavelength_um
void SetWavelength_um(const double &new_wavelength_um)
Set the observer's observing wavelength (micrometers)
Definition: CEObserver.h:393
test_CECoordinates::base_observer_
CEObserver base_observer_
Definition: test_CECoordinates.h:79
CECoordinates::Observed2ICRS
static int Observed2ICRS(double az, double zen, double *ra, double *dec, const CEDate &date, const CEObserver &observer, const CEAngleType &angle_type=CEAngleType::RADIANS)
Convert Observed -> ICRS coordinates.
Definition: CECoordinates.cpp:608
CEObserver::SetPressure_hPa
void SetPressure_hPa(const double &pressure=CppEphem::EstimatePressure_hPa(CppEphem::SeaLevelTemp_C()))
Set the observer's pressure.
Definition: CEObserver.h:338
CECoordinates::GetDMS
static std::vector< double > GetDMS(const double &angle, const CEAngleType &angle_type=CEAngleType::DEGREES)
Convert a given angle into degrees, arcminutes, arcseconds.
Definition: CECoordinates.cpp:1594
test_CECoordinates::test_Convert2Icrs
virtual bool test_Convert2Icrs(void)
Test ability to convert to ICRS.
Definition: test_CECoordinates.cpp:269
CEAngle
Definition: CEAngle.h:38
CEDate::ypolar
static double ypolar(const double &date, const CEDateType &date_type=CEDateType::JD)
Polar motion (xy for a given date.
Definition: CEDate.cpp:520
CEAngle::Rad
double Rad(void) const
Return angle in radians as a double.
Definition: CEAngle.cpp:351
CEObserver::Pressure_hPa
double Pressure_hPa() const
Return atmospheric pressure in units of hPa.
Definition: CEObserver.h:176
CECoordinates::ConvertToCIRS
CECoordinates ConvertToCIRS(double jd=CEDate::CurrentJD(), double longitude=0.0, double latitude=0.0, double elevation_m=0.0, double pressure_hPa=-1.0, double temperature_celsius=-1000, double relative_humidity=0.0, double dut1=0.0, double xp=0.0, double yp=0.0, double wavelength_um=0.5)
Convert these coordinates to CIRS coordinates.
Definition: CECoordinates.cpp:1358
CEObserver::Wavelength_um
double Wavelength_um() const
Return the wavelength in units of micrometers.
Definition: CEObserver.h:226
CEObserver::SetTemperature_C
void SetTemperature_C(const double &temp_C=CppEphem::SeaLevelTemp_C())
Set the observer's temperature (Celsius)
Definition: CEObserver.h:360
CECoordinates::GetCoordSystem
CECoordinateType GetCoordSystem(void) const
Return coordinate system.
Definition: CECoordinates.h:486
CppEphem::julian_date_J2000
double julian_date_J2000()
Julian Date corresponding to J2000.
Definition: CENamespace.h:67
test_CECoordinates::base_date_
CEDate base_date_
Definition: test_CECoordinates.h:78
CEAngleType::DEGREES
test_CECoordinates::base_gal_
CECoordinates base_gal_
Definition: test_CECoordinates.h:76
CECoordinates::ConvertToObserved
CECoordinates ConvertToObserved(double jd=CEDate::CurrentJD(), double longitude=0.0, double latitude=0.0, double elevation_m=0.0, double pressure_hPa=-1.0, double temperature_celsius=-1000, double relative_humidity=0.0, double dut1=0.0, double xp=0.0, double yp=0.0, double wavelength_um=0.5)
Convert these coordinates to observed coordinates.
Definition: CECoordinates.cpp:1522
JD
Julian Date.
Definition: CEDate.h:56
test_CECoordinates::test_construct
virtual bool test_construct(void)
Test generic constructors.
Definition: test_CECoordinates.cpp:103
test_CECoordinates::test_ConvertTo
virtual bool test_ConvertTo(void)
Tests the CECoordinates::ConvrtTo methods.
Definition: test_CECoordinates.cpp:573
CECoordinates::Galactic2CIRS
static void Galactic2CIRS(double glon, double glat, double *ra, double *dec, const CEDate &date=CEDate(), const CEAngleType &angle_type=CEAngleType::RADIANS)
Galactic -> CIRS coordinate conversion.
Definition: CECoordinates.cpp:441
test_CECoordinates::test_coords
virtual bool test_coords(const CECoordinates &test, const CECoordinates &expected, const std::string &func, const int &line)
Tests two coordinates are equal and print some help if they aren't.
Definition: test_CECoordinates.cpp:608
CECoordinates::CIRS2Observed
static int CIRS2Observed(double ra, double dec, double *az, double *zen, const CEDate &date, const CEObserver &observer, const CEAngleType &angle_type=CEAngleType::RADIANS, double wavelength_um=0.5, double *observed_ra=nullptr, double *observed_dec=nullptr, double *hour_angle=nullptr)
CIRS -> Observed (or observer specific) coordinate conversion This function takes in verious observat...
Definition: CECoordinates.cpp:224
CECoordinates::Galactic2Observed
static int Galactic2Observed(double glon, double glat, double *az, double *zen, const CEDate &date, const CEObserver &observer, const CEAngleType &angle_type=CEAngleType::RADIANS, double wavelength_um=0.5, double *observed_glon=nullptr, double *observed_glat=nullptr, double *hour_angle=nullptr)
Galactic -> Observed (i.e.
Definition: CECoordinates.cpp:508
CECoordinates::HMSToAngle
static double HMSToAngle(const std::vector< double > &angle, const CEAngleType &return_type=CEAngleType::DEGREES)
Convert from {hours, minutes, seconds} to an angle.
Definition: CECoordinates.cpp:1636
CECoordinates::GetHMS
static std::vector< double > GetHMS(const double &angle, const CEAngleType &angle_type=CEAngleType::DEGREES)
Convert a given angle into hours, minutes, seconds.
Definition: CECoordinates.cpp:1613
CECoordinates
Definition: CECoordinates.h:48
CEAngleType::RADIANS
CEObserver
Definition: CEObserver.h:28
CEAngle::Deg
double Deg(void) const
Return angle in degrees as a double.
Definition: CEAngle.cpp:328
test_CECoordinates::test_Convert2Galactic
virtual bool test_Convert2Galactic(void)
Test ability to convert to Galactic.
Definition: test_CECoordinates.cpp:329
CppEphem::CorrectionsInterp
void CorrectionsInterp(bool set_interp)
Set the corrections object to use interpolation.
Definition: CENamespace.cpp:99
CECoordinates::XCoord
virtual CEAngle XCoord(const double &jd=CppEphem::julian_date_J2000()) const
Return x coordinate at given Julian date.
Definition: CECoordinates.h:411
CECoordinateType::CIRS
RA, Dec (referenced at the center of the Earth)
CEDate::xpolar
static double xpolar(const double &date, const CEDateType &date_type=CEDateType::JD)
Polar motion (x) for a given date.
Definition: CEDate.cpp:494
CECoordinates::ICRS2CIRS
static void ICRS2CIRS(double input_ra, double input_dec, double *return_ra, double *return_dec, const CEDate &date=CEDate(), const CEAngleType &angle_type=CEAngleType::RADIANS)
ICRS -> CIRS coordinate conversion.
Definition: CECoordinates.cpp:287
CECoordinates::SetCoordinates
virtual void SetCoordinates(const CEAngle &xcoord, const CEAngle &ycoord, const CECoordinateType &coord_type=CECoordinateType::ICRS)
Set the coordinates of this object.
Definition: CECoordinates.cpp:1682
CECoordinates::YCoordinate_Rad
virtual double YCoordinate_Rad(double jd=CppEphem::julian_date_J2000()) const
Returns y coordinate at given Julian date in radians.
Definition: CECoordinates.h:463
CEDate::SetReturnType
void SetReturnType(CEDateType return_type)
Set the return type from the overloaded 'operator double'.
Definition: CEDate.h:247
test_CECoordinates::test_Convert2Observed
virtual bool test_Convert2Observed(void)
Test ability to convert to Observed.
Definition: test_CECoordinates.cpp:393
CEDate::JD
virtual double JD() const
Get the Julian date represented by this object.
Definition: CEDate.h:150
CEObserver::Latitude_Rad
double Latitude_Rad() const
Return geographic latitude in radians.
Definition: CEObserver.h:146
test_CECoordinates::base_cirs_
CECoordinates base_cirs_
Definition: test_CECoordinates.h:74
CECoordinateType::OBSERVED
Azimuth, Zenith (requires additional observer information)
CEAngle::Deg
static CEAngle Deg(const double &angle)
Return angle (radians) constructed from a degree angle.
Definition: CEAngle.cpp:317
CECoordinates::ICRS2Observed
static int ICRS2Observed(double ra, double dec, double *az, double *zen, const CEDate &date, const CEObserver &observer, const CEAngleType &angle_type=CEAngleType::RADIANS, double wavelength_um=0.5, double *observed_ra=nullptr, double *observed_dec=nullptr, double *hour_angle=nullptr)
ICRS -> Observed coordinate conversion.
Definition: CECoordinates.cpp:373
CECoordinates::Galactic2ICRS
static void Galactic2ICRS(double glon, double glat, double *ra, double *dec, const CEAngleType &angle_type=CEAngleType::RADIANS)
Galactic -> ICRS coordinate conversion.
Definition: CECoordinates.cpp:474
CEDate::dut1
static double dut1(const double &date, const CEDateType &date_type=CEDateType::JD)
Return dut1 based on a given modified date.
Definition: CEDate.cpp:447
test_CECoordinates::test_AngularSeparation
virtual bool test_AngularSeparation(void)
Test computation of angular separation.
Definition: test_CECoordinates.cpp:544
Generated on Wed Aug 21 2019 12:14:12 for CppEphem by   doxygen 1.8.16