@flexabrain/mcp-server/docs/RAIL_ENGINEERING.md

Advanced electrical schematic analysis MCP server with rail engineering expertise

# 🚆 FlexaBrain MCP Server - Rail Engineering Guide

**Deep Domain Expertise for Electrical Schematic Analysis**

This guide details the rail electrical engineering expertise built into FlexaBrain MCP Server, providing the foundation for accurate component recognition, safety analysis, and compliance validation.

---


## 🚋 **Rail System Types**

FlexaBrain supports analysis for all major rail system configurations:

### Metro/Subway Systems
- **Voltage Systems**: 600V, 750V, 1500V DC (third rail, overhead)
- **Typical Components**: DC choppers, resistor banks, auxiliary converters
- **Safety Considerations**: Third rail protection, platform safety, tunnel ventilation
- **Standards**: IEEE 1653.1, NFPA 130, local transit authority standards

### Light Rail Transit (LRT)
- **Voltage Systems**: 600V, 750V DC overhead catenary
- **Typical Components**: Traction inverters, regenerative braking systems
- **Safety Considerations**: Grade crossing protection, pedestrian safety
- **Standards**: IEEE 1653.2, AREMA, FTA guidelines

### Heavy Rail/Commuter Rail
- **Voltage Systems**: 1500V, 3000V DC; 25kV AC overhead
- **Typical Components**: High-power traction transformers, pantograph systems
- **Safety Considerations**: High-voltage clearances, electromagnetic compatibility
- **Standards**: IEEE 1653.3, AAR standards, FRA regulations

### High-Speed Rail
- **Voltage Systems**: 25kV 50Hz/60Hz AC, 15kV 16⅔Hz AC
- **Typical Components**: High-frequency transformers, active power filters
- **Safety Considerations**: EMI/EMC compliance, dynamic loading
- **Standards**: TSI, EN 50388, IEC 62888, UIC standards

### Freight Rail
- **Voltage Systems**: Diesel-electric, battery-electric hybrid
- **Typical Components**: Traction alternators, dynamic brake grids
- **Safety Considerations**: PTC systems, hazmat compatibility
- **Standards**: AAR standards, FRA Part 229, RSAC guidelines

---


## ⚡ **Traction Power Systems**

### DC Traction Systems

#### 600V DC Systems
```
Common Applications: Light rail, older metro systems
Components Recognized:
- Traction substations with 12-pulse rectifiers
- Third rail conductor systems
- DC circuit breakers (1000A-4000A range)
- Surge arresters and lightning protection
- Negative return systems and stray current mitigation

Safety Considerations:
- Arc flash energy typically 8-25 cal/cm² at bus level
- PPE Category 2-3 required for maintenance
- Touch potential concerns near third rail
```

#### 750V DC Systems
```
Common Applications: Metro systems, some light rail
Components Recognized:
- Converter stations with AC/DC conversion
- Overhead catenary or third rail distribution
- High-speed DC circuit breakers
- Regenerative energy storage systems
- Traction power control systems

Safety Considerations:
- Arc flash energy 15-40 cal/cm² at substation level
- PPE Category 3-4 required for HV maintenance
- Electrical clearance requirements per NESC/IEC
```

#### 1500V DC Systems
```
Common Applications: Heavy rail, high-performance metro
Components Recognized:
- Traction power substations (multi-MW capacity)
- Sectionalizing switches and isolators
- DC fast circuit breakers with SF6 or vacuum interrupters
- Harmonic filters and power quality equipment
- SCADA and remote control systems

Safety Considerations:
- Arc flash energy 25-65 cal/cm² - highest risk level
- PPE Category 4+ required, approach boundaries critical
- Specialized switching procedures and lockout/tagout
```

#### 3000V DC Systems
```
Common Applications: Heavy rail, regional systems
Components Recognized:
- High-power rectifier stations
- Catenary section insulators
- Specialized 3kV DC switching equipment
- Neutral zones and section breaks
- Track circuit compatibility equipment

Safety Considerations:
- Extreme arc flash hazard - requires specialized PPE
- Remote switching preferred for maintenance
- Extensive electrical clearance requirements
```

