Wertschöpfungskette: Logistik, SCM & ERP Systeme

Die Wertschöpfungskette ist das zentrale Konzept zur Analyse und Optimierung von Geschäftsprozessen. Sie umfasst alle Aktivitäten von der Rohstoffbeschaffung bis zur Endkundenbelieferung.

Grundlagen der Wertschöpfungskette

Definition und Konzept

Die Wertschöpfungskette nach Porter beschreibt die sequenziellen Aktivitäten, die ein Unternehmen durchführt, um Produkte oder Dienstleistungen zu erstellen und an den Kunden zu bringen.

Primäre Aktivitäten

graph TD
    A[Eingangslogistik] --> B[Operations]
    B --> C[Ausgangslogistik]
    C --> D[Marketing & Vertrieb]
    D --> E[Service]
    
    F[Unterstützungsaktivitäten] --> A
    F --> B
    F --> C
    F --> D
    F --> E

Sekundäre Aktivitäten

• Unternehmensinfrastruktur: Management, Planung, Finanzen
• Personalmanagement: Rekrutierung, Schulung, Entlohnung
• Technologieentwicklung: Forschung, Prozessverbesserung
• Beschaffung: Einkauf von Rohstoffen und Dienstleistungen

Supply Chain Management (SCM)

SCM-Komponenten

// SCM System Architecture
public class SupplyChainManagement {
    
    // Beschaffungsmanagement
    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);
            
            // Lieferantenbewertung
            updateSupplierRating(supplier, calculateDeliveryPerformance(supplier));
            
            // Bestandsmanagement
            updateInventory(product, quantity);
        }
        
        private void updateSupplierRating(Supplier supplier, double performance) {
            double currentRating = supplier.getPerformanceRating();
            double newRating = (currentRating + performance) / 2;
            supplier.setPerformanceRating(newRating);
        }
    }
    
    // Lagerverwaltung
    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);
        }
    }
    
    // Transportmanagement
    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-Komponenten

-- SCM Datenbankmodell
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)
);

Logistik-Management

Transport- und Lagerlogistik

