astral 0.3.1

High level astronomy library.
Documentation 
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

use astro;
use super::*;
use chrono::{Datelike, Timelike};
use chrono::prelude::*;
use chrono::{DateTime, NaiveDateTime};
use vsop87::vsop87c;

macro_rules! eq_frm_ecl {
    ($ecl_long: expr, $ecl_lat: expr, $oblq_eclip: expr) => {{
        (astro::coords::asc_frm_ecl($ecl_long, $ecl_lat, $oblq_eclip),
         astro::coords::dec_frm_ecl($ecl_long, $ecl_lat, $oblq_eclip))
    }};
}

#[derive(Debug)]
pub struct PlanetInfo{
	pub helio_x: f64,
	pub helio_y: f64,
	pub helio_z: f64,
	pub geo_x: f64,
	pub geo_y: f64,
	pub geo_z: f64,
	pub geo_ecl_long: f64,
	pub geo_ecl_lat: f64,
	pub geo_ecl_dist: f64,
	pub helio_ecl_long: f64,
	pub helio_ecl_lat: f64,
	pub ra: f64,
	pub dec: f64,
	pub geo_lat:f64,
	pub geo_long:f64,
	pub az:f64,
	pub alt:f64,
}

pub fn cart2eq(x:f64, y:f64, z:f64) -> (f64, f64, f64){
    let r = (x * x + y * y + z * z).sqrt();
    let mut ra = (y).atan2(x);
    ra = if ra >= 0.0 {ra} else {(2.0 * PI + ra)};
    let dec = (z / r).asin();
    return (ra, dec, r);
}

pub fn print_planet_info(julian: f64, planet_name: &str, location: Location){
	let info = get_planet_info(julian, planet_name,location);
	let (ra_h,ra_min,ra_sec) = astro::angle::hms_frm_deg(info.ra);
	println!("{:#?}", planet_name);
	println!("{:#?}", info);
	println!("Ra: {:?}:{:?}:{:?}({})",ra_h,ra_min,ra_sec,info.ra);

	// // println!("Ra(geo ecl): {:?}:{:?}:{:?}({})",ra_sun_h,ra_sun_min,ra_sun_sec,info.geo_ecl_long);
	// println!("Dec: {:?}",info.dec);
	// println!("suncalc az: {:?}",suncalc_az.to_degrees()+180.0);
	// println!("suncalc alt: {:?}",suncalc_alt.to_degrees());
	// println!("astro az: {:?}",astro_az.to_degrees()+180.0);
	// println!("Helio Eclp Lat: {:?}",info.helio_ecl_lat);
	// println!("Helio Eclp Long: {:?}",info.helio_ecl_long);
	// println!("");
	// println!("Ra: {:?}:{:?}:{:?},{:?},{:?}",info.geo_ecl_long,ra_h,ra_min,ra_sec, info.geo_ecl_lat, info.geo_ecl_dist );
}

// pub fn print_planet_info_debug(julian: f64, planet_name: &str){
// 	let info = get_planet_info(julian, planet_name);
// 	println!("{:#?}", info);
// 	let (ra_h,ra_min,ra_sec) = astro::angle::hms_frm_deg(info.geo_ecl_long);
// 	println!("({}){:?}:{:?}:{:?},{:?},{:?}",info.geo_ecl_long,ra_h,ra_min,ra_sec, info.geo_ecl_lat, info.geo_ecl_dist );
// }

