UK startup Altilium bags £18.5m to build Britain’s first commercial EV battery refinery

Introduction

In this tutorial, you'll learn how to simulate the process of extracting valuable materials from electric vehicle (EV) batteries using Python. This is inspired by the work of UK startup Altilium, which is developing technology to recover critical minerals from end-of-life EV batteries. While we won't build a real refinery, we'll create a simplified model that demonstrates the core concepts of battery recycling and material recovery.

Understanding this process is important because as EV adoption grows, we need sustainable ways to handle battery waste. This tutorial will help you grasp how data modeling and simulation can support environmental technology solutions.

Prerequisites

• Basic understanding of Python programming
• Python 3.x installed on your computer
• Optional: Jupyter Notebook or any code editor

Step-by-Step Instructions

1. Set Up Your Python Environment

First, we need to create a Python script that will model our battery recycling process. Open your code editor and create a new file called battery_recycling.py.

2. Import Required Libraries

We'll need the math module for calculations and random for simulating variability in the process.

import math
import random

3. Create a Battery Class

Let's model an EV battery with basic properties. This represents a typical lithium-ion battery used in electric vehicles.

class Battery:
    def __init__(self, capacity_kwh, lithium_content, cobalt_content, nickel_content):
        self.capacity_kwh = capacity_kwh  # Battery capacity in kWh
        self.lithium_content = lithium_content  # Amount of lithium in kg
        self.cobalt_content = cobalt_content  # Amount of cobalt in kg
        self.nickel_content = nickel_content  # Amount of nickel in kg
        
    def __str__(self):
        return f"Battery: {self.capacity_kwh}kWh, Lithium: {self.lithium_content}kg, Cobalt: {self.cobalt_content}kg, Nickel: {self.nickel_content}kg"

4. Define the Recycling Process

Now we'll create a function that simulates the EcoCathode™ process. This is a simplified representation of how valuable materials can be recovered from batteries.

def process_battery(battery):
    # Simulate recovery rates (these are hypothetical values)
    lithium_recovery_rate = 0.85  # 85% recovery
    cobalt_recovery_rate = 0.75   # 75% recovery
    nickel_recovery_rate = 0.70   # 70% recovery
    
    # Calculate recovered materials
    recovered_lithium = battery.lithium_content * lithium_recovery_rate
    recovered_cobalt = battery.cobalt_content * cobalt_recovery_rate
    recovered_nickel = battery.nickel_content * nickel_recovery_rate
    
    # Return the results
    return {
        'lithium': recovered_lithium,
        'cobalt': recovered_cobalt,
        'nickel': recovered_nickel,
        'total_recovery': recovered_lithium + recovered_cobalt + recovered_nickel
    }

5. Create a Recycling Facility Class

Let's model a recycling facility that can process multiple batteries.

class RecyclingFacility:
    def __init__(self, name, processing_capacity):
        self.name = name
        self.processing_capacity = processing_capacity  # Batteries per day
        self.processed_batteries = []
        self.total_recovered_materials = {'lithium': 0, 'cobalt': 0, 'nickel': 0}
        
    def process_batteries(self, batteries):
        total_batteries = len(batteries)
        processed_count = 0
        
        print(f"Starting processing of {total_batteries} batteries at {self.name}")
        
        for battery in batteries:
            if processed_count >= self.processing_capacity:
                print(f"Processing capacity reached. Stopping at {processed_count} batteries.")
                break
            
            results = process_battery(battery)
            self.processed_batteries.append(battery)
            
            # Add to total recovered materials
            for material, amount in results.items():
                if material != 'total_recovery':
                    self.total_recovered_materials[material] += amount
            
            processed_count += 1
            
        print(f"Successfully processed {processed_count} batteries")
        return self.total_recovered_materials

6. Generate Sample Battery Data

We need some sample data to test our recycling process. Let's create a function that generates random but realistic battery data.

def generate_sample_batteries(count):
    batteries = []
    for i in range(count):
        # Generate realistic battery properties
        capacity = random.uniform(40, 100)  # kWh
        lithium = random.uniform(2, 8)      # kg
        cobalt = random.uniform(0.5, 3)     # kg
        nickel = random.uniform(1, 5)       # kg
        
        battery = Battery(capacity, lithium, cobalt, nickel)
        batteries.append(battery)
    
    return batteries

7. Run the Simulation

Now we'll put everything together in a main function that runs our simulation.

def main():
    print("=== EV Battery Recycling Simulation ===")
    
    # Generate sample batteries
    batteries = generate_sample_batteries(50)
    
    # Create a recycling facility
    facility = RecyclingFacility("Altilium ACT3", 20)
    
    # Process the batteries
    recovered = facility.process_batteries(batteries)
    
    # Display results
    print("\n=== Recycling Results ===")
    print(f"Total lithium recovered: {recovered['lithium']:.2f} kg")
    print(f"Total cobalt recovered: {recovered['cobalt']:.2f} kg")
    print(f"Total nickel recovered: {recovered['nickel']:.2f} kg")
    
    total_materials = recovered['lithium'] + recovered['cobalt'] + recovered['nickel']
    print(f"Total materials recovered: {total_materials:.2f} kg")
    
    # Show some statistics
    print("\n=== Facility Statistics ===")
    print(f"Facility name: {facility.name}")
    print(f"Processing capacity: {facility.processing_capacity} batteries/day")
    print(f"Total batteries processed: {len(facility.processed_batteries)}")

if __name__ == "__main__":
    main()

8. Run Your Simulation

Save your file and run it from the command line:

python battery_recycling.py

This will simulate processing 50 batteries and show how much material can be recovered using the recycling process.

9. Analyze the Results

When you run the simulation, you'll see output showing:

• How many batteries were processed
• How much lithium, cobalt, and nickel were recovered
• Overall material recovery rates

This demonstrates the importance of recycling - even though we start with 50 batteries, we can recover significant amounts of valuable materials that would otherwise be wasted.

Summary

In this tutorial, you've learned how to create a simple simulation of EV battery recycling using Python. You built classes to represent batteries and recycling facilities, created a process function to simulate material recovery, and ran a complete simulation. This approach helps visualize how companies like Altilium are working to create sustainable solutions for battery waste.

The simulation shows that even with current recovery rates, we can salvage significant amounts of valuable materials from end-of-life batteries. This is crucial for both environmental sustainability and economic efficiency, as these materials are expensive to mine and process.

While this is a simplified model, it demonstrates the kind of data analysis and modeling that real recycling facilities use to optimize their operations and maximize material recovery.