Value Chain: Logistics, SCM & ERP Systems

The value chain is the central concept for analyzing and optimizing business processes. It encompasses all activities from raw material procurement to end customer delivery.

Fundamentals of the Value Chain

Definition and Concept

The value chain according to Porter describes the sequential activities that a company performs to create products or services and bring them to the customer.

Primary Activities

graph TD
    A[Inbound Logistics] --> B[Operations]
    B --> C[Outbound Logistics]
    C --> D[Marketing & Sales]
    D --> E[Service]
    
    F[Support Activities] --> A
    F --> B
    F --> C
    F --> D
    F --> E

Secondary Activities

• Corporate Infrastructure: Management, planning, finance
• Human Resource Management: Recruitment, training, compensation
• Technology Development: Research, process improvement
• Procurement: Purchasing of raw materials and services

Supply Chain Management (SCM)

SCM Components

// SCM System Architecture
public class SupplyChainManagement {
    
    // Procurement Management
    public class ProcurementManagement {
        private List<Supplier> suppliers;
        private List<PurchaseOrder> orders;
        
        public void createPurchaseOrder(Product product, int quantity, Supplier supplier) {
            PurchaseOrder order = new PurchaseOrder(product, quantity, supplier);
            orders.add(order);
            
            // Supplier evaluation
            updateSupplierRating(supplier, calculateDeliveryPerformance(supplier));
            
            // Inventory management
            updateInventory(product, quantity);
        }
        
        private void updateSupplierRating(Supplier supplier, double performance) {
            double currentRating = supplier.getPerformanceRating();
            double newRating = (currentRating + performance) / 2;
            supplier.setPerformanceRating(newRating);
        }
    }
    
    // Inventory Management
    public class InventoryManagement {
        private Map<Product, Integer> stockLevels = new HashMap<>();
        private Map<Product, Integer> reorderPoints = new HashMap<>();
        
        public void checkReorderLevels() {
            for (Map.Entry<Product, Integer> entry : stockLevels.entrySet()) {
                Product product = entry.getKey();
                int currentStock = entry.getValue();
                int reorderPoint = reorderPoints.getOrDefault(product, 0);
                
                if (currentStock <= reorderPoint) {
                    triggerReorder(product, calculateOptimalOrderQuantity(product));
                }
            }
        }
        
        private int calculateOptimalOrderQuantity(Product product) {
            // EOQ Formula: sqrt(2 * D * S / H)
            double demand = product.getAnnualDemand();
            double setupCost = product.getSetupCost();
            double holdingCost = product.getHoldingCostPerUnit();
            
            return (int) Math.sqrt((2 * demand * setupCost) / holdingCost);
        }
    }
    
    // Transportation Management
    public class TransportationManagement {
        private List<Vehicle> vehicles;
        private List<Route> routes;
        
        public Route optimizeRoute(List<Delivery> deliveries) {
            // Traveling Salesman Problem Approximation
            List<Location> locations = deliveries.stream()
                .map(Delivery::getLocation)
                .collect(Collectors.toList());
            
            return calculateOptimalRoute(locations);
        }
        
        private Route calculateOptimalRoute(List<Location> locations) {
            // Nearest Neighbor Algorithm
            Route route = new Route();
            Location current = locations.get(0); // Start from warehouse
            
            while (!locations.isEmpty()) {
                Location nearest = findNearestLocation(current, locations);
                route.addLocation(nearest);
                locations.remove(nearest);
                current = nearest;
            }
            
            return route;
        }
    }
}

SCM Software Components

-- SCM Database Model
CREATE TABLE Suppliers (
    supplier_id INT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    contact_person VARCHAR(100),
    email VARCHAR(100),
    phone VARCHAR(20),
    performance_rating DECIMAL(3,2),
    delivery_time INT,
    quality_score DECIMAL(3,2)
);

CREATE TABLE Products (
    product_id INT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    description TEXT,
    unit_price DECIMAL(10,2),
    annual_demand INT,
    setup_cost DECIMAL(10,2),
    holding_cost_per_unit DECIMAL(10,2),
    reorder_point INT,
    current_stock INT
);

CREATE TABLE PurchaseOrders (
    order_id INT PRIMARY KEY,
    supplier_id INT,
    product_id INT,
    quantity INT,
    order_date DATE,
    expected_delivery_date DATE,
    actual_delivery_date DATE,
    status VARCHAR(20),
    unit_price DECIMAL(10,2),
    total_amount DECIMAL(12,2),
    FOREIGN KEY (supplier_id) REFERENCES Suppliers(supplier_id),
    FOREIGN KEY (product_id) REFERENCES Products(product_id)
);