# Python Beispiel für Logistik-Optimierung
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):
        """
        Optimiert die Verteilung von Waren auf Lagerhäuser
        Verwendung des Hungarian Algorithmus für Zuordnungsprobleme
        """
        # Hungarian Algorithmus für minimale Kosten
        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):
        """
        Berechnet Transportkosten basierend auf verschiedenen Faktoren
        """
        base_rates = {
            'truck': 0.15,      # € pro km pro 100kg
            'rail': 0.08,       # € pro km pro 100kg
            'air': 0.45,        # € pro km pro 100kg
            'ship': 0.05        # € pro km pro 100kg
        }
        
        base_rate = base_rates.get(transport_mode, 0.15)
        cost = distance * (weight / 100) * base_rate
        
        # Zusatzkosten
        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 für optimale Fahrzeugbeladung
        """
        # Greedy Algorithmus für Bin Packing
        packages_sorted = sorted(packages, key=lambda x: x['weight'], reverse=True)
        vehicles = []
        
        for package in packages_sorted:
            placed = False
            
            # Versuche, Paket in vorhandenes Fahrzeug zu laden
            for vehicle in vehicles:
                if vehicle['used_capacity'] + package['weight'] <= vehicle_capacity:
                    vehicle['packages'].append(package)
                    vehicle['used_capacity'] += package['weight']
                    placed = True
                    break
            
            # Neues Fahrzeug erstellen, wenn Platz nicht gefunden
            if not placed:
                vehicles.append({
                    'packages': [package],
                    'used_capacity': package['weight'],
                    'capacity': vehicle_capacity
                })
        
        return vehicles

# Beispiel für Logistik-Optimierung
optimizer = LogisticsOptimizer()

# Nachfragematrix (Lagerhäuser x Kunden)
demand_matrix = np.array([
    [100, 150, 200, 0, 50],   # Lagerhaus 1
    [0, 200, 100, 150, 100],  # Lagerhaus 2
    [150, 0, 100, 200, 150]   # Lagerhaus 3
])

# Kostenmatrix (€ pro Einheit)
cost_matrix = np.array([
    [10, 15, 20, 25, 30],     # Von Lagerhaus 1
    [20, 10, 15, 20, 25],     # Von Lagerhaus 2
    [15, 20, 10, 15, 20]      # Von Lagerhaus 3
])

assignment, total_cost = optimizer.optimize_distribution(demand_matrix, cost_matrix)
print(f"Optimale Gesamtkosten: €{total_cost:.2f}")

Routenplanung

// 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('Routenberechnung fehlgeschlagen:', 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-Systeme in der Wertschöpfungskette

ERP-Modul-Architektur

-- 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-ähnliche Funktionalität

// 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);
            }
            
            // Bestände aktualisieren
            updateStockLevels(materialNumber, quantity, movementType, storageLocation);
            
            // Materialbeleg erstellen
            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) {
            // Lagerbestand je nach Bewegungsart aktualisieren
            switch (movementType) {
                case "101": // Wareneingang
                    increaseStock(materialNumber, quantity, storageLocation);
                    break;
                case "201": // Warenentnahme
                    decreaseStock(materialNumber, quantity, storageLocation);
                    break;
                case "301": // Lagerumbuchung
                    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);
            }
            
            // Preisberechnung
            BigDecimal totalAmount = calculateTotalAmount(items, customer);
            
            // Verfügbarkeit prüfen
            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) {
                // Kundenspezifische Preise berücksichtigen
                BigDecimal unitPrice = getCustomerSpecificPrice(item.getMaterialNumber(), customer);
                BigDecimal itemTotal = unitPrice.multiply(BigDecimal.valueOf(item.getQuantity()));
                total = total.add(itemTotal);
            }
            
            // Rabatte und Zuschläge
            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) {
            // Kapazitätsplanung
            WorkCenter suitableWorkCenter = findSuitableWorkCenter(materialNumber);
            
            // Terminplanung
            Date startDate = calculateStartDate(requiredDate, quantity, suitableWorkCenter);
            Date endDate = calculateEndDate(startDate, quantity, suitableWorkCenter);
            
            // Materialbedarfsplanung
            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<>();
            
            // Stückliste auflösen
            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;
        }
    }
}

Prozessoptimierung

Lean Management Prinzipien

# 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):
        """
        Analyse der 7 Arten von Verschwendung (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):
        """
        Berechnet spezifische Metriken für jede Verschwendungsart
        """
        metrics = {}
        
        if waste_type == 'waiting':
            # Wartezeiten analysieren
            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':
            # Überbestände analysieren
            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':
            # Fehlerquote analysieren
            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):
        """
        5S Methodik implementieren
        """
        improvements = []
        
        # 1S - Seiri (Sortieren)
        improvements.append(self.implement_sorting(workplace_data))
        
        # 2S - Seiton (Systematisieren)
        improvements.append(self.implement_systematization(workplace_data))
        
        # 3S - Seiso (Säubern)
        improvements.append(self.implement_cleaning(workplace_data))
        
        # 4S - Seiketsu (Standardisieren)
        improvements.append(self.implement_standardization(workplace_data))
        
        # 5S - Shitsuke (Selbst-disziplin)
        improvements.append(self.implement_discipline(workplace_data))
        
        return improvements
    
    def implement_kaizen(self, current_process):
        """
        Kontinuierliche Verbesserung (Kaizen)
        """
        kaizen_suggestions = []
        
        # Prozessschritte analysieren
        for i, step in enumerate(current_process['steps']):
            # Engpässe identifizieren
            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']
                })
            
            # Qualitätsprobleme identifizieren
            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 Implementierung

// 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);
        
        // CTQs (Critical to Quality) definieren
        List<CriticalToQuality> ctqs = identifyCriticalToQuality(problemStatement);
        definition.setCriticalToQualities(ctqs);
        
        return definition;
    }
    
    // Measure Phase
    public MeasurementSystem measureCurrentState(ProcessData currentData) {
        MeasurementSystem measurement = new MeasurementSystem();
        
        // Prozessfähigkeit analysieren (Cpk, Ppk)
        double cpk = calculateProcessCapabilityIndex(currentData);
        double ppk = calculateProcessPerformanceIndex(currentData);
        
        measurement.setCpk(cpk);
        measurement.setPpk(ppk);
        
        // Messsystemanalyse (MSA)
        MeasurementSystemAnalysis msa = performMeasurementSystemAnalysis(currentData);
        measurement.setMsaResults(msa);
        
        return measurement;
    }
    
    // Analyze Phase
    public AnalysisResults analyzeRootCauses(ProcessData data, List<String> potentialCauses) {
        AnalysisResults results = new AnalysisResults();
        
        // Statistische Analyse
        for (String cause : potentialCauses) {
            double correlation = calculateCorrelation(data, cause);
            double significance = calculateSignificance(data, cause);
            
            if (significance < 0.05) { // Signifikanzniveau 5%
                results.addSignificantCause(cause, correlation, significance);
            }
        }
        
        // Root Cause Analyse
        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);
                }
            }
        }
        
        // Lösungen priorisieren
        plan.prioritizeSolutions();
        
        return plan;
    }
    
    // Control Phase
    public ControlSystem implementControlSystem(ImprovementPlan plan) {
        ControlSystem control = new ControlSystem();
        
        // Kontrollkarten implementieren
        for (Solution solution : plan.getSelectedSolutions()) {
            ControlChart chart = createControlChart(solution);
            control.addControlChart(chart);
        }
        
        // Frühwarnsystem einrichten
        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;
    }
}