### AC Traction Systems

#### 25kV 50Hz/60Hz Systems
```
Common Applications: High-speed rail, modern heavy rail
Components Recognized:
- Traction power stations with 110kV/25kV transformers
- Auto-transformer (AT) feeding systems
- 25kV switchgear and circuit breakers
- Power factor correction and harmonic filtering
- Sectioning posts and neutral zones

Safety Considerations:
- Highest electrical hazard level in rail systems
- Arc flash energies >100 cal/cm² possible
- Requires Category 4+ PPE and specialized procedures
- Electromagnetic field exposure considerations
```

#### 15kV 16⅔Hz Systems
```
Common Applications: European high-speed rail, some heavy rail
Components Recognized:
- Single-phase traction transformers
- 16⅔Hz power supply systems
- Specialized frequency conversion equipment
- Rotary converters and static frequency converters
- Railway-specific protection systems

Safety Considerations:
- High-voltage AC hazards similar to 25kV systems
- Specialized frequency creates unique safety considerations
- EMC compliance critical for signaling systems
```

---


## 🔍 **Component Recognition Patterns**

FlexaBrain uses advanced pattern recognition optimized for rail electrical components:

### Traction Power Components

#### Converters and Inverters
```typescript
// Recognition patterns for traction converters
const CONVERTER_PATTERNS = {
  // European style: A601, A1234B
  european: /^A\d{3,4}[A-Z]?$/,
  
  // North American style: CONV01, INV205
  north_american: /^(CONV|INV|REC)\d{2,3}[A-Z]?$/,
  
  // Asian style: TC001, PC205A  
  asian: /^(TC|PC|AC)\d{3}[A-Z]?$/,
  
  // Generic patterns: TRAC001, PWR205
  generic: /^(TRAC|PWR|DRIVE)\d{3,4}[A-Z]?$/
};

// Confidence scoring based on context
const getConverterConfidence = (text: string, context: RailContext) => {
  if (context.region === 'EU' && CONVERTER_PATTERNS.european.test(text)) {
    return 0.95;
  }
  // Additional context-based scoring...
};
```

#### Circuit Breakers
```typescript
// Circuit breaker identification patterns
const BREAKER_PATTERNS = {
  // Standard patterns: CB101, Q205, BR999
  standard: /^(CB|Q|BR|MCB)\d{2,4}[A-Z]?$/,
  
  // High-voltage patterns: HVB001, 25KV-CB-01
  high_voltage: /^(HVB|HV-CB|\d+KV-CB)\d{2,3}[A-Z]?$/,
  
  // Specialized rail patterns: TCB205, PTCB001
  rail_specific: /^(TCB|PTCB|RECB)\d{3}[A-Z]?$/
};

// Voltage rating inference from context
const inferVoltageRating = (componentId: string, surroundingText: string[]) => {
  const voltageIndicators = surroundingText.join(' ').match(/(\d+(?:\.\d+)?)\s*(k?V)/gi);
  if (voltageIndicators) {
    return parseVoltageFromText(voltageIndicators[0]);
  }
  return getDefaultVoltageForComponent(componentId);
};
```

### Signaling Components

#### Signal Reference Numbers
```typescript
// 8-digit signal reference patterns (rail-specific)
const SIGNAL_PATTERNS = {
  // Standard 8-digit: 12345678
  standard_8digit: /^\d{8}$/,
  
  // Extended patterns: 1234-5678, 12.34.56.78
  formatted_8digit: /^\d{4}[-\.]\d{4}$|^\d{2}[\.\-]\d{2}[\.\-]\d{2}[\.\-]\d{2}$/,
  
  // Signal module references: SIG12345, SM-98765
  signal_modules: /^(SIG|SM|SIGNAL)\d{5,8}$/,
  
  // Interlocking references: IXL001, INTER-205
  interlocking: /^(IXL|INTER|INT)\d{3,6}[A-Z]?$/
};

// Signal system context validation
const validateSignalContext = (componentId: string, systemType: string) => {
  const systemCompatibility = {
    'ATC': ['speed_control', 'cab_signal', 'train_stop'],
    'PTC': ['positive_train_control', 'overlap_protection'],
    'CBTC': ['moving_block', 'communication_based'],
    'ERTMS': ['european_standard', 'gsm_r_compatible']
  };
  
  return systemCompatibility[systemType]?.some(feature => 
    isComponentCompatibleWithFeature(componentId, feature)
  ) ?? false;
};
```