CREATE TABLE InventoryTransactions (
    transaction_id INT PRIMARY KEY,
    product_id INT,
    transaction_type VARCHAR(20), -- 'IN', 'OUT', 'ADJUSTMENT'
    quantity INT,
    transaction_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    reference_id INT, -- Purchase Order ID or Sales Order ID
    notes TEXT,
    FOREIGN KEY (product_id) REFERENCES Products(product_id)
);

CREATE TABLE Shipments (
    shipment_id INT PRIMARY KEY,
    order_id INT,
    carrier VARCHAR(100),
    tracking_number VARCHAR(50),
    ship_date DATE,
    expected_delivery_date DATE,
    actual_delivery_date DATE,
    status VARCHAR(20),
    cost DECIMAL(10,2)
);

Logistics Management

Transportation and Warehouse Logistics

# Python example for logistics optimization
import numpy as np
from scipy.optimize import linear_sum_assignment
from datetime import datetime, timedelta

class LogisticsOptimizer:
    
    def __init__(self):
        self.warehouses = []
        self.customers = []
        self.vehicles = []
    
    def optimize_distribution(self, demand_matrix, cost_matrix):
        """
        Optimizes the distribution of goods to warehouses
        Using the Hungarian algorithm for assignment problems
        """
        # Hungarian algorithm for minimal costs
        row_ind, col_ind = linear_sum_assignment(cost_matrix)
        
        optimal_assignment = []
        total_cost = 0
        
        for i, j in zip(row_ind, col_ind):
            if demand_matrix[i, j] > 0:
                optimal_assignment.append({
                    'warehouse': i,
                    'customer': j,
                    'quantity': demand_matrix[i, j],
                    'cost': cost_matrix[i, j]
                })
                total_cost += demand_matrix[i, j] * cost_matrix[i, j]
        
        return optimal_assignment, total_cost
    
    def calculate_transport_costs(self, distance, weight, transport_mode):
        """
        Calculates transportation costs based on various factors
        """
        base_rates = {
            'truck': 0.15,      # € per km per 100kg
            'rail': 0.08,       # € per km per 100kg
            'air': 0.45,        # € per km per 100kg
            'ship': 0.05        # € per km per 100kg
        }
        
        base_rate = base_rates.get(transport_mode, 0.15)
        cost = distance * (weight / 100) * base_rate
        
        # Additional costs
        if transport_mode == 'air':
            cost += 50  # Handling fee
        elif transport_mode == 'ship':
            cost += 25  # Port fee
        
        return cost
    
    def optimize_vehicle_loading(self, packages, vehicle_capacity):
        """
        Bin packing problem for optimal vehicle loading
        """
        # Greedy algorithm for bin packing
        packages_sorted = sorted(packages, key=lambda x: x['weight'], reverse=True)
        vehicles = []
        
        for package in packages_sorted:
            placed = False
            
            # Try to load package into existing vehicle
            for vehicle in vehicles:
                if vehicle['used_capacity'] + package['weight'] <= vehicle_capacity:
                    vehicle['packages'].append(package)
                    vehicle['used_capacity'] += package['weight']
                    placed = True
                    break
            
            # Create new vehicle if space not found
            if not placed:
                vehicles.append({
                    'packages': [package],
                    'used_capacity': package['weight'],
                    'capacity': vehicle_capacity
                })
        
        return vehicles

# Example for logistics optimization
optimizer = LogisticsOptimizer()

# Demand matrix (warehouses x customers)
demand_matrix = np.array([
    [100, 150, 200, 0, 50],   # Warehouse 1
    [0, 200, 100, 150, 100],  # Warehouse 2
    [150, 0, 100, 200, 150]   # Warehouse 3
])

# Cost matrix (€ per unit)
cost_matrix = np.array([
    [10, 15, 20, 25, 30],     # From warehouse 1
    [20, 10, 15, 20, 25],     # From warehouse 2
    [15, 20, 10, 15, 20]      # From warehouse 3
])

assignment, total_cost = optimizer.optimize_distribution(demand_matrix, cost_matrix)
print(f"Optimal total costs: €{total_cost:.2f}")

Route Planning

// JavaScript für Routenplanung mit Google Maps API
class RouteOptimizer {
    constructor() {
        this.apiKey = 'YOUR_GOOGLE_MAPS_API_KEY';
    }
    
    async calculateOptimalRoute(locations, vehicleConstraints) {
        // Vehicle Routing Problem mit Google Directions API
        const waypoints = locations.slice(1, -1).map(loc => ({
            location: loc.address,
            stopover: true
        }));
        
        const request = {
            origin: locations[0].address,
            destination: locations[locations.length - 1].address,
            waypoints: waypoints,
            optimize: true, // Optimiert die Reihenfolge
            travelMode: 'DRIVING',
            unitSystem: 'METRIC',
            vehicleConstraints: vehicleConstraints
        };
        
        try {
            const response = await this.callDirectionsAPI(request);
            return this.processRouteResponse(response);
        } catch (error) {
            console.error('Route calculation failed:', error);
            return null;
        }
    }
    
