Construction Expert

Expert guidance for construction management, project planning, Building Information Modeling (BIM), safety compliance, and modern construction technology solutions.

Core Concepts

Construction Management

• Project planning and scheduling
• Cost estimation and control
• Resource management
• Quality assurance
• Contract management
• Risk management
• Change order management

Technologies

• Building Information Modeling (BIM)
• Construction management software
• Drone surveying and inspection
• 3D printing and modular construction
• IoT sensors for monitoring
• Augmented reality for visualization
• Construction robotics

Standards and Regulations

• OSHA safety regulations
• Building codes (IBC, IRC)
• AIA contracts and standards
• LEED certification
• ISO 19650 (BIM standards)
• CSI MasterFormat
• Environmental regulations

Project Management System

from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List, Optional, Dict
from decimal import Decimal
from enum import Enum

class ProjectPhase(Enum):
    PRE_CONSTRUCTION = "pre_construction"
    SITE_PREPARATION = "site_preparation"
    FOUNDATION = "foundation"
    FRAMING = "framing"
    MEP = "mep"  # Mechanical, Electrical, Plumbing
    INTERIOR = "interior"
    EXTERIOR = "exterior"
    FINAL = "final"
    CLOSEOUT = "closeout"

class TaskStatus(Enum):
    NOT_STARTED = "not_started"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"
    DELAYED = "delayed"
    ON_HOLD = "on_hold"

@dataclass
class ConstructionProject:
    """Construction project information"""
    project_id: str
    project_name: str
    location: dict
    project_type: str  # 'residential', 'commercial', 'industrial'
    owner: str
    general_contractor: str
    start_date: datetime
    planned_end_date: datetime
    actual_end_date: Optional[datetime]
    budget: Decimal
    current_cost: Decimal
    square_footage: float
    current_phase: ProjectPhase

@dataclass
class Task:
    """Construction task/activity"""
    task_id: str
    project_id: str
    name: str
    description: str
    phase: ProjectPhase
    status: TaskStatus
    assigned_to: str  # Subcontractor or crew
    planned_start: datetime
    planned_end: datetime
    actual_start: Optional[datetime]
    actual_end: Optional[datetime]
    budget: Decimal
    actual_cost: Decimal
    predecessors: List[str]  # Task IDs that must complete first
    progress_percent: float

class ConstructionManagementSystem:
    """Construction project management system"""

    def __init__(self):
        self.projects = {}
        self.tasks = {}
        self.change_orders = []
        self.inspections = []

    def create_project_schedule(self, project_id: str, tasks_data: List[dict]) -> dict:
        """Create project schedule using Critical Path Method"""
        project = self.projects.get(project_id)
        if not project:
            return {'error': 'Project not found'}

        # Create tasks
        tasks = []
        for task_data in tasks_data:
            task = Task(
                task_id=self._generate_task_id(),
                project_id=project_id,
                name=task_data['name'],
                description=task_data.get('description', ''),
                phase=ProjectPhase(task_data['phase']),
                status=TaskStatus.NOT_STARTED,
                assigned_to=task_data['assigned_to'],
                planned_start=task_data['planned_start'],
                planned_end=task_data['planned_end'],
                actual_start=None,
                actual_end=None,
                budget=Decimal(str(task_data['budget'])),
                actual_cost=Decimal('0'),
                predecessors=task_data.get('predecessors', []),
                progress_percent=0.0
            )
            tasks.append(task)
            self.tasks[task.task_id] = task

        # Calculate critical path
        critical_path = self._calculate_critical_path(tasks)

        # Calculate project duration
        if tasks:
            project_end = max(t.planned_end for t in tasks)
            project_duration = (project_end - project.start_date).days
        else:
            project_duration = 0

        return {
            'project_id': project_id,
            'total_tasks': len(tasks),
            'project_duration_days': project_duration,
            'critical_path': [t.task_id for t in critical_path],
            'critical_path_duration': sum(
                (t.planned_end - t.planned_start).days for t in critical_path
            )
        }

    def _calculate_critical_path(self, tasks: List[Task]) -> List[Task]:
        """Calculate critical path through project network"""
        # Simplified critical path calculation
        # In production, would use proper CPM algorithm

        # Find tasks with no predecessors
        start_tasks = [t for t in tasks if not t.predecessors]

        # Find longest path through network
        critical_path = []
        current_tasks = start_tasks

        while current_tasks:
            # Find task with longest duration
            longest_task = max(current_tasks,
                             key=lambda t: (t.planned_end - t.planned_start).days)
            critical_path.append(longest_task)