practical_astronomy/source/test_coordinate.py

#!/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()