    async callDirectionsAPI(request) {
        const url = `https://routes.googleapis.com/directions/v2:computeRoutes?key=${this.apiKey}`;
        
        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'X-Goog-Api-Key': this.apiKey
            },
            body: JSON.stringify(request)
        });
        
        return response.json();
    }
    
    processRouteResponse(response) {
        const optimizedRoute = {
            totalDistance: response.routes[0].legs.reduce((sum, leg) => sum + leg.distance.value, 0),
            totalDuration: response.routes[0].legs.reduce((sum, leg) => sum + leg.duration.value, 0),
            waypoints: response.routes[0].waypoint_order,
            legs: response.routes[0].legs.map(leg => ({
                distance: leg.distance,
                duration: leg.duration,
                start_address: leg.start_address,
                end_address: leg.end_address,
                steps: leg.steps
            }))
        };
        
        return optimizedRoute;
    }
    
    calculateFuelConsumption(distance, vehicleType) {
        const fuelConsumptionRates = {
            'small_truck': 0.12,    // Liter pro km
            'medium_truck': 0.18,
            'large_truck': 0.25,
            'van': 0.08
        };
        
        const rate = fuelConsumptionRates[vehicleType] || 0.15;
        return distance * rate;
    }
    
    estimateDeliveryTime(distance, trafficConditions) {
        const baseSpeed = 80; // km/h
        const trafficFactor = trafficConditions === 'heavy' ? 0.6 : 
                           trafficConditions === 'moderate' ? 0.8 : 1.0;
        
        const adjustedSpeed = baseSpeed * trafficFactor;
        return distance / adjustedSpeed; // Stunden
    }
}

// Beispiel für Routenoptimierung
const optimizer = new RouteOptimizer();

const locations = [
    { address: 'München, Deutschland', type: 'warehouse' },
    { address: 'Augsburg, Deutschland', type: 'customer' },
    { address: 'Ingolstadt, Deutschland', type: 'customer' },
    { address: 'Nürnberg, Deutschland', type: 'customer' },
    { address: 'Regensburg, Deutschland', type: 'warehouse' }
];

const vehicleConstraints = {
    maxWeight: 3500, // kg
    maxHeight: 3.0,  // meter
    hazardousMaterials: false
};

optimizer.calculateOptimalRoute(locations, vehicleConstraints)
    .then(route => {
        console.log('Optimierte Route:', route);
    });

ERP Systems in the Value Chain

ERP Module Architecture

-- ERP Datenbankmodell für Wertschöpfungskette
CREATE TABLE Companies (
    company_id INT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    tax_id VARCHAR(50),
    address VARCHAR(200),
    phone VARCHAR(50),
    email VARCHAR(100),
    website VARCHAR(100)
);

CREATE TABLE Warehouses (
    warehouse_id INT PRIMARY KEY,
    company_id INT,
    name VARCHAR(100),
    address VARCHAR(200),
    capacity DECIMAL(10,2),
    manager_id INT,
    FOREIGN KEY (company_id) REFERENCES Companies(company_id)
);

CREATE TABLE ProductionOrders (
    production_order_id INT PRIMARY KEY,
    product_id INT,
    quantity INT,
    start_date DATE,
    end_date DATE,
    status VARCHAR(20),
    priority INT,
    assigned_workcenter_id INT,
    material_cost DECIMAL(12,2),
    labor_cost DECIMAL(12,2),
    overhead_cost DECIMAL(12,2)
);

CREATE TABLE WorkCenters (
    workcenter_id INT PRIMARY KEY,
    name VARCHAR(100),
    capacity_per_hour DECIMAL(8,2),
    setup_time_minutes INT,
    efficiency_rate DECIMAL(3,2),
    maintenance_cost_per_hour DECIMAL(8,2)
);

CREATE TABLE QualityChecks (
    check_id INT PRIMARY KEY,
    production_order_id INT,
    check_date TIMESTAMP,
    inspector_id INT,
    result VARCHAR(20), -- 'PASS', 'FAIL', 'REWORK'
    defects_found INT,
    corrective_action TEXT,
    FOREIGN KEY (production_order_id) REFERENCES ProductionOrders(production_order_id)
);

SAP-like Functionality

// ERP System mit SAP-ähnlicher Funktionalität
public class ERPSystem {
    
