Sign in

    zhaoyuanjuns/moonbit_extractor/liquid does not have a README file

    CascadeComparison

    pub(all) struct CascadeComparison {
    constant_result : CountercurrentResult
    table_result : NonlinearCountercurrentResult
    outlet_difference : Double
    recovery_difference : Double
    } derive(Eq, ToJson,
    Debug
    )

    Compare constant-K and tabulated equilibrium predictions.

    CascadeMetrics

    pub(all) struct CascadeMetrics {
    stage_count : Int
    total_feed_solute : Double
    extracted_solute : Double
    raffinate_solute : Double
    recovery : Double
    average_stage_recovery : Double
    maximum_stage_transfer : Double
    minimum_stage_transfer : Double
    transfer_uniformity : Double
    balance_residual : Double
    } derive(Eq, ToJson,
    Debug
    )

    Aggregate metrics for comparing cascade designs.

    CascadeProfile

    pub(all) struct CascadeProfile {
    stages : Array[CascadeProfilePoint]
    total_recovery : Double
    total_balance_error : Double
    minimum_driving_force : Double
    bottleneck_stage : Int
    monotonic : Bool
    } derive(Eq, ToJson,
    Debug
    )

    CascadeProfilePoint

    pub(all) struct CascadeProfilePoint {
    stage : Int
    raffinate_in : Double
    raffinate_out : Double
    extract_in : Double
    extract_out : Double
    local_recovery : Double
    cumulative_recovery : Double
    driving_force : Double
    balance_error : Double
    } derive(Eq, ToJson,
    Debug
    )

    Stage-by-stage profile and sensitivity utilities for liquid extraction.

    CascadeSensitivityPoint

    pub(all) struct CascadeSensitivityPoint {
    parameter : String
    baseline : Double
    perturbed : Double
    absolute_change : Double
    relative_change : Double
    elasticity : Double
    } derive(Eq, ToJson,
    Debug
    )

    CountercurrentResult

    pub(all) struct CountercurrentResult {
    stages : Array[CountercurrentStage]
    raffinate_outlet_concentration : Double
    extract_outlet_concentration : Double
    recovery : Double
    balance_residual : Double
    extraction_factor : Double
    } derive(Eq, ToJson,
    Debug
    )

    CountercurrentStage

    pub(all) struct CountercurrentStage {
    stage : Int
    raffinate_concentration : Double
    extract_concentration : Double
    raffinate_solute_flow : Double
    extract_solute_flow : Double
    } derive(Eq, ToJson,
    Debug
    )

    CrosscurrentResult

    pub(all) struct CrosscurrentResult {
    stages : Array[CrosscurrentStage]
    final_raffinate_concentration : Double
    total_extracted_solute : Double
    overall_recovery : Double
    balance_residual : Double
    } derive(Eq, ToJson,
    Debug
    )

    CrosscurrentStage

    pub(all) struct CrosscurrentStage {
    stage : Int
    solvent_flow : Double
    inlet_raffinate_concentration : Double
    outlet_raffinate_concentration : Double
    extract_concentration : Double
    extracted_solute : Double
    cumulative_recovery : Double
    } derive(Eq, ToJson,
    Debug
    )

    NonlinearCountercurrentResult

    pub(all) struct NonlinearCountercurrentResult {
    stages : Array[NonlinearCountercurrentStage]
    raffinate_outlet_concentration : Double
    extract_outlet_concentration : Double
    recovery : Double
    balance_residual : Double
    iterations : Int
    converged : Bool
    maximum_local_residual : Double
    } derive(Eq, ToJson,
    Debug
    )

    NonlinearCountercurrentStage

    pub(all) struct NonlinearCountercurrentStage {
    stage : Int
    raffinate_concentration : Double
    extract_concentration : Double
    raffinate_solute_flow : Double
    extract_solute_flow : Double
    local_residual : Double
    } derive(Eq, ToJson,
    Debug
    )

    Stage result for a countercurrent cascade using a tabulated equilibrium curve.

    SingleStageResult

    pub(all) struct SingleStageResult {
    raffinate_concentration : Double
    extract_concentration : Double
    raffinate_solute : Double
    extract_solute : Double
    recovery : Double
    balance_residual : Double
    } derive(Eq, ToJson,
    Debug
    )

    Material-balance result for one equilibrium contact.

    StageRanking

    pub(all) struct StageRanking {
    stage : Int
    score : Double
    transfer : Double
    rank : Int
    } derive(Eq, ToJson,
    Debug
    )

    build_cascade_profile

    fn build_cascade_profile(raffinate_inlets : ArrayView[Double], raffinate_outlets : ArrayView[Double], extract_inlets : ArrayView[Double], extract_outlets : ArrayView[Double], tolerance : Double) -> CascadeProfile raise
    ExtractionError

    cascade_is_balanced

    fn cascade_is_balanced(result : CountercurrentResult, tolerance~ : Double) -> Bool raise
    ExtractionError

    compare_countercurrent_models

    fn compare_countercurrent_models(carrier_flow~ : Double, feed_concentration~ : Double, solvent_flow~ : Double, distribution~ : Double, equilibrium~ :
    EquilibriumTable
    , stage_count~ : Int) -> CascadeComparison raise
    ExtractionError

    compare_metrics

    fn compare_metrics(first : CascadeMetrics, second : CascadeMetrics) -> Array[String]

    countercurrent_constant_k

    fn countercurrent_constant_k(carrier_flow~ : Double, feed_concentration~ : Double, solvent_flow~ : Double, solvent_inlet_concentration? : Double, distribution~ : Double, stage_count~ : Int) -> CountercurrentResult raise
    ExtractionError

    Solve an ideal countercurrent cascade with constant flows and constant K. Stage one is adjacent to the feed; stage N is adjacent to fresh solvent.

    countercurrent_table

    fn countercurrent_table(carrier_flow~ : Double, feed_concentration~ : Double, solvent_flow~ : Double, solvent_inlet_concentration? : Double, equilibrium~ :
    EquilibriumTable
    , stage_count~ : Int, tolerance? : Double, maximum_iterations? : Int, relaxation? : Double) -> NonlinearCountercurrentResult raise
    ExtractionError

    Solve a nonlinear countercurrent cascade by damped Gauss–Seidel iteration.

    crosscurrent_constant_k

    fn crosscurrent_constant_k(feed_flow~ : Double, feed_concentration~ : Double, solvent_flows : ArrayView[Double], solvent_concentrations? : Array[Double], distribution~ : Double) -> CrosscurrentResult raise
    ExtractionError

    Calculate ideal crosscurrent stages with fresh or preloaded solvent.

    solvent_flows and solvent_concentrations contain one value per stage.

    crosscurrent_equal_solvent

    fn crosscurrent_equal_solvent(feed_flow~ : Double, feed_concentration~ : Double, total_solvent~ : Double, stage_count~ : Int, distribution~ : Double) -> CrosscurrentResult raise
    ExtractionError

    Equal-solvent allocation convenience wrapper.

    distribution_coefficient

    fn distribution_coefficient(raffinate_concentration : Double, extract_concentration : Double) -> Double raise
    ExtractionError

    Calculate the distribution coefficient K_D = y / x.

    extraction_factor

    fn extraction_factor(distribution~ : Double, solvent_flow~ : Double, carrier_flow~ : Double) -> Double raise
    ExtractionError

    maximum_concentration

    fn maximum_concentration(result : NonlinearCountercurrentResult) -> Double

    minimum_countercurrent_stages

    fn minimum_countercurrent_stages(carrier_flow~ : Double, feed_concentration~ : Double, solvent_flow~ : Double, solvent_inlet_concentration? : Double, distribution~ : Double, target_raffinate~ : Double, maximum_stages? : Int) -> CountercurrentResult raise
    ExtractionError

    Find the smallest integer stage count that meets a raffinate target.

    minimum_table_stages

    fn minimum_table_stages(carrier_flow~ : Double, feed_concentration~ : Double, solvent_flow~ : Double, solvent_inlet_concentration? : Double, equilibrium~ :
    EquilibriumTable
    , target_raffinate~ : Double, maximum_stages? : Int) -> NonlinearCountercurrentResult raise
    ExtractionError

    Find the first nonlinear cascade meeting a raffinate specification.

    profile_alerts

    fn profile_alerts(profile : CascadeProfile, minimum_force : Double, maximum_error : Double) -> Array[String]

    profile_average_recovery

    fn profile_average_recovery(profile : CascadeProfile) -> Double

    profile_balance_errors

    fn profile_balance_errors(profile : CascadeProfile) -> Array[Double]

    profile_compare

    fn profile_compare(first : CascadeProfile, second : CascadeProfile) -> String

    profile_csv

    fn profile_csv(profile : CascadeProfile) -> String

    profile_driving_forces

    fn profile_driving_forces(profile : CascadeProfile) -> Array[Double]

    profile_first_stage_share

    fn profile_first_stage_share(profile : CascadeProfile) -> Double

    profile_from_stage_data

    fn profile_from_stage_data(feed : Double, stage_recoveries : ArrayView[Double], solvent_flow : Double) -> CascadeProfile raise
    ExtractionError

    profile_is_acceptable

    fn profile_is_acceptable(profile : CascadeProfile, minimum_recovery : Double, maximum_error : Double) -> Bool

    profile_is_well_balanced

    fn profile_is_well_balanced(profile : CascadeProfile, maximum_balance_error : Double, minimum_force : Double) -> Bool

    profile_last_stage_share

    fn profile_last_stage_share(profile : CascadeProfile) -> Double

    profile_markdown

    fn profile_markdown(profile : CascadeProfile) -> String

    profile_recoveries

    fn profile_recoveries(profile : CascadeProfile) -> Array[Double]

    profile_recovery_stddev

    fn profile_recovery_stddev(profile : CascadeProfile) -> Double

    profile_resample

    profile_sensitivity

    fn profile_sensitivity(baseline : CascadeProfile, perturbed : CascadeProfile, parameter : String) -> CascadeSensitivityPoint

    profile_sensitivity_matrix

    fn profile_sensitivity_matrix(baseline : CascadeProfile, variants : ArrayView[CascadeProfile], names : ArrayView[String]) -> Array[CascadeSensitivityPoint]

    recovery_fraction

    fn recovery_fraction(inlet_solute : Double, raffinate_solute : Double) -> Double raise
    ExtractionError

    selectivity

    fn selectivity(solute_a_raffinate~ : Double, solute_a_extract~ : Double, solute_b_raffinate~ : Double, solute_b_extract~ : Double) -> Double raise
    ExtractionError

    Calculate separation selectivity (y_a/x_a) / (y_b/x_b).

    single_stage_constant_k

    fn single_stage_constant_k(feed_flow~ : Double, feed_concentration~ : Double, solvent_flow~ : Double, solvent_concentration? : Double, distribution~ : Double) -> SingleStageResult raise
    ExtractionError

    Solve one ideal equilibrium stage with constant distribution coefficient. Concentrations and flow rates must use a consistent solute-free basis.

    single_stage_table

    fn single_stage_table(feed_flow~ : Double, feed_concentration~ : Double, solvent_flow~ : Double, solvent_concentration? : Double, equilibrium~ :
    EquilibriumTable
    , tolerance? : Double, max_iterations? : Int) -> SingleStageResult raise
    ExtractionError

    Solve one stage against a tabulated equilibrium relation using bisection.

    stage_residuals

    fn stage_residuals(result : NonlinearCountercurrentResult) -> Array[Double]

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io