sim-lib-interference-runtime 0.1.0

Tensor-backed Citizen records and Shape contracts for coherent interference studies.
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 std::sync::Arc;

use sim_citizen::CitizenField;
use sim_kernel::{Args, Cx, DefaultFactory, EagerPolicy, Expr, Symbol, Value};
use sim_lib_interference_runtime::{
    InterferenceLib, InterferenceRecordsLib, StudyDescriptor, problem_function_symbol,
    sampling_plane_function_symbol, solve_function_symbol,
};

fn main() -> sim_kernel::Result<()> {
    let mut cx = Cx::new(Arc::new(EagerPolicy), Arc::new(DefaultFactory));
    cx.load_lib(&InterferenceRecordsLib)?;
    cx.load_lib(&InterferenceLib)?;

    let problem_spec = value(
        &mut cx,
        map([
            ("frequency-hz", field(&1_000.0)),
            ("speed-m-s", field(&343.0)),
            ("attenuation-np-m", field(&0.0)),
            ("singularity-radius-m", field(&0.01)),
            (
                "sources",
                Expr::List(vec![
                    map([
                        ("kind", Expr::Symbol(Symbol::new("point"))),
                        ("id", Expr::Symbol(Symbol::new("left"))),
                        ("position-m", vector([-0.25, 0.0, 0.0])),
                        ("amplitude-at-reference", field(&1.0)),
                        ("phase-rad", field(&0.0)),
                    ]),
                    map([
                        ("kind", Expr::Symbol(Symbol::new("point"))),
                        ("id", Expr::Symbol(Symbol::new("right"))),
                        ("position-m", vector([0.25, 0.0, 0.0])),
                        ("amplitude-at-reference", field(&1.0)),
                        ("phase-rad", field(&std::f64::consts::PI)),
                    ]),
                ]),
            ),
        ]),
    )?;
    let problem = cx.call_function(&problem_function_symbol(), Args::new(vec![problem_spec]))?;

    let plane_spec = value(
        &mut cx,
        map([
            ("origin-m", vector([-1.0, -1.0, 0.5])),
            ("u-axis", vector([1.0, 0.0, 0.0])),
            ("v-axis", vector([0.0, 1.0, 0.0])),
            ("extent-u-m", field(&2.0)),
            ("extent-v-m", field(&2.0)),
            ("rows", field(&1_024_usize)),
            ("cols", field(&1_024_usize)),
        ]),
    )?;
    let plane = cx.call_function(
        &sampling_plane_function_symbol(),
        Args::new(vec![plane_spec]),
    )?;
    let options = value(
        &mut cx,
        map([
            ("sampling", Expr::Symbol(Symbol::new("strict"))),
            ("work-budget", Expr::Symbol(Symbol::new("default"))),
        ]),
    )?;
    let study = cx.call_function(
        &solve_function_symbol(),
        Args::new(vec![problem, plane, options]),
    )?;
    let study = study
        .object()
        .downcast_ref::<StudyDescriptor>()
        .expect("interference/solve result Shape");
    println!(
        "interference/Study rows={} cols={} emitters={} cells={} evaluations={} verdict={}",
        study.field.rows,
        study.field.cols,
        study.evidence.work.emitters,
        study.evidence.work.cells,
        study.evidence.work.emitter_evaluations,
        study.evidence.sampling.verdict.name
    );
    Ok(())
}

fn value(cx: &mut Cx, expr: Expr) -> sim_kernel::Result<Value> {
    sim_citizen::value_from_expr(cx, &expr)
}

fn field<T: CitizenField>(value: &T) -> Expr {
    value.encode_field()
}

fn vector<const N: usize>(values: [f64; N]) -> Expr {
    Expr::List(values.into_iter().map(|value| field(&value)).collect())
}

fn map<const N: usize>(entries: [(&str, Expr); N]) -> Expr {
    Expr::Map(
        entries
            .into_iter()
            .map(|(key, value)| (Expr::Symbol(Symbol::new(key)), value))
            .collect(),
    )
}