pifira 0.1.0__tar.gz

pifira-0.1.0/CITATION.cff

@@ -0,0 +1,29 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: "pifira: Pressure-based Inverse Fire-heat-flux and Radiative-Area analysis"
+abstract: >-
+  A data-agnostic Python toolkit for estimating fire heat input and effective
+  flame-contact area for pressurized LPG tanks under localized (non-engulfing)
+  flame exposure. It combines the closed-vessel pressure-rise method with a
+  radiative (T^4) weighted angular-temperature inversion to recover the
+  effective fire-contact area and heat flux, and provides a dimensionless
+  framework unifying localized and full-engulfment exposure across tank sizes,
+  fill levels and orientations.
+type: software
+authors:
+  - given-names: "Woo-gui-yeon"
+    family-names: "Lee"
+    affiliation: "Korea Gas Safety Corporation (KGS), AI Safety Research Team"
+    orcid: "https://orcid.org/0009-0008-8976-5363"
+version: "0.1.0"
+license: MIT
+keywords:
+  - LPG
+  - fire safety
+  - heat flux
+  - pressure relief valve
+  - closed-vessel pressure-rise method
+  - BLEVE
+  - inverse method
+  - process safety
+repository-code: "https://github.com/lyullee/pifira"

pifira-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Woo-gui-yeon Lee, Korea Gas Safety Corporation (KGS), AI Safety Research Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pifira-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+include README.md
+include CITATION.cff
+recursive-include examples *.py

