PapAiEra — AI-Powered Optimization for the Pulp & Paper Industry

A comprehensive Python library that mathematically models and solves optimization problems based on Best Available Techniques (BAT) reference documents from the EU BREF 2015.

🔬 Process Modeling 🤖 Machine Learning ⚙️ Non-Linear Optimization 🌱 Sustainability Tracking 📊 Industry 4.0 Ready 🇪🇺 BAT Compliant

🚀 Get Started 📖 View Examples

Installation

Install PapAiEra from PyPI in seconds:

$ pip install PapAiEra

Install

pip install PapAiEra

Import

from pap_ai_era import *

Optimize

Apply BAT-compliant models

Deploy

Integrate into mill DCS

🌲 Pulping Modules

Comprehensive tools for all major pulping processes with BAT compliance checking and mass/energy balances.

Kraft Pulping

pap_ai_era.pulping.kraft

H-factor calculation for cooking intensity, digester mass balance, Kappa number prediction, recovery boiler efficiency, black liquor solids monitoring, and BAT compliance validation for chemical recovery cycles.

calculate_h_factor() digester_mass_balance() predict_kappa() recovery_efficiency() black_liquor_solids() check_bat_compliance()

View Example →

Sulphite Pulping

pap_ai_era.pulping.sulphite

Yield calculations for paper-grade and dissolving-grade pulp, SO₂ recovery management, and Mg/Ca base chemical recovery optimization with environmental emission constraints.

calculate_yield() so2_recovery() base_cycle_optimize() dissolving_grade_check()

View Example →

Mechanical Pulping

pap_ai_era.pulping.mechanical

Energy intensity modeling for SGW, PGW, TMP, and CTMP processes. Heat recovery potential analysis, specific energy optimization, and freeness target achievement.

energy_intensity_sgw() energy_intensity_pgw() tmp_optimization() ctmp_chemical_load() heat_recovery_potential()

View Example →

Recycled Fibre Processing

pap_ai_era.pulping.recycled_fibre

De-inking efficiency calculations, yield loss tracking through screening/cleaning stages, stickies management, and BAT water usage compliance for recycled fibre lines.

deinking_efficiency() yield_loss_tracking() stickies_management() water_usage_bat()

View Example →

Non-Wood Fibres

pap_ai_era.pulping.nonwood

Silica management for straw/bagasse pulping, soda recovery optimization, and specialized cooking parameter calculations for agricultural residue fibres.

silica_management() soda_recovery() cooking_params()

View Example →

Universal Bleaching Engine

pap_ai_era.bleaching

AI-driven bleaching sequence optimizer supporting dynamic stage configuration (D, EOP, A, O, P, Z stages), chemical cost minimization, and multi-target quality achievement.

run_optimization_from_config() build_sequence() simulate_stage() cost_analysis() quality_prediction()

View Example →

Example Kraft Digester — H-Factor & Mass Balance

from pap_ai_era.pulping.kraft import (
    calculate_h_factor,
    digester_mass_balance,
    predict_kappa
)

# ── 1. Calculate integrated cooking reaction rate ──
# Cooking at 165°C for 45 minutes
h_factor = calculate_h_factor(
    temperature_celsius=165.0,
    time_minutes=45.0
)
print(f"H-Factor: {h_factor:.2f}")
# → H-Factor: 892.45

# ── 2. Digester mass balance ──
balance = digester_mass_balance(
    wood_input_tpd=1200,
    chip_moisture_pct=50.0,
    kappa_target=30
)
print(f"Pulp output: {balance['pulp_tpd']:.1f} tpd")
print(f"Black liquor: {balance['bl_solids_tpd']:.1f} tpd")

# ── 3. Predict Kappa from cooking conditions ──
kappa = predict_kappa(
    h_factor=h_factor,
    ea_charge_pct=18.5,
    sulfidity_pct=25.0
)
print(f"Predicted Kappa: {kappa:.1f}")
          

Example Sulphite Process — Yield & SO₂ Recovery

from pap_ai_era.pulping.sulphite import (
    calculate_yield,
    so2_recovery
)

# Paper-grade yield calculation
result = calculate_yield(
    grade="paper",
    wood_species="spruce",
    cooking_temp=140,
    cooking_time_hr=6.5
)
print(f"Yield: {result['yield_pct']:.1f}%")
print(f"BAT compliant: {result['bat_compliant']}")

# SO₂ recovery efficiency
recovery = so2_recovery(
    flue_gas_so2_ppm=2500,
    scrubber_efficiency=0.95
)
print(f"SO₂ recovered: {recovery['recovered_kg_hr']:.1f} kg/hr")
          

