Prefabrication Optimization
Overview
This skill implements optimization algorithms for prefabricated and modular construction. Maximize factory utilization, minimize transportation costs, and optimize on-site assembly sequences.
Optimization Areas:
- Module design for transport
- Factory production scheduling
- Logistics and transportation
- On-site assembly sequencing
- Crane and equipment planning
- Quality control checkpoints
Quick Start
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta
from typing import List, Dict, Tuple, Optional
from enum import Enum
class ModuleStatus(Enum):
DESIGN = "design"
PRODUCTION = "production"
QC = "quality_control"
STORAGE = "storage"
TRANSPORT = "transport"
ON_SITE = "on_site"
INSTALLED = "installed"
@dataclass
class PrefabModule:
module_id: str
name: str
module_type: str
dimensions: Tuple[float, float, float] # L, W, H in meters
weight_kg: float
status: ModuleStatus = ModuleStatus.DESIGN
production_hours: float = 0
dependencies: List[str] = field(default_factory=list)
@dataclass
class ProductionSlot:
slot_id: str
start_time: datetime
end_time: datetime
bay_id: str
module_id: str
def calculate_transport_constraints(module: PrefabModule) -> Dict:
"""Calculate transport constraints for module"""
L, W, H = module.dimensions
# Standard transport limits (varies by region)
max_width = 4.0 # meters
max_height = 4.5 # meters
max_length = 12.0 # meters
max_weight = 40000 # kg
constraints = {
'within_standard': True,
'requires_escort': False,
'requires_permit': False,
'transport_type': 'standard'
}
if W > max_width or H > max_height:
constraints['within_standard'] = False
constraints['requires_escort'] = True
constraints['requires_permit'] = True
constraints['transport_type'] = 'wide_load'
if L > max_length:
constraints['requires_permit'] = True
constraints['transport_type'] = 'long_load'
if module.weight_kg > max_weight:
constraints['requires_permit'] = True
constraints['transport_type'] = 'heavy_load'
return constraints
# Example
module = PrefabModule(
module_id="MOD-001",
name="Bathroom Pod Type A",
module_type="bathroom",
dimensions=(4.5, 3.0, 3.2),
weight_kg=8500,
production_hours=40
)
constraints = calculate_transport_constraints(module)
print(f"Module {module.name}: {constraints}")Comprehensive Prefab System
Module Definition and Analysis
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta
from typing import List, Dict, Tuple, Optional, Set
from enum import Enum
import numpy as np
class ModuleCategory(Enum):
BATHROOM_POD = "bathroom_pod"
KITCHEN_POD = "kitchen_pod"
STRUCTURAL = "structural"
FACADE = "facade"
MEP = "mep"
STAIR = "stair"
ELEVATOR = "elevator"
ROOM_MODULE = "room_module"
@dataclass
class ModuleConnection:
connection_id: str
connection_type: str # structural, mep, electrical
from_module: str
to_module: str
from_point: Tuple[float, float, float]
to_point: Tuple[float, float, float]
tolerance_mm: float = 10
@dataclass
class ModuleDesign:
module_id: str
name: str
category: ModuleCategory
version: str
# Dimensions and weight
length_m: float
width_m: float
height_m: float
weight_kg: float
# Production
production_hours: float
required_skills: List[str]
materials_list: List[Dict]
# Connections
connections: List[ModuleConnection] = field(default_factory=list)
# Dependencies
required_modules: List[str] = field(default_factory=list) # Must be installed before
blocks_modules: List[str] = field(default_factory=list) # Cannot install until this is done
# Metadata
floor_level: int = 0
grid_position: Tuple[str, str] = ('', '') # Grid reference
zone: str = ''
@property
def volume_m3(self) -> float:
return self.length_m * self.width_m * self.height_m
@property
def footprint_m2(self) -> float:
return self.length_m * self.width_m
class ModuleAnalyzer:
"""Analyze prefab modules for optimization"""
def __init__(self):
self.transport_limits = {
'standard': {'width': 2.55, 'height': 4.0, 'length': 12.0, 'weight': 25000},
'wide_load': {'width': 4.0, 'height': 4.5, 'length': 16.0, 'weight': 40000},
'special': {'width': 6.0, 'height': 5.0, 'length': 25.0, 'weight': 100000}
}
def analyze_transportability(self, module: ModuleDesign) -> Dict:
"""Analyze module transportability"""
dims = (module.length_m, module.width_m, module.height_m)
# Check against limits
for transport_type, limits in self.transport_limits.items():
if (max(dims[0], dims[1]) <= limits['length'] and
min(dims[0], dims[1]) <= limits['width'] and
dims[2] <= limits['height'] and
module.weight_kg <= limits['weight']):
analysis = {
'feasible': True,
'transport_type': transport_type,
'orientation': 'length_first' if dims[0] >= dims[1] else 'width_first',
'utilization': {
'length': max(dims[0], dims[1]) / limits['length'],
'width': min(dims[0], dims[1]) / limits['width'],
'height': dims[2] / limits['height'],
'weight': module.weight_kg / limits['weight']
}
}
if transport_type == 'standard':
analysis['cost_factor'] = 1.0
elif transport_type == 'wide_load':
analysis['cost_factor'] = 1.5
analysis['requirements'] = ['escort_vehicle', 'permit', 'route_survey']
else:
analysis['cost_factor'] = 3.0
analysis['requirements'] = ['police_escort', 'special_permit', 'night_transport']
return analysis
return {
'feasible': False,
'reason': 'Exceeds maximum transport dimensions',
'max_dimension': max(dims),
'recommendation': 'Consider splitting into smaller modules'
}
def analyze_lifting(self, module: ModuleDesign) -> Dict:
"""Analyze lifting requirements"""
# Estimate crane capacity needed (with safety factor)
safety_factor = 1.25
required_capacity = module.weight_kg * safety_factor / 1000 # tonnes
# Estimate boom length based on typical building heights
floor_height = 3.5 # meters per floor
estimated_height = module.floor_level * floor_height + 10 # +10m clearance
# Rough crane selection
if required_capacity <= 50 and estimated_height <= 30:
crane_type = 'mobile_50t'
elif required_capacity <= 100 and estimated_height <= 50:
crane_type = 'mobile_100t'
elif required_capacity <= 200:
crane_type = 'crawler_200t'
else:
crane_type = 'tower_crane'
return {
'required_capacity_tonnes': required_capacity,
'estimated_lift_height_m': estimated_height,
'recommended_crane': crane_type,
'lift_points': self._calculate_lift_points(module),
'center_of_gravity': (module.length_m / 2, module.width_m / 2, module.height_m / 3)
}
def _calculate_lift_points(self, module: ModuleDesign) -> List[Tuple[float, float]]:
"""Calculate optimal lift point positions"""
L, W = module.length_m, module.width_m
# Standard 4-point lift
offset = 0.2 # 20% from edges
re