🥮 mooncakes.io

moonbit-chemreport

A MoonBit-native report layer for chemical engineering calculations.

chemistry
report
engineering
markdown
html
json
moon add lllg123/moonbit-chemreport@0.3.0
Download zip
Author
Version
0.3.0
License
Apache-2.0
Repository
Last updated
1 hour ago
Downloads
4
README

#moonbit-chemreport

moonbit-chemreport is a MoonBit-native reporting and engineering calculation layer for process engineering software. It turns assumptions, inputs, formulas, balances, results, warnings, sources, and scenario sweeps into one deterministic model for people, scripts, and CI.

#Project positioning

The package is an integration layer, not a process simulator or a thermodynamic property database. It is designed for reactor, distillation, absorption, heat-exchanger, pump, and mass-balance packages that need reproducible calculation evidence and consistent exports.

#Core capabilities

  • Typed ChemReport model with validation and quality gates.
  • Markdown, HTML, JSON, CSV, and table exports from shared data.
  • Unit-aware quantities with dimensional compatibility checks and temperature validation.
  • Material and energy balance closure, recovery, residual, and limiting-component analysis.
  • Reactor, distillation, heat-exchanger, pump, pressure-drop, and safety-review calculations.
  • Statistical summaries, percentiles, moving averages, control limits, and deterministic sweeps.
  • Batch execution, recipe scaling, process scheduling, maintenance windows, and workflow audit trails.
  • Stream inventories, equipment screening, reaction kinetics, mass transfer, heat transfer, risk registers, and environmental inventories.
  • Data-quality profiles, delimited import validation, cost models, uncertainty propagation, and rule-driven acceptance gates.

#Quick start

moon update
moon check --target all --deny-warn
moon test --target all --deny-warn
moon run cmd/main

The package has no runtime dependency outside the MoonBit standard toolchain. The CLI prints a Markdown preview followed by the same report encoded as JSON.

#CLI

moon run cmd/main

The CLI is intentionally small: it exercises the public package as a consumer would, keeping the example aligned with the library API.

#Architecture

AreaFilesResponsibility
Domain modelmoonbit-chemreport.mbtReport records, enums, and constructors
Exportersmarkdown_export.mbt, html_export.mbt, json_export.mbt, table.mbtDeterministic human and machine output
Engineering mathunits.mbt, balance.mbt, process_calculations.mbtUnits, balances, equipment and safety calculations
Scenario analysisanalytics.mbt, scenario_engine.mbtStatistics, control limits, sweeps, and sensitivity
Process modelsstreams.mbt, equipment_design.mbt, reactor_kinetics.mbt, mass_transfer.mbt, heat_transfer.mbtInventory, sizing, kinetics, contacting and thermal screening
Operationsbatch_operations.mbt, process_schedule.mbt, workflow.mbt, control_system.mbtRecipes, calendars, review state, alarms and control loops
Quality and riskvalidate.mbt, quality.mbt, diagnostics.mbt, validation_rules.mbt, data_quality.mbt, risk_analysis.mbtEvidence checks, risk ranking, import quality and acceptance gates
Economics and sustainabilitycost_model.mbt, uncertainty.mbt, environmental.mbtCost, uncertainty, emissions and reduction scenarios
Integrationreport_pipeline.mbt, benchmark.mbt, data_import.mbtBuilders, batches, reproducible measurements and delimited data
Integrationreport_pipeline.mbt, benchmark.mbtBuilders, batches, and reproducible export measurements

Public concrete types live in the root package so downstream packages can construct and inspect them without depending on internal implementation paths.

#Benchmark

The benchmark is executable and measures the bytes produced by all three primary exporters over a chosen number of iterations:

let result = benchmark_exports([example_chemreport()], 100)
println(result.to_markdown())

It reports Markdown, HTML, JSON, total, and average bytes. This is an export-size proxy, not a claim about a particular machine's wall-clock performance; run it in the target CI environment when comparing revisions.

The checked-in CLI benchmark was run with 100 iterations on one example report and produced 349,200 Markdown bytes, 477,100 HTML bytes, and 404,200 JSON bytes (1,230,500 bytes total; 12,305 bytes/report). Reproduce it with moon run cmd/benchmark.

#Testing

The library currently contains more than 8,600 lines of formatted production MoonBit source. Tests cover public behavior and boundary cases including incompatible units, absolute-zero validation, balance tolerance, empty and singleton statistics, control-limit classification, malformed delimited rows, batch scaling, risk ranking, reactor gates, HTML/Markdown/CSV escaping, quality gates, and benchmark reproducibility.

moon test --target all --deny-warn
moon test --target native --enable-coverage
moon coverage report -f summary
moon coverage analyze

#CI

.github/workflows/check.yml runs on Ubuntu, macOS, and Windows. Each job installs the current stable MoonBit CLI, updates dependencies, checks all targets, runs tests including native tests and coverage, verifies formatting and generated interfaces, and exercises the CLI.

moon info output is checked into the change review so accidental public API changes remain visible.

#License

Apache-2.0. See LICENSE.

#
AbsorberDesign

source
pub struct AbsorberDesign {
  gas_flow_mol_h : Float
  liquid_flow_mol_h : Float
  inlet_gas_fraction : Float
  outlet_gas_fraction : Float
  equilibrium : EquilibriumLine
  overall_kya_h : Float
}

#
AbsorberDesign::height

source
fn AbsorberDesign::height(self : AbsorberDesign, htu_m : Float) -> Float

#
AbsorberDesign::liquid_to_gas

source
fn AbsorberDesign::liquid_to_gas(self : AbsorberDesign) -> Float

#
AbsorberDesign::ntu

source
fn AbsorberDesign::ntu(self : AbsorberDesign) -> Float

#
AbsorberDesign::removal_fraction

source
fn AbsorberDesign::removal_fraction(self : AbsorberDesign) -> Float

#
AbsorberDesign::solute_load_mol_h

source
fn AbsorberDesign::solute_load_mol_h(self : AbsorberDesign) -> Float

#
Alarm

source
pub struct Alarm {
  code : String
  tag : String
  value : Float
  low : Float
  high : Float
  state : AlarmState
  message : String
} derive(Eq, 
Debug)

#
Alarm::acknowledge

source
fn Alarm::acknowledge(self : Alarm) -> Alarm

#
Alarm::is_active

source
fn Alarm::is_active(self : Alarm) -> Bool

#
Alarm::is_normal

source
fn Alarm::is_normal(self : Alarm) -> Bool

#
Alarm::severity

source
fn Alarm::severity(self : Alarm) -> String

#
Alarm::shelve

source
fn Alarm::shelve(self : Alarm) -> Alarm

#
AlarmBoard

source
pub struct AlarmBoard {
  alarms : Array[Alarm]
  updated_at : String
} derive(Eq, 
Debug)

#
AlarmBoard::acknowledge_all

source
fn AlarmBoard::acknowledge_all(self : AlarmBoard) -> AlarmBoard

#
AlarmBoard::active_count

source
fn AlarmBoard::active_count(self : AlarmBoard) -> Int

#
AlarmBoard::count

source
fn AlarmBoard::count(self : AlarmBoard) -> Int

#
AlarmBoard::normal_count

source
fn AlarmBoard::normal_count(self : AlarmBoard) -> Int

#
AlarmBoard::shelve_code

source
fn AlarmBoard::shelve_code(self : AlarmBoard, code : String) -> AlarmBoard

#
AlarmBoard::table

source
fn AlarmBoard::table(self : AlarmBoard) -> ReportTable

#
AlarmState

source
pub enum AlarmState {
  NormalAlarm
  Acknowledged
  Shelved
  ActiveAlarm
} derive(Eq, 
Debug)

#
AntoineCorrelation

source
pub struct AntoineCorrelation {
  a : Float
  b : Float
  c : Float
  minimum_c : Float
  maximum_c : Float
}

#
AntoineCorrelation::log10_pressure

source
fn AntoineCorrelation::log10_pressure(self : AntoineCorrelation, temperature_c : Float) -> Float

#
AntoineCorrelation::pressure_kpa

source
fn AntoineCorrelation::pressure_kpa(self : AntoineCorrelation, temperature_c : Float) -> Float

#
AntoineCorrelation::valid

source
fn AntoineCorrelation::valid(self : AntoineCorrelation, temperature_c : Float) -> Bool

#
ArrheniusModel

source
pub struct ArrheniusModel {
  pre_exponential : Float
  activation_energy_kj : Float
  reference_temperature_k : Float
}

Reaction-kinetics and reactor-screening calculations.

#
ArrheniusModel::rate_constant

source
fn ArrheniusModel::rate_constant(self : ArrheniusModel, temperature_k : Float) -> Float

#
ArrheniusModel::relative_rate

source
fn ArrheniusModel::relative_rate(self : ArrheniusModel, temperature_k : Float) -> Float

#
Assumption

source
pub struct Assumption {
  statement : String
  impact : String
} derive(Eq, 
Debug)

#
AuditEvent

source
pub struct AuditEvent {
  timestamp : String
  actor : String
  action : String
  object : String
} derive(Eq, 
Debug)

#
AuditTrail

source
pub struct AuditTrail {
  events : Array[AuditEvent]
} derive(Eq, 
Debug)

#
AuditTrail::actions

source
fn AuditTrail::actions(self : AuditTrail) -> Array[String]

#
AuditTrail::actors

source
fn AuditTrail::actors(self : AuditTrail) -> Array[String]

#
AuditTrail::append

source
fn AuditTrail::append(self : AuditTrail, event : AuditEvent) -> AuditTrail

#
AuditTrail::count

source
fn AuditTrail::count(self : AuditTrail) -> Int

#
AuditTrail::to_markdown

source
fn AuditTrail::to_markdown(self : AuditTrail) -> String

#
AuditTrail::to_table

source
fn AuditTrail::to_table(self : AuditTrail) -> ReportTable

#
BatchCharge

source
pub struct BatchCharge {
  material : String
  mass_kg : Float
  purity : Float
}

Batch execution primitives for repeatable chemical-process campaigns.

#
BatchCharge::active_mass

source
fn BatchCharge::active_mass(self : BatchCharge) -> Float

#
BatchCharge::valid

source
fn BatchCharge::valid(self : BatchCharge) -> Bool

#
BatchPlan

source
pub struct BatchPlan {
  recipe : BatchRecipe
  steps : Array[BatchStep]
  cleaning_hours : Float
  setup_hours : Float
}

#
BatchPlan::cycle_hours

source
fn BatchPlan::cycle_hours(self : BatchPlan) -> Float

#
BatchPlan::process_hours

source
fn BatchPlan::process_hours(self : BatchPlan) -> Float

#
BatchPlan::safe

source
fn BatchPlan::safe(self : BatchPlan, max_temperature : Float, max_pressure : Float) -> Bool

#
BatchPlan::throughput

source
fn BatchPlan::throughput(self : BatchPlan) -> Float

#
BatchRecipe

source
pub struct BatchRecipe {
  name : String
  target_kg : Float
  charges : Array[BatchCharge]
  hold_hours : Float
  yield_fraction : Float
}

#
BatchRecipe::active_input

source
fn BatchRecipe::active_input(self : BatchRecipe) -> Float

#
BatchRecipe::conversion

source
fn BatchRecipe::conversion(self : BatchRecipe) -> Float

#
BatchRecipe::expected_output

source
fn BatchRecipe::expected_output(self : BatchRecipe) -> Float

#
BatchRecipe::input_mass

source
fn BatchRecipe::input_mass(self : BatchRecipe) -> Float

#
BatchRecipe::valid

source
fn BatchRecipe::valid(self : BatchRecipe) -> Bool

#
BatchRecord

source
pub struct BatchRecord {
  id : String
  plan_name : String
  started_at : String
  finished_at : String
  output_kg : Float
  scrap_kg : Float
  accepted : Bool
}

#
BatchRecord::scrap_rate

source
fn BatchRecord::scrap_rate(self : BatchRecord) -> Float

#
BatchRecord::total_mass

source
fn BatchRecord::total_mass(self : BatchRecord) -> Float

#
BatchRecord::yield_rate

source
fn BatchRecord::yield_rate(self : BatchRecord, input_kg : Float) -> Float

#
BatchReport

source
pub struct BatchReport {
  reports : Array[ChemReport]
  labels : Array[String]
} derive(Eq, 
Debug)

#
BatchReport::all_formats

source
fn BatchReport::all_formats(self : BatchReport) -> Array[ExportBundle]

#
BatchReport::benchmark

source
fn BatchReport::benchmark(self : BatchReport, iterations : Int) -> BenchmarkResult

#
BatchReport::count

source
fn BatchReport::count(self : BatchReport) -> Int

#
BatchReport::critical_count

source
fn BatchReport::critical_count(self : BatchReport) -> Int

#
BatchReport::invalid_count

source
fn BatchReport::invalid_count(self : BatchReport) -> Int

#
BatchReport::result_count

source
fn BatchReport::result_count(self : BatchReport) -> Int

#
BatchReport::summary

source
fn BatchReport::summary(self : BatchReport) -> String

#
BatchReport::to_json

source
fn BatchReport::to_json(self : BatchReport) -> String

#
BatchReport::to_markdown

source
fn BatchReport::to_markdown(self : BatchReport) -> String

#
BatchReport::valid_count

source
fn BatchReport::valid_count(self : BatchReport) -> Int

#
BatchReport::warning_count

source
fn BatchReport::warning_count(self : BatchReport) -> Int

#
BatchStep

source
pub struct BatchStep {
  name : String
  duration_hours : Float
  temperature_c : Float
  pressure_bar : Float
  agitation_rpm : Float
}

#
BatchStep::safe

source
fn BatchStep::safe(self : BatchStep, max_temperature : Float, max_pressure : Float) -> Bool

#
BenchmarkResult

source
pub struct BenchmarkResult {
  iterations : Int
  reports : Int
  markdown_bytes : Int
  html_bytes : Int
  json_bytes : Int
} derive(Eq, 
Debug)

#
BenchmarkResult::average_bytes

source
fn BenchmarkResult::average_bytes(self : BenchmarkResult) -> Float

#
BenchmarkResult::to_markdown

source
fn BenchmarkResult::to_markdown(self : BenchmarkResult) -> String

#
BenchmarkResult::total_bytes

source
fn BenchmarkResult::total_bytes(self : BenchmarkResult) -> Int

#
BowTie

source
pub struct BowTie {
  hazard : String
  threats : Array[String]
  preventive : Array[Safeguard]
  mitigative : Array[Safeguard]
}

