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

/*!
# **kalast**

Thermophysical model for binary systems of asteroids.

## Using **kalast**

You will need the last stable build of the [rust compiler](https://www.rust-lang.org)
and the official package manager: [cargo](https://github.com/rust-lang/cargo).

Simply add the following to your `Cargo.toml` file:

```.ignore
[dependencies]
kalast = "0.1.6"
```

Most useful functionalities of **kalast** are grouped in the root module `kalast::`.

However, the recommended way to use nalgebra is to import types and traits explicitly, and call free-functions using the na:: prefix:

```no_run
use kalast::{Body, Properties, Time, World, ASTRONAUMICAL_UNIT, HOUR, TAU, V3};
use std::path::Path;

fn main() {
    // Instanciate a celestial body named 'Dimorphos', at a distance of 1.664 AU from
    // the Sun, from a 3D object shape model located at 'rsc/obj/dimorphos.obj',
    // with a complete set of ground physical properties.
    let mut body = Body::new(
        "Dimorphos",
        V3::new(0.0, 1.0, 0.0) * ASTRONAUMICAL_UNIT * 1.664,
        Path::new("rsc/obj/dimorphos.obj"),
        Properties::new(
            11.92 * HOUR,        // rotation period
            11.92 * HOUR,        // revolution period
            162.0 * TAU / 360.0, // obliquity
            500.0,               // thermal inertia
            2146.0,              // density
            600.0,               // heat capacity
            0.07,                // albedo
            0.9,                 // emissivity
        ),
    );
    body.set_faces_mask_equator(); // only computes temperatures for equator

    // Create a simulation time that lasts 50 revolution period of the body with 30 seconds steps.
    // The residual 0.75 period is for the last frame to be at noon (max temperature peek at
    // longitude=0°, according to this initial bodies setup).
    let time = Time::new(50.75 * body.properties.revolution_period(), 30.0);

    let mut world = World::new(time, body, None); // define the world of the simulation
    world.start(); // run the simulation
    world.save(Path::new("rsc/temperatures/dimorphos_equator.txt")); // save the temperatures to a file
}
```

## Features

**kalast** is meant for binary system of asteroids surface thermophysical modelling. The physics of this engine includes these features:

+ custom shape model
+ celestial body revolution
+ compute surface temperatures from solar flux
+ ground 1D heat transfert conduction
+ celestial body mask view (example only equator)
+ TODO: mutual heating from primary/moon
+ TODO: self heating
+ TODO: mutual occultations
+ TODO: shadowing

## Explore

If your want to explore the documentation, you can visite these pages:

+ [`Object3D`]: parse 3D object file and compute atributes of faces (centers, normals, ...)
+ [`Body`]: the representation for a celestial body
+ [`Properties`]: all the properties to characterise a body
+ [`World`]: the simulation manager
*/

extern crate alga;
extern crate indicatif;
#[macro_use]
extern crate itertools;
extern crate nalgebra as na;
extern crate num_traits;
extern crate obj;

/// Base features.
pub mod base;
/// Collection of generic functions for math, physics, matrix operations, or for the usage of other
/// crates.
pub mod toolbox;

use alga::general::RingCommutative;
use na::Scalar;
use na::{
    DVector, Dynamic, Matrix, Matrix3x1, Matrix3xX, SliceStorage, SliceStorageMut, VecStorage, U1,
    U10,
};
use num_traits::{NumCast, ToPrimitive};
use std::cmp::PartialOrd;

pub use crate::base::*;
pub use crate::toolbox::*;

/// Type alias for [`Matrix3xX`]. The matrix has a fixed number of rows (3) and a dynamical number of
/// columns.
pub type V3X<T> = Matrix3xX<T>;

/// Type alias for [`Matrix3x1`]. The matrix has a fixed number of rows (3) and a fixed number of
/// columns (1).
pub type V3<T> = Matrix3x1<T>;

/// Type alias for [`DVector`]. The matrix is a vector of X columns.
pub type VX<T> = DVector<T>;

/// Type alias for [`Object3D`]. The matrix has a fixed number of rows (10) and a dynamical number
/// of columns.
pub type Matrix10xX<T> = Matrix<T, U10, Dynamic, VecStorage<T, U10, Dynamic>>;

/// Type alias for [`Object3D`]. The slice matrix has a fixed number of rows (10) and a fixed
/// number of columns (1).
pub type MatrixSlice10x1<'a, T, RStride = U1, CStride = U10> =
    Matrix<T, U10, U1, SliceStorage<'a, T, U10, U1, RStride, CStride>>;

/// Type alias for [`Object3D`]. The mutable slice matrix has a fixed number of rows (10) and a
/// fixed number of columns (1).
pub type MatrixSliceMut10x1<'a, T, RStride = U1, CStride = U10> =
    Matrix<T, U10, U1, SliceStorageMut<'a, T, U10, U1, RStride, CStride>>;

/// Trait that extends [`Scalar`] to create integer matrices like float matrices. It aims to be the
/// equivalent of [`nalgebra::RealField`] but for integer.
pub trait SuperScalar:
    Scalar + RingCommutative + PartialOrd + std::ops::Div + ToPrimitive + NumCast + Copy
{
}

impl<T> SuperScalar for T where
    T: Scalar + RingCommutative + PartialOrd + std::ops::Div + ToPrimitive + NumCast + Copy
{
}