Optimization Package

The optimization package provides economic optimization tools, process optimization, and parameter estimation capabilities for process control systems.

Note

This is part of the modern modular structure of SPROCLIB.

Submodules

Economic Optimization

Economic Optimization Subpackage

This subpackage provides comprehensive economic optimization tools for chemical engineering applications including production planning, utility optimization, investment analysis, and economic model predictive control.

Classes:

EconomicOptimization: Main economic optimization class with multiple algorithms

Functions:

optimize_operation: Standalone operation optimization function

Example

>>> from sproclib.optimization.economic_optimization import EconomicOptimization
>>> optimizer = EconomicOptimization("Production Planning")
>>> result = optimizer.production_optimization(...)
class sproclib.optimization.economic_optimization.EconomicOptimization(name='Economic Optimization')[source]

Bases: object

Economic optimization tools for process control.

Parameters:

name (str)

__init__(name='Economic Optimization')[source]

Initialize economic optimization.

Parameters:

name (str) – Optimization problem name

linear_programming(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None, bounds=None, method='highs')[source]

Solve linear programming problem: min c^T x subject to constraints.

Parameters:

  • c (<MagicMock id='130137675873456'>) – Objective function coefficients

  • A_ub (<MagicMock id='130137675873120'> | None) – Inequality constraints A_ub @ x <= b_ub

  • b_ub (<MagicMock id='130137675872112'> | None) – Inequality constraints A_ub @ x <= b_ub

  • A_eq (<MagicMock id='130137675870768'> | None) – Equality constraints A_eq @ x = b_eq

  • b_eq (<MagicMock id='130137675864048'> | None) – Equality constraints A_eq @ x = b_eq

  • bounds (List[Tuple] | None) – Variable bounds [(min, max), …]

  • method (str) – Solver method

Returns:

Optimization results

Return type:

Dict[str, Any]

production_optimization(production_rates, costs, prices, capacity_constraints, demand_constraints=None, material_balances=None)[source]

Optimize production planning for maximum profit.

Parameters:

  • production_rates (<MagicMock id='130137675866400'>) – Production variables [units/time]

  • costs (<MagicMock id='130137676235504'>) – Unit production costs [$/unit]

  • prices (<MagicMock id='130137676235168'>) – Product prices [$/unit]

  • capacity_constraints (<MagicMock id='130137676234832'>) – Maximum production capacities [units/time]

  • demand_constraints (<MagicMock id='130137676236176'> | None) – Minimum demand requirements [units/time]

  • material_balances (Dict[str, <MagicMock id='130137676237184'>] | None) – Material balance constraints

Returns:

Optimization results with profit analysis

Return type:

Dict[str, Any]

utility_optimization(utility_costs, utility_demands, utility_capacities, time_horizon=24)[source]

Optimize utility usage (steam, electricity, cooling water).

Parameters:

  • utility_costs (Dict[str, float]) – Cost per unit for each utility

  • utility_demands (Dict[str, <MagicMock id='130137676238192'>]) – Demand profiles for each utility

  • utility_capacities (Dict[str, float]) – Maximum capacity for each utility

  • time_horizon (int) – Planning horizon [hours]

Returns:

Optimization results for utility scheduling

Return type:

Dict[str, Any]

economic_mpc(process_model, economic_objective, constraints, prediction_horizon=10, control_horizon=None)[source]

Economic Model Predictive Control optimization.

Parameters:

  • process_model – Process model for predictions

  • economic_objective (callable) – Economic objective function

  • constraints (List[Dict]) – List of constraint dictionaries

  • prediction_horizon (int) – Prediction horizon

  • control_horizon (int | None) – Control horizon

Returns:

Economic MPC solution

Return type:

Dict[str, Any]

investment_optimization(investment_options, budget_constraint, time_horizon=10, discount_rate=0.1)[source]

Optimize capital investment decisions.

Parameters:

  • investment_options (List[Dict[str, float]]) – List of investment options with costs and returns

  • budget_constraint (float) – Total available budget

  • time_horizon (int) – Investment time horizon [years]

  • discount_rate (float) – Discount rate for NPV calculation

Returns:

Investment optimization results

Return type:

Dict[str, Any]

sproclib.optimization.economic_optimization.optimize_operation(objective_func, x0, constraints=None, bounds=None, method='SLSQP')[source]