#
BowTie::defended

source
fn BowTie::defended(self : BowTie) -> Bool

#
BowTie::mitigation_count

source
fn BowTie::mitigation_count(self : BowTie) -> Int

#
BowTie::prevention_count

source
fn BowTie::prevention_count(self : BowTie) -> Int

#
Candidate

source
pub struct Candidate {
  name : String
  variables : Array[Float]
  score : Float
} derive(Eq, 
Debug)

#
Candidate::dimension

source
fn Candidate::dimension(self : Candidate) -> Int

#
Candidate::is_finite

source
fn Candidate::is_finite(self : Candidate) -> Bool

#
Candidate::variable

source
fn Candidate::variable(self : Candidate, index : Int) -> Float?

#
ChemReport

source
pub struct ChemReport {
  metadata : ReportMetadata
  summary : String
  assumptions : Array[Assumption]
  inputs : Array[InputValue]
  formulas : Array[FormulaNote]
  results : Array[ResultValue]
  warnings : Array[WarningNote]
  sources : Array[SourceRef]
  sections : Array[ReportSection]
  tags : Array[String]
} derive(Eq, 
Debug)

#
ChemReport::diagnostics

source
fn ChemReport::diagnostics(self : ChemReport) -> DiagnosticReport

#
ChemReport::export_table

source
fn ChemReport::export_table(self : ChemReport) -> ReportTable

#
ChemReport::format

source
fn ChemReport::format(self : ChemReport, format : String) -> String

#
ChemReport::format_names

source
fn ChemReport::format_names(_self : ChemReport) -> Array[String]

#
ChemReport::has_blocking_diagnostics

source
fn ChemReport::has_blocking_diagnostics(self : ChemReport) -> Bool

#
ChemReport::has_tag

source
fn ChemReport::has_tag(self : ChemReport, tag : String) -> Bool

#
ChemReport::is_publish_ready

source
fn ChemReport::is_publish_ready(self : ChemReport) -> Bool

#
ChemReport::render_all_formats

source
fn ChemReport::render_all_formats(self : ChemReport) -> ExportBundle

#
ChemReport::result_names

source
fn ChemReport::result_names(self : ChemReport) -> Array[String]

#
ChemReport::source_table

source
fn ChemReport::source_table(self : ChemReport) -> ReportTable

#
ChemReport::to_html

source
fn ChemReport::to_html(self : ChemReport) -> String

#
ChemReport::to_json

source
fn ChemReport::to_json(self : ChemReport) -> String

#
ChemReport::to_markdown

source
fn ChemReport::to_markdown(self : ChemReport) -> String

#
ChemReport::validate

source
fn ChemReport::validate(self : ChemReport) -> Array[ValidationIssue]

#
ChemReport::warning_count

source
fn ChemReport::warning_count(self : ChemReport, severity : WarningSeverity) -> Int

#
ChemReport::warning_table

source
fn ChemReport::warning_table(self : ChemReport) -> ReportTable

#
ChemReport::with_metadata

source
fn ChemReport::with_metadata(self : ChemReport, metadata : ReportMetadata) -> ChemReport

#
ChemReport::with_results

source
fn ChemReport::with_results(self : ChemReport, results : Array[ResultValue]) -> ChemReport

#
ChemReport::with_sources

source
fn ChemReport::with_sources(self : ChemReport, sources : Array[SourceRef]) -> ChemReport

#
ChemReport::with_summary

source
fn ChemReport::with_summary(self : ChemReport, summary : String) -> ChemReport

#
ChemReport::with_tag

source
fn ChemReport::with_tag(self : ChemReport, tag : String) -> ChemReport

#
ChemReport::with_warnings

source
fn ChemReport::with_warnings(self : ChemReport, warnings : Array[WarningNote]) -> ChemReport

#
ChemReport::without_critical_warnings

source
fn ChemReport::without_critical_warnings(self : ChemReport) -> ChemReport

#
ChemicalPropertySet

source
pub struct ChemicalPropertySet {
  name : String
  molecular_weight : Float
  density : LinearProperty
  viscosity : LinearProperty
  heat_capacity : LinearProperty
  vapor_pressure : AntoineCorrelation
}

#
ChemicalPropertySet::density_at

source
fn ChemicalPropertySet::density_at(self : ChemicalPropertySet, temperature_c : Float) -> Float

#
ChemicalPropertySet::heat_capacity_at

source
fn ChemicalPropertySet::heat_capacity_at(self : ChemicalPropertySet, temperature_c : Float) -> Float

#
ChemicalPropertySet::mass_to_moles

source
fn ChemicalPropertySet::mass_to_moles(self : ChemicalPropertySet, mass_kg : Float) -> Float

#
ChemicalPropertySet::moles_to_mass

source
fn ChemicalPropertySet::moles_to_mass(self : ChemicalPropertySet, moles : Float) -> Float

#
ChemicalPropertySet::phase_at

source
fn ChemicalPropertySet::phase_at(self : ChemicalPropertySet, temperature_c : Float, pressure_kpa : Float) -> PhaseState

#
ChemicalPropertySet::vapor_pressure_at

source
fn ChemicalPropertySet::vapor_pressure_at(self : ChemicalPropertySet, temperature_c : Float) -> Float

#
ChemicalPropertySet::viscosity_at

source
fn ChemicalPropertySet::viscosity_at(self : ChemicalPropertySet, temperature_c : Float) -> Float

#
ComponentBalance

source
pub struct ComponentBalance {
  component : String
  inlet : Float
  outlet : Float
  net : Float
  relative_error : Float
} derive(Eq, 
Debug)

#
ComponentFlow

source
pub struct ComponentFlow {
  component : String
  value : Float
  unit : MeasureUnit
} derive(Eq, 
Debug)

#
CompressorDesign

source
pub struct CompressorDesign {
  suction_pressure : Float
  discharge_pressure : Float
  inlet_temperature : Float
  flow_rate : Float
  efficiency : Float
  gas_constant : Float
  heat_capacity_ratio : Float
} derive(Eq, 
Debug)

#
CompressorDesign::discharge_temperature

source
fn CompressorDesign::discharge_temperature(self : CompressorDesign) -> Float

#
CompressorDesign::is_acceptable

source
fn CompressorDesign::is_acceptable(self : CompressorDesign, maximum_temperature : Float) -> Bool

#
CompressorDesign::power

source
fn CompressorDesign::power(self : CompressorDesign) -> Float

#
CompressorDesign::pressure_ratio

source
fn CompressorDesign::pressure_ratio(self : CompressorDesign) -> Float

#
CompressorDesign::specific_work

source
fn CompressorDesign::specific_work(self : CompressorDesign) -> Float

#
Constraint

source
pub struct Constraint {
  index : Int
  lower : Float
  upper : Float
} derive(Eq, 
Debug)

#
Constraint::contains

source
fn Constraint::contains(self : Constraint, candidate : Candidate) -> Bool

#
ControlLimits

source
pub struct ControlLimits {
  center : Float
  upper : Float
  lower : Float
} derive(Eq, 
Debug)

#
ControlLimits::contains

source
fn ControlLimits::contains(self : ControlLimits, value : Float) -> Bool

#
ControlLimits::flag

source
fn ControlLimits::flag(self : ControlLimits, values : Array[Float]) -> Array[ObservationFlag]

#
ControlLoop

source
pub struct ControlLoop {
  controllers : Array[Controller]
  alarms : AlarmBoard
} derive(Eq, 
Debug)

#
ControlLoop::controller_count

source
fn ControlLoop::controller_count(self : ControlLoop) -> Int

#
ControlLoop::healthy_count

source
fn ControlLoop::healthy_count(self : ControlLoop) -> Int

#
ControlLoop::table

source
fn ControlLoop::table(self : ControlLoop) -> ReportTable

#
ControlLoop::update

source
fn ControlLoop::update(self : ControlLoop, values : Array[Float], step : Float, minimum : Float, maximum : Float) -> ControlLoop

#
Controller

source
pub struct Controller {
  tag : String
  setpoint : Float
  process_value : Float
  output : Float
  gain : Float
  integral : Float
  mode : ControllerMode
} derive(Eq, 
Debug)

#
Controller::error

source
fn Controller::error(self : Controller) -> Float

#
Controller::is_automatic

source
fn Controller::is_automatic(self : Controller) -> Bool

#
Controller::is_healthy

source
fn Controller::is_healthy(self : Controller) -> Bool

#
Controller::next_output

source
fn Controller::next_output(self : Controller, step : Float, minimum : Float, maximum : Float) -> Float

#
Controller::update

source
fn Controller::update(self : Controller, process_value : Float, step : Float, minimum : Float, maximum : Float) -> Controller

#
ControllerMode

source
pub enum ControllerMode {
  Manual
  Automatic
  Cascade
  Failed
} derive(Eq, 
Debug)

#
CostItem

source
pub struct CostItem {
  name : String
  quantity : Float
  unit_cost : Float
  category : String
} derive(Eq, 
Debug)

#
CostItem::is_valid

source
fn CostItem::is_valid(self : CostItem) -> Bool

#
CostItem::total

source
fn CostItem::total(self : CostItem) -> Float

#
CostModel

source
pub struct CostModel {
  items : Array[CostItem]
  currency : String
  period : String
} derive(Eq, 
Debug)

#
CostModel::add

source
fn CostModel::add(self : CostModel, item : CostItem) -> CostModel

#
CostModel::by_category

source
fn CostModel::by_category(self : CostModel, category : String) -> Float

#
CostModel::categories

source
fn CostModel::categories(self : CostModel) -> Array[String]

#
CostModel::category_table

source
fn CostModel::category_table(self : CostModel) -> ReportTable

#
CostModel::count

source
fn CostModel::count(self : CostModel) -> Int

#
CostModel::item_table

source
fn CostModel::item_table(self : CostModel) -> ReportTable

#
CostModel::scale

source
fn CostModel::scale(self : CostModel, factor : Float) -> CostModel

#
CostModel::total

source
fn CostModel::total(self : CostModel) -> Float

#
CostModel::valid

source
fn CostModel::valid(self : CostModel) -> Bool

#
CstrDesign

source
pub struct CstrDesign {
  volume_m3 : Float
  flow_m3_h : Float
  rate_mol_m3_h : Float
  feed_mol_m3 : Float
}

#
CstrDesign::conversion

source
fn CstrDesign::conversion(self : CstrDesign) -> Float

#
CstrDesign::outlet

source
fn CstrDesign::outlet(self : CstrDesign) -> Float

#
CstrDesign::residence_hours

source
fn CstrDesign::residence_hours(self : CstrDesign) -> Float

#
CstrDesign::valid

source
fn CstrDesign::valid(self : CstrDesign) -> Bool

#
DataField

source
pub struct DataField {
  name : String
  value : String?
  expected_unit : String?
  policy : MissingPolicy
} derive(Eq, 
Debug)

#
DataField::is_acceptable

source
fn DataField::is_acceptable(self : DataField) -> Bool

#
DataField::is_missing

source
fn DataField::is_missing(self : DataField) -> Bool

#
DataQuality

source
pub struct DataQuality {
  name : String
  completeness : Float
  validity : Float
  timeliness : Float
  consistency : Float
} derive(Eq, 
Debug)

#
DataQuality::is_acceptable

source
fn DataQuality::is_acceptable(self : DataQuality, minimum : Float) -> Bool

#
DataQuality::is_valid

source
fn DataQuality::is_valid(self : DataQuality) -> Bool

#
DataQuality::score

source
fn DataQuality::score(self : DataQuality) -> Float

#
DelimitedRow

source
pub struct DelimitedRow {
  fields : Array[String]
  line_number : Int
}

Deterministic delimited-data parsing for instrument and audit exports.

#
DelimitedRow::field

source
fn DelimitedRow::field(self : DelimitedRow, index : Int) -> String

#
DelimitedRow::valid

source
fn DelimitedRow::valid(self : DelimitedRow) -> Bool

#
DelimitedRow::width

source
fn DelimitedRow::width(self : DelimitedRow) -> Int

#
DelimitedTable

source
pub struct DelimitedTable {
  headers : Array[String]
  rows : Array[DelimitedRow]
  delimiter : String
}

#
DelimitedTable::column

source
fn DelimitedTable::column(self : DelimitedTable, name : String) -> Array[String]

#
DelimitedTable::invalid_rows

source
fn DelimitedTable::invalid_rows(self : DelimitedTable) -> Array[DelimitedRow]

#
DelimitedTable::quality

source
fn DelimitedTable::quality(self : DelimitedTable) -> Float

#
DelimitedTable::row_count

source
fn DelimitedTable::row_count(self : DelimitedTable) -> Int

#
DelimitedTable::valid_rows

source
fn DelimitedTable::valid_rows(self : DelimitedTable) -> Array[DelimitedRow]

#
DelimitedTable::width

source
fn DelimitedTable::width(self : DelimitedTable) -> Int

#
Diagnostic

source
pub struct Diagnostic {
  code : String
  severity : DiagnosticSeverity
  path : String
  message : String
  remediation : String
} derive(Eq, 
Debug)

#
Diagnostic::is_blocking

source
fn Diagnostic::is_blocking(self : Diagnostic) -> Bool

#
Diagnostic::level

source
fn Diagnostic::level(self : Diagnostic) -> String

#
DiagnosticReport

source
pub struct DiagnosticReport {
  diagnostics : Array[Diagnostic]
  passed : Bool
} derive(Eq, 
Debug)

#
DiagnosticReport::blocking_count

source
fn DiagnosticReport::blocking_count(self : DiagnosticReport) -> Int

#
DiagnosticReport::count

source
fn DiagnosticReport::count(self : DiagnosticReport) -> Int

#
DiagnosticReport::errors

source

#
DiagnosticReport::to_markdown

source
fn DiagnosticReport::to_markdown(self : DiagnosticReport) -> String

#
DiagnosticReport::warnings

source

#
DiagnosticSeverity

source
pub enum DiagnosticSeverity {
  DiagHint
  DiagWarning
  DiagError
  DiagBlocker
} derive(Eq, 
Debug)

#
DistillationCase

source
pub struct DistillationCase {
  feed_rate : Float
  feed_fraction : Float
  distillate_rate : Float
  distillate_fraction : Float
  bottoms_rate : Float
  bottoms_fraction : Float
  reflux_ratio : Float
  stages : Int
} derive(Eq, 
Debug)

#
DistillationCase::component_balance

source
fn DistillationCase::component_balance(self : DistillationCase) -> Float

#
DistillationCase::is_closed

