CppEphem
test_CESkyCoord.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * test_CESkyCoord.cpp: CppEphem *
3  * ----------------------------------------------------------------------- *
4  * Copyright © 2019 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_CESkyCoord.h"
23 #include "CEObserver.h"
24 #include "CENamespace.h"
25 #include "test_CECoordinates.h"
26 
27 
28 /**********************************************************************/
31 test_CESkyCoord::test_CESkyCoord() :
32  CETestSuite()
33 {
34  // Interpolate the correction terms
35  CppEphem::CorrectionsInterp(true);
36 
37  // Lets use the Crab Nebula (M1) for our testing
38 
39  // The following coordinates are derived from Astopy using the script:
40  // cppephem/test/astropy_scripts/test_cecoordinates_setup.py
41  base_icrs_ = CESkyCoord(CEAngle::Deg(83.633), CEAngle::Deg(22.0145),
42  CESkyCoordType::ICRS);
43  base_cirs_ = CESkyCoord(CEAngle::Deg(83.63843844654943),
44  CEAngle::Deg(22.012942530431776),
45  CESkyCoordType::CIRS);
46  base_gal_ = CESkyCoord(CEAngle::Deg(184.55741630955762),
47  CEAngle::Deg(-5.784421958594916),
48  CESkyCoordType::GALACTIC);
49  base_obs_ = CESkyCoord(CEAngle::Deg(35.598599384274294),
50  CEAngle::Deg(152.55068501449307),
51  CESkyCoordType::OBSERVED);
52  base_ecl_ = CESkyCoord(CEAngle::Deg(84.09742873115043),
53  CEAngle::Deg(-1.2944191660399447),
54  CESkyCoordType::ECLIPTIC);
55 
56  // Create the date object
57  base_date_ = CEDate(CppEphem::julian_date_J2000(), CEDateType::JD);
58  // Interpret the date object as a julian date
59  base_date_.SetReturnType(CEDateType::JD);
60 
61  // Setup the observer object for observed coordinates
62  base_observer_ = CEObserver(0.0, 0.0, 0.0, CEAngleType::DEGREES);
63  base_observer_.SetTemperature_C(0.0);
64  base_observer_.SetPressure_hPa(0.0);
65  base_observer_.SetRelativeHumidity(0.0);
66  base_observer_.SetWavelength_um(0.0);
67 }
68 
69 
70 /**********************************************************************/
73 test_CESkyCoord::~test_CESkyCoord()
74 {}
75 
76 
77 /**********************************************************************/
82 bool test_CESkyCoord::runtests()
83 {
84  std::cout << "\nTesting CESkyCoord:\n";
85 
86  // Test constructions
87  test_construct();
88  test_copy();
89 
90  // Conversion tests
91  test_Convert2Cirs();
92  test_Convert2Icrs();
93  test_Convert2Galactic();
94  test_Convert2Observed();
95  test_Convert2Ecliptic();
96 
97  // Test dedicated methods
98  test_AngularSeparation();
99  test_ConvertTo();
100 
101  return pass();
102 }
103 
104 /**********************************************************************/
107 bool test_CESkyCoord::test_construct()
108 {
109  // Test the default constructor
110  CESkyCoord test1;
111  test_double(test1.XCoord().Rad(), 0.0, __func__, __LINE__);
112  test_double(test1.YCoord().Rad(), 0.0, __func__, __LINE__);
113 
114  // Test constructor from CEAngle objects
115  CEAngle testx = CEAngle::Deg(83.633);
116  CEAngle testy = CEAngle::Deg(22.0145);
117  CESkyCoord test2(testx, testy, CESkyCoordType::ICRS);
118  test_double(test2.XCoord(), testx, __func__, __LINE__);
119  test_double(test2.YCoord(), testy, __func__, __LINE__);
120  test_int(int(test2.GetCoordSystem()), int(CESkyCoordType::ICRS), __func__, __LINE__);
121 
122  // Test copy constructor
123  CESkyCoord test4(test2);
124  test_double(test4.XCoord(), testx, __func__, __LINE__);
125  test_double(test4.YCoord(), testy, __func__, __LINE__);
126  test_int(int(test4.GetCoordSystem()), int(test2.GetCoordSystem()), __func__, __LINE__);
127 
128  // Test copy-assignment operator
129  CESkyCoord test5 = test2;
130  test_coords(test5, test2, __func__, __LINE__);
131 
132  // Test constructor from CECoordinates
133  CECoordinates coord(testx, testy, CECoordinateType::GALACTIC);
134  CESkyCoord test6(coord);
135  test_double(test6.XCoord(), testx, __func__, __LINE__);
136  test_double(test6.YCoord(), testy, __func__, __LINE__);
137  test_int(int(test6.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_CESkyCoord::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  CESkyCoord cirs = base_cirs_;
158  test_coords(cirs, base_cirs_, __func__, __LINE__);
159 
160  // Copy ICRS
161  CESkyCoord icrs = base_icrs_;
162  test_coords(icrs, base_icrs_, __func__, __LINE__);
163 
164  // Copy Galactic
165  CESkyCoord gal = base_gal_;
166  test_coords(gal, base_gal_, __func__, __LINE__);
167 
168  // Copy Observed
169  CESkyCoord obs = base_obs_;
170  test_coords(obs, base_obs_, __func__, __LINE__);
171 
172  // Copy coordinates directly
173  gal.SetCoordinates(icrs);
174  test_coords(gal, icrs, __func__, __LINE__);
175 
176  return pass();
177 }
178 
179 
180 /**********************************************************************/
183 bool test_CESkyCoord::test_Convert2Cirs()
184 {
185  // CIRS -> CIRS
186  CESkyCoord cirs2cirs = base_cirs_.ConvertToCIRS();
187  test_coords(cirs2cirs, base_cirs_, __func__, __LINE__);
188 
189  // ICRS -> CIRS
190  CESkyCoord icrs2cirs = base_icrs_.ConvertToCIRS(base_date_);
191  test_coords(icrs2cirs, base_cirs_, __func__, __LINE__);
192 
193  CESkyCoord::ICRS2CIRS(base_icrs_, &icrs2cirs, base_date_);
194  test_coords(icrs2cirs, base_cirs_, __func__, __LINE__);
195 
196  // Galactic -> CIRS
197  CESkyCoord gal2cirs = base_gal_.ConvertToCIRS(base_date_);
198  test_coords(gal2cirs, base_cirs_, __func__, __LINE__);
199 
200  CESkyCoord::Galactic2CIRS(base_gal_, &gal2cirs, base_date_);
201  test_coords(gal2cirs, base_cirs_, __func__, __LINE__);
202 
203  // Observed -> CIRS
204  CESkyCoord obs2cirs = base_obs_.ConvertToCIRS(base_date_, base_observer_);
205  test_coords(obs2cirs, base_cirs_, __func__, __LINE__);
206 
207  CESkyCoord::Observed2CIRS(base_obs_, &obs2cirs, base_date_, base_observer_);
208  test_coords(obs2cirs, base_cirs_, __func__, __LINE__);
209 
210  // Ecliptic -> CIRS
211  CESkyCoord ecl2cirs = base_ecl_.ConvertToCIRS(base_date_);
212  test_coords(ecl2cirs, base_cirs_, __func__, __LINE__);
213 
214  CESkyCoord::Ecliptic2CIRS(base_ecl_, &ecl2cirs, base_date_);
215  test_coords(ecl2cirs, base_cirs_, __func__, __LINE__);
216 
217  return pass();
218 }
219 
220 
221 /**********************************************************************/
224 bool test_CESkyCoord::test_Convert2Icrs()
225 {
226  // CIRS -> ICRS
227  CESkyCoord cirs2icrs = base_cirs_.ConvertToICRS(base_date_);
228  test_coords(cirs2icrs, base_icrs_, __func__, __LINE__);
229 
230  CESkyCoord::CIRS2ICRS(base_cirs_, &cirs2icrs, base_date_);
231  test_coords(cirs2icrs, base_icrs_, __func__, __LINE__);
232 
233  // ICRS -> ICRS
234  CESkyCoord icrs2icrs = base_icrs_.ConvertToICRS();
235  test_coords(icrs2icrs, base_icrs_, __func__, __LINE__);
236 
237  // Galactic -> ICRS
238  CESkyCoord gal2icrs = base_gal_.ConvertToICRS();
239  test_coords(gal2icrs, base_icrs_, __func__, __LINE__);
240 
241  CESkyCoord::Galactic2ICRS(base_gal_, &gal2icrs);
242  test_coords(gal2icrs, base_icrs_, __func__, __LINE__);
243 
244  // Observed -> ICRS
245  CESkyCoord obs2icrs = base_obs_.ConvertToICRS(base_date_, base_observer_);
246  test_coords(obs2icrs, base_icrs_, __func__, __LINE__);
247 
248  CESkyCoord::Observed2ICRS(base_obs_, &obs2icrs, base_date_, base_observer_);
249  test_coords(obs2icrs, base_icrs_, __func__, __LINE__);
250 
251  // Ecliptic -> ICRS
252  CESkyCoord ecl2icrs = base_ecl_.ConvertToICRS(base_date_);
253  test_coords(ecl2icrs, base_icrs_, __func__, __LINE__);
254 
255  CESkyCoord::Ecliptic2ICRS(base_ecl_, &ecl2icrs, base_date_);
256  test_coords(ecl2icrs, base_icrs_, __func__, __LINE__);
257 
258  return pass();
259 }
260 
261 /**********************************************************************/
264 bool test_CESkyCoord::test_Convert2Galactic()
265 {
266  // CIRS -> Galactic
267  CESkyCoord cirs2gal = base_cirs_.ConvertToGalactic(base_date_);
268  test_coords(cirs2gal, base_gal_, __func__, __LINE__);
269 
270  CESkyCoord::CIRS2Galactic(base_cirs_, &cirs2gal, base_date_);
271  test_coords(cirs2gal, base_gal_, __func__, __LINE__);
272 
273  // ICRS -> Galactic
274  CESkyCoord icrs2gal = base_icrs_.ConvertToGalactic();
275  test_coords(icrs2gal, base_gal_, __func__, __LINE__);
276 
277  CESkyCoord::ICRS2Galactic(base_icrs_, &icrs2gal);
278  test_coords(icrs2gal, base_gal_, __func__, __LINE__);
279 
280  // Galactic -> Galactic
281  CESkyCoord gal2gal = base_gal_.ConvertToGalactic();
282  test_coords(gal2gal, base_gal_, __func__, __LINE__);
283 
284  // Observed -> Galactic
285  CESkyCoord obs2gal = base_obs_.ConvertToGalactic(base_date_, base_observer_);
286  test_coords(obs2gal, base_gal_, __func__, __LINE__);
287 
288  CESkyCoord::Observed2Galactic(base_obs_, &obs2gal, base_date_, base_observer_);
289  test_coords(obs2gal, base_gal_, __func__, __LINE__);
290 
291  // Ecliptic -> Galactic
292  CESkyCoord ecl2gal = base_ecl_.ConvertToGalactic(base_date_);
293  test_coords(ecl2gal, base_gal_, __func__, __LINE__);
294 
295  CESkyCoord::Ecliptic2Galactic(base_ecl_, &ecl2gal, base_date_);
296  test_coords(ecl2gal, base_gal_, __func__, __LINE__);
297 
298  return pass();
299 }
300 
301 
302 /**********************************************************************/
305 bool test_CESkyCoord::test_Convert2Observed()
306 {
307  // Preliminary variable for observer based conversion
308  CESkyCoord testobs;
309 
310  // CIRS -> Observed
311  CESkyCoord cirs2obs = base_cirs_.ConvertToObserved(base_date_, base_observer_);
312  test_coords(cirs2obs, base_obs_, __func__, __LINE__);
313 
314  CESkyCoord::CIRS2Observed(base_cirs_, &testobs, base_date_, base_observer_);
315  test_coords(testobs, base_obs_, __func__, __LINE__);
316 
317  // ICRS -> Observed
318  CESkyCoord icrs2obs = base_icrs_.ConvertToObserved(base_date_, base_observer_);
319  test_coords(icrs2obs, base_obs_, __func__, __LINE__);
320 
321  CESkyCoord::ICRS2Observed(base_icrs_, &testobs, base_date_, base_observer_);
322  test_coords(testobs, base_obs_, __func__, __LINE__);
323 
324  // Galactic -> Observed
325  CESkyCoord gal2obs = base_gal_.ConvertToObserved(base_date_, base_observer_);
326  test_coords(gal2obs, base_obs_, __func__, __LINE__);
327 
328  CESkyCoord::Galactic2Observed(base_gal_, &testobs, base_date_, base_observer_);
329  test_coords(testobs, base_obs_, __func__, __LINE__);
330 
331  // Observed -> Observed
332  CESkyCoord obs2obs = base_obs_.ConvertToObserved();
333  test_coords(obs2obs, base_obs_, __func__, __LINE__);
334 
335  // Ecliptic -> Observed
336  CESkyCoord ecl2obs = base_ecl_.ConvertToObserved(base_date_, base_observer_);
337  test_coords(ecl2obs, base_obs_, __func__, __LINE__);
338 
339  CESkyCoord::Ecliptic2Observed(base_ecl_, &ecl2obs, base_date_, base_observer_);
340  test_coords(ecl2obs, base_obs_, __func__, __LINE__);
341 
342  return pass();
343 }
344 
345 
346 /**********************************************************************/
349 bool test_CESkyCoord::test_Convert2Ecliptic()
350 {
351  // CIRS -> Ecliptic
352  CESkyCoord cirs2ecl = base_cirs_.ConvertToEcliptic(base_date_);
353  test_coords(cirs2ecl, base_ecl_, __func__, __LINE__);
354 
355  CESkyCoord::CIRS2Ecliptic(base_cirs_, &cirs2ecl, base_date_);
356  test_coords(cirs2ecl, base_ecl_, __func__, __LINE__);
357 
358  // ICRS -> Ecliptic
359  CESkyCoord icrs2ecl = base_icrs_.ConvertToEcliptic(base_date_);
360  test_coords(icrs2ecl, base_ecl_, __func__, __LINE__);
361 
362  CESkyCoord::ICRS2Ecliptic(base_icrs_, &icrs2ecl, base_date_);
363  test_coords(icrs2ecl, base_ecl_, __func__, __LINE__);
364 
365  // Galactic -> Ecliptic
366  CESkyCoord gal2ecl = base_gal_.ConvertToEcliptic(base_date_);
367  test_coords(gal2ecl, base_ecl_, __func__, __LINE__);
368 
369  // Observed -> Ecliptic
370  CESkyCoord obs2ecl = base_obs_.ConvertToEcliptic(base_date_, base_observer_);
371  test_coords(obs2ecl, base_ecl_, __func__, __LINE__);
372 
373  CESkyCoord::Observed2Ecliptic(base_obs_, &obs2ecl, base_date_, base_observer_);
374  test_coords(obs2ecl, base_ecl_, __func__, __LINE__);
375 
376  // Ecliptic -> Ecliptic
377  CESkyCoord ecl2ecl = base_ecl_.ConvertToEcliptic();
378  test_coords(ecl2ecl, base_ecl_, __func__, __LINE__);
379 
380  return pass();
381 }
382 
383 
384 /**********************************************************************/
387 bool test_CESkyCoord::test_AngularSeparation(void)
388 {
389  // Establish the preliminary variables that will be used
390  CEAngle test1_x = CEAngle::Deg(0.0);
391  CEAngle test1_y = CEAngle::Deg(-1.0);
392  CEAngle test2_x = CEAngle::Deg(0.0);
393  CEAngle test2_y = CEAngle::Deg(1.0);
394  CESkyCoord test1(test1_x, test1_y, CESkyCoordType::ICRS);
395  CESkyCoord test2(test2_x, test2_y, CESkyCoordType::ICRS);
396 
397  // Test the default coordinate separation
398  CEAngle angsep = test1.AngularSeparation(test2);
399  test_double(angsep.Deg(), 2.0, __func__, __LINE__);
400 
401  // Static method
402  angsep = CESkyCoord::AngularSeparation(test1, test2);
403  test_double(angsep.Deg(), 2.0, __func__, __LINE__);
404 
405  // 2nd static Method not requiring CESkyCoord objects
406  angsep = CESkyCoord::AngularSeparation(test1_x, test1_y,
407  test2_x, test2_y);
408  test_double(angsep.Deg(), 2.0, __func__, __LINE__);
409 
410  // Test that the two coordinates are not equal
411  test((test1 != test2), __func__, __LINE__);
412 
413  // Test that it fails if the coordinates are not the same type
414  try {
415  angsep = CESkyCoord::AngularSeparation(base_icrs_, base_gal_);
416  test(false, __func__, __LINE__);
417  } catch (std::exception &e) {
418  test(true, __func__, __LINE__);
419  }
420 
421  return pass();
422 }
423 
424 
425 /**********************************************************************/
428 bool test_CESkyCoord::test_ConvertTo(void)
429 {
430  // Create an observer object
431  CEObserver observer(0.0, 0.0, 0.0, CEAngleType::DEGREES);
432  observer.SetTemperature_C(0.0);
433  observer.SetPressure_hPa(0.0);
434  observer.SetWavelength_um(0.0);
435  observer.SetRelativeHumidity(0.0);
436 
437  // Create a date object
438  CEDate date(CppEphem::julian_date_J2000(), CEDateType::JD);
439 
440  /* ---------------------------*
441  * ConvertTo basic form
442  * ---------------------------*/
443  CESkyCoord test_icrs = base_icrs_.ConvertTo(CESkyCoordType::ICRS,
444  date, observer);
445  test_coords(test_icrs, base_icrs_, __func__, __LINE__);
446  CESkyCoord test_cirs = base_icrs_.ConvertTo(CESkyCoordType::CIRS,
447  date, observer);
448  test_coords(test_cirs, base_cirs_, __func__, __LINE__);
449  CESkyCoord test_gal = base_icrs_.ConvertTo(CESkyCoordType::GALACTIC,
450  date, observer);
451  test_coords(test_gal, base_gal_, __func__, __LINE__);
452  CESkyCoord test_obs = base_icrs_.ConvertTo(CESkyCoordType::OBSERVED,
453  date, observer);
454  test_coords(test_obs, base_obs_, __func__, __LINE__);
455 
456  return pass();
457 }
458 
459 
460 /**********************************************************************/
463 bool test_CESkyCoord::test_coords(const CESkyCoord& test,
464  const CESkyCoord& expected,
465  const std::string& func,
466  const int& line)
467 {
468  // Test if the coordinates are equal
469  bool pass = test_bool((test == expected), true, func, line);
470  if (!pass) {
471  std::printf(" CoordSys (1 v 2): %d v %d\n",
472  int(test.GetCoordSystem()), int(expected.GetCoordSystem()));
473  std::printf(" XCoords: %3.15e : %3.15e (deg), diff = %e arcsec\n",
474  test.XCoord().Deg(), expected.XCoord().Deg(),
475  (test.XCoord().Deg()-expected.XCoord().Deg())*3600.0);
476  std::printf(" YCoords: %3.15e : %3.15e (deg), diff = %e arcsec\n",
477  test.YCoord().Deg(), expected.YCoord().Deg(),
478  (test.YCoord().Deg()-expected.YCoord().Deg())*3600.0);
479  std::printf(" AngSep: %e arcsec\n",
480  test.AngularSeparation(expected).Deg()*3600.0);
481  }
482  return pass;
483 }
484 
485 
486 /**********************************************************************/
489 int main(int argc, char** argv)
490 {
491  test_CESkyCoord tester;
492  return (!tester.runtests());
493 }
CESkyCoord::ConvertToEcliptic
CESkyCoord ConvertToEcliptic(const CEDate &date=CEDate(), const CEObserver &observer=CEObserver())
Convert this coordinate to ECLIPTIC coordinates.
Definition: CESkyCoord.cpp:965
test_CESkyCoord::test_copy
virtual bool test_copy(void)
Test ability to copy coordinates.
Definition: test_CESkyCoord.cpp:148
test_CESkyCoord::~test_CESkyCoord
virtual ~test_CESkyCoord()
Destructor.
Definition: test_CESkyCoord.cpp:73
CESkyCoordType::ICRS
RA, Dec (referenced at the barycenter of the solarsystem)
test_CESkyCoord::test_ConvertTo
virtual bool test_ConvertTo(void)
Tests the CESkyCoord::ConvertTo methods.
Definition: test_CESkyCoord.cpp:428
CESkyCoord::Galactic2ICRS
static void Galactic2ICRS(const CESkyCoord &in_galactic, CESkyCoord *out_icrs)
GALACTIC -> ICRS coordinate conversion.
Definition: CESkyCoord.cpp:492
CENamespace.h
CESkyCoord::ConvertToCIRS
CESkyCoord ConvertToCIRS(const CEDate &date=CEDate(), const CEObserver &observer=CEObserver())
Convert this coordinate to CIRS coordinates.
Definition: CESkyCoord.cpp:817
CESkyCoord::Ecliptic2ICRS
static void Ecliptic2ICRS(const CESkyCoord &in_ecliptic, CESkyCoord *out_icrs, const CEDate &date=CEDate())
ECLIPTIC -> ICRS coordinate conversion.
Definition: CESkyCoord.cpp:706
CESkyCoordType::CIRS
RA, Dec (referenced at the center of the Earth)
CECoordinateType::GALACTIC
Galacitc longitude, latitude.
CEDate
Definition: CEDate.h:43
CESkyCoord::Galactic2Observed
static void Galactic2Observed(const CESkyCoord &in_galactic, CESkyCoord *out_observed, const CEDate &date, const CEObserver &observer, CESkyCoord *observed_galactic=nullptr, CEAngle *hour_angle=nullptr)
GALACTIC -> OBSERVED coordinate conversion.
Definition: CESkyCoord.cpp:520
CESkyCoord
Definition: CESkyCoord.h:49
test_CESkyCoord::test_Convert2Icrs
virtual bool test_Convert2Icrs(void)
Test ability to convert to ICRS.
Definition: test_CESkyCoord.cpp:224
main
int main(int argc, char **argv)
Main method that actually runs the tests.
Definition: test_CESkyCoord.cpp:489
CESkyCoord::CIRS2ICRS
static void CIRS2ICRS(const CESkyCoord &in_cirs, CESkyCoord *out_icrs, const CEDate &date=CEDate())
Convert CIRS to ICRS coordinates.
Definition: CESkyCoord.cpp:201
CEObserver.h
CESkyCoord::AngularSeparation
virtual CEAngle AngularSeparation(const CESkyCoord &coords) const
Get the angular separation between the coordinates represented by this object and another coordinate ...
Definition: CESkyCoord.cpp:119
test_CESkyCoord::test_construct
virtual bool test_construct(void)
Test generic constructors.
Definition: test_CESkyCoord.cpp:107
CESkyCoord::ICRS2Galactic
static void ICRS2Galactic(const CESkyCoord &in_icrs, CESkyCoord *out_galactic)
ICRS -> GALACTIC coordinate conversion.
Definition: CESkyCoord.cpp:379
test_CESkyCoord.h
test_CESkyCoord::base_cirs_
CESkyCoord base_cirs_
Definition: test_CESkyCoord.h:74
CESkyCoord::CIRS2Galactic
static void CIRS2Galactic(const CESkyCoord &in_cirs, CESkyCoord *out_galactic, const CEDate &date=CEDate())
Convert CIRS to Galactic coordinates.
Definition: CESkyCoord.cpp:235
CESkyCoordType::GALACTIC
Galacitc longitude, latitude.
CESkyCoord::CIRS2Observed
static void CIRS2Observed(const CESkyCoord &in_cirs, CESkyCoord *out_observed, const CEDate &date, const CEObserver &observer, CESkyCoord *observed_cirs=nullptr, CEAngle *hour_angle=nullptr)
CIRS -> Observed (or observer specific) coordinate conversion.
Definition: CESkyCoord.cpp:258
test_CESkyCoord::test_Convert2Cirs
virtual bool test_Convert2Cirs(void)
Test ability to set coordinates as CIRS.
Definition: test_CESkyCoord.cpp:183
test_CECoordinates.h
test_CESkyCoord
Definition: test_CESkyCoord.h:29
CEObserver::SetRelativeHumidity
void SetRelativeHumidity(const double &humidity=0.0)
Set the observer's relative humidity.
Definition: CEObserver.h:349
test_CESkyCoord::base_ecl_
CESkyCoord base_ecl_
Definition: test_CESkyCoord.h:78
CEObserver::SetWavelength_um
void SetWavelength_um(const double &new_wavelength_um)
Set the observer's observing wavelength (micrometers)
Definition: CEObserver.h:393
test_CESkyCoord::test_Convert2Galactic
virtual bool test_Convert2Galactic(void)
Test ability to convert to Galactic.
Definition: test_CESkyCoord.cpp:264
CEObserver::SetPressure_hPa
void SetPressure_hPa(const double &pressure=CppEphem::EstimatePressure_hPa(CppEphem::SeaLevelTemp_C()))
Set the observer's pressure.
Definition: CEObserver.h:338
test_CESkyCoord::base_obs_
CESkyCoord base_obs_
Definition: test_CESkyCoord.h:77
CESkyCoord::ICRS2Ecliptic
static void ICRS2Ecliptic(const CESkyCoord &in_icrs, CESkyCoord *out_ecliptic, const CEDate &date=CEDate())
ICRS -> ECLIPTIC coordinate conversion.
Definition: CESkyCoord.cpp:440
test_CESkyCoord::base_observer_
CEObserver base_observer_
Definition: test_CESkyCoord.h:80
CESkyCoord::ICRS2CIRS
static void ICRS2CIRS(const CESkyCoord &in_icrs, CESkyCoord *out_cirs, const CEDate &date=CEDate())
ICRS -> CIRS coordinate conversion.
Definition: CESkyCoord.cpp:342
CEAngle
Definition: CEAngle.h:38
CESkyCoord::Ecliptic2CIRS
static void Ecliptic2CIRS(const CESkyCoord &in_ecliptic, CESkyCoord *out_cirs, const CEDate &date=CEDate())
ECLIPTIC -> CIRS coordinate conversion.
Definition: CESkyCoord.cpp:686
CEObserver::SetTemperature_C
void SetTemperature_C(const double &temp_C=CppEphem::SeaLevelTemp_C())
Set the observer's temperature (Celsius)
Definition: CEObserver.h:360
CppEphem::julian_date_J2000
double julian_date_J2000()
Julian Date corresponding to J2000.
Definition: CENamespace.h:67
CEAngle::Rad
static CEAngle Rad(const double &angle)
Return angle constructed from a radians angle.
Definition: CEAngle.cpp:340
CESkyCoord::GetCoordSystem
CESkyCoordType GetCoordSystem(void) const
Return coordinate system.
Definition: CESkyCoord.h:251
test_CESkyCoord::runtests
virtual bool runtests()
Run tests.
Definition: test_CESkyCoord.cpp:82
CEAngleType::DEGREES
CESkyCoord::Ecliptic2Galactic
static void Ecliptic2Galactic(const CESkyCoord &in_ecliptic, CESkyCoord *out_galactic, const CEDate &date=CEDate())
ECLIPTIC -> GALACTIC coordinate conversion.
Definition: CESkyCoord.cpp:737
CESkyCoord::ConvertToObserved
CESkyCoord ConvertToObserved(const CEDate &date=CEDate(), const CEObserver &observer=CEObserver())
Convert this coordinate to OBSERVED coordinates.
Definition: CESkyCoord.cpp:928
JD
Julian Date.
Definition: CEDate.h:56
test_CESkyCoord::test_coords
virtual bool test_coords(const CESkyCoord &test, const CESkyCoord &expected, const std::string &func, const int &line)
Tests two coordinates are equal and print some help if they aren't.
Definition: test_CESkyCoord.cpp:463
CESkyCoord::ICRS2Observed
static void ICRS2Observed(const CESkyCoord &in_icrs, CESkyCoord *out_observed, const CEDate &date, const CEObserver &observer, CESkyCoord *observed_cirs=nullptr, CEAngle *hour_angle=nullptr)
ICRS -> OBSERVED coordinate conversion.
Definition: CESkyCoord.cpp:407
CESkyCoord::Observed2CIRS
static void Observed2CIRS(const CESkyCoord &in_observed, CESkyCoord *out_cirs, const CEDate &date, const CEObserver &observer)
OBSERVED -> CIRS coordinate conversion.
Definition: CESkyCoord.cpp:573
test_CESkyCoord::test_AngularSeparation
virtual bool test_AngularSeparation(void)
Test computation of angular separation.
Definition: test_CESkyCoord.cpp:387
CESkyCoord::CIRS2Ecliptic
static void CIRS2Ecliptic(const CESkyCoord &in_cirs, CESkyCoord *out_ecliptic, const CEDate &date=CEDate())
Convert CIRS to ECLIPTIC coordinates.
Definition: CESkyCoord.cpp:322
test_CESkyCoord::test_Convert2Ecliptic
virtual bool test_Convert2Ecliptic(void)
Test ability to convert to Ecliptic.
Definition: test_CESkyCoord.cpp:349
test_CESkyCoord::base_icrs_
CESkyCoord base_icrs_
Definition: test_CESkyCoord.h:75
CECoordinates
Definition: CECoordinates.h:48
CESkyCoord::ConvertToGalactic
CESkyCoord ConvertToGalactic(const CEDate &date=CEDate(), const CEObserver &observer=CEObserver())
Convert this coordinate to GALACTIC coordinates.
Definition: CESkyCoord.cpp:891
test_CESkyCoord::test_CESkyCoord
test_CESkyCoord()
Default constructor.
Definition: test_CESkyCoord.cpp:31
test_CESkyCoord::test_Convert2Observed
virtual bool test_Convert2Observed(void)
Test ability to convert to Observed.
Definition: test_CESkyCoord.cpp:305
CEObserver
Definition: CEObserver.h:28
CEAngle::Deg
double Deg(void) const
Return angle in degrees as a double.
Definition: CEAngle.cpp:328
CppEphem::CorrectionsInterp
void CorrectionsInterp(bool set_interp)
Set the corrections object to use interpolation.
Definition: CENamespace.cpp:99
CESkyCoord::Observed2Galactic
static void Observed2Galactic(const CESkyCoord &in_observed, CESkyCoord *out_galactic, const CEDate &date, const CEObserver &observer)
OBSERVED -> GALACTIC coordinate conversion.
Definition: CESkyCoord.cpp:643
CESkyCoord::Ecliptic2Observed
static void Ecliptic2Observed(const CESkyCoord &in_ecliptic, CESkyCoord *out_observed, const CEDate &date, const CEObserver &observer)
ECLIPTIC -> OBSERVED coordinate conversion.
Definition: CESkyCoord.cpp:758
test_CESkyCoord::base_date_
CEDate base_date_
Definition: test_CESkyCoord.h:79
CESkyCoord::SetCoordinates
virtual void SetCoordinates(const CEAngle &xcoord, const CEAngle &ycoord, const CESkyCoordType &coord_type=CESkyCoordType::ICRS) const
Set the coordinates of this object.
Definition: CESkyCoord.cpp:1000
CEDate::SetReturnType
void SetReturnType(CEDateType return_type)
Set the return type from the overloaded 'operator double'.
Definition: CEDate.h:247
CESkyCoord::Observed2ICRS
static void Observed2ICRS(const CESkyCoord &in_observed, CESkyCoord *out_icrs, const CEDate &date, const CEObserver &observer)
OBSERVED -> ICRS coordinate conversion.
Definition: CESkyCoord.cpp:621
CESkyCoord::Observed2Ecliptic
static void Observed2Ecliptic(const CESkyCoord &in_observed, CESkyCoord *out_ecliptic, const CEDate &date, const CEObserver &observer)
OBSERVED -> ECLIPTIC coordinate conversion.
Definition: CESkyCoord.cpp:665
CESkyCoordType::ECLIPTIC
Ecliptic longitude, latitude.
CESkyCoord::Galactic2CIRS
static void Galactic2CIRS(const CESkyCoord &in_galactic, CESkyCoord *out_cirs, const CEDate &date=CEDate())
GALACTIC -> CIRS coordinate conversion.
Definition: CESkyCoord.cpp:471
CEAngle::Deg
static CEAngle Deg(const double &angle)
Return angle (radians) constructed from a degree angle.
Definition: CEAngle.cpp:317
CESkyCoord::ConvertToICRS
CESkyCoord ConvertToICRS(const CEDate &date=CEDate(), const CEObserver &observer=CEObserver())
Convert this coordinate to ICRS coordinates.
Definition: CESkyCoord.cpp:854
CESkyCoord::ConvertTo
CESkyCoord ConvertTo(const CESkyCoordType &output_coord_type, const CEDate &date=CEDate(), const CEObserver &observer=CEObserver())
Convert these coordinates to another coordinate system NOTE: If this object is not OBSERVED coordinat...
Definition: CESkyCoord.cpp:786
CESkyCoord::XCoord
virtual CEAngle XCoord(const CEDate &jd=CppEphem::julian_date_J2000()) const
Return x coordinate at given Julian date.
Definition: CESkyCoord.h:227
CESkyCoordType::OBSERVED
Azimuth, Zenith (requires additional observer information)
CESkyCoord::YCoord
virtual CEAngle YCoord(const CEDate &jd=CppEphem::julian_date_J2000()) const
Return y coordinate at given Julian date.
Definition: CESkyCoord.h:240
test_CESkyCoord::base_gal_
CESkyCoord base_gal_
Definition: test_CESkyCoord.h:76
Generated on Wed Aug 21 2019 12:14:12 for CppEphem by   doxygen 1.8.16