air-pollution-control

name	air-pollution-control
description	Specialized skill for air pollution control equipment selection and design including scrubbers, baghouses, ESPs, oxidizers, and BACT/LAER determination.
allowed-tools	Read, Grep, Write, Bash, Edit, Glob
category	Air Quality Management
backlog-id	SK-007
metadata	{"author":"babysitter-sdk","version":"1.0.0"}

Air Pollution Control Design Skill

Air pollution control equipment selection and design for industrial emission reduction.

Purpose

This skill provides comprehensive capabilities for designing air pollution control systems, including technology selection, equipment sizing, efficiency calculations, and regulatory compliance demonstration (BACT/LAER/MACT).

Capabilities

Scrubber Design

• Wet scrubber technology selection
• Packed tower design and sizing
• Spray tower configuration
• Venturi scrubber design
• Pressure drop calculations
• Liquid-to-gas ratio optimization
• Chemical dosing requirements

Baghouse and Fabric Filter Sizing

• Filter media selection
• Air-to-cloth ratio determination
• Compartmentalization design
• Pulse-jet vs reverse-air cleaning
• Pressure drop estimation
• Bag life prediction
• Hopper sizing

Electrostatic Precipitator Design

• Collection efficiency calculation
• Specific Collection Area (SCA) determination
• Plate spacing and configuration
• Electrical field strength
• Rapping system design
• Resistivity considerations
• Power supply sizing

Thermal and Catalytic Oxidizer Specification

• Destruction efficiency requirements
• Temperature and residence time
• Heat recovery options (regenerative, recuperative)
• Catalyst selection for catalytic oxidizers
• Auxiliary fuel requirements
• Turndown capabilities

Carbon Adsorption System Design

• Activated carbon selection
• Adsorption capacity calculations
• Breakthrough time estimation
• Bed sizing
• Regeneration system design
• Carbon replacement frequency

Control Efficiency Calculations

• Outlet emission rate determination
• Removal efficiency verification
• Stack testing correlation
• Continuous monitoring requirements

Pressure Drop and Energy Analysis

• System pressure drop calculation
• Fan power requirements
• Operating cost estimation
• Energy optimization opportunities

BACT/LAER/MACT Determination

• Control technology identification
• Cost-effectiveness analysis
• Technical feasibility evaluation
• Regulatory database research
• Top-down BACT analysis

Prerequisites

Installation

pip install numpy scipy pandas matplotlib

Optional Dependencies

# For chemical property lookup
pip install chemicals thermo

# For visualization
pip install plotly

Usage Patterns

Baghouse Design

import numpy as np
from dataclasses import dataclass
from typing import Dict, List, Optional

@dataclass
class GasStreamData:
    """Gas stream characteristics"""
    flow_rate_acfm: float
    temperature_f: float
    moisture_pct: float
    particulate_loading_gr_acf: float
    particle_size_micron: float
    gas_composition: Dict[str, float] = None

@dataclass
class BaghouseDesign:
    """Baghouse design parameters"""
    filter_media: str
    bag_diameter_in: float
    bag_length_ft: float
    air_to_cloth_ratio: float
    cleaning_type: str  # 'pulse_jet', 'reverse_air', 'shaker'

