rsspice 0.1.0

Pure Rust port of the SPICE Toolkit for space geometry
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

//
// GENERATED FILE
//

use super::*;
use f2rust_std::*;

const ATOL: f64 = 0.000000000001;

//$Procedure ZZGFSPQ ( GF, separation quantity )
pub fn ZZGFSPQ(
    ET: f64,
    TARG1: i32,
    TARG2: i32,
    R1: f64,
    R2: f64,
    OBS: i32,
    ABCORR: &[u8],
    REF: &[u8],
    VALUE: &mut f64,
    ctx: &mut Context,
) -> f2rust_std::Result<()> {
    let mut ANG1: f64 = 0.0;
    let mut ANG2: f64 = 0.0;
    let mut PV1 = StackArray::<f64, 3>::new(1..=3);
    let mut PV2 = StackArray::<f64, 3>::new(1..=3);
    let mut RANGE1: f64 = 0.0;
    let mut RANGE2: f64 = 0.0;
    let mut THETA: f64 = 0.0;
    let mut LT: f64 = 0.0;

    //
    // SPICELIB functions.
    //

    //
    // Local Variables.
    //

    //
    // ATOL is a tolerance value for computing arc sine.
    //

    //
    // Standard SPICE error handling.
    //
    if RETURN(ctx) {
        return Ok(());
    }

    CHKIN(b"ZZGFSPQ", ctx)?;

    //
    // First check for bad inputs.
    //
    if ((R1 < 0.0) || (R2 < 0.0)) {
        SETMSG(b"A negative radius for a body was encountered. The radius for body # was given as #, the radius of body # was given as #. ", ctx);

        ERRINT(b"#", TARG1, ctx);
        ERRDP(b"#", R1, ctx);
        ERRINT(b"#", TARG2, ctx);
        ERRDP(b"#", R2, ctx);
        SIGERR(b"SPICE(BADRADIUS)", ctx)?;
        CHKOUT(b"ZZGFSPQ", ctx)?;
        return Ok(());
    }

    //
    // Get the state of the TARG1, TARG2 objects relative to OBS.
    //
    SPKEZP(
        TARG1,
        ET,
        REF,
        ABCORR,
        OBS,
        PV1.as_slice_mut(),
        &mut LT,
        ctx,
    )?;

    if FAILED(ctx) {
        CHKOUT(b"ZZGFSPQ", ctx)?;
        return Ok(());
    }

    SPKEZP(
        TARG2,
        ET,
        REF,
        ABCORR,
        OBS,
        PV2.as_slice_mut(),
        &mut LT,
        ctx,
    )?;

    if FAILED(ctx) {
        CHKOUT(b"ZZGFSPQ", ctx)?;
        return Ok(());
    }

    //
    // Compute the range to the objects of interest.
    //
    RANGE1 = VNORM(PV1.as_slice());
    RANGE2 = VNORM(PV2.as_slice());

    //
    // Compute the apparent angular radii as seen from OBS.
    //
    if (RANGE1 > R1) {
        ANG1 = DASINE((R1 / RANGE1), ATOL, ctx)?;

        if FAILED(ctx) {
            CHKOUT(b"ZZGFSPQ", ctx)?;
            return Ok(());
        }
    } else {
        ANG1 = HALFPI(ctx);
    }

    if (RANGE2 > R2) {
        ANG2 = DASINE((R2 / RANGE2), ATOL, ctx)?;

        if FAILED(ctx) {
            CHKOUT(b"ZZGFSPQ", ctx)?;
            return Ok(());
        }
    } else {
        ANG2 = HALFPI(ctx);
    }

    //
    // Finally compute the apparent separation.
    //
    THETA = VSEP(PV1.as_slice(), PV2.as_slice(), ctx);
    *VALUE = ((THETA - ANG1) - ANG2);

    CHKOUT(b"ZZGFSPQ", ctx)?;
    Ok(())
}