Advanced Universal Bleaching Optimizer — Multi-Stage Cost Minimization

from pap_ai_era.bleaching import run_optimization_from_config

config = {
    "stages": [
        {
            "name": "D0",
            "chemicals": [
                {"name": "ClO2", "min_dosage": 5,
                 "max_dosage": 30, "cost": 0.80}
            ]
        },
        {
            "name": "EOP",
            "chemicals": [
                {"name": "NaOH", "min_dosage": 5,
                 "max_dosage": 25, "cost": 0.40},
                {"name": "H2O2", "min_dosage": 2,
                 "max_dosage": 15, "cost": 0.60}
            ]
        },
        {
            "name": "D1",
            "chemicals": [
                {"name": "ClO2", "min_dosage": 2,
                 "max_dosage": 15, "cost": 0.80}
            ]
        }
    ],
    "targets": {
        "brightness": 90.0,
        "kappa": 2.0,
        "viscosity_min": 800
    },
    "input_pulp": {
        "kappa": 12.0,
        "brightness": 35.0,
        "viscosity": 1100
    }
}

result = run_optimization_from_config(config)

print(f"Optimal cost: ${result['total_cost']:.2f}/ton")
print(f"Achieved brightness: {result['brightness']:.1f} ISO")
print(f"Chemical dosages: {result['dosages']}")
          

📄 Papermaking Modules

End-to-end paper machine optimization from headbox to reel, with ML-powered quality predictions and ABB-compliant variability analysis.

Machine Operations

pap_ai_era.papermaking.machine

Fiber mass balance tracking across the entire machine, OEE calculation, broke management and recirculation tracking, wire retention analysis, and dryer section steam economy optimization.

calculate_oee() fiber_mass_balance() track_broke() dryer_economy() wire_retention() production_rate()

View Example →

Wet End Chemistry

pap_ai_era.papermaking.wet_end_chemistry

Furnish-based chemical dosing heuristics for retention aids, sizing agents, and fillers. Pump conversion algorithms (GPL → LPH), ash retention modeling, and first-pass retention optimization.

optimize_dosing() convert_gpl_to_lph() predict_ash_retention() first_pass_retention() charge_demand()

View Example →

ML Bulk Prediction

pap_ai_era.papermaking.BulkModel

Physics-aware machine learning model predicting paper/board bulk (cm³/g) based on layer-wise furnish composition, pulp properties (CSF, SW/HW ratio), and pressing conditions.

BulkModel(n_layers) BulkModel.train() BulkModel.predict() sensitivity_analysis() feature_importance()

View Example →

Variability Analysis (VPA)

pap_ai_era.papermaking.variability_analysis

ABB-compliant Variance Partition Analysis decomposing reel variability into MD Long-term, Cross Direction, and MD Short-term with root-cause inference and 2-sigma normalized reporting.

compute_vpa() decompose_variability() identify_root_cause() generate_vpa_report()

View Example →

Coating & Finishing

pap_ai_era.papermaking.coating

Coating color formulation optimization, coat weight uniformity analysis, calendering parameter optimization for gloss/smoothness targets, and finishing waste minimization.

optimize_coat_weight() color_formulation() calender_settings() finishing_waste()

View Example →

Example Machine Operations — OEE & Fiber Balance

from pap_ai_era.papermaking.machine import (
    calculate_oee,
    fiber_mass_balance,
    track_broke
)

# ── OEE Calculation ──
oee = calculate_oee(
    availability=0.92,
    performance=0.88,
    quality=0.97
)
print(f"OEE: {oee['oee_pct']:.1f}%")
print(f"World-class threshold: 85%")
print(f"Status: {oee['rating']}")

# ── Fiber Mass Balance ──
balance = fiber_mass_balance(
    furnish_input_tpd=500,
    consistency_pct=3.5,
    first_pass_retention=0.78,
    wire_retention=0.92
)
print(f"Fiber to reel: {balance['reel_fiber_tpd']:.1f} tpd")
print(f"White water losses: {balance['ww_losses_tpd']:.1f} tpd")
          

Example Wet End Chemistry — Dosing Optimization

from pap_ai_era.papermaking.wet_end_chemistry import (
    optimize_dosing,
    convert_gpl_to_lph,
    predict_ash_retention
)

# Optimize chemical dosing for a given furnish
furnish = {
    "sw_pulp_pct": 40,
    "hw_pulp_pct": 30,
    "broke_pct": 15,
    "filler_pct": 15,
    "production_tpd": 450
}

