Merge branch 'dev'

Author: THeK3nger

.gitignore

@@ -1,4 +1,7 @@
 dist/app.js
 node_modules
 \.vscode/
-\.idea
+\.idea
+
+# Ignore minimized output for now
+dist/app.min.js

CHANGELOG.md

@@ -1,6 +1,13 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+
+## [0.4.0] - 2017-09-20
+
+### Added 
+
+ - **New! Lunar Phases** Now the calendar generate lunar phases for the principal satellite!
+
 ## [0.3.0] - 2017-08-21
 
 ### Changed

README.md

@@ -30,7 +30,7 @@ I will address the problem with such exotic planets in the future.
 
 ## Feature Backlog
 
-- [ ] Lunar Phases
+- [x] Lunar Phases
 - [x] Seasons
 - [ ] Astrological Features (zodiac-like)
 - [ ] Multi-Year Cycles (e.g., like in the Chinese Calendar)

dist/css/styles.css

@@ -41,3 +41,12 @@ div#generator > div {
 	padding: 10px;
 }
 
+/* Calendexample */
+table tbody tr td div.calenday {
+	width: 40px;
+}
+
+table  div.calenday span {
+	display: inline-block;
+	width: 20px;
+}

package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.0",
+  "version": "0.4.0",
   "author": {
     "email": "thek3nger@gmail.com",
     "name": "Davide Aversa"
@@ -29,7 +29,7 @@
     "react": "^15.6.1",
     "react-dom": "^15.6.1",
     "ts-node": "^3.0.4",
-    "typescript": "^2.3.4"
+    "typescript": "^2.5.2"
   },
   "devDependencies": {
     "ts-loader": "^2.3.2",

src/app.ts

@@ -2,7 +2,7 @@ import * as log from 'loglevel'
 
 import * as GeneratorUI from "./interface"
 
-const VERSION = "v0.3.0";
+const VERSION = "v0.4.0";
 
 export function init() {
     log.setLevel("debug");

src/calendgen.ts

@@ -1,47 +1,38 @@
-import * as Physic from "./physic"
 import * as Newton from "./newton"
-
-/**
- * `OrbitalBody` defines data representing information about an orbiting body of the solar system.
- * 
- * This can be referred to a planet orbiting around a star, or a satellite orbiting a planet.
- */
-interface OrbitalBody {
-    mass: number                /// The orbital body mass in Kg.
-    rotation: number            /// The rotation period in seconds.
-    orbit: OrbitalParameters    /// The orbital parameters.
-    axial_tilt?: number         /// Axial tilt for the body rotation wrt the orbital plane.
-}
+import { OrbitalBody, orbital_period, secondsToDays, eccentricity } from "./physic";
 
 /**
  * `SystemParameters` describes the parameters for a planet in star system.
  * 
  * It includes the star mass, and the planet and satellites orbital information.
  */
 interface SystemParameters {
-    planet: OrbitalBody             /// The planet.
-    star_mass: number               /// The orbiting star mass in Kg.
-    satellites: Array<OrbitalBody>  /// A list of satellites.
+    readonly planet: OrbitalBody                        /// The planet.
+    readonly satellites: ReadonlyArray<OrbitalBody>     /// A list of satellites.
 }
 
 /**
- * Define the orbital parameters for an orbital body.
+ * The output data for the actual calendar.
  */
-interface OrbitalParameters {
-    periapsis: number       /// The celestial body orbit periapsis in meters.
-    apoapsis: number        /// The celestial body orbit apopasis in meters.
-    inclination?: number    /// The inclination of the orbital plane respect to the system reference plane.
+interface CalendarParameters {
+    readonly days_per_year: number           /// Number of days in a year.
+    readonly moon_day_period: number         /// Number of days in a principal moon revolution.
+    readonly months_per_year: number         /// How many moon revolutions there are in a year.
+    readonly base_days_per_month: number     /// Number of days in a principal moon revolution (floored). // TODO: This is probably superfluous.
+    readonly leap: LeapYearData              /// Information about leap days.
 }
 
 /**
- * The output data for the actual calendar.
+ * Store information on the lunar phases of a single moon.
+ * 
+ * All time correspond to the FIRST occurrence from time zero.
+ * Values are expressed in seconds.
  */
-interface CalendarParameters {
-    days_per_year: number           /// Number of days in a year.
-    moon_day_period: number         /// Number of days in a principal moon revolution.
-    months_per_year: number         /// How many moon revolutions there are in a year.
-    base_days_per_month: number     /// Number of days in a principal moon revolution (floored). // TODO: This is probably superfluous.
-    leap: LeapYearData              /// Information about leap days.
+export interface LunarPhases {
+    readonly full_moon: number
+    readonly new_moon: number
+    readonly third_quart: number
+    readonly first_quart: number
 }
 
 /**
@@ -53,25 +44,26 @@ interface LeapYearData { leap_total_days: number, leap_period: number }
  * Output of the calendar generator. // TODO: Probably superfluous.
  */
 export interface CalendarGeneratorOutput {
-    calendar_parameters: CalendarParameters
+    readonly calendar_parameters: CalendarParameters
 }
 
 /**
  * Computed astronomical season-related events.
  */
 export interface SeasonsParameters {
-    spring_equinox: number, /// Time in seconds for the first equinox.
-    summer_solstice: number,
-    autumn_equinox: number,
-    winter_solstice: number
+    readonly spring_equinox: number, /// Time in seconds for the first equinox.
+    readonly summer_solstice: number,
+    readonly autumn_equinox: number,
+    readonly winter_solstice: number
 }
 
 /**
  * Encapsulate the global generator output.
  */
 export interface GeneratorOutput {
-    calendar: CalendarGeneratorOutput,
-    seasons: SeasonsParameters
+    readonly calendar: CalendarGeneratorOutput,
+    readonly seasons: SeasonsParameters,
+    readonly lunar_phases: LunarPhases
 }
 
 /**
@@ -80,31 +72,25 @@ export interface GeneratorOutput {
  * @returns An instance of a generated calendar for the planet.
  */
 export function generateCalendarFromOrbit(system_data: SystemParameters): GeneratorOutput {
-    const planet_apoapsis = system_data.planet.orbit.apoapsis;
-    const planet_periapsis = system_data.planet.orbit.periapsis;
-    const planet_axis_major = (planet_apoapsis + planet_periapsis) / 2;
-    const planet_mass = system_data.planet.mass;
     const planet_day_duration = system_data.planet.rotation;
-    const eccentricity = (planet_apoapsis - planet_periapsis) / (planet_apoapsis + planet_periapsis);
 
     // Compute planet orbital period.
-    let planet_year = Physic.orbital_period(system_data.star_mass, planet_axis_major, planet_mass);
+    let planet_year = orbital_period(system_data.planet);
 
     let moon_periods: Array<number> = [];
     // Compute moon periods.
     for (let moon of system_data.satellites) {
-        let moon_axis_major = (moon.orbit.periapsis + moon.orbit.apoapsis) / 2;
-        moon_periods.push(Physic.orbital_period(planet_mass, moon_axis_major, moon.mass));
+        moon_periods.push(orbital_period(moon));
     }
 
-    const seasons = computeSeasons(0, 6, 4, eccentricity, planet_year);
+    const seasons = compute_seasons(system_data.planet, 6, 4);
     const calendar = generateCalendarFromPeriod(planet_year, moon_periods, planet_day_duration);
-    //instantiateCalendar(calendar, 7, seasons);
-    return { calendar, seasons };
+    const lunar_phases = computeLunarPhases(system_data.planet, system_data.satellites[0], calendar);
+    return { calendar, seasons, lunar_phases };
 }
 
 function generateCalendarFromPeriod(planet_period: number, moon_periods: Array<number>, planet_day_duration: number = 86400): CalendarGeneratorOutput {
-    let year_days_full = Physic.secondsToDays(planet_period, planet_day_duration);
+    let year_days_full = secondsToDays(planet_period, planet_day_duration);
     let year_days = Math.floor(year_days_full);
 
     // Compute Leap Years.
@@ -121,10 +107,10 @@ function generateCalendarFromPeriod(planet_period: number, moon_periods: Array<n
 
     if (moon_periods.length > 0) {
         // TODO: For now, there is only one moon. In the future we may support multiple moons.
-        let moon_day_period = Physic.secondsToDays(moon_periods[0], planet_day_duration);
-        let month_days = Math.floor(Physic.secondsToDays(moon_periods[0], planet_day_duration));
+        let moon_day_period = secondsToDays(moon_periods[0], planet_day_duration);
+        let month_days = Math.floor(secondsToDays(moon_periods[0], planet_day_duration));
         let lunar_months = Math.floor(year_days / month_days);
-        let days_remainder = year_days - lunar_months * month_days;
+        // let days_remainder = year_days - lunar_months * month_days;
 
         output_parameters = {
             days_per_year: year_days,
@@ -204,20 +190,54 @@ function thirdOrderConvergent(cf: Array<number>): [number, number] {
 }
 
 // SEASONS
-
-export function computeSeasons(axial_tilt: number, A: number, B: number, eccentricity: number, period: number): SeasonsParameters {
+export function compute_seasons(body: OrbitalBody, A: number, B: number) : SeasonsParameters {
+    const e = eccentricity(body.orbit);
+    const period = orbital_period(body);
     let E = Newton.NewtonRoot(
-        (x) => (B * (Math.cos(x) - eccentricity) - A * (Math.sqrt(1 - eccentricity * eccentricity) * Math.sin(x))),
-        (x) => -(B * Math.sin(x) + A * (Math.sqrt(1 - eccentricity * eccentricity)) * Math.cos(x)),
+        (x) => (B * (Math.cos(x) - e) - A * (Math.sqrt(1 - e * e) * Math.sin(x))),
+        (x) => -(B * Math.sin(x) + A * (Math.sqrt(1 - e * e)) * Math.cos(x)),
         1, 0.01);
     let E2 = E + Math.PI / 2;
     let E3 = E + Math.PI;
     let E4 = E + (3 / 2) * Math.PI;
     return {
-        spring_equinox: (period / (2 * Math.PI)) * (E - eccentricity * Math.sin(E)),
-        summer_solstice: (period / (2 * Math.PI)) * (E2 - eccentricity * Math.sin(E2)),
-        autumn_equinox: (period / (2 * Math.PI)) * (E3 - eccentricity * Math.sin(E3)),
-        winter_solstice: (period / (2 * Math.PI)) * (E4 - eccentricity * Math.sin(E4))
+        spring_equinox: (period / (2 * Math.PI)) * (E - e * Math.sin(E)),
+        summer_solstice: (period / (2 * Math.PI)) * (E2 - e * Math.sin(E2)),
+        autumn_equinox: (period / (2 * Math.PI)) * (E3 - e * Math.sin(E3)),
+        winter_solstice: (period / (2 * Math.PI)) * (E4 - e * Math.sin(E4))
     };
 
+}
+
+// LUNAR PHASES
+export function computeLunarPhases(planet: OrbitalBody, moon: OrbitalBody, calendar: CalendarGeneratorOutput): LunarPhases {
+    const moon_period = calendar.calendar_parameters.moon_day_period;
+    // Compute first full moon.
+    // Full moons occurs when the moon is aligned with the SUN-PLANET axis.
+    // This is equivalent of saying that the full moon occurs when the  true anomaly of the moon orbit is 0.
+    // FM = kP (where P is the orbital period and k is an integer)
+    const full_moon_time = 0;
+    // Compute first new moon.
+    // This occurs when the moon is in opposition to the SUN-PLANET axis.
+    // This is equivalent of saying that the new moon occurs when the true anomaly of the moon orbit is PI.
+    // NM = P/2 + kP
+    // (Note that Mean Anomaly, Eccentric Anomaly and True Anomaly are equivalent on 0 and PI)
+    const new_moon_time = Math.floor(moon_period / 2);
+    // Compute the third quart.
+    // this occur when MOON-PLANET axis is perpendicular to the SUN-PLANET orbit.
+    // This is equivalent of saying that the third quarter occurs when the true anomaly of the moon orbit is PI/2.
+    // In this case MA, EA, and TA **do not match**. The formula is more complex.
+    const moon_apoapsis = moon.orbit.apoapsis;
+    const moon_periapsis = moon.orbit.periapsis;
+    const e = (moon_apoapsis - moon_periapsis) / (moon_apoapsis + moon_periapsis);
+    const gamma = Math.sqrt((1 + e) / (1 - e));
+    const third_quart_time = Math.floor(moon_period * (1 / Math.PI) * Math.atan(1 / gamma) - e * ((2 * gamma) / (gamma * gamma) + 1));
+    // Compute the first quart.
+    // this occur when MOON-PLANET axis is anti-perpendicular to the SUN-PLANET orbit.
+    // This is equivalent of saying that the third quarter occurs when the true anomaly of the moon orbit is -PI/2.
+    // In this case MA, EA, and TA **do not match**. The formula is more complex.
+    const first_quart_time = Math.floor(-third_quart_time + moon_period); // TODO: Check this.
+
+    return { full_moon: full_moon_time, new_moon: new_moon_time, first_quart: first_quart_time, third_quart: third_quart_time };
+
 }