🥮 mooncakes.io
    Sign in

    zhaoyuanjuns/moonbit_extractor/process does not have a README file

    BalanceLedger

    source
    pub(all) struct BalanceLedger {
      entries : Array[StreamBalance]
      total_carrier_error : Double
      total_solvent_error : Double
      total_solute_error : Double
      maximum_relative_error : Double
      closed : Bool
    } derive(Eq, ToJson, 
    Debug    )

    ComponentLedger

    source
    pub(all) struct ComponentLedger {
      component : String
      feed : Double
      product : Double
      waste : Double
      recovered : Double
      recovery : Double
      closure_error : Double
    } derive(Eq, ToJson, 
    Debug    )

    EnvelopeSummary

    source
    pub(all) struct EnvelopeSummary {
      evaluated : Int
      feasible : Int
      infeasible : Int
      minimum_recovery : Double
      maximum_recovery : Double
      average_recovery : Double
      limiting_scenario : String
    } derive(Eq, ToJson, 
    Debug    )

    EquipmentKind

    source
    pub(all) enum EquipmentKind {
      Mixer
      Settler
      ExtractorColumn
      HeatExchanger
      Pump
      StorageTank
    } derive(Eq, ToJson, 
    Debug    )

    Equipment categories used for preliminary process sizing.

    EquipmentSizing

    source
    pub(all) struct EquipmentSizing {
      name : String
      kind : EquipmentKind
      working_volume : Double
      design_volume : Double
      cross_section_area : Double
      diameter : Double
      heat_transfer_area : Double
      pump_head : Double
      warnings : Array[String]
    } derive(Eq, ToJson, 
    Debug    )

    EquipmentSpec

    source
    pub(all) struct EquipmentSpec {
      name : String
      kind : EquipmentKind
      design_flow : Double
      design_residence_time : Double
      design_pressure : Double
      design_temperature : Double
      safety_factor : Double
    } derive(Eq, ToJson, 
    Debug    )

    EquipmentSpec::new

    source
    fn EquipmentSpec::new(name~ : String, kind~ : EquipmentKind, design_flow~ : Double, design_residence_time~ : Double, design_pressure~ : Double, design_temperature~ : Double, safety_factor? : Double) -> EquipmentSpec raise 
    ExtractionError

    Flowsheet

    source
    pub(all) struct Flowsheet {
      name : String
      steps : Array[ProcessStep]
    } derive(Eq, ToJson, 
    Debug    )

    Flowsheet::add

    source
    fn Flowsheet::add(self : Flowsheet, step : ProcessStep) -> Flowsheet

    Flowsheet::new

    source

    Flowsheet::step_count

    source
    fn Flowsheet::step_count(self : Flowsheet) -> Int

    Flowsheet::steps

    source
    fn Flowsheet::steps(self : Flowsheet) -> Array[ProcessStep]

    FlowsheetResult

    source
    pub(all) struct FlowsheetResult {
      name : String
      inlet : ProcessStream
      outlet : ProcessStream
      steps : Array[StepResult]
      total_residual : Double
      maximum_step_residual : Double
      passed : Bool
    } derive(Eq, ToJson, 
    Debug    )

    HeatExchangerSizing

    source
    pub(all) struct HeatExchangerSizing {
      area : Double
      log_mean_temperature_difference : Double
      duty : Double
      hot_outlet_temperature : Double
      cold_outlet_temperature : Double
      pinch_temperature_difference : Double
    } derive(Eq, ToJson, 
    Debug    )

    LedgerEntry

    source
    pub(all) struct LedgerEntry {
      name : String
      inlet : Double
      outlet : Double
      generated : Double
      consumed : Double
      residual : Double
    } derive(Eq, ToJson, 
    Debug    )

    MixerSizing

    source
    pub(all) struct MixerSizing {
      volume : Double
      power : Double
      power_per_volume : Double
      tip_speed : Double
      torque : Double
    } derive(Eq, ToJson, 
    Debug    )

    OperatingLimit

    source
    pub(all) struct OperatingLimit {
      name : String
      lower : Double
      upper : Double
      unit : String
      critical : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Operating-envelope utilities for translating process limits into executable checks and scenario summaries.

    OperatingLimit::contains

    source
    fn OperatingLimit::contains(self : OperatingLimit, value : Double) -> Bool

    OperatingLimit::new

    source
    fn OperatingLimit::new(name~ : String, lower~ : Double, upper~ : Double, unit? : String, critical? : Bool) -> OperatingLimit raise 
    ExtractionError

    OperatingLimit::normalized_distance

    source
    fn OperatingLimit::normalized_distance(self : OperatingLimit, value : Double) -> Double

    OperatingLimit::to_text

    source
    fn OperatingLimit::to_text(self : OperatingLimit) -> String

    OperatingPoint

    source
    pub(all) struct OperatingPoint {
      name : String
      values : Array[Double]
      feasible : Bool
      violations : Array[String]
      distance_to_limit : Double
    } derive(Eq, ToJson, 
    Debug    )

    OperatingPoint::critical

    source
    fn OperatingPoint::critical(self : OperatingPoint, limits : ArrayView[OperatingLimit]) -> Bool

    OperatingPoint::margin_vector

    source
    fn OperatingPoint::margin_vector(self : OperatingPoint, limits : ArrayView[OperatingLimit]) -> Array[Double]

    OperatingPoint::new

    source

    OperatingWindow

    source
    pub(all) struct OperatingWindow {
      minimum_flow : Double
      maximum_flow : Double
      minimum_concentration : Double
      maximum_concentration : Double
      minimum_distribution : Double
      maximum_distribution : Double
      minimum_recovery : Double
      maximum_recovery : Double
    } derive(Eq, ToJson, 
    Debug    )

    Operating-window validation keeps a calculation inside a declared process envelope.

    OperatingWindow::contains

    source
    fn OperatingWindow::contains(self : OperatingWindow, flow : Double, concentration : Double, distribution : Double, recovery : Double) -> Bool

    OperatingWindow::new

    source
    fn OperatingWindow::new(flow~ : Range, concentration~ : Range, distribution~ : Range, recovery~ : Range) -> OperatingWindow

    OperatingWindow::validate

    source
    fn OperatingWindow::validate(self : OperatingWindow, flow : Double, concentration : Double, distribution : Double, recovery : Double) -> Array[Violation]

    OperationKind

    source
    pub(all) enum OperationKind {
      Contact(distribution~ : Double)
      Heat(outlet_temperature_kelvin~ : Double)
      Cool(outlet_temperature_kelvin~ : Double)
      PressureDrop(outlet_pressure_pascal~ : Double)
      Split(fraction~ : Double)
      HoldUp(residence_seconds~ : Double)
    } derive(Eq, ToJson, 
    Debug    )

    ProcessStep

    source
    pub(all) struct ProcessStep {
      name : String
      kind : OperationKind
    } derive(Eq, ToJson, 
    Debug    )

    ProcessStream

    source
    pub(all) struct ProcessStream {
      name : String
      carrier_flow : Double
      solvent_flow : Double
      carrier_concentration : Double
      solvent_concentration : Double
      temperature : 
    Temperature
      pressure : 
    Pressure
    } derive(Eq, ToJson, 
    Debug    )

    A stream state used by sequential flowsheet calculations.

    ProcessStream::carrier_solute

    source
    fn ProcessStream::carrier_solute(self : ProcessStream) -> Double

    ProcessStream::name

    source
    fn ProcessStream::name(self : ProcessStream) -> String

    ProcessStream::new

    source
    fn ProcessStream::new(name~ : String, carrier_flow~ : Double, solvent_flow~ : Double, carrier_concentration~ : Double, solvent_concentration? : Double, temperature~ : 
    Temperature    , pressure~ : 
    Pressure    ) -> ProcessStream raise 
    ExtractionError

    ProcessStream::overall_concentration

    source
    fn ProcessStream::overall_concentration(self : ProcessStream) -> Double

    ProcessStream::scale

    source

    ProcessStream::solvent_solute

    source
    fn ProcessStream::solvent_solute(self : ProcessStream) -> Double

    ProcessStream::total_flow

    source
    fn ProcessStream::total_flow(self : ProcessStream) -> Double

    ProcessStream::total_solute

    source
    fn ProcessStream::total_solute(self : ProcessStream) -> Double

    ProcessStream::with_name

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

    ProcessStream::with_pressure

    source

    ProcessStream::with_temperature

    source

    PumpSizing

    source
    pub(all) struct PumpSizing {
      head : Double
      hydraulic_power : Double
      shaft_power : Double
      efficiency : Double
      pressure_rise : Double
    } derive(Eq, ToJson, 
    Debug    )

    Range

    source
    pub(all) struct Range {
      lower : Double
      upper : Double
    } derive(Eq, ToJson, 
    Debug    )

    Range::new

    source
    fn Range::new(lower~ : Double, upper~ : Double) -> Range raise 
    ExtractionError

    RecycleResult

    source
    pub(all) struct RecycleResult {
      converged_stream : ProcessStream
      iterations : Int
      residual : Double
      converged : Bool
    } derive(Eq, ToJson, 
    Debug    )

    A recycle convergence result for a single recycle fraction.

    SafetyFactor

    source
    pub(all) struct SafetyFactor {
      nominal : Double
      factor : Double
      design : Double
    } derive(Eq, ToJson, 
    Debug    )

    ScenarioPoint

    source
    pub(all) struct ScenarioPoint {
      name : String
      temperature : Double
      pressure : Double
      flow : Double
      solvent_ratio : Double
      recovery : Double
      feasible : Bool
    } derive(Eq, ToJson, 
    Debug    )

    SettlerSizing

    source
    pub(all) struct SettlerSizing {
      volume : Double
      interface_area : Double
      length : Double
      width : Double
      height : Double
      overflow_rate : Double
    } derive(Eq, ToJson, 
    Debug    )

    StepResult

    source
    pub(all) struct StepResult {
      step_name : String
      inlet : ProcessStream
      outlet : ProcessStream
      residual : Double
      duty : Double
      warning : String
    } derive(Eq, ToJson, 
    Debug    )

    StreamBalance

    source
    pub(all) struct StreamBalance {
      stream : String
      carrier_in : Double
      carrier_out : Double
      solvent_in : Double
      solvent_out : Double
      solute_in : Double
      solute_out : Double
      carrier_error : Double
      solvent_error : Double
      solute_error : Double
      closed : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Mass-balance closure and utility accounting for process streams.

    StreamComparison

    source
    pub(all) struct StreamComparison {
      carrier_flow_change : Double
      solvent_flow_change : Double
      solute_change : Double
      temperature_change : Double
      pressure_change : Double
      concentration_change : Double
    } derive(Eq, ToJson, 
    Debug    )

    StreamStatistics

    source
    pub(all) struct StreamStatistics {
      stream : String
      total_flow : Double
      solute_flow : Double
      solute_fraction : Double
      concentration_ratio : Double
      thermal_content : Double
      pressure_energy : Double
    } derive(Eq, ToJson, 
    Debug    )

    UtilityAllocation

    source
    pub(all) struct UtilityAllocation {
      node : String
      requested : Double
      allocated : Double
      curtailed : Double
      fraction : Double
      served : Bool
    } derive(Eq, ToJson, 
    Debug    )

    UtilityNetwork

    source
    pub(all) struct UtilityNetwork {
      kind : String
      nodes : Array[UtilityNode]
      total_demand : Double
      total_capacity : Double
      utilization : Double
      feasible : Bool
      curtailed_demand : Double
    } derive(Eq, ToJson, 
    Debug    )

    UtilityNode

    source
    pub(all) struct UtilityNode {
      name : String
      demand : Double
      capacity : Double
      priority : Int
      available : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Violation

    source
    pub(all) enum Violation {
      BelowMinimum(name~ : String, value~ : Double, minimum~ : Double)
      AboveMaximum(name~ : String, value~ : Double, maximum~ : Double)
    } derive(Eq, ToJson, 
    Debug    )

    allocate_utility

    source
    fn allocate_utility(network : UtilityNetwork) -> Array[UtilityAllocation]

    allocations_curtailed

    source
    fn allocations_curtailed(allocations : ArrayView[UtilityAllocation]) -> Double

    allocations_failed_nodes

    source
    fn allocations_failed_nodes(allocations : ArrayView[UtilityAllocation]) -> Array[String]

    allocations_service_rate

    source
    fn allocations_service_rate(allocations : ArrayView[UtilityAllocation]) -> Double

    allocations_total

    source
    fn allocations_total(allocations : ArrayView[UtilityAllocation]) -> Double

    apply_safety_factor

    source
    fn apply_safety_factor(nominal~ : Double, factor~ : Double) -> SafetyFactor raise 
    ExtractionError

    apply_step

    source

    balance_error_vector

    source
    fn balance_error_vector(ledger : BalanceLedger) -> Array[Double]

    balance_ledger

    source
    fn balance_ledger(entries : ArrayView[StreamBalance], tolerance : Double) -> BalanceLedger

    balance_markdown

    source
    fn balance_markdown(ledger : BalanceLedger) -> String

    build_utility_network

    source
    fn build_utility_network(kind : String, nodes : ArrayView[UtilityNode]) -> UtilityNetwork

    cascade_recovery

    source
    fn cascade_recovery(stage_recoveries : ArrayView[Double]) -> Double raise 
    ExtractionError

    compare_streams

    source
    fn compare_streams(first : ProcessStream, second : ProcessStream) -> StreamComparison

    component_ledger

    source
    fn component_ledger(component : String, feed : Double, product : Double, waste : Double, tolerance : Double) -> ComponentLedger raise 
    ExtractionError

    component_ledger_csv

    source
    fn component_ledger_csv(ledgers : ArrayView[ComponentLedger]) -> String

    concentration_after_recovery

    source
    fn concentration_after_recovery(feed : Double, recovery : Double) -> Double raise 
    ExtractionError

    envelope_recovery

    source
    fn envelope_recovery(temperature : Double, pressure : Double, flow : Double, solvent_ratio : Double, equilibrium_factor : Double, stage_count : Int) -> Double raise 
    ExtractionError

    equipment_margin

    source
    fn equipment_margin(actual_flow~ : Double, design_flow~ : Double) -> Double raise 
    ExtractionError

    equipment_utilization

    source
    fn equipment_utilization(actual_flow~ : Double, design_flow~ : Double) -> Double raise 
    ExtractionError

    estimate_heat_duty

    source

    Estimate a heat duty from a flowsheet temperature change.

    evaluate_grid

    source

    feasible_points

    source
    fn feasible_points(points : ArrayView[OperatingPoint]) -> Array[OperatingPoint]

    flowsheet_ledger

    source

    Combine per-step material balances into ledger entries.

    infeasible_points

    source
    fn infeasible_points(points : ArrayView[OperatingPoint]) -> Array[OperatingPoint]

    ledger_entry

    source
    fn ledger_entry(name~ : String, inlet~ : Double, outlet~ : Double, generated? : Double, consumed? : Double) -> LedgerEntry raise 
    ExtractionError

    ledger_passes

    source
    fn ledger_passes(entries : ArrayView[LedgerEntry], tolerance~ : Double) -> Bool

    ledgers_reconciled

    source
    fn ledgers_reconciled(ledgers : ArrayView[ComponentLedger], tolerance : Double) -> Bool

    limits_minimum_span

    source
    fn limits_minimum_span(limits : ArrayView[OperatingLimit]) -> Double

    make_scenario

    source
    fn make_scenario(name~ : String, temperature~ : Double, pressure~ : Double, flow~ : Double, solvent_ratio~ : Double, equilibrium_factor~ : Double, stage_count~ : Int) -> ScenarioPoint raise 
    ExtractionError

    maximum_residual

    source
    fn maximum_residual(entries : ArrayView[LedgerEntry]) -> Double

    merge_streams

    source

    mix_streams

    source

    Mix two streams on a common mass-flow basis.

    near_limit_points

    source
    fn near_limit_points(points : ArrayView[OperatingPoint], threshold : Double) -> Array[OperatingPoint]

    network_add_node

    source
    fn network_add_node(network : UtilityNetwork, node : UtilityNode) -> UtilityNetwork

    network_is_feasible

    source
    fn network_is_feasible(network : UtilityNetwork, reserve_fraction : Double) -> Bool

    network_margin

    source
    fn network_margin(network : UtilityNetwork) -> Double

    network_remove_node

    source
    fn network_remove_node(network : UtilityNetwork, name : String) -> UtilityNetwork

    network_reserve

    source
    fn network_reserve(network : UtilityNetwork) -> Double

    network_scale_capacity

    source
    fn network_scale_capacity(network : UtilityNetwork, factor : Double) -> UtilityNetwork

    network_scale_demand

    source
    fn network_scale_demand(network : UtilityNetwork, factor : Double) -> UtilityNetwork

    network_sensitivity

    source
    fn network_sensitivity(network : UtilityNetwork, demand_factors : ArrayView[Double]) -> Array[Double]

    network_utilization

    source
    fn network_utilization(network : UtilityNetwork) -> Double

    operating_point_csv

    source
    fn operating_point_csv(point : OperatingPoint) -> String

    operating_points_csv

    source
    fn operating_points_csv(points : ArrayView[OperatingPoint]) -> String

    outlet_recovery

    source
    fn outlet_recovery(result : FlowsheetResult) -> Double

    overall_recovery

    source
    fn overall_recovery(ledgers : ArrayView[ComponentLedger]) -> Double

    point_is_near_limit

    source
    fn point_is_near_limit(point : OperatingPoint, threshold : Double) -> Bool

    fn recommended_safety_factor(uncertainty_fraction : Double, minimum? : Double) -> Double raise 
    ExtractionError

    recovery_percentile_band

    source
    fn recovery_percentile_band(scenarios : ArrayView[ScenarioPoint], lower_probability? : Double, upper_probability? : Double) -> (Double, Double) raise 
    ExtractionError

    recovery_quantile

    source
    fn recovery_quantile(scenarios : ArrayView[ScenarioPoint], probability : Double) -> Double raise 
    ExtractionError

    required_recovery_per_stage

    source
    fn required_recovery_per_stage(target_recovery : Double, stage_count : Int) -> Double raise 
    ExtractionError

    robust_scenario

    source
    fn robust_scenario(scenarios : ArrayView[ScenarioPoint], minimum_recovery : Double) -> Bool

    scenario_markdown

    source
    fn scenario_markdown(scenarios : ArrayView[ScenarioPoint]) -> String

    scenario_names

    source
    fn scenario_names(scenarios : ArrayView[ScenarioPoint]) -> Array[String]

    scenario_recovery_values

    source
    fn scenario_recovery_values(scenarios : ArrayView[ScenarioPoint]) -> Array[Double]

    scenario_sensitivity

    source
    fn scenario_sensitivity(baseline : ScenarioPoint, perturbations : ArrayView[ScenarioPoint]) -> Array[Double]

    simulate

    source

    simulate_recycle

    source
    fn simulate_recycle(flowsheet : Flowsheet, inlet : ProcessStream, recycle_fraction~ : Double, tolerance? : Double, maximum_iterations? : Int) -> RecycleResult raise 
    ExtractionError

    size_equipment

    source
    fn size_equipment(spec : EquipmentSpec, density~ : Double, velocity~ : Double, heat_duty~ : Double, heat_transfer_coefficient~ : Double) -> EquipmentSizing raise 
    ExtractionError

    size_heat_exchanger

    source
    fn size_heat_exchanger(duty~ : Double, overall_coefficient~ : Double, hot_inlet_temperature~ : Double, hot_outlet_temperature~ : Double, cold_inlet_temperature~ : Double, cold_outlet_temperature~ : Double) -> HeatExchangerSizing raise 
    ExtractionError

    size_mixer

    source
    fn size_mixer(flow~ : Double, residence_time~ : Double, density~ : Double, power_number~ : Double, rotation_per_second~ : Double, impeller_diameter~ : Double) -> MixerSizing raise 
    ExtractionError

    size_pump

    source
    fn size_pump(flow~ : Double, pressure_rise~ : Double, density~ : Double, efficiency~ : Double) -> PumpSizing raise 
    ExtractionError

    size_settler

    source
    fn size_settler(total_flow~ : Double, residence_time~ : Double, length_to_width? : Double, width_to_height? : Double) -> SettlerSizing raise 
    ExtractionError

    split_stream

    source
    fn split_stream(stream : ProcessStream, fraction : Double, first_name : String, second_name : String) -> (ProcessStream, ProcessStream) raise 
    ExtractionError

    statistics_filter_dilute

    source
    fn statistics_filter_dilute(statistics : ArrayView[StreamStatistics], threshold : Double) -> Array[StreamStatistics]

    statistics_filter_rich

    source
    fn statistics_filter_rich(statistics : ArrayView[StreamStatistics], threshold : Double) -> Array[StreamStatistics]

    statistics_maximum_ratio

    source
    fn statistics_maximum_ratio(statistics : ArrayView[StreamStatistics]) -> Double

    statistics_mean

    source
    fn statistics_mean(statistics : ArrayView[StreamStatistics]) -> StreamStatistics

    statistics_minimum_ratio

    source
    fn statistics_minimum_ratio(statistics : ArrayView[StreamStatistics]) -> Double

    statistics_quality_range

    source
    fn statistics_quality_range(statistics : ArrayView[StreamStatistics]) -> Double

    statistics_ratio_range

    source
    fn statistics_ratio_range(statistics : ArrayView[StreamStatistics]) -> Double

    statistics_total_flow

    source
    fn statistics_total_flow(statistics : ArrayView[StreamStatistics]) -> Double

    statistics_total_solute

    source
    fn statistics_total_solute(statistics : ArrayView[StreamStatistics]) -> Double

    stream_balance

    source
    fn stream_balance(name : String, inlet : ProcessStream, outlet : ProcessStream, tolerance : Double) -> StreamBalance

    stream_carrier_fraction

    source
    fn stream_carrier_fraction(stream : ProcessStream) -> Double

    stream_change_magnitude

    source
    fn stream_change_magnitude(change : StreamComparison) -> Double

    stream_comparison_report

    source
    fn stream_comparison_report(comparison : StreamComparison) -> String

    stream_concentration_change

    source
    fn stream_concentration_change(first : ProcessStream, second : ProcessStream) -> Double

    stream_concentration_ratio

    source
    fn stream_concentration_ratio(stream : ProcessStream) -> Double

    stream_energy_change

    source
    fn stream_energy_change(first : ProcessStream, second : ProcessStream, heat_capacity : Double) -> Double

    stream_flow_ratio

    source
    fn stream_flow_ratio(first : ProcessStream, second : ProcessStream) -> Double

    stream_is_dilute

    source
    fn stream_is_dilute(stream : ProcessStream, threshold : Double) -> Bool

    stream_is_rich

    source
    fn stream_is_rich(stream : ProcessStream, threshold : Double) -> Bool

    stream_loss_factor

    source
    fn stream_loss_factor(feed : ProcessStream, waste : ProcessStream) -> Double

    stream_pressure_change

    source
    fn stream_pressure_change(first : ProcessStream, second : ProcessStream) -> Double

    stream_pressure_ratio

    source
    fn stream_pressure_ratio(first : ProcessStream, second : ProcessStream) -> Double

    stream_pressure_work

    source
    fn stream_pressure_work(first : ProcessStream, second : ProcessStream) -> Double

    stream_quality_index

    source
    fn stream_quality_index(stream : ProcessStream) -> Double

    stream_quality_label

    source
    fn stream_quality_label(stream : ProcessStream) -> String

    stream_recovery_factor

    source
    fn stream_recovery_factor(feed : ProcessStream, product : ProcessStream) -> Double

    stream_solute_fraction

    source
    fn stream_solute_fraction(stream : ProcessStream) -> Double

    stream_solute_ratio

    source
    fn stream_solute_ratio(first : ProcessStream, second : ProcessStream) -> Double

    stream_solvent_concentration_change

    source
    fn stream_solvent_concentration_change(first : ProcessStream, second : ProcessStream) -> Double

    stream_solvent_fraction

    source
    fn stream_solvent_fraction(stream : ProcessStream) -> Double

    stream_statistics

    source
    fn stream_statistics(stream : ProcessStream, heat_capacity : Double) -> StreamStatistics

    stream_statistics_csv

    source
    fn stream_statistics_csv(statistics : ArrayView[StreamStatistics]) -> String

    stream_statistics_markdown

    source
    fn stream_statistics_markdown(statistics : ArrayView[StreamStatistics]) -> String

    stream_summary_line

    source
    fn stream_summary_line(statistics : StreamStatistics) -> String

    stream_temperature_change

    source
    fn stream_temperature_change(first : ProcessStream, second : ProcessStream) -> Double

    stream_temperature_ratio

    source
    fn stream_temperature_ratio(first : ProcessStream, second : ProcessStream) -> Double

    streams_balanced

    source
    fn streams_balanced(inlet : ProcessStream, outlet : ProcessStream, tolerance : Double) -> Bool

    summarize_scenarios

    source

    total_feed

    source
    fn total_feed(ledgers : ArrayView[ComponentLedger]) -> Double

    total_pressure_drop

    source
    fn total_pressure_drop(result : FlowsheetResult) -> Double

    total_product

    source
    fn total_product(ledgers : ArrayView[ComponentLedger]) -> Double

    total_temperature_change

    source
    fn total_temperature_change(result : FlowsheetResult) -> Double

    utility_allocation_csv

    source
    fn utility_allocation_csv(allocations : ArrayView[UtilityAllocation]) -> String

    utility_limit_report

    source
    fn utility_limit_report(limits : ArrayView[OperatingLimit]) -> String

    utility_network_alerts

    source
    fn utility_network_alerts(network : UtilityNetwork, maximum_utilization : Double) -> Array[String]

    utility_network_balanced

    source
    fn utility_network_balanced(network : UtilityNetwork, tolerance : Double) -> Bool

    utility_network_cost

    source
    fn utility_network_cost(network : UtilityNetwork, unit_cost : Double) -> Double

    utility_network_emissions

    source
    fn utility_network_emissions(network : UtilityNetwork, emission_factor : Double) -> Double

    utility_network_markdown

    source
    fn utility_network_markdown(network : UtilityNetwork) -> String

    utility_network_max_priority

    source
    fn utility_network_max_priority(network : UtilityNetwork) -> Int

    utility_network_min_priority

    source
    fn utility_network_min_priority(network : UtilityNetwork) -> Int

    utility_network_summary

    source
    fn utility_network_summary(network : UtilityNetwork) -> String

    utility_node

    source
    fn utility_node(name : String, demand : Double, capacity : Double, priority : Int) -> UtilityNode

    utility_node_count_available

    source
    fn utility_node_count_available(network : UtilityNetwork) -> Int

    utility_node_rank

    source
    fn utility_node_rank(network : UtilityNetwork, name : String) -> Int

    vessel_volume_for_batch

    source
    fn vessel_volume_for_batch(batch_mass~ : Double, density~ : 
    Density    , fill_fraction~ : Double, safety_factor? : Double) -> 
    Volume     raise 
    ExtractionError

    worst_margin

    source
    fn worst_margin(points : ArrayView[OperatingPoint]) -> Double

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io