class BaghouseCalculator:
    """Pulse-jet baghouse sizing calculations"""

    # Recommended air-to-cloth ratios (acfm/ft2) by application
    AC_RATIOS = {
        'cement': {'gross': 4.0, 'net': 3.5},
        'coal': {'gross': 6.0, 'net': 5.0},
        'foundry': {'gross': , : },
        : {: , : },
        : {: , : },
        : {: , : },
        : {: , : }
    }

    
    MEDIA_PROPERTIES = {
        : {: , : , : },
        : {: , : , : },
        : {: , : , : },
        : {: , : , : },
        : {: , : , : },
        : {: , : , : }
    }

     () -> :
        
        temp = gas.temperature_f

        suitable = []
         media, props  .MEDIA_PROPERTIES.items():
             props[] >= temp:
                suitable.append((media, props))

        
        suitable.sort(key= x: x[][])
         suitable[][]  suitable  

     () -> :
        
        ratios = .AC_RATIOS.get(application, .AC_RATIOS[])
        ac_ratio = ratios[]  use_net_ratio  ratios[]

        filter_area = gas.flow_rate_acfm / ac_ratio

         {
            : gas.flow_rate_acfm,
            : ac_ratio,
            : filter_area
        }

     () -> :
        

        
        media = .select_filter_media(gas)

        
        area_calc = .calculate_filter_area(gas, application)
        required_area = area_calc[]

        
        bag_area = np.pi * (bag_diameter_in / ) * bag_length_ft  

        
        num_bags = np.ceil(required_area / bag_area)

        
        bags_per_compartment =   
        num_compartments = np.ceil(num_bags / bags_per_compartment)

        
        dp_filter =   
        dp_tubesheet = 
        dp_inlet_outlet = 
        total_dp = dp_filter + dp_tubesheet + dp_inlet_outlet

        
        dust_rate_lb_hr = gas.particulate_loading_gr_acf * gas.flow_rate_acfm *  / 
        hopper_volume = dust_rate_lb_hr *  /   

         {
            : media,
            : required_area,
            : bag_diameter_in,
            : bag_length_ft,
            : bag_area,
            : (num_bags),
            : (num_compartments),
            : gas.flow_rate_acfm / (num_bags * bag_area),
            : total_dp,
            : dust_rate_lb_hr,
            : hopper_volume,
            : .MEDIA_PROPERTIES[media][]
        }


gas = GasStreamData(
    flow_rate_acfm=,
    temperature_f=,
    moisture_pct=,
    particulate_loading_gr_acf=,
    particle_size_micron=
)

calculator = BaghouseCalculator()
design = calculator.size_baghouse(gas, application=)

()
()
()
()
()

Wet Scrubber Design

class WetScrubberDesign:
    """Wet scrubber design calculations"""

    def packed_tower_sizing(self, gas_flow_acfm: float,
                           pollutant: str,
                           inlet_conc_ppm: float,
                           outlet_conc_ppm: float,
                           scrubbing_liquid: str = 'water') -> Dict:
        """Size packed tower for gas absorption"""

        # Removal efficiency
        efficiency = (inlet_conc_ppm - outlet_conc_ppm) / inlet_conc_ppm

        # Gas velocity (typical range 3-6 ft/s for packed towers)
        gas_velocity_fps = 4.5

        # Cross-sectional area
        area_sqft = (gas_flow_acfm / 60) / gas_velocity_fps

        # Diameter
        diameter_ft = np.sqrt(4 * area_sqft / np.pi)

        # Height based on NTU (simplified)
        ntu = -np.log(1 - efficiency)  # Number of transfer units
        htu = 2.5  # Height of transfer unit (ft) - typical for 2" packing
        packing_height = ntu * htu

        # L/G ratio (liquid to gas)
        lg_ratio = 10  # gpm per 1000 acfm typical

        # Liquid flow rate
        liquid_flow_gpm = gas_flow_acfm * lg_ratio / 1000

        # Pressure drop (1-2 in w.c. per ft of packing typical)
        pressure_drop = packing_height * 1.5

        return {
            'diameter_ft': diameter_ft,
            'packing_height_ft': packing_height,
            'total_height_ft': packing_height * ,  
            : area_sqft,
            : gas_velocity_fps,
            : liquid_flow_gpm,
            : lg_ratio,
            : pressure_drop,
            : efficiency * ,
            : ntu
        }

     () -> :
        

        
        
        

         target_efficiency_pct >= :
            pressure_drop = 
         target_efficiency_pct >= :
            pressure_drop = 
         target_efficiency_pct >= :
            pressure_drop = 
        :
            pressure_drop = 

        
        lg_ratio =  + (target_efficiency_pct - ) * 

        
        throat_velocity =   

        
        throat_area = gas_flow_acfm / throat_velocity

        
        liquid_flow = gas_flow_acfm * lg_ratio / 

         {
            : throat_area,
            : throat_velocity,
            : pressure_drop,
            : liquid_flow,
            : lg_ratio,
            : target_efficiency_pct
        }