    // Material Management (MM)
    public class MaterialManagement {
        private Map<String, Material> materials = new HashMap<>();
        private Map<String, MaterialDocument> materialDocuments = new HashMap<>();
        
        public void createMaterial(String materialNumber, String description, 
                                String materialType, String unitOfMeasure) {
            Material material = new Material(materialNumber, description, 
                                           materialType, unitOfMeasure);
            materials.put(materialNumber, material);
        }
        
        public MaterialDocument postGoodsMovement(String materialNumber, int quantity, 
                                                String movementType, String storageLocation) {
            Material material = materials.get(materialNumber);
            if (material == null) {
                throw new IllegalArgumentException("Material not found: " + materialNumber);
            }
            
            // Update stock levels
            updateStockLevels(materialNumber, quantity, movementType, storageLocation);
            
            // Create material document
            MaterialDocument document = new MaterialDocument(
                generateDocumentNumber(), materialNumber, quantity, 
                movementType, storageLocation, new Date()
            );
            
            materialDocuments.put(document.getDocumentNumber(), document);
            return document;
        }
        
        private void updateStockLevels(String materialNumber, int quantity, 
                                     String movementType, String storageLocation) {
            // Update stock based on movement type
            switch (movementType) {
                case "101": // Goods receipt
                    increaseStock(materialNumber, quantity, storageLocation);
                    break;
                case "201": // Goods issue
                    decreaseStock(materialNumber, quantity, storageLocation);
                    break;
                case "301": // Stock transfer
                    transferStock(materialNumber, quantity, storageLocation);
                    break;
            }
        }
    }
    
    // Sales and Distribution (SD)
    public class SalesDistribution {
        private Map<String, SalesOrder> salesOrders = new HashMap<>();
        private Map<String, Customer> customers = new HashMap<>();
        private Map<String, BillingDocument> billingDocuments = new HashMap<>();
        
        public SalesOrder createSalesOrder(String customerNumber, List<OrderItem> items) {
            Customer customer = customers.get(customerNumber);
            if (customer == null) {
                throw new IllegalArgumentException("Customer not found: " + customerNumber);
            }
            
            // Price calculation
            BigDecimal totalAmount = calculateTotalAmount(items, customer);
            
            // Check availability
            checkAvailability(items);
            
            SalesOrder salesOrder = new SalesOrder(
                generateOrderNumber(), customerNumber, items, 
                new Date(), "OPEN", totalAmount
            );
            
            salesOrders.put(salesOrder.getOrderNumber(), salesOrder);
            return salesOrder;
        }
        
        public BillingDocument createBillingDocument(String salesOrderNumber) {
            SalesOrder salesOrder = salesOrders.get(salesOrderNumber);
            if (salesOrder == null) {
                throw new IllegalArgumentException("Sales order not found: " + salesOrderNumber);
            }
            
            BillingDocument billingDocument = new BillingDocument(
                generateBillingNumber(), salesOrderNumber, 
                salesOrder.getItems(), salesOrder.getTotalAmount(), new Date()
            );
            
            billingDocuments.put(billingDocument.getBillingNumber(), billingDocument);
            return billingDocument;
        }
        
        private BigDecimal calculateTotalAmount(List<OrderItem> items, Customer customer) {
            BigDecimal total = BigDecimal.ZERO;
            
            for (OrderItem item : items) {
                // Consider customer-specific prices
                BigDecimal unitPrice = getCustomerSpecificPrice(item.getMaterialNumber(), customer);
                BigDecimal itemTotal = unitPrice.multiply(BigDecimal.valueOf(item.getQuantity()));
                total = total.add(itemTotal);
            }
            
            // Apply discounts and surcharges
            total = applyDiscountsAndSurcharges(total, customer);
            
            return total;
        }
    }
    
    // Production Planning (PP)
    public class ProductionPlanning {
        private Map<String, ProductionOrder> productionOrders = new HashMap<>();
        private Map<String, WorkCenter> workCenters = new HashMap<>();
        
        public ProductionOrder createProductionOrder(String materialNumber, int quantity, 
                                                   Date requiredDate) {
            // Capacity planning
            WorkCenter suitableWorkCenter = findSuitableWorkCenter(materialNumber);
            
            // Scheduling
            Date startDate = calculateStartDate(requiredDate, quantity, suitableWorkCenter);
            Date endDate = calculateEndDate(startDate, quantity, suitableWorkCenter);
            
            // Material requirements planning
            List<MaterialRequirement> requirements = 
                calculateMaterialRequirements(materialNumber, quantity);
            
            ProductionOrder order = new ProductionOrder(
                generateProductionOrderNumber(), materialNumber, quantity,
                startDate, endDate, suitableWorkCenter.getId(), "CREATED",
                requirements
            );
            
            productionOrders.add(order);
            return order;
        }
        
