Chpater59 sfpe

crates/python_api/docs/api/sfpe-handbook.rst

@@ -137,4 +137,68 @@ Equation 50.20 - Visibility Through Smoke (Percent Obscuration)
 .. automodule:: ofire.sfpe_handbook.chapter_50.equation_50_20
    :members:
    :undoc-members:
-   :show-inheritance:
+   :show-inheritance:
+
+Chapter 59
+----------
+
+.. automodule:: ofire.sfpe_handbook.chapter_59
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Equation 59.5
+~~~~~~~~~~~~~
+
+.. automodule:: ofire.sfpe_handbook.chapter_59.equation_59_5
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Equation 59.6
+~~~~~~~~~~~~~
+
+.. automodule:: ofire.sfpe_handbook.chapter_59.equation_59_6
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Equation 59.7
+~~~~~~~~~~~~~
+
+.. automodule:: ofire.sfpe_handbook.chapter_59.equation_59_7
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Equation 59.8
+~~~~~~~~~~~~~
+
+.. automodule:: ofire.sfpe_handbook.chapter_59.equation_59_8
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Equation 59.9
+~~~~~~~~~~~~~
+
+.. automodule:: ofire.sfpe_handbook.chapter_59.equation_59_9
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Equation 59.10
+~~~~~~~~~~~~~~
+
+.. automodule:: ofire.sfpe_handbook.chapter_59.equation_59_10
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Equation 59.11
+~~~~~~~~~~~~~~
+
+.. automodule:: ofire.sfpe_handbook.chapter_59.equation_59_11
+   :members:
+   :undoc-members:
+   :show-inheritance:

crates/python_api/src/sfpe_handbook.rs

@@ -1,5 +1,6 @@
 pub mod chapter_14;
 pub mod chapter_50;
+pub mod chapter_59;
 
 use pyo3::prelude::*;
 use pyo3::wrap_pymodule;
@@ -14,5 +15,6 @@ use pyo3::wrap_pymodule;
 pub fn sfpe_handbook(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pymodule!(chapter_14::chapter_14))?;
     m.add_wrapped(wrap_pymodule!(chapter_50::chapter_50))?;
+    m.add_wrapped(wrap_pymodule!(chapter_59::chapter_59))?;
     Ok(())
 }

crates/python_api/src/sfpe_handbook/chapter_50/equation_50_17.rs

@@ -43,4 +43,4 @@ fn stairwell_temperature(t_0: f64, eta: f64, t_b: f64) -> PyResult<f64> {
 pub fn equation_50_17(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(stairwell_temperature, m)?)?;
     Ok(())
-}
+}

crates/python_api/src/sfpe_handbook/chapter_50/equation_50_20.rs

@@ -43,4 +43,4 @@ fn visibility(k: f64, l: f64, lambda: f64) -> PyResult<f64> {
 pub fn equation_50_20(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(visibility, m)?)?;
     Ok(())
-}
+}

crates/python_api/src/sfpe_handbook/chapter_59.rs

@@ -0,0 +1,25 @@
+pub mod equation_59_10;
+pub mod equation_59_11;
+pub mod equation_59_5;
+pub mod equation_59_6;
+pub mod equation_59_7;
+pub mod equation_59_8;
+pub mod equation_59_9;
+
+use pyo3::prelude::*;
+use pyo3::wrap_pymodule;
+
+#[pymodule]
+/// Chapter 59 - Placeholder equations.
+///
+/// This chapter contains placeholder equations that will be implemented.
+pub fn chapter_59(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_wrapped(wrap_pymodule!(equation_59_5::equation_59_5))?;
+    m.add_wrapped(wrap_pymodule!(equation_59_6::equation_59_6))?;
+    m.add_wrapped(wrap_pymodule!(equation_59_7::equation_59_7))?;
+    m.add_wrapped(wrap_pymodule!(equation_59_8::equation_59_8))?;
+    m.add_wrapped(wrap_pymodule!(equation_59_9::equation_59_9))?;
+    m.add_wrapped(wrap_pymodule!(equation_59_10::equation_59_10))?;
+    m.add_wrapped(wrap_pymodule!(equation_59_11::equation_59_11))?;
+    Ok(())
+}

crates/python_api/src/sfpe_handbook/chapter_59/equation_59_10.rs

