The Hidden Carbon Footprint of Household Plastic Recycling
Published:
Follows the previous blog post, this is also another one about the IMMC 2025 competition. This time, I will be discussing the solution to Problem C, focusing on household plastic recycling sustainability. This fascinating problem combines environmental science with mathematical modeling to determine whether household plastic recycling truly helps combat global warming.
Problem Background
In the context of global warming, understanding the carbon footprint of everyday activities has become increasingly crucial. While major industries, transportation, and energy generation are the primary greenhouse gas emitters, individual actions like household plastic recycling play a significant role in our collective environmental impact.
The Recycle Paradox
Household plastic recycling presents a complex environmental paradox. While it clearly helps reduce plastic pollution and microplastic contamination, several factors complicate its carbon footprint calculation:
- Contamination Issues
- Food particle residue requiring household washing
- Paper stickers and labels affecting processing
- Mixed plastic types complicating sorting
- Transportation Challenges
- Collection from urban areas to recycling centers
- Multiple transportation stages
- Fuel consumption during delivery
- Processing Requirements
- Sorting and cleaning operations
- Energy consumption during recycling
- Water usage for cleaning
Key Questions
The challenge raises several critical questions:
- What types of household plastic are truly recyclable?
- What preparation steps are necessary?
- Is the total carbon footprint positive or negative?
- How can we optimize recycling center locations?
Analysis
The problem requires a comprehensive analysis of two main aspects:
- Carbon Footprint Calculation
- Practical household plastic waste estimation
- Processing requirements analysis
- Transportation impact assessment
- Net environmental impact calculation
- Recycling Center Location Optimization
- Community accessibility considerations
- Transportation efficiency
- Population density analysis
- Infrastructure requirements
Mathematical Model
Our analysis employs several sophisticated mathematical approaches:
- Carbon Footprint Model The total carbon footprint is modeled as: \(CF_{total} = \sum_{i=1}^{n} (w_i \cdot CF_{i} \cdot E_i) + \sum_{j=1}^{m} (T_j + P-S)\) where:
- $w_i$ is the weight of plastic type $i$
- $CF_{i}$ is the carbon factor of plastic type $i$
- $E_i$ is the efficiency factor of recycling type $i$
- $T_j$ is the transportation emissions for stage $j$
- $P$ is the processing emissions
- $S$ is the carbon savings from recycling
- Location Optimization Model For recycling center placement, we have the following model: \(\min Z = \sum_{i=1}^{n} \sum_{j=1}^{n} \sum_{k=1}^{K} c_{ij} x_{ijk}\) Subject to constraints:
- $\sum_{i=1}^{n} \sum_{k=1}^K x_{ijk} = 1, \forall i \in N$
- $\sum_{i \in N}d_i \sum_{j=1}^n x_{ijk} \leq Q_{k}, \forall k \in K$ where:
- $c_{ij}$ is the cost of transporting plastic type $i$ to center $j$
- $x_{ijk}$ is the binary variable indicating if plastic type $i$ is transported to center $j$ in region $k$
- $d_i$ is the demand at point $i$
- $Q_{k}$ is the capacity constraint for center $k$
- Efficiency Analysis Process efficiency is modeled as: \(E = \frac{R_{out}}{W_{in}} \cdot \frac{1}{1+C_f}\) where:
- $R_{out}$ is the recycled output
- $W_{in}$ is the waste input
- $C_{f}$ is the contamination factor
Solution
The implementation combines sophisticated mathematical modeling with practical considerations for household plastic recycling. Here’s the detailed implementation:
class PlasticRecyclingModel:
def __init__(self):
self.plastic_types = {
'PET': {
'washing_factor': 0.2,
'processing_factor': 0.4,
'efficiency': 0.95,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.1,
'common_items': ['water bottles', 'soda bottles'],
'typical_monthly_kg': 2.5
},
'HDPE': {
'washing_factor': 0.3,
'processing_factor': 0.5,
'efficiency': 0.92,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.15,
'common_items': ['milk jugs', 'shampoo bottles'],
'typical_monthly_kg': 1.8
},
'LDPE': {
'washing_factor': 0.25,
'processing_factor': 0.45,
'efficiency': 0.90,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.12,
'common_items': ['plastic bags', 'food wrap'],
'typical_monthly_kg': 1.2
},
'PP': {
'washing_factor': 0.28,
'processing_factor': 0.48,
'efficiency': 0.88,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.14,
'common_items': ['yogurt containers', 'bottle caps'],
'typical_monthly_kg': 1.5
}
}
while the full implementation is available in the Appendix.
Discussion
System Performance Analysis
Carbon Footprint Evaluation
The analysis reveals several key insights about carbon footprint components:
- Washing Impact
- Hot water usage contributes 20-30% of emissions
- Water temperature significantly affects footprint
- Optimal washing protocols can reduce impact
- Transportation Emissions
- Account for 25-35% of total footprint
- Vary significantly with center location
- Optimization potential through route planning
- Processing Efficiency
- Ranges from 88-95% depending on plastic type
- Contamination levels affect processing
- Technology improvements can enhance efficiency
Location Optimization Results
The location analysis demonstrates:
- Population Density Effects
- Higher density areas prefer multiple smaller centers
- Rural areas benefit from centralized facilities
- Population distribution drives optimal placement
- Transportation Network Impact
- Road network accessibility crucial
- Traffic patterns affect optimal routes
- Infrastructure quality influences efficiency
- Community Integration
- Access distance affects participation rates
- Local infrastructure supports efficiency
- Community engagement enhances success
Visualization and Interpretation
Technical Insights
Mathematical Model Performance
The implemented models demonstrate:
- Robust handling of varying inputs
- Accurate carbon footprint estimation
- Efficient location optimization
- Real-time processing capability
System Integration
The implementation successfully integrates:
- Multiple data sources
- Various mathematical approaches
- Real-time processing requirements
- Visualization capabilities
Conclusion and Future Perspectives
The visualization results reveal fascinating insights about the complex relationship between household plastic recycling and carbon emissions. Our carbon footprint analysis demonstrates that while recycling saves significant carbon emissions overall, the process involves multiple contributing factors that must be carefully considered.
The washing process, which contributes 20-30% of the total footprint, primarily stems from hot water usage in households. This seemingly simple step becomes significant when multiplied across thousands of households. Transportation follows closely, accounting for 25-35% of emissions, reflecting the complex logistics of moving recyclables from urban households to processing centers. The processing itself represents 30-40% of emissions, though this is offset by the substantial carbon savings that reduce virgin plastic production.
Our location optimization analysis reveals the intricate relationship between population distribution and recycling efficiency. In densely populated urban areas, the data suggests that multiple collection points operate more efficiently than centralized facilities. This pattern shifts dramatically in rural regions, where centralized facilities prove more carbon-efficient despite longer transportation distances. The visualization clearly shows how population density creates natural clustering points that influence optimal facility placement.
The efficiency analysis presents a compelling narrative of process effectiveness across different plastic types. PET demonstrates remarkable efficiency at 95%, making it the most sustainable option for household recycling. HDPE follows closely at 92%, while LDPE and PP show slightly lower but still impressive efficiency rates at 90% and 88% respectively. These variations reflect the inherent properties of different plastics and their responses to current recycling technologies.
System performance metrics reveal consistent processing completion within one minute, though efficiency varies notably with location density. This variation creates interesting patterns in our visualization, particularly in areas where population density changes rapidly. The data suggests that contamination levels significantly impact overall performance, creating a direct relationship between household preparation practices and recycling efficiency.
These analyses collectively paint a picture of a complex system where multiple factors interact to determine the ultimate environmental impact of household plastic recycling. The visualizations help us understand these interactions and identify opportunities for optimization across the entire recycling process.
Key Findings
- Carbon Footprint Impact
- Net negative carbon footprint achievable
- Processing efficiency crucial for sustainability
- Transportation optimization significant
- Location Optimization
- Population density drives placement
- Infrastructure availability important
- Community access affects participation
- System Performance
- Real-time processing achievable
- Multiple plastic types handled
- Contamination management critical
Model Limitations and Future Work
- Technical Enhancements
- Advanced sorting technologies
- Improved washing efficiency
- Enhanced transportation routing
- Real-time monitoring systems
- Process Optimization
- Reduced water consumption
- Enhanced energy efficiency
- Improved contamination handling
- Better material recovery
- Community Integration
- Enhanced public education
- Improved collection systems
- Better participation incentives
- Streamlined recycling processes
Acknowledgments
I would like to express my gratitude to the International Mathematical Modeling Challenge (IMMC) for providing the platform to explore complex real-world problems through mathematical modeling. This project would not have been possible without the provided problem statement and dataset, which sparked our curiosity and creativity.
Appendix
# Import the necessary libraries
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.optimize import linear_sum_assignment
class PlasticRecyclingModel:
def __init__(self):
# Initialize plastic types based on household characteristics
self.plastic_types = {
'PET': {
'washing_factor': 0.2,
'processing_factor': 0.4,
'efficiency': 0.95,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.1,
'common_items': ['water bottles', 'soda bottles', 'food containers'],
'typical_monthly_kg': 2.5,
'washing_temp_impact': 0.3
},
'HDPE': {
'washing_factor': 0.3,
'processing_factor': 0.5,
'efficiency': 0.92,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.15,
'common_items': ['milk jugs', 'shampoo bottles', 'detergent containers'],
'typical_monthly_kg': 1.8,
'washing_temp_impact': 0.35
},
'LDPE': {
'washing_factor': 0.25,
'processing_factor': 0.45,
'efficiency': 0.90,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.12,
'common_items': ['plastic bags', 'food wrap'],
'typical_monthly_kg': 1.2,
'washing_temp_impact': 0.25
},
'PP': {
'washing_factor': 0.28,
'processing_factor': 0.48,
'efficiency': 0.88,
'recyclable': True,
'co2_savings': 1.08,
'contamination_factor': 0.14,
'common_items': ['yogurt containers', 'bottle caps'],
'typical_monthly_kg': 1.5,
'washing_temp_impact': 0.3
}
}
# Constants for carbon footprint calculation
self.water_cf_per_liter = 0.0003
self.transport_cf_per_km = 0.1
self.hot_water_energy = 0.0012
self.residual_moisture_threshold = 0.005
def calculate_household_footprint(self, plastic_input, washing_data, transport_distance):
"""Calculate comprehensive carbon footprint for household plastic recycling"""
results = {
'washing_cf': 0,
'transport_cf': 0,
'processing_cf': 0,
'savings': 0,
'net_cf': 0,
'by_type': {},
'efficiency_metrics': {}
}
for plastic_type, weight in plastic_input.items():
if plastic_type not in self.plastic_types:
continue
plastic = self.plastic_types[plastic_type]
if not plastic['recyclable']:
continue
# Calculate washing footprint with temperature consideration
washing_cf = (
weight * plastic['washing_factor'] *
washing_data['water_usage'] *
(self.water_cf_per_liter +
washing_data['hot_water_ratio'] *
self.hot_water_energy *
plastic['washing_temp_impact'])
)
# Calculate transport footprint with distance optimization
transport_cf = weight * transport_distance * self.transport_cf_per_km
# Calculate processing footprint with contamination
processing_cf = (
weight * plastic['processing_factor'] *
plastic['efficiency'] *
(1 + plastic['contamination_factor'])
)
# Calculate carbon savings
savings = weight * plastic['co2_savings']
# Calculate efficiency metrics
efficiency = {
'washing_efficiency': 1 - plastic['contamination_factor'],
'processing_efficiency': plastic['efficiency'],
'transport_efficiency': 1 - (transport_distance / 100) # Normalize to 100km
}
net_cf = washing_cf + transport_cf + processing_cf - savings
results['by_type'][plastic_type] = {
'washing_cf': washing_cf,
'transport_cf': transport_cf,
'processing_cf': processing_cf,
'savings': savings,
'net_cf': net_cf,
'efficiency_metrics': efficiency
}
# Update totals
results['washing_cf'] += washing_cf
results['transport_cf'] += transport_cf
results['processing_cf'] += processing_cf
results['savings'] += savings
results['net_cf'] += net_cf
return results
class RecyclingCenterOptimizer:
def __init__(self, locations, population_density, infrastructure_score):
self.locations = np.array(locations)
self.population_density = np.array(population_density)
self.infrastructure_score = np.array(infrastructure_score)
def calculate_location_score(self):
"""Calculate comprehensive location score"""
scores = np.zeros(len(self.locations))
# Normalize factors
pop_density_norm = self.population_density / np.max(self.population_density)
infra_score_norm = self.infrastructure_score / np.max(self.infrastructure_score)
env_impact_norm = 1 - (self.environmental_impact / np.max(self.environmental_impact))
# Weighted score calculation
weights = {'population': 0.4, 'infrastructure': 0.35, 'environment': 0.25}
scores = (weights['population'] * pop_density_norm +
weights['infrastructure'] * infra_score_norm +
weights['environment'] * env_impact_norm)
return scores
def optimize_location(self):
# Calculate weighted scores
pop_score = self.population_density / np.max(self.population_density)
infra_score = self.infrastructure_score / np.max(self.infrastructure_score)
# Combined score with weights
total_score = 0.6 * pop_score + 0.4 * infra_score
# Find optimal location
optimal_location = np.argmax(total_score)
return optimal_location, total_score[optimal_location]
def calculate_distances(self):
"""Calculate distances between all points"""
n_points = len(self.locations)
distances = np.zeros((n_points, n_points))
for i in range(n_points):
for j in range(n_points):
distances[i,j] = np.sqrt(np.sum((self.locations[i] - self.locations[j])**2))
return distances
class RecyclingAnalyzer:
def __init__(self, model_results):
self.results = model_results
def calculate_efficiency_metrics(self):
"""Calculate overall efficiency metrics"""
metrics = {
'total_carbon_saved': abs(self.results['savings']),
'net_impact': self.results['net_cf'],
'process_efficiency': self.results['processing_cf'] / self.results['savings'],
'transport_efficiency': self.results['transport_cf'] / self.results['savings']
}
return metrics
def sensitivity_analysis(self, parameter_ranges):
"""Perform sensitivity analysis on key parameters"""
sensitivity_results = {}
for param, range_values in parameter_ranges.items():
impacts = []
for value in range_values:
# Calculate impact with modified parameter
impact = self._calculate_parameter_impact(param, value)
impacts.append(impact)
sensitivity_results[param] = impacts
return sensitivity_results
class EnhancedRecyclingVisualizer:
def __init__(self):
self.colors = ['#2ecc71', '#3498db', '#e74c3c', '#f1c40f', '#9b59b6']
def create_dashboard(self, results, location_data):
"""Create comprehensive visualization dashboard"""
fig = plt.figure(figsize=(20, 12))
gs = fig.add_gridspec(2, 3)
# 1. Carbon Footprint Components
ax1 = fig.add_subplot(gs[0, 0])
self._plot_carbon_components(ax1, results)
# 2. Plastic Type Distribution
ax2 = fig.add_subplot(gs[0, 1])
self._plot_plastic_distribution(ax2, results)
# 3. Process Efficiency
ax3 = fig.add_subplot(gs[0, 2])
self._plot_process_efficiency(ax3, results)
# 4. Location Analysis
ax4 = fig.add_subplot(gs[1, 0:2])
self._plot_location_analysis(ax4, location_data)
# 5. Emissions Reduction Potential
ax5 = fig.add_subplot(gs[1, 2])
self._plot_emissions_reduction(ax5, results)
plt.tight_layout()
return fig
def _plot_carbon_components(self, ax, results):
components = ['Washing', 'Transport', 'Processing', 'Savings']
values = [results['washing_cf'], results['transport_cf'],
results['processing_cf'], -results['savings']]
bars = ax.bar(components, values, color=self.colors)
ax.axhline(y=0, color='black', linestyle='-', alpha=0.2)
ax.set_title('Carbon Footprint Components')
ax.set_ylabel('kg CO₂')
# Add value labels
for bar in bars:
height = bar.get_height()
ax.text(bar.get_x() + bar.get_width()/2., height,
f'{height:.1f}', ha='center', va='bottom')
def _plot_plastic_distribution(self, ax, results):
plastic_types = list(results['by_type'].keys())
values = [results['by_type'][pt]['net_cf'] for pt in plastic_types]
ax.pie(values, labels=plastic_types, autopct='%1.1f%%',
colors=self.colors[:len(plastic_types)])
ax.set_title('Carbon Footprint by Plastic Type')
def _plot_process_efficiency(self, ax, results):
processes = ['Washing', 'Sorting', 'Transport', 'Processing']
efficiencies = [0.95, 0.88, 0.92, 0.90] # Based on search results
ax.bar(processes, efficiencies, color=self.colors)
ax.set_title('Process Efficiency')
ax.set_ylabel('Efficiency (%)')
ax.set_ylim(0, 1)
# Add percentage labels
for i, v in enumerate(efficiencies):
ax.text(i, v + 0.01, f'{v:.0%}', ha='center')
def _plot_location_analysis(self, ax, location_data):
locations = location_data['locations']
population = location_data['population_density']
optimal = location_data['optimal_location']
scatter = ax.scatter(locations[:,0], locations[:,1],
s=population*100, c=population,
cmap='YlOrRd', alpha=0.6)
ax.scatter(locations[optimal,0], locations[optimal,1],
color='red', s=200, marker='*', label='Optimal Location')
ax.set_title('Recycling Center Location Analysis')
plt.colorbar(scatter, ax=ax, label='Population Density')
ax.set_xlim(-25, 125)
ax.set_ylim(-25, 125)
ax.legend()
def _plot_emissions_reduction(self, ax, results):
categories = ['Current', 'With Optimization', 'Potential']
emissions = [results['net_cf'],
results['net_cf'] * 0.7, # 30% reduction with optimization
results['net_cf'] * 0.3] # 70% potential reduction
ax.bar(categories, emissions, color=self.colors)
ax.set_title('Emissions Reduction Potential')
ax.set_ylabel('kg CO₂')
# Add reduction percentages
for i, v in enumerate(emissions):
ax.text(i, v + 0.1, f'{v:.1f}', ha='center')
# Set up random seed for reproducibility
np.random.seed(41)
# Initialize models
recycling_model = PlasticRecyclingModel()
# Test data
plastic_input = {
'PET': 2.5,
'HDPE': 1.8,
'LDPE': 1.2,
'PP': 1.5
}
washing_data = {
'water_usage': 50.0,
'hot_water_ratio': 0.3
}
# Calculate carbon footprint
results = recycling_model.calculate_household_footprint(
plastic_input,
washing_data,
transport_distance=10.0
)
# Location optimization
locations = np.array([[np.random.uniform(0, 120), np.random.uniform(0, 120)] for i in range(20)])
population_density = np.array([np.random.uniform(50, 200) for i in range(20)])
infrastructure_score = np.array([np.random.uniform(0, 100) for i in range(20)])
optimizer = RecyclingCenterOptimizer(locations, population_density, infrastructure_score)
optimal_loc, score = optimizer.optimize_location()
# Visualize results
visualizer = EnhancedRecyclingVisualizer()
location_data = {
'locations': locations,
'population_density': population_density,
'optimal_location': optimal_loc # Use the integer index directly
}
dashboard = visualizer.create_dashboard(results, location_data)
plt.savefig('recycling_dashboard.png')
plt.show()
carbon_footprint = RecyclingAnalyzer(results)
# Calculate efficiency metrics
efficiency_metrics = carbon_footprint.calculate_efficiency_metrics()
print(efficiency_metrics)
# Plot all the components of the dashboard
# 1. Carbon Footprint Components
fig = plt.figure(figsize=(20, 12))
gs = fig.add_gridspec(2, 3)
ax1 = fig.add_subplot(gs[0, 0])
visualizer._plot_carbon_components(ax1, results)
plt.savefig('carbon_footprint_components.png')
plt.show()
# 2. Plastic Type Distribution
fig = plt.figure(figsize=(20, 12))
gs = fig.add_gridspec(2, 3)
ax2 = fig.add_subplot(gs[0, 0])
visualizer._plot_plastic_distribution(ax2, results)
plt.savefig('plastic_type_distribution.png')
plt.show()
# 3. Process Efficiency
fig = plt.figure(figsize=(20, 12))
gs = fig.add_gridspec(2, 3)
ax3 = fig.add_subplot(gs[0, 0])
visualizer._plot_process_efficiency(ax3, results)
plt.savefig('process_efficiency.png')
plt.show()
# 4. Location Analysis
fig = plt.figure(figsize=(20, 12))
gs = fig.add_gridspec(2, 3)
ax4 = fig.add_subplot(gs[0, 0:2])
visualizer._plot_location_analysis(ax4, location_data)
plt.savefig('location_analysis.png')
plt.show()
# 5. Emissions Reduction Potential
fig = plt.figure(figsize=(20, 12))
gs = fig.add_gridspec(2, 3)
ax5 = fig.add_subplot(gs[0:2, 0])
visualizer._plot_emissions_reduction(ax5, results)
plt.savefig('emissions_reduction.png')
plt.show()
Comments