8 Python Libraries Every Chemical Engineer Should Know for Faster Workflows

Matplotlib & Seaborn

Matplotlib is a plotting library that gives you complete control over every part of a figure. Seaborn is built on top of Matplotlib and provides a simpler way to create attractive and informative statistical graphs.

In chemical engineering, Matplotlib is used to create plots like temperature vs. time, concentration profiles, and phase diagrams to understand process behavior.

Seaborn makes it easier to create more attractive and informative visualizations, like heat maps for reactor temperatures or distribution plots for experimental data.

Here is an example for using seaborn library to plot a heatmap of temperature distribution in a reactor.

!pip install seaborn matplotlib

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# Sample data: Temperature distribution in a reactor (°C)
temperature_data = np.array([
    [70, 72, 75, 77, 80],
    [68, 70, 73, 75, 78],
    [65, 67, 70, 72, 75],
    [63, 65, 67, 69, 72],
    [60, 63, 65, 68, 70]
])

# Plotting the heatmap
plt.figure(figsize=(9, 5))
sns.heatmap(temperature_data, annot=True, cmap='coolwarm', fmt=".1f")
plt.title("Temperature Distribution in Reactor")
plt.xlabel("Position (m)")
plt.ylabel("Height (m)")
plt.show()

Output:

Cantera for Thermodynamics, Kinetics & Transport

Cantera is a powerful open-source library used for solving problems involving thermodynamics, chemical kinetics, and transport processes. It’s particularly strong in reacting flows.

Here is an example for simulating the Haber Process to calculate the equilibrium temperature, pressure, and mole fractions of nitrogen, hydrogen, and ammonia using Cantera.

!pip install cantera

import cantera as ct

# Define the gas mixture (Ammonia synthesis reaction)
gas = ct.Solution('gri30.yaml')
gas.TP = 700 + 273.15, 20 * ct.one_atm  # Set temperature to 700°C and pressure to 20 atm

# Set the initial mole fractions (1:3 ratio of N2 and H2)
gas.X = {'N2': 1, 'H2': 3, 'NH3': 0}

# Equilibrate the gas mixture for constant T and P
gas.equilibrate('TP')

# Display the results
print(f"Equilibrium Temperature: {gas.T:.2f} K")
print(f"Equilibrium Pressure: {gas.P / ct.one_atm:.2f} atm")
print("Equilibrium Mole Fractions:")

# Loop through species names and mole fractions
for species, fraction in zip(gas.species_names, gas.X):
    if fraction > 1e-5:  # Display only significant species
        print(f"{species}: {fraction:.5f}")

Output:

Equilibrium Temperature: 973.15 K
Equilibrium Pressure: 4.73 atm
Equilibrium Mole Fractions:
H2: 0.74919
NH3: 0.00108
N2: 0.24973

Related: Relation Between Van der Waals Constants and Critical Constants

Related: Clausius Clapeyron Equation Calculator, Derivation and Applications

CoolProp for Thermophysical Properties

CoolProp provides accurate thermophysical property data for a wide range of pure fluids, pseudo-pure fluids, and predefined mixtures.

Google Colab Python code for plotting above P-H diagram for refrigerant using coolprop data – python code link

📊 Data Analytics with Python

Learn Python, Pandas, NumPy & Matplotlib by solving real-world data problems. Ideal for beginners & data enthusiasts.

👉 Start Learning Now

Powered by SimpliLearn | Coursera Approved

This example shows how to use the CoolProp library in python to calculate water properties (density, viscosity, specific heat, and thermal conductivity) at a specified temperature and pressure.

from CoolProp.CoolProp import PropsSI

# Properties of water at 300 K and 1 atm (101325 Pa)
T = 300  # Kelvin
P = 101325 # Pascals

density = PropsSI('D', 'T', T, 'P', P, 'Water') # Density in kg/m^3
viscosity = PropsSI('V', 'T', T, 'P', P, 'Water') # Viscosity in Pa*s
cp = PropsSI('C', 'T', T, 'P', P, 'Water') # Specific heat capacity (Cp) in J/kg*K
conductivity = PropsSI('L', 'T', T, 'P', P, 'Water') # Thermal conductivity in W/m*K

print(f"Water properties at {T} K and {P/1000} kPa:")
print(f"  Density: {density:.2f} kg/m^3")
print(f"  Viscosity: {viscosity:.2e} Pa*s")
print(f"  Specific Heat (Cp): {cp:.2f} J/kg*K")
print(f"  Thermal Conductivity: {conductivity:.3f} W/m*K")

Output:

 Water properties at 300 K and 101.325 kPa:
   Density: 996.56 kg/m^3
   Viscosity: 8.51e-04 Pa*s
   Specific Heat (Cp): 4180.59 J/kg*K
   Thermal Conductivity: 0.609 W/m*K

Related: Area of Cross-Section Calculator for Hollow Sections, Beams & Shapes

Related: Friction Factor Calculator Moody’s Diagram for Smooth and Rough Pipes

Related: Head Loss or Pressure Loss Calculator using Darcy-Weisbach Equation

Pint – Library for Units & Conversions

Pint is the python package to define and operate physical quantities with units. It allows you to perform calculations while keeping track of units.

In Chemical Engineerig, Pint library is used to simplify unit conversions and calculations for measurements like temperature or volume. It saves time, reduces errors, and ensures consistent units in designs and teamwork.