        private List<MaterialRequirement> calculateMaterialRequirements(String materialNumber, 
                                                                      int quantity) {
            List<MaterialRequirement> requirements = new ArrayList<>();
            
            // Explode bill of materials
            BillOfMaterials bom = getBillOfMaterials(materialNumber);
            
            for (BOMItem bomItem : bom.getItems()) {
                double requiredQuantity = bomItem.getQuantity() * quantity;
                
                MaterialRequirement requirement = new MaterialRequirement(
                    bomItem.getMaterialNumber(), requiredQuantity, 
                    bomItem.getUnitOfMeasure(), "OPEN"
                );
                
                requirements.add(requirement);
            }
            
            return requirements;
        }
    }
}

Process Optimization

Lean Management Principles

# Lean Management Implementierung
class LeanManagement:
    
    def __init__(self):
        self.waste_types = [
            'overproduction', 'waiting', 'transportation', 
            'inventory', 'motion', 'overprocessing', 'defects'
        ]
        self.value_stream_maps = {}
    
    def analyze_waste(self, process_data):
        """
        Analysis of the 7 types of waste (Muda)
        """
        waste_analysis = {}
        
        for waste_type in self.waste_types:
            waste_analysis[waste_type] = self.calculate_waste_metrics(
                process_data, waste_type
            )
        
        return waste_analysis
    
    def calculate_waste_metrics(self, process_data, waste_type):
        """
        Calculates specific metrics for each type of waste
        """
        metrics = {}
        
        if waste_type == 'waiting':
            # Analyze waiting times
            waiting_times = []
            for step in process_data['process_steps']:
                waiting_times.append(step.get('waiting_time', 0))
            
            metrics['total_waiting_time'] = sum(waiting_times)
            metrics['average_waiting_time'] = sum(waiting_times) / len(waiting_times)
            metrics['waiting_percentage'] = (metrics['total_waiting_time'] / 
                                           process_data['total_cycle_time']) * 100
            
        elif waste_type == 'inventory':
            # Analyze excess inventory
            current_inventory = process_data.get('current_inventory', 0)
            optimal_inventory = process_data.get('optimal_inventory', 0)
            
            excess_inventory = max(0, current_inventory - optimal_inventory)
            metrics['excess_inventory'] = excess_inventory
            metrics['excess_inventory_value'] = excess_inventory * process_data.get('unit_cost', 0)
            
        elif waste_type == 'defects':
            # Analyze defect rate
            total_units = process_data.get('total_units', 0)
            defective_units = process_data.get('defective_units', 0)
            
            metrics['defect_rate'] = (defective_units / total_units) * 100
            metrics['rework_cost'] = defective_units * process_data.get('rework_cost_per_unit', 0)
        
        return metrics
    
    def implement_5s(self, workplace_data):
        """
        Implement 5S methodology
        """
        improvements = []
        
        # 1S - Seiri (Sort)
        improvements.append(self.implement_sorting(workplace_data))
        
        # 2S - Seiton (Systematize)
        improvements.append(self.implement_systematization(workplace_data))
        
        # 3S - Seiso (Clean)
        improvements.append(self.implement_cleaning(workplace_data))
        
        # 4S - Seiketsu (Standardize)
        improvements.append(self.implement_standardization(workplace_data))
        
        # 5S - Shitsuke (Self-discipline)
        improvements.append(self.implement_discipline(workplace_data))
        
        return improvements
    
    def implement_kaizen(self, current_process):
        """
        Continuous improvement (Kaizen)
        """
        kaizen_suggestions = []
        
        # Analyze process steps
        for i, step in enumerate(current_process['steps']):
            # Identify bottlenecks
            if step.get('cycle_time', 0) > current_process.get('target_cycle_time', 0):
                kaizen_suggestions.append({
                    'step': i,
                    'issue': 'Cycle time exceeds target',
                    'suggestion': 'Optimize work sequence or reduce setup time',
                    'potential_improvement': step['cycle_time'] - current_process['target_cycle_time']
                })
            
            # Identify quality issues
            if step.get('defect_rate', 0) > current_process.get('target_defect_rate', 0):
                kaizen_suggestions.append({
                    'step': i,
                    'issue': 'Defect rate exceeds target',
                    'suggestion': 'Implement error-proofing or improve training',
                    'potential_improvement': step['defect_rate'] - current_process['target_defect_rate']
                })
        
        return kaizen_suggestions

Six Sigma Implementation

// Six Sigma DMAIC Methodik
public class SixSigmaImplementation {
    
