arcflash 0.1.1

Arc flash calculations according to IEEE 1584
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
143
144
145
146
147
148
149
150
151
152
153
154
155

use crate::{e_afb, i_arc, multistep_e_and_afb, Cubicle, ElectrodeConfiguration};
use float_cmp::assert_approx_eq;
use uom::si::electric_current::{kiloampere, ElectricCurrent};
use uom::si::electric_potential::{kilovolt, ElectricPotential};
use uom::si::length::{millimeter, Length};
use uom::si::radiant_exposure::joule_per_square_centimeter;
use uom::si::time::{millisecond, Time};

/// Test high voltage calculation example, from Annex D.1.
///
/// Test that doing a calculation in 2 steps gives an identical result to doing the calculation in 1 step.
#[test]
fn test_annex_d1_calc_multistep() {
    let cubicle = Cubicle::new(
        ElectricPotential::new::<kilovolt>(4.16),
        ElectrodeConfiguration::VCB,
        Length::new::<millimeter>(104.0),
        Length::new::<millimeter>(914.4),
        Length::new::<millimeter>(1143.0),
        Length::new::<millimeter>(762.0),
        Length::new::<millimeter>(508.0),
    )
    .unwrap();
    let i_bf = ElectricCurrent::new::<kiloampere>(15.0);

    // Total 197ms as per original example
    let t_arc_max_1 = Time::new::<millisecond>(170.0);
    let t_arc_max_2 = Time::new::<millisecond>(27.0);

    // Total 223 ms as per original example
    let t_arc_min_1 = Time::new::<millisecond>(200.0);
    let t_arc_min_2 = Time::new::<millisecond>(23.0);

    // Do all calculations

    let i_arc_max_1 = i_arc(&cubicle, i_bf, false).unwrap();
    let e_afb_max_1 = e_afb(&cubicle, i_arc_max_1.clone(), t_arc_max_1);

    let i_arc_max_2 = i_arc(&cubicle, i_bf, false).unwrap();
    let e_afb_max_2 = e_afb(&cubicle, i_arc_max_2.clone(), t_arc_max_2);

    let (max_e, max_afb) = multistep_e_and_afb(&cubicle, &[e_afb_max_1, e_afb_max_2]);

    let i_arc_min_1 = i_arc(&cubicle, i_bf, true).unwrap();
    let e_afb_min_1 = e_afb(&cubicle, i_arc_min_1.clone(), t_arc_min_1);

    let i_arc_min_2 = i_arc(&cubicle, i_bf, true).unwrap();
    let e_afb_min_2 = e_afb(&cubicle, i_arc_min_2.clone(), t_arc_min_2);

    let (min_e, min_afb) = multistep_e_and_afb(&cubicle, &[e_afb_min_1, e_afb_min_2]);

    // Step 5 //

    // D.32
    assert_approx_eq!(
        f64,
        max_e.get::<joule_per_square_centimeter>(),
        12.152,
        epsilon = 1e-3
    );

    // Step 7 //

    // D.42
    assert_approx_eq!(f64, max_afb.get::<millimeter>(), 1606.0, epsilon = 1e0);

    // Step 12 //

    // D.62
    assert_approx_eq!(
        f64,
        min_e.get::<joule_per_square_centimeter>(),
        13.343,
        epsilon = 1e-3
    );

    // Step 14 //

    // D.72
    assert_approx_eq!(f64, min_afb.get::<millimeter>(), 1704.0, epsilon = 1e0);
}

/// Test low voltage calculation example, from Annex D.2.
///
/// Test that doing a calculation in 2 steps gives an identical result to doing the calculation in 1 step.
#[test]
fn test_annex_d2_calc_multistep() {
    let cubicle = Cubicle::new(
        ElectricPotential::new::<kilovolt>(0.48),
        ElectrodeConfiguration::VCB,
        Length::new::<millimeter>(32.0),
        Length::new::<millimeter>(609.6),
        Length::new::<millimeter>(610.0),
        Length::new::<millimeter>(610.0),
        Length::new::<millimeter>(254.0),
    )
    .unwrap();
    let i_bf = ElectricCurrent::new::<kiloampere>(45.0);

    // Original 61.3 ms
    let t_arc_max_1 = Time::new::<millisecond>(50.0);
    let t_arc_max_2 = Time::new::<millisecond>(11.3);

    // Original 319 ms
    let t_arc_min_1 = Time::new::<millisecond>(200.0);
    let t_arc_min_2 = Time::new::<millisecond>(119.0);

    // Do all calculations

    let i_arc_max_1 = i_arc(&cubicle, i_bf, false).unwrap();
    let e_afb_max_1 = e_afb(&cubicle, i_arc_max_1.clone(), t_arc_max_1);

    let i_arc_max_2 = i_arc(&cubicle, i_bf, false).unwrap();
    let e_afb_max_2 = e_afb(&cubicle, i_arc_max_2.clone(), t_arc_max_2);

    let (max_e, max_afb) = multistep_e_and_afb(&cubicle, &[e_afb_max_1, e_afb_max_2]);

    let i_arc_min_1 = i_arc(&cubicle, i_bf, true).unwrap();
    let e_afb_min_1 = e_afb(&cubicle, i_arc_min_1.clone(), t_arc_min_1);

    let i_arc_min_2 = i_arc(&cubicle, i_bf, true).unwrap();
    let e_afb_min_2 = e_afb(&cubicle, i_arc_min_2.clone(), t_arc_min_2);

    let (min_e, min_afb) = multistep_e_and_afb(&cubicle, &[e_afb_min_1, e_afb_min_2]);

    // Step 4 / Step 5 //

    // D.91
    assert_approx_eq!(
        f64,
        max_e.get::<joule_per_square_centimeter>(),
        11.585,
        epsilon = 1e-3
    );

    // Step 6 / Step 7 //

    // D.95
    assert_approx_eq!(f64, max_afb.get::<millimeter>(), 1029.0, epsilon = 1e0);

    // Step 10 / Step 11 //

    // D.103
    assert_approx_eq!(
        f64,
        min_e.get::<joule_per_square_centimeter>(),
        53.156,
        epsilon = 1e-3
    );

    // Step 12 / Step 13 //

    // D.106
    assert_approx_eq!(f64, min_afb.get::<millimeter>(), 2669.0, epsilon = 1e0);
}