### Protection Components

#### Protective Relays
```typescript
// Protective relay patterns
const RELAY_PATTERNS = {
  // Numerical relays: 21/87/50/51 functions
  numerical: /^(21|27|50|51|67|87|25|59|81|32)\d{2,3}[A-Z]?$/,
  
  // Modern relays: REL001, PROT205A
  modern: /^(REL|PROT|RELAY)\d{3,4}[A-Z]?$/,
  
  // Rail-specific: TPR001, SRP205 (Traction Protection, Signal Relay Protection)
  rail_protection: /^(TPR|SRP|RRP)\d{3}[A-Z]?$/
};

// Protection function mapping
const PROTECTION_FUNCTIONS = {
  '21': 'Distance Protection',
  '25': 'Synchronism Check',
  '27': 'Undervoltage',
  '50': 'Instantaneous Overcurrent',
  '51': 'Time Overcurrent',
  '67': 'Directional Overcurrent',
  '81': 'Frequency',
  '87': 'Differential Protection'
};
```

### Auxiliary Systems

#### HVAC and Auxiliary Power
```typescript
// Auxiliary component patterns
const AUX_PATTERNS = {
  // HVAC systems: FAN001, HEAT205, AC-UNIT-01
  hvac: /^(FAN|HEAT|AC-UNIT|HVAC)\d{2,4}[A-Z]?$/,
  
  // Auxiliary converters: AUX001, AUXCONV205
  converters: /^(AUX|AUXCONV|APS)\d{3,4}[A-Z]?$/,
  
  // Lighting: LIGHT001, EMRG-LT-01
  lighting: /^(LIGHT|LT|EMRG-LT)\d{2,4}[A-Z]?$/,
  
  // UPS systems: UPS001, BATT-SYS-01
  power_backup: /^(UPS|BATT-SYS|BACKUP)\d{2,4}[A-Z]?$/
};
```

---


## 🛡️ **Safety Analysis Framework**

FlexaBrain incorporates comprehensive rail electrical safety analysis:

### Arc Flash Analysis

#### IEEE 1584-2018 Implementation
```typescript
// Arc flash energy calculation for rail systems
const calculateArcFlashEnergy = (
  voltage: number,
  current: number,
  time: number,
  distance: number,
  systemType: 'DC' | 'AC'
): ArcFlashResult => {
  
  if (systemType === 'DC') {
    // DC arc flash calculation (limited standards)
    // Based on empirical data and safety margins
    const dcEnergy = calculateDCIncidentEnergy(voltage, current, time, distance);
    return {
      incident_energy: dcEnergy,
      ppe_category: getPPECategory(dcEnergy),
      approach_boundary: calculateApproachBoundary(voltage),
      special_requirements: getDCSpecialRequirements(voltage)
    };
  } else {
    // AC arc flash per IEEE 1584-2018
    const acEnergy = calculateACIncidentEnergy(voltage, current, time, distance);
    return {
      incident_energy: acEnergy,
      ppe_category: getPPECategory(acEnergy),
      arc_flash_boundary: calculateArcFlashBoundary(acEnergy),
      limited_approach: calculateLimitedApproach(voltage),
      restricted_approach: calculateRestrictedApproach(voltage)
    };
  }
};

// Rail-specific PPE categories
const RAIL_PPE_CATEGORIES = {
  Category_0: { max_energy: 1.2, clothing: 'Non-melting or untreated cotton' },
  Category_1: { max_energy: 4.0, clothing: 'Arc-rated shirt and pants or coverall' },
  Category_2: { max_energy: 8.0, clothing: 'Arc-rated shirt and pants, plus arc flash suit' },
  Category_3: { max_energy: 25.0, clothing: 'Arc-rated shirt and pants, plus 25 cal/cm² suit' },
  Category_4: { max_energy: 40.0, clothing: 'Arc-rated shirt and pants, plus 40 cal/cm² suit' },
  Rail_Special: { max_energy: 100.0, clothing: 'Specialized rail arc flash protection >40 cal/cm²' }
};
```