    // Define Phase
    public ProjectDefinition defineProject(String problemStatement, 
                                         List<String> stakeholders, 
                                         Map<String, Object> projectGoals) {
        ProjectDefinition definition = new ProjectDefinition();
        definition.setProblemStatement(problemStatement);
        definition.setStakeholders(stakeholders);
        definition.setProjectGoals(projectGoals);
        
        // Define CTQs (Critical to Quality)
        List<CriticalToQuality> ctqs = identifyCriticalToQuality(problemStatement);
        definition.setCriticalToQualities(ctqs);
        
        return definition;
    }
    
    // Measure Phase
    public MeasurementSystem measureCurrentState(ProcessData currentData) {
        MeasurementSystem measurement = new MeasurementSystem();
        
        // Analyze process capability (Cpk, Ppk)
        double cpk = calculateProcessCapabilityIndex(currentData);
        double ppk = calculateProcessPerformanceIndex(currentData);
        
        measurement.setCpk(cpk);
        measurement.setPpk(ppk);
        
        // Measurement system analysis (MSA)
        MeasurementSystemAnalysis msa = performMeasurementSystemAnalysis(currentData);
        measurement.setMsaResults(msa);
        
        return measurement;
    }
    
    // Analyze Phase
    public AnalysisResults analyzeRootCauses(ProcessData data, List<String> potentialCauses) {
        AnalysisResults results = new AnalysisResults();
        
        // Statistical analysis
        for (String cause : potentialCauses) {
            double correlation = calculateCorrelation(data, cause);
            double significance = calculateSignificance(data, cause);
            
            if (significance < 0.05) { // Significance level 5%
                results.addSignificantCause(cause, correlation, significance);
            }
        }
        
        // Root cause analysis
        List<String> rootCauses = performRootCauseAnalysis(results.getSignificantCauses());
        results.setRootCauses(rootCauses);
        
        return results;
    }
    
    // Improve Phase
    public ImprovementPlan developImprovementPlan(List<String> rootCauses) {
        ImprovementPlan plan = new ImprovementPlan();
        
        for (String cause : rootCauses) {
            List<String> solutions = generateSolutions(cause);
            
            for (String solution : solutions) {
                SolutionEvaluation evaluation = evaluateSolution(solution, cause);
                
                if (evaluation.getExpectedBenefit() > evaluation.getImplementationCost()) {
                    plan.addSolution(solution, evaluation);
                }
            }
        }
        
        // Prioritize solutions
        plan.prioritizeSolutions();
        
        return plan;
    }
    
    // Control Phase
    public ControlSystem implementControlSystem(ImprovementPlan plan) {
        ControlSystem control = new ControlSystem();
        
        // Implement control charts
        for (Solution solution : plan.getSelectedSolutions()) {
            ControlChart chart = createControlChart(solution);
            control.addControlChart(chart);
        }
        
        // Set up early warning system
        EarlyWarningSystem warningSystem = setupEarlyWarningSystem(control);
        control.setEarlyWarningSystem(warningSystem);
        
        return control;
    }
    
    private double calculateProcessCapabilityIndex(ProcessData data) {
        double mean = data.getMean();
        double stdDev = data.getStandardDeviation();
        double upperSpec = data.getUpperSpecificationLimit();
        double lowerSpec = data.getLowerSpecificationLimit();
        
        double cpu = (upperSpec - mean) / (3 * stdDev);
        double cpl = (mean - lowerSpec) / (3 * stdDev);
        
        return Math.min(cpu, cpl);
    }
    
    private ControlChart createControlChart(Solution solution) {
        ControlChart chart = new ControlChart();
        chart.setProcessParameter(solution.getMonitoredParameter());
        chart.setUpperControlLimit(solution.getUpperControlLimit());
        chart.setLowerControlLimit(solution.getLowerControlLimit());
        chart.setCenterLine(solution.getTargetValue());
        
        return chart;
    }
}

Digital Transformation in the Value Chain

Industry 4.0 Integration