source
fn DistillationCase::is_closed(self : DistillationCase, tolerance? : Float) -> Bool

#
DistillationCase::minimum_stages

source
fn DistillationCase::minimum_stages(self : DistillationCase) -> Int

#
DistillationCase::recovery

source
fn DistillationCase::recovery(self : DistillationCase) -> Float

#
DistillationCase::total_balance

source
fn DistillationCase::total_balance(self : DistillationCase) -> Float

#
Emission

source
pub struct Emission {
  pollutant : String
  amount : Float
  unit : String
  source : String
} derive(Eq, 
Debug)

#
Emission::is_valid

source
fn Emission::is_valid(self : Emission) -> Bool

#
EmissionFactor

source
pub struct EmissionFactor {
  pollutant : String
  factor : Float
  unit : String
  source : String
} derive(Eq, 
Debug)

#
EnergyBalance

source
pub struct EnergyBalance {
  inlet : Float
  outlet : Float
  residual : Float
  streams : Array[EnergyStream]
} derive(Eq, 
Debug)

#
EnergyBalance::is_closed

source
fn EnergyBalance::is_closed(self : EnergyBalance, tolerance? : Float) -> Bool

#
EnergyBalance::specific_duty

source
fn EnergyBalance::specific_duty(self : EnergyBalance, mass : Quantity) -> Result[Quantity, QuantityError]

#
EnergyCost

source
pub struct EnergyCost {
  energy : Float
  rate : Float
  demand_charge : Float
  fixed_charge : Float
} derive(Eq, 
Debug)

#
EnergyCost::average_rate

source
fn EnergyCost::average_rate(self : EnergyCost) -> Float

#
EnergyCost::total

source
fn EnergyCost::total(self : EnergyCost) -> Float

#
EnergyCost::variable

source
fn EnergyCost::variable(self : EnergyCost) -> Float

#
EnergyStream

source
pub struct EnergyStream {
  name : String
  duty : Quantity
  direction : StreamDirection
} derive(Eq, 
Debug)

#
EnvironmentalInventory

source
pub struct EnvironmentalInventory {
  emissions : Array[Emission]
  period : String
  facility : String
} derive(Eq, 
Debug)

#
EnvironmentalInventory::by_pollutant

source
fn EnvironmentalInventory::by_pollutant(self : EnvironmentalInventory, pollutant : String) -> Float

#
EnvironmentalInventory::pollutants

source
fn EnvironmentalInventory::pollutants(self : EnvironmentalInventory) -> Array[String]

#
EnvironmentalInventory::table

source

#
EnvironmentalInventory::total

source

#
EnvironmentalInventory::valid

source

#
EquilibriumLine

source
pub struct EquilibriumLine {
  slope : Float
  intercept : Float
}

Absorption, stripping, and contacting calculations.

#
EquilibriumLine::gas_fraction

source
fn EquilibriumLine::gas_fraction(self : EquilibriumLine, liquid_fraction : Float) -> Float

#
EquilibriumLine::valid

source
fn EquilibriumLine::valid(self : EquilibriumLine) -> Bool

#
ExchangerDesign

source
pub struct ExchangerDesign {
  area : Float
  overall_u : Float
  hot_inlet : Float
  hot_outlet : Float
  cold_inlet : Float
  cold_outlet : Float
  hot_capacity : Float
  cold_capacity : Float
} derive(Eq, 
Debug)

#
ExchangerDesign::area_margin

source
fn ExchangerDesign::area_margin(self : ExchangerDesign) -> Float

#
ExchangerDesign::cold_duty

source
fn ExchangerDesign::cold_duty(self : ExchangerDesign) -> Float

#
ExchangerDesign::delta_cold

source
fn ExchangerDesign::delta_cold(self : ExchangerDesign) -> Float

#
ExchangerDesign::delta_hot

source
fn ExchangerDesign::delta_hot(self : ExchangerDesign) -> Float

#
ExchangerDesign::duty_error

source
fn ExchangerDesign::duty_error(self : ExchangerDesign) -> Float

#
ExchangerDesign::effectiveness

source
fn ExchangerDesign::effectiveness(self : ExchangerDesign) -> Float

#
ExchangerDesign::hot_duty

source
fn ExchangerDesign::hot_duty(self : ExchangerDesign) -> Float

#
ExchangerDesign::is_acceptable

source
fn ExchangerDesign::is_acceptable(self : ExchangerDesign) -> Bool

#
ExchangerDesign::lmtd

source
fn ExchangerDesign::lmtd(self : ExchangerDesign) -> Float

#
ExchangerDesign::required_area

source
fn ExchangerDesign::required_area(self : ExchangerDesign) -> Float

#
ExportBundle

source
pub struct ExportBundle {
  markdown : String
  html : String
  json : String
} derive(Eq, 
Debug)

#
FieldRequirement

source
pub enum FieldRequirement {
  Required
  Optional
} derive(Eq, 
Debug)

#
FormulaNote

source
pub struct FormulaNote {
  name : String
  expression : String
  explanation : String
} derive(Eq, 
Debug)

#
Hazard

source
pub struct Hazard {
  id : String
  node : String
  deviation : String
  cause : String
  consequence : String
  likelihood : RiskLikelihood
  severity : RiskSeverity
  safeguards : Array[String]
}

#
Hazard::adequately_safeguarded

source
fn Hazard::adequately_safeguarded(self : Hazard) -> Bool

#
Hazard::level

source
fn Hazard::level(self : Hazard) -> String

#
Hazard::score

source
fn Hazard::score(self : Hazard) -> Int

#
HeatExchangerCase

source
pub struct HeatExchangerCase {
  hot_inlet : Float
  hot_outlet : Float
  cold_inlet : Float
  cold_outlet : Float
  hot_capacity_rate : Float
  cold_capacity_rate : Float
  area : Float
  overall_u : Float
} derive(Eq, 
Debug)

#
HeatExchangerCase::area_margin

