calculateIz static method

Implementation

static double calculateIz({
  required double sectionMm2,
  required enums.ConductorMaterial material,
  required enums.CableInsulation insulation,
  required enums.InstallationMethod method,
  required enums.CorrectionFactors factors,
}) {
  // Alias Z1 to XLPE
  final effectiveInsulation = (insulation == enums.CableInsulation.z1)
      ? enums.CableInsulation.xlpe
      : insulation;

  // 1. Base Capacity (Itab)
  final table = IzConstants.currentCarryingCapacity[effectiveInsulation]
      ?[material]?[method];
  if (table == null) return 0.0;

  double iTab = table[sectionMm2] ?? 0.0;

  // Interpolation
  if (iTab == 0.0 && sectionMm2 > 0) {
    final sections = table.keys.toList()..sort();
    if (sectionMm2 < sections.first) return 0.0;
    if (sectionMm2 > sections.last) return 0.0;

    for (int i = 0; i < sections.length - 1; i++) {
      final s1 = sections[i];
      final s2 = sections[i + 1];
      if (sectionMm2 > s1 && sectionMm2 < s2) {
        final i1 = table[s1]!;
        final i2 = table[s2]!;
        iTab = i1 + (sectionMm2 - s1) * (i2 - i1) / (s2 - s1);
        break;
      }
    }
  }

  // 2. Temperature Correction (Ktemp)
  final tempTable = method.isBuried
      ? IzConstants.tempCorrectionTableGround[effectiveInsulation]
      : IzConstants.tempCorrectionTableAir[effectiveInsulation];

  double kTemp = 1.0;
  if (tempTable != null) {
    final temp = factors.ambientTemperature;
    if (tempTable.containsKey(temp)) {
      kTemp = tempTable[temp]!;
    } else {
      // Nearest/Interp
      final keys = tempTable.keys.toList()..sort();
      if (temp <= keys.first) {
        kTemp = tempTable[keys.first]!;
      } else if (temp >= keys.last) {
        kTemp = tempTable[keys.last]!;
      } else {
        for (int i = 0; i < keys.length - 1; i++) {
          if (temp > keys[i] && temp < keys[i + 1]) {
            final t1 = keys[i];
            final t2 = keys[i + 1];
            final v1 = tempTable[t1]!;
            final v2 = tempTable[t2]!;
            kTemp = v1 + (temp - t1) * (v2 - v1) / (t2 - t1);
            break;
          }
        }
      }
    }
  }

  // 3. Grouping Correction (Kgroup)
  final groupTable = IzConstants.groupingCorrectionTable[method];
  double kGroup = 1.0;
  if (groupTable != null) {
    final n = factors.numberOfCircuits;
    if (groupTable.containsKey(n)) {
      kGroup = groupTable[n]!;
    } else if (n > 1) {
      final maxKey = groupTable.keys.reduce(max);
      if (n > maxKey) kGroup = groupTable[maxKey]!;
    }
  } else if (factors.numberOfCircuits > 1) {
    kGroup = 0.8;
  }

  // 4. Soil Resistivity (Ksoil)
  double kSoil = 1.0;
  if (method.isBuried) {
    final resistivity = factors.soilResistivity;
    if (IzConstants.soilResistivityTable.containsKey(resistivity)) {
      kSoil = IzConstants.soilResistivityTable[resistivity]!;
    } else {
      final rKeys = IzConstants.soilResistivityTable.keys.toList()..sort();
      if (resistivity <= rKeys.first) {
        kSoil = IzConstants.soilResistivityTable[rKeys.first]!;
      } else if (resistivity >= rKeys.last) {
        kSoil = IzConstants.soilResistivityTable[rKeys.last]!;
      } else {
        for (int i = 0; i < rKeys.length - 1; i++) {
          if (resistivity > rKeys[i] && resistivity < rKeys[i + 1]) {
            final r1 = rKeys[i];
            final r2 = rKeys[i + 1];
            final v1 = IzConstants.soilResistivityTable[r1]!;
            final v2 = IzConstants.soilResistivityTable[r2]!;
            kSoil = v1 + (resistivity - r1) * (v2 - v1) / (r2 - r1);
            break;
          }
        }
      }
    }
  }

  return iTab * kTemp * kGroup * kSoil;
}