#### Electrical Shock Protection
```typescript
// Shock protection boundaries for rail systems
const RAIL_SHOCK_BOUNDARIES = {
  // Low voltage systems (< 1000V)
  low_voltage: {
    limited_approach: '3 feet 6 inches',
    restricted_approach: 'Avoid contact',
    prohibited_approach: 'Avoid contact'
  },
  
  // Medium voltage (1kV - 35kV) - most rail traction systems
  medium_voltage: {
    '1.5kV': { limited: '4 feet 6 inches', restricted: '2 feet 2 inches', prohibited: '1 foot' },
    '3kV': { limited: '5 feet', restricted: '2 feet 7 inches', prohibited: '1 foot 5 inches' },
    '25kV': { limited: '10 feet', restricted: '4 feet 6 inches', prohibited: '2 feet 9 inches' }
  },
  
  // High voltage (> 35kV) - transmission feeds
  high_voltage: {
    '69kV': { limited: '12 feet 6 inches', restricted: '6 feet 2 inches', prohibited: '4 feet 3 inches' },
    '115kV': { limited: '15 feet', restricted: '7 feet', prohibited: '5 feet' }
  }
};
```

### Grounding and Bonding Analysis

#### Rail Return Systems
```typescript
// Rail return current analysis
const analyzeRailReturn = (components: ElectricalComponent[]): RailReturnAnalysis => {
  const railBonds = components.filter(c => c.type === 'rail_bond');
  const returnConductors = components.filter(c => c.type === 'return_conductor');
  const isolatedJoints = components.filter(c => c.type === 'insulated_joint');
  
  return {
    rail_continuity: validateRailContinuity(railBonds, isolatedJoints),
    return_impedance: calculateReturnImpedance(returnConductors),
    stray_current_risk: assessStrayCurrent(railBonds, returnConductors),
    corrosion_protection: validateCorrosionProtection(components),
    touch_voltage_assessment: calculateTouchVoltages(components)
  };
};

// Stray current mitigation assessment
const assessStrayCurrent = (railBonds: Component[], returnConductors: Component[]) => {
  const bondingResistance = railBonds.reduce((total, bond) => 
    total + (bond.specifications?.resistance || 0.001), 0
  );
  
  const returnResistance = returnConductors.reduce((total, conductor) =>
    total + calculateConductorResistance(conductor), 0
  );
  
  return {
    stray_current_level: calculateStrayCurrent(bondingResistance, returnResistance),
    mitigation_required: bondingResistance > 0.005, // 5 milliohm threshold
    recommendations: generateStrayCurrenRecommendations(bondingResistance)
  };
};
```

---


## 📊 **Standards Compliance Framework**

### Rail-Specific Standards

#### EN 50155 - Railway Electronics
```typescript
// EN 50155 compliance validation
const validateEN50155 = (components: ElectricalComponent[]): ComplianceResult => {
  const results = [];
  
  for (const component of components) {
    const compliance = {
      component_id: component.id,
      standard: 'EN 50155',
      sections: {
        // Temperature and humidity requirements
        environmental: validateEnvironmentalRequirements(component),
        
        // Vibration and shock resistance
        mechanical: validateMechanicalRequirements(component),
        
        // EMC requirements
        emc: validateEMCRequirements(component),
        
        // Power supply variations
        power_quality: validatePowerQualityTolerance(component),
        
        // Safety isolation requirements
        safety_isolation: validateSafetyIsolation(component)
      }
    };
    
    results.push(compliance);
  }
  
  return consolidateComplianceResults(results);
};

// Environmental requirements per EN 50155
const EN50155_ENVIRONMENTAL = {
  temperature: {
    operational: { min: -25, max: 70 }, // °C for OT category
    storage: { min: -40, max: 85 },
    thermal_shock: { rate: 1 } // °C/min max rate
  },
  humidity: {
    operational: { max: 95, condition: 'non-condensing at 25°C' },
    storage: { max: 95, condition: 'non-condensing' }
  },
  altitude: { operational: 2000, storage: 4000 } // meters above sea level
};
```