source
fn HeatExchangerCase::area_margin(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::cold_duty

source
fn HeatExchangerCase::cold_duty(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::duty_residual

source
fn HeatExchangerCase::duty_residual(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::effectiveness

source
fn HeatExchangerCase::effectiveness(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::estimated_area

source
fn HeatExchangerCase::estimated_area(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::hot_duty

source
fn HeatExchangerCase::hot_duty(self : HeatExchangerCase) -> Float

#
HeatExchangerCheck

source
pub struct HeatExchangerCheck {
  area_m2 : Float
  required_m2 : Float
  duty_kw : Float
  pressure_drop_bar : Float
  max_pressure_drop_bar : Float
}

#
HeatExchangerCheck::acceptable

source
fn HeatExchangerCheck::acceptable(self : HeatExchangerCheck) -> Bool

#
HeatExchangerCheck::area_margin

source
fn HeatExchangerCheck::area_margin(self : HeatExchangerCheck) -> Float

#
ImportIssue

source
pub struct ImportIssue {
  line_number : Int
  field : String
  message : String
  severity : String
}

#
InputValue

source
pub struct InputValue {
  name : String
  value : String
  unit : String?
  note : String?
} derive(Eq, 
Debug)

#
InsulationDesign

source
pub struct InsulationDesign {
  thickness_m : Float
  conductivity_w_mk : Float
  area_m2 : Float
  ambient_c : Float
  process_c : Float
}

#
InsulationDesign::acceptable

source
fn InsulationDesign::acceptable(self : InsulationDesign, limit_w_m2 : Float) -> Bool

#
InsulationDesign::loss_w

source
fn InsulationDesign::loss_w(self : InsulationDesign) -> Float

#
InsulationDesign::surface_load

source
fn InsulationDesign::surface_load(self : InsulationDesign) -> Float

#
InventoryItem

source
pub struct InventoryItem {
  component : String
  flow : Float
  unit : MeasureUnit
} derive(Eq, 
Debug)

#
InventoryItem::as_kg_per_hour

source
fn InventoryItem::as_kg_per_hour(self : InventoryItem) -> Float

#
InventoryItem::is_valid

source
fn InventoryItem::is_valid(self : InventoryItem) -> Bool

#
LinearProperty

source
pub struct LinearProperty {
  reference : Float
  slope : Float
  reference_temperature : Float
}

#
LinearProperty::at

source
fn LinearProperty::at(self : LinearProperty, temperature_c : Float) -> Float

#
MaintenanceTask

source
pub struct MaintenanceTask {
  asset : String
  task : String
  interval_hours : Float
  operating_hours : Float
  critical : Bool
} derive(Eq, 
Debug)

#
MaintenanceTask::due

source
fn MaintenanceTask::due(self : MaintenanceTask) -> Bool

#
MaintenanceTask::remaining

source
fn MaintenanceTask::remaining(self : MaintenanceTask) -> Float

#
MaintenanceTask::risk

source
fn MaintenanceTask::risk(self : MaintenanceTask) -> String

#
MaintenanceWindow

source
pub struct MaintenanceWindow {
  asset : String
  due_hour : Float
  duration_hours : Float
  critical : Bool
  completed : Bool
}

#
MaintenanceWindow::overdue

source
fn MaintenanceWindow::overdue(self : MaintenanceWindow, current_hour : Float) -> Bool

#
MaintenanceWindow::risk

source
fn MaintenanceWindow::risk(self : MaintenanceWindow, current_hour : Float) -> String

#
MaterialBalance

source
pub struct MaterialBalance {
  components : Array[ComponentBalance]
  total_inlet : Float
  total_outlet : Float
} derive(Eq, 
Debug)

#
MaterialBalance::closure_percent

source
fn MaterialBalance::closure_percent(self : MaterialBalance) -> Float

#
MaterialBalance::component

source
fn MaterialBalance::component(self : MaterialBalance, name : String) -> ComponentBalance?

#
MaterialBalance::is_closed

source
fn MaterialBalance::is_closed(self : MaterialBalance, tolerance? : Float) -> Bool

#
MaterialBalance::limiting_component

source
fn MaterialBalance::limiting_component(self : MaterialBalance) -> String?

#
MaterialBalance::to_markdown

source
fn MaterialBalance::to_markdown(self : MaterialBalance) -> String

#
MaterialProperty

source
pub struct MaterialProperty {
  name : String
  molecular_weight : Float
  density : Float
  heat_capacity : Float
  boiling_point : Float
  safety_limit : Float
} derive(Eq, 
Debug)

#
MaterialProperty::is_valid

source
fn MaterialProperty::is_valid(self : MaterialProperty) -> Bool

#
MaterialProperty::thermal_capacity

source
fn MaterialProperty::thermal_capacity(self : MaterialProperty, mass : Float) -> Float

#
MeasureUnit

source
pub enum MeasureUnit {
  Kilogram
  Gram
  Tonne
  KgPerHour
  Mol
  Kmol
  Liter
  CubicMeter
  CubicMeterPerHour
  Meter
  Pascal
  KiloPascal
  Bar
  Joule
  KiloJoule
  KiloWatt
  Celsius
  Kelvin
  Second
  Minute
  Hour
  Percent
  Ratio
} derive(Eq, 
Debug)

#
MeasureUnit::dimension

source
fn MeasureUnit::dimension(self : MeasureUnit) -> UnitDimension

#
MeasureUnit::symbol

source
fn MeasureUnit::symbol(self : MeasureUnit) -> String

#
MissingPolicy

source
pub enum MissingPolicy {
  RejectMissing
  IgnoreMissing
  UseDefault
} derive(Eq, 
Debug)

#
MixtureProperty

source
pub struct MixtureProperty {
  component : String
  mole_fraction : Float
  property : ChemicalPropertySet
}

#
MonteCarloSummary

source
pub struct MonteCarloSummary {
  trials : Int
  mean : Float
  minimum : Float
  maximum : Float
  p05 : Float
  p50 : Float
  p95 : Float
} derive(Eq, 
Debug)

#
MonteCarloSummary::is_stable

source
fn MonteCarloSummary::is_stable(self : MonteCarloSummary, maximum_spread : Float) -> Bool

#
MonteCarloSummary::spread

source
fn MonteCarloSummary::spread(self : MonteCarloSummary) -> Float

#
MonteCarloSummary::to_table

source

#
ObservationFlag

source
pub enum ObservationFlag {
  NormalObservation
  AboveControlLimit
  BelowControlLimit
} derive(Eq, 
Debug)

#
PackedColumn

source
pub struct PackedColumn {
  diameter_m : Float
  packing_height_m : Float
  packing_factor : Float
  gas_velocity_m_s : Float
  flooding_velocity_m_s : Float
}

#
PackedColumn::acceptable

source
fn PackedColumn::acceptable(self : PackedColumn, maximum_fraction : Float) -> Bool

#
PackedColumn::area_m2

source
fn PackedColumn::area_m2(self : PackedColumn) -> Float

#
PackedColumn::capacity_mol_h

source
fn PackedColumn::capacity_mol_h(self : PackedColumn, gas_density_mol_m3 : Float) -> Float

#
PackedColumn::flood_fraction

source
fn PackedColumn::flood_fraction(self : PackedColumn) -> Float

#
PfrDesign

source
pub struct PfrDesign {
  volume_m3 : Float
  flow_m3_h : Float
  inlet_mol_m3 : Float
  rate_mol_m3_h : Float
}

#
PfrDesign::conversion

source
fn PfrDesign::conversion(self : PfrDesign) -> Float

#
PfrDesign::outlet

source
fn PfrDesign::outlet(self : PfrDesign) -> Float

#
PfrDesign::space_time

source
fn PfrDesign::space_time(self : PfrDesign) -> Float

#
PhaseState

source
pub enum PhaseState {
  Solid
  Liquid
  Vapor
  Supercritical
}

Lightweight property correlations used by design and screening calculations.

#
PipeDesign

source
pub struct PipeDesign {
  length : Float
  diameter : Float
  roughness : Float
  flow_rate : Float
  density : Float
  viscosity : Float
  allowable_drop : Float
} derive(Eq, 
Debug)

#
PipeDesign::area

source
fn PipeDesign::area(self : PipeDesign) -> Float

#
PipeDesign::friction_factor

source
fn PipeDesign::friction_factor(self : PipeDesign) -> Float

#
PipeDesign::is_acceptable

source
fn PipeDesign::is_acceptable(self : PipeDesign) -> Bool

#
PipeDesign::pressure_drop

source
fn PipeDesign::pressure_drop(self : PipeDesign) -> Float

#
PipeDesign::pressure_margin

source
fn PipeDesign::pressure_margin(self : PipeDesign) -> Float

#
PipeDesign::reynolds

source
fn PipeDesign::reynolds(self : PipeDesign) -> Float

#
PipeDesign::velocity

source
fn PipeDesign::velocity(self : PipeDesign) -> Float

#
PressureDropCase

source
pub struct PressureDropCase {
  length : Float
  diameter : Float
  velocity : Float
  density : Float
  viscosity : Float
  roughness : Float
  fittings_k : Float
} derive(Eq, 
Debug)

#
PressureDropCase::friction_factor

source
fn PressureDropCase::friction_factor(self : PressureDropCase) -> Float

#
PressureDropCase::major_loss

source
fn PressureDropCase::major_loss(self : PressureDropCase) -> Float

#
PressureDropCase::minor_loss

source
fn PressureDropCase::minor_loss(self : PressureDropCase) -> Float

#
PressureDropCase::reynolds

source
fn PressureDropCase::reynolds(self : PressureDropCase) -> Float

#
PressureDropCase::total_loss

source
fn PressureDropCase::total_loss(self : PressureDropCase) -> Float

#
ProcessStream

source
pub struct ProcessStream {
  name : String
  direction : StreamDirection
  components : Array[ComponentFlow]
} derive(Eq, 
Debug)

#
ProductionEconomics

source
pub struct ProductionEconomics {
  revenue : Float
  operating_cost : Float
  capital_cost : Float
  production : Float
  lifetime : Int
} derive(Eq, 
Debug)

#
ProductionEconomics::gross_margin

source
fn ProductionEconomics::gross_margin(self : ProductionEconomics) -> Float

#
ProductionEconomics::is_viable

source
fn ProductionEconomics::is_viable(self : ProductionEconomics, maximum_payback : Float) -> Bool

#
ProductionEconomics::margin_rate

source
fn ProductionEconomics::margin_rate(self : ProductionEconomics) -> Float

#
ProductionEconomics::net_margin

source
fn ProductionEconomics::net_margin(self : ProductionEconomics) -> Float

#
ProductionEconomics::payback_period

source
fn ProductionEconomics::payback_period(self : ProductionEconomics) -> Float

#
ProductionEconomics::simple_roi

source
fn ProductionEconomics::simple_roi(self : ProductionEconomics) -> Float

#
ProductionEconomics::unit_cost

source
fn ProductionEconomics::unit_cost(self : ProductionEconomics) -> Float

#
PumpCase

source
pub struct PumpCase {
  flow_rate : Float
  differential_pressure : Float
  efficiency : Float
  fluid_density : Float
  installed_power : Float
} derive(Eq, 
Debug)

#
PumpCase::hydraulic_power

source
fn PumpCase::hydraulic_power(self : PumpCase) -> Float

#
PumpCase::is_overloaded

source
fn PumpCase::is_overloaded(self : PumpCase) -> Bool

#
PumpCase::power_margin

source
fn PumpCase::power_margin(self : PumpCase) -> Float

#
PumpCase::shaft_power

source
fn PumpCase::shaft_power(self : PumpCase) -> Float

#
PumpCase::specific_speed

source
fn PumpCase::specific_speed(self : PumpCase, head : Float) -> Float

#
QualityDimension

source
pub struct QualityDimension {
  name : String
  passed : Int
  total : Int
} derive(Eq, 
Debug)

#
QualityDimension::is_acceptable

source
fn QualityDimension::is_acceptable(self : QualityDimension, minimum : Float) -> Bool

#
QualityDimension::ratio

source
fn QualityDimension::ratio(self : QualityDimension) -> Float

#
QualityGate

source
pub struct QualityGate {
  passed : Bool
  blockers : Array[String]
  notices : Array[String]
} derive(Eq, 
Debug)

#
QualityProfile

source
pub struct QualityProfile {
  name : String
  dimensions : Array[QualityDimension]
} derive(Eq, 
Debug)

#
QualityProfile::is_acceptable

source
fn QualityProfile::is_acceptable(self : QualityProfile, minimum : Float) -> Bool

#
QualityProfile::score

source
fn QualityProfile::score(self : QualityProfile) -> Float

#
QualityProfile::to_table

source
fn QualityProfile::to_table(self : QualityProfile) -> ReportTable

#
QualityProfile::weakest

source

#
Quantity

source
pub struct Quantity {
  value : Float
  unit : MeasureUnit
} derive(Eq, 
Debug)

#
Quantity::add

source
fn Quantity::add(self : Quantity, other : Quantity) -> Result[Quantity, QuantityError]

#
Quantity::convert_to

source
fn Quantity::convert_to(self : Quantity, target : MeasureUnit) -> Result[Float, QuantityError]

#
Quantity::format

source
fn Quantity::format(self : Quantity, decimals : Int) -> String

#
Quantity::in_unit

source
fn Quantity::in_unit(self : Quantity, target : MeasureUnit) -> Result[Quantity, QuantityError]

#
Quantity::scale

source
fn Quantity::scale(self : Quantity, factor : Float) -> Quantity

#
Quantity::subtract

source
fn Quantity::subtract(self : Quantity, other : Quantity) -> Result[Quantity, QuantityError]

#
Quantity::validate

source
fn Quantity::validate(self : Quantity) -> Result[MeasureUnit, QuantityError]

#
QuantityError

source
pub enum QuantityError {
  IncompatibleDimensions(UnitDimension, UnitDimension)
  BelowAbsoluteZero
  InvalidValue
} derive(Eq, 
Debug)

#
ReactionOrder

source
pub struct ReactionOrder {
  order_a : Float
  order_b : Float
  stoich_a : Float
  stoich_b : Float
}

#
ReactionOrder::rate

source
fn ReactionOrder::rate(self : ReactionOrder, constant : Float, concentration_a : Float, concentration_b : Float) -> Float

#
ReactionOrder::valid

source
fn ReactionOrder::valid(self : ReactionOrder) -> Bool

#
ReactionPath

source
pub struct ReactionPath {
  name : String
  conversion : Float
  selectivity : Float
  yield_fraction : Float
}

#
ReactionPath::product_fraction

source
fn ReactionPath::product_fraction(self : ReactionPath) -> Float

#
ReactionPath::valid

source
fn ReactionPath::valid(self : ReactionPath) -> Bool

#
ReactorCase

source
pub struct ReactorCase {
  name : String
  feed : Float
  product : Float
  byproduct : Float
  residence_time : Float
  temperature : Float
  pressure : Float
} derive(Eq, 
Debug)

#
ReactorCase::conversion

source
fn ReactorCase::conversion(self : ReactorCase) -> Float

#
ReactorCase::is_safe

source
fn ReactorCase::is_safe(self : ReactorCase, temperature_limit : Float, pressure_limit : Float) -> Bool

#
ReactorCase::product_yield

source
fn ReactorCase::product_yield(self : ReactorCase) -> Float

#
ReactorCase::selectivity

source
fn ReactorCase::selectivity(self : ReactorCase) -> Float

#
ReactorCase::space_time_yield

source
fn ReactorCase::space_time_yield(self : ReactorCase) -> Float

#
ReportBuilder

source
pub struct ReportBuilder {
  value : ChemReport
  history : Array[String]
} derive(Eq, 
Debug)

#
ReportBuilder::add_assumption

source
fn ReportBuilder::add_assumption(self : ReportBuilder, statement : String, impact : String) -> ReportBuilder

#
ReportBuilder::add_formula

source
fn ReportBuilder::add_formula(self : ReportBuilder, name : String, expression : String, explanation : String) -> ReportBuilder

#
ReportBuilder::add_input

source
fn ReportBuilder::add_input(self : ReportBuilder, name : String, value : String, unit : String?, note : String?) -> ReportBuilder

#
ReportBuilder::add_result

source
fn ReportBuilder::add_result(self : ReportBuilder, name : String, value : String, unit : String?, status : ResultStatus, note : String?) -> ReportBuilder

#
ReportBuilder::add_section

source
fn ReportBuilder::add_section(self : ReportBuilder, title : String, kind : SectionKind, body : String) -> ReportBuilder

#
ReportBuilder::add_source

source
fn ReportBuilder::add_source(self : ReportBuilder, label : String, kind : SourceKind, url : String?, license : String?, note : String?) -> ReportBuilder

#
ReportBuilder::add_warning

source
fn ReportBuilder::add_warning(self : ReportBuilder, code : String, severity : WarningSeverity, summary : String, action : String) -> ReportBuilder

#
ReportBuilder::build

source

#
ReportBuilder::events

source
fn ReportBuilder::events(self : ReportBuilder) -> Array[String]

#
ReportBuilder::is_ready

source
fn ReportBuilder::is_ready(self : ReportBuilder) -> Bool

#
ReportBuilder::quality

source
fn ReportBuilder::quality(self : ReportBuilder) -> QualityGate

#
ReportBuilder::summary

source
fn ReportBuilder::summary(self : ReportBuilder, text : String) -> ReportBuilder

#
ReportBuilder::tag

source
fn ReportBuilder::tag(self : ReportBuilder, tag : String) -> ReportBuilder

#
ReportMetadata

source
pub struct ReportMetadata {
  report_id : String
  title : String
  process_unit : String
  scenario : String
  generated_at : String
  tool_version : String
} derive(Eq, 
Debug)

#
ReportSection

source
pub struct ReportSection {
  title : String
  kind : SectionKind
  body : String
} derive(Eq, 
Debug)

#
ReportTable

source
pub struct ReportTable {
  columns : Array[String]
  rows : Array[Array[String]]
} derive(Eq, 
Debug)

#
ReportTable::column_count

source
fn ReportTable::column_count(self : ReportTable) -> Int

#
ReportTable::is_rectangular

source
fn ReportTable::is_rectangular(self : ReportTable) -> Bool

#
ReportTable::row_count

source
fn ReportTable::row_count(self : ReportTable) -> Int

#
ReportTable::to_csv

source
fn ReportTable::to_csv(self : ReportTable) -> String

#
ReportTable::to_html

source
fn ReportTable::to_html(self : ReportTable) -> String

#
ReportTable::to_markdown

source
fn ReportTable::to_markdown(self : ReportTable) -> String

#
ReportTable::validate

source
fn ReportTable::validate(self : ReportTable) -> Array[String]

#
ReportTemplate

source
pub struct ReportTemplate {
  name : String
  fields : Array[TemplateField]
} derive(Eq, 
Debug)

#
ReportTemplate::add_field

source
fn ReportTemplate::add_field(self : ReportTemplate, field : TemplateField) -> ReportTemplate

#
ReportTemplate::field_count

source
fn ReportTemplate::field_count(self : ReportTemplate) -> Int

#
ReportTemplate::field_names

source
fn ReportTemplate::field_names(self : ReportTemplate) -> Array[String]

#
ReportTemplate::has_field

source
fn ReportTemplate::has_field(self : ReportTemplate, name : String) -> Bool

#
ReportTemplate::missing_fields

source
fn ReportTemplate::missing_fields(self : ReportTemplate, values : Array[TemplateValue]) -> Array[String]

#
ReportTemplate::render

source
fn ReportTemplate::render(self : ReportTemplate, values : Array[TemplateValue]) -> String

#
ReportTemplate::required_count

source
fn ReportTemplate::required_count(self : ReportTemplate) -> Int

#
ReportTemplate::to_report

source
fn ReportTemplate::to_report(self : ReportTemplate, values : Array[TemplateValue], metadata : ReportMetadata) -> ChemReport

#
ReportTemplate::validate

source
fn ReportTemplate::validate(self : ReportTemplate, values : Array[TemplateValue]) -> Array[String]

#
ReportTemplate::with_name

source
fn ReportTemplate::with_name(self : ReportTemplate, name : String) -> ReportTemplate

#
ReportWorkflow

source
pub struct ReportWorkflow {
  id : String
  steps : Array[WorkflowStep]
  current : Int
} derive(Eq, 
Debug)

#
ReportWorkflow::advance

source

#
ReportWorkflow::approve_current

source
fn ReportWorkflow::approve_current(self : ReportWorkflow, note : String) -> ReportWorkflow

#
ReportWorkflow::completed_count

source
fn ReportWorkflow::completed_count(self : ReportWorkflow) -> Int

#
ReportWorkflow::count

source
fn ReportWorkflow::count(self : ReportWorkflow) -> Int

#
ReportWorkflow::current_step

source
fn ReportWorkflow::current_step(self : ReportWorkflow) -> WorkflowStep?

#
ReportWorkflow::is_complete

source
fn ReportWorkflow::is_complete(self : ReportWorkflow) -> Bool

#
ReportWorkflow::progress

source
fn ReportWorkflow::progress(self : ReportWorkflow) -> Float

#
ReportWorkflow::reject_current

source
fn ReportWorkflow::reject_current(self : ReportWorkflow, note : String) -> ReportWorkflow

#
ReportWorkflow::to_section

source
fn ReportWorkflow::to_section(self : ReportWorkflow) -> ReportSection

#
ReportWorkflow::to_table

source
fn ReportWorkflow::to_table(self : ReportWorkflow) -> ReportTable

#
ReportWorkflow::with_step

source
fn ReportWorkflow::with_step(self : ReportWorkflow, step : WorkflowStep) -> ReportWorkflow

#
ResourceCalendar

source
pub struct ResourceCalendar {
  name : String
  capacity_hours : Float
  blocks : Array[ScheduleBlock]
}

#
ResourceCalendar::available

source
fn ResourceCalendar::available(self : ResourceCalendar) -> Float

#
ResourceCalendar::conflicts

source
fn ResourceCalendar::conflicts(self : ResourceCalendar) -> Array[String]

#
ResourceCalendar::loaded_hours

source
fn ResourceCalendar::loaded_hours(self : ResourceCalendar) -> Float

#
ResourceCalendar::utilization

source
fn ResourceCalendar::utilization(self : ResourceCalendar) -> Float

#
ResourceCalendar::valid

source
fn ResourceCalendar::valid(self : ResourceCalendar) -> Bool

#
ResultStatus

source
pub enum ResultStatus {
  Normal
  Flagged
  Estimated
} derive(Eq, 
Debug)

#
ResultValue

source
pub struct ResultValue {
  name : String
  value : String
  unit : String?
  status : ResultStatus
  note : String?
} derive(Eq, 
Debug)

#
RiskLikelihood

source
pub enum RiskLikelihood {
  Rare
  Unlikely
  Possible
  Likely
  Frequent
}

Structured hazard identification and risk-ranking helpers.

#
RiskRegister

source
pub struct RiskRegister {
  hazards : Array[Hazard]
}

#
RiskRegister::acceptable

source
fn RiskRegister::acceptable(self : RiskRegister, max_high : Int) -> Bool

#
RiskRegister::high

source
fn RiskRegister::high(self : RiskRegister) -> Array[Hazard]

#
RiskRegister::score

source
fn RiskRegister::score(self : RiskRegister) -> Int

#
RiskRegister::uncontrolled

source
fn RiskRegister::uncontrolled(self : RiskRegister) -> Array[Hazard]

#
RiskSeverity

source
pub enum RiskSeverity {
  Negligible
  Minor
  Serious
  Major
  Catastrophic
}

#
Rule

source
pub struct Rule {
  code : String
  operator : RuleOperator
  field : String
  limit : Float
  severity : RuleSeverity
} derive(Eq, 
Debug)

#
RuleEvaluation

source
pub struct RuleEvaluation {
  passed : Bool
  violations : Array[RuleViolation]
  checked : Int
} derive(Eq, 
Debug)

#
RuleEvaluation::error_count

source
fn RuleEvaluation::error_count(self : RuleEvaluation) -> Int

#
RuleEvaluation::to_diagnostics

source
fn RuleEvaluation::to_diagnostics(self : RuleEvaluation) -> Array[Diagnostic]

#
RuleEvaluation::to_table

source
fn RuleEvaluation::to_table(self : RuleEvaluation) -> ReportTable

#
RuleEvaluation::warning_count

source
fn RuleEvaluation::warning_count(self : RuleEvaluation) -> Int

#
RuleOperator

source
pub enum RuleOperator {
  GreaterThan
  LessThan
  EqualTo
  AtLeast
  AtMost
} derive(Eq, 
Debug)

#
RuleSeverity

source
pub enum RuleSeverity {
  RuleInfo
  RuleWarning
  RuleError
} derive(Eq, 
Debug)

#
RuleValue

source
pub struct RuleValue {
  field : String
  value : Float
} derive(Eq, 
Debug)

#
RuleViolation

source
pub struct RuleViolation {
  code : String
  field : String
  actual : Float
  limit : Float
  severity : RuleSeverity
  message : String
} derive(Eq, 
Debug)

#
Safeguard

source
pub struct Safeguard {
  name : String
  kind : String
  independent : Bool
  test_interval_hours : Float
  enabled : Bool
}

#
Safeguard::reliable

source
fn Safeguard::reliable(self : Safeguard) -> Bool

#
Safeguard::valid

source
fn Safeguard::valid(self : Safeguard) -> Bool

#
SafetyReview

source
pub struct SafetyReview {
  name : String
  measured : Float
  design_limit : Float
  warning_fraction : Float
  unit : String
} derive(Eq, 
Debug)

#
SafetyReview::is_exceeded

source
fn SafetyReview::is_exceeded(self : SafetyReview) -> Bool

#
SafetyReview::is_warning

source
fn SafetyReview::is_warning(self : SafetyReview) -> Bool

#
SafetyReview::status

source
fn SafetyReview::status(self : SafetyReview) -> String

#
SafetyReview::utilization

source
fn SafetyReview::utilization(self : SafetyReview) -> Float

#
Sample

source
pub struct Sample {
  timestamp : Float
  value : Float
} derive(Eq, 
Debug)

#
Sample::is_finite

source
fn Sample::is_finite(self : Sample) -> Bool

#
ScenarioPoint

source
pub struct ScenarioPoint {
  name : String
  input : Float
  output : Float
  score : Float
  status : ResultStatus
  note : String
} derive(Eq, 
Debug)

#
ScenarioPoint::efficiency

source
fn ScenarioPoint::efficiency(self : ScenarioPoint) -> Float

#
ScenarioPoint::is_acceptable

source
fn ScenarioPoint::is_acceptable(self : ScenarioPoint, minimum_score : Float) -> Bool

#
ScenarioSeries

source
pub struct ScenarioSeries {
  name : String
  points : Array[ScenarioPoint]
  input_unit : String
  output_unit : String
} derive(Eq, 
Debug)

#
ScenarioSeries::acceptable

source
fn ScenarioSeries::acceptable(self : ScenarioSeries, minimum_score : Float) -> Array[ScenarioPoint]

#
ScenarioSeries::at

source
fn ScenarioSeries::at(self : ScenarioSeries, index : Int) -> ScenarioPoint?

#
ScenarioSeries::best

source

#
ScenarioSeries::count

source
fn ScenarioSeries::count(self : ScenarioSeries) -> Int

#
ScenarioSeries::flagged

source

#
ScenarioSeries::inputs

source
fn ScenarioSeries::inputs(self : ScenarioSeries) -> Array[Float]

#
ScenarioSeries::merge

source

#
ScenarioSeries::normalized

source
fn ScenarioSeries::normalized(self : ScenarioSeries) -> ScenarioSeries

#
ScenarioSeries::outputs

source
fn ScenarioSeries::outputs(self : ScenarioSeries) -> Array[Float]

#
ScenarioSeries::quality_gate

source
fn ScenarioSeries::quality_gate(self : ScenarioSeries, minimum_score : Float, maximum_flagged : Int) -> Bool

#
ScenarioSeries::report_section

source
fn ScenarioSeries::report_section(self : ScenarioSeries) -> ReportSection

#
ScenarioSeries::scores

source
fn ScenarioSeries::scores(self : ScenarioSeries) -> Array[Float]

#
ScenarioSeries::summary

source

#
ScenarioSeries::to_csv

source
fn ScenarioSeries::to_csv(self : ScenarioSeries) -> String

#
ScenarioSeries::to_markdown

source
fn ScenarioSeries::to_markdown(self : ScenarioSeries) -> String

#
ScenarioSeries::to_table

source
fn ScenarioSeries::to_table(self : ScenarioSeries) -> ReportTable

#
ScenarioSeries::with_point

source
fn ScenarioSeries::with_point(self : ScenarioSeries, point : ScenarioPoint) -> ScenarioSeries

#
ScenarioSeries::worst

source

#
ScheduleBlock

source
pub struct ScheduleBlock {
  id : String
  asset : String
  kind : ScheduleKind
  start_hour : Float
  duration_hours : Float
  priority : Int
  operator : String
}

#
ScheduleBlock::end_hour

source
fn ScheduleBlock::end_hour(self : ScheduleBlock) -> Float

#
ScheduleBlock::overlaps

source
fn ScheduleBlock::overlaps(self : ScheduleBlock, other : ScheduleBlock) -> Bool

#
ScheduleBlock::valid

source
fn ScheduleBlock::valid(self : ScheduleBlock) -> Bool

#
ScheduleKind

source
pub enum ScheduleKind {
  Production
  Cleaning
  Maintenance
  Inspection
  Changeover
}

Campaign scheduling, resource loading, and maintenance windows.

#
SectionKind

source
pub enum SectionKind {
  Context
  Method
  Safety
  Notes
} derive(Eq, 
Debug)

#
SensitivityAnalysis

source
pub struct SensitivityAnalysis {
  baseline : Float
  points : Array[SensitivityPoint]
} derive(Eq, 
Debug)

#
SensitivityAnalysis::count

source
fn SensitivityAnalysis::count(self : SensitivityAnalysis) -> Int

#
SensitivityAnalysis::maximum

source

#
SensitivityAnalysis::mean_response

source
fn SensitivityAnalysis::mean_response(self : SensitivityAnalysis) -> Float

#
SensitivityAnalysis::minimum

source

#
SensitivityAnalysis::ranked

source

#
SensitivityAnalysis::to_table

source

#
SensitivityPoint

source
pub struct SensitivityPoint {
  parameter : String
  change : Float
  response : Float
} derive(Eq, 
Debug)

#
SensitivityPoint::elasticity

source
fn SensitivityPoint::elasticity(self : SensitivityPoint) -> Float

#
Shift

source
pub struct Shift {
  name : String
  start_hour : Float
  end_hour : Float
  crew : Int
}

#
Shift::hours

source
fn Shift::hours(self : Shift) -> Float

#
Shift::valid

source
fn Shift::valid(self : Shift) -> Bool

#
SourceKind

source
pub enum SourceKind {
  Standard
  Datasheet
  Literature
  Internal
} derive(Eq, 
Debug)

#
SourceRef

source
pub struct SourceRef {
  label : String
  kind : SourceKind
  url : String?
  license : String?
  note : String?
} derive(Eq, 
Debug)

#
Statistics

source
pub struct Statistics {
  count : Int
  minimum : Float
  maximum : Float
  mean : Float
  variance : Float
  standard_deviation : Float
  sum : Float
} derive(Eq, 
Debug)

#
StreamDifference

source
pub struct StreamDifference {
  component : String
  left : Float
  right : Float
  difference : Float
  relative_difference : Float
} derive(Eq, 
Debug)

#
StreamDirection

source
pub enum StreamDirection {
  Inlet
  Outlet
} derive(Eq, 
Debug)

#
StreamInventory

source
pub struct StreamInventory {
  name : String
  items : Array[InventoryItem]
} derive(Eq, 
Debug)

#
StreamInventory::component_count

source
fn StreamInventory::component_count(self : StreamInventory) -> Int

#
StreamInventory::component_flow

source
fn StreamInventory::component_flow(self : StreamInventory, component : String) -> Float

#
StreamInventory::component_names

source
fn StreamInventory::component_names(self : StreamInventory) -> Array[String]

#
StreamInventory::fraction

source
fn StreamInventory::fraction(self : StreamInventory, component : String) -> Float

#
StreamInventory::is_empty

source
fn StreamInventory::is_empty(self : StreamInventory) -> Bool

#
StreamInventory::largest_component

source
fn StreamInventory::largest_component(self : StreamInventory) -> String?

#
StreamInventory::mass_fraction

source
fn StreamInventory::mass_fraction(self : StreamInventory, component : String) -> Float

#
StreamInventory::normalize

source
fn StreamInventory::normalize(self : StreamInventory, target : MeasureUnit) -> Result[StreamInventory, QuantityError]

#
StreamInventory::smallest_component

source
fn StreamInventory::smallest_component(self : StreamInventory) -> String?

#
StreamInventory::to_json

source
fn StreamInventory::to_json(self : StreamInventory) -> String

#
StreamInventory::to_markdown

source
fn StreamInventory::to_markdown(self : StreamInventory) -> String

#
StreamInventory::to_table

source

#
StreamInventory::total_flow

source
fn StreamInventory::total_flow(self : StreamInventory) -> Float

#
StreamInventory::with_item

source

#
StreamInventory::without_component

source
fn StreamInventory::without_component(self : StreamInventory, component : String) -> StreamInventory

#
SweepConfig

source
pub struct SweepConfig {
  start : Float
  stop : Float
  steps : Int
  label : String
} derive(Eq, 
Debug)

#
SweepConfig::is_valid

source
fn SweepConfig::is_valid(self : SweepConfig) -> Bool

#
SweepConfig::values

source
fn SweepConfig::values(self : SweepConfig) -> Array[Float]

#
TankDesign

source
pub struct TankDesign {
  diameter : Float
  height : Float
  working_level : Float
  dead_volume : Float
  overflow_level : Float
} derive(Eq, 
Debug)

#
TankDesign::cross_section

source
fn TankDesign::cross_section(self : TankDesign) -> Float

#
TankDesign::is_acceptable

source
fn TankDesign::is_acceptable(self : TankDesign) -> Bool

#
TankDesign::overflow_volume

source
fn TankDesign::overflow_volume(self : TankDesign) -> Float

#
TankDesign::residence_time

source
fn TankDesign::residence_time(self : TankDesign, flow_rate : Float) -> Float

#
TankDesign::usable_volume

source
fn TankDesign::usable_volume(self : TankDesign) -> Float

#
TankDesign::working_volume

source
fn TankDesign::working_volume(self : TankDesign) -> Float

#
TemplateCatalog

source
pub struct TemplateCatalog {
  templates : Array[ReportTemplate]
} derive(Eq, 
Debug)

#
TemplateCatalog::add

source

#
TemplateCatalog::count

source
fn TemplateCatalog::count(self : TemplateCatalog) -> Int

#
TemplateCatalog::find

source
fn TemplateCatalog::find(self : TemplateCatalog, name : String) -> ReportTemplate?

#
TemplateCatalog::names

source
fn TemplateCatalog::names(self : TemplateCatalog) -> Array[String]

#
TemplateCatalog::render_index

source
fn TemplateCatalog::render_index(self : TemplateCatalog) -> String

#
TemplateField

source
pub struct TemplateField {
  name : String
  requirement : FieldRequirement
} derive(Eq, 
Debug)

#
TemplateValue

source
pub struct TemplateValue {
  name : String
  value : String
} derive(Eq, 
Debug)

#
TimeSeries

source
pub struct TimeSeries {
  name : String
  samples : Array[Sample]
} derive(Eq, 
Debug)

#
TimeSeries::append

source
fn TimeSeries::append(self : TimeSeries, point : Sample) -> TimeSeries

#
TimeSeries::at

source
fn TimeSeries::at(self : TimeSeries, index : Int) -> Sample?

#
TimeSeries::between

source
fn TimeSeries::between(self : TimeSeries, start : Float, stop : Float) -> TimeSeries

#
TimeSeries::ewma

source
fn TimeSeries::ewma(self : TimeSeries, alpha : Float) -> TimeSeries

#
TimeSeries::first_derivative

source
fn TimeSeries::first_derivative(self : TimeSeries) -> TimeSeries

#
TimeSeries::integral

source
fn TimeSeries::integral(self : TimeSeries) -> Float

#
TimeSeries::interpolate

source
fn TimeSeries::interpolate(self : TimeSeries, timestamp : Float) -> Float?

#
TimeSeries::length

source
fn TimeSeries::length(self : TimeSeries) -> Int

#
TimeSeries::moving_average

source
fn TimeSeries::moving_average(self : TimeSeries, window : Int) -> TimeSeries

#
TimeSeries::normal

source
fn TimeSeries::normal(self : TimeSeries, threshold : Float) -> Array[Sample]

#
TimeSeries::outliers

source
fn TimeSeries::outliers(self : TimeSeries, threshold : Float) -> Array[Sample]

#
TimeSeries::quality_gate

source
fn TimeSeries::quality_gate(self : TimeSeries, minimum_count : Int, maximum_outliers : Int, threshold : Float) -> Bool

#
TimeSeries::range

source
fn TimeSeries::range(self : TimeSeries) -> Float

#
TimeSeries::resample

source
fn TimeSeries::resample(self : TimeSeries, timestamps : Array[Float]) -> TimeSeries

#
TimeSeries::summary

source
fn TimeSeries::summary(self : TimeSeries) -> Statistics

#
TimeSeries::time_weighted_mean

source
fn TimeSeries::time_weighted_mean(self : TimeSeries) -> Float

#
TimeSeries::timestamps

source
fn TimeSeries::timestamps(self : TimeSeries) -> Array[Float]

#
TimeSeries::to_markdown

source
fn TimeSeries::to_markdown(self : TimeSeries) -> String

#
TimeSeries::to_table

source
fn TimeSeries::to_table(self : TimeSeries) -> ReportTable

#
TimeSeries::trend

source
fn TimeSeries::trend(self : TimeSeries) -> Float

#
TimeSeries::trend_report

source
fn TimeSeries::trend_report(self : TimeSeries) -> ReportSection

#
TimeSeries::valid

source
fn TimeSeries::valid(self : TimeSeries) -> TimeSeries

#
TimeSeries::values

source
fn TimeSeries::values(self : TimeSeries) -> Array[Float]

#
TrayStage

source
pub struct TrayStage {
  number : Int
  efficiency : Float
  liquid_flow : Float
  vapor_flow : Float
}

#
TrayStage::capacity_ratio

source
fn TrayStage::capacity_ratio(self : TrayStage) -> Float

#
TrayStage::effective_stage

source
fn TrayStage::effective_stage(self : TrayStage) -> Float

#
TrendSummary

source
pub struct TrendSummary {
  slope : Float
  intercept : Float
  r_squared : Float
  direction : String
} derive(Eq, 
Debug)

#
Uncertainty

source
pub struct Uncertainty {
  nominal : Float
  lower : Float
  upper : Float
  confidence : Float
} derive(Eq, 
Debug)

#
Uncertainty::contains

source
fn Uncertainty::contains(self : Uncertainty, value : Float) -> Bool

#
Uncertainty::expand

source
fn Uncertainty::expand(self : Uncertainty, factor : Float) -> Uncertainty

#
Uncertainty::half_width

source
fn Uncertainty::half_width(self : Uncertainty) -> Float

#
Uncertainty::is_valid

source
fn Uncertainty::is_valid(self : Uncertainty) -> Bool

#
Uncertainty::relative_width

source
fn Uncertainty::relative_width(self : Uncertainty) -> Float

#
Uncertainty::shift

source
fn Uncertainty::shift(self : Uncertainty, delta : Float) -> Uncertainty

#
Uncertainty::width

source
fn Uncertainty::width(self : Uncertainty) -> Float

#
UnitDimension

source
pub enum UnitDimension {
  Mass
  Amount
  Volume
  Length
  Pressure
  Energy
  Power
  Temperature
  Time
  Dimensionless
} derive(Eq, 
Debug)

#
UtilityLoad

source
pub struct UtilityLoad {
  name : String
  demand : Float
  availability : Float
  priority : Int
} derive(Eq, 
Debug)

#
UtilityLoad::is_supplied

source
fn UtilityLoad::is_supplied(self : UtilityLoad) -> Bool

#
UtilityLoad::margin

source
fn UtilityLoad::margin(self : UtilityLoad) -> Float

#
UtilityLoad::utilization

source
fn UtilityLoad::utilization(self : UtilityLoad) -> Float

#
ValidationIssue

source
pub struct ValidationIssue {
  path : String
  message : String
} derive(Eq, 
Debug)

#
ValveDesign

source
pub struct ValveDesign {
  flow_coefficient : Float
  pressure_drop : Float
  density : Float
  opening : Float
  maximum_flow : Float
} derive(Eq, 
Debug)

#
ValveDesign::capacity_margin

source
fn ValveDesign::capacity_margin(self : ValveDesign) -> Float

#
ValveDesign::estimated_flow

source
fn ValveDesign::estimated_flow(self : ValveDesign) -> Float

#
ValveDesign::is_acceptable

source
fn ValveDesign::is_acceptable(self : ValveDesign) -> Bool

#
VesselDesign

source
pub struct VesselDesign {
  volume : Float
  liquid_volume : Float
  design_pressure : Float
  allowable_pressure : Float
  design_temperature : Float
  allowable_temperature : Float
} derive(Eq, 
Debug)

#
VesselDesign::fill_fraction

source
fn VesselDesign::fill_fraction(self : VesselDesign) -> Float

#
VesselDesign::is_acceptable

source
fn VesselDesign::is_acceptable(self : VesselDesign) -> Bool

#
VesselDesign::pressure_margin

source
fn VesselDesign::pressure_margin(self : VesselDesign) -> Float

#
VesselDesign::recommended_relief_pressure

source
fn VesselDesign::recommended_relief_pressure(self : VesselDesign, factor : Float) -> Float

#
VesselDesign::temperature_margin

source
fn VesselDesign::temperature_margin(self : VesselDesign) -> Float

#
VesselDesign::volume_margin

source
fn VesselDesign::volume_margin(self : VesselDesign) -> Float

#
WallLayer

source
pub struct WallLayer {
  name : String
  thickness_m : Float
  conductivity_w_mk : Float
}

Heat-transfer balances for preliminary equipment sizing.

#
WallLayer::resistance

source
fn WallLayer::resistance(self : WallLayer, area_m2 : Float) -> Float

#
WarningNote

source
pub struct WarningNote {
  code : String
  severity : WarningSeverity
  summary : String
  action : String
} derive(Eq, 
Debug)

#
WarningSeverity

source
pub enum WarningSeverity {
  Info
  Warning
  Critical
} derive(Eq, 
Debug)

#
WeightedObjective

source
pub struct WeightedObjective {
  weights : Array[Float]
  offset : Float
} derive(Eq, 
Debug)

#
WeightedObjective::evaluate

source
fn WeightedObjective::evaluate(self : WeightedObjective, variables : Array[Float]) -> Float

#
WeightedObjective::rank

source

#
WorkflowStatus

source
pub enum WorkflowStatus {
  Draft
  Review
  Approved
  Rejected
  Archived
} derive(Eq, 
Debug)

#
WorkflowStep

source
pub struct WorkflowStep {
  name : String
  owner : String
  status : WorkflowStatus
  note : String
} derive(Eq, 
Debug)

#
WorkflowStep::is_complete

source
fn WorkflowStep::is_complete(self : WorkflowStep) -> Bool

#
above_control_limit

source
fn above_control_limit() -> ObservationFlag

#
absorber_design

source
fn absorber_design(gas_flow_mol_h : Float, liquid_flow_mol_h : Float, inlet_gas_fraction : Float, outlet_gas_fraction : Float, equilibrium : EquilibriumLine, overall_kya_h : Float) -> AbsorberDesign

#
alarm

source
fn alarm(code : String, tag : String, value : Float, low : Float, high : Float, message : String) -> Alarm

#
alarm_board

source
fn alarm_board(alarms : Array[Alarm], updated_at : String) -> AlarmBoard

#
annual_cost

source
fn annual_cost(model : CostModel, periods : Int) -> Float

#
annualized_energy

source
fn annualized_energy(power : Float, operating_hours : Float) -> Float

#
antoine

source
fn antoine(a : Float, b : Float, c : Float, minimum_c : Float, maximum_c : Float) -> AntoineCorrelation

#
archive_step

source
fn archive_step(name : String, owner : String, note : String) -> WorkflowStep

#
arrhenius

source
fn arrhenius(pre_exponential : Float, activation_energy_kj : Float, reference_temperature_k : Float) -> ArrheniusModel

#
audit_event

source
fn audit_event(timestamp : String, actor : String, action : String, object : String) -> AuditEvent

#
audit_quality_gate

source
fn audit_quality_gate(trail : AuditTrail) -> Bool

#
audit_trail

source
fn audit_trail(events : Array[AuditEvent]) -> AuditTrail

#
automatic_mode

source
fn automatic_mode() -> ControllerMode

#
balance_error_percent

source
fn balance_error_percent(inlet : Float, outlet : Float) -> Float

#
balance_residual

source
fn balance_residual(inlet : Float, outlet : Float) -> Float

#
bar

source
fn bar() -> MeasureUnit

#
base_unit

source
fn base_unit(dimension : UnitDimension) -> MeasureUnit

#
batch_campaign_scrap

source
fn batch_campaign_scrap(records : Array[BatchRecord]) -> Float

#
batch_campaign_yield

source
fn batch_campaign_yield(records : Array[BatchRecord], input_kg : Float) -> Float

#
batch_charge

source
fn batch_charge(material : String, mass_kg : Float, purity : Float) -> BatchCharge

#
batch_plan

source
fn batch_plan(recipe : BatchRecipe, steps : Array[BatchStep], cleaning_hours : Float, setup_hours : Float) -> BatchPlan

#
batch_recipe

source
fn batch_recipe(name : String, target_kg : Float, charges : Array[BatchCharge], hold_hours : Float, yield_fraction : Float) -> BatchRecipe

#
batch_record

source
fn batch_record(id : String, plan_name : String, started_at : String, finished_at : String, output_kg : Float, scrap_kg : Float, accepted : Bool) -> BatchRecord

#
batch_records_acceptance

source
fn batch_records_acceptance(records : Array[BatchRecord]) -> Float

#
batch_records_table

source
fn batch_records_table(records : Array[BatchRecord]) -> ReportTable

#
batch_records_total

source
fn batch_records_total(records : Array[BatchRecord]) -> Float

#
batch_report

source
fn batch_report(reports : Array[ChemReport], labels : Array[String]) -> BatchReport

#
batch_scale

source
fn batch_scale(plan : BatchPlan, factor : Float) -> BatchPlan

#
batch_step

source
fn batch_step(name : String, duration_hours : Float, temperature_c : Float, pressure_bar : Float, agitation_rpm : Float) -> BatchStep

#
below_control_limit

source
fn below_control_limit() -> ObservationFlag

#
benchmark_exports

source
fn benchmark_exports(reports : Array[ChemReport], iterations : Int) -> BenchmarkResult

#
best_candidate

source
fn best_candidate(candidates : Array[Candidate]) -> Candidate?

#
bow_tie

source
fn bow_tie(hazard : String, threats : Array[String], preventive : Array[Safeguard], mitigative : Array[Safeguard]) -> BowTie

#
break_even_quantity

source
fn break_even_quantity(fixed_cost : Float, price : Float, variable_cost : Float) -> Float

#
candidate

source
fn candidate(name : String, variables : Array[Float], score : Float) -> Candidate

#
candidate_table

source
fn candidate_table(candidates : Array[Candidate]) -> ReportTable

#
carbon_emission

source
fn carbon_emission(energy : Float, factor : EmissionFactor) -> Emission

#
carbon_intensity

source
fn carbon_intensity(energy : Float, emission_factor : Float) -> Float

#
cascade_mode

source
fn cascade_mode() -> ControllerMode

#
catalyst_productivity

source
fn catalyst_productivity(product_kg : Float, catalyst_kg : Float, hours : Float) -> Float

#
catastrophic

source
fn catastrophic() -> RiskSeverity

#
celsius

source
fn celsius() -> MeasureUnit

#
changeover_schedule

source
fn changeover_schedule() -> ScheduleKind

#
chemical_properties

source
fn chemical_properties(name : String, molecular_weight : Float, density : LinearProperty, viscosity : LinearProperty, heat_capacity : LinearProperty, vapor_pressure : AntoineCorrelation) -> ChemicalPropertySet

#
clamp

source
fn clamp(value : Float, minimum : Float, maximum : Float) -> Float

#
classify_series

source
fn classify_series(series : ScenarioSeries, lower : Float, upper : Float) -> ScenarioSeries

#
cleaning_schedule

source
fn cleaning_schedule() -> ScheduleKind

#
coefficient_of_variation

source
fn coefficient_of_variation(values : Array[Float]) -> Float?

#
combine_by_component

source
fn combine_by_component(streams : Array[StreamInventory], component : String) -> Float

#
compare_reports

source
fn compare_reports(left : ChemReport, right : ChemReport) -> Array[Diagnostic]

#
compare_streams

source
fn compare_streams(left : StreamInventory, right : StreamInventory) -> Array[StreamDifference]

#
compatible

source
fn compatible(left : MeasureUnit, right : MeasureUnit) -> Bool

#
completeness

source
fn completeness(fields : Array[DataField]) -> Float

#
completeness_score

source
fn completeness_score(report : ChemReport) -> Float

#
component_flow

source
fn component_flow(component : String, value : Float, unit : MeasureUnit) -> ComponentFlow

#
component_loss

source
fn component_loss(feed : StreamInventory, product : StreamInventory, component : String) -> Float

#
component_recovery

source
fn component_recovery(feed : StreamInventory, product : StreamInventory, component : String) -> Float

#
compressor_design

source
fn compressor_design(suction_pressure : Float, discharge_pressure : Float, inlet_temperature : Float, flow_rate : Float, efficiency : Float, gas_constant : Float, heat_capacity_ratio : Float) -> CompressorDesign

#
conduction_resistance

source
fn conduction_resistance(thickness_m : Float, conductivity_w_mk : Float, area_m2 : Float) -> Float

#
constraint

source
fn constraint(index : Int, lower : Float, upper : Float) -> Constraint

#
constraint_violation

source
fn constraint_violation(candidate : Candidate, constraints : Array[Constraint]) -> Float

#
contribution_margin

source
fn contribution_margin(price : Float, variable_cost : Float) -> Float

#
control_limits

source
fn control_limits(values : Array[Float]) -> ControlLimits

#
control_loop

source
fn control_loop(controllers : Array[Controller], alarms : AlarmBoard) -> ControlLoop

#
control_quality_gate

source
fn control_quality_gate(control : ControlLoop, maximum_active_alarms : Int) -> Bool

#
controller

source
fn controller(tag : String, setpoint : Float, process_value : Float, output : Float, gain : Float, integral : Float, mode : ControllerMode) -> Controller

#
controller_error

source
fn controller_error(controller : Controller) -> Float

#
convection_resistance

source
fn convection_resistance(coefficient_w_m2k : Float, area_m2 : Float) -> Float

#
correlation_squared

source
fn correlation_squared(left : Array[Float], right : Array[Float]) -> Float

#
cost_item

source
fn cost_item(name : String, quantity : Float, unit_cost : Float, category : String) -> CostItem

#
cost_model

source
fn cost_model(items : Array[CostItem], currency : String, period : String) -> CostModel

#
cost_quality_gate

source
fn cost_quality_gate(model : CostModel) -> Bool

#
cstr_design

source
fn cstr_design(volume_m3 : Float, flow_m3_h : Float, rate_mol_m3_h : Float, feed_mol_m3 : Float) -> CstrDesign

#
data_field

source
fn data_field(name : String, value : String?, expected_unit : String?, policy : MissingPolicy) -> DataField

#
data_quality

source
fn data_quality(name : String, completeness : Float, validity : Float, timeliness : Float, consistency : Float) -> DataQuality

#
data_quality_gate

source
fn data_quality_gate(fields : Array[DataField], minimum : Float) -> Bool

#
delimited_row

source
fn delimited_row(fields : Array[String], line_number : Int) -> DelimitedRow

#
delimited_table

source
fn delimited_table(headers : Array[String], rows : Array[DelimitedRow], delimiter : String) -> DelimitedTable

#
diagnose_report

source
fn diagnose_report(report : ChemReport) -> DiagnosticReport

#
diagnostic

source
fn diagnostic(code : String, severity : DiagnosticSeverity, path : String, message : String, remediation : String) -> Diagnostic

#
diagnostic_report

source
fn diagnostic_report(diagnostics : Array[Diagnostic]) -> DiagnosticReport

#
discount_factor

source
fn discount_factor(rate : Float, period : Int) -> Float

#
distillation_case

source
fn distillation_case(feed_rate : Float, feed_fraction : Float, distillate_rate : Float, distillate_fraction : Float, bottoms_rate : Float, bottoms_fraction : Float, reflux_ratio : Float, stages : Int) -> DistillationCase

#
duplicate_headers

source
fn duplicate_headers(headers : Array[String]) -> Array[String]

#
earliest_available

source
fn earliest_available(calendar : ResourceCalendar, duration_hours : Float, from_hour : Float) -> Float

#
elasticity

source
fn elasticity(input_before : Float, input_after : Float, output_before : Float, output_after : Float) -> Float

#
emission

source
fn emission(pollutant : String, amount : Float, unit : String, source : String) -> Emission

#
emission_factor

source
fn emission_factor(pollutant : String, factor : Float, unit : String, source : String) -> EmissionFactor

#
emission_intensity

source
fn emission_intensity(emissions : EnvironmentalInventory, production : Float) -> Float

#
energy_balance

source
fn energy_balance(streams : Array[EnergyStream]) -> EnergyBalance

#
energy_cost

source
fn energy_cost(energy : Float, rate : Float, demand_charge : Float, fixed_charge : Float) -> EnergyCost

#
energy_stream

source
fn energy_stream(name : String, duty : Quantity, direction : StreamDirection) -> EnergyStream

#
environmental_gate

source
fn environmental_gate(inventory : EnvironmentalInventory, maximum : Float) -> Bool

#
environmental_inventory

source
fn environmental_inventory(emissions : Array[Emission], period : String, facility : String) -> EnvironmentalInventory

#
environmental_section

source
fn environmental_section(inventory : EnvironmentalInventory) -> ReportSection

#
equal_to

source
fn equal_to() -> RuleOperator

#
equilibrium_line

source
fn equilibrium_line(slope : Float, intercept : Float) -> EquilibriumLine

#
escalation

source
fn escalation(value : Float, annual_rate : Float, years : Int) -> Float

#
evaluate_candidates

source
fn evaluate_candidates(candidates : Array[Candidate], constraints : Array[Constraint]) -> Array[Candidate]

#
evaluate_rules

source
fn evaluate_rules(rules : Array[Rule], values : Array[RuleValue]) -> RuleEvaluation

#
example_chemreport

source
fn example_chemreport() -> ChemReport

#
exchanger_area

source
fn exchanger_area(duty_kw : Float, coefficient_kw_m2k : Float, driving_force_k : Float, correction : Float) -> Float

#
exchanger_design

source
fn exchanger_design(area : Float, overall_u : Float, hot_inlet : Float, hot_outlet : Float, cold_inlet : Float, cold_outlet : Float, hot_capacity : Float, cold_capacity : Float) -> ExchangerDesign

#
failed_mode

source
fn failed_mode() -> ControllerMode

#
feasible

source
fn feasible(candidate : Candidate, constraints : Array[Constraint]) -> Bool

#
first_order_conversion

source
fn first_order_conversion(rate_constant : Float, residence_hours : Float) -> Float

#
first_order_half_life

source
fn first_order_half_life(rate_constant : Float) -> Float

#
frequent

source
fn frequent() -> RiskLikelihood

#
froude_number

source
fn froude_number(velocity : Float, length : Float, gravity : Float) -> Float

#
greater_than

source
fn greater_than() -> RuleOperator

#
hazard

source
fn hazard(id : String, node : String, deviation : String, cause : String, consequence : String, likelihood : RiskLikelihood, severity : RiskSeverity, safeguards : Array[String]) -> Hazard

#
heat_balance

source
fn heat_balance(inlet_kw : Float, reaction_kw : Float, utility_kw : Float, outlet_kw : Float) -> Float

#
heat_balance_gate

source
fn heat_balance_gate(error_kw : Float, tolerance_kw : Float) -> Bool

#
heat_duty

source
fn heat_duty(mass_flow_kg_h : Float, heat_capacity_kj_kgk : Float, delta_temperature_k : Float) -> Float

#
heat_duty_with_phase

source
fn heat_duty_with_phase(mass_flow_kg_h : Float, heat_capacity_kj_kgk : Float, delta_temperature_k : Float, latent_kj_kg : Float) -> Float

#
heat_exchanger_case

source
fn heat_exchanger_case(hot_inlet : Float, hot_outlet : Float, cold_inlet : Float, cold_outlet : Float, hot_capacity_rate : Float, cold_capacity_rate : Float, area : Float, overall_u : Float) -> HeatExchangerCase

#
heat_exchanger_check

source
fn heat_exchanger_check(area_m2 : Float, required_m2 : Float, duty_kw : Float, pressure_drop_bar : Float, max_pressure_drop_bar : Float) -> HeatExchangerCheck

#
heat_transfer_table

source
fn heat_transfer_table(checks : Array[HeatExchangerCheck]) -> ReportTable

#
ignore_missing

source
fn ignore_missing() -> MissingPolicy

#
import_gate

source
fn import_gate(data : DelimitedTable, minimum_quality : Float, required : Array[String]) -> Bool

#
import_issue

source
fn import_issue(line_number : Int, field : String, message : String, severity : String) -> ImportIssue

#
import_issues_table

source
fn import_issues_table(issues : Array[ImportIssue]) -> ReportTable

#
initial_workflow

source
fn initial_workflow(id : String, owner : String) -> ReportWorkflow

#
inlet

source
fn inlet() -> StreamDirection

#
inspection_schedule

source
fn inspection_schedule() -> ScheduleKind

#
insulation_design

source
fn insulation_design(thickness_m : Float, conductivity_w_mk : Float, area_m2 : Float, ambient_c : Float, process_c : Float) -> InsulationDesign

#
interpolate_linear

source
fn interpolate_linear(x : Float, x_one : Float, y_one : Float, x_two : Float, y_two : Float) -> Float

#
interpolate_scenario

source
fn interpolate_scenario(series : ScenarioSeries, input : Float) -> Float?

#
inventory_item

source
fn inventory_item(component : String, flow : Float, unit : MeasureUnit) -> InventoryItem

#
kelvin

source
fn kelvin() -> MeasureUnit

#
kg_per_hour

source
fn kg_per_hour() -> MeasureUnit

#
latent_duty

source
fn latent_duty(mass_flow : Float, latent_heat : Float, vapor_fraction : Float) -> Float

#
less_than

source
fn less_than() -> RuleOperator

#
likely

source
fn likely() -> RiskLikelihood

#
linear_property

source
fn linear_property(reference : Float, slope : Float, reference_temperature : Float) -> LinearProperty

#
liquid_state

source
fn liquid_state() -> PhaseState

#
lmtd

source
fn lmtd(hot_in : Float, hot_out : Float, cold_in : Float, cold_out : Float) -> Float

#
log_mean_temperature_difference

source
fn log_mean_temperature_difference(delta_one : Float, delta_two : Float) -> Float

#
loss_fraction

source
fn loss_fraction(inlet : Float, recovered : Float) -> Float

#
lower_bound_rule

source
fn lower_bound_rule(code : String, field : String, limit : Float, severity : RuleSeverity) -> Rule

#
maintenance_gate

source
fn maintenance_gate(tasks : Array[MaintenanceTask]) -> Bool

#
maintenance_schedule

source
fn maintenance_schedule() -> ScheduleKind

#
maintenance_table

source
fn maintenance_table(tasks : Array[MaintenanceTask]) -> ReportTable

#
maintenance_task

source
fn maintenance_task(asset : String, task : String, interval_hours : Float, operating_hours : Float, critical : Bool) -> MaintenanceTask

#
maintenance_window

source
fn maintenance_window(asset : String, due_hour : Float, duration_hours : Float, critical : Bool, completed : Bool) -> MaintenanceWindow

#
maintenance_windows_table

source
fn maintenance_windows_table(items : Array[MaintenanceWindow], current_hour : Float) -> ReportTable

#
major

source
fn major() -> RiskSeverity

#
manual_mode

source
fn manual_mode() -> ControllerMode

#
mass_transfer_coefficient

source
fn mass_transfer_coefficient(diffusivity_m2_s : Float, film_thickness_m : Float) -> Float

#
material_balance

source
fn material_balance(streams : Array[ProcessStream]) -> MaterialBalance

#
material_property

source
fn material_property(name : String, molecular_weight : Float, density : Float, heat_capacity : Float, boiling_point : Float, safety_limit : Float) -> MaterialProperty

#
mean

source
fn mean(values : Array[Float]) -> Float?

#
merge_reports

source
fn merge_reports(left : ChemReport, right : ChemReport) -> ChemReport

#
merge_rules

source
fn merge_rules(left : Array[Rule], right : Array[Rule]) -> Array[Rule]

#
minor

source
fn minor() -> RiskSeverity

#
missing_field_issues

source
fn missing_field_issues(data : DelimitedTable, required : Array[String]) -> Array[ImportIssue]

#
mix_streams

source
fn mix_streams(streams : Array[StreamInventory]) -> StreamInventory

#
mixture_density

source
fn mixture_density(items : Array[MixtureProperty], temperature_c : Float) -> Float

#
mixture_fraction_total

source
fn mixture_fraction_total(items : Array[MixtureProperty]) -> Float

#
mixture_heat_capacity

source
fn mixture_heat_capacity(items : Array[MixtureProperty], temperature_c : Float) -> Float

#
mixture_property

source
fn mixture_property(component : String, mole_fraction : Float, property : ChemicalPropertySet) -> MixtureProperty

#
mixture_valid

source
fn mixture_valid(items : Array[MixtureProperty]) -> Bool

#
mixture_vapor_pressure

source
fn mixture_vapor_pressure(items : Array[MixtureProperty], temperature_c : Float) -> Float

#
monte_carlo_summary

source
fn monte_carlo_summary(values : Array[Float]) -> MonteCarloSummary

#
moving_average

source
fn moving_average(values : Array[Float], window : Int) -> Array[Float]

#
nearest_scenario

source
fn nearest_scenario(series : ScenarioSeries, input : Float) -> ScenarioPoint?

#
negligible

source
fn negligible() -> RiskSeverity

#
net_present_value

source
fn net_present_value(initial : Float, cashflows : Array[Float], rate : Float) -> Float

#
non_negative_rule

source
fn non_negative_rule(code : String, field : String, severity : RuleSeverity) -> Rule

#
normal_observation

source
fn normal_observation() -> ObservationFlag

#
normalize_scores

source
fn normalize_scores(candidates : Array[Candidate]) -> Array[Candidate]

#
normalized_error

source
fn normalized_error(observed : Float, expected : Float) -> Float

#
optimization_report

source
fn optimization_report(candidates : Array[Candidate], constraints : Array[Constraint]) -> ReportSection

#
optimize

source
fn optimize(candidates : Array[Candidate], constraints : Array[Constraint]) -> Candidate?

#
optional

source
fn optional() -> FieldRequirement

#
outlet

source
fn outlet() -> StreamDirection

#
packed_column

source
fn packed_column(diameter_m : Float, packing_height_m : Float, packing_factor : Float, gas_velocity_m_s : Float, flooding_velocity_m_s : Float) -> PackedColumn

#
pareto_front

source
fn pareto_front(candidates : Array[Candidate]) -> Array[Candidate]

#
parse_delimited

source
fn parse_delimited(text : String, delimiter : String) -> DelimitedTable

#
parse_unit

source
fn parse_unit(text : String) -> MeasureUnit?

#
pascal

source
fn pascal() -> MeasureUnit

#
penalized_best

source
fn penalized_best(candidates : Array[Candidate], constraints : Array[Constraint], penalty : Float) -> Candidate?

#
penalty_score

source
fn penalty_score(candidate : Candidate, constraints : Array[Constraint], penalty : Float) -> Float

#
percent_change

source
fn percent_change(before : Float, after : Float) -> Float

#
percentile

source
fn percentile(values : Array[Float], percentile : Float) -> Float?

#
pfr_design

source
fn pfr_design(volume_m3 : Float, flow_m3_h : Float, inlet_mol_m3 : Float, rate_mol_m3_h : Float) -> PfrDesign

#
pipe_design

source
fn pipe_design(length : Float, diameter : Float, roughness : Float, flow_rate : Float, density : Float, viscosity : Float, allowable_drop : Float) -> PipeDesign

#
positive_rule

source
fn positive_rule(code : String, field : String, severity : RuleSeverity) -> Rule

#
possible

source
fn possible() -> RiskLikelihood

#
prandtl_number

source
fn prandtl_number(heat_capacity : Float, viscosity : Float, conductivity : Float) -> Float

#
present_value

source
fn present_value(cashflows : Array[Float], rate : Float) -> Float

#
pressure_drop_case

source
fn pressure_drop_case(length : Float, diameter : Float, velocity : Float, density : Float, viscosity : Float, roughness : Float, fittings_k : Float) -> PressureDropCase

#
production_economics

source
fn production_economics(revenue : Float, operating_cost : Float, capital_cost : Float, production : Float, lifetime : Int) -> ProductionEconomics

#
production_schedule

source
fn production_schedule() -> ScheduleKind

#
profile_from_fields

source
fn profile_from_fields(name : String, fields : Array[DataField]) -> QualityProfile

#
propagate_add

source
fn propagate_add(left : Uncertainty, right : Uncertainty) -> Uncertainty

#
propagate_divide

source
fn propagate_divide(left : Uncertainty, right : Uncertainty) -> Uncertainty

#
propagate_multiply

source
fn propagate_multiply(left : Uncertainty, right : Uncertainty) -> Uncertainty

#
propagate_scale

source
fn propagate_scale(value : Uncertainty, factor : Float) -> Uncertainty

#
propagate_subtract

source
fn propagate_subtract(left : Uncertainty, right : Uncertainty) -> Uncertainty

#
property_reynolds_number

source
fn property_reynolds_number(density : Float, velocity : Float, diameter : Float, viscosity : Float) -> Float

#
property_table

source
fn property_table(items : Array[MixtureProperty], temperature_c : Float) -> ReportTable

#
pump_case

source
fn pump_case(flow_rate : Float, differential_pressure : Float, efficiency : Float, fluid_density : Float, installed_power : Float) -> PumpCase

#
quality_dimension

source
fn quality_dimension(name : String, passed : Int, total : Int) -> QualityDimension

#
quality_gate

source
fn quality_gate(report : ChemReport) -> QualityGate

#
quality_profile

source
fn quality_profile(name : String, dimensions : Array[QualityDimension]) -> QualityProfile

#
quality_report

source
fn quality_report(profiles : Array[QualityProfile]) -> ReportTable

#
quantity

source
fn quantity(value : Float, unit : MeasureUnit) -> Quantity

#
radiation_coefficient

source
fn radiation_coefficient(emissivity : Float, hot_k : Float, cold_k : Float) -> Float

#
rare

source
fn rare() -> RiskLikelihood

#
reaction_heat

source
fn reaction_heat(duty_mol_h : Float, heat_kj_mol : Float) -> Float

#
reaction_order

source
fn reaction_order(order_a : Float, order_b : Float, stoich_a : Float, stoich_b : Float) -> ReactionOrder

#
reaction_path

source
fn reaction_path(name : String, conversion : Float, selectivity : Float, yield_fraction : Float) -> ReactionPath

#
reaction_path_table

source
fn reaction_path_table(paths : Array[ReactionPath]) -> ReportTable

#
reactor_case

source
fn reactor_case(name : String, feed : Float, product : Float, byproduct : Float, residence_time : Float, temperature : Float, pressure : Float) -> ReactorCase

#
reactor_gate

source
fn reactor_gate(conversion : Float, minimum : Float, temperature_c : Float, maximum_c : Float) -> Bool

#
recovery

source
fn recovery(inlet : Float, recovered : Float) -> Float

#
reduction_achieved

source
fn reduction_achieved(baseline : Float, current : Float) -> Float

#
reduction_target

source
fn reduction_target(baseline : Float, reduction : Float) -> Float

#
regression_gate

source
fn regression_gate(baseline : ChemReport, candidate : ChemReport) -> Bool

#
reject_missing

source
fn reject_missing() -> MissingPolicy

#
report

source
fn report(metadata : ReportMetadata, summary : String, assumptions : Array[Assumption], inputs : Array[InputValue], formulas : Array[FormulaNote], results : Array[ResultValue], warnings : Array[WarningNote], sources : Array[SourceRef], sections : Array[ReportSection], tags : Array[String]) -> ChemReport

#
report_builder

source
fn report_builder(value : ChemReport) -> ReportBuilder

#
report_template

source
fn report_template(name : String, fields : Array[TemplateField]) -> ReportTemplate

#
report_workflow

source
fn report_workflow(id : String, steps : Array[WorkflowStep]) -> ReportWorkflow

#
required

source
fn required() -> FieldRequirement

#
required_sections

source
fn required_sections(report : ChemReport) -> Array[String]

#
residence_time

source
fn residence_time(volume : Float, flow_rate : Float) -> Float

#
resource_calendar

source
fn resource_calendar(name : String, capacity_hours : Float, blocks : Array[ScheduleBlock]) -> ResourceCalendar

#
reynolds_number

source
fn reynolds_number(density : Float, velocity : Float, diameter : Float, viscosity : Float) -> Float

#
risk_priority_order

source
fn risk_priority_order(hazards : Array[Hazard]) -> Array[Hazard]

#
risk_reduction

source
fn risk_reduction(before : Hazard, after : Hazard) -> Int

#
risk_register

source
fn risk_register(hazards : Array[Hazard]) -> RiskRegister

#
risk_register_table

source
fn risk_register_table(register : RiskRegister) -> ReportTable

#
risk_summary

source
fn risk_summary(register : RiskRegister) -> String

#
rule

source
fn rule(code : String, operator : RuleOperator, field : String, limit : Float, severity : RuleSeverity) -> Rule

#
rule_codes

source
fn rule_codes(rules : Array[Rule]) -> Array[String]

#
rule_error

source
fn rule_error() -> RuleSeverity

#
rule_fields

source
fn rule_fields(rules : Array[Rule]) -> Array[String]

#
rule_gate

source
fn rule_gate(rules : Array[Rule], values : Array[RuleValue]) -> Bool

#
rule_info

source
fn rule_info() -> RuleSeverity

#
rule_summary

source
fn rule_summary(evaluation : RuleEvaluation) -> String

#
rule_value

source
fn rule_value(field : String, value : Float) -> RuleValue

#
rule_warning

source
fn rule_warning() -> RuleSeverity

#
run_sweep

source
fn run_sweep(config : SweepConfig, evaluate : (Float) -> Float) -> ScenarioSeries

#
safeguard

source
fn safeguard(name : String, kind : String, independent : Bool, test_interval_hours : Float, enabled : Bool) -> Safeguard

#
safety_factor

source
fn safety_factor(allowable : Float, applied : Float) -> Float

#
safety_review

source
fn safety_review(name : String, measured : Float, design_limit : Float, warning_fraction : Float, unit : String) -> SafetyReview

#
sample

source
fn sample(timestamp : Float, value : Float) -> Sample

#
scenario_distance

source
fn scenario_distance(left : ScenarioPoint, right : ScenarioPoint) -> Float

#
scenario_point

source
fn scenario_point(name : String, input : Float, output : Float, score : Float, status : ResultStatus, note : String) -> ScenarioPoint

#
scenario_series

source
fn scenario_series(name : String, points : Array[ScenarioPoint], input_unit : String, output_unit : String) -> ScenarioSeries

#
scenario_status

source
fn scenario_status(score : Float, lower : Float, upper : Float) -> ResultStatus

#
schedule_block

source
fn schedule_block(id : String, asset : String, kind : ScheduleKind, start_hour : Float, duration_hours : Float, priority : Int, operator : String) -> ScheduleBlock

#
schedule_load_gate

source
fn schedule_load_gate(calendar : ResourceCalendar, maximum_utilization : Float) -> Bool

#
schedule_table

source
fn schedule_table(blocks : Array[ScheduleBlock]) -> ReportTable

#
score_range

source
fn score_range(candidates : Array[Candidate]) -> Float

#
sensitivity

source
fn sensitivity(base : Float, delta : Float, response_base : Float, response_delta : Float) -> Float

#
sensitivity_analysis

source
fn sensitivity_analysis(baseline : Float, points : Array[SensitivityPoint]) -> SensitivityAnalysis

#
sensitivity_point

source
fn sensitivity_point(parameter : String, change : Float, response : Float) -> SensitivityPoint

#
serious

source
fn serious() -> RiskSeverity

#
sherwood_number

source
fn sherwood_number(coefficient_m_s : Float, length_m : Float, diffusivity_m2_s : Float) -> Float

#
shift

source
fn shift(name : String, start_hour : Float, end_hour : Float, crew : Int) -> Shift

#
solid_state

source
fn solid_state() -> PhaseState

#
sort_loads_by_priority

source
fn sort_loads_by_priority(loads : Array[UtilityLoad]) -> Array[UtilityLoad]

#
split_delimited_line

source
fn split_delimited_line(line : String, delimiter : String, line_number : Int) -> DelimitedRow

#
split_fractions_are_closed

source
fn split_fractions_are_closed(fractions : Array[Float], tolerance? : Float) -> Bool

#
split_stream

source
fn split_stream(source : StreamInventory, fractions : Array[Float]) -> Array[StreamInventory]

#
stage_efficiency_table

source
fn stage_efficiency_table(stages : Array[TrayStage]) -> ReportTable

#
standard_balance_template

source
fn standard_balance_template() -> ReportTemplate

#
standard_operations_template

source
fn standard_operations_template() -> ReportTemplate

#
standard_safety_template

source
fn standard_safety_template() -> ReportTemplate

#
standard_template_catalog

source
fn standard_template_catalog() -> TemplateCatalog

#
stream

source
fn stream(name : String, direction : StreamDirection, components : Array[ComponentFlow]) -> ProcessStream

#
stream_balance_error

source
fn stream_balance_error(left : StreamInventory, right : StreamInventory) -> Float

#
stream_difference_table

source
fn stream_difference_table(differences : Array[StreamDifference]) -> ReportTable

#
stream_directions

source
fn stream_directions() -> Array[StreamDirection]

#
stream_inventory

source
fn stream_inventory(name : String, items : Array[InventoryItem]) -> StreamInventory

#
stream_selectivity

source
fn stream_selectivity(product : StreamInventory, target : String, byproduct : String) -> Float

#
stream_yield

source
fn stream_yield(feed : StreamInventory, product : StreamInventory) -> Float

#
sum_negative

source
fn sum_negative(values : Array[Float]) -> Float

#
sum_positive

source
fn sum_positive(values : Array[Float]) -> Float

#
summarize

source
fn summarize(values : Array[Float]) -> Statistics

#
supercritical_state

source
fn supercritical_state() -> PhaseState

#
sweep_candidates

source
fn sweep_candidates(config : SweepConfig, objective : WeightedObjective) -> Array[Candidate]

#
sweep_config

source
fn sweep_config(start : Float, stop : Float, steps : Int, label : String) -> SweepConfig

#
table

source
fn table(columns : Array[String], rows : Array[Array[String]]) -> ReportTable

#
table_to_csv

source
fn table_to_csv(data : DelimitedTable) -> String

#
tank_design

source
fn tank_design(diameter : Float, height : Float, working_level : Float, dead_volume : Float, overflow_level : Float) -> TankDesign

#
template_catalog

source
fn template_catalog(templates : Array[ReportTemplate]) -> TemplateCatalog

#
template_completeness

source
fn template_completeness(template : ReportTemplate, values : Array[TemplateValue]) -> Float

#
template_field

source
fn template_field(name : String, requirement : FieldRequirement) -> TemplateField

#
template_quality_gate

source
fn template_quality_gate(template : ReportTemplate, values : Array[TemplateValue]) -> Bool

#
template_value

source
fn template_value(name : String, value : String) -> TemplateValue

#
template_values_from_inputs

source
fn template_values_from_inputs(inputs : Array[InputValue]) -> Array[TemplateValue]

#
thermal_duty

source
fn thermal_duty(mass_flow : Float, heat_capacity : Float, inlet : Float, outlet : Float) -> Float

#
thermal_expansion

source
fn thermal_expansion(density : Float, slope : Float) -> Float

#
time_series

source
fn time_series(name : String, samples : Array[Sample]) -> TimeSeries

#
total_crew_hours

source
fn total_crew_hours(shifts : Array[Shift]) -> Float

#
total_heat_duty

source
fn total_heat_duty(sensible : Float, latent : Float, reaction : Float) -> Float

#
total_utility_availability

source
fn total_utility_availability(loads : Array[UtilityLoad]) -> Float

#
total_utility_demand

source
fn total_utility_demand(loads : Array[UtilityLoad]) -> Float

#
transfer_duty

source
fn transfer_duty(flow_mol_h : Float, inlet_fraction : Float, outlet_fraction : Float) -> Float

#
transfer_gate

source
fn transfer_gate(removal : Float, target : Float) -> Bool

#
tray_stage

source
fn tray_stage(number : Int, efficiency : Float, liquid_flow : Float, vapor_flow : Float) -> TrayStage

#
trays_required

source
fn trays_required(theoretical_stages : Float, efficiency : Float) -> Float

#
trend_summary

source
fn trend_summary(series : TimeSeries) -> TrendSummary

#
turnover_rate

source
fn turnover_rate(volume : Float, flow_rate : Float) -> Float

#
uncertainty

source
fn uncertainty(nominal : Float, lower : Float, upper : Float, confidence : Float) -> Uncertainty

#
uncertainty_quality_gate

source
fn uncertainty_quality_gate(values : Array[Uncertainty]) -> Bool

#
uncertainty_table

source
fn uncertainty_table(values : Array[Uncertainty]) -> ReportTable

#
unit_revenue

source
fn unit_revenue(price : Float, quantity : Float) -> Float

#
unlikely

source
fn unlikely() -> RiskLikelihood

#
upper_bound_rule

source
fn upper_bound_rule(code : String, field : String, limit : Float, severity : RuleSeverity) -> Rule

#
use_default

source
fn use_default() -> MissingPolicy

#
utility_load

source
fn utility_load(name : String, demand : Float, availability : Float, priority : Int) -> UtilityLoad

#
utility_load_table

source
fn utility_load_table(loads : Array[UtilityLoad]) -> ReportTable

#
utility_margin

source
fn utility_margin(loads : Array[UtilityLoad]) -> Float

#
validate_fields

source
fn validate_fields(fields : Array[DataField]) -> Array[String]

#
valve_design

source
fn valve_design(flow_coefficient : Float, pressure_drop : Float, density : Float, opening : Float, maximum_flow : Float) -> ValveDesign

#
vapor_state

source
fn vapor_state() -> PhaseState

#
vessel_design

source
fn vessel_design(volume : Float, liquid_volume : Float, design_pressure : Float, allowable_pressure : Float, design_temperature : Float, allowable_temperature : Float) -> VesselDesign

#
wall_layer

source
fn wall_layer(name : String, thickness_m : Float, conductivity_w_mk : Float) -> WallLayer

#
weighted_mean

source
fn weighted_mean(values : Array[Float], weights : Array[Float]) -> Float?

#
weighted_objective

source
fn weighted_objective(weights : Array[Float], offset : Float) -> WeightedObjective

#
weighted_pressure_drop

source
fn weighted_pressure_drop(lengths : Array[Float], drops : Array[Float]) -> Float

#
workflow_gate

source
fn workflow_gate(workflow : ReportWorkflow) -> Bool

#
workflow_step

source
fn workflow_step(name : String, owner : String, status : WorkflowStatus, note : String) -> WorkflowStep

#
worst_candidate

source
fn worst_candidate(candidates : Array[Candidate]) -> Candidate?

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io