scrubber = WetScrubberDesign()


packed = scrubber.packed_tower_sizing(
    gas_flow_acfm=,
    pollutant=,
    inlet_conc_ppm=,
    outlet_conc_ppm=
)
()
()
()


venturi = scrubber.venturi_scrubber_sizing(
    gas_flow_acfm=,
    particulate_loading_gr_acf=,
    target_efficiency_pct=
)
()
()

BACT Analysis

class BACTAnalysis:
    """Best Available Control Technology analysis"""

    # Control technology database (simplified)
    CONTROL_TECHNOLOGIES = {
        'PM': [
            {'name': 'Baghouse', 'efficiency': 99.9, 'cost_per_ton': 500},
            {'name': 'ESP', 'efficiency': 99.5, 'cost_per_ton': 400},
            {'name': 'Cyclone', 'efficiency': 90, 'cost_per_ton': 100},
            {'name': 'Wet Scrubber', 'efficiency': 95, 'cost_per_ton': 600}
        ],
        'SO2': [
            {'name': 'Wet FGD', 'efficiency': 98, 'cost_per_ton': 800},
            {'name': 'Dry FGD', 'efficiency': 95, 'cost_per_ton': 600},
            {'name': 'SDA', 'efficiency': 92, 'cost_per_ton': 500}
        ],
        'NOx': [
            {'name': 'SCR', : , : },
            {: , : , : },
            {: , : , : }
        ],
        : [
            {: , : , : },
            {: , : , : },
            {: , : , : },
            {: , : , : }
        ]
    }

     () -> []:
        
        technologies = .CONTROL_TECHNOLOGIES.get(pollutant, [])

        
        technologies = (technologies, key= x: x[], reverse=)

        results = []
         tech  technologies:
            tons_removed = uncontrolled_tpy * tech[] / 
            controlled_emissions = uncontrolled_tpy - tons_removed
            annual_cost = tech[] * tons_removed
            cost_effectiveness = tech[]

            is_feasible = cost_effectiveness <= cost_threshold

            results.append({
                : tech[],
                : tech[],
                : controlled_emissions,
                : tons_removed,
                : annual_cost,
                : cost_effectiveness,
                : is_feasible,
                : is_feasible
            })

             is_feasible:
                  

         results

     () -> :
        
        analysis = .top_down_bact(pollutant, uncontrolled_tpy)

        report = 
         i, tech  (analysis, ):
            status =   tech[]  \
                        tech[]  

            report += 

        
        bact = ((t  t  analysis  t[]), )
         bact:
            report += 

         report


bact = BACTAnalysis()

report = bact.generate_bact_report(, uncontrolled_tpy=)
(report)


voc_analysis = bact.top_down_bact(, uncontrolled_tpy=)
 tech  voc_analysis:
    (
          
          )

Usage Guidelines

When to Use This Skill

• Air pollution control system design
• Permit application preparation
• BACT/LAER/MACT determinations
• Control equipment optimization
• Emission reduction projects

Best Practices

1. Characterize emissions thoroughly before design
2. Consider multiple control options for BACT
3. Account for variable operating conditions in sizing
4. Include maintenance access in design
5. Design for turndown when loads vary
6. Plan for monitoring to verify performance

Process Integration

• AQ-002: Air Pollution Control System Design (all phases)
• AQ-001: Air Permit Application Development (BACT determination)

Dependencies

• numpy: Numerical calculations
• scipy: Engineering correlations

References

• EPA Air Pollution Control Technology Fact Sheets
• OAQPS Control Cost Manual
• EPA RACT/BACT/LAER Clearinghouse