# Chemical Engineering

> Chemical process engineering fundamentals

- Skill: `ffsshhttiikk/chemical-engineering` (Agent Skill)
- Install (CLI): `npx skillmds@latest add ffsshhttiikk/chemical-engineering`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ffsshhttiikk/chemical-engineering/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: ffsshhttiikk (https://skillmd.com/u/ffsshhttiikk)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/ffsshhttiikk/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

```python
# 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

```python
# 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

```python
# 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

| Process | Phase Contact | Separation Basis |
|---------|--------------|------------------|
| Distillation | Vapor-Liquid | Boiling point |
| Absorption | Gas-Liquid | Solubility |
| Extraction | Liquid-Liquid | Solute solubility |
| Adsorption | Solid-Gas/Liquid | Surface affinity |
| Filtration | Solid-Liquid | Particle size |
| Crystallization | Solid-Liquid | Solubility |

### Equipment Sizing

```python
# 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
```