pub fn get_planet_info(julian: f64, planet_name: &str, location: Location) -> PlanetInfo{
	let lat= location.lat;
	let long= location.lon;

	// let helio_coords = vsop87c::venus(julian);
	let helio_coords = match planet_name {
		"venus" => vsop87c::venus(julian),
		"earth" => vsop87c::earth(julian),
		"mars" => vsop87c::mars(julian),
		"jupiter" => vsop87c::jupiter(julian),
		"mercury" => vsop87c::mercury(julian),
		"saturn" => vsop87c::saturn(julian),
		"uranus" => vsop87c::uranus(julian),
		_ => unreachable!(),
	};
	

	let earth_coords = vsop87c::earth(julian);
    let oblq = astro::ecliptic::mn_oblq_IAU(julian);

	let (geo_x,geo_y,geo_z) = (helio_coords.x-earth_coords.x,helio_coords.y-earth_coords.y,helio_coords.z-earth_coords.z);
	let (geo_ecl_long, geo_ecl_lat, geo_ecl_dist) = cart2eq(geo_x, geo_y, geo_z);
	let (helio_ecl_long, helio_ecl_lat, helio_ecl_dist) = cart2eq(helio_coords.x, helio_coords.y, helio_coords.z);
	// let (geo_ecl_lat, geo_ecl_long, geo_ecl_dist) = cart2eq(helio_coords.x, helio_coords.y, helio_coords.z);
	let (geoeq_asc,geoeq_dec)  = eq_frm_ecl!(geo_ecl_long,geo_ecl_lat,oblq);
	
	// let astro_sidr =  astro::time::mn_sidr(julian);
	// let astro_ha = astro::coords::hr_angl_frm_observer_long(astro_sidr,long,geoeq_asc);
 //    let astro_az =  astro::coords::az_frm_eq(astro_ha,geoeq_dec,lat);

 // 	let (ra_h,ra_min,ra_sec) = astro::angle::hms_frm_deg(info.geo_ecl_long);
	// println!("{}", planet_name);

	let ra_sun = 360.0 + right_ascension(geo_ecl_long,geo_ecl_lat).to_degrees();

	let (ra_sun_h,ra_sun_min,ra_sun_sec) = astro::angle::hms_frm_deg(ra_sun);
	
    let lw  = RAD * -long;
    let phi = RAD * lat;
    let d   = julian_epoch_offset(julian);
	let hour_angle = siderealTime(d, lw) - ra_sun.to_radians();
	let mut suncalc_alt = altitude(hour_angle, phi, geoeq_dec);
    suncalc_alt = suncalc_alt + astroRefraction(suncalc_alt); // altitude correction for refraction
	let suncalc_az = azimuth(hour_angle, phi, geoeq_dec);
    return PlanetInfo{
    	helio_x: helio_coords.x,
    	helio_y: helio_coords.y,
    	helio_z: helio_coords.z,
    	geo_x: geo_x,
    	geo_y: geo_y,
    	geo_z: geo_z,
    	helio_ecl_long: helio_ecl_long.to_degrees(),
    	helio_ecl_lat: helio_ecl_lat.to_degrees(),
    	geo_ecl_long: geo_ecl_long.to_degrees(),
    	geo_ecl_lat: geo_ecl_lat.to_degrees(),
    	geo_ecl_dist: geo_ecl_dist,
    	ra:ra_sun,
    	// ra:geoeq_asc.to_degrees(),
    	dec:geoeq_dec.to_degrees(),
    	geo_lat:lat,
    	geo_long:long,
    	az:suncalc_az.to_degrees()+180.0,
    	alt:suncalc_alt.to_degrees(),

    };
	
}
pub fn moon_pos(julian: f64){
	let lat: f64 = 38.44043;
	let long: f64 = -122.71405;
	// let lw  = (-lng).to_radians();
 	// let phi = (lat).to_radians();
 	let moon_coords = moon::moon_coords(julian);

    // let d   = julian_epoch_offset(julian);
	
    let oblq = astro::ecliptic::mn_oblq_IAU(julian);
	let (geo_ecl, dist) = astro::lunar::geocent_ecl_pos(julian);
	let (geo_eq_asc,geo_eq_dec)  = eq_frm_ecl!(geo_ecl.long,geo_ecl.lat,oblq);
	
	let astro_sidr =  astro::time::mn_sidr(julian);
	let astro_ha = astro::coords::hr_angl_frm_observer_long(astro_sidr,long,geo_eq_asc);
    let astro_az =  astro::coords::az_frm_eq(astro_ha,geo_eq_dec,lat);
    // let hour_angle = siderealTime(d, lw) - geo_eq_asc;
// 
    // let azimuth = azimuth(hour_angle, phi, geo_eq_dec);
	println!("oblq ecleptic{}",oblq);
	println!("suncalc ra, dec, dist \n{},\n{},\n{}", moon_coords.ra, moon_coords.dec, moon_coords.dist);
	println!("suncalc(deg) ra, dec, \n{},\n{}", moon_coords.ra.to_degrees(), moon_coords.dec.to_degrees());
	println!("");
	println!("");
	println!("astro long,lat \n{},\n{},\n{}", geo_ecl.long, geo_ecl.lat, dist);
	println!("");
	println!("astro az {}", astro_az.to_degrees() );
	println!("astro ra, dec, dist \n{},\n{},\n{}", geo_eq_asc, geo_eq_dec, dist);
	println!("astro(deg) ra, dec,  \n{},\n{}", geo_eq_asc.to_degrees(), geo_eq_dec.to_degrees());
	// print!("az rad/deg suncalc{:?}", azimuth.to_degrees());
	// print!("{:?}", azimuth.to_degrees());
}