#### IEC 62278 - RAMS (Reliability, Availability, Maintainability, Safety)
```typescript
// RAMS analysis for rail components
const performRAMSAnalysis = (components: ElectricalComponent[]): RAMSResult => {
  return {
    reliability: calculateComponentReliability(components),
    availability: calculateSystemAvailability(components),
    maintainability: assessMaintainability(components),
    safety: performSafetyAssessment(components),
    
    // SIL (Safety Integrity Level) assessment
    sil_requirements: determineSILRequirements(components),
    
    // Life cycle cost analysis
    lcc_analysis: performLifeCycleCostAnalysis(components)
  };
};

// Safety Integrity Level determination
const determineSILRequirements = (components: ElectricalComponent[]) => {
  const safetyClassification = {
    'SIL_4': components.filter(c => c.category === 'signaling' && c.safety_level === 'CRITICAL'),
    'SIL_3': components.filter(c => c.category === 'protection' && c.safety_level === 'HIGH'),
    'SIL_2': components.filter(c => c.category === 'control' && c.safety_level === 'HIGH'),
    'SIL_1': components.filter(c => c.safety_level === 'MEDIUM')
  };
  
  return safetyClassification;
};
```

#### IEEE 1653 Series - Rail Transit Standards
```typescript
// IEEE 1653.1 - DC Traction Power Systems
const validateIEEE1653_1 = (components: ElectricalComponent[]): ComplianceResult => {
  const dcComponents = components.filter(c => 
    c.specifications?.voltage_rating?.unit?.includes('DC')
  );
  
  return {
    power_supply_design: validateDCPowerSupplyDesign(dcComponents),
    distribution_system: validateDCDistribution(dcComponents),
    protection_coordination: validateDCProtectionCoordination(dcComponents),
    grounding_bonding: validateDCGroundingBonding(dcComponents),
    stray_current: validateStrayCurrcurrentMitigation(dcComponents)
  };
};

// IEEE 1653.2 - AC Traction Power Systems  
const validateIEEE1653_2 = (components: ElectricalComponent[]): ComplianceResult => {
  const acComponents = components.filter(c => 
    c.specifications?.voltage_rating?.unit?.includes('AC')
  );
  
  return {
    power_supply_design: validateACPowerSupplyDesign(acComponents),
    catenary_system: validateCatenarySystem(acComponents),
    transformer_design: validateTransformerDesign(acComponents),
    harmonic_analysis: performHarmonicAnalysis(acComponents),
    power_factor_correction: validatePowerFactorCorrection(acComponents)
  };
};
```

---


## 🔧 **Maintenance Scheduling**

### Rail Component Maintenance Intervals

#### Traction Power Equipment
```typescript
const TRACTION_MAINTENANCE_INTERVALS = {
  // Traction converters/inverters
  converters: {
    visual_inspection: { frequency: 1, unit: 'months' },
    thermal_imaging: { frequency: 3, unit: 'months' },
    power_quality_check: { frequency: 6, unit: 'months' },
    major_overhaul: { frequency: 5, unit: 'years' }
  },
  
  // Traction transformers
  transformers: {
    oil_analysis: { frequency: 6, unit: 'months' },
    dissolved_gas_analysis: { frequency: 12, unit: 'months' },
    power_factor_test: { frequency: 24, unit: 'months' },
    winding_resistance: { frequency: 36, unit: 'months' }
  },
  
  // High voltage circuit breakers
  hv_breakers: {
    visual_inspection: { frequency: 1, unit: 'months' },
    contact_resistance: { frequency: 6, unit: 'months' },
    timing_tests: { frequency: 12, unit: 'months' },
    gas_analysis: { frequency: 24, unit: 'months' }, // for SF6 breakers
    overhaul: { frequency: 15, unit: 'years' }
  }
};

// Condition-based maintenance triggers
const CONDITION_TRIGGERS = {
  temperature: {
    warning: 80, // °C for power electronics
    alarm: 90,
    shutdown: 100
  },
  vibration: {
    warning: 10, // mm/s RMS for transformers
    alarm: 15,
    shutdown: 25
  },
  insulation_resistance: {
    good: 1000, // MΩ minimum
    fair: 100,
    poor: 10
  },
  partial_discharge: {
    acceptable: 100, // pC for 25kV equipment
    investigate: 500,
    critical: 1000
  }
};
```