@@ -0,0 +1,36 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+/// Placeholder for equation 59.10.
+///
+/// This function is a placeholder and will be implemented with the actual
+/// equation logic.
+///
+/// .. math::
+///
+///    \text{TODO: Add equation}
+///
+/// where:
+///
+/// - TODO: Add variable definitions
+///
+/// Args:
+///     TODO: Add arguments
+///
+/// Returns:
+///     float: TODO: Add return description
+///
+/// Example:
+///     >>> import ofire
+///     >>> # TODO: Add example when equation is implemented
+fn equation_59_10_placeholder() -> PyResult<f64> {
+    Err(pyo3::exceptions::PyNotImplementedError::new_err(
+        "Equation 59.10 is not yet implemented",
+    ))
+}
+
+#[pymodule]
+pub fn equation_59_10(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(pyo3::wrap_pyfunction!(equation_59_10_placeholder, m)?)?;
+    Ok(())
+}

crates/python_api/src/sfpe_handbook/chapter_59/equation_59_11.rs

@@ -0,0 +1,36 @@
+use pyo3::prelude::*;
+
+#[pyfunction]
+/// Placeholder for equation 59.11.
+///
+/// This function is a placeholder and will be implemented with the actual
+/// equation logic.
+///
+/// .. math::
+///
+///    \text{TODO: Add equation}
+///
+/// where:
+///
+/// - TODO: Add variable definitions
+///
+/// Args:
+///     TODO: Add arguments
+///
+/// Returns:
+///     float: TODO: Add return description
+///
+/// Example:
+///     >>> import ofire
+///     >>> # TODO: Add example when equation is implemented
+fn equation_59_11_placeholder() -> PyResult<f64> {
+    Err(pyo3::exceptions::PyNotImplementedError::new_err(
+        "Equation 59.11 is not yet implemented",
+    ))
+}
+
+#[pymodule]
+pub fn equation_59_11(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(pyo3::wrap_pyfunction!(equation_59_11_placeholder, m)?)?;
+    Ok(())
+}

crates/python_api/src/sfpe_handbook/chapter_59/equation_59_5.rs

@@ -0,0 +1,39 @@
+use pyo3::prelude::*;
+
+use openfire::sfpe_handbook::chapter_59::equation_59_5 as rust_equation_59_5;
+
+#[pyfunction]
+/// Calculates pedestrian travel speed along a path (Equation 59.5).
+///
+/// .. math::
+///
+///    S = k - akD
+///
+/// where:
+///
+/// - :math:`S` is the speed along the line of travel
+/// - :math:`k` is the speed constant from Table 59.2
+/// - :math:`a` is the unit conversion constant (0.266 for SI, 2.86 for imperial)
+/// - :math:`D` is the population density in persons per unit area
+///
+/// Args:
+///     k (float): Speed constant from Table 59.2
+///     a (float): Unit conversion constant (0.266 for SI, 2.86 for imperial)
+///     d (float): Population density (persons per unit area)
+///
+/// Returns:
+///     float: Speed S along the line of travel
+///
+/// Example:
+///     >>> import ofire
+///     >>> result = ofire.sfpe_handbook.chapter_59.equation_59_5.travel_speed(1.19, 0.266, 0.5)
+///     >>> print(f"{result:.3f} m/s")
+fn travel_speed(k: f64, a: f64, d: f64) -> PyResult<f64> {
+    Ok(rust_equation_59_5::travel_speed(k, a, d))
+}
+
+#[pymodule]
+pub fn equation_59_5(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(pyo3::wrap_pyfunction!(travel_speed, m)?)?;
+    Ok(())
+}

crates/python_api/src/sfpe_handbook/chapter_59/equation_59_6.rs

@@ -0,0 +1,40 @@
+use pyo3::prelude::*;
+
+use openfire::sfpe_handbook::chapter_59::equation_59_6 as rust_equation_59_6;
+
+#[pyfunction]
+/// Calculates specific flow of evacuating persons (Equation 59.6).
+///
+/// Specific flow is the flow of evacuating persons past a point in the exit
+/// route per unit of time per unit of effective width.
+///
+/// .. math::
+///
+///    F_s = S \cdot D
+///
+/// where:
+///
+/// - :math:`F_s` is the specific flow (persons/min/ft or persons/s/m of effective width)
+/// - :math:`S` is the speed along the line of travel (from Equation 59.5)
+/// - :math:`D` is the population density (persons per unit area)
+///
+/// Args:
+///     s (float): Speed along the line of travel (m/s or ft/min)
+///     d (float): Population density (persons/m² or persons/ft²)
+///
+/// Returns:
+///     float: Specific flow Fs (persons/s/m or persons/min/ft of effective width)
+///
+/// Example:
+///     >>> import ofire
+///     >>> result = ofire.sfpe_handbook.chapter_59.equation_59_6.specific_flow(1.0, 0.5)
+///     >>> print(f"{result:.2f} persons/s/m")
+fn specific_flow(s: f64, d: f64) -> PyResult<f64> {
+    Ok(rust_equation_59_6::specific_flow(s, d))
+}
+
+#[pymodule]
+pub fn equation_59_6(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(pyo3::wrap_pyfunction!(specific_flow, m)?)?;
+    Ok(())
+}