# IoT und Predictive Maintenance
class Industry40Integration:
    
    def __init__(self):
        self.sensors = {}
        self.predictive_models = {}
    
    def setup_iot_sensors(self, equipment_id, sensor_types):
        """
        IoT-Sensoren für Produktionsausrüstung einrichten
        """
        sensors = {}
        
        for sensor_type in sensor_types:
            sensor = {
                'type': sensor_type,
                'equipment_id': equipment_id,
                'data_points': [],
                'thresholds': self.get_sensor_thresholds(sensor_type),
                'last_maintenance': datetime.now()
            }
            sensors[sensor_type] = sensor
        
        self.sensors[equipment_id] = sensors
        return sensors
    
    def predict_maintenance_needs(self, equipment_id):
        """
        Prediction of maintenance needs with machine learning
        """
        if equipment_id not in self.sensors:
            return None
        
        sensors = self.sensors[equipment_id]
        maintenance_prediction = {
            'equipment_id': equipment_id,
            'prediction_date': datetime.now(),
            'maintenance_needed': False,
            'urgency': 'LOW',
            'predicted_failure_date': None,
            'recommendations': []
        }
        
        # Analyze sensor data
        for sensor_type, sensor_data in sensors.items():
            recent_data = sensor_data['data_points'][-100:]  # Last 100 data points
            
            if len(recent_data) > 50:
                # Trend analysis
                trend = self.calculate_trend(recent_data)
                
                # Anomaly detection
                anomalies = self.detect_anomalies(recent_data, sensor_data['thresholds'])
                
                # Apply prediction model
                failure_probability = self.predict_failure_probability(
                    recent_data, sensor_type
                )
                
                if failure_probability > 0.7:  # High failure probability
                    maintenance_prediction['maintenance_needed'] = True
                    maintenance_prediction['urgency'] = 'HIGH'
                    maintenance_prediction['predicted_failure_date'] = \
                        self.predict_failure_date(recent_data, failure_probability)
                    
                    maintenance_prediction['recommendations'].append(
                        f"Immediate inspection required for {sensor_type} sensor"
                    )
                elif failure_probability > 0.4:  # Medium failure probability
                    maintenance_prediction['urgency'] = 'MEDIUM'
                    maintenance_prediction['recommendations'].append(
                        f"Schedule maintenance for {sensor_type} within 2 weeks"
                    )
        
        return maintenance_prediction
    
    def optimize_production_schedule(self, production_orders, equipment_status):
        """
        Optimize production planning with real-time status
        """
        optimized_schedule = []
        available_equipment = [eq for eq in equipment_status if eq['status'] == 'AVAILABLE']
        
        for order in production_orders:
            # Find suitable equipment
            suitable_equipment = self.find_suitable_equipment(
                order, available_equipment
            )
            
            if suitable_equipment:
                # Estimate production time
                estimated_time = self.estimate_production_time(
                    order, suitable_equipment
                )
                
                # Optimize energy consumption
                energy_optimization = self.optimize_energy_consumption(
                    order, suitable_equipment
                )
                
                scheduled_order = {
                    'order_id': order['id'],
                    'equipment_id': suitable_equipment['id'],
                    'start_time': self.calculate_start_time(order, optimized_schedule),
                    'estimated_duration': estimated_time,
                    'energy_optimization': energy_optimization
                }
                
                optimized_schedule.append(scheduled_order)
                
                # Mark equipment as busy
                suitable_equipment['status'] = 'BUSY'
        
        return optimized_schedule
    
    def implement_blockchain_supply_chain(self):
        """
        Implement blockchain for transparent supply chains
        """
        blockchain = SupplyChainBlockchain()
        
        # Smart Contracts für Lieferketten-Events
        blockchain.deploy_smart_contract('ProductTracking', '''
            contract ProductTracking {
                struct Product {
                    uint256 id;
                    string currentLocation;
                    uint256 timestamp;
                    address currentHolder;
                    string status;
                }
                
                mapping(uint256 => Product) public products;
                
                event ProductMoved(uint256 productId, string newLocation, address newHolder);
                
                function moveProduct(uint256 productId, string memory newLocation, address newHolder) public {
                    products[productId].currentLocation = newLocation;
                    products[productId].currentHolder = newHolder;
                    products[productId].timestamp = block.timestamp;
                    
                    emit ProductMoved(productId, newLocation, newHolder);
                }
            }
        ''')
        
        return blockchain

KPIs and Performance Measurement

Key Metrics

-- KPI Dashboard für Wertschöpfungskette
CREATE TABLE SupplyChainKPIs (
    kpi_id INT PRIMARY KEY,
    kpi_name VARCHAR(100) NOT NULL,
    kpi_category VARCHAR(50), -- 'Efficiency', 'Quality', 'Cost', 'Delivery'
    calculation_method TEXT,
    target_value DECIMAL(10,2),
    current_value DECIMAL(10,2),
    measurement_date DATE,
    trend VARCHAR(10) -- 'IMPROVING', 'DECLINING', 'STABLE'
);