dosing = optimize_dosing(furnish)
print(f"Retention aid: {dosing['retention_aid_lph']:.1f} LPH")
print(f"Sizing agent: {dosing['sizing_lph']:.1f} LPH")

# Convert concentration to flow rate
flow = convert_gpl_to_lph(
    concentration_gpl=5.0,
    target_kg_hr=12.5
)
print(f"Pump setting: {flow:.1f} LPH")
          

ML Model Bulk Prediction — Multi-Layer Board Structure

from pap_ai_era.papermaking import BulkModel

# Define 3-layer board structure
layers = [
    {"gsm": 40,  "sw_ratio": 0.95, "csf": 580},  # Top
    {"gsm": 180, "sw_ratio": 0.10, "csf": 380},  # Middle
    {"gsm": 50,  "sw_ratio": 0.85, "csf": 520},  # Bottom
]
process = {
    "nip_load": 65,      # kN/m
    "n_nips": 3,
    "press_temp": 85   # °C
}

# Initialize model for 3-layer structure
model = BulkModel(n_layers=3)

# Train on historical mill data (optional)
# model.train(historical_dataframe)

# Predict bulk for current configuration
predicted_bulk = model.predict(layers, process)
print(f"Predicted Bulk: {predicted_bulk:.3f} cm³/g")

# Sensitivity: how does nip load affect bulk?
sensitivity = model.sensitivity_analysis(
    parameter="nip_load",
    range_min=40,
    range_max=100
)
          

Analytics Variance Partition Analysis — 2-Sigma Decomposition

import numpy as np
from pap_ai_era.papermaking.variability_analysis import (
    compute_vpa,
    identify_root_cause
)

# Simulated scanner data: 50 scans × 600 CD boxes
np.random.seed(42)
data = np.random.normal(loc=50.0, scale=1.5, size=(50, 600))

# Add CD profile bias (simulating a headbox issue)
data[:, 200:400] += 2.0

# Compute VPA report
vpa = compute_vpa(data, process_average=50.0)

print(f"Total 2σ Variability: {vpa.normalised['TOT']:.2f}%")
print(f"MD Long-term (MDL):   {vpa.normalised['MDL']:.2f}%")
print(f"Cross Direction (CD):  {vpa.normalised['CD']:.2f}%")
print(f"MD Short-term (MDS):   {vpa.normalised['MDS']:.2f}%")

# Root cause inference
cause = identify_root_cause(vpa)
print(f"Primary issue: {cause['problem']}")
print(f"Recommendation: {cause['action']}")
          

♻️ Sustainability Modules

Comprehensive environmental impact tracking aligned with ISO 14001, EU BREF 2015, and BAT-AEL reference values.

Emissions Tracking

pap_ai_era.sustainability.emissions

Calculate and report BOD, COD, TSS loads discharged to water bodies, and TRS, SO₂, NOₓ, Dust emissions to air. Automatic comparison against BAT-AEL reference limits with compliance flagging.

calculate_water_loads() estimate_air_emissions() check_bat_limits() emission_inventory() compliance_dashboard()

View Example →

Water & Wastewater

pap_ai_era.sustainability.wastewater

Loop closure analysis for water circuits, explicit cooling-water vs contaminated-water accounting, wastewater treatment efficiency modeling, and specific water consumption benchmarking.

analyze_loop_closure() water_balance() treatment_efficiency() specific_consumption() bat_water_benchmark()

View Example →

Environmental Management

pap_ai_era.sustainability.ems

ISO 14001 compliance grading across all EMS elements, solid waste footprint calculation (Ash + Sludge + Rejects), carbon accounting, and automated sustainability KPI dashboards.

iso14001_grade() calculate_waste_footprint() carbon_accounting() generate_sustainability_report() kpi_dashboard()

View Example →

Example Emissions — BAT Compliance Check

from pap_ai_era.sustainability.emissions import (
    calculate_water_loads,
    estimate_air_emissions,
    check_bat_limits
)

# ── Water emissions ──
water = calculate_water_loads(
    flow_m3_day=15000,
    bod_mgl=18.5,
    cod_mgl=85.0,
    tss_mgl=12.0,
    production_tpd=800
)
print(f"COD load: {water['cod_kg_ton']:.2f} kg/ton product")

# ── Air emissions ──
air = estimate_air_emissions(
    recovery_boiler={"so2_ppm": 120, "nox_ppm": 180},
    lime_kiln={"dust_mgNm3": 25, "so2_ppm": 40},
    production_tpd=800
)

# ── BAT compliance ──
compliance = check_bat_limits(water, air, process_type="kraft")
print(f"Overall BAT status: {compliance['status']}")
for param, result in compliance["details"].items():
    status = "✅" if result["compliant"] else "❌"
    print(f"  {status} {param}: {result['value']} (BAT: {result['bat_limit']})")
          