Digitale Transformation in der Wertschöpfungskette

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):
        """
        Vorhersage von Wartungsbedarfen mit 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': []
        }
        
        # Sensordaten analysieren
        for sensor_type, sensor_data in sensors.items():
            recent_data = sensor_data['data_points'][-100:]  # Letzte 100 Datenpunkte
            
            if len(recent_data) > 50:
                # Trendanalyse
                trend = self.calculate_trend(recent_data)
                
                # Anomalie-Erkennung
                anomalies = self.detect_anomalies(recent_data, sensor_data['thresholds'])
                
                # Vorhersagemodell anwenden
                failure_probability = self.predict_failure_probability(
                    recent_data, sensor_type
                )
                
                if failure_probability > 0.7:  # Hohe Versagenswahrscheinlichkeit
                    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:  # Mittlere Versagenswahrscheinlichkeit
                    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):
        """
        Produktionsplanung mit Echtzeit-Status optimieren
        """
        optimized_schedule = []
        available_equipment = [eq for eq in equipment_status if eq['status'] == 'AVAILABLE']
        
        for order in production_orders:
            # Geeignetes Equipment finden
            suitable_equipment = self.find_suitable_equipment(
                order, available_equipment
            )
            
            if suitable_equipment:
                # Produktionszeit prognostizieren
                estimated_time = self.estimate_production_time(
                    order, suitable_equipment
                )
                
                # Energieverbrauch optimieren
                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)
                
                # Equipment als belegt markieren
                suitable_equipment['status'] = 'BUSY'
        
        return optimized_schedule
    
    def implement_blockchain_supply_chain(self):
        """
        Blockchain für transparente Lieferketten implementieren
        """
        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 und Performance-Messung

Wichtige Kennzahlen

-- 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-Berechnungen
CREATE VIEW SupplyChainPerformance AS
SELECT 
    -- Lieferketten-Effizienz
    (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,
    
    -- Lager-Effizienz
    (SELECT SUM(current_stock * unit_cost) FROM Products) / 
    (SELECT SUM(annual_demand * unit_cost) FROM Products) * 100 AS inventory_turnover_ratio,
    
    -- Qualität
    (SELECT COUNT(*) FROM QualityChecks WHERE result = 'PASS') * 100.0 / 
    (SELECT COUNT(*) FROM QualityChecks) AS first_pass_yield,
    
    -- Kosten
    (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):
        """
        Echtzeit-Überwachung der wichtigsten 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):
        """
        Berechnet aktuelle KPI-Werte aus Datenbank
        """
        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-Daten für Management-Überblick
        """
        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

Prüfungsrelevante Konzepte

Wichtige Begriffe

Begriff	Beschreibung	Bedeutung
Wertschöpfungskette	Sequenz von Aktivitäten zur Wertschaffung	Porter-Modell
SCM	Management von Lieferkettenprozessen	Integration und Optimierung
ERP	Enterprise Resource Planning	Integrierte Geschäftsprozesse
Lean Management	Verschwendung eliminieren	5S, Kaizen, Just-in-Time
Six Sigma	Qualitätsverbesserung	DMAIC, Statistische Prozesskontrolle

Typische Prüfungsaufgaben

1. Analysieren Sie Wertschöpfungsketten
2. Optimieren Sie Lieferkettenprozesse
3. Implementieren Sie ERP-Module
4. Wenden Sie Lean Management an
5. Berechnen Sie Supply Chain KPIs

Zusammenfassung

Moderne Wertschöpfungsketten erfordern integrierte Ansätze:

• SCM-Systeme optimieren Lieferkettenprozesse
• ERP-Integration schafft durchgängige Prozesse
• Lean & Six Sigma eliminieren Verschwendung
• Digitalisierung ermöglicht Echtzeit-Optimierung
• KPI-Monitoring sichert kontinuierliche Verbesserung

Erfolgreiche Wertschöpfungsketten sind datengesteuert, kundenorientiert und kontinuierlich optimiert.