-- KPI calculations
CREATE VIEW SupplyChainPerformance AS
SELECT 
    -- Supply chain efficiency
    (SELECT COUNT(*) FROM PurchaseOrders WHERE status = 'DELIVERED' AND 
     DATEDIFF(actual_delivery_date, expected_delivery_date) <= 0) * 100.0 / 
    (SELECT COUNT(*) FROM PurchaseOrders WHERE status = 'DELIVERED') AS on_time_delivery_rate,
    
    -- Inventory efficiency
    (SELECT SUM(current_stock * unit_cost) FROM Products) / 
    (SELECT SUM(annual_demand * unit_cost) FROM Products) * 100 AS inventory_turnover_ratio,
    
    -- Quality
    (SELECT COUNT(*) FROM QualityChecks WHERE result = 'PASS') * 100.0 / 
    (SELECT COUNT(*) FROM QualityChecks) AS first_pass_yield,
    
    -- Cost
    (SELECT SUM(total_amount) FROM PurchaseOrders WHERE 
     DATE(order_date) >= DATE_SUB(CURRENT_DATE, INTERVAL 30 DAY)) /
    (SELECT SUM(quantity) FROM InventoryTransactions WHERE 
     transaction_type = 'IN' AND 
     DATE(transaction_date) >= DATE_SUB(CURRENT_DATE, INTERVAL 30 DAY)) 
    AS average_cost_per_unit;

Performance Monitoring

# Real-time Performance Monitoring
class SupplyChainMonitor:
    
    def __init__(self):
        self.kpi_thresholds = {
            'on_time_delivery_rate': 95.0,
            'inventory_turnover_ratio': 12.0,
            'first_pass_yield': 98.0,
            'order_fulfillment_cycle_time': 24.0
        }
        self.alerts = []
    
    def monitor_real_time_kpis(self):
        """
        Real-time monitoring of key KPIs
        """
        current_kpis = self.calculate_current_kpis()
        alerts = []
        
        for kpi_name, threshold in self.kpi_thresholds.items():
            current_value = current_kpis.get(kpi_name, 0)
            
            if current_value < threshold:
                alert = {
                    'kpi_name': kpi_name,
                    'current_value': current_value,
                    'threshold': threshold,
                    'severity': self.calculate_alert_severity(current_value, threshold),
                    'timestamp': datetime.now(),
                    'recommendations': self.generate_recommendations(kpi_name, current_value)
                }
                alerts.append(alert)
        
        self.alerts.extend(alerts)
        return alerts
    
    def calculate_current_kpis(self):
        """
        Calculates current KPI values from database
        """
        kpis = {}
        
        # On-Time Delivery Rate
        delivered_orders = self.get_delivered_orders_count()
        total_orders = self.get_total_orders_count()
        kpis['on_time_delivery_rate'] = (delivered_orders / total_orders) * 100 if total_orders > 0 else 0
        
        # Inventory Turnover Ratio
        total_inventory_value = self.get_total_inventory_value()
        annual_cost_of_goods_sold = self.get_annual_cogs()
        kpis['inventory_turnover_ratio'] = annual_cost_of_goods_sold / total_inventory_value if total_inventory_value > 0 else 0
        
        # First Pass Yield
        passed_inspections = self.get_passed_inspections_count()
        total_inspections = self.get_total_inspections_count()
        kpis['first_pass_yield'] = (passed_inspections / total_inspections) * 100 if total_inspections > 0 else 0
        
        # Order Fulfillment Cycle Time
        order_cycles = self.get_order_cycle_times()
        kpis['order_fulfillment_cycle_time'] = sum(order_cycles) / len(order_cycles) if order_cycles else 0
        
        return kpis
    
    def generate_dashboard_data(self):
        """
        Dashboard data for management overview
        """
        kpis = self.calculate_current_kpis()
        alerts = self.monitor_real_time_kpis()
        
        dashboard_data = {
            'current_kpis': kpis,
            'active_alerts': alerts,
            'trend_analysis': self.analyze_trends(),
            'benchmark_comparison': self.compare_with_benchmarks(kpis),
            'improvement_opportunities': self.identify_improvement_opportunities(kpis)
        }
        
        return dashboard_data

Exam-Relevant Concepts

Important Terms

Term	Description	Significance
Value Chain	Sequence of activities for value creation	Porter Model
SCM	Management of supply chain processes	Integration and optimization
ERP	Enterprise Resource Planning	Integrated business processes
Lean Management	Eliminate waste	5S, Kaizen, Just-in-Time
Six Sigma	Quality improvement	DMAIC, Statistical process control

Typical Exam Tasks

1. Analyze value chains
2. Optimize supply chain processes
3. Implement ERP modules
4. Apply Lean Management
5. Calculate Supply Chain KPIs

Summary

Modern value chains require integrated approaches:

• SCM systems optimize supply chain processes
• ERP integration creates end-to-end processes
• Lean & Six Sigma eliminate waste
• Digitalization enables real-time optimization
• KPI monitoring ensures continuous improvement

Successful value chains are data-driven, customer-focused, and continuously optimized.