crates/python_api/src/sfpe_handbook/chapter_59/equation_59_7.rs

@@ -0,0 +1,42 @@
+use pyo3::prelude::*;
+
+use openfire::sfpe_handbook::chapter_59::equation_59_7 as rust_equation_59_7;
+
+#[pyfunction]
+/// Calculates specific flow by combining Equations 59.5 and 59.6 (Equation 59.7).
+///
+/// This equation combines the travel speed equation (59.5) with the specific
+/// flow equation (59.6) to express specific flow directly in terms of density.
+///
+/// .. math::
+///
+///    F_s = (1 - aD) \cdot k \cdot D
+///
+/// where:
+///
+/// - :math:`F_s` is the specific flow (persons/min/ft or persons/s/m of effective width)
+/// - :math:`a` is the unit conversion constant (0.266 for SI, 2.86 for imperial)
+/// - :math:`D` is the population density (persons per unit area)
+/// - :math:`k` is the speed constant from Table 59.2
+///
+/// Args:
+///     a (float): Unit conversion constant (0.266 for SI units, 2.86 for imperial units)
+///     d (float): Population density (persons/m² or persons/ft²)
+///     k (float): Speed constant from Table 59.2
+///
+/// Returns:
+///     float: Specific flow Fs (persons/s/m or persons/min/ft of effective width)
+///
+/// Example:
+///     >>> import ofire
+///     >>> result = ofire.sfpe_handbook.chapter_59.equation_59_7.specific_flow(0.266, 0.5, 1.19)
+///     >>> print(f"{result:.4f} persons/s/m")
+fn specific_flow(a: f64, d: f64, k: f64) -> PyResult<f64> {
+    Ok(rust_equation_59_7::specific_flow(a, d, k))
+}
+
+#[pymodule]
+pub fn equation_59_7(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(pyo3::wrap_pyfunction!(specific_flow, m)?)?;
+    Ok(())
+}

crates/python_api/src/sfpe_handbook/chapter_59/equation_59_8.rs

@@ -0,0 +1,41 @@
+use pyo3::prelude::*;
+
+use openfire::sfpe_handbook::chapter_59::equation_59_8 as rust_equation_59_8;
+
+#[pyfunction]
+/// Calculates the flow rate of persons passing a point in an exit route (Equation 59.8).
+///
+/// The calculated flow is the predicted flow rate of persons passing a particular
+/// point in an exit route. This equation assumes the achievable flow rate through
+/// a component is directly proportional to its width.
+///
+/// .. math::
+///
+///    F_c = F_s \cdot W_e
+///
+/// where:
+///
+/// - :math:`F_c` is the calculated flow (persons/min or persons/s)
+/// - :math:`F_s` is the specific flow (persons/min/ft or persons/s/m of effective width)
+/// - :math:`W_e` is the effective width of the component being traversed (ft or m)
+///
+/// Args:
+///     fs (float): Specific flow (persons/min/ft or persons/s/m of effective width)
+///     we (float): Effective width of the component being traversed (ft or m)
+///
+/// Returns:
+///     float: Calculated flow Fc (persons/min or persons/s)
+///
+/// Example:
+///     >>> import ofire
+///     >>> result = ofire.sfpe_handbook.chapter_59.equation_59_8.calculated_flow(1.3, 1.5)
+///     >>> print(f"{result:.2f} persons/s")
+fn calculated_flow(fs: f64, we: f64) -> PyResult<f64> {
+    Ok(rust_equation_59_8::calculated_flow(fs, we))
+}
+
+#[pymodule]
+pub fn equation_59_8(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(pyo3::wrap_pyfunction!(calculated_flow, m)?)?;
+    Ok(())
+}