This example shows how the Pint library manages scientific units and conversions by calculating the volume of a gas using the ideal gas law.

# Install Pint if not already installed
!pip install pint

# Import required libraries
from pint import UnitRegistry
import numpy as np

# Initialize Pint unit registry
ureg = UnitRegistry()

# Define constants and inputs
R = 8.314 * ureg.J / (ureg.mol * ureg.K)  # Ideal gas constant
n = 10 * ureg.kmol  # Amount of nitrogen
T = ureg.Quantity(25, ureg.degC)  # Temperature
P = 5 * ureg.bar  # Pressure

# Convert temperature to Kelvin and pressure to Pascals for ideal gas law
T = T.to(ureg.K)  # Convert °C to K
P = P.to(ureg.Pa)  # Convert bar to Pa

# Calculate volume using ideal gas law: V = nRT / P
V = (n * R * T) / P

# Convert volume to liters and cubic meters for practical use
V_liters = V.to(ureg.L)  # Convert to liters
V_cubic_meters = V.to(ureg.m**3)  # Convert to cubic meters (fixed syntax)

# Print results
print(f"Ideal Gas Volume Calculation for Nitrogen:")
print(f"Amount: {n:.2f}")
print(f"Temperature: {T:.2f} ({T.to(ureg.degC):.2f})")
print(f"Pressure: {P:.2e} ({P.to(ureg.bar):.2f})")
print(f"Volume: {V_cubic_meters:.2f} or {V_liters:.2f}")

# Practical application: Check if volume fits a standard tank (e.g., 10 m^3)
tank_volume = 10 * ureg.m**3  # Fixed syntax for tank volume
if V_cubic_meters <= tank_volume:
    print(f"The volume {V_cubic_meters:.2f} fits in a {tank_volume:.2f} tank.")
else:
    print(f"The volume {V_cubic_meters:.2f} is too large for a {tank_volume:.2f} tank.")

Output:

Ideal Gas Volume Calculation for Nitrogen:
Amount: 10.00 kilomole
Temperature: 298.15 kelvin (25.00 degree_Celsius)
Pressure: 5.00e+05 pascal (5.00 bar)
Volume: 49.58 meter ** 3 or 49576.38 liter
The volume 49.58 meter ** 3 is too large for a 10.00 meter ** 3 tank.

Must Read: Personal Carbon Footprint Calculator – Track your CO2 Emissions

Also Read: The Crucial Role of Chemical Engineering in Everyday Life

Also Read: Online Psychrometric Calculator for Chemical Engineers

ChemPy for Chemical Reaction Engineering

ChemPy is a Python package designed to solve chemical kinetics problems, especially systems of ODEs from reaction mechanisms. It can also be used to analyze chemical equilibria.

This example demonstrates how to use the ChemPy Python package to balance reaction stoichiometry and it can also be used to calculate the amount of reactant needed for a given chemical reaction.

# Install ChemPy if not already installed
!pip install chempy

# Import required libraries
from chempy import balance_stoichiometry
from chempy.chemistry import Substance

# Define the substances involved in the propane combustion reaction
substances = {
    'C3H8': Substance.from_formula('C3H8'),  # Propane
    'O2': Substance.from_formula('O2'),      # Oxygen
    'CO2': Substance.from_formula('CO2'),    # Carbon dioxide
    'H2O': Substance.from_formula('H2O')     # Water
}

# Define reactants and products for the reaction: C3H8 + O2 -> CO2 + H2O
reactants = ['C3H8', 'O2']
products = ['CO2', 'H2O']

# Balance the reaction stoichiometry
reac, prod = balance_stoichiometry(reactants, products, substances=substances)

# Print the balanced reaction
print("Balanced Combustion Reaction for Propane:")
print(f"{reac['C3H8']} C3H8 + {reac['O2']} O2 -> {prod['CO2']} CO2 + {prod['H2O']} H2O")

Output:

Balanced Combustion Reaction for Propane:
1 C3H8 + 5 O2 -> 3 CO2 + 4 H2O

Related: Bernoulli’s Equation Calculator / Solver – Interactive Python Code

Also Read: Chemical Engineering as a career option in India

Note: Many process simulators, such as DWSIM, COCO, and Aspen Plus, can integrate with Python via dedicated interfaces or scripts, enabling users to automate tasks and easily customize simulations.

The integration of Python into chemical engineering is changing the field by making problem-solving faster, more flexible, data-focused, and innovative. Learning these libraries gives you a strong and adaptable set of tools.

Resources

1. Process Control and Automation. Chemical Engineering Fundamentals Review
2. Seider, W. D., Seader, J. D., & Lewin, D. R. (2010). Product and Process Design Principles: Synthesis, Analysis, and Evaluation. John Wiley & Sons.
3. Aspen Technology. (n.d.). Aspen Plus and HYSYS for Process Modeling. AspenTech.
4. The MathWorks, Inc. (n.d.). MATLAB and Simulink for Chemical Process Control. MathWorks.
5. Roush, J. (2020). Data Science and Machine Learning in Chemical Engineering. AIChE.

Disclaimer: The content provided here is for educational purposes. While efforts ensure accuracy, results may not always reflect real-world scenarios. Verify results with other sources and consult professionals for critical applications. Contact us for any suggestions or corrections.