#### Signaling Equipment
```typescript
const SIGNALING_MAINTENANCE = {
  // Signal modules and vital relays
  vital_equipment: {
    functional_test: { frequency: 1, unit: 'months' },
    calibration_check: { frequency: 6, unit: 'months' },
    full_calibration: { frequency: 24, unit: 'months' },
    replacement: { frequency: 10, unit: 'years' }
  },
  
  // Track circuits
  track_circuits: {
    impedance_check: { frequency: 3, unit: 'months' },
    shunt_sensitivity: { frequency: 6, unit: 'months' },
    insulation_test: { frequency: 12, unit: 'months' },
    component_replacement: { frequency: 15, unit: 'years' }
  },
  
  // Communication systems
  communication_equipment: {
    link_quality_check: { frequency: 1, unit: 'weeks' },
    protocol_verification: { frequency: 3, unit: 'months' },
    backup_system_test: { frequency: 6, unit: 'months' },
    software_update: { frequency: 12, unit: 'months' }
  }
};
```

---


## 📈 **Performance Optimization**

### Power Quality Analysis

#### Harmonic Analysis for Rail Systems
```typescript
// Rail system harmonic analysis
const analyzeHarmonics = (components: ElectricalComponent[]): HarmonicAnalysis => {
  const converters = components.filter(c => c.type === 'converter');
  const filters = components.filter(c => c.type === 'harmonic_filter');
  
  // Calculate total harmonic distortion
  const thd = calculateTotalHarmonicDistortion(converters);
  
  // IEEE 519 compliance check
  const ieee519Compliance = validateIEEE519Limits(thd);
  
  // Filter effectiveness assessment
  const filterPerformance = assessFilterPerformance(filters, thd);
  
  return {
    total_harmonic_distortion: thd,
    individual_harmonics: calculateIndividualHarmonics(converters),
    ieee_519_compliance: ieee519Compliance,
    filter_recommendations: generateFilterRecommendations(thd, filterPerformance),
    power_quality_impact: assessPowerQualityImpact(thd)
  };
};

// Power factor correction analysis
const analyzePowerFactor = (components: ElectricalComponent[]): PowerFactorAnalysis => {
  const loads = components.filter(c => c.category === 'load');
  const capacitors = components.filter(c => c.type === 'capacitor');
  
  const systemPowerFactor = calculateSystemPowerFactor(loads);
  const correctionNeeded = systemPowerFactor < 0.95;
  
  return {
    current_power_factor: systemPowerFactor,
    correction_needed: correctionNeeded,
    capacitor_sizing: calculateCapacitorSizing(loads, 0.95),
    energy_savings: calculateEnergySavings(systemPowerFactor, 0.95),
    payback_period: calculatePaybackPeriod(loads, capacitors)
  };
};
```

### Energy Efficiency Optimization