Optimize process operation using nonlinear programming.

Parameters:

  • objective_func (callable) – Objective function to minimize

  • x0 (<MagicMock id='130137676239200'>) – Initial guess

  • constraints (List[Dict] | None) – List of constraint dictionaries

  • bounds (List[Tuple] | None) – Variable bounds [(min, max), …]

  • method (str) – Optimization method

Returns:

Optimization results

Return type:

Dict[str, Any]

Parameter Estimation

Parameter Estimation Module for Chemical Process Engineering

This module provides comprehensive tools for estimating parameters from experimental data in chemical engineering applications, including reaction kinetics, heat and mass transfer, and thermodynamic properties.

Key Features: - Linear and nonlinear parameter estimation - Statistical uncertainty quantification - Bayesian inference methods - Model validation and diagnostics - Economic impact analysis

Classes:

ParameterEstimation: Main class for parameter estimation BayesianParameterEstimation: Bayesian inference methods MultiObjectiveEstimation: Multi-response parameter estimation

Functions:

arrhenius_estimation: Specialized for Arrhenius parameter estimation heat_transfer_estimation: Heat transfer coefficient correlation mass_transfer_estimation: Mass transfer parameter estimation validate_model: Comprehensive model validation estimate_fopdt_parameters: FOPDT parameter estimation (legacy)

Examples

>>> from sproclib.optimization.parameter_estimation import ParameterEstimation
>>> import numpy as np

# Arrhenius parameter estimation >>> temps = np.array([300, 310, 320, 330, 340]) >>> rates = np.array([0.001, 0.002, 0.004, 0.008, 0.015]) >>> def arrhenius(T, k0, Ea): … return k0 * np.exp(-Ea / (8.314 * T)) >>> estimator = ParameterEstimation(arrhenius, (temps, rates)) >>> results = estimator.estimate_parameters() >>> print(f”Activation energy: {results.parameters[1]/1000:.1f} kJ/mol”)

# Heat transfer correlation >>> flows = np.array([10, 20, 30, 40, 50]) >>> coeffs = np.array([250, 320, 380, 430, 470]) >>> def correlation(flow, a, b): … return a * flow**b >>> estimator = ParameterEstimation(correlation, (flows, coeffs)) >>> results = estimator.estimate_parameters() >>> print(f”Exponent: {results.parameters[1]:.3f}”)

See also

Process Optimization: Integration with optimization workflows Economic Optimization: Economic objective functions Unit Operations: Process models for parameter estimation

References

  1. Bard, Y. (1974). Nonlinear Parameter Estimation. Academic Press.

  2. Englezos, P. & Kalogerakis, N. (2001). Applied Parameter Estimation for Chemical Engineers. Marcel Dekker.

  3. Rawlings, J.B. & Ekerdt, J.G. (2002). Chemical Reactor Analysis and Design Fundamentals. Nob Hill Publishing.

class sproclib.optimization.parameter_estimation.ParameterEstimation(name='Parameter Estimation')[source]

Bases: object

Parameter estimation for process models.

Parameters:

name (str)

__init__(name='Parameter Estimation')[source]

Initialize parameter estimation.

Parameters:

name (str) – Estimation name

estimate_parameters(model_func, t_data, y_data, param_bounds, initial_guess=None, method='least_squares')[source]

Estimate model parameters from experimental data.

Parameters:

  • model_func (Callable) – Model function that takes (t, params) and returns y

  • t_data (<MagicMock id='130137676242224'>) – Time data

  • y_data (<MagicMock id='130137676242560'>) – Output data

  • param_bounds (List[Tuple[float, float]]) – Parameter bounds [(min, max), …]

  • initial_guess (<MagicMock id='130137676242896'> | None) – Initial parameter guess

  • method (str) – Estimation method

Returns:

Parameter estimation results

Return type:

Dict[str, Any]

validate_model(model_func, parameters, t_validation, y_validation)[source]

Validate model with independent validation data.

Parameters:

  • model_func (Callable) – Model function

  • parameters (<MagicMock id='130137676243904'>) – Estimated parameters

  • t_validation (<MagicMock id='130137676244240'>) – Validation time data

  • y_validation (<MagicMock id='130137676244576'>) – Validation output data

