starfall 0.1.0

Astronomical sciences, from the galaxy to the moon, for my Hornvale project.
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

use rand::prelude::*;
use std::default::Default;

use crate::astronomy::distant_binary_star::constants::*;
use crate::astronomy::distant_binary_star::error::Error;
use crate::astronomy::distant_binary_star::DistantBinaryStar;
use crate::astronomy::planetary_system::constraints::Constraints as PlanetarySystemConstraints;

/// Constraints for creating a main-sequence star subsystem.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Constraints {
  /// The minimum average separation, in AU.
  pub minimum_average_separation: Option<f64>,
  /// The maximum average separation, in AU.
  pub maximum_average_separation: Option<f64>,
  /// The minimum orbital eccentricity.
  pub minimum_orbital_eccentricity: Option<f64>,
  /// The maximum orbital eccentricity.
  pub maximum_orbital_eccentricity: Option<f64>,
}

impl Constraints {
  /// Generate a distant binary star with at least one habitable system.
  #[named]
  pub fn habitable() -> Self {
    trace_enter!();
    let result = Self {
      ..Constraints::default()
    };
    trace_var!(result);
    trace_exit!();
    result
  }

  /// Generate.
  #[named]
  pub fn generate<R: Rng + ?Sized>(&self, rng: &mut R) -> Result<DistantBinaryStar, Error> {
    trace_enter!();
    let primary_constraints = PlanetarySystemConstraints::default();
    trace_var!(primary_constraints);
    let primary = primary_constraints.generate(rng)?;
    trace_var!(primary);
    let secondary_constraints = PlanetarySystemConstraints::default();
    trace_var!(secondary_constraints);
    let secondary = secondary_constraints.generate(rng)?;
    trace_var!(secondary);
    let result = DistantBinaryStar { primary, secondary };
    trace_var!(result);
    trace_exit!();
    Ok(result)
  }
}

impl Default for Constraints {
  /// No constraints, just let it all hang out.
  fn default() -> Self {
    let minimum_average_separation = Some(MINIMUM_AVERAGE_SEPARATION);
    let maximum_average_separation = Some(MAXIMUM_AVERAGE_SEPARATION);
    let minimum_orbital_eccentricity = Some(MINIMUM_ORBITAL_ECCENTRICITY);
    let maximum_orbital_eccentricity = Some(MAXIMUM_ORBITAL_ECCENTRICITY);
    Self {
      minimum_average_separation,
      maximum_average_separation,
      minimum_orbital_eccentricity,
      maximum_orbital_eccentricity,
    }
  }
}

#[cfg(test)]
pub mod test {

  use rand::prelude::*;

  use super::*;
  use crate::test::*;

  #[named]
  #[test]
  pub fn test_generate() -> Result<(), Error> {
    init();
    trace_enter!();
    let mut rng = thread_rng();
    trace_var!(rng);
    let distant_binary_star = Constraints::default().generate(&mut rng)?;
    trace_var!(distant_binary_star);
    print_var!(distant_binary_star);
    trace_exit!();
    Ok(())
  }

  #[named]
  #[test]
  pub fn test_habitable() -> Result<(), Error> {
    init();
    trace_enter!();
    let mut rng = thread_rng();
    trace_var!(rng);
    let distant_binary_star = Constraints::habitable().generate(&mut rng)?;
    trace_var!(distant_binary_star);
    print_var!(distant_binary_star);
    distant_binary_star.get_stellar_mass();
    distant_binary_star.is_habitable();
    trace_exit!();
    Ok(())
  }
}