Chemical Engineering

What I do

• Design chemical processes and unit operations
• Perform mass and energy balance calculations
• Analyze reaction kinetics and reactor design
• Model separation processes (distillation, absorption, extraction)
• Size equipment (vessels, heat exchangers, pumps)
• Optimize process economics and efficiency

When to use me

• When designing chemical plants or process equipment
• When calculating material and energy balances
• When selecting or sizing process equipment
• When analyzing reaction kinetics and reactor performance
• When optimizing separation processes
• When evaluating process safety and economics

Key Concepts

Mass and Energy Balances

# Basic mass balance
class MassBalance:
    def __init__(self):
        self.inputs = {}
        self.outputs = {}
        self.reactions = []
    
    def add_stream(self, name, components, flowrate):
        """Add a material stream"""
        self.inputs[name] = {
            "components": components,
            "flowrate": flowrate  # kmol/hr or kg/hr
        }
    
    def add_reaction(self, stoichiometry, rate_expression=None):
        """Add chemical reaction"""
        self.reactions.append({
            "stoichiometry": stoichiometry,
            "rate": rate_expression
        })
    
    def solve_steady_state(self):
        """Solve for unknown streams"""
        # Sum inputs = Sum outputs + Accumulation
        # At steady state: Accumulation = 0
        total_in = sum(s["flowrate"] for s in self.inputs.values())
        return total_in

# Energy balance
def energy_balance(Q_in, W_s, H_out, H_in, dU_steady=0):
    """
    Q_in + W_s + ΣH_in = ΣH_out + dU/dt
    At steady state: dU/dt = 0
    """
    return Q_in + W_s + H_in - H_out - dU_steady

Reaction Engineering

# Reactor design equations
class ReactorDesign:
    @staticmethod
    def cstr_volume(F_A0, X, k, C_A0):
        """Continuous Stirred Tank Reactor"""
        # V = F_A0 * X / (-r_A)
        # For first order: -r_A = k * C_A0 * (1 - X)
        return F_A0 * X / (k * C_A0 * (1 - X))
    
    @staticmethod
    def pfr_volume(F_A0, X, k):
        """Plug Flow Reactor"""
        # V = F_A0 ∫ dX/(-r_A)
        # For first order: V = F_A0 * (-ln(1-X)) / k
        return F_A0 * (-np.log(1 - X)) / k
    
    @staticmethod
    def conversion_time(t, k, order=1):
        """Batch reactor"""
        if order == 1:
            return 1 - np.exp(-k * t)
        elif order == 2:
            return k * t / (1 + k * t)

Heat Transfer

# Heat exchanger design
class HeatExchanger:
    @staticmethod
    def lmtd(T_h_in, T_h_out, T_c_in, T_c_out):
        """Log Mean Temperature Difference"""
        if T_h_out == T_c_in:
            return (T_h_in - T_c_out - (T_h_out - T_c_in)) / \
                   np.log((T_h_in - T_c_out) / (T_h_out - T_c_in))
        
        dT1 = T_h_in - T_c_out
        dT2 = T_h_out - T_c_in
        return (dT1 - dT2) / np.log(dT1 / dT2)
    
    @staticmethod
    def heat_transfer_area(Q, U, LMTD):
        """Calculate required area"""
        return Q / (U * LMTD)

Separation Processes

Equipment Sizing

# Tank sizing
def size_storage_tank(volume, agitation=False):
    """Size a storage tank"""
    H_to_D = 1.5 if agitation else 1.0
    D = (4 * volume / (np.pi * H_to_D)) ** (1/3)
    H = H_to_D * D
    return {"diameter": D, "height": H}

# Pump power
def pump_power(flow_rate, head, efficiency=0.7):
    """Calculate pump power requirement"""
    # Q in m³/s, H in m, ρ in kg/m³
    rho = 1000  # water
    power_hydraulic = rho * 9.81 * flow_rate * head
    return power_hydraulic / efficiency