Returns:

Validation results

Return type:

Dict[str, Any]

describe()[source]

Provide comprehensive information about ParameterEstimation capabilities.

Returns:

Dictionary containing parameter estimation algorithms, applications, parameters, and technical specifications for chemical engineering models.

Return type:

Dict[str, Any]

sproclib.optimization.parameter_estimation.estimate_fopdt_parameters(t_data, y_data, step_magnitude=1.0)[source]

Estimate FOPDT parameters from step response data.

Parameters:

  • t_data (<MagicMock id='130137676244912'>) – Time data

  • y_data (<MagicMock id='130137676245248'>) – Step response data

  • step_magnitude (float) – Magnitude of step input

Returns:

Estimated FOPDT parameters

Return type:

Dict[str, Any]

sproclib.optimization.parameter_estimation.run_example()

Parameter Estimation Example: Reaction Kinetics for Catalytic Process

This example demonstrates parameter estimation for a catalytic reaction using experimental data from a batch reactor study.

sproclib.optimization.parameter_estimation.quick_arrhenius_fit(temperatures, rate_constants, initial_guess=None)[source]

Quick Arrhenius parameter estimation with default settings.

Parameters:

  • temperatures (array_like) – Temperature data (K)

  • rate_constants (array_like) – Rate constant data (same units as desired k0)

  • initial_guess (list, optional) – Initial parameter guess [k0, Ea]. If None, uses automatic estimation.

Returns:

Dictionary with ‘k0’, ‘Ea’, ‘r_squared’, and ‘confidence_intervals’

Return type:

dict

Examples

>>> temps = [300, 310, 320, 330, 340]
>>> rates = [0.001, 0.002, 0.004, 0.008, 0.015]
>>> results = quick_arrhenius_fit(temps, rates)
>>> print(f"Ea = {results['Ea']/1000:.1f} kJ/mol")
sproclib.optimization.parameter_estimation.quick_power_law_fit(x_data, y_data, initial_guess=None)[source]

Quick power law fitting: y = a * x^b

Parameters:

  • x_data (array_like) – Independent variable data

  • y_data (array_like) – Dependent variable data

  • initial_guess (list, optional) – Initial parameter guess [a, b]. If None, uses log-linear estimation.

Returns:

Dictionary with ‘a’, ‘b’, ‘r_squared’, and ‘confidence_intervals’

Return type:

dict

Examples

>>> flows = [10, 20, 30, 40, 50]
>>> coeffs = [250, 320, 380, 430, 470]
>>> results = quick_power_law_fit(flows, coeffs)
>>> print(f"Exponent = {results['b']:.3f}")

Process Optimization

ProcessOptimization Package

This package provides general process optimization tools for chemical engineering applications.

class sproclib.optimization.process_optimization.ProcessOptimization(name='Process Optimization')[source]

Bases: object

Basic process optimization class.

Parameters:

name (str)

__init__(name='Process Optimization')[source]

Initialize process optimization.

Parameters:

name (str) – Optimization name

optimize(objective_func, x0, constraints=None, bounds=None)[source]

Basic optimization method.

describe()[source]

Introspect metadata for documentation and algorithm querying.

Returns:

Metadata about the model including algorithms,

parameters, equations, and usage information.

Return type:

dict

Quick Usage

Economic Optimization:

from optimization.economic_optimization import EconomicOptimization
import numpy as np

# Create optimizer
optimizer = EconomicOptimization("Production Planning")

# Define production planning problem
costs = np.array([10, 15, 20])      # Production costs
prices = np.array([25, 30, 35])     # Product prices
capacity = np.array([100, 80, 60])  # Production capacities
demand = np.array([50, 40, 30])     # Market demand

# Solve optimization
result = optimizer.production_optimization(
    costs=costs,
    prices=prices,
    capacity_constraints=capacity,
    demand_constraints=demand
)

print(f"Optimal production: {result['optimal_production']}")
print(f"Maximum profit: ${result['max_profit']:.2f}")

Parameter Estimation:

from optimization.parameter_estimation import ParameterEstimation

# Create parameter estimator
estimator = ParameterEstimation()

# Estimate parameters from data
result = estimator.least_squares_estimation(
    data=data,
    model=model_function,
    initial_guess=[1.0, 2.0]
)