pifira-0.1.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: pifira
+Version: 0.1.0
+Summary: Pressure-based inverse estimation of fire heat flux and effective flame-contact area for pressurized LPG tanks under localized flame exposure
+Author: Woo-gui-yeon Lee
+Maintainer: Woo-gui-yeon Lee
+License: MIT
+Project-URL: Homepage, https://github.com/lyullee/pifira
+Project-URL: Repository, https://github.com/lyullee/pifira
+Project-URL: Issues, https://github.com/lyullee/pifira/issues
+Keywords: LPG,fire safety,heat flux,pressure relief valve,closed-vessel,pressure-rise method,BLEVE,process safety,thermal engineering,inverse method
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: pandas>=1.3
+Requires-Dist: CoolProp>=6.4
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.4; extra == "plot"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: matplotlib>=3.4; extra == "dev"
+Dynamic: license-file
+
+# pifira
+
+**P**ressure-based **I**nverse **F**ire-heat-flux and **R**adiative-**A**rea analysis
+
+A data-agnostic Python toolkit for estimating **fire heat input** and
+**effective flame-contact area** for pressurized LPG tanks under **localized
+(non-engulfing) flame exposure**.
+
+pifira combines the **closed-vessel pressure-rise method** (heat input from a
+measured pressure history) with a **radiative (T?? weighted angular-temperature
+inversion** (effective fire-contact area from surface temperatures), and
+provides a **dimensionless framework** that unifies localized and
+full-engulfment exposure across tank sizes, fill levels and orientations.
+
+> **No experimental data are bundled with this package.** All routines operate
+> on user-supplied arrays. See [Data sources](#data-sources) for how to obtain
+> the public validation datasets.
+
+---
+
+## Why
+
+Most published fire-engulfment work assumes *uniform, full engulfment* of
+*horizontal* tanks. Small **vertical** LPG tanks under *localized* flame
+exposure are under-studied, and standards (API 521, KGS) do not cover heat-input
+estimation for this case. pifira addresses this by inverting a measured
+pressure rise for heat input and a measured angular temperature distribution
+for the effective contact area ??without assuming full engulfment.
+
+## Installation
+
+```bash
+pip install pifira
+```
+
+Dependencies: `numpy`, `scipy`, `pandas`, `CoolProp`. Optional plotting extras:
+
+```bash
+pip install "pifira[plot]"
+```
+
+## Quick start
+
+```python
+import numpy as np
+import pifira
+
+# 1. Define the tank (volume, fluid, fill fraction)
+tank = pifira.TankSpec(
+    volume=0.619,
+    fluid="HEOS::Propane[0.95]&n-Butane[0.05]",
+    fill=0.70,
+)
+
+# 2. Heat input from a pressure history (bring your own arrays)
+#    t [s], P [bar gauge], closed-vessel window before PRV opens
+Q_W = pifira.heat_input(P1_bar=10.83, P2_bar=16.30, dt=544.5, tank=tank)
+print(Q_W / 1000, "kW")
+
+# 3. Effective contact area from angular wall temperatures
+#    flame centre at 0 deg; off-flame points at +/-90, 180
+res = pifira.effective_arc(
+    angles_deg=[0, 90, 180, -90],
+    T_wall_C=[271, 49, 39, 46],   # period-averaged wall temps
+    T_amb_C=35.0,
+)
+arc_deg = res["arc_deg"]          # area-preserving equivalent width
+
+h_eff = pifira.effective_height(flame_height_m=0.767, liquid_height_m=0.885)
+A_eff = pifira.effective_area(diameter_m=0.75, arc_deg=arc_deg, height_m=h_eff)
+
+# 4. Heat flux
+print(pifira.heat_flux(Q_W, A_eff), "kW/m^2")
+```
+
+A full time-varying workflow (moving-window heat input, per-instant effective
+arc, heat-input-weighted representative value) is in
+[`examples/analyze_localized.py`](examples/analyze_localized.py).
+
+## Public API
+
+| Area | Functions |
+|---|---|
+| Heat input (pressure-rise) | `TankSpec`, `internal_energy`, `liquid_height`, `heat_input`, `heat_input_series` |
+| Effective area (inversion) | `radiative_driving_force`, `effective_arc`, `effective_height`, `effective_area`, `heat_flux` |
+| Representative value | `heat_input_weighted_mean`, `simple_mean` |
+| Dimensionless framework | `coverage_fraction` (?), `normalized_flux` (q\*), `pressurization_number` (?), `orientation_factor` (Ω) |
+| I/O | `load_pressure_csv`, `load_temperature_csv` |
+
+## Method summary
+
+1. **Closed-vessel pressure-rise.** Before pressure-relief venting, incident
+   heat converts entirely into the contents' internal-energy rise:
+   `Q = dU/dt = d/dt(m_L u_L + m_V u_V)`. Mass and volume are fixed; the
+   liquid/vapour split is re-flashed at each pressure (CoolProp).
+
+2. **Radiative (T?? angular inversion.** Radiative flux scales with
+   `T_wall????T_amb?? (Stefan-Boltzmann). Angular wall temperatures are fit
+   with a Gaussian; the area-preserving equivalent width `??2?)·?` gives the
+   effective arc.
+
+3. **Axial intersection.** Effective height = min(flame contact height, wetted
+   liquid height). Vapour-space wall is excluded.
+
+4. **Representative value.** Heat-input-weighted mean `Σ(q·Q)/ΣQ`, since fire
+   safety is governed by high-heat-input instants.
+
+5. **Dimensionless framework.** ? (coverage), q\* (normalized flux), ?
+   (pressurization), Ω (orientation) unify localized/full and vertical/horizontal.
+
+## Data sources
+
+pifira ships **no data**. The public datasets used to validate the method in
+the associated study are available from their original publications:
+
+- **Moodie, K., Billinge, K., Cutler, D.P. (1988).** *Fire Engulfment of LPG
+  Storage Tanks.* IChemE Symposium Series No. 93, pp. 87??06. Institution of
+  Chemical Engineers. ??pressure history (Fig. 5) and initial conditions /
+  heat fluxes (Tables 1??). Obtain from IChemE or a library.
+
+- **Birk, A.M., Poirier, D., Davison, C. (2006).** *On the thermal rupture of
+  1.9 m³ propane pressure vessels with defects in their thermal protection
+  system.* Journal of Loss Prevention in the Process Industries **19**(6),
+  582??97. https://doi.org/10.1016/j.jlp.2006.02.002 ??pressure (Fig. 8) and
+  lading-temperature stratification (Fig. 10) for the 25% partial-engulfment
+  test. Obtain from the publisher.
+
+To reproduce the validation, digitize the relevant figures from the original
+papers and pass the values to the pifira API. Digitized values are **not**
+redistributed here.
+
+Experimental data from the authors' own fire tests are **not** included and are
+reported separately.
+
+## Citing
+
+If you use pifira, please cite it via [`CITATION.cff`](CITATION.cff) and the
+archived release DOI (Zenodo). See the repository release page for the DOI.
+
+## License
+
+MIT ??see [LICENSE](LICENSE).
+
+## Author
+
+Woo-gui-yeon Lee, Korea Gas Safety Corporation (KGS), AI Safety Research Team
+([ORCID 0009-0008-8976-5363](https://orcid.org/0009-0008-8976-5363)).

pifira-0.1.0/README.md

@@ -0,0 +1,147 @@
+# pifira
+
+**P**ressure-based **I**nverse **F**ire-heat-flux and **R**adiative-**A**rea analysis
+
+A data-agnostic Python toolkit for estimating **fire heat input** and
+**effective flame-contact area** for pressurized LPG tanks under **localized
+(non-engulfing) flame exposure**.
+
+pifira combines the **closed-vessel pressure-rise method** (heat input from a
+measured pressure history) with a **radiative (T?? weighted angular-temperature
+inversion** (effective fire-contact area from surface temperatures), and
+provides a **dimensionless framework** that unifies localized and
+full-engulfment exposure across tank sizes, fill levels and orientations.
+
+> **No experimental data are bundled with this package.** All routines operate
+> on user-supplied arrays. See [Data sources](#data-sources) for how to obtain
+> the public validation datasets.
+
+---
+
+## Why
+
+Most published fire-engulfment work assumes *uniform, full engulfment* of
+*horizontal* tanks. Small **vertical** LPG tanks under *localized* flame
+exposure are under-studied, and standards (API 521, KGS) do not cover heat-input
+estimation for this case. pifira addresses this by inverting a measured
+pressure rise for heat input and a measured angular temperature distribution
+for the effective contact area ??without assuming full engulfment.
+
+## Installation
+
+```bash
+pip install pifira
+```
+
+Dependencies: `numpy`, `scipy`, `pandas`, `CoolProp`. Optional plotting extras:
+
+```bash
+pip install "pifira[plot]"
+```
+
+## Quick start
+
+```python
+import numpy as np
+import pifira
+
+# 1. Define the tank (volume, fluid, fill fraction)
+tank = pifira.TankSpec(
+    volume=0.619,
+    fluid="HEOS::Propane[0.95]&n-Butane[0.05]",
+    fill=0.70,
+)
+
+# 2. Heat input from a pressure history (bring your own arrays)
+#    t [s], P [bar gauge], closed-vessel window before PRV opens
+Q_W = pifira.heat_input(P1_bar=10.83, P2_bar=16.30, dt=544.5, tank=tank)
+print(Q_W / 1000, "kW")
+
+# 3. Effective contact area from angular wall temperatures
+#    flame centre at 0 deg; off-flame points at +/-90, 180
+res = pifira.effective_arc(
+    angles_deg=[0, 90, 180, -90],
+    T_wall_C=[271, 49, 39, 46],   # period-averaged wall temps
+    T_amb_C=35.0,
+)
+arc_deg = res["arc_deg"]          # area-preserving equivalent width
+
+h_eff = pifira.effective_height(flame_height_m=0.767, liquid_height_m=0.885)
+A_eff = pifira.effective_area(diameter_m=0.75, arc_deg=arc_deg, height_m=h_eff)
+
+# 4. Heat flux
+print(pifira.heat_flux(Q_W, A_eff), "kW/m^2")
+```
+
+A full time-varying workflow (moving-window heat input, per-instant effective
+arc, heat-input-weighted representative value) is in
+[`examples/analyze_localized.py`](examples/analyze_localized.py).
+
+## Public API
+
+| Area | Functions |
+|---|---|
+| Heat input (pressure-rise) | `TankSpec`, `internal_energy`, `liquid_height`, `heat_input`, `heat_input_series` |
+| Effective area (inversion) | `radiative_driving_force`, `effective_arc`, `effective_height`, `effective_area`, `heat_flux` |
+| Representative value | `heat_input_weighted_mean`, `simple_mean` |
+| Dimensionless framework | `coverage_fraction` (?), `normalized_flux` (q\*), `pressurization_number` (?), `orientation_factor` (Ω) |
+| I/O | `load_pressure_csv`, `load_temperature_csv` |
+
+## Method summary
+
+1. **Closed-vessel pressure-rise.** Before pressure-relief venting, incident
+   heat converts entirely into the contents' internal-energy rise:
+   `Q = dU/dt = d/dt(m_L u_L + m_V u_V)`. Mass and volume are fixed; the
+   liquid/vapour split is re-flashed at each pressure (CoolProp).
+
+2. **Radiative (T?? angular inversion.** Radiative flux scales with
+   `T_wall????T_amb?? (Stefan-Boltzmann). Angular wall temperatures are fit
+   with a Gaussian; the area-preserving equivalent width `??2?)·?` gives the
+   effective arc.
+
+3. **Axial intersection.** Effective height = min(flame contact height, wetted
+   liquid height). Vapour-space wall is excluded.
+
+4. **Representative value.** Heat-input-weighted mean `Σ(q·Q)/ΣQ`, since fire
+   safety is governed by high-heat-input instants.
+
+5. **Dimensionless framework.** ? (coverage), q\* (normalized flux), ?
+   (pressurization), Ω (orientation) unify localized/full and vertical/horizontal.
+
+## Data sources
+
+pifira ships **no data**. The public datasets used to validate the method in
+the associated study are available from their original publications:
+
+- **Moodie, K., Billinge, K., Cutler, D.P. (1988).** *Fire Engulfment of LPG
+  Storage Tanks.* IChemE Symposium Series No. 93, pp. 87??06. Institution of
+  Chemical Engineers. ??pressure history (Fig. 5) and initial conditions /
+  heat fluxes (Tables 1??). Obtain from IChemE or a library.
+
+- **Birk, A.M., Poirier, D., Davison, C. (2006).** *On the thermal rupture of
+  1.9 m³ propane pressure vessels with defects in their thermal protection
+  system.* Journal of Loss Prevention in the Process Industries **19**(6),
+  582??97. https://doi.org/10.1016/j.jlp.2006.02.002 ??pressure (Fig. 8) and
+  lading-temperature stratification (Fig. 10) for the 25% partial-engulfment
+  test. Obtain from the publisher.
+
+To reproduce the validation, digitize the relevant figures from the original
+papers and pass the values to the pifira API. Digitized values are **not**
+redistributed here.
+
+Experimental data from the authors' own fire tests are **not** included and are
+reported separately.
+
+## Citing
+
+If you use pifira, please cite it via [`CITATION.cff`](CITATION.cff) and the
+archived release DOI (Zenodo). See the repository release page for the DOI.
+
+## License
+
+MIT ??see [LICENSE](LICENSE).
+
+## Author
+
+Woo-gui-yeon Lee, Korea Gas Safety Corporation (KGS), AI Safety Research Team
+([ORCID 0009-0008-8976-5363](https://orcid.org/0009-0008-8976-5363)).

pifira-0.1.0/examples/analyze_localized.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Example: full localized-exposure heat-flux workflow with pifira.
+
+This reproduces the time-varying analysis:
+  moving-window heat input  x  per-instant radiative-weighted effective arc
+  x  axial intersection  ->  heat-input-weighted representative flux.
+
+No data are bundled. Provide your own pressure/temperature CSVs via the
+command line:
+
+    python analyze_localized.py PRESSURE.csv TEMPERATURE.csv
+
+Pressure CSV : columns [idx, datetime, seconds, pressure_bar]
+Temperature  : columns [idx, datetime, seconds, CH1..CH10]
+              with the flame-facing sensors identified by *temperature*
+              (hottest = flame side), not by any label.
+
+Sensor angular layout used here (edit to match your rig):
+    0 deg   = flame centre   (hottest circumferential sensor)
+   +90 deg  = top   (12 o'clock)
+   180 deg  = rear  (opposite the flame)
+   -90 deg  = bottom (6 o'clock)     <-- note: bottom, not a side sensor
+"""
+
+import sys
+import numpy as np
+
+import pifira
+
+
+# ----- rig-specific configuration (edit for your setup) -------------------
+DIAMETER_M = 0.75
+VOLUME_M3 = 0.619
+FLUID = "HEOS::Propane[0.95]&n-Butane[0.05]"
+FILL = 0.70
+CYL_LENGTH_M = 1.150
+
+T_START, T_END = 205.5, 750.0        # closed-vessel window [s]
+T_AMB_C = 35.0
+FLAME_HEIGHT_M = CYL_LENGTH_M * (2 / 3)   # observed flame contact height
+
+# circumferential angle -> channel name (assign from your rig geometry)
+CIRC = {0: "CH3", 90: "CH1", 180: "CH7", -90: "CH5"}
+
+
+def main(pressure_csv, temperature_csv):
+    A_sec = np.pi / 4 * DIAMETER_M**2
+    V_head = np.pi / 24 * DIAMETER_M**3
+
+    t_p, P = pifira.load_pressure_csv(pressure_csv)
+    t_t, dft = pifira.load_temperature_csv(temperature_csv)
+
+    tank = pifira.TankSpec(volume=VOLUME_M3, fluid=FLUID, fill=FILL)
+    m_tot = tank.initial_mass(P[np.searchsorted(t_p, T_START)])
+
+    _, Q = pifira.heat_input_series(t_p, P, tank, window=60, m_tot=m_tot)
+
+    i0, i1 = np.searchsorted(t_p, T_START), np.searchsorted(t_p, T_END)
+    ql, Ql, widths = [], [], []
+    for i in range(i0, i1, 4):
+        Qi = Q[i]
+        if not np.isfinite(Qi):
+            continue
+        idx = np.searchsorted(t_t, t_p[i])
+        angles = list(CIRC.keys())
+        temps = [dft[CIRC[a]].iloc[idx] for a in angles]
+        try:
+            arc = pifira.effective_arc(angles, temps, T_amb_C=T_AMB_C)["arc_deg"]
+        except Exception:
+            continue
+        h_liq = pifira.liquid_height(P[i], m_tot, tank, A_sec, V_head)
+        h_eff = pifira.effective_height(FLAME_HEIGHT_M, h_liq)
+        A = pifira.effective_area(DIAMETER_M, arc, h_eff)
+        ql.append(pifira.heat_flux(Qi, A))
+        Ql.append(Qi)
+        widths.append(arc)
+
+    q_rep = pifira.heat_input_weighted_mean(ql, Ql)
+    print(f"total mass         : {m_tot:.1f} kg")
+    print(f"effective arc (var): {min(widths):.0f}-{max(widths):.0f} deg "
+          f"(mean {np.mean(widths):.0f})")
+    print(f"heat-input weighted: {q_rep:.1f} kW/m^2   <- representative")
+    print(f"simple mean        : {pifira.simple_mean(ql):.1f} kW/m^2")
+    print(f"instantaneous max  : {max(ql):.1f} kW/m^2")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        print(__doc__)
+        sys.exit(1)
+    main(sys.argv[1], sys.argv[2])

pifira-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pifira"
+version = "0.1.0"
+description = "Pressure-based inverse estimation of fire heat flux and effective flame-contact area for pressurized LPG tanks under localized flame exposure"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "Woo-gui-yeon Lee" },
+]
+maintainers = [
+    { name = "Woo-gui-yeon Lee" },
+]
+keywords = [
+    "LPG", "fire safety", "heat flux", "pressure relief valve",
+    "closed-vessel", "pressure-rise method", "BLEVE", "process safety",
+    "thermal engineering", "inverse method",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+    "numpy>=1.20",
+    "scipy>=1.7",
+    "pandas>=1.3",
+    "CoolProp>=6.4",
+]
+
+[project.optional-dependencies]
+plot = ["matplotlib>=3.4"]
+dev = ["pytest>=7.0", "matplotlib>=3.4"]
+
+[project.urls]
+Homepage = "https://github.com/lyullee/pifira"
+Repository = "https://github.com/lyullee/pifira"
+Issues = "https://github.com/lyullee/pifira/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pifira-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pifira-0.1.0/src/pifira/__init__.py

@@ -0,0 +1,60 @@
+"""
+pifira -- Pressure-based Inverse Fire-heat-flux and Radiative-Area analysis
+==========================================================================
+
+A data-agnostic toolkit for estimating fire heat input and effective
+flame-contact area for pressurized LPG tanks under localized (non-engulfing)
+flame exposure, using the closed-vessel pressure-rise method combined with a
+radiative (T^4) weighted angular-temperature inversion.
+
+No experimental data are bundled. Supply your own pressure/temperature series;
+see the ``examples`` directory for the analysis workflow.
+
+Public API
+----------
+Pressure-rise (heat input):
+    TankSpec, internal_energy, liquid_height, heat_input, heat_input_series
+Effective area (inversion):
+    radiative_driving_force, effective_arc, effective_height,
+    effective_area, heat_flux
+Representative value & dimensionless framework:
+    heat_input_weighted_mean, simple_mean, coverage_fraction,
+    normalized_flux, pressurization_number, orientation_factor
+I/O:
+    load_pressure_csv, load_temperature_csv
+"""
+
+from .pressure_rise import (
+    TankSpec,
+    internal_energy,
+    liquid_height,
+    heat_input,
+    heat_input_series,
+)
+from .effective_area import (
+    radiative_driving_force,
+    effective_arc,
+    effective_height,
+    effective_area,
+    heat_flux,
+)
+from .representative import (
+    heat_input_weighted_mean,
+    simple_mean,
+    coverage_fraction,
+    normalized_flux,
+    pressurization_number,
+    orientation_factor,
+)
+from .io import load_pressure_csv, load_temperature_csv
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "TankSpec", "internal_energy", "liquid_height", "heat_input",
+    "heat_input_series", "radiative_driving_force", "effective_arc",
+    "effective_height", "effective_area", "heat_flux",
+    "heat_input_weighted_mean", "simple_mean", "coverage_fraction",
+    "normalized_flux", "pressurization_number", "orientation_factor",
+    "load_pressure_csv", "load_temperature_csv",
+]

pifira-0.1.0/src/pifira/effective_area.py

@@ -0,0 +1,99 @@
+"""
+pifira.effective_area
+=====================
+Inverse estimation of the effective fire-contact area from surface-temperature
+measurements under localized (non-engulfing) flame exposure.
+
+Two directions are treated independently:
+
+* Circumferential -- wall temperatures at several angular positions are
+  weighted by their radiative driving force (Stefan-Boltzmann, T^4) and fit
+  with a Gaussian. The area-preserving equivalent width sqrt(2*pi)*sigma gives
+  the effective arc.
+* Axial -- the flame-contact height intersected with the wetted (liquid) part
+  of the wall; vapour-space wall above the liquid level is excluded because it
+  contributes negligibly to pressurization.
+
+The effective contact area is the product of the effective arc length and the
+effective height. All routines are data-agnostic.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.optimize import curve_fit
+
+KELVIN = 273.15
+
+
+def _gaussian(theta, amp, sigma):
+    return amp * np.exp(-theta**2 / (2.0 * sigma**2))
+
+
+def radiative_driving_force(T_wall_C, T_amb_C=35.0):
+    """Radiative driving force (T_wall^4 - T_amb^4) with temperatures in degC.
+
+    Returns the value in K^4. This is the physically correct weight for a
+    radiation-dominated fire, rather than the plain temperature rise.
+    """
+    return (np.asarray(T_wall_C) + KELVIN) ** 4 - (T_amb_C + KELVIN) ** 4
+
+
+def effective_arc(angles_deg, T_wall_C, T_amb_C=35.0, sigma0=40.0):
+    """Effective circumferential arc [deg] from angular wall temperatures.
+
+    Parameters
+    ----------
+    angles_deg : array-like
+        Circumferential angles of the sensors [deg], flame centre at 0.
+        Include the flame-facing point (0 deg) and off-flame points
+        (e.g. +/-90, 180). At least three distinct angles are needed.
+    T_wall_C : array-like
+        Wall temperatures at those angles [degC] (period-averaged or
+        instantaneous).
+    T_amb_C : float
+        Ambient temperature [degC].
+    sigma0 : float
+        Initial guess for the Gaussian standard deviation [deg].
+
+    Returns
+    -------
+    dict with keys:
+        ``sigma`` : fitted standard deviation [deg]
+        ``arc_deg`` : area-preserving equivalent width sqrt(2*pi)*sigma [deg]
+        ``fwhm_deg`` : full width at half maximum 2.355*sigma [deg]
+    """
+    ang = np.asarray(angles_deg, float)
+    drive = radiative_driving_force(T_wall_C, T_amb_C)
+    if np.max(drive) <= 0:
+        raise ValueError("Non-positive radiative driving force; check inputs.")
+    popt, _ = curve_fit(_gaussian, ang, drive,
+                        p0=[float(np.max(drive)), sigma0], maxfev=10000)
+    sigma = abs(popt[1])
+    return {
+        "sigma": sigma,
+        "arc_deg": np.sqrt(2.0 * np.pi) * sigma,
+        "fwhm_deg": 2.355 * sigma,
+    }
+
+
+def effective_height(flame_height_m, liquid_height_m):
+    """Effective axial height [m] = min(flame contact, wetted liquid).
+
+    Vapour-space wall above the liquid level is excluded.
+    """
+    return min(flame_height_m, liquid_height_m)
+
+
+def effective_area(diameter_m, arc_deg, height_m):
+    """Effective fire-contact area [m^2].
+
+    A_eff = pi * D * (arc/360) * height
+    """
+    arc_length = np.pi * diameter_m * (arc_deg / 360.0)
+    return arc_length * height_m
+
+
+def heat_flux(Q_W, area_m2):
+    """Heat flux [kW/m^2] from heat-input rate [W] and area [m^2]."""
+    return Q_W / area_m2 / 1000.0

pifira-0.1.0/src/pifira/io.py

@@ -0,0 +1,74 @@
+"""
+pifira.io
+=========
+Lightweight loaders for user-supplied CSV files.
+
+No experimental data are bundled with pifira. These helpers parse the two
+common file shapes produced by GL840-type dataloggers, but any pipeline that
+yields ``(time, pressure)`` and ``(time, temperatures)`` arrays works with the
+rest of the library. Bring your own data.
+"""
+
+from __future__ import annotations
+
+from io import StringIO
+
+import numpy as np
+import pandas as pd
+
+_ENCODINGS = ("utf-8-sig", "cp949", "euc-kr", "utf-8", "latin-1")
+
+
+def _read_text(path):
+    for enc in _ENCODINGS:
+        try:
+            return open(path, encoding=enc).read().replace("\r", "")
+        except (UnicodeDecodeError, UnicodeError):
+            continue
+    return open(path, encoding="utf-8", errors="ignore").read().replace("\r", "")
+
+
+def load_pressure_csv(path, time_col=2, value_col=3, header_scan=True):
+    """Load a pressure CSV -> (time_s, pressure).
+
+    By default expects columns [index, datetime, seconds, pressure]; the data
+    body is detected as the first row whose first field is numeric.
+
+    Parameters
+    ----------
+    path : str
+    time_col, value_col : int
+        Column indices for time [s] and pressure.
+    header_scan : bool
+        If True, auto-detect the first numeric data row.
+    """
+    lines = _read_text(path).split("\n")
+    if header_scan:
+        start = next(i for i, ln in enumerate(lines)
+                     if ln.split(",")[0].strip().replace(".", "", 1).isdigit())
+    else:
+        start = 0
+    df = pd.read_csv(StringIO("\n".join(lines[start:])), header=None,
+                    engine="python")
+    t = pd.to_numeric(df.iloc[:, time_col], errors="coerce").values
+    v = pd.to_numeric(df.iloc[:, value_col], errors="coerce").values
+    ok = ~(np.isnan(t) | np.isnan(v))
+    return t[ok], v[ok]
+
+
+def load_temperature_csv(path, n_channels=10, data_start_row=2):
+    """Load a multi-channel temperature CSV -> (time_s, DataFrame[CH1..CHn]).
+
+    Expects columns [index, datetime, seconds, CH1..CHn, ...]. Channel labels
+    in the header (e.g. ``CH3(front-centre)``) are ignored here; positions are
+    assigned by the caller.
+    """
+    lines = _read_text(path).split("\n")
+    names = ["no", "dt", "sec"] + [f"CH{i}" for i in range(1, n_channels + 1)]
+    df = pd.read_csv(StringIO("\n".join(lines[data_start_row:])),
+                    header=None, names=names, engine="python")
+    df = df[pd.to_numeric(df["no"], errors="coerce").notna()].reset_index(drop=True)
+    for ch in [f"CH{i}" for i in range(1, n_channels + 1)]:
+        df[ch] = pd.to_numeric(df[ch], errors="coerce")
+    t = pd.to_numeric(df["sec"], errors="coerce").values
+    return t, df

pifira-0.1.0/src/pifira/pressure_rise.py

@@ -0,0 +1,150 @@
+"""
+pifira.pressure_rise
+====================
+Closed-vessel pressure-rise method for fire heat-input estimation.
+
+The core physics: for a sealed vessel (constant mass and volume) exposed to
+fire before any pressure-relief venting, the incident heat is converted
+entirely into the internal-energy rise of the two-phase contents:
+
+    Q = dU/dt = d/dt ( m_L u_L + m_V u_V )
+
+By tracking total mass and internal energy at each pressure and calling a
+two-phase equilibrium flash, the heat-input rate Q is recovered from a
+measured pressure history alone.
+
+This module is data-agnostic: the caller supplies pressure-time arrays and
+tank/fluid parameters. No experimental data are bundled.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+import numpy as np
+
+try:
+    from CoolProp.CoolProp import PropsSI
+except ImportError as exc:  # pragma: no cover
+    raise ImportError(
+        "pifira requires CoolProp. Install with: pip install CoolProp"
+    ) from exc
+
+
+P_ATM_BAR = 1.01325
+
+
+@dataclass
+class TankSpec:
+    """Geometry and fluid specification for a pressurized tank.
+
+    Parameters
+    ----------
+    volume : float
+        Internal volume [m^3].
+    fluid : str
+        CoolProp fluid string, e.g. ``"HEOS::Propane"`` or a mixture like
+        ``"HEOS::Propane[0.95]&n-Butane[0.05]"``.
+    fill : float
+        Initial liquid fill fraction by volume (0-1).
+    """
+
+    volume: float
+    fluid: str = "HEOS::Propane"
+    fill: float = 0.70
+
+    def initial_mass(self, P_bar_gauge: float) -> float:
+        """Total contents mass [kg] at a given initial gauge pressure."""
+        p = (P_bar_gauge + P_ATM_BAR) * 1e5
+        VL = self.fill * self.volume
+        VV = (1.0 - self.fill) * self.volume
+        rho_L = PropsSI("D", "P", p, "Q", 0, self.fluid)
+        rho_V = PropsSI("D", "P", p, "Q", 1, self.fluid)
+        return VL * rho_L + VV * rho_V
+
+
+def internal_energy(P_bar_gauge: float, m_tot: float, tank: TankSpec) -> float:
+    """Two-phase internal energy U [J] under closed-vessel constraint.
+
+    The liquid/vapour split is redistributed at each pressure so that total
+    mass ``m_tot`` and total volume ``tank.volume`` are conserved.
+    """
+    p = (P_bar_gauge + P_ATM_BAR) * 1e5
+    rho_L = PropsSI("D", "P", p, "Q", 0, tank.fluid)
+    rho_V = PropsSI("D", "P", p, "Q", 1, tank.fluid)
+    u_L = PropsSI("U", "P", p, "Q", 0, tank.fluid)
+    u_V = PropsSI("U", "P", p, "Q", 1, tank.fluid)
+    V_L = (m_tot - tank.volume * rho_V) / (rho_L - rho_V)
+    return V_L * rho_L * u_L + (tank.volume - V_L) * rho_V * u_V
+
+
+def liquid_height(P_bar_gauge: float, m_tot: float, tank: TankSpec,
+                  cross_section: float, head_volume: float = 0.0) -> float:
+    """Dynamic liquid height [m] in the cylindrical section.
+
+    Parameters
+    ----------
+    cross_section : float
+        Horizontal cross-sectional area of the cylinder [m^2].
+    head_volume : float
+        Volume of the bottom head below the cylinder [m^3] (default 0).
+    """
+    p = (P_bar_gauge + P_ATM_BAR) * 1e5
+    rho_L = PropsSI("D", "P", p, "Q", 0, tank.fluid)
+    rho_V = PropsSI("D", "P", p, "Q", 1, tank.fluid)
+    V_L = (m_tot - tank.volume * rho_V) / (rho_L - rho_V)
+    return max(0.0, (V_L - head_volume) / cross_section)
+
+
+def heat_input(P1_bar: float, P2_bar: float, dt: float,
+               tank: TankSpec, m_tot: float | None = None) -> float:
+    """Average heat-input rate Q [W] over a closed-vessel window.
+
+    Q = (U(P2) - U(P1)) / dt, with mass fixed at its initial value.
+
+    Parameters
+    ----------
+    P1_bar, P2_bar : float
+        Gauge pressures at the start and end of the window [bar].
+    dt : float
+        Duration of the window [s].
+    tank : TankSpec
+    m_tot : float, optional
+        Total mass [kg]. If omitted, computed from ``P1_bar``.
+    """
+    if m_tot is None:
+        m_tot = tank.initial_mass(P1_bar)
+    dU = internal_energy(P2_bar, m_tot, tank) - internal_energy(P1_bar, m_tot, tank)
+    return dU / dt
+
+
+def heat_input_series(t: np.ndarray, P_bar: np.ndarray, tank: TankSpec,
+                      window: int = 60, m_tot: float | None = None
+                      ) -> tuple[np.ndarray, np.ndarray]:
+    """Instantaneous heat-input rate Q(t) [W] via a moving-window slope.
+
+    A local linear fit of pressure over +/- ``window`` samples gives dP/dt,
+    which is converted to dU/dt through the equation of state.
+
+    Returns
+    -------
+    t_out, Q_out : np.ndarray
+        Times and instantaneous heat-input rates (NaN where the window
+        does not fit).
+    """
+    t = np.asarray(t, float)
+    P_bar = np.asarray(P_bar, float)
+    if m_tot is None:
+        m_tot = tank.initial_mass(P_bar[0])
+
+    Q = np.full(len(P_bar), np.nan)
+    for i in range(len(P_bar)):
+        if i < window or i + window >= len(P_bar):
+            continue
+        a, b = np.polyfit(t[i - window:i + window], P_bar[i - window:i + window], 1)
+        Pc = a * t[i] + b
+        dUdP = (internal_energy(Pc + 0.05, m_tot, tank)
+                - internal_energy(Pc - 0.05, m_tot, tank)) / 0.1
+        Q[i] = dUdP * a
+    return t, Q

pifira-0.1.0/src/pifira/representative.py

@@ -0,0 +1,64 @@
+"""
+pifira.representative
+=====================
+Representative heat-flux estimators and the dimensionless framework.
+
+For a time-varying heat flux q(t) driven by a time-varying heat input Q(t),
+the physically meaningful design value weights instants by how much heat
+actually entered the vessel (a heat-input-weighted mean), because fire safety
+is governed by the high-heat-input instants.
+
+The dimensionless framework expresses localized-exposure heat flux in a form
+independent of tank size, fill level and orientation.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+Q_ENGULF_DEFAULT = 100.0  # reference full-engulfment heat flux [kW/m^2]
+
+
+def heat_input_weighted_mean(q, Q):
+    """Heat-input-weighted mean flux: sum(q*Q) / sum(Q).
+
+    Parameters
+    ----------
+    q : array-like
+        Instantaneous heat flux [kW/m^2].
+    Q : array-like
+        Instantaneous heat-input rate [W] (weights).
+    """
+    q = np.asarray(q, float)
+    Q = np.asarray(Q, float)
+    mask = np.isfinite(q) & np.isfinite(Q)
+    return float(np.sum(q[mask] * Q[mask]) / np.sum(Q[mask]))
+
+
+def simple_mean(q):
+    """Plain time-average of instantaneous flux [kW/m^2]."""
+    q = np.asarray(q, float)
+    return float(np.nanmean(q))
+
+
+# --------------------------------------------------------------------------
+# Dimensionless framework
+# --------------------------------------------------------------------------
+def coverage_fraction(A_eff, A_wetted):
+    """phi = A_eff / A_wetted  (fire coverage fraction; 1 = full engulfment)."""
+    return A_eff / A_wetted
+
+
+def normalized_flux(q_local, q_engulf=Q_ENGULF_DEFAULT):
+    """q* = q_local / q_engulf (dimensionless heat flux)."""
+    return q_local / q_engulf
+
+
+def pressurization_number(dPdt, volume, Q_engulf_W):
+    """Pi = (dP/dt * V) / Q_engulf (dimensionless pressurization rate)."""
+    return (dPdt * volume) / Q_engulf_W
+
+
+def orientation_factor(liquid_height_m, diameter_m):
+    """Omega = h_liq / D (orientation factor; vertical > 1, horizontal < 1)."""
+    return liquid_height_m / diameter_m

pifira-0.1.0/src/pifira.egg-info/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: pifira
+Version: 0.1.0
+Summary: Pressure-based inverse estimation of fire heat flux and effective flame-contact area for pressurized LPG tanks under localized flame exposure
+Author: Woo-gui-yeon Lee
+Maintainer: Woo-gui-yeon Lee
+License: MIT
+Project-URL: Homepage, https://github.com/lyullee/pifira
+Project-URL: Repository, https://github.com/lyullee/pifira
+Project-URL: Issues, https://github.com/lyullee/pifira/issues
+Keywords: LPG,fire safety,heat flux,pressure relief valve,closed-vessel,pressure-rise method,BLEVE,process safety,thermal engineering,inverse method
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: pandas>=1.3
+Requires-Dist: CoolProp>=6.4
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.4; extra == "plot"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: matplotlib>=3.4; extra == "dev"
+Dynamic: license-file
+
+# pifira
+
+**P**ressure-based **I**nverse **F**ire-heat-flux and **R**adiative-**A**rea analysis
+
+A data-agnostic Python toolkit for estimating **fire heat input** and
+**effective flame-contact area** for pressurized LPG tanks under **localized
+(non-engulfing) flame exposure**.
+
+pifira combines the **closed-vessel pressure-rise method** (heat input from a
+measured pressure history) with a **radiative (T?? weighted angular-temperature
+inversion** (effective fire-contact area from surface temperatures), and
+provides a **dimensionless framework** that unifies localized and
+full-engulfment exposure across tank sizes, fill levels and orientations.
+
+> **No experimental data are bundled with this package.** All routines operate
+> on user-supplied arrays. See [Data sources](#data-sources) for how to obtain
+> the public validation datasets.
+
+---
+
+## Why
+
+Most published fire-engulfment work assumes *uniform, full engulfment* of
+*horizontal* tanks. Small **vertical** LPG tanks under *localized* flame
+exposure are under-studied, and standards (API 521, KGS) do not cover heat-input
+estimation for this case. pifira addresses this by inverting a measured
+pressure rise for heat input and a measured angular temperature distribution
+for the effective contact area ??without assuming full engulfment.
+
+## Installation
+
+```bash
+pip install pifira
+```
+
+Dependencies: `numpy`, `scipy`, `pandas`, `CoolProp`. Optional plotting extras:
+
+```bash
+pip install "pifira[plot]"
+```
+
+## Quick start
+
+```python
+import numpy as np
+import pifira
+
+# 1. Define the tank (volume, fluid, fill fraction)
+tank = pifira.TankSpec(
+    volume=0.619,
+    fluid="HEOS::Propane[0.95]&n-Butane[0.05]",
+    fill=0.70,
+)
+
+# 2. Heat input from a pressure history (bring your own arrays)
+#    t [s], P [bar gauge], closed-vessel window before PRV opens
+Q_W = pifira.heat_input(P1_bar=10.83, P2_bar=16.30, dt=544.5, tank=tank)
+print(Q_W / 1000, "kW")
+
+# 3. Effective contact area from angular wall temperatures
+#    flame centre at 0 deg; off-flame points at +/-90, 180
+res = pifira.effective_arc(
+    angles_deg=[0, 90, 180, -90],
+    T_wall_C=[271, 49, 39, 46],   # period-averaged wall temps
+    T_amb_C=35.0,
+)
+arc_deg = res["arc_deg"]          # area-preserving equivalent width
+
+h_eff = pifira.effective_height(flame_height_m=0.767, liquid_height_m=0.885)
+A_eff = pifira.effective_area(diameter_m=0.75, arc_deg=arc_deg, height_m=h_eff)
+
+# 4. Heat flux
+print(pifira.heat_flux(Q_W, A_eff), "kW/m^2")
+```
+
+A full time-varying workflow (moving-window heat input, per-instant effective
+arc, heat-input-weighted representative value) is in
+[`examples/analyze_localized.py`](examples/analyze_localized.py).
+
+## Public API
+
+| Area | Functions |
+|---|---|
+| Heat input (pressure-rise) | `TankSpec`, `internal_energy`, `liquid_height`, `heat_input`, `heat_input_series` |
+| Effective area (inversion) | `radiative_driving_force`, `effective_arc`, `effective_height`, `effective_area`, `heat_flux` |
+| Representative value | `heat_input_weighted_mean`, `simple_mean` |
+| Dimensionless framework | `coverage_fraction` (?), `normalized_flux` (q\*), `pressurization_number` (?), `orientation_factor` (Ω) |
+| I/O | `load_pressure_csv`, `load_temperature_csv` |
+
+## Method summary
+
+1. **Closed-vessel pressure-rise.** Before pressure-relief venting, incident
+   heat converts entirely into the contents' internal-energy rise:
+   `Q = dU/dt = d/dt(m_L u_L + m_V u_V)`. Mass and volume are fixed; the
+   liquid/vapour split is re-flashed at each pressure (CoolProp).
+
+2. **Radiative (T?? angular inversion.** Radiative flux scales with
+   `T_wall????T_amb?? (Stefan-Boltzmann). Angular wall temperatures are fit
+   with a Gaussian; the area-preserving equivalent width `??2?)·?` gives the
+   effective arc.
+
+3. **Axial intersection.** Effective height = min(flame contact height, wetted
+   liquid height). Vapour-space wall is excluded.
+
+4. **Representative value.** Heat-input-weighted mean `Σ(q·Q)/ΣQ`, since fire
+   safety is governed by high-heat-input instants.
+
+5. **Dimensionless framework.** ? (coverage), q\* (normalized flux), ?
+   (pressurization), Ω (orientation) unify localized/full and vertical/horizontal.
+
+## Data sources
+
+pifira ships **no data**. The public datasets used to validate the method in
+the associated study are available from their original publications:
+
+- **Moodie, K., Billinge, K., Cutler, D.P. (1988).** *Fire Engulfment of LPG
+  Storage Tanks.* IChemE Symposium Series No. 93, pp. 87??06. Institution of
+  Chemical Engineers. ??pressure history (Fig. 5) and initial conditions /
+  heat fluxes (Tables 1??). Obtain from IChemE or a library.
+
+- **Birk, A.M., Poirier, D., Davison, C. (2006).** *On the thermal rupture of
+  1.9 m³ propane pressure vessels with defects in their thermal protection
+  system.* Journal of Loss Prevention in the Process Industries **19**(6),
+  582??97. https://doi.org/10.1016/j.jlp.2006.02.002 ??pressure (Fig. 8) and
+  lading-temperature stratification (Fig. 10) for the 25% partial-engulfment
+  test. Obtain from the publisher.
+
+To reproduce the validation, digitize the relevant figures from the original
+papers and pass the values to the pifira API. Digitized values are **not**
+redistributed here.
+
+Experimental data from the authors' own fire tests are **not** included and are
+reported separately.
+
+## Citing
+
+If you use pifira, please cite it via [`CITATION.cff`](CITATION.cff) and the
+archived release DOI (Zenodo). See the repository release page for the DOI.
+
+## License
+
+MIT ??see [LICENSE](LICENSE).
+
+## Author
+
+Woo-gui-yeon Lee, Korea Gas Safety Corporation (KGS), AI Safety Research Team
+([ORCID 0009-0008-8976-5363](https://orcid.org/0009-0008-8976-5363)).

pifira-0.1.0/src/pifira.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+CITATION.cff
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+examples/analyze_localized.py
+src/pifira/__init__.py
+src/pifira/effective_area.py
+src/pifira/io.py
+src/pifira/pressure_rise.py
+src/pifira/representative.py
+src/pifira.egg-info/PKG-INFO
+src/pifira.egg-info/SOURCES.txt
+src/pifira.egg-info/dependency_links.txt
+src/pifira.egg-info/requires.txt
+src/pifira.egg-info/top_level.txt
+tests/test_pifira.py

pifira-0.1.0/src/pifira.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pifira-0.1.0/src/pifira.egg-info/requires.txt

@@ -0,0 +1,11 @@
+numpy>=1.20
+scipy>=1.7
+pandas>=1.3
+CoolProp>=6.4
+
+[dev]
+pytest>=7.0
+matplotlib>=3.4
+
+[plot]
+matplotlib>=3.4

pifira-0.1.0/src/pifira.egg-info/top_level.txt

@@ -0,0 +1 @@
+pifira

pifira-0.1.0/tests/test_pifira.py

@@ -0,0 +1,76 @@
+"""
+Tests for pifira. These are data-free: they check physical consistency and
+known analytic properties, not any bundled experimental dataset.
+"""
+
+import numpy as np
+import pytest
+
+import pifira
+
+
+def test_tankspec_mass_positive():
+    tank = pifira.TankSpec(volume=0.619, fluid="HEOS::Propane", fill=0.70)
+    m = tank.initial_mass(10.0)
+    assert m > 0
+    # 70% of 0.619 m^3 of liquid propane is order 200-300 kg
+    assert 150 < m < 350
+
+
+def test_heat_input_positive_for_rising_pressure():
+    tank = pifira.TankSpec(volume=0.619, fluid="HEOS::Propane", fill=0.70)
+    Q = pifira.heat_input(P1_bar=10.0, P2_bar=15.0, dt=500.0, tank=tank)
+    assert Q > 0  # heating raises pressure -> positive heat input
+
+
+def test_internal_energy_monotonic_in_pressure():
+    tank = pifira.TankSpec(volume=0.619, fluid="HEOS::Propane", fill=0.70)
+    m = tank.initial_mass(10.0)
+    U1 = pifira.internal_energy(10.0, m, tank)
+    U2 = pifira.internal_energy(15.0, m, tank)
+    assert U2 > U1
+
+
+def test_radiative_driving_force_t4():
+    # doubling absolute temperature raises driving force ~16x (minus ambient)
+    d1 = pifira.radiative_driving_force(0.0, T_amb_C=-273.15)   # 273.15 K
+    d2 = pifira.radiative_driving_force(273.15, T_amb_C=-273.15)  # 546.3 K
+    assert d2 / d1 == pytest.approx(16.0, rel=0.05)
+
+
+def test_effective_arc_symmetric_gaussian():
+    # a symmetric bell centred at 0 should recover a finite equivalent width
+    angles = [0, 90, 180, -90]
+    temps = [271, 49, 39, 46]
+    res = pifira.effective_arc(angles, temps, T_amb_C=35.0)
+    assert res["sigma"] > 0
+    assert res["arc_deg"] == pytest.approx(np.sqrt(2 * np.pi) * res["sigma"])
+    assert res["fwhm_deg"] == pytest.approx(2.355 * res["sigma"])
+
+
+def test_effective_height_takes_minimum():
+    assert pifira.effective_height(0.767, 0.885) == 0.767
+    assert pifira.effective_height(1.2, 0.885) == 0.885
+
+
+def test_effective_area_and_flux():
+    A = pifira.effective_area(diameter_m=0.75, arc_deg=90.0, height_m=0.767)
+    assert A > 0
+    q = pifira.heat_flux(16800.0, A)  # 16.8 kW over A
+    assert q > 0
+
+
+def test_weighted_mean_biases_toward_high_Q():
+    q = [30.0, 70.0]
+    Q_equal = [1.0, 1.0]
+    Q_high = [1.0, 9.0]
+    m_eq = pifira.heat_input_weighted_mean(q, Q_equal)
+    m_hi = pifira.heat_input_weighted_mean(q, Q_high)
+    assert m_eq == pytest.approx(50.0)
+    assert m_hi > m_eq  # weighting toward the high-flux instant
+
+
+def test_dimensionless_definitions():
+    assert pifira.coverage_fraction(0.5, 2.0) == 0.25
+    assert pifira.normalized_flux(50.0, q_engulf=100.0) == 0.5
+    assert pifira.orientation_factor(0.89, 0.75) == pytest.approx(1.187, rel=1e-3)