🧠 Mathematical AI Solvers

Non-linear optimization engines using SciPy constraint solvers and Differential Evolution for global search across process setpoints.

⚡

Multi-Objective Optimization

Balance cost, quality, and sustainability targets simultaneously with weighted objective functions.

🔒

Constraint-Aware Solving

Respects operational safety limits, equipment boundaries, and regulatory BAT constraints.

🔄

Hybrid Modeling

Combines first-principles physics equations with ML residual corrections for accuracy.

🎯

Global Search (DE)

Differential Evolution avoids local minima traps in highly non-linear process landscapes.

🔍

Optimizer Library

pap_ai_era.optimization_models

Complete library of pre-built optimization models covering the entire pulp and paper value chain. Each model encodes BAT constraints and process physics.

optimize_batch_kraft_digester() optimize_continuous_kamyr_digester() optimize_bleaching_sequence_cost() optimize_sulphite_base_recovery() optimize_machine_steam_consumption() optimize_wet_end_dosing() optimize_cogeneration_tg_fuel() optimize_recycled_fibre_yield() optimize_coating_formulation()

Explore Source →

🔥

Boiler Digital Twin

pap_ai_era.energy.boiler_optimizer

Physics-aware hybrid model maximizing thermal efficiency while respecting O₂%, pressure, temperature, and emission constraints. Supports multi-fuel scenarios.

Boiler(name, capacity) BoilerOptimizer.optimize() efficiency_analysis() fuel_blend_optimization()

View Example →

💨

Hood Energy Optimizer

pap_ai_era.papermaking.hood_optimizer

Balances evaporation load against supply/exhaust airflow and recirculation to minimize steam and electrical energy while ensuring target sheet dryness at the reel.

run_hood_optimization() calculate_drying_load() optimize_fan_rpm() heat_recovery_analysis()

View Example →

Example Boiler Digital Twin — Efficiency Optimization

from pap_ai_era.energy.boiler_optimizer import (
    Boiler,
    BoilerOptimizer
)

# Define boiler unit
boiler = Boiler(
    name="RB-1",
    capacity_tph=150,
    fuel_type="black_liquor",
    design_pressure_bar=65
)

# Run optimization
optimizer = BoilerOptimizer(boiler)
result = optimizer.optimize(
    constraints={
        "o2_min_pct": 2.0,
        "o2_max_pct": 5.0,
        "max_pressure_bar": 62,
        "max_temp_c": 480
    },
    objective="maximize_efficiency"
)

print(f"Optimal efficiency: {result['efficiency']:.1f}%")
print(f"Optimal O₂ setpoint: {result['o2_pct']:.2f}%")
print(f"Fuel savings: {result['savings_pct']:.1f}%")
          

Example Hood Energy Optimizer — Steam & Airflow Balance

from pap_ai_era.papermaking.hood_optimizer import (
    run_hood_optimization
)

result = run_hood_optimization(
    production_tpd=600,
    inlet_dryness_pct=42,
    target_dryness_pct=92,
    hood_type="closed",
    steam_pressure_bar=4.5,
    ambient_temp_c=30
)

print(f"Evaporation load: {result['evap_kg_hr']:.0f} kg/hr")
print(f"Optimal supply air: {result['supply_air_m3h']:.0f} m³/h")
print(f"Steam consumption: {result['steam_tph']:.2f} tph")
print(f"Energy savings vs baseline: {result['savings_pct']:.1f}%")
          

📚 Quick Reference

🔧 Core Imports

from pap_ai_era.pulping import kraft from pap_ai_era.pulping import sulphite from pap_ai_era.pulping import mechanical from pap_ai_era.bleaching import * from pap_ai_era.papermaking import * from pap_ai_era.sustainability import * from pap_ai_era.optimization_models import * from pap_ai_era.energy import *

🎯 Common Parameters

temperature_celsius — Process temp (°C)
time_minutes — Reaction duration
production_tpd — Tonnes per day
target_gsm — Basis weight (g/m²)
moisture_pct — Water content %
consistency_pct — Stock consistency %
kappa_target — Kappa number goal
brightness_iso — Brightness target
chemical_dosage — Additive kg/ton

📦 Return Types

dict — Detailed result metrics
float — Single calculated value
dataclass — Structured report
numpy.array — VPA matrices
pandas.DataFrame — Tabular data

🏷️ Standards

EU BREF 2015 (BAT)
ISO 14001 (EMS)
ABB VPA Standards
TAPPI Test Methods