-
Notifications
You must be signed in to change notification settings - Fork 4
/
test_coordinate.py
executable file
·438 lines (345 loc) · 25.6 KB
/
test_coordinate.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
#!/usr/bin/env python3
import src.practical_astronomy.pa_coordinate as PC
import unittest as UT
def get_decimal_degrees(degrees,minutes,seconds):
resultDecimalDegrees = round(PC.angle_to_decimal_degrees(degrees,minutes,seconds),7)
return resultDecimalDegrees
class test_angle_decimal_degrees(UT.TestCase):
def setUp(self):
self.degrees = 182
self.minutes = 31
self.seconds = 27
def test_angle_to_decimal_degrees(self):
resultDecimalDegrees = get_decimal_degrees(self.degrees,self.minutes,self.seconds)
print(f"Angle to Decimal Degrees: [Angle] {self.degrees}d {self.minutes}m {self.seconds}s = [Decimal Degrees] {resultDecimalDegrees}")
self.assertEqual(resultDecimalDegrees,182.5241667,"Decimal Degrees")
def test_decimal_degrees_to_angle(self):
resultDecimalDegrees = get_decimal_degrees(self.degrees,self.minutes,self.seconds)
revertDegrees,revertMinutes,revertSeconds = PC.decimal_degrees_to_angle(resultDecimalDegrees)
print(f"Decimal Degrees to Angle: [Decimal Degrees] {resultDecimalDegrees} = [Angle] {revertDegrees}d {revertMinutes}m {revertSeconds}s")
self.assertEqual(revertDegrees,182,"Angle Degrees")
self.assertEqual(revertMinutes,31,"Angle Minutes")
self.assertEqual(revertSeconds,27,"Angle Seconds")
class test_right_ascension_hour_angle(UT.TestCase):
def setUp(self):
self.ra_hours = 18
self.ra_minutes = 32
self.ra_seconds = 21
self.lct_hours = 14
self.lct_minutes = 36
self.lct_seconds = 51.67
self.is_daylight_saving = False
self.zone_correction = -4
self.local_day = 22
self.local_month = 4
self.local_year = 1980
self.geographical_longitude = -64
def test_right_ascension_to_hour_angle(self):
hour_angle_hours,hour_angle_minutes,hour_angle_seconds = PC.right_ascension_to_hour_angle(self.ra_hours,self.ra_minutes,self.ra_seconds,self.lct_hours,self.lct_minutes,self.lct_seconds,self.is_daylight_saving,self.zone_correction,self.local_day,self.local_month,self.local_year,self.geographical_longitude)
print(f"Right Ascension to Hour Angle: [RA] {self.ra_hours}:{self.ra_minutes}:{self.ra_seconds} [LCT] {self.lct_hours}:{self.lct_minutes}:{self.lct_seconds} [DS] {self.is_daylight_saving} [ZC] {self.zone_correction} [LD] {self.local_month}/{self.local_day}/{self.local_year} [LON] {self.geographical_longitude} = [HA] {hour_angle_hours}:{hour_angle_minutes}:{hour_angle_seconds}")
self.assertEqual(hour_angle_hours,9,"Hour Angle Hours")
self.assertEqual(hour_angle_minutes,52,"Hour Angle Minutes")
self.assertEqual(hour_angle_seconds,23.66,"Hour Angle Seconds")
def test_hour_angle_to_right_ascension(self):
hour_angle_hours,hour_angle_minutes,hour_angle_seconds = PC.right_ascension_to_hour_angle(self.ra_hours,self.ra_minutes,self.ra_seconds,self.lct_hours,self.lct_minutes,self.lct_seconds,self.is_daylight_saving,self.zone_correction,self.local_day,self.local_month,self.local_year,self.geographical_longitude)
right_ascension_hours,right_ascension_minutes,right_ascension_seconds = PC.hour_angle_to_right_ascension(hour_angle_hours,hour_angle_minutes,hour_angle_seconds,self.lct_hours,self.lct_minutes,self.lct_seconds,self.is_daylight_saving,self.zone_correction,self.local_day,self.local_month,self.local_year,self.geographical_longitude)
print(f"Hour Angle to Right Ascension: [HA] {hour_angle_hours}:{hour_angle_minutes}:{hour_angle_seconds} [LCT] {self.lct_hours}:{self.lct_minutes}:{self.lct_seconds} [DS] {self.is_daylight_saving} [ZC] {self.zone_correction} [LD] {self.local_month}/{self.local_day}/{self.local_year} [LON] {self.geographical_longitude} = [RA] {self.ra_hours}:{self.ra_minutes}:{self.ra_seconds}")
self.assertEqual(right_ascension_hours,18,"Right Ascension Hours")
self.assertEqual(right_ascension_minutes,32,"Right Ascension Minutes")
self.assertEqual(right_ascension_seconds,21,"Right Ascension Seconds")
class test_equatorial_coordinates_horizon_coordinates(UT.TestCase):
def setUp(self):
self.hour_angle_hours = 5
self.hour_angle_minutes = 51
self.hour_angle_seconds = 44
self.declination_degrees = 23
self.declination_minutes = 13
self.declination_seconds = 10
self.geographical_latitude = 52
def test_equatorial_coordinates_to_horizon_coordinates(self):
azimuth_degrees,azimuth_minutes,azimuth_seconds,altitude_degrees,altitude_minutes,altitude_seconds = PC.equatorial_coordinates_to_horizon_coordinates(self.hour_angle_hours,self.hour_angle_minutes,self.hour_angle_seconds,self.declination_degrees,self.declination_minutes,self.declination_seconds,self.geographical_latitude)
print(f"Equatorial Coordinates to Horizon Coordinates: [HA] {self.hour_angle_hours}:{self.hour_angle_minutes}:{self.hour_angle_seconds} [DEC] {self.declination_degrees}d {self.declination_minutes}m {self.declination_seconds}s [LAT] {self.geographical_latitude} = [AZ] {azimuth_degrees}d {azimuth_minutes}m {azimuth_seconds}s [ALT] {altitude_degrees}d {altitude_minutes}m {altitude_seconds}s")
self.assertEqual(azimuth_degrees,283,"Azimuth Degrees")
self.assertEqual(azimuth_minutes,16,"Azimuth Minutes")
self.assertEqual(azimuth_seconds,15.7,"Azimuth Seconds")
self.assertEqual(altitude_degrees,19,"Altitude Degrees")
self.assertEqual(altitude_minutes,20,"Altitude Minutes")
self.assertEqual(altitude_seconds,3.64,"Altitude Seconds")
def test_horizon_coordinates_to_equatorial_coordinates(self):
azimuth_degrees,azimuth_minutes,azimuth_seconds,altitude_degrees,altitude_minutes,altitude_seconds = PC.equatorial_coordinates_to_horizon_coordinates(self.hour_angle_hours,self.hour_angle_minutes,self.hour_angle_seconds,self.declination_degrees,self.declination_minutes,self.declination_seconds,self.geographical_latitude)
hour_angle_hours,hour_angle_minutes,hour_angle_seconds,declination_degrees,declination_minutes,declination_seconds = PC.horizon_coordinates_to_equatorial_coordinates(azimuth_degrees,azimuth_minutes,azimuth_seconds,altitude_degrees,altitude_minutes,altitude_seconds,self.geographical_latitude)
print(f"Horizon Coordinates to Equatorial Coordinates: [AZ] {azimuth_degrees}d {azimuth_minutes}m {azimuth_seconds}s [ALT] {altitude_degrees}d {altitude_minutes}m {altitude_seconds}s [LAT] {self.geographical_latitude} = [HA] {hour_angle_hours}:{hour_angle_minutes}:{hour_angle_seconds} [DEC] {declination_degrees}d {declination_minutes}m {declination_seconds}s)")
self.assertEqual(hour_angle_hours,5,"Hour Angle Hours")
self.assertEqual(hour_angle_minutes,51,"Hour Angle Minutes")
self.assertEqual(hour_angle_seconds,44,"Hour Angle Seconds")
self.assertEqual(declination_degrees,23,"Declination Degrees")
self.assertEqual(declination_minutes,13,"Declination Minutes")
self.assertEqual(declination_seconds,10,"Declination Seconds")
class test_ecliptic(UT.TestCase):
def setUp(self):
self.ecliptic_longitude_degrees = 139
self.ecliptic_longitude_minutes = 41
self.ecliptic_longitude_seconds = 10
self.ecliptic_latitude_degrees = 4
self.ecliptic_latitude_minutes = 52
self.ecliptic_latitude_seconds = 31
self.greenwich_day = 6
self.greenwich_month = 7
self.greenwich_year = 2009
def test_mean_obliquity_of_the_ecliptic(self):
g_day = 6
g_month = 7
g_year = 2009
obliquity = PC.mean_obliquity_of_the_ecliptic(g_day,g_month,g_year)
obliquity = round(obliquity,8)
print(f"Mean obliquity of the ecliptic: [Greenwich Date] {g_month}/{g_day}/{g_year} = [Obliquity] {obliquity}")
self.assertEqual(obliquity,23.43805531,"Obliquity")
def test_ecliptic_coordinate_to_equatorial_coordinate(self):
ra_hours,ra_minutes,ra_seconds,dec_degrees,dec_minutes,dec_seconds = PC.ecliptic_coordinate_to_equatorial_coordinate(self.ecliptic_longitude_degrees,self.ecliptic_longitude_minutes,self.ecliptic_longitude_seconds,self.ecliptic_latitude_degrees,self.ecliptic_latitude_minutes,self.ecliptic_latitude_seconds,self.greenwich_day,self.greenwich_month,self.greenwich_year)
print(f"Ecliptic Coordinates to Equatorial Coordinates: [LON] {self.ecliptic_longitude_degrees}d {self.ecliptic_longitude_minutes}m {self.ecliptic_longitude_seconds}s [LAT] {self.ecliptic_latitude_degrees}d {self.ecliptic_latitude_minutes}m {self.ecliptic_latitude_seconds}s [GD] {self.greenwich_month}/{self.greenwich_day}/{self.greenwich_year} = [RA] {ra_hours}:{ra_minutes}:{ra_seconds} [DEC] {dec_degrees}d {dec_minutes}m {dec_seconds}s")
self.assertEqual(ra_hours,9,"RA Hours")
self.assertEqual(ra_minutes,34,"RA Minutes")
self.assertEqual(ra_seconds,53.4,"RA Seconds")
self.assertEqual(dec_degrees,19,"Dec Degrees")
self.assertEqual(dec_minutes,32,"Dec Minutes")
self.assertEqual(dec_seconds,8.52,"Dec Seconds")
def test_equatorial_coordinate_to_ecliptic_coordinate(self):
ra_hours,ra_minutes,ra_seconds,dec_degrees,dec_minutes,dec_seconds = PC.ecliptic_coordinate_to_equatorial_coordinate(self.ecliptic_longitude_degrees,self.ecliptic_longitude_minutes,self.ecliptic_longitude_seconds,self.ecliptic_latitude_degrees,self.ecliptic_latitude_minutes,self.ecliptic_latitude_seconds,self.greenwich_day,self.greenwich_month,self.greenwich_year)
ecl_long_deg,ecl_long_min,ecl_long_sec,ecl_lat_deg,ecl_lat_min,ecl_lat_sec = PC.equatorial_coordinate_to_ecliptic_coordinate(ra_hours,ra_minutes,ra_seconds,dec_degrees,dec_minutes,dec_seconds,self.greenwich_day,self.greenwich_month,self.greenwich_year)
print(f"Equatorial Coordinates to Ecliptic Coordinates: [RA] {ra_hours}:{ra_minutes}:{ra_seconds} [DEC] {dec_degrees}d {dec_minutes}m {dec_seconds}s [GD] {self.greenwich_month}/{self.greenwich_day}/{self.greenwich_year} = [LON] {ecl_long_deg}d {ecl_long_min}m {ecl_long_sec}s [LAT] {ecl_lat_deg}d {ecl_lat_min}m {ecl_lat_sec}s")
self.assertEqual(ecl_long_deg,139,"Ecliptic Longitude Degrees")
self.assertEqual(ecl_long_min,41,"Ecliptic Longitude Minutes")
self.assertEqual(ecl_long_sec,9.97,"Ecliptic Longitude Seconds")
self.assertEqual(ecl_lat_deg,4,"Ecliptic Latitude Degrees")
self.assertEqual(ecl_lat_min,52,"Ecliptic Latitude Minutes")
self.assertEqual(ecl_lat_sec,30.99,"Ecliptic Latitude Seconds")
class test_galactic(UT.TestCase):
def setUp(self):
self.ra_hours = 10
self.ra_minutes = 21
self.ra_seconds = 0
self.dec_degrees = 10
self.dec_minutes = 3
self.dec_seconds = 11
def test_equatorial_coordinate_to_galactic_coordinate(self):
gal_long_deg,gal_long_min,gal_long_sec,gal_lat_deg,gal_lat_min,gal_lat_sec = PC.equatorial_coordinate_to_galactic_coordinate(self.ra_hours,self.ra_minutes,self.ra_seconds,self.dec_degrees,self.dec_minutes,self.dec_seconds)
print(f"Equatorial Coordinates to Galactic Coordinates: [EQ] [RA] {self.ra_hours}:{self.ra_minutes}:{self.ra_seconds} [DEC] {self.dec_degrees}d {self.dec_minutes}m {self.dec_seconds}s = [GAL] [LON] {gal_long_deg}d {gal_long_min}m {gal_long_sec}s [LAT] {gal_lat_deg}d {gal_lat_min}m {gal_lat_sec}s")
self.assertEqual(gal_long_deg,232,"Galactic Longitude Degrees")
self.assertEqual(gal_long_min,14,"Galactic Longitude Minutes")
self.assertEqual(gal_long_sec,52.38,"Galactic Longitude Seconds")
self.assertEqual(gal_lat_deg,51,"Galactic Latitude Degrees")
self.assertEqual(gal_lat_min,7,"Galactic Latitude Minutes")
self.assertEqual(gal_lat_sec,20.16,"Galactic Latitude Seconds")
def test_galactic_coordinate_to_equatorial_coordinate(self):
gal_long_deg,gal_long_min,gal_long_sec,gal_lat_deg,gal_lat_min,gal_lat_sec = PC.equatorial_coordinate_to_galactic_coordinate(self.ra_hours,self.ra_minutes,self.ra_seconds,self.dec_degrees,self.dec_minutes,self.dec_seconds)
ra_hours,ra_minutes,ra_seconds,dec_degrees,dec_minutes,dec_seconds = PC.galactic_coordinate_to_equatorial_coordinate(gal_long_deg,gal_long_min,gal_long_sec,gal_lat_deg,gal_lat_min,gal_lat_sec)
print(f"Galactic Coordinates to Equatorial Coordinates: [GAL] [LON] {gal_long_deg}d {gal_long_min}m {gal_long_sec}s [LAT] {gal_lat_deg}d {gal_lat_min}m {gal_lat_sec}s = [EQ] [RA] {ra_hours}:{ra_minutes}:{ra_seconds} [DEC] {dec_degrees}d {dec_minutes}m {dec_seconds}s")
self.assertEqual(ra_hours,10,"Right Ascension Hours")
self.assertEqual(ra_minutes,21,"Right Ascension Minutes")
self.assertEqual(ra_seconds,0,"Right Ascension Seconds")
self.assertEqual(dec_degrees,10,"Declination Degrees")
self.assertEqual(dec_minutes,3,"Declination Degrees")
self.assertEqual(dec_seconds,11,"Declination Seconds")
class test_object_angles(UT.TestCase):
def setUp(self):
self.ra_long_1_hour_deg = 5
self.ra_long_1_min = 13
self.ra_long_1_sec = 31.7
self.dec_lat_1_deg = -8
self.dec_lat_1_min = 13
self.dec_lat_1_sec = 30
self.ra_long_2_hour_deg = 6
self.ra_long_2_min = 44
self.ra_long_2_sec = 13.4
self.dec_lat_2_deg = -16
self.dec_lat_2_min = 41
self.dec_lat_2_sec = 11
self.hour_or_degree = "H"
def test_angle_between_two_objects(self):
angle_deg,angle_min,angle_sec = PC.angle_between_two_objects(self.ra_long_1_hour_deg,self.ra_long_1_min,self.ra_long_1_sec,self.dec_lat_1_deg,self.dec_lat_1_min,self.dec_lat_1_sec,self.ra_long_2_hour_deg,self.ra_long_2_min,self.ra_long_2_sec,self.dec_lat_2_deg,self.dec_lat_2_min,self.dec_lat_2_sec,self.hour_or_degree)
print (f"Angle between two objects: [OBJ 1] [RA LON] {self.ra_long_1_hour_deg}h/d {self.ra_long_1_min}m {self.ra_long_1_sec}s [DEC LAT] {self.dec_lat_1_deg}d {self.dec_lat_1_min}m {self.dec_lat_1_sec}s [OBJ 2] [RA LON] {self.ra_long_2_hour_deg}h/d {self.ra_long_2_min}m {self.ra_long_2_sec}s [DEC LAT] {self.dec_lat_2_deg}d {self.dec_lat_2_min}m {self.dec_lat_2_sec}s [TYPE] {self.hour_or_degree} = [ANGLE] {angle_deg}d {angle_min}m {angle_sec}s")
self.assertEqual(angle_deg,23,"Angle Degrees")
self.assertEqual(angle_min,40,"Angle Minutes")
self.assertEqual(angle_sec,25.86,"Angle Seconds")
class test_rise_set(UT.TestCase):
def setUp(self):
self.ra_hours = 23
self.ra_minutes = 39
self.ra_seconds = 20
self.dec_deg = 21
self.dec_min = 42
self.dec_sec = 0
self.gw_date_day = 24
self.gw_date_month = 8
self.gw_date_year = 2010
self.geog_long_deg = 64
self.geog_lat_deg = 30
self.vert_shift_deg = 0.5667
def test_rising_and_setting(self):
rise_set_status,ut_rise_hour,ut_rise_min,ut_set_hour,ut_set_min,az_rise,az_set = PC.rising_and_setting(self.ra_hours,self.ra_minutes,self.ra_seconds,self.dec_deg,self.dec_min,self.dec_sec,self.gw_date_day,self.gw_date_month,self.gw_date_year,self.geog_long_deg,self.geog_lat_deg,self.vert_shift_deg)
print(f"Rising and setting times: [RA] {self.ra_hours}:{self.ra_minutes}:{self.ra_seconds} [DEC] {self.dec_deg}d {self.dec_min}m {self.dec_sec}s [GWD] {self.gw_date_month}/{self.gw_date_day}/{self.gw_date_year} [LON] {self.geog_long_deg} [LAT] {self.geog_lat_deg} [VS] {self.vert_shift_deg} = [STATUS] {rise_set_status} [UT] [RISE] {ut_rise_hour}:{ut_rise_min} [SET] {ut_set_hour}:{ut_set_min} [AZ] [RISE] {az_rise} [SET] {az_set}")
self.assertEqual(rise_set_status,"OK","Rise/Set Status")
self.assertEqual(ut_rise_hour,14,"UT Rise Hour")
self.assertEqual(ut_rise_min,16,"UT Rise Minute")
self.assertEqual(ut_set_hour,4,"UT Set Hour")
self.assertEqual(ut_set_min,10,"UT Set Minute")
self.assertEqual(az_rise,64.36,"AZ Rise")
self.assertEqual(az_set,295.64,"AZ Set")
class test_precession(UT.TestCase):
def setUp(self):
self.ra_hour = 9
self.ra_minutes = 10
self.ra_seconds = 43
self.dec_deg = 14
self.dec_minutes = 23
self.dec_seconds = 25
self.epoch1_day = 0.923
self.epoch1_month = 1
self.epoch1_year = 1950
self.epoch2_day = 1
self.epoch2_month = 6
self.epoch2_year = 1979
def test_precession(self):
corrected_ra_hour,corrected_ra_minutes,corrected_ra_seconds,corrected_dec_deg,corrected_dec_minutes,corrected_dec_seconds = PC.correct_for_precession(self.ra_hour,self.ra_minutes,self.ra_seconds,self.dec_deg,self.dec_minutes,self.dec_seconds,self.epoch1_day,self.epoch1_month,self.epoch1_year,self.epoch2_day,self.epoch2_month,self.epoch2_year)
print(f"Precession: [RA] {self.ra_hour}:{self.ra_minutes}:{self.ra_seconds} [DEC] {self.dec_deg}d {self.dec_minutes}m {self.dec_seconds}s [EPOCH 1] {self.epoch1_month}/{self.epoch1_day}/{self.epoch1_year} [EPOCH 2] {self.epoch2_month}/{self.epoch2_day}/{self.epoch2_year} = [Corrected] [RA] {corrected_ra_hour}:{corrected_ra_minutes}:{corrected_ra_seconds} [DEC] {corrected_dec_deg}d {corrected_dec_minutes}m {corrected_dec_seconds}s")
self.assertEqual(corrected_ra_hour,9,"Corrected Right Ascension Hour")
self.assertEqual(corrected_ra_minutes,12,"Corrected Right Ascension Minutes")
self.assertEqual(corrected_ra_seconds,20.18,"Corrected Right Ascension Seconds")
self.assertEqual(corrected_dec_deg,14,"Corrected Declination Hour")
self.assertEqual(corrected_dec_minutes,16,"Corrected Declination Minutes")
self.assertEqual(corrected_dec_seconds,9.12,"Corrected Declination Seconds")
class test_nutation(UT.TestCase):
def setUp(self):
self.greenwich_day = 1
self.greenwich_month = 9
self.greenwich_year = 1988
def test_nutation(self):
nut_in_long_deg,nut_in_obl_deg = PC.nutation_in_ecliptic_longitude_and_obliquity(self.greenwich_day,self.greenwich_month,self.greenwich_year)
nut_in_long_deg = round(nut_in_long_deg,9)
nut_in_obl_deg = round(nut_in_obl_deg,7)
print(f"Nutation: [GWDATE] {self.greenwich_month}/{self.greenwich_day}/{self.greenwich_year} = [NUTATION] [LON] {nut_in_long_deg} [OBL] {nut_in_obl_deg}")
self.assertEqual(nut_in_long_deg,0.001525808,"Nutation in Longitude (degrees)")
self.assertEqual(nut_in_obl_deg,0.0025671,"Nutation in Obliquity (degrees)")
class test_aberration(UT.TestCase):
def setUp(self):
self.ut_hour = 0
self.ut_minutes = 0
self.ut_seconds = 0
self.gw_day = 8
self.gw_month = 9
self.gw_year = 1988
self.true_ecl_long_deg = 352
self.true_ecl_long_min = 37
self.true_ecl_long_sec = 10.1
self.true_ecl_lat_deg = -1
self.true_ecl_lat_min = 32
self.true_ecl_lat_sec = 56.4
def test_correct_for_aberration(self):
apparent_ecl_long_deg,apparent_ecl_long_min,apparent_ecl_long_sec,apparent_ecl_lat_deg,apparent_ecl_lat_min,apparent_ecl_lat_sec = PC.correct_for_aberration(self.ut_hour,self.ut_minutes,self.ut_seconds,self.gw_day,self.gw_month,self.gw_year,self.true_ecl_long_deg,self.true_ecl_long_min,self.true_ecl_long_sec,self.true_ecl_lat_deg,self.true_ecl_lat_min,self.true_ecl_lat_sec)
print(f"Aberration: [UT] {self.ut_hour}:{self.ut_minutes}:{self.ut_seconds} [GWD] {self.gw_month}/{self.gw_day}/{self.gw_year} [ECL] [LON] {self.true_ecl_long_deg}d {self.true_ecl_long_min}m {self.true_ecl_long_sec}s [LAT] {self.true_ecl_lat_deg}d {self.true_ecl_lat_min}m {self.true_ecl_lat_sec}s = [Apparent ECL] [LON] {apparent_ecl_long_deg}d {apparent_ecl_long_min}m {apparent_ecl_long_sec}s [LAT] {apparent_ecl_lat_deg}d {apparent_ecl_lat_min}m {apparent_ecl_lat_sec}s")
self.assertEqual(apparent_ecl_long_deg,352,"Apparent Ecliptic Longitude Degrees")
self.assertEqual(apparent_ecl_long_min,37,"Apparent Ecliptic Longitude Minutes")
self.assertEqual(apparent_ecl_long_sec,30.45,"Apparent Ecliptic Longitude Seconds")
self.assertEqual(apparent_ecl_lat_deg,-1,"Apparent Ecliptic Latitude Degrees")
self.assertEqual(apparent_ecl_lat_min,32,"Apparent Ecliptic Latitude Minutes")
self.assertEqual(apparent_ecl_lat_sec,56.33,"Apparent Ecliptic Latitude Seconds")
class test_atmospheric_refraction(UT.TestCase):
def setUp(self):
self.true_ra_hour = 23
self.true_ra_min = 14
self.true_ra_sec = 0
self.true_dec_deg = 40
self.true_dec_min = 10
self.true_dec_sec = 0
self.coordinate_type = "TRUE"
self.geog_long_deg = 0.17
self.geog_lat_deg = 51.2036110
self.daylight_saving_hours = 0
self.timezone_hours = 0
self.lcd_day = 23
self.lcd_month = 3
self.lcd_year = 1987
self.lct_hour = 1
self.lct_min = 1
self.lct_sec = 24
self.atmospheric_pressure_mbar = 1012
self.atmospheric_temperature_celsius = 21.7
def test_atmospheric_refraction(self):
corrected_ra_hour,corrected_ra_min,corrected_ra_sec,corrected_dec_deg,corrected_dec_min,corrected_dec_sec = PC.atmospheric_refraction(self.true_ra_hour,self.true_ra_min,self.true_ra_sec,self.true_dec_deg,self.true_dec_min,self.true_dec_sec,self.coordinate_type,self.geog_long_deg,self.geog_lat_deg,self.daylight_saving_hours,self.timezone_hours,self.lcd_day,self.lcd_month,self.lcd_year,self.lct_hour,self.lct_min,self.lct_sec,self.atmospheric_pressure_mbar,self.atmospheric_temperature_celsius)
print(f"Refraction: [RA] {self.true_ra_hour}:{self.true_ra_min}:{self.true_ra_sec} [DEC] {self.true_dec_deg}d {self.true_dec_min}m {self.true_dec_sec}s [COORD TYPE] {self.coordinate_type} [GEOG LON/LAT] {self.geog_long_deg}d/{self.geog_lat_deg}d [DS HOURS] {self.daylight_saving_hours} [TZ HOURS] {self.timezone_hours} [LCD] {self.lcd_month}/{self.lcd_day}/{self.lcd_year} [LCT] {self.lct_hour}:{self.lct_min}:{self.lct_sec} [ATM] [PRESS MBR] {self.atmospheric_pressure_mbar} [TEMP C] {self.atmospheric_temperature_celsius} = [CORRECTED] [RA] {corrected_ra_hour}:{corrected_ra_min}:{corrected_ra_sec} [DEC] {corrected_dec_deg}d {corrected_dec_min}m {corrected_dec_sec}s")
self.assertEqual(corrected_ra_hour,23,"Corrected RA Hours")
self.assertEqual(corrected_ra_min,13,"Corrected RA Minutes")
self.assertEqual(corrected_ra_sec,44.74,"Corrected RA Seconds")
self.assertEqual(corrected_dec_deg,40,"Corrected Declination Degrees")
self.assertEqual(corrected_dec_min,19,"Corrected Declination Minutes")
self.assertEqual(corrected_dec_sec,45.76,"Corrected Declination Seconds")
class test_geocentric_parallax(UT.TestCase):
def setUp(self):
self.ra_hour = 22
self.ra_min = 35
self.ra_sec = 19
self.dec_deg = -7
self.dec_min = 41
self.dec_sec = 13
self.coordinate_type = "TRUE"
self.equatorial_hor_parallax_deg = 1.019167
self.geog_long_deg = -100
self.geog_lat_deg = 50
self.height_m = 60
self.daylight_saving = 0
self.timezone_hours = -6
self.lcd_day = 26
self.lcd_month = 2
self.lcd_year = 1979
self.lct_hour = 10
self.lct_min = 45
self.lct_sec = 0
def test_corrections_for_geocentric_parallax(self):
corrected_ra_hour,corrected_ra_min,corrected_ra_sec,corrected_dec_deg,corrected_dec_min,corrected_dec_sec = PC.corrections_for_geocentric_parallax(self.ra_hour,self.ra_min,self.ra_sec,self.dec_deg,self.dec_min,self.dec_sec,self.coordinate_type,self.equatorial_hor_parallax_deg,self.geog_long_deg,self.geog_lat_deg,self.height_m,self.daylight_saving,self.timezone_hours,self.lcd_day,self.lcd_month,self.lcd_year,self.lct_hour,self.lct_min,self.lct_sec)
print(f"Geocentric parallax: [RA] {self.ra_hour}:{self.ra_min}:{self.ra_sec} [DEC] {self.dec_deg}d {self.dec_min}m {self.dec_sec}s [COORD TYPE] {self.coordinate_type} [EQ HOR PARA DEG] {self.equatorial_hor_parallax_deg} [GEOG] [LON] {self.geog_long_deg} [LAT] {self.geog_lat_deg} [HEIGHT] {self.height_m} [DS] {self.daylight_saving} [TZ] {self.timezone_hours} [LCD] {self.lcd_month}/{self.lcd_day}/{self.lcd_year} [LCT] {self.lct_hour}:{self.lct_min}:{self.lct_sec} = [CORRECTED] [RA] {corrected_ra_hour}:{corrected_ra_min}:{corrected_ra_sec} [DEC] {corrected_dec_deg}d {corrected_dec_min}m {corrected_dec_sec}s")
self.assertEqual(corrected_ra_hour,22,"Corrected RA Hours")
self.assertEqual(corrected_ra_min,36,"Corrected RA Minutes")
self.assertEqual(corrected_ra_sec,43.22,"Corrected RA Seconds")
self.assertEqual(corrected_dec_deg,-8,"Corrected Declination Degrees")
self.assertEqual(corrected_dec_min,32,"Corrected Declination Minutes")
self.assertEqual(corrected_dec_sec,17.4,"Corrected Declination Seconds")
class test_heliographic_coordinates(UT.TestCase):
def setUp(self):
self.helio_position_angle_deg = 220
self.helio_displacement_arcmin = 10.5
self.gwdate_day = 1
self.gwdate_month = 5
self.gwdate_year = 1988
def test_heliographic_coordinates(self):
helio_long_deg,helio_lat_deg = PC.heliographic_coordinates(self.helio_position_angle_deg,self.helio_displacement_arcmin,self.gwdate_day,self.gwdate_month,self.gwdate_year)
print(f"Heliographic coordinates: [helio] [pos angle] {self.helio_position_angle_deg} [displ arcmin] {self.helio_displacement_arcmin}, [GW Date] {self.gwdate_month}/{self.gwdate_day}/{self.gwdate_year} = [helio] [lon] {helio_long_deg}d [lat] {helio_lat_deg}d")
self.assertEqual(helio_long_deg,142.59,"Heliographic Longitude - degrees")
self.assertEqual(helio_lat_deg,-19.94,"Heliographic Latitude - degrees")
class test_carrington_rotation_number(UT.TestCase):
def setUp(self):
self.gwdate_day = 27
self.gwdate_month = 1
self.gwdate_year = 1975
def test_carrington_rotation_number(self):
crn = PC.carrington_rotation_number(self.gwdate_day,self.gwdate_month,self.gwdate_year)
print(f"Carrington Rotation Number: [GW Date] {self.gwdate_month}/{self.gwdate_day}/{self.gwdate_year} = [CRN] {crn}")
self.assertEqual(crn,1624,"Carrington Rotation Number")
class test_selenographic_coordinates(UT.TestCase):
def setUp(self):
self.gwdate_day = 1
self.gwdate_month = 5
self.gwdate_year = 1988
def test_selenographic_coordinates_1(self):
sub_earth_longitude,sub_earth_latitude,position_angle_of_pole = PC.selenographic_coordinates_1(self.gwdate_day,self.gwdate_month,self.gwdate_year)
print(f"Selenographic Coordinates 1: [GW Date] {self.gwdate_month}/{self.gwdate_day}/{self.gwdate_year} = [Sub Earth] [LON] {sub_earth_longitude} [LAT] {sub_earth_latitude}, [POS ANGLE OF POLE] {position_angle_of_pole}")
self.assertEqual(sub_earth_longitude,-4.88,"Sub-Earth Longitude")
self.assertEqual(sub_earth_latitude,4.04,"Sub-Earth Latitude")
self.assertEqual(position_angle_of_pole,19.78,"Position Angle of Pole")
def test_selenographic_coordinates_2(self):
sub_solar_longitude,sub_solar_colongitude,sub_solar_latitude = PC.selenographic_coordinates_2(self.gwdate_day,self.gwdate_month,self.gwdate_year)
print(f"Selenographic Coordinates 2: [GW Date] {self.gwdate_month}/{self.gwdate_day}/{self.gwdate_year} = [Sub Solar] [LON] {sub_solar_longitude} [COLN] {sub_solar_colongitude} [LAT] {sub_solar_latitude}")
self.assertEqual(sub_solar_longitude,6.81,"Sub-Solar Longitude")
self.assertEqual(sub_solar_colongitude,83.19,"Sub-Solar Colongitude")
self.assertEqual(sub_solar_latitude,1.19,"Sub-Solar Latitude")
if __name__ == '__main__':
UT.main()