#### Regenerative Braking Analysis
```typescript
// Regenerative braking energy recovery analysis
const analyzeRegenerativeBraking = (
  tractionSystems: ElectricalComponent[],
  brakingProfile: BrakingProfile
): RegenerativeAnalysis => {
  
  const converters = tractionSystems.filter(c => c.type === 'converter');
  const energyStorage = tractionSystems.filter(c => c.type === 'energy_storage');
  
  // Calculate potential energy recovery
  const maxRecovery = calculateMaxEnergyRecovery(brakingProfile);
  const actualRecovery = calculateActualRecovery(converters, energyStorage, brakingProfile);
  
  // Efficiency analysis
  const recoveryEfficiency = actualRecovery / maxRecovery;
  
  return {
    max_recoverable_energy: maxRecovery,
    actual_recovered_energy: actualRecovery,
    recovery_efficiency: recoveryEfficiency,
    energy_storage_utilization: assessStorageUtilization(energyStorage),
    optimization_recommendations: generateRecoveryOptimizations(
      recoveryEfficiency, 
      energyStorage
    )
  };
};
```

---


## 🎯 **Expert Recommendations Engine**

FlexaBrain generates context-aware recommendations based on rail engineering best practices:

### Safety Recommendations
```typescript
const generateSafetyRecommendations = (
  safetyAnalysis: SafetyAnalysis,
  components: ElectricalComponent[]
): Recommendation[] => {
  const recommendations = [];
  
  // Arc flash mitigation
  if (safetyAnalysis.arc_flash_hazards.present) {
    recommendations.push({
      id: 'arc_flash_001',
      type: 'SAFETY',
      priority: 'CRITICAL',
      title: 'Install Arc Flash Mitigation Systems',
      description: `Arc flash hazard detected with ${safetyAnalysis.arc_flash_hazards.estimated_energy} cal/cm² incident energy`,
      action: 'Install arc resistant switchgear or implement remote operation',
      components: safetyAnalysis.arc_flash_hazards.components,
      cost_estimate: 'HIGH',
      payback_period: 'Immediate (safety compliance)',
      standards: ['IEEE 1584', 'NFPA 70E']
    });
  }
  
  // Grounding improvements
  if (!safetyAnalysis.ground_fault_risks.has_ground_fault_protection) {
    recommendations.push({
      id: 'grounding_001',
      type: 'SAFETY',
      priority: 'HIGH',
      title: 'Implement Ground Fault Protection',
      description: 'Missing ground fault protection increases shock hazard risk',
      action: 'Install ground fault relays and current transformers',
      cost_estimate: 'MEDIUM',
      payback_period: '2-3 years (reduced insurance, downtime)',
      standards: ['IEEE 142', 'NFPA 70']
    });
  }
  
  return recommendations;
};
```

### Performance Optimization Recommendations
```typescript
const generatePerformanceRecommendations = (
  performanceAnalysis: PerformanceAnalysis,
  components: ElectricalComponent[]
): Recommendation[] => {
  const recommendations = [];
  
  // Power factor correction
  if (performanceAnalysis.efficiency_metrics.power_factor < 0.95) {
    recommendations.push({
      id: 'pf_correction_001',
      type: 'PERFORMANCE',
      priority: 'MEDIUM',
      title: 'Install Power Factor Correction',
      description: `Current power factor ${performanceAnalysis.efficiency_metrics.power_factor.toFixed(2)} below optimal`,
      action: 'Install automatic power factor correction capacitors',
      cost_estimate: 'MEDIUM',
      payback_period: '18-24 months',
      energy_savings: '5-8% reduction in energy costs'
    });
  }
  
  // Harmonic mitigation
  if (performanceAnalysis.efficiency_metrics.harmonic_distortion > 0.08) {
    recommendations.push({
      id: 'harmonic_001',
      type: 'PERFORMANCE',
      priority: 'MEDIUM',
      title: 'Implement Harmonic Filtering',
      description: `THD ${(performanceAnalysis.efficiency_metrics.harmonic_distortion * 100).toFixed(1)}% exceeds recommended limits`,
      action: 'Install passive or active harmonic filters',
      cost_estimate: 'HIGH',
      payback_period: '3-5 years',
      standards: ['IEEE 519']
    });
  }
  
  return recommendations;
};
```

---


This rail engineering guide provides the foundation for FlexaBrain's domain expertise. The built-in knowledge enables accurate component recognition, appropriate safety analysis, and relevant recommendations specific to rail electrical systems.

*For implementation details and API usage, see the [API Reference](API.md) and main [README](../README.md).*