oltc-selector 2.1.0 → 2.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +50 -45
- package/bin/oltc.js +2960 -446
- package/package.json +5 -5
package/bin/oltc.js
CHANGED
|
@@ -1,5 +1,8 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
|
|
3
|
+
// lib/appVersion.ts
|
|
4
|
+
var APP_VERSION = "2.3.0";
|
|
5
|
+
|
|
3
6
|
// lib/decimal.ts
|
|
4
7
|
var GROUPED = /^\d{1,3}([,,]\d{3})+$/;
|
|
5
8
|
var PLAIN = /^\d*\.?\d*$/;
|
|
@@ -16,6 +19,35 @@ function parseDecimal(raw) {
|
|
|
16
19
|
|
|
17
20
|
// lib/tapCode.ts
|
|
18
21
|
var PITCHES = [10, 12, 14, 16, 18];
|
|
22
|
+
function parseTapRange(raw) {
|
|
23
|
+
let s = raw.trim().replace(/\s+/g, "");
|
|
24
|
+
if (!s) return null;
|
|
25
|
+
s = s.replace(/[×✕✖]/g, "x").replace(/%/g, "%").replace(/,/g, ",");
|
|
26
|
+
s = s.replace(/,/g, ".");
|
|
27
|
+
let stepPercent = null;
|
|
28
|
+
const pct = s.match(/x(\d+(?:\.\d+)?)%$/i);
|
|
29
|
+
if (pct && pct.index != null) {
|
|
30
|
+
const p = Number(pct[1]) / 100;
|
|
31
|
+
if (p > 0 && p < 0.2) stepPercent = p;
|
|
32
|
+
s = s.slice(0, pct.index);
|
|
33
|
+
}
|
|
34
|
+
const patterns = [
|
|
35
|
+
/^[±](\d+)[//](\d+)$/,
|
|
36
|
+
/^[±](\d+)-(\d+)$/,
|
|
37
|
+
/^\+(\d+)\/-(\d+)$/,
|
|
38
|
+
/^\+(\d+)-(\d+)$/,
|
|
39
|
+
/^(\d+)[//](\d+)$/
|
|
40
|
+
];
|
|
41
|
+
for (const re of patterns) {
|
|
42
|
+
const m = s.match(re);
|
|
43
|
+
if (!m) continue;
|
|
44
|
+
const plus = Number(m[1]);
|
|
45
|
+
const minus = Number(m[2]);
|
|
46
|
+
if (!(plus > 0) || !(minus > 0) || plus > 30 || minus > 30) return null;
|
|
47
|
+
return { plus, minus, positions: plus + minus + 1, stepPercent };
|
|
48
|
+
}
|
|
49
|
+
return null;
|
|
50
|
+
}
|
|
19
51
|
var W_DIAGRAMS = [
|
|
20
52
|
// mid=1, small pitch ladder
|
|
21
53
|
{ plusMinus: 4, pitch: 10, positions: 9, mid: 1 },
|
|
@@ -127,6 +159,23 @@ var PM_STEP_OPTIONS_W = [
|
|
|
127
159
|
16,
|
|
128
160
|
17
|
|
129
161
|
];
|
|
162
|
+
var PM_STEP_OPTIONS_G = [
|
|
163
|
+
8,
|
|
164
|
+
9,
|
|
165
|
+
10,
|
|
166
|
+
11,
|
|
167
|
+
12,
|
|
168
|
+
13,
|
|
169
|
+
14,
|
|
170
|
+
15,
|
|
171
|
+
16,
|
|
172
|
+
17
|
|
173
|
+
];
|
|
174
|
+
function pmStepOptionsFor(regulation) {
|
|
175
|
+
if (regulation === "coarse_fine") return PM_STEP_OPTIONS_G;
|
|
176
|
+
if (regulation === "reversing") return PM_STEP_OPTIONS_W;
|
|
177
|
+
return [];
|
|
178
|
+
}
|
|
130
179
|
var PM_TAP_MAP = Object.fromEntries(
|
|
131
180
|
PM_STEP_OPTIONS_W.map((n) => {
|
|
132
181
|
const mid = preferredMid(n, "reversing");
|
|
@@ -211,12 +260,23 @@ function resolveTapFields(input) {
|
|
|
211
260
|
mid: mid2,
|
|
212
261
|
tapCode: buildTapCode({ pitch: pitch2, positions: positions2, mid: mid2, regulation: reg }),
|
|
213
262
|
changeOver: "0",
|
|
214
|
-
|
|
263
|
+
// 2–4 linear positions are not a brochure diagram (r2 ORDERS-9).
|
|
264
|
+
standard: positions2 >= 5
|
|
215
265
|
};
|
|
216
266
|
}
|
|
217
267
|
if (input.plusMinusSteps != null && input.plusMinusSteps > 0) {
|
|
218
268
|
const n = input.plusMinusSteps;
|
|
219
269
|
const allowed = midOptionsFor(n, reg);
|
|
270
|
+
if (reg === "coarse_fine" && n === 7 && !allowed.length) {
|
|
271
|
+
return {
|
|
272
|
+
positions: 17,
|
|
273
|
+
pitch: 10,
|
|
274
|
+
mid: 3,
|
|
275
|
+
tapCode: buildTapCode({ pitch: 10, positions: 17, mid: 3, regulation: reg }),
|
|
276
|
+
changeOver: changeOverOf(reg),
|
|
277
|
+
standard: false
|
|
278
|
+
};
|
|
279
|
+
}
|
|
220
280
|
let mid2;
|
|
221
281
|
if (input.midPositions === 1 || input.midPositions === 3) {
|
|
222
282
|
mid2 = allowed.includes(input.midPositions) ? input.midPositions : preferredMid(n, reg);
|
|
@@ -235,8 +295,8 @@ function resolveTapFields(input) {
|
|
|
235
295
|
standard: row != null && isStandard(positions2, mid2, pitch2)
|
|
236
296
|
};
|
|
237
297
|
}
|
|
238
|
-
|
|
239
|
-
|
|
298
|
+
const positions = input.positions ?? 19;
|
|
299
|
+
const mid = input.midPositions === 1 || input.midPositions === 3 ? input.midPositions : defaultMid(positions, reg);
|
|
240
300
|
const pitch = input.pitch ?? (mid === 1 || mid === 3 ? (() => {
|
|
241
301
|
const n = plusMinusFromPositions(positions, reg);
|
|
242
302
|
if (n != null) {
|
|
@@ -382,8 +442,10 @@ var SELECTOR_SIZES_BY_UM = {
|
|
|
382
442
|
126: ["B", "C", "D", "DE"],
|
|
383
443
|
145: ["C", "D", "DE"],
|
|
384
444
|
170: ["B", "C", "D", "DE"],
|
|
385
|
-
252:
|
|
386
|
-
|
|
445
|
+
// 252 B and 300 D: sold (3× 252B, e.g. CM2III-500Y/252B on E-CM2250216;
|
|
446
|
+
// 3xSHZVI-1200/300D on E-SHZV260102). The Um default stays the auto floor.
|
|
447
|
+
252: ["B", "C", "D", "DE"],
|
|
448
|
+
300: ["D", "DE"],
|
|
387
449
|
363: ["DE"]
|
|
388
450
|
};
|
|
389
451
|
var SIZE_ORDER = ["B", "C", "D", "DE"];
|
|
@@ -396,6 +458,29 @@ var INTERNAL_INSULATION = {
|
|
|
396
458
|
DE: { a_li: 550, a_pf: 120, b_li: 550, b_pf: 160 },
|
|
397
459
|
E: { a_li: 0, a_pf: 0, b_li: 0, b_pf: 0 }
|
|
398
460
|
};
|
|
461
|
+
var INTERNAL_INSULATION_BY_FAMILY = {
|
|
462
|
+
cm2: { C: { a_li: 350, a_pf: 82, b_li: 350, b_pf: 82 } },
|
|
463
|
+
cm: { C: { a_li: 350, a_pf: 82, b_li: 350, b_pf: 82 } },
|
|
464
|
+
cmd: { D: { a_li: 490, a_pf: 105, b_li: 490, b_pf: 146 } }
|
|
465
|
+
};
|
|
466
|
+
function internalInsulation(seriesId, size) {
|
|
467
|
+
const own = seriesId ? INTERNAL_INSULATION_BY_FAMILY[seriesId]?.[size] : void 0;
|
|
468
|
+
return own ?? INTERNAL_INSULATION[size];
|
|
469
|
+
}
|
|
470
|
+
function atPitch(table, pitch) {
|
|
471
|
+
const pitches = Object.keys(table).map(Number).sort((a, b) => a - b);
|
|
472
|
+
const at = pitches.find((p) => p >= pitch) ?? pitches[pitches.length - 1];
|
|
473
|
+
return at != null ? table[at] : void 0;
|
|
474
|
+
}
|
|
475
|
+
function stepCapacityKva(s, current, pitch, dutyA) {
|
|
476
|
+
const byPitch = s.stepCapacityByPitch?.[current];
|
|
477
|
+
const rated = (byPitch ? atPitch(byPitch, pitch) : void 0) ?? s.stepCapacityByCurrent?.[current] ?? null;
|
|
478
|
+
const reduced = s.stepCapacityReduced ? atPitch(s.stepCapacityReduced, pitch) : void 0;
|
|
479
|
+
if (rated != null && reduced && dutyA != null && dutyA <= reduced.currentA + 0.01) {
|
|
480
|
+
return Math.max(rated, reduced.kva);
|
|
481
|
+
}
|
|
482
|
+
return rated;
|
|
483
|
+
}
|
|
399
484
|
function iiiTypeAllowsConnection(s, phases, conn) {
|
|
400
485
|
if (phases !== "III") return true;
|
|
401
486
|
const allowed = s.iiiConnections ?? s.connections;
|
|
@@ -418,7 +503,11 @@ var FAMILY_MIN_RANK = {
|
|
|
418
503
|
// only wins on on-tank path
|
|
419
504
|
cvt: 12,
|
|
420
505
|
cz: 14,
|
|
421
|
-
|
|
506
|
+
// 2026-11-04: WDG/WLG are the drum OCTC sold (45 OS rows, none WSG), so
|
|
507
|
+
// they rank before WSG; WSG stays for the D quote QS2607203.
|
|
508
|
+
wsg: 7,
|
|
509
|
+
wdg: 5.9,
|
|
510
|
+
wlg: 5.9,
|
|
422
511
|
hwdk: 80,
|
|
423
512
|
wsl: 5,
|
|
424
513
|
// OCTC-only list (never mixed into CV2→CM2→SHZV)
|
|
@@ -641,6 +730,8 @@ var SERIES = [
|
|
|
641
730
|
umKv: [72.5, 126, 170, 252],
|
|
642
731
|
usesSelectorSize: true,
|
|
643
732
|
maxStepVoltageV: 4e3,
|
|
733
|
+
// TD-CMD Table 1: 3300 V at 400/600 A, 4000 V from 1000 A.
|
|
734
|
+
maxStepVoltageByCurrent: { 400: 3300, 600: 3300 },
|
|
644
735
|
stepCapacityByCurrent: {
|
|
645
736
|
400: 1320,
|
|
646
737
|
600: 1600,
|
|
@@ -673,6 +764,8 @@ var SERIES = [
|
|
|
673
764
|
},
|
|
674
765
|
umKv: [40.5, 72.5, 126, 145],
|
|
675
766
|
usesSelectorSize: false,
|
|
767
|
+
pitches: [10, 12],
|
|
768
|
+
// CV2 Table 1: 10 and 12 contacts
|
|
676
769
|
maxStepVoltageV: 2e3,
|
|
677
770
|
stepCapacityByCurrent: {
|
|
678
771
|
350: 700,
|
|
@@ -701,11 +794,18 @@ var SERIES = [
|
|
|
701
794
|
},
|
|
702
795
|
umKv: [40.5, 72.5],
|
|
703
796
|
usesSelectorSize: false,
|
|
797
|
+
pitches: [10, 12, 14],
|
|
798
|
+
// CV&SV Table 1: 10/12/14
|
|
704
799
|
maxStepVoltageV: 1500,
|
|
705
800
|
stepCapacityByCurrent: {
|
|
706
801
|
350: 525,
|
|
707
802
|
700: 660
|
|
708
803
|
},
|
|
804
|
+
// TD-CV&SV (HM0.154.001) Table 1 row 7, by contacts 10 / 12 / 14.
|
|
805
|
+
stepCapacityByPitch: {
|
|
806
|
+
350: { 10: 525, 12: 420, 14: 350 },
|
|
807
|
+
700: { 10: 660, 12: 520, 14: 450 }
|
|
808
|
+
},
|
|
709
809
|
connections: ["Y", "D"],
|
|
710
810
|
maxPositionsLinear: 14,
|
|
711
811
|
maxPositionsWithChangeOver: 27,
|
|
@@ -728,9 +828,22 @@ var SERIES = [
|
|
|
728
828
|
},
|
|
729
829
|
umKv: [40.5, 72.5],
|
|
730
830
|
usesSelectorSize: false,
|
|
831
|
+
pitches: [10, 12],
|
|
832
|
+
// CV&SV Table 1: SV has no 14
|
|
731
833
|
maxStepVoltageV: 1500,
|
|
732
834
|
stepCapacityByCurrent: {
|
|
733
|
-
500:
|
|
835
|
+
500: 400
|
|
836
|
+
},
|
|
837
|
+
// TD-CV&SV Table 1 gives SV "400~525* / 325~420*" (10 / 12 contacts, no 14).
|
|
838
|
+
// Footnote *: 525 / 420 kVA only with through-current cut to 350 / 300 A.
|
|
839
|
+
// Conservative reading: 400 / 325 kVA at any duty above 350 / 300 A
|
|
840
|
+
// (no interpolation between the two brochure points).
|
|
841
|
+
stepCapacityByPitch: {
|
|
842
|
+
500: { 10: 400, 12: 325 }
|
|
843
|
+
},
|
|
844
|
+
stepCapacityReduced: {
|
|
845
|
+
10: { currentA: 350, kva: 525 },
|
|
846
|
+
12: { currentA: 300, kva: 420 }
|
|
734
847
|
},
|
|
735
848
|
connections: ["Y", "D"],
|
|
736
849
|
maxPositionsLinear: 12,
|
|
@@ -761,8 +874,8 @@ var SERIES = [
|
|
|
761
874
|
200: 80
|
|
762
875
|
},
|
|
763
876
|
connections: ["Y", "D", "any"],
|
|
764
|
-
maxPositionsLinear:
|
|
765
|
-
maxPositionsWithChangeOver:
|
|
877
|
+
maxPositionsLinear: 9,
|
|
878
|
+
maxPositionsWithChangeOver: 9,
|
|
766
879
|
defaultMdu: "CMA7",
|
|
767
880
|
notesEn: "Dry-type CVTIII-160/200 / 12 kV.",
|
|
768
881
|
notesZh: "\u5E72\u5F0F CVTIII-160/200\uFF0C12 kV\u3002",
|
|
@@ -808,7 +921,9 @@ var SERIES = [
|
|
|
808
921
|
I: [1500, 2e3, 2500],
|
|
809
922
|
III: [1500, 2e3, 2500]
|
|
810
923
|
},
|
|
811
|
-
|
|
924
|
+
// 2026-11-04: Um classes of HWDK Un 35 / 69 kV. The type carries Um
|
|
925
|
+
// (sold HWDKI-1500/40.5-17), not Un.
|
|
926
|
+
umKv: [40.5, 72.5],
|
|
812
927
|
usesSelectorSize: false,
|
|
813
928
|
maxStepVoltageV: 6e3,
|
|
814
929
|
connections: ["Y", "D", "any"],
|
|
@@ -865,12 +980,61 @@ var SERIES = [
|
|
|
865
980
|
usesSelectorSize: false,
|
|
866
981
|
maxStepVoltageV: 1e4,
|
|
867
982
|
connections: ["Y", "D"],
|
|
868
|
-
|
|
869
|
-
|
|
983
|
+
// 2026-11-04: contacts are 4x5 / 6x5 only. 12 let a 6x5 stand for 7–12
|
|
984
|
+
// positions; no WSG string was ever sold.
|
|
985
|
+
maxPositionsLinear: 6,
|
|
986
|
+
maxPositionsWithChangeOver: 6,
|
|
870
987
|
defaultMdu: "CMA7",
|
|
871
988
|
notesEn: "Drum OCTC (WG sheet). dutyKind=octc only. Wiring roman follows octcSeries (form default IV). Auto D \u2192 WSGII (Anthony WSG II-800D/40.5-4x5A).",
|
|
872
989
|
notesZh: "\u9F13\u5F0F\u65E0\u8F7D\uFF08WG \u4EF7\u76EE\u8868\uFF09\u3002\u4EC5 dutyKind=octc\u3002\u63A5\u7EBF\u65B9\u5F0F\u8DDF octcSeries\uFF08\u9875\u9762\u9ED8\u8BA4 IV\uFF09\u3002\u672A\u6307\u5B9A\u65F6 D \u2192 WSGII\u3002",
|
|
873
|
-
rank:
|
|
990
|
+
rank: 7
|
|
991
|
+
},
|
|
992
|
+
// 2026-11-04: the drum OCTC the maker actually sells. Single-phase, one per
|
|
993
|
+
// phase (3xWDGIV-800/40.5-5x5A). Existence is the sold-row list in
|
|
994
|
+
// lib/listIndex.ts; every sold row is Y or blank, so no D.
|
|
995
|
+
{
|
|
996
|
+
id: "wdg",
|
|
997
|
+
code: "WDG",
|
|
998
|
+
nameEn: "WDG single-phase drum off-circuit tap changer (OCTC)",
|
|
999
|
+
nameZh: "WDG \u5355\u76F8\u9F13\u5F0F\u65E0\u8F7D\u5206\u63A5\u5F00\u5173\uFF08OCTC\uFF09",
|
|
1000
|
+
mounting: ["in_tank"],
|
|
1001
|
+
medium: "oil",
|
|
1002
|
+
structure: "drum",
|
|
1003
|
+
vacuum: false,
|
|
1004
|
+
dutyKind: "octc",
|
|
1005
|
+
currents: { I: [300, 400, 800, 1250] },
|
|
1006
|
+
umKv: [40.5, 72.5],
|
|
1007
|
+
usesSelectorSize: false,
|
|
1008
|
+
maxStepVoltageV: 1e4,
|
|
1009
|
+
connections: ["Y"],
|
|
1010
|
+
maxPositionsLinear: 6,
|
|
1011
|
+
maxPositionsWithChangeOver: 6,
|
|
1012
|
+
defaultMdu: "CMA7",
|
|
1013
|
+
notesEn: "Single-phase drum OCTC, one unit per phase. IV 5x5 up to 5 positions; V 6x5 up to 6 when V is asked.",
|
|
1014
|
+
notesZh: "\u5355\u76F8\u9F13\u5F0F\u65E0\u8F7D\uFF0C\u6BCF\u76F8\u4E00\u53F0\u3002IV 5x5 \u81F3 5 \u6863\uFF1B\u6307\u5B9A V \u65F6 6x5 \u81F3 6 \u6863\u3002",
|
|
1015
|
+
rank: 5.9
|
|
1016
|
+
},
|
|
1017
|
+
{
|
|
1018
|
+
id: "wlg",
|
|
1019
|
+
code: "WLG",
|
|
1020
|
+
nameEn: "WLG single-phase drum off-circuit tap changer (OCTC)",
|
|
1021
|
+
nameZh: "WLG \u5355\u76F8\u9F13\u5F0F\u65E0\u8F7D\u5206\u63A5\u5F00\u5173\uFF08OCTC\uFF09",
|
|
1022
|
+
mounting: ["in_tank"],
|
|
1023
|
+
medium: "oil",
|
|
1024
|
+
structure: "drum",
|
|
1025
|
+
vacuum: false,
|
|
1026
|
+
dutyKind: "octc",
|
|
1027
|
+
currents: { I: [800] },
|
|
1028
|
+
umKv: [40.5],
|
|
1029
|
+
usesSelectorSize: false,
|
|
1030
|
+
maxStepVoltageV: 1e4,
|
|
1031
|
+
connections: ["Y"],
|
|
1032
|
+
maxPositionsLinear: 5,
|
|
1033
|
+
maxPositionsWithChangeOver: 5,
|
|
1034
|
+
defaultMdu: "CMA7",
|
|
1035
|
+
notesEn: "Single-phase drum OCTC, series-parallel VIII 4x2 only (one sale).",
|
|
1036
|
+
notesZh: "\u5355\u76F8\u9F13\u5F0F\u65E0\u8F7D\uFF0C\u53EA\u6709\u4E32\u5E76\u8054 VIII 4x2\uFF08\u4E00\u5355\uFF09\u3002",
|
|
1037
|
+
rank: 5.9
|
|
874
1038
|
}
|
|
875
1039
|
];
|
|
876
1040
|
function nearestUm(wanted, allowed) {
|
|
@@ -889,11 +1053,7 @@ function coveringUms(wanted, allowed) {
|
|
|
889
1053
|
function nearestCurrent(wanted, allowed) {
|
|
890
1054
|
if (!allowed?.length) return null;
|
|
891
1055
|
const sorted = [...allowed].sort((a, b) => a - b);
|
|
892
|
-
|
|
893
|
-
if (ge != null) return ge;
|
|
894
|
-
const max = sorted[sorted.length - 1];
|
|
895
|
-
if (wanted <= max * 1.01 + 0.5) return max;
|
|
896
|
-
return null;
|
|
1056
|
+
return sorted.find((c) => c >= wanted - 0.01) ?? null;
|
|
897
1057
|
}
|
|
898
1058
|
function phaseToken(p) {
|
|
899
1059
|
return p;
|
|
@@ -911,24 +1071,31 @@ function firstAllowedAtOrAbove(min, allowed) {
|
|
|
911
1071
|
}
|
|
912
1072
|
return allowed[allowed.length - 1] ?? "B";
|
|
913
1073
|
}
|
|
914
|
-
function coversAcrossTap(size, needALi, needAPf) {
|
|
915
|
-
const ins =
|
|
1074
|
+
function coversAcrossTap(size, needALi, needAPf, seriesId) {
|
|
1075
|
+
const ins = internalInsulation(seriesId, size);
|
|
916
1076
|
return ins.a_li + 0.5 >= needALi && ins.a_pf + 0.5 >= needAPf;
|
|
917
1077
|
}
|
|
918
|
-
function resolveSelectorSize(um, requested, acrossTapBilKv, acrossTapPfKv) {
|
|
1078
|
+
function resolveSelectorSize(um, requested, acrossTapBilKv, acrossTapPfKv, seriesId, statedFloor = false, minSize) {
|
|
919
1079
|
const allowed = SELECTOR_SIZES_BY_UM[um] ?? ["B", "C", "D", "DE"];
|
|
920
1080
|
const needALi = acrossTapBilKv ?? 0;
|
|
921
1081
|
const needAPf = acrossTapPfKv ?? 0;
|
|
922
1082
|
const typed = requested && requested !== "auto" ? requested : null;
|
|
1083
|
+
const stated = statedFloor && needALi > 0 && needAPf > 0;
|
|
1084
|
+
const umDefault = defaultSelectorSizeForUm(um);
|
|
1085
|
+
const untyped = minSize && SIZE_ORDER.indexOf(minSize) > SIZE_ORDER.indexOf(umDefault) ? minSize : umDefault;
|
|
923
1086
|
const floor = firstAllowedAtOrAbove(
|
|
924
|
-
typed ??
|
|
1087
|
+
typed ?? (stated ? allowed[0] : untyped),
|
|
925
1088
|
allowed
|
|
926
1089
|
);
|
|
927
1090
|
for (let i = SIZE_ORDER.indexOf(floor); i < SIZE_ORDER.length; i++) {
|
|
928
1091
|
const cand = SIZE_ORDER[i];
|
|
929
1092
|
if (!allowed.includes(cand)) continue;
|
|
930
|
-
if (!coversAcrossTap(cand, needALi, needAPf)) continue;
|
|
931
|
-
|
|
1093
|
+
if (!coversAcrossTap(cand, needALi, needAPf, seriesId)) continue;
|
|
1094
|
+
if (typed && cand !== typed) return { size: cand, raisedFrom: typed };
|
|
1095
|
+
if (!typed && SIZE_ORDER.indexOf(cand) < SIZE_ORDER.indexOf(umDefault)) {
|
|
1096
|
+
return { size: cand, loweredFrom: umDefault };
|
|
1097
|
+
}
|
|
1098
|
+
return { size: cand };
|
|
932
1099
|
}
|
|
933
1100
|
return { size: null };
|
|
934
1101
|
}
|
|
@@ -949,7 +1116,7 @@ var listIndex_data_default = { source: "QS/a. Base Price List 2025.xlsx (WSL/WDL
|
|
|
949
1116
|
|
|
950
1117
|
// lib/parseType.ts
|
|
951
1118
|
function normalizeType(raw) {
|
|
952
|
-
let t = raw.replace(/[×*]/g, "x").replace(/[–—-]/g, "-").replace(/,/g, ".").replace(/(/g, "(").replace(/)/g, ")").replace(/\s+/g, "").replace(/(\d)_(\d)/g, "$1x$2").replace(/(III|II|I)(\d)/, "$1-$2").replace(/(WSL|WDL|WSG)(VIII|VII|IV|VI|IX|V)(\d)/i, "$1$2-$3");
|
|
1119
|
+
let t = raw.replace(/[×*]/g, "x").replace(/[–—-]/g, "-").replace(/,/g, ".").replace(/(/g, "(").replace(/)/g, ")").replace(/\s+/g, "").replace(/(\d)_(\d)/g, "$1x$2").replace(/(III|II|I)(\d)/, "$1-$2").replace(/(WSL|WDL|WSG|WDG|WLG)(VIII|VII|IV|VI|IX|V)(\d)/i, "$1$2-$3");
|
|
953
1120
|
if (!t.includes("/")) {
|
|
954
1121
|
t = t.replace(/([YD])(\d+(?:\.\d+)?)-/i, "$1/$2-");
|
|
955
1122
|
}
|
|
@@ -959,7 +1126,7 @@ function normalizeType(raw) {
|
|
|
959
1126
|
);
|
|
960
1127
|
return t;
|
|
961
1128
|
}
|
|
962
|
-
var OCTC_TYPE_RE = /^(?:(\d+)x)?(WSL|WDL|WSG)(VIII|VII|III|II|IV|VI|IX|V|I)-(\d+)([YD])?[/-](\d+(?:\.\d+)?)-(\d+)x(\d+)(?:\((\d+)x(\d+)\))?(?:\(([A-E])\)|([A-E]))?$/i;
|
|
1129
|
+
var OCTC_TYPE_RE = /^(?:(\d+)x)?(WSL|WDL|WSG|WDG|WLG)(VIII|VII|III|II|IV|VI|IX|V|I)-(\d+)([YD])?[/-](\d+(?:\.\d+)?)-(\d+)x(\d+)(?:\((\d+)x(\d+)\))?(?:\(([A-E])\)|([A-E]))?$/i;
|
|
963
1130
|
function parseTypeString(raw) {
|
|
964
1131
|
const t = normalizeType(raw);
|
|
965
1132
|
const octc = t.match(OCTC_TYPE_RE);
|
|
@@ -1021,10 +1188,27 @@ function octcSig(row) {
|
|
|
1021
1188
|
].join("|");
|
|
1022
1189
|
}
|
|
1023
1190
|
var octcIndex = null;
|
|
1191
|
+
var DRUM_SOLD_ROWS = [
|
|
1192
|
+
"WDGIV-300/40.5-5x5A",
|
|
1193
|
+
"WDGIV-400/40.5-5x5A",
|
|
1194
|
+
"WDGIV-800/40.5-5x5A",
|
|
1195
|
+
"WDGIV-300/72.5-5x5B",
|
|
1196
|
+
"WDGIV-400/72.5-5x5A",
|
|
1197
|
+
"WDGIV-800/72.5-5x5A",
|
|
1198
|
+
"WDGIV-1250/72.5-5x5A",
|
|
1199
|
+
"WDGV-800/40.5-6x5B",
|
|
1200
|
+
"WDGV-800/72.5-6x5B",
|
|
1201
|
+
"WLGVIII-800/40.5-4x2A"
|
|
1202
|
+
];
|
|
1203
|
+
var DRUM_FAMILIES = /* @__PURE__ */ new Set(["WDG", "WLG"]);
|
|
1024
1204
|
function getOctcIndex() {
|
|
1025
1205
|
if (octcIndex) return octcIndex;
|
|
1026
1206
|
const bySig = /* @__PURE__ */ new Map();
|
|
1027
|
-
|
|
1207
|
+
const drumRows = DRUM_SOLD_ROWS.flatMap((listKey) => {
|
|
1208
|
+
const p = parseTypeString(listKey);
|
|
1209
|
+
return p ? [{ ...p, listKey }] : [];
|
|
1210
|
+
});
|
|
1211
|
+
for (const row of [...file.octc, ...drumRows]) {
|
|
1028
1212
|
const k = octcSig(row);
|
|
1029
1213
|
const bucket = bySig.get(k);
|
|
1030
1214
|
if (bucket) bucket.push(row);
|
|
@@ -1055,14 +1239,23 @@ function listRowExists(model) {
|
|
|
1055
1239
|
if (KEYS.has(compact)) return true;
|
|
1056
1240
|
const parsed = parseTypeString(compact);
|
|
1057
1241
|
if (!parsed) return false;
|
|
1058
|
-
if (parsed.family !== "WSL" && parsed.family !== "WDL")
|
|
1242
|
+
if (parsed.family !== "WSL" && parsed.family !== "WDL" && !DRUM_FAMILIES.has(parsed.family)) {
|
|
1243
|
+
return false;
|
|
1244
|
+
}
|
|
1059
1245
|
return Boolean(lookupOctcRows(parsed)?.length);
|
|
1060
1246
|
}
|
|
1061
1247
|
function resolveOctcListKey(model) {
|
|
1062
1248
|
const parsed = parseTypeString(model);
|
|
1063
1249
|
if (!parsed) return null;
|
|
1064
1250
|
if (parsed.family === "WSG") return model;
|
|
1065
|
-
|
|
1251
|
+
const unit = model.match(/^(\d+)x/i);
|
|
1252
|
+
if (unit) {
|
|
1253
|
+
const one = resolveOctcListKey(model.slice(unit[0].length));
|
|
1254
|
+
return one ? `${unit[1]}x${one}` : null;
|
|
1255
|
+
}
|
|
1256
|
+
if (parsed.family !== "WSL" && parsed.family !== "WDL" && !DRUM_FAMILIES.has(parsed.family)) {
|
|
1257
|
+
return null;
|
|
1258
|
+
}
|
|
1066
1259
|
const candidates = /* @__PURE__ */ new Set();
|
|
1067
1260
|
const add = (m) => {
|
|
1068
1261
|
if (m) candidates.add(m);
|
|
@@ -1081,6 +1274,10 @@ function resolveOctcListKey(model) {
|
|
|
1081
1274
|
add(stripped.replace(new RegExp(`${sizeNow}$`), sz));
|
|
1082
1275
|
}
|
|
1083
1276
|
}
|
|
1277
|
+
if (sizeNow) {
|
|
1278
|
+
add(model.replace(new RegExp(`${sizeNow}$`), ""));
|
|
1279
|
+
add(stripped.replace(new RegExp(`${sizeNow}$`), ""));
|
|
1280
|
+
}
|
|
1084
1281
|
for (const c of candidates) {
|
|
1085
1282
|
if (listRowExists(c)) {
|
|
1086
1283
|
const hits2 = lookupOctcRows(parseTypeString(c) ?? parsed);
|
|
@@ -1104,8 +1301,10 @@ function commercialTypeExists(model, series) {
|
|
|
1104
1301
|
if (s.dutyKind === "octc") {
|
|
1105
1302
|
if (s.id === "wsg") {
|
|
1106
1303
|
const i = s.currents.III?.includes(parsed.currentA) || s.currents.II?.includes(parsed.currentA) || s.currents.I?.includes(parsed.currentA);
|
|
1304
|
+
const roman = ["II", "IV", "V"].includes(parsed.phases);
|
|
1305
|
+
const contact = parsed.tapCode === "4x5" || parsed.tapCode === "6x5";
|
|
1107
1306
|
return Boolean(
|
|
1108
|
-
i && s.umKv.some((u) => Math.abs(u - parsed.umKv) < 0.05)
|
|
1307
|
+
i && roman && contact && s.umKv.some((u) => Math.abs(u - parsed.umKv) < 0.05)
|
|
1109
1308
|
);
|
|
1110
1309
|
}
|
|
1111
1310
|
return listRowExists(model);
|
|
@@ -1152,24 +1351,105 @@ function connectionLetterOnPhase(s, phases, connection) {
|
|
|
1152
1351
|
return connection;
|
|
1153
1352
|
}
|
|
1154
1353
|
|
|
1354
|
+
// lib/deriveUm.ts
|
|
1355
|
+
var SNAP_UN = [33, 35, 66, 69, 110, 115, 132, 138, 150, 220, 230, 330];
|
|
1356
|
+
var IEC_UM = [
|
|
1357
|
+
3.6,
|
|
1358
|
+
7.2,
|
|
1359
|
+
12,
|
|
1360
|
+
17.5,
|
|
1361
|
+
24,
|
|
1362
|
+
36,
|
|
1363
|
+
40.5,
|
|
1364
|
+
52,
|
|
1365
|
+
72.5,
|
|
1366
|
+
100,
|
|
1367
|
+
123,
|
|
1368
|
+
145,
|
|
1369
|
+
170,
|
|
1370
|
+
245,
|
|
1371
|
+
300,
|
|
1372
|
+
362,
|
|
1373
|
+
420,
|
|
1374
|
+
550,
|
|
1375
|
+
800
|
|
1376
|
+
];
|
|
1377
|
+
var CATALOGUE_UM = [12, 17.5, 40.5, 72.5, 126, 145, 170, 252, 300, 363];
|
|
1378
|
+
function nominalSystemKv(ratedKv) {
|
|
1379
|
+
let best = ratedKv;
|
|
1380
|
+
for (const u of [...SNAP_UN, 400, 500]) {
|
|
1381
|
+
const win = u >= 400 ? 0.05 : 0.12;
|
|
1382
|
+
if (u <= ratedKv && (ratedKv - u) / ratedKv <= win) best = u;
|
|
1383
|
+
}
|
|
1384
|
+
return best;
|
|
1385
|
+
}
|
|
1386
|
+
function iecUmFromRatedKv(ratedKv) {
|
|
1387
|
+
if (!(ratedKv > 0)) return NaN;
|
|
1388
|
+
const un = nominalSystemKv(ratedKv);
|
|
1389
|
+
return IEC_UM.find((u) => u >= un * 1.04) ?? NaN;
|
|
1390
|
+
}
|
|
1391
|
+
function catalogueUmFromRatedKv(ratedKv) {
|
|
1392
|
+
const um = iecUmFromRatedKv(ratedKv);
|
|
1393
|
+
if (!Number.isFinite(um)) return NaN;
|
|
1394
|
+
return CATALOGUE_UM.find((c) => c >= um - 1e-9) ?? um;
|
|
1395
|
+
}
|
|
1396
|
+
function maxThroughCurrent(ratedA, minusSteps, stepPercent) {
|
|
1397
|
+
if (!(ratedA > 0)) return NaN;
|
|
1398
|
+
if (!(minusSteps > 0) || !(stepPercent > 0)) return ratedA;
|
|
1399
|
+
const drop = minusSteps * stepPercent;
|
|
1400
|
+
if (drop <= 0) return ratedA;
|
|
1401
|
+
if (drop >= 1) return NaN;
|
|
1402
|
+
return ratedA / (1 - drop);
|
|
1403
|
+
}
|
|
1404
|
+
|
|
1155
1405
|
// lib/engine.ts
|
|
1156
1406
|
function normOctcContact(raw) {
|
|
1157
|
-
const t = (raw ?? "").replace(/\s+/g, "").toLowerCase();
|
|
1158
|
-
const m = t.match(/^(\d+)x(\d+)
|
|
1407
|
+
const t = (raw ?? "").replace(/\s+/g, "").replace(/[×*✕]/g, "x").toLowerCase();
|
|
1408
|
+
const m = t.match(/^(\d+)x(\d+)[a-e]?$/);
|
|
1159
1409
|
if (!m) return "";
|
|
1160
1410
|
return `${Number(m[1])}x${Number(m[2])}`;
|
|
1161
1411
|
}
|
|
1412
|
+
function octcContactPositions(contact) {
|
|
1413
|
+
const c = normOctcContact(contact);
|
|
1414
|
+
if (c === "4x5" || c === "5x5" || c === "4x2" || c === "5x2") return 5;
|
|
1415
|
+
return Number(c.split("x")[0]) || 0;
|
|
1416
|
+
}
|
|
1417
|
+
function octcPositionsAsked(input) {
|
|
1418
|
+
if (input.plusMinusSteps != null && input.plusMinusSteps > 0) return 2 * input.plusMinusSteps + 1;
|
|
1419
|
+
return input.positions;
|
|
1420
|
+
}
|
|
1162
1421
|
function octcContactCode(input, seriesId) {
|
|
1163
1422
|
const hinted = normOctcContact(input.octcContact);
|
|
1164
|
-
if (hinted) return hinted;
|
|
1165
1423
|
let pos = input.positions;
|
|
1166
1424
|
if (input.plusMinusSteps != null && input.plusMinusSteps > 0) {
|
|
1167
1425
|
pos = 2 * input.plusMinusSteps + 1;
|
|
1168
1426
|
}
|
|
1169
1427
|
if (seriesId === "wsg") {
|
|
1428
|
+
if (pos != null && pos > 6) return "";
|
|
1429
|
+
if (hinted === "4x5") return pos == null || pos <= 5 ? hinted : "";
|
|
1430
|
+
if (hinted === "6x5") return hinted;
|
|
1431
|
+
if (hinted) return "";
|
|
1170
1432
|
if (pos == null || pos <= 5) return "4x5";
|
|
1171
1433
|
return "6x5";
|
|
1172
1434
|
}
|
|
1435
|
+
if (seriesId === "wdg" || seriesId === "wlg") {
|
|
1436
|
+
const roman = input.octcSeries ?? "auto";
|
|
1437
|
+
const hintRoman = roman === "auto" && hinted === "6x5" && seriesId === "wdg";
|
|
1438
|
+
let drum = "";
|
|
1439
|
+
if (seriesId === "wlg") {
|
|
1440
|
+
if ((roman === "VIII" || roman === "auto" && hinted === "4x2") && (pos == null || pos <= 5)) {
|
|
1441
|
+
drum = "4x2";
|
|
1442
|
+
}
|
|
1443
|
+
} else if (roman === "V" || hintRoman) {
|
|
1444
|
+
if (pos == null || pos <= 6) drum = "6x5";
|
|
1445
|
+
} else if (roman === "auto" || roman === "IV") {
|
|
1446
|
+
if (pos == null || pos <= 5) drum = "5x5";
|
|
1447
|
+
}
|
|
1448
|
+
return hinted && hinted !== drum ? "" : drum;
|
|
1449
|
+
}
|
|
1450
|
+
if (hinted && pos != null && octcContactPositions(hinted) < pos) return "";
|
|
1451
|
+
if (hinted) return hinted;
|
|
1452
|
+
if (input.octcSeries === "VIII" && (pos == null || pos <= 5)) return "5x2";
|
|
1173
1453
|
if (pos == null || pos <= 6) return "6x5";
|
|
1174
1454
|
if (pos <= 7) return "7x6";
|
|
1175
1455
|
if (pos <= 8) return "8x7";
|
|
@@ -1179,7 +1459,7 @@ function octcContactCode(input, seriesId) {
|
|
|
1179
1459
|
if (pos <= 16) return "16x15";
|
|
1180
1460
|
return "18x17";
|
|
1181
1461
|
}
|
|
1182
|
-
function octcSizeLetter(um, contact, requested) {
|
|
1462
|
+
function octcSizeLetter(um, contact, requested, acrossTapGiven = false) {
|
|
1183
1463
|
if (requested && requested !== "auto") {
|
|
1184
1464
|
if (requested === "DE") return "E";
|
|
1185
1465
|
return requested;
|
|
@@ -1187,25 +1467,33 @@ function octcSizeLetter(um, contact, requested) {
|
|
|
1187
1467
|
const c = contact.toLowerCase();
|
|
1188
1468
|
if (c === "18x17" || c === "16x15") return "E";
|
|
1189
1469
|
if (c === "12x11" || c === "10x9" || c === "12x12") return "D";
|
|
1190
|
-
if (um <= 72.5 + 0.1 && ["6x5", "4x5", "5x4", "5x2", "4x3", "3x2", "7x6"].includes(c)) {
|
|
1470
|
+
if (um <= (acrossTapGiven ? 72.5 : 145) + 0.1 && ["6x5", "4x5", "5x4", "5x2", "4x3", "3x2", "7x6"].includes(c)) {
|
|
1191
1471
|
return "A";
|
|
1192
1472
|
}
|
|
1193
1473
|
return "B";
|
|
1194
1474
|
}
|
|
1195
1475
|
function octcRoman(connection, contact, series, familyCode) {
|
|
1196
1476
|
if (series && series !== "auto") return series;
|
|
1197
|
-
const c = (contact
|
|
1477
|
+
const c = normOctcContact(contact);
|
|
1198
1478
|
if (c === "5x2" || c === "12x2") return "VIII";
|
|
1199
1479
|
if (c === "3x2" || c === "6x2") return "VI";
|
|
1200
1480
|
if (c === "5x4" || c === "4x3") return "V";
|
|
1201
1481
|
if (c === "12x12") return "VII";
|
|
1482
|
+
if (familyCode === "WDG" && c === "6x5") return "V";
|
|
1483
|
+
if (familyCode === "WLG" && c === "4x2") return "VIII";
|
|
1202
1484
|
if (familyCode === "WSG" && connection === "D") return "II";
|
|
1203
1485
|
return "IV";
|
|
1204
1486
|
}
|
|
1205
1487
|
function isOctcSeries(s) {
|
|
1206
1488
|
return s.dutyKind === "octc";
|
|
1207
1489
|
}
|
|
1208
|
-
|
|
1490
|
+
var DRUM_SINGLE = /* @__PURE__ */ new Set(["wdg", "wlg"]);
|
|
1491
|
+
function rankUnits(seriesId, unitCount) {
|
|
1492
|
+
return DRUM_SINGLE.has(seriesId) ? 1 : unitCount;
|
|
1493
|
+
}
|
|
1494
|
+
function maxStepVoltageForSeries(s, pitch, current) {
|
|
1495
|
+
const byCurrent = current != null ? s.maxStepVoltageByCurrent?.[current] : void 0;
|
|
1496
|
+
if (byCurrent != null) return byCurrent;
|
|
1209
1497
|
if (s.id === "cv2" || s.id === "cv" || s.id === "sv") {
|
|
1210
1498
|
if (pitch <= 10) return s.id === "cv2" ? 2e3 : 1500;
|
|
1211
1499
|
if (pitch <= 12) return s.id === "cv2" ? 1500 : 1400;
|
|
@@ -1213,17 +1501,25 @@ function maxStepVoltageForSeries(s, pitch) {
|
|
|
1213
1501
|
}
|
|
1214
1502
|
return s.maxStepVoltageV;
|
|
1215
1503
|
}
|
|
1504
|
+
function seriesTap(s, tap, reg) {
|
|
1505
|
+
if (!s.pitches || reg === "linear" || s.pitches.includes(tap.pitch)) return tap;
|
|
1506
|
+
const pitch = s.pitches.find((p) => tap.positions <= 2 * (p - 1) + 1);
|
|
1507
|
+
if (pitch == null) return null;
|
|
1508
|
+
const tapCode = buildTapCode({ pitch, positions: tap.positions, mid: tap.mid, regulation: reg });
|
|
1509
|
+
const guideRow = pitch === 10 && tap.mid === 1 && reg === "reversing" && (tap.positions === 13 || tap.positions === 15 || tap.positions === 17 || tap.positions === 19);
|
|
1510
|
+
return { ...tap, pitch, tapCode, standard: guideRow };
|
|
1511
|
+
}
|
|
1216
1512
|
function compoundCoversAcrossTap(s, input) {
|
|
1217
1513
|
if (s.structure !== "compound") return true;
|
|
1218
1514
|
const needBil = input.acrossTapBilKv ?? 0;
|
|
1219
1515
|
const needPf = input.acrossTapPfKv ?? 0;
|
|
1220
1516
|
if (needBil <= 0 && needPf <= 0) return true;
|
|
1221
|
-
const aLi =
|
|
1222
|
-
const aPf =
|
|
1517
|
+
const aLi = 200;
|
|
1518
|
+
const aPf = 50;
|
|
1223
1519
|
return aLi + 0.5 >= needBil && aPf + 0.5 >= needPf;
|
|
1224
1520
|
}
|
|
1225
1521
|
function formatUmToken(um, size, usesSelectorSize) {
|
|
1226
|
-
const umStr =
|
|
1522
|
+
const umStr = String(um);
|
|
1227
1523
|
if (!usesSelectorSize || !size) return umStr;
|
|
1228
1524
|
return `${umStr}${size}`;
|
|
1229
1525
|
}
|
|
@@ -1238,7 +1534,8 @@ function buildModelString(series, phases, current, connection, umToken, tapCode,
|
|
|
1238
1534
|
octcSeries,
|
|
1239
1535
|
series.code
|
|
1240
1536
|
);
|
|
1241
|
-
|
|
1537
|
+
const ydToken = DRUM_SINGLE.has(series.id) ? "" : yd;
|
|
1538
|
+
core = `${series.code}${roman}-${current}${ydToken}/${umToken}-${tapCode}`;
|
|
1242
1539
|
} else if (series.code === "HWDK") {
|
|
1243
1540
|
core = `${series.code}${phases}-${current}/${umToken}`;
|
|
1244
1541
|
if (tapCode && /^\d+$/.test(tapCode)) core += `-${tapCode}`;
|
|
@@ -1268,7 +1565,7 @@ function seriesMatchesMedium(s, input) {
|
|
|
1268
1565
|
if (input.medium === "oil") return s.medium === "oil" && !s.vacuum;
|
|
1269
1566
|
return true;
|
|
1270
1567
|
}
|
|
1271
|
-
function adequacyScore(s, input, current, um, unitCount) {
|
|
1568
|
+
function adequacyScore(s, input, current, um, unitCount, pitch) {
|
|
1272
1569
|
let score = 1e4;
|
|
1273
1570
|
const fam = FAMILY_MIN_RANK[s.id] ?? s.rank;
|
|
1274
1571
|
score -= fam * 100;
|
|
@@ -1280,6 +1577,14 @@ function adequacyScore(s, input, current, um, unitCount) {
|
|
|
1280
1577
|
score += 2500;
|
|
1281
1578
|
}
|
|
1282
1579
|
if (input.mounting === "in_tank" && s.id === "hwv") score -= 4e3;
|
|
1580
|
+
if ((s.id === "cv" || s.id === "sv") && input.stepVoltageV > STEP_VOLTAGE_LINE * maxStepVoltageForSeries(s, pitch)) {
|
|
1581
|
+
score -= 3500;
|
|
1582
|
+
}
|
|
1583
|
+
if (input.phases === "I" && s.id === "cv2") score -= 3500;
|
|
1584
|
+
const windUm = input.tapWindingKv ? catalogueUmFromRatedKv(input.tapWindingKv) : 0;
|
|
1585
|
+
if (s.id === "shzv" && (windUm >= 420 || unitCount === 1 && input.phases === "III" && windUm >= 252 && input.throughCurrentA > 430)) {
|
|
1586
|
+
score += 1700;
|
|
1587
|
+
}
|
|
1283
1588
|
if (unitCount > 1) {
|
|
1284
1589
|
score -= 8e3;
|
|
1285
1590
|
score -= current * 0.05;
|
|
@@ -1288,7 +1593,7 @@ function adequacyScore(s, input, current, um, unitCount) {
|
|
|
1288
1593
|
score -= overshootI * 0.25;
|
|
1289
1594
|
const overshootUm = um - input.umKv;
|
|
1290
1595
|
score -= overshootUm * 3;
|
|
1291
|
-
const psin = s.
|
|
1596
|
+
const psin = stepCapacityKva(s, current, pitch, input.throughCurrentA);
|
|
1292
1597
|
if (psin && input.stepVoltageV > 0) {
|
|
1293
1598
|
const need = input.throughCurrentA * input.stepVoltageV / 1e3;
|
|
1294
1599
|
if (need > 0 && psin >= need) {
|
|
@@ -1298,17 +1603,31 @@ function adequacyScore(s, input, current, um, unitCount) {
|
|
|
1298
1603
|
return score;
|
|
1299
1604
|
}
|
|
1300
1605
|
function ratingCoversDuty(wanted, rating) {
|
|
1301
|
-
|
|
1302
|
-
return wanted <= rating * 1.01 + 0.5;
|
|
1606
|
+
return wanted <= rating + 0.01;
|
|
1303
1607
|
}
|
|
1304
|
-
function buildAttempts(s, input) {
|
|
1608
|
+
function buildAttempts(s, input, octcWide = false) {
|
|
1305
1609
|
const out = [];
|
|
1306
1610
|
const covering = coveringUms(input.umKv, s.umKv).filter(
|
|
1307
1611
|
(u) => u >= input.umKv - 0.1
|
|
1308
1612
|
);
|
|
1309
1613
|
if (!covering.length) return out;
|
|
1310
1614
|
const um0 = covering[0];
|
|
1311
|
-
const ums = !isOctcSeries(s) && (FAMILY_MIN_RANK[s.id] ?? s.rank) < 40 ? covering : [um0];
|
|
1615
|
+
const ums = !isOctcSeries(s) && (FAMILY_MIN_RANK[s.id] ?? s.rank) < 40 ? covering : s.id === "wsl" && (input.preferStructure === "cage" || octcWide) ? covering : [um0];
|
|
1616
|
+
if (DRUM_SINGLE.has(s.id)) {
|
|
1617
|
+
const curI = nearestCurrent(input.throughCurrentA, s.currents.I ?? []);
|
|
1618
|
+
if (curI != null && ratingCoversDuty(input.throughCurrentA, curI)) {
|
|
1619
|
+
for (const um of input.preferStructure === "drum" || octcWide ? covering : [um0]) {
|
|
1620
|
+
out.push({
|
|
1621
|
+
series: s,
|
|
1622
|
+
phases: "I",
|
|
1623
|
+
current: curI,
|
|
1624
|
+
um,
|
|
1625
|
+
unitCount: input.phases === "I" ? 1 : input.phases === "II" ? 2 : 3
|
|
1626
|
+
});
|
|
1627
|
+
}
|
|
1628
|
+
}
|
|
1629
|
+
return out;
|
|
1630
|
+
}
|
|
1312
1631
|
if (s.id === "cz") {
|
|
1313
1632
|
const curI = nearestCurrent(input.throughCurrentA, s.currents.I ?? []);
|
|
1314
1633
|
if (curI != null && ratingCoversDuty(input.throughCurrentA, curI)) {
|
|
@@ -1317,7 +1636,8 @@ function buildAttempts(s, input) {
|
|
|
1317
1636
|
phases: "I",
|
|
1318
1637
|
current: curI,
|
|
1319
1638
|
um: um0,
|
|
1320
|
-
|
|
1639
|
+
// 2026-11-07: one CZI per phase; a single-phase job was quoted 3×CZI.
|
|
1640
|
+
unitCount: input.phases === "I" ? 1 : input.phases === "II" ? 2 : 3
|
|
1321
1641
|
});
|
|
1322
1642
|
}
|
|
1323
1643
|
return out;
|
|
@@ -1344,7 +1664,8 @@ function buildAttempts(s, input) {
|
|
|
1344
1664
|
}
|
|
1345
1665
|
}
|
|
1346
1666
|
if (isOctcSeries(s)) return out;
|
|
1347
|
-
if (s.currents.I?.length &&
|
|
1667
|
+
if (s.currents.I?.length && // 2026-11-07: one I-unit per phase; a two-phase (II) delta job was quoted 3×.
|
|
1668
|
+
(input.phases === "III" || connIllegal && input.phases === "II")) {
|
|
1348
1669
|
const curI = nearestCurrent(input.throughCurrentA, s.currents.I);
|
|
1349
1670
|
if (curI != null) {
|
|
1350
1671
|
out.push({
|
|
@@ -1352,7 +1673,7 @@ function buildAttempts(s, input) {
|
|
|
1352
1673
|
phases: "I",
|
|
1353
1674
|
current: curI,
|
|
1354
1675
|
um: um0,
|
|
1355
|
-
unitCount: 3,
|
|
1676
|
+
unitCount: input.phases === "II" ? 2 : 3,
|
|
1356
1677
|
deltaForced: connIllegal
|
|
1357
1678
|
});
|
|
1358
1679
|
}
|
|
@@ -1387,6 +1708,196 @@ function diversifyResults(ranked) {
|
|
|
1387
1708
|
}
|
|
1388
1709
|
return [primary, ...rest];
|
|
1389
1710
|
}
|
|
1711
|
+
var LIMIT_AXES = ["um", "current", "positions", "ust", "kva"];
|
|
1712
|
+
function limitScope(input) {
|
|
1713
|
+
if (input.dutyKind === "octc") return { en: "OCTC", zh: "\u65E0\u8F7D" };
|
|
1714
|
+
if (input.mounting === "dry_type") return { en: "dry-type", zh: "\u5E72\u5F0F" };
|
|
1715
|
+
if (input.mounting === "reactor") return { en: "reactor", zh: "\u7535\u6297\u5F0F" };
|
|
1716
|
+
const on = input.mounting === "on_tank" || input.mounting === "external_compartment";
|
|
1717
|
+
const vac = input.preferVacuum || input.medium === "oil_vacuum";
|
|
1718
|
+
const oil = !vac && input.medium === "oil";
|
|
1719
|
+
return {
|
|
1720
|
+
en: `${on ? "on-tank" : "in-tank"}${vac ? " vacuum" : oil ? " oil" : ""}`,
|
|
1721
|
+
zh: `${on ? "\u7BB1\u5916" : "\u7BB1\u5185"}${vac ? "\u771F\u7A7A" : oil ? "\u6CB9\u6D78" : ""}`
|
|
1722
|
+
};
|
|
1723
|
+
}
|
|
1724
|
+
function familyMiss(s, input, tap) {
|
|
1725
|
+
const octc = isOctcSeries(s);
|
|
1726
|
+
const ratings = [];
|
|
1727
|
+
if (s.id === "cz") {
|
|
1728
|
+
const n = input.phases === "I" ? 1 : input.phases === "II" ? 2 : 3;
|
|
1729
|
+
for (const c of s.currents.I ?? []) ratings.push({ current: c, label: `${n > 1 ? `${n}\xD7` : ""}${s.code}I-${c}` });
|
|
1730
|
+
} else if (s.id === "wdg" || s.id === "wlg") {
|
|
1731
|
+
const n = input.phases === "I" ? 1 : input.phases === "II" ? 2 : 3;
|
|
1732
|
+
for (const c of s.currents.I ?? []) {
|
|
1733
|
+
const row = DRUM_SOLD_ROWS.filter((r) => r.startsWith(s.code) && r.includes(`-${c}/`)).pop();
|
|
1734
|
+
const name = row ? row.replace(/-[^-]+$/, "") : `${s.code}-${c}`;
|
|
1735
|
+
ratings.push({ current: c, label: `${n > 1 ? `${n}\xD7` : ""}${name}` });
|
|
1736
|
+
}
|
|
1737
|
+
} else {
|
|
1738
|
+
const legal = phaseConnectionLegal(s, input.phases, input.connection);
|
|
1739
|
+
if (legal) {
|
|
1740
|
+
for (const c of s.currents[input.phases] ?? []) {
|
|
1741
|
+
ratings.push({ current: c, label: `${s.code}${input.phases}-${c}` });
|
|
1742
|
+
}
|
|
1743
|
+
}
|
|
1744
|
+
if (!octc && (input.phases === "III" || !legal)) {
|
|
1745
|
+
for (const c of s.currents.I ?? []) ratings.push({ current: c, label: `3\xD7${s.code}I-${c}` });
|
|
1746
|
+
}
|
|
1747
|
+
}
|
|
1748
|
+
if (!ratings.length) return null;
|
|
1749
|
+
const blocks = [];
|
|
1750
|
+
if (!s.umKv.some((u) => u >= input.umKv - 0.1)) {
|
|
1751
|
+
blocks.push({ axis: "um", need: input.umKv, limit: Math.max(...s.umKv), label: s.code });
|
|
1752
|
+
}
|
|
1753
|
+
const top = ratings.reduce((a, b) => b.current > a.current ? b : a);
|
|
1754
|
+
const covering = ratings.filter((r) => ratingCoversDuty(input.throughCurrentA, r.current));
|
|
1755
|
+
if (!covering.length) {
|
|
1756
|
+
blocks.push({ axis: "current", need: input.throughCurrentA, limit: top.current, label: top.label });
|
|
1757
|
+
}
|
|
1758
|
+
const pool = covering.length ? covering : [top];
|
|
1759
|
+
if (octc) {
|
|
1760
|
+
let pos = input.positions;
|
|
1761
|
+
if (input.plusMinusSteps != null && input.plusMinusSteps > 0) pos = 2 * input.plusMinusSteps + 1;
|
|
1762
|
+
if (pos != null && pos > s.maxPositionsLinear) {
|
|
1763
|
+
blocks.push({ axis: "positions", need: pos, limit: s.maxPositionsLinear, label: s.code });
|
|
1764
|
+
}
|
|
1765
|
+
} else {
|
|
1766
|
+
const maxPos = input.regulation === "linear" ? s.maxPositionsLinear : s.maxPositionsWithChangeOver;
|
|
1767
|
+
if (tap.positions > maxPos) {
|
|
1768
|
+
blocks.push({ axis: "positions", need: tap.positions, limit: maxPos, label: s.code });
|
|
1769
|
+
}
|
|
1770
|
+
if (input.stepVoltageV > 0) {
|
|
1771
|
+
const ust = Math.max(
|
|
1772
|
+
...pool.map((r) => maxStepVoltageForSeries(s, tap.pitch, r.current))
|
|
1773
|
+
);
|
|
1774
|
+
if (input.stepVoltageV > ust + 0.5) {
|
|
1775
|
+
blocks.push({ axis: "ust", need: input.stepVoltageV, limit: ust, label: s.code });
|
|
1776
|
+
}
|
|
1777
|
+
const caps = pool.map((r) => ({
|
|
1778
|
+
r,
|
|
1779
|
+
kva: stepCapacityKva(s, r.current, tap.pitch, input.throughCurrentA)
|
|
1780
|
+
}));
|
|
1781
|
+
const needKva = input.throughCurrentA * input.stepVoltageV / 1e3;
|
|
1782
|
+
if (caps.every((c) => c.kva != null)) {
|
|
1783
|
+
const best = caps.reduce((a, b) => (b.kva ?? 0) > (a.kva ?? 0) ? b : a);
|
|
1784
|
+
if (needKva > (best.kva ?? 0) + 0.5) {
|
|
1785
|
+
blocks.push({ axis: "kva", need: needKva, limit: best.kva ?? 0, label: best.r.label });
|
|
1786
|
+
}
|
|
1787
|
+
}
|
|
1788
|
+
}
|
|
1789
|
+
}
|
|
1790
|
+
const worst = Math.max(0, ...blocks.map((b) => b.limit > 0 ? b.need / b.limit : Infinity));
|
|
1791
|
+
return { s, blocks, worst };
|
|
1792
|
+
}
|
|
1793
|
+
function fmtNeed(axis, v) {
|
|
1794
|
+
if (axis === "um") return String(v);
|
|
1795
|
+
if (axis === "current" && v < 100) return String(Math.round(v * 10) / 10);
|
|
1796
|
+
return String(Math.round(v));
|
|
1797
|
+
}
|
|
1798
|
+
function everyFamilyLine(b, scope, pitch) {
|
|
1799
|
+
const n = fmtNeed(b.axis, b.need);
|
|
1800
|
+
const max = fmtNeed(b.axis, b.limit);
|
|
1801
|
+
switch (b.axis) {
|
|
1802
|
+
case "um":
|
|
1803
|
+
return {
|
|
1804
|
+
en: `Um ${n} kV is above the highest ${scope.en} class (${max} kV, ${b.label}).`,
|
|
1805
|
+
zh: `Um ${n} kV \u8D85\u51FA${scope.zh}\u6700\u9AD8\u7B49\u7EA7\uFF08${max} kV\uFF0C${b.label}\uFF09\u3002`
|
|
1806
|
+
};
|
|
1807
|
+
case "current":
|
|
1808
|
+
return {
|
|
1809
|
+
en: `Through-current ${n} A is above the largest ${scope.en} rating (${max} A, ${b.label}).`,
|
|
1810
|
+
zh: `\u901A\u8FC7\u7535\u6D41 ${n} A \u8D85\u51FA${scope.zh}\u6700\u5927\u989D\u5B9A\uFF08${max} A\uFF0C${b.label}\uFF09\u3002`
|
|
1811
|
+
};
|
|
1812
|
+
case "positions":
|
|
1813
|
+
return {
|
|
1814
|
+
en: `${n} positions are above every ${scope.en} family (max ${max}, ${b.label}).`,
|
|
1815
|
+
zh: `${n} \u4E2A\u5DE5\u4F5C\u4F4D\u7F6E\u8D85\u51FA${scope.zh}\u6240\u6709\u7CFB\u5217\uFF08\u6700\u591A ${max}\uFF0C${b.label}\uFF09\u3002`
|
|
1816
|
+
};
|
|
1817
|
+
case "ust":
|
|
1818
|
+
return {
|
|
1819
|
+
en: `Step voltage ${n} V is above every ${scope.en} family at pitch ${pitch} (max ${max} V, ${b.label}).`,
|
|
1820
|
+
zh: `\u7EA7\u7535\u538B ${n} V \u8D85\u51FA\u8282\u8DDD ${pitch} \u4E0B${scope.zh}\u6240\u6709\u7CFB\u5217\uFF08\u6700\u9AD8 ${max} V\uFF0C${b.label}\uFF09\u3002`
|
|
1821
|
+
};
|
|
1822
|
+
case "kva":
|
|
1823
|
+
return {
|
|
1824
|
+
en: `Step capacity ${n} kVA is above every ${scope.en} family at pitch ${pitch} (max ${max} kVA, ${b.label}).`,
|
|
1825
|
+
zh: `\u7EA7\u5BB9\u91CF ${n} kVA \u8D85\u51FA\u8282\u8DDD ${pitch} \u4E0B${scope.zh}\u6240\u6709\u7CFB\u5217\uFF08\u6700\u5927 ${max} kVA\uFF0C${b.label}\uFF09\u3002`
|
|
1826
|
+
};
|
|
1827
|
+
}
|
|
1828
|
+
}
|
|
1829
|
+
function familyLine(code2, b, pitch) {
|
|
1830
|
+
const n = fmtNeed(b.axis, b.need);
|
|
1831
|
+
const max = fmtNeed(b.axis, b.limit);
|
|
1832
|
+
switch (b.axis) {
|
|
1833
|
+
case "um":
|
|
1834
|
+
return {
|
|
1835
|
+
en: `${code2}: Um ${n} kV is above its ${max} kV.`,
|
|
1836
|
+
zh: `${code2}\uFF1AUm ${n} kV \u8D85\u51FA\u5176 ${max} kV\u3002`
|
|
1837
|
+
};
|
|
1838
|
+
case "current":
|
|
1839
|
+
return {
|
|
1840
|
+
en: `${code2}: through-current ${n} A is above its ${max} A.`,
|
|
1841
|
+
zh: `${code2}\uFF1A\u901A\u8FC7\u7535\u6D41 ${n} A \u8D85\u51FA\u5176 ${max} A\u3002`
|
|
1842
|
+
};
|
|
1843
|
+
case "positions":
|
|
1844
|
+
return {
|
|
1845
|
+
en: `${code2}: ${n} positions are above its ${max}.`,
|
|
1846
|
+
zh: `${code2}\uFF1A${n} \u4E2A\u5DE5\u4F5C\u4F4D\u7F6E\u8D85\u51FA\u5176 ${max}\u3002`
|
|
1847
|
+
};
|
|
1848
|
+
case "ust":
|
|
1849
|
+
return {
|
|
1850
|
+
en: `${code2}: step voltage ${n} V is above its ${max} V at pitch ${pitch}.`,
|
|
1851
|
+
zh: `${code2}\uFF1A\u7EA7\u7535\u538B ${n} V \u8D85\u51FA\u5176\u8282\u8DDD ${pitch} \u4E0B\u7684 ${max} V\u3002`
|
|
1852
|
+
};
|
|
1853
|
+
case "kva":
|
|
1854
|
+
return {
|
|
1855
|
+
en: `${code2}: step capacity ${n} kVA is above its ${max} kVA at pitch ${pitch}.`,
|
|
1856
|
+
zh: `${code2}\uFF1A\u7EA7\u5BB9\u91CF ${n} kVA \u8D85\u51FA\u5176\u8282\u8DDD ${pitch} \u4E0B\u7684 ${max} kVA\u3002`
|
|
1857
|
+
};
|
|
1858
|
+
}
|
|
1859
|
+
}
|
|
1860
|
+
function noFitReasons(families, input, tap) {
|
|
1861
|
+
const misses = families.map((s) => familyMiss(s, input, tap)).filter((m) => m != null);
|
|
1862
|
+
if (!misses.length || misses.some((m) => !m.blocks.length)) return null;
|
|
1863
|
+
const pitch = tap.pitch;
|
|
1864
|
+
const en = [];
|
|
1865
|
+
const zh = [];
|
|
1866
|
+
const everywhere = LIMIT_AXES.filter(
|
|
1867
|
+
(ax) => misses.every((m) => m.blocks.some((b) => b.axis === ax))
|
|
1868
|
+
).filter((ax, _, all) => !(ax === "kva" && all.includes("current")));
|
|
1869
|
+
if (everywhere.length) {
|
|
1870
|
+
const scope = limitScope(input);
|
|
1871
|
+
for (const ax of everywhere.slice(0, 2)) {
|
|
1872
|
+
const blocks = misses.map((m) => ({ m, b: m.blocks.find((b) => b.axis === ax) })).sort((x, y) => y.b.limit - x.b.limit || x.m.s.rank - y.m.s.rank);
|
|
1873
|
+
const ceiling = blocks[0].b;
|
|
1874
|
+
const label = ax === "current" || ax === "kva" ? ceiling.label : [...new Set(blocks.filter((x) => x.b.limit === ceiling.limit).map((x) => x.m.s.code))].slice(0, 3).join("/");
|
|
1875
|
+
const line = everyFamilyLine({ ...ceiling, label }, scope, pitch);
|
|
1876
|
+
en.push(line.en);
|
|
1877
|
+
zh.push(line.zh);
|
|
1878
|
+
}
|
|
1879
|
+
return { en, zh };
|
|
1880
|
+
}
|
|
1881
|
+
const ranked = [...misses].sort(
|
|
1882
|
+
(a, b) => a.blocks.length - b.blocks.length || a.worst - b.worst || a.s.rank - b.s.rank
|
|
1883
|
+
);
|
|
1884
|
+
const ratio = (b) => b.limit > 0 ? b.need / b.limit : Infinity;
|
|
1885
|
+
const worstBlock = (m) => m.blocks.reduce((a, b) => ratio(b) > ratio(a) ? b : a);
|
|
1886
|
+
const closest = ranked[0];
|
|
1887
|
+
const bind = worstBlock(closest);
|
|
1888
|
+
const first = familyLine(closest.s.code, bind, pitch);
|
|
1889
|
+
en.push(first.en);
|
|
1890
|
+
zh.push(first.zh);
|
|
1891
|
+
const clears = ranked.find(
|
|
1892
|
+
(m) => m !== closest && !m.blocks.some((b) => b.axis === bind.axis)
|
|
1893
|
+
);
|
|
1894
|
+
if (clears) {
|
|
1895
|
+
const second = familyLine(clears.s.code, worstBlock(clears), pitch);
|
|
1896
|
+
en.push(second.en);
|
|
1897
|
+
zh.push(second.zh);
|
|
1898
|
+
}
|
|
1899
|
+
return { en, zh };
|
|
1900
|
+
}
|
|
1390
1901
|
function selectOltc(input) {
|
|
1391
1902
|
const errorsEn = [];
|
|
1392
1903
|
const errorsZh = [];
|
|
@@ -1402,9 +1913,36 @@ function selectOltc(input) {
|
|
|
1402
1913
|
errorsEn.push("Step voltage must be a number \u2265 0 (0 = not given).");
|
|
1403
1914
|
errorsZh.push("\u7EA7\u7535\u538B\u987B\u4E3A \u2265 0 \u7684\u6570\u5B57\uFF080 \u8868\u793A\u672A\u7ED9\uFF09\u3002");
|
|
1404
1915
|
}
|
|
1916
|
+
if (input.positions != null && !(Number.isInteger(input.positions) && input.positions >= 2)) {
|
|
1917
|
+
errorsEn.push("Positions must be a whole number of at least 2.");
|
|
1918
|
+
errorsZh.push("\u6863\u4F4D\u6570\u987B\u4E3A\u4E0D\u5C0F\u4E8E 2 \u7684\u6574\u6570\u3002");
|
|
1919
|
+
}
|
|
1920
|
+
for (const [name, v] of [
|
|
1921
|
+
["Across-tap LI", input.acrossTapBilKv],
|
|
1922
|
+
["Across-tap AC", input.acrossTapPfKv],
|
|
1923
|
+
["Earth LI", input.bilKv],
|
|
1924
|
+
["Earth AC", input.pfKv]
|
|
1925
|
+
]) {
|
|
1926
|
+
if (v != null && !(Number.isFinite(v) && v >= 0)) {
|
|
1927
|
+
errorsEn.push(`${name} must be a number \u2265 0 (kV).`);
|
|
1928
|
+
errorsZh.push(`${name} \u987B\u4E3A \u2265 0 \u7684\u6570\u5B57\uFF08kV\uFF09\u3002`);
|
|
1929
|
+
}
|
|
1930
|
+
}
|
|
1931
|
+
if (input.plusMinusSteps != null && !(Number.isInteger(input.plusMinusSteps) && input.plusMinusSteps >= 1)) {
|
|
1932
|
+
errorsEn.push("\xB1 steps must be a whole number of at least 1.");
|
|
1933
|
+
errorsZh.push("\xB1 \u7EA7\u6570\u987B\u4E3A\u4E0D\u5C0F\u4E8E 1 \u7684\u6574\u6570\u3002");
|
|
1934
|
+
}
|
|
1405
1935
|
if (errorsEn.length) {
|
|
1406
1936
|
return { ok: false, results: [], errorsEn, errorsZh };
|
|
1407
1937
|
}
|
|
1938
|
+
if (input.dutyKind === "octc" || input.mounting === "reactor") {
|
|
1939
|
+
input = {
|
|
1940
|
+
...input,
|
|
1941
|
+
medium: "oil",
|
|
1942
|
+
preferVacuum: false,
|
|
1943
|
+
...input.dutyKind === "octc" ? { octcSeries: input.octcSeries ?? "auto" } : {}
|
|
1944
|
+
};
|
|
1945
|
+
}
|
|
1408
1946
|
if ((input.bilKv ?? 0) > 0 || (input.pfKv ?? 0) > 0) {
|
|
1409
1947
|
const earthUm = umForEarthInsulation(input.umKv, input.bilKv, input.pfKv);
|
|
1410
1948
|
if (earthUm == null) {
|
|
@@ -1421,7 +1959,7 @@ function selectOltc(input) {
|
|
|
1421
1959
|
}
|
|
1422
1960
|
if (earthUm > input.umKv + 0.01) input = { ...input, umKv: earthUm };
|
|
1423
1961
|
}
|
|
1424
|
-
const
|
|
1962
|
+
const baseTap = resolveTapFields({
|
|
1425
1963
|
regulation: input.regulation,
|
|
1426
1964
|
positions: input.positions,
|
|
1427
1965
|
plusMinusSteps: input.plusMinusSteps,
|
|
@@ -1437,17 +1975,21 @@ function selectOltc(input) {
|
|
|
1437
1975
|
if (input.connection === "any") return true;
|
|
1438
1976
|
return s.connections.includes(input.connection) || s.connections.includes("any");
|
|
1439
1977
|
});
|
|
1978
|
+
candidates = candidates.filter(
|
|
1979
|
+
(s) => s.id !== "wsg" || ["auto", "II", "IV", "V"].includes(input.octcSeries ?? "auto")
|
|
1980
|
+
);
|
|
1440
1981
|
const wantStruct = input.preferStructure;
|
|
1441
|
-
|
|
1982
|
+
const autoKind = input.transformerKind === "auto";
|
|
1983
|
+
if ((autoKind || input.combinedOnly) && !wantOctc) {
|
|
1442
1984
|
if (wantStruct === "compound") {
|
|
1443
1985
|
return {
|
|
1444
1986
|
ok: false,
|
|
1445
1987
|
results: [],
|
|
1446
1988
|
errorsEn: [
|
|
1447
|
-
"Autotransformers take combined types only: compound types (CV/CV2/SV) stop at 200 kV across the tap winding."
|
|
1989
|
+
autoKind ? "Autotransformers take combined types only: compound types (CV/CV2/SV) stop at 200 kV across the tap winding." : "Tapped windings of 220 kV class and above take combined types only: compound types (CV/CV2/SV) stop at 200 kV across the tap winding."
|
|
1448
1990
|
],
|
|
1449
1991
|
errorsZh: [
|
|
1450
|
-
"\u81EA\u8026\u53D8\u53EA\u7528\u7EC4\u5408\u5F0F\uFF1A\u590D\u5408\u5F0F\uFF08CV/CV2/SV\uFF09\u8DE8\u8C03\u538B\u7ED5\u7EC4\u51B2\u51FB\u4E0A\u9650 200 kV\u3002"
|
|
1992
|
+
autoKind ? "\u81EA\u8026\u53D8\u53EA\u7528\u7EC4\u5408\u5F0F\uFF1A\u590D\u5408\u5F0F\uFF08CV/CV2/SV\uFF09\u8DE8\u8C03\u538B\u7ED5\u7EC4\u51B2\u51FB\u4E0A\u9650 200 kV\u3002" : "220 kV \u7EA7\u53CA\u4EE5\u4E0A\u8C03\u538B\u7ED5\u7EC4\u53EA\u7528\u7EC4\u5408\u5F0F\uFF1A\u590D\u5408\u5F0F\uFF08CV/CV2/SV\uFF09\u8DE8\u8C03\u538B\u7ED5\u7EC4\u51B2\u51FB\u4E0A\u9650 200 kV\u3002"
|
|
1451
1993
|
]
|
|
1452
1994
|
};
|
|
1453
1995
|
}
|
|
@@ -1471,287 +2013,429 @@ function selectOltc(input) {
|
|
|
1471
2013
|
const results = [];
|
|
1472
2014
|
const seen = /* @__PURE__ */ new Set();
|
|
1473
2015
|
let acrossTapShort = false;
|
|
1474
|
-
|
|
1475
|
-
|
|
1476
|
-
|
|
1477
|
-
|
|
1478
|
-
}
|
|
1479
|
-
|
|
1480
|
-
|
|
1481
|
-
|
|
1482
|
-
|
|
1483
|
-
|
|
1484
|
-
|
|
1485
|
-
|
|
1486
|
-
|
|
1487
|
-
|
|
1488
|
-
|
|
1489
|
-
if (
|
|
1490
|
-
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
const need = input.stepVoltageV > 0 ? input.throughCurrentA * input.stepVoltageV / 1e3 : 0;
|
|
1494
|
-
const capacityOk = (c) => {
|
|
1495
|
-
const psin = s.stepCapacityByCurrent?.[c];
|
|
1496
|
-
if (psin != null && need > psin + 0.5) return false;
|
|
1497
|
-
return true;
|
|
1498
|
-
};
|
|
1499
|
-
const covering = phaseCurrents.filter(
|
|
1500
|
-
(c) => ratingCoversDuty(input.throughCurrentA, c) && capacityOk(c)
|
|
1501
|
-
);
|
|
1502
|
-
if (!covering.length) continue;
|
|
1503
|
-
const currentsToEmit = covering.slice(0, 2);
|
|
1504
|
-
const topEmitted = Math.max(...currentsToEmit);
|
|
1505
|
-
const stepUpCurrent = [...phaseCurrents].sort((a, b) => a - b).find(
|
|
1506
|
-
(c) => c > topEmitted + 0.5 && ratingCoversDuty(input.throughCurrentA, c) && capacityOk(c)
|
|
1507
|
-
);
|
|
1508
|
-
if (stepUpCurrent != null && !currentsToEmit.includes(stepUpCurrent)) {
|
|
1509
|
-
currentsToEmit.push(stepUpCurrent);
|
|
2016
|
+
const trRaised = /* @__PURE__ */ new Map();
|
|
2017
|
+
const octcWidePass = wantOctc && (wantStruct ?? "auto") === "auto";
|
|
2018
|
+
const passes = !wantOctc ? [{ wide: false, all: false }] : octcWidePass ? [
|
|
2019
|
+
{ wide: false, all: false },
|
|
2020
|
+
{ wide: true, all: false },
|
|
2021
|
+
{ wide: false, all: true },
|
|
2022
|
+
{ wide: true, all: true }
|
|
2023
|
+
] : [
|
|
2024
|
+
{ wide: false, all: false },
|
|
2025
|
+
{ wide: false, all: true }
|
|
2026
|
+
];
|
|
2027
|
+
for (const { wide, all } of passes) {
|
|
2028
|
+
if ((wide || all) && results.length) break;
|
|
2029
|
+
for (const s of candidates) {
|
|
2030
|
+
const tap = isOctcSeries(s) ? baseTap : seriesTap(s, baseTap, input.regulation);
|
|
2031
|
+
if (!tap) continue;
|
|
2032
|
+
if (!compoundCoversAcrossTap(s, input)) {
|
|
2033
|
+
acrossTapShort = true;
|
|
2034
|
+
continue;
|
|
1510
2035
|
}
|
|
1511
|
-
|
|
1512
|
-
const
|
|
1513
|
-
|
|
1514
|
-
const
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
|
|
1518
|
-
|
|
1519
|
-
|
|
1520
|
-
if (gradePick && gradePick.size == null) {
|
|
1521
|
-
acrossTapShort = true;
|
|
1522
|
-
continue;
|
|
1523
|
-
}
|
|
1524
|
-
const selectorSize = octc ? octcSizeLetter(att.um, contact, input.selectorSize ?? "auto") : gradePick?.size ?? "";
|
|
1525
|
-
const tapCode = octc ? contact : tap.tapCode;
|
|
1526
|
-
const modelTap = octc ? `${contact}${selectorSize}` : s.id === "cz" || s.id === "hwdk" ? String(tap.positions) : tap.tapCode;
|
|
1527
|
-
const umToken = formatUmToken(att.um, selectorSize, s.usesSelectorSize);
|
|
1528
|
-
const phases = phaseToken(att.phases);
|
|
1529
|
-
const conn = input.connection === "any" ? s.connections.includes("Y") ? "Y" : s.connections[0] : input.connection;
|
|
1530
|
-
let mduStr = "";
|
|
1531
|
-
const mduPref = input.mdu ?? "none";
|
|
1532
|
-
if (mduPref && mduPref !== "none" && mduPref !== "auto") {
|
|
1533
|
-
mduStr = mduPref;
|
|
1534
|
-
} else if (mduPref === "auto") {
|
|
1535
|
-
mduStr = s.defaultMdu;
|
|
1536
|
-
}
|
|
1537
|
-
const modelConn = connectionLetterOnPhase(
|
|
1538
|
-
s,
|
|
1539
|
-
att.phases,
|
|
1540
|
-
conn
|
|
1541
|
-
);
|
|
1542
|
-
let finalModel = buildModelString(
|
|
1543
|
-
s,
|
|
1544
|
-
phases,
|
|
1545
|
-
current,
|
|
1546
|
-
modelConn,
|
|
1547
|
-
umToken,
|
|
1548
|
-
modelTap,
|
|
1549
|
-
att.unitCount,
|
|
1550
|
-
input.octcSeries
|
|
1551
|
-
);
|
|
1552
|
-
if (att.phases === "I") {
|
|
1553
|
-
finalModel = finalModel.replace(
|
|
1554
|
-
new RegExp(`(${s.code}I-\\d+)[YD]/`),
|
|
1555
|
-
"$1/"
|
|
1556
|
-
);
|
|
1557
|
-
} else if (att.phases === "II" && modelConn === "any") {
|
|
1558
|
-
finalModel = finalModel.replace(
|
|
1559
|
-
new RegExp(`(${s.code}II-\\d+)[YD]/`),
|
|
1560
|
-
"$1/"
|
|
1561
|
-
);
|
|
1562
|
-
}
|
|
1563
|
-
if (octc) {
|
|
1564
|
-
const listed = resolveOctcListModel(finalModel);
|
|
1565
|
-
if (!listed) continue;
|
|
1566
|
-
finalModel = listed;
|
|
1567
|
-
} else if (!commercialTypeExists(finalModel, s)) {
|
|
1568
|
-
continue;
|
|
1569
|
-
}
|
|
1570
|
-
if (seen.has(finalModel)) continue;
|
|
1571
|
-
seen.add(finalModel);
|
|
1572
|
-
const modelWithMdu = mduStr ? `${finalModel}+${mduStr}` : finalModel;
|
|
1573
|
-
const score = adequacyScore(s, input, current, att.um, att.unitCount);
|
|
1574
|
-
const reasonsEn = [];
|
|
1575
|
-
const reasonsZh = [];
|
|
1576
|
-
const warningsEn = [];
|
|
1577
|
-
const warningsZh = [];
|
|
1578
|
-
const cautionsEn = [];
|
|
1579
|
-
const cautionsZh = [];
|
|
1580
|
-
if (input.throughCurrentA > current + 0.01) {
|
|
1581
|
-
const pct = ((input.throughCurrentA / current - 1) * 100).toFixed(1);
|
|
1582
|
-
cautionsEn.push(
|
|
1583
|
-
`Duty ${input.throughCurrentA.toFixed(1)} A is ${pct}% above the ${current} A rating (1% commercial tolerance). Confirm with engineering.`
|
|
1584
|
-
);
|
|
1585
|
-
cautionsZh.push(
|
|
1586
|
-
`\u9700\u6C42 ${input.throughCurrentA.toFixed(1)} A \u8D85\u51FA\u989D\u5B9A ${current} A \u7684 ${pct}%\uFF08\u6309 1% \u5546\u52A1\u5BB9\u5DEE\u653E\u884C\uFF09\uFF0C\u987B\u5DE5\u7A0B\u786E\u8BA4\u3002`
|
|
1587
|
-
);
|
|
2036
|
+
if (!isOctcSeries(s)) {
|
|
2037
|
+
const pitchMaxUst = maxStepVoltageForSeries(s, tap.pitch);
|
|
2038
|
+
if (input.stepVoltageV > pitchMaxUst + 0.5) continue;
|
|
2039
|
+
const maxPos = input.regulation === "linear" ? s.maxPositionsLinear : s.maxPositionsWithChangeOver;
|
|
2040
|
+
if (tap.positions > maxPos) continue;
|
|
2041
|
+
} else {
|
|
2042
|
+
let octcPos = input.positions;
|
|
2043
|
+
if (input.plusMinusSteps != null && input.plusMinusSteps > 0) {
|
|
2044
|
+
octcPos = 2 * input.plusMinusSteps + 1;
|
|
1588
2045
|
}
|
|
1589
|
-
if (
|
|
1590
|
-
|
|
1591
|
-
|
|
1592
|
-
|
|
1593
|
-
|
|
1594
|
-
|
|
1595
|
-
|
|
1596
|
-
|
|
1597
|
-
|
|
1598
|
-
|
|
1599
|
-
|
|
1600
|
-
|
|
1601
|
-
)
|
|
1602
|
-
}
|
|
1603
|
-
if (gradePick?.raisedFrom) {
|
|
1604
|
-
cautionsEn.push(
|
|
1605
|
-
`Selector grade raised from ${gradePick.raisedFrom} to ${selectorSize} (Um ${att.um} kV / across-tap stress).`
|
|
1606
|
-
);
|
|
1607
|
-
cautionsZh.push(
|
|
1608
|
-
`\u9009\u62E9\u5668\u7B49\u7EA7\u5DF2\u7531 ${gradePick.raisedFrom} \u5347\u4E3A ${selectorSize}\uFF08Um ${att.um} kV \u6216\u8C03\u538B\u7ED5\u7EC4\u95F4\u7EDD\u7F18\u8981\u6C42\uFF09\u3002`
|
|
1609
|
-
);
|
|
1610
|
-
}
|
|
1611
|
-
if (!octc && !s.usesSelectorSize && s.structure !== "compound" && ((input.acrossTapBilKv ?? 0) > 0 || (input.acrossTapPfKv ?? 0) > 0)) {
|
|
1612
|
-
cautionsEn.push(
|
|
1613
|
-
`${s.code} across-tap withstand is not in the catalogue data: across-tap stress not checked.`
|
|
1614
|
-
);
|
|
1615
|
-
cautionsZh.push(
|
|
1616
|
-
`${s.code} \u8C03\u538B\u7ED5\u7EC4\u95F4\u8010\u53D7\u4E0D\u5728\u76EE\u5F55\u6570\u636E\u91CC\uFF1A\u8C03\u538B\u7ED5\u7EC4\u95F4\u7EDD\u7F18\u672A\u6821\u9A8C\u3002`
|
|
1617
|
-
);
|
|
1618
|
-
}
|
|
1619
|
-
const dutyA = input.throughCurrentA >= 100 ? String(Math.round(input.throughCurrentA)) : String(Math.round(input.throughCurrentA * 10) / 10);
|
|
1620
|
-
reasonsEn.push(
|
|
1621
|
-
`Minimum-adequate path: ${s.nameEn}, Ium ${current} A \u2265 ${dutyA} A, Um ${att.um} kV.`
|
|
2046
|
+
if (octcPos != null && octcPos > s.maxPositionsLinear) continue;
|
|
2047
|
+
}
|
|
2048
|
+
for (const att of buildAttempts(s, input, wide)) {
|
|
2049
|
+
const phaseCurrents = s.currents[att.phases] ?? s.currents.I ?? [];
|
|
2050
|
+
const need = input.stepVoltageV > 0 ? input.throughCurrentA * input.stepVoltageV / 1e3 : 0;
|
|
2051
|
+
const capacityOk = (c) => {
|
|
2052
|
+
const psin = stepCapacityKva(s, c, tap.pitch, input.throughCurrentA);
|
|
2053
|
+
if (psin != null && need > psin + 0.5) return false;
|
|
2054
|
+
if (input.stepVoltageV > maxStepVoltageForSeries(s, tap.pitch, c) + 0.5) return false;
|
|
2055
|
+
return true;
|
|
2056
|
+
};
|
|
2057
|
+
const covering = phaseCurrents.filter(
|
|
2058
|
+
(c) => ratingCoversDuty(input.throughCurrentA, c) && capacityOk(c)
|
|
1622
2059
|
);
|
|
1623
|
-
|
|
1624
|
-
|
|
2060
|
+
if (!covering.length) continue;
|
|
2061
|
+
const listGated = isOctcSeries(s) && all;
|
|
2062
|
+
let listRowsEmitted = 0;
|
|
2063
|
+
const currentsToEmit = listGated ? [...covering] : covering.slice(0, 2);
|
|
2064
|
+
const topEmitted = Math.max(...currentsToEmit);
|
|
2065
|
+
const stepUpCurrent = [...phaseCurrents].sort((a, b) => a - b).find(
|
|
2066
|
+
(c) => c > topEmitted + 0.5 && ratingCoversDuty(input.throughCurrentA, c) && capacityOk(c)
|
|
1625
2067
|
);
|
|
1626
|
-
if (
|
|
1627
|
-
|
|
1628
|
-
"Compound type fits duty \u2014 preferred over larger combined types when eligible."
|
|
1629
|
-
);
|
|
1630
|
-
reasonsZh.push(
|
|
1631
|
-
"\u590D\u5408\u5F0F\u6EE1\u8DB3\u5DE5\u51B5\u65F6\u4F18\u5148\u4E8E\u66F4\u5927\u7684\u7EC4\u5408\u5F0F\uFF08\u975E\u9ED8\u8BA4 SHZV\uFF09\u3002"
|
|
1632
|
-
);
|
|
2068
|
+
if (stepUpCurrent != null && !currentsToEmit.includes(stepUpCurrent)) {
|
|
2069
|
+
currentsToEmit.push(stepUpCurrent);
|
|
1633
2070
|
}
|
|
1634
|
-
|
|
1635
|
-
|
|
1636
|
-
|
|
1637
|
-
);
|
|
1638
|
-
|
|
1639
|
-
|
|
1640
|
-
)
|
|
1641
|
-
|
|
1642
|
-
|
|
1643
|
-
|
|
1644
|
-
|
|
1645
|
-
|
|
1646
|
-
|
|
1647
|
-
|
|
1648
|
-
|
|
2071
|
+
for (const current of currentsToEmit) {
|
|
2072
|
+
if (listGated && listRowsEmitted >= 3) break;
|
|
2073
|
+
const octc = isOctcSeries(s);
|
|
2074
|
+
const contact = octc ? octcContactCode(input, s.id) : "";
|
|
2075
|
+
if (octc && !contact) continue;
|
|
2076
|
+
const umDefault = defaultSelectorSizeForUm(att.um);
|
|
2077
|
+
const classBump = !octc && s.usesSelectorSize && input.transformerKind !== "auto" && (input.tapWindingKv ?? 0) >= 330 && att.um <= 126 + 0.1 && // One stated value alone does not settle the grade (ENGINE-1).
|
|
2078
|
+
!((input.acrossTapBilKv ?? 0) > 0 && (input.acrossTapPfKv ?? 0) > 0) ? SIZE_ORDER[SIZE_ORDER.indexOf(umDefault) + 1] : void 0;
|
|
2079
|
+
const trBump = !octc && !classBump && s.usesSelectorSize && (input.market ?? "").trim().toUpperCase() === "TR" && input.connection === "Y" && input.transformerKind !== "auto" && (input.tapWindingKv ?? 0) >= 110 && att.um <= 72.5 + 0.1 && !((input.acrossTapBilKv ?? 0) > 0 && (input.acrossTapPfKv ?? 0) > 0) && // 2026-11-04 final ENGINE-11: one stated value above what B withstands
|
|
2080
|
+
// (LI 350 > 265) sets C from the stress, not from practice: no
|
|
2081
|
+
// "B also fits" caution and no B copy.
|
|
2082
|
+
coversAcrossTap(umDefault, input.acrossTapBilKv ?? 0, input.acrossTapPfKv ?? 0, s.id) ? SIZE_ORDER[SIZE_ORDER.indexOf(umDefault) + 1] : void 0;
|
|
2083
|
+
const gradePick = !octc && s.usesSelectorSize ? resolveSelectorSize(
|
|
2084
|
+
att.um,
|
|
2085
|
+
input.selectorSize ?? "auto",
|
|
2086
|
+
input.acrossTapBilKv,
|
|
2087
|
+
input.acrossTapPfKv,
|
|
2088
|
+
s.id,
|
|
2089
|
+
// Only a, not b, is checked: the stated stress may lower the
|
|
2090
|
+
// grade where no phase-to-phase gap matters (2026-11-04 GRADE-2).
|
|
2091
|
+
att.phases === "I" || att.phases === "III" && input.connection === "Y",
|
|
2092
|
+
classBump ?? trBump
|
|
2093
|
+
) : null;
|
|
2094
|
+
if (gradePick && gradePick.size == null) {
|
|
2095
|
+
acrossTapShort = true;
|
|
2096
|
+
continue;
|
|
2097
|
+
}
|
|
2098
|
+
let selectorSize = octc ? octcSizeLetter(
|
|
2099
|
+
att.um,
|
|
2100
|
+
contact,
|
|
2101
|
+
input.selectorSize ?? "auto",
|
|
2102
|
+
(input.acrossTapBilKv ?? 0) > 0 || (input.acrossTapPfKv ?? 0) > 0
|
|
2103
|
+
) : gradePick?.size ?? "";
|
|
2104
|
+
const tapCode = octc ? contact : tap.tapCode;
|
|
2105
|
+
const modelTap = octc ? `${contact}${selectorSize}` : s.id === "cz" ? String(tap.positions) : s.id === "hwdk" ? String(
|
|
2106
|
+
input.plusMinusSteps != null && input.plusMinusSteps > 0 ? 2 * input.plusMinusSteps + 1 : tap.positions
|
|
2107
|
+
) : s.id === "cvt" ? `09${String(tap.positions).padStart(2, "0")}` : tap.tapCode;
|
|
2108
|
+
const umToken = formatUmToken(att.um, selectorSize, s.usesSelectorSize);
|
|
2109
|
+
const phases = phaseToken(att.phases);
|
|
2110
|
+
const conn = input.connection === "any" ? s.connections.includes("Y") ? "Y" : s.connections[0] : input.connection;
|
|
2111
|
+
let mduStr = "";
|
|
2112
|
+
const mduPref = input.mdu ?? "none";
|
|
2113
|
+
if (mduPref && mduPref !== "none" && mduPref !== "auto") {
|
|
2114
|
+
mduStr = mduPref;
|
|
2115
|
+
} else if (mduPref === "auto") {
|
|
2116
|
+
mduStr = s.defaultMdu;
|
|
2117
|
+
}
|
|
2118
|
+
const modelConn = connectionLetterOnPhase(
|
|
2119
|
+
s,
|
|
2120
|
+
att.phases,
|
|
2121
|
+
conn
|
|
1649
2122
|
);
|
|
1650
|
-
|
|
1651
|
-
|
|
1652
|
-
|
|
2123
|
+
let finalModel = buildModelString(
|
|
2124
|
+
s,
|
|
2125
|
+
phases,
|
|
2126
|
+
current,
|
|
2127
|
+
modelConn,
|
|
2128
|
+
umToken,
|
|
2129
|
+
modelTap,
|
|
2130
|
+
att.unitCount,
|
|
2131
|
+
input.octcSeries
|
|
1653
2132
|
);
|
|
1654
|
-
|
|
1655
|
-
|
|
2133
|
+
if (att.phases === "I") {
|
|
2134
|
+
finalModel = finalModel.replace(
|
|
2135
|
+
new RegExp(`(${s.code}I-\\d+)[YD]/`),
|
|
2136
|
+
"$1/"
|
|
2137
|
+
);
|
|
2138
|
+
} else if (att.phases === "II" && modelConn === "any") {
|
|
2139
|
+
finalModel = finalModel.replace(
|
|
2140
|
+
new RegExp(`(${s.code}II-\\d+)[YD]/`),
|
|
2141
|
+
"$1/"
|
|
2142
|
+
);
|
|
2143
|
+
}
|
|
2144
|
+
if (octc) {
|
|
2145
|
+
const listed = resolveOctcListModel(finalModel);
|
|
2146
|
+
if (!listed) continue;
|
|
2147
|
+
finalModel = listed;
|
|
2148
|
+
const listedSize = parseTypeString(listed)?.selectorSize;
|
|
2149
|
+
if (listedSize) selectorSize = listedSize;
|
|
2150
|
+
} else if (!commercialTypeExists(finalModel, s)) {
|
|
2151
|
+
continue;
|
|
2152
|
+
}
|
|
2153
|
+
if (seen.has(finalModel)) continue;
|
|
2154
|
+
seen.add(finalModel);
|
|
2155
|
+
listRowsEmitted += 1;
|
|
2156
|
+
const modelWithMdu = mduStr ? `${finalModel}+${mduStr}` : finalModel;
|
|
2157
|
+
const score = adequacyScore(
|
|
2158
|
+
s,
|
|
2159
|
+
input,
|
|
2160
|
+
current,
|
|
2161
|
+
att.um,
|
|
2162
|
+
rankUnits(s.id, att.unitCount),
|
|
2163
|
+
tap.pitch
|
|
1656
2164
|
);
|
|
1657
|
-
|
|
1658
|
-
|
|
1659
|
-
|
|
1660
|
-
|
|
1661
|
-
|
|
2165
|
+
const reasonsEn = [];
|
|
2166
|
+
const reasonsZh = [];
|
|
2167
|
+
const warningsEn = [];
|
|
2168
|
+
const warningsZh = [];
|
|
2169
|
+
const cautionsEn = [];
|
|
2170
|
+
const cautionsZh = [];
|
|
2171
|
+
if (!octc && !(input.stepVoltageV > 0)) {
|
|
2172
|
+
cautionsEn.push(
|
|
2173
|
+
"Step voltage not given: step-voltage and step-capacity limits were not checked."
|
|
1662
2174
|
);
|
|
1663
|
-
|
|
1664
|
-
|
|
2175
|
+
cautionsZh.push("\u672A\u7ED9\u7EA7\u7535\u538B\uFF1A\u7EA7\u7535\u538B\u548C\u7EA7\u5BB9\u91CF\u90FD\u6CA1\u6709\u6821\u9A8C\u3002");
|
|
2176
|
+
}
|
|
2177
|
+
if (!octc && !tap.standard) {
|
|
2178
|
+
cautionsEn.push(
|
|
2179
|
+
`Tap code ${tap.tapCode} is not a brochure Fig. 3-3 diagram. Engineering must confirm the connection.`
|
|
1665
2180
|
);
|
|
1666
|
-
|
|
1667
|
-
|
|
1668
|
-
`${att.unitCount}\xD7 single-phase \u2014 no single III unit covers this I\u1D64 (prefer one SHZV/SHZVG when it fits; 3\xD7 costs more).`
|
|
2181
|
+
cautionsZh.push(
|
|
2182
|
+
`\u5206\u63A5\u4EE3\u7801 ${tap.tapCode} \u4E0D\u5728\u6837\u672C\u56FE 3-3 \u6807\u51C6\u63A5\u7EBF\u5185\uFF0C\u987B\u5DE5\u7A0B\u786E\u8BA4\u63A5\u7EBF\u3002`
|
|
1669
2183
|
);
|
|
1670
|
-
|
|
1671
|
-
|
|
2184
|
+
}
|
|
2185
|
+
if (s.id === "cvt" && input.regulation !== "linear") {
|
|
2186
|
+
cautionsEn.push("CVT is a linear-regulation type (brochure). Engineering must confirm it for this range.");
|
|
2187
|
+
cautionsZh.push("CVT \u6837\u672C\u53EA\u6709\u7EBF\u6027\u8C03\uFF0C\u6B64\u8C03\u538B\u8303\u56F4\u8BF7\u5DE5\u7A0B\u786E\u8BA4\u3002");
|
|
2188
|
+
}
|
|
2189
|
+
if (!octc) {
|
|
2190
|
+
const review = [];
|
|
2191
|
+
const reviewZh = [];
|
|
2192
|
+
if (s.id === "cm2" && input.stepVoltageV > 2500 + 0.5) {
|
|
2193
|
+
review.push("CM2 step voltage above 2500 V");
|
|
2194
|
+
reviewZh.push("CM2 \u7EA7\u7535\u538B\u8D85\u8FC7 2500 V");
|
|
2195
|
+
}
|
|
2196
|
+
if (s.id === "shzv" && input.stepVoltageV > 3300 + 0.5) {
|
|
2197
|
+
review.push("SHZV step voltage above 3300 V");
|
|
2198
|
+
reviewZh.push("SHZV \u7EA7\u7535\u538B\u8D85\u8FC7 3300 V");
|
|
2199
|
+
}
|
|
2200
|
+
if (selectorSize === "DE" || selectorSize === "E") {
|
|
2201
|
+
review.push(`selector grade ${selectorSize}`);
|
|
2202
|
+
reviewZh.push(`\u9009\u62E9\u5668 ${selectorSize} \u7EA7`);
|
|
2203
|
+
}
|
|
2204
|
+
if (att.um >= 300) {
|
|
2205
|
+
review.push(`Um ${att.um} kV`);
|
|
2206
|
+
reviewZh.push(`Um ${att.um} kV`);
|
|
2207
|
+
}
|
|
2208
|
+
if (review.length) {
|
|
2209
|
+
cautionsEn.push(`Needs the maker's technical review: ${review.join(", ")}.`);
|
|
2210
|
+
cautionsZh.push(`\u987B\u5382\u5BB6\u6280\u672F\u7279\u522B\u8BC4\u5BA1\uFF1A${reviewZh.join("\uFF0C")}\u3002`);
|
|
2211
|
+
}
|
|
2212
|
+
if (tap.changeOver !== "0" && input.transformerKind !== "auto" && (input.tapWindingKv ?? 0) > 121) {
|
|
2213
|
+
cautionsEn.push(
|
|
2214
|
+
"Change-over selector above 110 kV: check the recovery voltage and quote the tie-in resistor as an option (maker's Cw/Ce needed)."
|
|
2215
|
+
);
|
|
2216
|
+
cautionsZh.push("110 kV \u4EE5\u4E0A\u7684\u6B63\u53CD\u8C03/\u7C97\u7EC6\u8C03\uFF1A\u8981\u6838\u6062\u590D\u7535\u538B\uFF0C\u53EF\u80FD\u8981\u52A0\u7535\u4F4D\u7535\u963B\u3002\u8BF7\u53D8\u538B\u5668\u5382\u63D0\u4F9B Cw\u3001Ce\uFF0C\u62A5\u4EF7\u65F6\u628A\u7535\u4F4D\u7535\u963B\u5217\u4E3A\u53EF\u9009\u9879\u3002");
|
|
2217
|
+
}
|
|
2218
|
+
}
|
|
2219
|
+
if (wide) {
|
|
2220
|
+
const from = nearestUm(input.umKv, s.umKv);
|
|
2221
|
+
if (from != null && att.um > from + 0.1) {
|
|
2222
|
+
cautionsEn.push(`No ${from} kV list row covers this duty: next class ${att.um} kV.`);
|
|
2223
|
+
cautionsZh.push(`${from} kV \u4EF7\u76EE\u8868\u6CA1\u6709\u6EE1\u8DB3\u6B64\u5DE5\u51B5\u7684\u578B\u53F7\uFF1A\u4E0A\u9760\u81F3 ${att.um} kV\u3002`);
|
|
2224
|
+
}
|
|
2225
|
+
}
|
|
2226
|
+
if (gradePick?.raisedFrom) {
|
|
2227
|
+
cautionsEn.push(
|
|
2228
|
+
`Selector grade raised from ${gradePick.raisedFrom} to ${selectorSize} (Um ${att.um} kV / across-tap stress).`
|
|
2229
|
+
);
|
|
2230
|
+
cautionsZh.push(
|
|
2231
|
+
`\u9009\u62E9\u5668\u7B49\u7EA7\u5DF2\u7531 ${gradePick.raisedFrom} \u5347\u4E3A ${selectorSize}\uFF08Um ${att.um} kV \u6216\u8C03\u538B\u7ED5\u7EC4\u95F4\u7EDD\u7F18\u8981\u6C42\uFF09\u3002`
|
|
1672
2232
|
);
|
|
1673
2233
|
}
|
|
1674
|
-
|
|
1675
|
-
|
|
1676
|
-
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
|
|
1681
|
-
|
|
1682
|
-
|
|
1683
|
-
|
|
1684
|
-
|
|
1685
|
-
|
|
1686
|
-
|
|
1687
|
-
|
|
1688
|
-
|
|
1689
|
-
|
|
1690
|
-
|
|
2234
|
+
const gradeAuto = !gradePick?.raisedFrom && (input.selectorSize ?? "auto") === "auto";
|
|
2235
|
+
if (gradeAuto && classBump && selectorSize === classBump) {
|
|
2236
|
+
cautionsEn.push(
|
|
2237
|
+
`Selector grade raised one step to ${selectorSize}: winding of 330 kV class or above.`
|
|
2238
|
+
);
|
|
2239
|
+
cautionsZh.push(`\u9009\u62E9\u5668\u7B49\u7EA7\u4E0A\u8C03\u4E00\u7EA7\u4E3A ${selectorSize}\uFF1A330 kV \u7EA7\u53CA\u4EE5\u4E0A\u7ED5\u7EC4\u3002`);
|
|
2240
|
+
} else if (gradeAuto && classBump && ((input.acrossTapBilKv ?? 0) > 0 || (input.acrossTapPfKv ?? 0) > 0) && SIZE_ORDER.indexOf(selectorSize) > SIZE_ORDER.indexOf(classBump)) {
|
|
2241
|
+
const li = input.acrossTapBilKv ?? 0;
|
|
2242
|
+
const ac = input.acrossTapPfKv ?? 0;
|
|
2243
|
+
const en = [li > 0 ? `LI ${li}` : "", ac > 0 ? `AC ${ac}` : ""].filter(Boolean).join(" / ");
|
|
2244
|
+
const zh = [li > 0 ? `\u96F7\u7535 ${li}` : "", ac > 0 ? `\u5DE5\u9891 ${ac}` : ""].filter(Boolean).join(" / ");
|
|
2245
|
+
cautionsEn.push(
|
|
2246
|
+
`Selector grade ${selectorSize} from the stated across-tap ${en} kV (330 kV-class step gives ${classBump}).`
|
|
2247
|
+
);
|
|
2248
|
+
cautionsZh.push(`\u9009\u62E9\u5668\u7B49\u7EA7 ${selectorSize} \u4F9D\u636E\u7ED9\u5B9A\u7684\u8C03\u538B\u7ED5\u7EC4\u95F4 ${zh} kV\uFF08330 kV \u7EA7\u4E0A\u8C03\u4E3A ${classBump}\uFF09\u3002`);
|
|
2249
|
+
}
|
|
2250
|
+
const trRaise = gradeAuto && trBump != null && selectorSize === trBump;
|
|
2251
|
+
if (trRaise) {
|
|
2252
|
+
cautionsEn.push(
|
|
2253
|
+
`Selector grade raised to ${selectorSize}: ${selectorSize} is usual on Turkish 110 kV-class neutrals (${umDefault} also fits).`
|
|
2254
|
+
);
|
|
2255
|
+
cautionsZh.push(
|
|
2256
|
+
`\u9009\u62E9\u5668\u7B49\u7EA7\u4E0A\u8C03\u4E3A ${selectorSize}\uFF1A\u571F\u8033\u5176 110 kV \u7EA7\u4E2D\u6027\u70B9\u901A\u5E38\u53D6 ${selectorSize}\uFF08${umDefault} \u4E5F\u6EE1\u8DB3\uFF09\u3002`
|
|
2257
|
+
);
|
|
2258
|
+
}
|
|
2259
|
+
if (gradePick?.loweredFrom) {
|
|
2260
|
+
cautionsEn.push(
|
|
2261
|
+
`Selector grade ${selectorSize} is below the Um ${att.um} kV default ${gradePick.loweredFrom}, from the stated across-tap LI ${input.acrossTapBilKv} / AC ${input.acrossTapPfKv} kV.`
|
|
2262
|
+
);
|
|
2263
|
+
cautionsZh.push(
|
|
2264
|
+
`\u9009\u62E9\u5668\u7B49\u7EA7 ${selectorSize} \u4F4E\u4E8E Um ${att.um} kV \u7684\u9ED8\u8BA4 ${gradePick.loweredFrom}\uFF0C\u4F9D\u636E\u7ED9\u5B9A\u7684\u8C03\u538B\u7ED5\u7EC4\u95F4 \u96F7\u7535 ${input.acrossTapBilKv} / \u5DE5\u9891 ${input.acrossTapPfKv} kV\u3002`
|
|
2265
|
+
);
|
|
2266
|
+
}
|
|
2267
|
+
if (!octc && !s.usesSelectorSize && s.structure !== "compound" && ((input.acrossTapBilKv ?? 0) > 0 || (input.acrossTapPfKv ?? 0) > 0)) {
|
|
2268
|
+
cautionsEn.push(
|
|
2269
|
+
`${s.code} across-tap withstand is not in the catalogue data: across-tap stress not checked.`
|
|
2270
|
+
);
|
|
2271
|
+
cautionsZh.push(
|
|
2272
|
+
`${s.code} \u8C03\u538B\u7ED5\u7EC4\u95F4\u8010\u53D7\u4E0D\u5728\u76EE\u5F55\u6570\u636E\u91CC\uFF1A\u8C03\u538B\u7ED5\u7EC4\u95F4\u7EDD\u7F18\u672A\u6821\u9A8C\u3002`
|
|
2273
|
+
);
|
|
2274
|
+
}
|
|
2275
|
+
const dutyA = input.throughCurrentA >= 100 ? String(Math.round(input.throughCurrentA)) : String(Math.round(input.throughCurrentA * 10) / 10);
|
|
1691
2276
|
reasonsEn.push(
|
|
1692
|
-
`
|
|
2277
|
+
`Minimum-adequate path: ${s.nameEn}, Ium ${current} A \u2265 ${dutyA} A, Um ${att.um} kV.`
|
|
1693
2278
|
);
|
|
1694
2279
|
reasonsZh.push(
|
|
1695
|
-
`\
|
|
2280
|
+
`\u6700\u4F4E\u6EE1\u8DB3\u8DEF\u5F84\uFF1A${s.nameZh}\uFF0CIum ${current} A \u2265 \u9700\u6C42 ${dutyA} A\uFF0CUm ${att.um} kV\u3002`
|
|
2281
|
+
);
|
|
2282
|
+
if (s.structure === "compound" && !octc) {
|
|
2283
|
+
reasonsEn.push(
|
|
2284
|
+
"Compound type fits duty \u2014 preferred over larger combined types when eligible."
|
|
2285
|
+
);
|
|
2286
|
+
reasonsZh.push(
|
|
2287
|
+
"\u590D\u5408\u5F0F\u6EE1\u8DB3\u5DE5\u51B5\u65F6\u4F18\u5148\u4E8E\u66F4\u5927\u7684\u7EC4\u5408\u5F0F\uFF08\u975E\u9ED8\u8BA4 SHZV\uFF09\u3002"
|
|
2288
|
+
);
|
|
2289
|
+
}
|
|
2290
|
+
if (s.usesSelectorSize) {
|
|
2291
|
+
reasonsEn.push(
|
|
2292
|
+
`Tap selector grade ${selectorSize} (smallest covering Um` + (input.acrossTapBilKv ? ` + across-tap BIL ${input.acrossTapBilKv} kV` : "") + ")."
|
|
2293
|
+
);
|
|
2294
|
+
reasonsZh.push(
|
|
2295
|
+
`\u5206\u63A5\u9009\u62E9\u5668\u7B49\u7EA7 ${selectorSize}\uFF08\u6EE1\u8DB3 Um` + (input.acrossTapBilKv ? ` \u4E0E\u8C03\u538B\u7ED5\u7EC4\u95F4 BIL ${input.acrossTapBilKv} kV` : "") + " \u7684\u6700\u5C0F\u89C4\u683C\uFF09\u3002"
|
|
2296
|
+
);
|
|
2297
|
+
}
|
|
2298
|
+
if (octc) {
|
|
2299
|
+
const roman = octcRoman(conn, contact, input.octcSeries, s.code);
|
|
2300
|
+
reasonsEn.push(
|
|
2301
|
+
`OCTC contact ${contact}${selectorSize} (${s.code}${roman}).`
|
|
2302
|
+
);
|
|
2303
|
+
reasonsZh.push(
|
|
2304
|
+
`\u65E0\u8F7D\u89E6\u5934 ${contact}${selectorSize}\uFF08${s.code}${roman}\uFF09\u3002`
|
|
2305
|
+
);
|
|
2306
|
+
} else {
|
|
2307
|
+
reasonsEn.push(
|
|
2308
|
+
`Tap code ${tap.tapCode}: pitch ${tap.pitch}, ${tap.positions} pos, mid ${tap.mid}, ${input.regulation}.`
|
|
2309
|
+
);
|
|
2310
|
+
reasonsZh.push(
|
|
2311
|
+
`\u5206\u63A5\u4EE3\u7801 ${tap.tapCode}\uFF1A\u8282\u8DDD ${tap.pitch}\uFF0C${tap.positions} \u4F4D\uFF0C\u4E2D\u95F4\u4F4D ${tap.mid}\u3002`
|
|
2312
|
+
);
|
|
2313
|
+
}
|
|
2314
|
+
if (rankUnits(s.id, att.unitCount) > 1) {
|
|
2315
|
+
if (att.deltaForced) {
|
|
2316
|
+
reasonsEn.push(
|
|
2317
|
+
`${att.unitCount}\xD7 single-phase \u2014 no brochure III type for this connection (e.g. CM2III-\u2026D does not exist).`
|
|
2318
|
+
);
|
|
2319
|
+
reasonsZh.push(
|
|
2320
|
+
`${att.unitCount} \u53F0\u5355\u76F8 \u2014 \u6837\u672C\u6CA1\u6709\u8FD9\u4E2A\u8FDE\u63A5\u7684\u4E09\u76F8\u578B\u53F7\uFF08\u6CA1\u6709 CM2III-\u2026D\uFF09\u3002`
|
|
2321
|
+
);
|
|
2322
|
+
} else {
|
|
2323
|
+
reasonsEn.push(
|
|
2324
|
+
`${att.unitCount}\xD7 single-phase \u2014 no single III unit covers this I\u1D64 (prefer one SHZV/SHZVG when it fits; 3\xD7 costs more).`
|
|
2325
|
+
);
|
|
2326
|
+
reasonsZh.push(
|
|
2327
|
+
`${att.unitCount} \u53F0\u5355\u76F8 \u2014 \u65E0\u4E09\u76F8\u6574\u673A\u53EF\u8986\u76D6\u6B64\u7535\u6D41\uFF08\u6709 SHZV/SHZVG \u6574\u673A\u65F6\u4F18\u5148\uFF1B3\xD7 \u66F4\u8D35\uFF09\u3002`
|
|
2328
|
+
);
|
|
2329
|
+
}
|
|
2330
|
+
}
|
|
2331
|
+
const earth = EARTH_INSULATION[att.um];
|
|
2332
|
+
if (earth) {
|
|
2333
|
+
reasonsEn.push(
|
|
2334
|
+
`Earth insulation (catalogue): PF ${earth.pf} / LI ${earth.bil} kV.`
|
|
2335
|
+
);
|
|
2336
|
+
reasonsZh.push(
|
|
2337
|
+
`\u5BF9\u5730\u7EDD\u7F18\uFF08\u6837\u672C\uFF09\uFF1A\u5DE5\u9891 ${earth.pf} / \u96F7\u7535 ${earth.bil} kV\u3002`
|
|
2338
|
+
);
|
|
2339
|
+
}
|
|
2340
|
+
if (current > input.throughCurrentA + 0.5) {
|
|
2341
|
+
warningsEn.push(`Through-current rounded up to ${current} A.`);
|
|
2342
|
+
warningsZh.push(`\u901A\u8FC7\u7535\u6D41\u5DF2\u4E0A\u9760\u81F3 ${current} A\u3002`);
|
|
2343
|
+
}
|
|
2344
|
+
const coveringUm = nearestUm(input.umKv, s.umKv);
|
|
2345
|
+
const extraUm = coveringUm != null && att.um > coveringUm + 0.1;
|
|
2346
|
+
if (extraUm) {
|
|
2347
|
+
reasonsEn.push(
|
|
2348
|
+
`Next catalogue Um ${att.um} kV (list twin of ${coveringUm} kV).`
|
|
2349
|
+
);
|
|
2350
|
+
reasonsZh.push(
|
|
2351
|
+
`\u76EE\u5F55\u4E0B\u4E00\u6863 Um ${att.um} kV\uFF08${coveringUm} kV \u7684\u4EF7\u76EE\u8868\u914D\u5BF9\uFF09\u3002`
|
|
2352
|
+
);
|
|
2353
|
+
} else if (att.um > input.umKv + 0.1) {
|
|
2354
|
+
warningsEn.push(`Um rounded up to ${att.um} kV.`);
|
|
2355
|
+
warningsZh.push(`Um \u5DF2\u4E0A\u9760\u81F3 ${att.um} kV\u3002`);
|
|
2356
|
+
}
|
|
2357
|
+
warningsEn.push(
|
|
2358
|
+
"Indicative selection from published technical data. Final OS requires engineering confirmation."
|
|
1696
2359
|
);
|
|
1697
|
-
|
|
1698
|
-
|
|
1699
|
-
|
|
2360
|
+
warningsZh.push(
|
|
2361
|
+
"\u4F9D\u636E\u516C\u5F00\u6280\u672F\u6837\u672C\u7684\u9009\u578B\u5EFA\u8BAE\u3002\u6700\u7EC8 OS \u987B\u5DE5\u7A0B\u786E\u8BA4\u3002"
|
|
2362
|
+
);
|
|
2363
|
+
const maxStepVoltageV = octc ? null : maxStepVoltageForSeries(s, tap.pitch, current);
|
|
2364
|
+
const stepCapacity = stepCapacityKva(s, current, tap.pitch, input.throughCurrentA);
|
|
2365
|
+
let confidence = 0.88;
|
|
2366
|
+
if (rankUnits(s.id, att.unitCount) > 1) confidence -= 0.08;
|
|
2367
|
+
confidence -= 0.05 * cautionsEn.length;
|
|
2368
|
+
if (warningsEn.length > 2) confidence -= 0.03;
|
|
2369
|
+
confidence = Math.max(0.45, Math.min(0.96, confidence));
|
|
2370
|
+
results.push({
|
|
2371
|
+
seriesId: s.id,
|
|
2372
|
+
seriesCode: s.code,
|
|
2373
|
+
model: finalModel,
|
|
2374
|
+
modelWithMdu,
|
|
2375
|
+
phases: att.phases,
|
|
2376
|
+
currentA: current,
|
|
2377
|
+
connection: conn,
|
|
2378
|
+
umKv: att.um,
|
|
2379
|
+
selectorSize,
|
|
2380
|
+
umToken,
|
|
2381
|
+
tapCode,
|
|
2382
|
+
regulation: input.regulation,
|
|
2383
|
+
changeOver: octc ? "0" : tap.changeOver,
|
|
2384
|
+
pitch: octc ? 0 : tap.pitch,
|
|
2385
|
+
positions: octc ? input.positions ?? (input.plusMinusSteps != null && input.plusMinusSteps > 0 ? 2 * input.plusMinusSteps + 1 : 5) : tap.positions,
|
|
2386
|
+
mid: octc ? 0 : tap.mid,
|
|
2387
|
+
mdu: mduStr,
|
|
2388
|
+
unitCount: att.unitCount,
|
|
2389
|
+
maxStepVoltageV,
|
|
2390
|
+
stepCapacityKva: stepCapacity,
|
|
2391
|
+
earthPfKv: earth?.pf ?? null,
|
|
2392
|
+
earthBilKv: earth?.bil ?? null,
|
|
2393
|
+
reasonsEn,
|
|
2394
|
+
reasonsZh,
|
|
2395
|
+
warningsEn,
|
|
2396
|
+
warningsZh,
|
|
2397
|
+
cautionsEn,
|
|
2398
|
+
cautionsZh,
|
|
2399
|
+
confidence,
|
|
2400
|
+
adequacyScore: score
|
|
2401
|
+
});
|
|
2402
|
+
if (trRaise) trRaised.set(results[results.length - 1], umDefault);
|
|
1700
2403
|
}
|
|
1701
|
-
warningsEn.push(
|
|
1702
|
-
"Indicative selection from published technical data. Final OS requires engineering confirmation."
|
|
1703
|
-
);
|
|
1704
|
-
warningsZh.push(
|
|
1705
|
-
"\u4F9D\u636E\u516C\u5F00\u6280\u672F\u6837\u672C\u7684\u9009\u578B\u5EFA\u8BAE\u3002\u6700\u7EC8 OS \u987B\u5DE5\u7A0B\u786E\u8BA4\u3002"
|
|
1706
|
-
);
|
|
1707
|
-
const maxStepVoltageV = octc ? null : maxStepVoltageForSeries(s, tap.pitch);
|
|
1708
|
-
const stepCapacityKva = s.stepCapacityByCurrent?.[current] ?? null;
|
|
1709
|
-
let confidence = 0.88;
|
|
1710
|
-
if (att.unitCount > 1) confidence -= 0.08;
|
|
1711
|
-
confidence -= 0.05 * cautionsEn.length;
|
|
1712
|
-
if (warningsEn.length > 2) confidence -= 0.03;
|
|
1713
|
-
confidence = Math.max(0.45, Math.min(0.96, confidence));
|
|
1714
|
-
results.push({
|
|
1715
|
-
seriesId: s.id,
|
|
1716
|
-
seriesCode: s.code,
|
|
1717
|
-
model: finalModel,
|
|
1718
|
-
modelWithMdu,
|
|
1719
|
-
phases: att.phases,
|
|
1720
|
-
currentA: current,
|
|
1721
|
-
connection: conn,
|
|
1722
|
-
umKv: att.um,
|
|
1723
|
-
selectorSize,
|
|
1724
|
-
umToken,
|
|
1725
|
-
tapCode,
|
|
1726
|
-
regulation: input.regulation,
|
|
1727
|
-
changeOver: octc ? "0" : tap.changeOver,
|
|
1728
|
-
pitch: octc ? 0 : tap.pitch,
|
|
1729
|
-
positions: octc ? input.positions ?? (input.plusMinusSteps != null && input.plusMinusSteps > 0 ? 2 * input.plusMinusSteps + 1 : 5) : tap.positions,
|
|
1730
|
-
mid: octc ? 0 : tap.mid,
|
|
1731
|
-
mdu: mduStr,
|
|
1732
|
-
unitCount: att.unitCount,
|
|
1733
|
-
maxStepVoltageV,
|
|
1734
|
-
stepCapacityKva,
|
|
1735
|
-
earthPfKv: earth?.pf ?? null,
|
|
1736
|
-
earthBilKv: earth?.bil ?? null,
|
|
1737
|
-
reasonsEn,
|
|
1738
|
-
reasonsZh,
|
|
1739
|
-
warningsEn,
|
|
1740
|
-
warningsZh,
|
|
1741
|
-
cautionsEn,
|
|
1742
|
-
cautionsZh,
|
|
1743
|
-
confidence,
|
|
1744
|
-
adequacyScore: score
|
|
1745
|
-
});
|
|
1746
2404
|
}
|
|
1747
2405
|
}
|
|
1748
2406
|
}
|
|
2407
|
+
for (const [r, from] of trRaised) {
|
|
2408
|
+
const s = SERIES.find((x) => x.id === r.seriesId);
|
|
2409
|
+
if (!s) continue;
|
|
2410
|
+
const umToken = formatUmToken(r.umKv, from, true);
|
|
2411
|
+
const model = r.model.replace(`/${r.umToken}-`, `/${umToken}-`);
|
|
2412
|
+
if (model === r.model || seen.has(model) || !commercialTypeExists(model, s)) continue;
|
|
2413
|
+
if (!coversAcrossTap(from, input.acrossTapBilKv ?? 0, input.acrossTapPfKv ?? 0, r.seriesId)) continue;
|
|
2414
|
+
seen.add(model);
|
|
2415
|
+
const keep = r.cautionsEn.map((c) => !c.startsWith("Selector grade raised to "));
|
|
2416
|
+
results.push({
|
|
2417
|
+
...r,
|
|
2418
|
+
model,
|
|
2419
|
+
modelWithMdu: r.mdu ? `${model}+${r.mdu}` : model,
|
|
2420
|
+
selectorSize: from,
|
|
2421
|
+
umToken,
|
|
2422
|
+
reasonsEn: r.reasonsEn.map((x) => x.replace(`grade ${r.selectorSize} (`, `grade ${from} (`)),
|
|
2423
|
+
reasonsZh: r.reasonsZh.map((x) => x.replace(`\u7B49\u7EA7 ${r.selectorSize}\uFF08`, `\u7B49\u7EA7 ${from}\uFF08`)),
|
|
2424
|
+
cautionsEn: r.cautionsEn.filter((_, i) => keep[i]),
|
|
2425
|
+
cautionsZh: r.cautionsZh.filter((_, i) => keep[i]),
|
|
2426
|
+
confidence: Math.min(0.96, r.confidence + 0.05),
|
|
2427
|
+
adequacyScore: r.adequacyScore - 1e-6
|
|
2428
|
+
});
|
|
2429
|
+
}
|
|
1749
2430
|
let final = results;
|
|
1750
2431
|
if (wantOctc) {
|
|
1751
2432
|
final = results.filter((r) => {
|
|
1752
2433
|
const s = SERIES.find((x) => x.id === r.seriesId);
|
|
1753
2434
|
return s != null && s.medium === "oil" && !s.vacuum;
|
|
1754
2435
|
});
|
|
2436
|
+
if (wantStruct === "drum" && final.some((r) => DRUM_SINGLE.has(r.seriesId))) {
|
|
2437
|
+
final = final.filter((r) => r.seriesId !== "wsg");
|
|
2438
|
+
}
|
|
1755
2439
|
} else if (input.preferVacuum) {
|
|
1756
2440
|
final = results.filter(
|
|
1757
2441
|
(r) => SERIES.find((s) => s.id === r.seriesId)?.vacuum
|
|
@@ -1762,12 +2446,63 @@ function selectOltc(input) {
|
|
|
1762
2446
|
);
|
|
1763
2447
|
}
|
|
1764
2448
|
final.sort((a, b) => {
|
|
1765
|
-
|
|
2449
|
+
const ua = rankUnits(a.seriesId, a.unitCount);
|
|
2450
|
+
const ub = rankUnits(b.seriesId, b.unitCount);
|
|
2451
|
+
if (ua !== ub) return ua - ub;
|
|
1766
2452
|
if (b.adequacyScore !== a.adequacyScore)
|
|
1767
2453
|
return b.adequacyScore - a.adequacyScore;
|
|
1768
2454
|
return b.confidence - a.confidence;
|
|
1769
2455
|
});
|
|
1770
2456
|
if (!final.length) {
|
|
2457
|
+
const locked = candidates.filter(
|
|
2458
|
+
(s) => wantOctc ? s.medium === "oil" && !s.vacuum : input.preferVacuum ? s.vacuum : input.medium === "oil" ? !s.vacuum : true
|
|
2459
|
+
);
|
|
2460
|
+
const why = noFitReasons(locked, input, baseTap);
|
|
2461
|
+
const hinted = normOctcContact(input.octcContact);
|
|
2462
|
+
const asked = octcPositionsAsked(input);
|
|
2463
|
+
if (wantOctc && hinted && asked != null && octcContactPositions(hinted) < asked) {
|
|
2464
|
+
const cov = octcContactPositions(hinted);
|
|
2465
|
+
return {
|
|
2466
|
+
ok: false,
|
|
2467
|
+
results: [],
|
|
2468
|
+
errorsEn: [`Contact ${hinted} covers ${cov} positions; ${asked} were asked.`, ...why?.en ?? []],
|
|
2469
|
+
errorsZh: [`\u89E6\u5934 ${hinted} \u53EA\u8986\u76D6 ${cov} \u4E2A\u5DE5\u4F5C\u4F4D\u7F6E\uFF0C\u8981\u6C42 ${asked} \u4E2A\u3002`, ...why?.zh ?? []]
|
|
2470
|
+
};
|
|
2471
|
+
}
|
|
2472
|
+
if (wantOctc && input.connection === "D") {
|
|
2473
|
+
const conn = input.connection;
|
|
2474
|
+
const dropped = SERIES.filter(
|
|
2475
|
+
(s) => isOctcSeries(s) && s.medium === "oil" && !s.vacuum && seriesMatchesMounting(s, input) && seriesMatchesMedium(s, input) && !s.connections.includes(conn) && !s.connections.includes("any") && (!wantStruct || wantStruct === "auto" || s.structure === wantStruct)
|
|
2476
|
+
);
|
|
2477
|
+
const onY = dropped.length ? selectOltc({ ...input, connection: "Y" }) : null;
|
|
2478
|
+
const fitY = dropped.filter((s) => onY?.ok && onY.results.some((r) => r.seriesId === s.id));
|
|
2479
|
+
if (fitY.length) {
|
|
2480
|
+
const codes = fitY.map((s) => s.code).join("/");
|
|
2481
|
+
if (selectOltc({ ...input, preferStructure: "cage" }).ok) {
|
|
2482
|
+
return {
|
|
2483
|
+
ok: false,
|
|
2484
|
+
results: [],
|
|
2485
|
+
errorsEn: [`${codes} drum OCTC is sold for star (Y) points only; for delta (D) use a cage type.`],
|
|
2486
|
+
errorsZh: [`${codes} \u9F13\u5F0F\u65E0\u8F7D\u53EA\u7528\u4E8E\u661F\u70B9\uFF08Y\uFF09\uFF1B\u89D2\u63A5\uFF08D\uFF09\u8BF7\u7528\u7B3C\u5F0F\u3002`]
|
|
2487
|
+
};
|
|
2488
|
+
}
|
|
2489
|
+
return {
|
|
2490
|
+
ok: false,
|
|
2491
|
+
results: [],
|
|
2492
|
+
errorsEn: [
|
|
2493
|
+
`${codes} drum OCTC is sold for star (Y) points only.`,
|
|
2494
|
+
...why?.en ?? ["Parameters out of catalogue range (current, Um, step voltage, or positions)."]
|
|
2495
|
+
],
|
|
2496
|
+
errorsZh: [
|
|
2497
|
+
`${codes} \u9F13\u5F0F\u65E0\u8F7D\u53EA\u7528\u4E8E\u661F\u70B9\uFF08Y\uFF09\u3002`,
|
|
2498
|
+
...why?.zh ?? ["\u53C2\u6570\u8D85\u51FA\u76EE\u5F55\u8303\u56F4\uFF08\u7535\u6D41\u3001Um\u3001\u7EA7\u7535\u538B\u6216\u6863\u4F4D\u6570\uFF09\u3002"]
|
|
2499
|
+
]
|
|
2500
|
+
};
|
|
2501
|
+
}
|
|
2502
|
+
}
|
|
2503
|
+
if (why) {
|
|
2504
|
+
return { ok: false, results: [], errorsEn: why.en, errorsZh: why.zh };
|
|
2505
|
+
}
|
|
1771
2506
|
return {
|
|
1772
2507
|
ok: false,
|
|
1773
2508
|
results: [],
|
|
@@ -1835,7 +2570,7 @@ function insulationUse(row, need) {
|
|
|
1835
2570
|
aLi = 200;
|
|
1836
2571
|
aPf = 50;
|
|
1837
2572
|
} else if (row.selectorSize) {
|
|
1838
|
-
const ins =
|
|
2573
|
+
const ins = internalInsulation(row.seriesId, row.selectorSize);
|
|
1839
2574
|
aLi = ins?.a_li ?? 0;
|
|
1840
2575
|
aPf = ins?.a_pf ?? 0;
|
|
1841
2576
|
}
|
|
@@ -1926,72 +2661,6 @@ function optionsWithInsurance(results, dutyA, stepVoltageV, n = 3, need) {
|
|
|
1926
2661
|
return step ? [step].slice(0, n) : [];
|
|
1927
2662
|
}
|
|
1928
2663
|
|
|
1929
|
-
// lib/deriveUm.ts
|
|
1930
|
-
var RATED_TO_WINDING_UM = {
|
|
1931
|
-
33: 40.5,
|
|
1932
|
-
35: 40.5,
|
|
1933
|
-
66: 72.5,
|
|
1934
|
-
69: 72.5,
|
|
1935
|
-
110: 126,
|
|
1936
|
-
115: 126,
|
|
1937
|
-
132: 145,
|
|
1938
|
-
138: 145,
|
|
1939
|
-
150: 170,
|
|
1940
|
-
220: 252,
|
|
1941
|
-
230: 252,
|
|
1942
|
-
330: 363
|
|
1943
|
-
};
|
|
1944
|
-
var SNAP_UN = Object.keys(RATED_TO_WINDING_UM).map(Number).sort(
|
|
1945
|
-
(a, b) => a - b
|
|
1946
|
-
);
|
|
1947
|
-
var IEC_UM = [
|
|
1948
|
-
3.6,
|
|
1949
|
-
7.2,
|
|
1950
|
-
12,
|
|
1951
|
-
17.5,
|
|
1952
|
-
24,
|
|
1953
|
-
36,
|
|
1954
|
-
40.5,
|
|
1955
|
-
52,
|
|
1956
|
-
72.5,
|
|
1957
|
-
100,
|
|
1958
|
-
123,
|
|
1959
|
-
145,
|
|
1960
|
-
170,
|
|
1961
|
-
245,
|
|
1962
|
-
300,
|
|
1963
|
-
362,
|
|
1964
|
-
420,
|
|
1965
|
-
550,
|
|
1966
|
-
800
|
|
1967
|
-
];
|
|
1968
|
-
var CATALOGUE_UM = [12, 17.5, 40.5, 72.5, 126, 145, 170, 252, 300, 363];
|
|
1969
|
-
function nominalSystemKv(ratedKv) {
|
|
1970
|
-
let best = ratedKv;
|
|
1971
|
-
for (const u of SNAP_UN) {
|
|
1972
|
-
if (u <= ratedKv && (ratedKv - u) / ratedKv <= 0.12) best = u;
|
|
1973
|
-
}
|
|
1974
|
-
return best;
|
|
1975
|
-
}
|
|
1976
|
-
function iecUmFromRatedKv(ratedKv) {
|
|
1977
|
-
if (!(ratedKv > 0)) return NaN;
|
|
1978
|
-
const un = nominalSystemKv(ratedKv);
|
|
1979
|
-
return IEC_UM.find((u) => u >= un * 1.04) ?? NaN;
|
|
1980
|
-
}
|
|
1981
|
-
function catalogueUmFromRatedKv(ratedKv) {
|
|
1982
|
-
const um = iecUmFromRatedKv(ratedKv);
|
|
1983
|
-
if (!Number.isFinite(um)) return NaN;
|
|
1984
|
-
return CATALOGUE_UM.find((c) => c >= um - 1e-9) ?? um;
|
|
1985
|
-
}
|
|
1986
|
-
function maxThroughCurrent(ratedA, minusSteps, stepPercent) {
|
|
1987
|
-
if (!(ratedA > 0)) return NaN;
|
|
1988
|
-
if (!(minusSteps > 0) || !(stepPercent > 0)) return ratedA;
|
|
1989
|
-
const drop = minusSteps * stepPercent;
|
|
1990
|
-
if (drop <= 0) return ratedA;
|
|
1991
|
-
const denom = 1 - Math.min(drop, 0.45);
|
|
1992
|
-
return ratedA / denom;
|
|
1993
|
-
}
|
|
1994
|
-
|
|
1995
2664
|
// lib/transformer.ts
|
|
1996
2665
|
var TAP_POINTS_FOR = {
|
|
1997
2666
|
two_winding: ["neutral", "line_end"],
|
|
@@ -2010,6 +2679,7 @@ var fail = (zh, en) => ({
|
|
|
2010
2679
|
umAssumed: false,
|
|
2011
2680
|
ratedA: NaN,
|
|
2012
2681
|
maxA: NaN,
|
|
2682
|
+
maxRule: "full_range",
|
|
2013
2683
|
dutyA: NaN,
|
|
2014
2684
|
currentKv: NaN,
|
|
2015
2685
|
currentDivisor: "sqrt3",
|
|
@@ -2019,6 +2689,7 @@ var fail = (zh, en) => ({
|
|
|
2019
2689
|
cautionsEn: []
|
|
2020
2690
|
});
|
|
2021
2691
|
var NEUTRAL_DEFAULT_UM = 72.5;
|
|
2692
|
+
var NEUTRAL_400KV_UM = 126;
|
|
2022
2693
|
function deriveDuty(spec) {
|
|
2023
2694
|
const cautionsZh = [];
|
|
2024
2695
|
const cautionsEn = [];
|
|
@@ -2064,17 +2735,82 @@ function deriveDuty(spec) {
|
|
|
2064
2735
|
stepBaseV = spec.tapKv * 1e3 / SQRT3;
|
|
2065
2736
|
}
|
|
2066
2737
|
const ratedA = spec.mva > 0 ? spec.mva * 1e3 / ((currentDivisor === "three" ? 3 : SQRT3) * currentKv) : NaN;
|
|
2067
|
-
const
|
|
2738
|
+
const minusDrop = spec.stepFraction != null && spec.stepFraction > 0 && spec.minusSteps > 0 ? spec.minusSteps * spec.stepFraction : 0;
|
|
2739
|
+
if (minusDrop >= 1) {
|
|
2740
|
+
return fail("\u8D1F\u5206\u63A5\u8303\u56F4 \u2265 100%\u3002", "Minus range \u2265 100%.");
|
|
2741
|
+
}
|
|
2742
|
+
const derivedMaxA = spec.stepFraction != null && spec.stepFraction > 0 ? maxThroughCurrent(ratedA, spec.minusSteps, spec.stepFraction) : ratedA;
|
|
2743
|
+
if (minusDrop > 0.45 && Number.isFinite(derivedMaxA)) {
|
|
2744
|
+
const pct = String(Math.round(minusDrop * 1e3) / 10);
|
|
2745
|
+
cautionsZh.push(`\u8D1F\u5206\u63A5\u8303\u56F4 ${pct}% \u5F02\u5E38\u5927\uFF1A\u6700\u4F4E\u6863\u7535\u6D41 ${fmtA(derivedMaxA)} A\uFF0C\u8BF7\u6838\u5BF9 OS\u3002`);
|
|
2746
|
+
cautionsEn.push(`Minus range ${pct}% is unusually large: lowest-tap current ${fmtA(derivedMaxA)} A, check the OS.`);
|
|
2747
|
+
}
|
|
2748
|
+
let maxA = derivedMaxA;
|
|
2749
|
+
let maxRule = "full_range";
|
|
2750
|
+
const statedMaxA = spec.statedMaxA ?? 0;
|
|
2751
|
+
if (statedMaxA > 0) {
|
|
2752
|
+
maxA = statedMaxA;
|
|
2753
|
+
maxRule = "stated";
|
|
2754
|
+
if (Number.isFinite(ratedA) && statedMaxA < ratedA - 0.05) {
|
|
2755
|
+
maxA = derivedMaxA;
|
|
2756
|
+
maxRule = "full_range";
|
|
2757
|
+
cautionsZh.push(`OS Imax ${fmtA(statedMaxA)} A \u4F4E\u4E8E\u989D\u5B9A ${fmtA(ratedA)} A\uFF1A\u4E0D\u91C7\u7528\uFF0C\u6309\u5168\u8303\u56F4 ${fmtA(derivedMaxA)} A \u9009\uFF0C\u8BF7\u6838\u5BF9 OS\u3002`);
|
|
2758
|
+
cautionsEn.push(`OS Imax ${fmtA(statedMaxA)} A is below the rated ${fmtA(ratedA)} A: not used, sized on the full-range ${fmtA(derivedMaxA)} A. Check the OS.`);
|
|
2759
|
+
} else if (Number.isFinite(derivedMaxA) && statedMaxA < 0.97 * derivedMaxA) {
|
|
2760
|
+
const capPct = ((1 - ratedA / statedMaxA) * 100).toFixed(1);
|
|
2761
|
+
cautionsZh.push(`OS Imax ${fmtA(statedMaxA)} A \u4F4E\u4E8E\u5168\u8303\u56F4 ${fmtA(derivedMaxA)} A\uFF1A\u5382\u5BB6\u5728 \u2212${capPct}% \u4EE5\u4E0B\u9650\u7535\u6D41\uFF08\u6700\u5927\u7535\u6D41\u5206\u63A5\uFF09\u3002\u6309 OS \u503C\u9009\u3002`);
|
|
2762
|
+
cautionsEn.push(`OS Imax ${fmtA(statedMaxA)} A is below the full-range ${fmtA(derivedMaxA)} A: the maker caps the current below \u2212${capPct}% (maximum-current tapping). Sized on the OS figure.`);
|
|
2763
|
+
} else if (Number.isFinite(derivedMaxA) && statedMaxA > 1.25 * derivedMaxA) {
|
|
2764
|
+
cautionsZh.push(`OS Imax ${fmtA(statedMaxA)} A \u8FDC\u9AD8\u4E8E\u5168\u8303\u56F4 ${fmtA(derivedMaxA)} A\uFF1A\u662F\u7EBF\u7535\u6D41\u8FD8\u662F\u6570\u636E\u9519\u8BEF\uFF1F\u6309 OS \u503C\u9009\u3002`);
|
|
2765
|
+
cautionsEn.push(`OS Imax ${fmtA(statedMaxA)} A is far above the full-range ${fmtA(derivedMaxA)} A: line current or a data error? Sized on the OS figure.`);
|
|
2766
|
+
}
|
|
2767
|
+
}
|
|
2068
2768
|
const k = spec.safetyK > 0 ? spec.safetyK : 1;
|
|
2069
|
-
const
|
|
2769
|
+
const derivedStepV = spec.stepFraction != null && spec.stepFraction > 0 ? stepBaseV * spec.stepFraction : null;
|
|
2770
|
+
let stepV = derivedStepV;
|
|
2771
|
+
const statedStepV = spec.statedStepV ?? 0;
|
|
2772
|
+
if (statedStepV > 0) {
|
|
2773
|
+
stepV = derivedStepV != null ? Math.max(derivedStepV, statedStepV) : statedStepV;
|
|
2774
|
+
const ratio = derivedStepV != null && derivedStepV > 0 ? statedStepV / derivedStepV : 0;
|
|
2775
|
+
if ((auto || spec.winding === "star") && ratio >= 1.7 && ratio <= 1.76) {
|
|
2776
|
+
cautionsZh.push(`OS Ust ${Math.round(statedStepV)} V \u50CF\u7EBF\u7535\u538B\u503C\uFF1B\u5B9E\u9645\u7EA7\u7535\u538B ${Math.round(derivedStepV)} V\u3002\u6309 OS \u503C\u9009\u3002`);
|
|
2777
|
+
cautionsEn.push(`OS Ust ${Math.round(statedStepV)} V looks like a line value; the physical step is ${Math.round(derivedStepV)} V. Sized on the OS figure.`);
|
|
2778
|
+
} else if (derivedStepV != null && statedStepV < derivedStepV * 0.97) {
|
|
2779
|
+
cautionsZh.push(`OS Ust ${Math.round(statedStepV)} V \u4F4E\u4E8E\u6309\u5BB9\u91CF\u548C\u6863\u8DDD\u7B97\u7684 ${Math.round(derivedStepV)} V\uFF0C\u6309 ${Math.round(derivedStepV)} V \u9009\u3002`);
|
|
2780
|
+
cautionsEn.push(`OS Ust ${Math.round(statedStepV)} V is below the ${Math.round(derivedStepV)} V from the rating and step. Sized on ${Math.round(derivedStepV)} V.`);
|
|
2781
|
+
} else if (
|
|
2782
|
+
// 2026-11-04 final ENGINE-12: --ust 1588 on 110 kV with no step % is
|
|
2783
|
+
// 2.5 % per step, but the lowest tap was sized on the 1.25 % default
|
|
2784
|
+
// (333.3 A on a 350 A switch; 375 A at 2.5 %). A stated Imax decides
|
|
2785
|
+
// the current itself; an auto's extreme tap sits above nominal (D5).
|
|
2786
|
+
derivedStepV != null && statedMaxA <= 0 && ratio > 1.03 && Number.isFinite(ratedA) && !(auto && spec.stepFractionStated)
|
|
2787
|
+
) {
|
|
2788
|
+
const implied = statedStepV / stepBaseV;
|
|
2789
|
+
const pct = (x) => String(Math.round(x * 1e4) / 100);
|
|
2790
|
+
const ust = Math.round(statedStepV);
|
|
2791
|
+
if (!spec.stepFractionStated && spec.minusSteps * implied < 1) {
|
|
2792
|
+
maxA = Math.max(maxA, maxThroughCurrent(ratedA, spec.minusSteps, implied));
|
|
2793
|
+
cautionsZh.push(`OS Ust ${ust} V \u5373\u6BCF\u7EA7 ${pct(implied)}%\uFF0C\u4E0D\u662F\u9ED8\u8BA4\u7684 ${pct(spec.stepFraction)}%\uFF1A\u6700\u4F4E\u6863\u7535\u6D41\u6309 ${pct(implied)}% \u7B97\u3002`);
|
|
2794
|
+
cautionsEn.push(`OS Ust ${ust} V is ${pct(implied)} % per step, not the ${pct(spec.stepFraction)} % default; lowest tap sized on ${pct(implied)} %.`);
|
|
2795
|
+
} else if (spec.stepFractionStated) {
|
|
2796
|
+
cautionsZh.push(`OS Ust ${ust} V \u5373\u6BCF\u7EA7 ${pct(implied)}%\uFF0C\u4E0E\u7ED9\u5B9A\u7684 ${pct(spec.stepFraction)}% \u4E0D\u7B26\uFF1A\u6700\u4F4E\u6863\u7535\u6D41\u6309 ${pct(spec.stepFraction)}% \u7B97\uFF0C\u8BF7\u6838\u5BF9 OS\u3002`);
|
|
2797
|
+
cautionsEn.push(`OS Ust ${ust} V is ${pct(implied)} % per step, not the stated ${pct(spec.stepFraction)} %; lowest tap sized on ${pct(spec.stepFraction)} %. Check the OS.`);
|
|
2798
|
+
}
|
|
2799
|
+
}
|
|
2800
|
+
}
|
|
2070
2801
|
let umSystemKv;
|
|
2071
2802
|
let umKv;
|
|
2072
2803
|
let umRule;
|
|
2073
2804
|
let umAssumed = false;
|
|
2805
|
+
let neutralMarket = null;
|
|
2074
2806
|
if (auto) {
|
|
2075
2807
|
umSystemKv = spec.hvKv;
|
|
2076
2808
|
umKv = catalogueUmFromRatedKv(spec.hvKv);
|
|
2077
2809
|
umRule = "auto_hv";
|
|
2810
|
+
if (spec.tapPoint === "auto_mv_line") {
|
|
2811
|
+
umKv = Math.min(umKv, Math.max(catalogueUmFromRatedKv(spec.mvKv), 170));
|
|
2812
|
+
}
|
|
2813
|
+
umAssumed = true;
|
|
2078
2814
|
} else if (spec.tapPoint === "neutral") {
|
|
2079
2815
|
umSystemKv = spec.tapKv;
|
|
2080
2816
|
const lineClass = catalogueUmFromRatedKv(spec.tapKv);
|
|
@@ -2083,20 +2819,49 @@ function deriveDuty(spec) {
|
|
|
2083
2819
|
umRule = "neutral_full";
|
|
2084
2820
|
if (lineClass === 40.5) umAssumed = true;
|
|
2085
2821
|
} else {
|
|
2086
|
-
umKv = NEUTRAL_DEFAULT_UM;
|
|
2822
|
+
umKv = lineClass > 363 ? NEUTRAL_400KV_UM : NEUTRAL_DEFAULT_UM;
|
|
2087
2823
|
umRule = "neutral_assumed";
|
|
2088
2824
|
umAssumed = true;
|
|
2825
|
+
const market = (spec.market ?? "").trim().toUpperCase();
|
|
2826
|
+
if (market === "IT" && lineClass <= 252) {
|
|
2827
|
+
umKv = lineClass === 145 ? 170 : lineClass;
|
|
2828
|
+
neutralMarket = "IT";
|
|
2829
|
+
} else if (market === "TR" && lineClass >= 252 && lineClass <= 363) {
|
|
2830
|
+
umKv = 126;
|
|
2831
|
+
neutralMarket = "TR";
|
|
2832
|
+
}
|
|
2089
2833
|
}
|
|
2090
2834
|
} else {
|
|
2091
2835
|
umSystemKv = spec.tapKv;
|
|
2092
2836
|
umKv = catalogueUmFromRatedKv(spec.tapKv);
|
|
2093
2837
|
umRule = "line";
|
|
2094
2838
|
}
|
|
2839
|
+
let ruleUmKv;
|
|
2095
2840
|
if (spec.earthUmKv != null && spec.earthUmKv > 0) {
|
|
2841
|
+
const floor = umRule === "line" ? umKv : auto ? catalogueUmFromRatedKv(spec.mvKv) : 0;
|
|
2842
|
+
if (spec.earthUmKv < floor - 0.01) {
|
|
2843
|
+
cautionsZh.push(`\u6307\u5B9A Um ${spec.earthUmKv} kV \u4F4E\u4E8E\u8BE5\u70B9\u7CFB\u7EDF Um ${floor} kV\uFF0C\u8BF7\u6838\u5BF9 OS\u3002`);
|
|
2844
|
+
cautionsEn.push(`Stated Um ${spec.earthUmKv} kV is below the system class Um ${floor} kV at this point. Check the OS.`);
|
|
2845
|
+
}
|
|
2846
|
+
ruleUmKv = umKv;
|
|
2096
2847
|
umKv = spec.earthUmKv;
|
|
2097
2848
|
umRule = "explicit";
|
|
2098
2849
|
umAssumed = false;
|
|
2099
2850
|
}
|
|
2851
|
+
if (auto && spec.tapPoint === "auto_junction" && umRule === "auto_hv" && umKv > 363) {
|
|
2852
|
+
const mvClass = catalogueUmFromRatedKv(spec.mvKv);
|
|
2853
|
+
const open = [72.5, 126, 170, 252, 300, 363].filter((u) => u >= mvClass - 0.01);
|
|
2854
|
+
if (!open.length) {
|
|
2855
|
+
return fail(
|
|
2856
|
+
`\u81EA\u8026\u53D8\u9AD8\u538B Um ${umKv} kV\u3001\u4E2D\u538B Um ${mvClass} kV \u90FD\u8D85\u51FA\u76EE\u5F55\uFF08\u6700\u9AD8 363 kV\uFF09\u3002\u8BF7\u8054\u7CFB\u5DE5\u7A0B\u3002`,
|
|
2857
|
+
`Autotransformer HV class Um ${umKv} kV and MV class Um ${mvClass} kV are both above the catalogue (top 363 kV). Contact engineering.`
|
|
2858
|
+
);
|
|
2859
|
+
}
|
|
2860
|
+
return fail(
|
|
2861
|
+
`\u81EA\u8026\u53D8\u9AD8\u538B Um ${umKv} kV \u8D85\u51FA\u76EE\u5F55\uFF08\u6700\u9AD8 363 kV\uFF09\u3002\u8BF7\u6309 OS \u586B\u5F00\u5173\u5BF9\u5730\u7EDD\u7F18\uFF08CLI\uFF1A--earth-um\uFF09\uFF0C\u53EF\u9009 ${open.join("\u3001")} kV\u3002`,
|
|
2862
|
+
`Autotransformer HV class Um ${umKv} kV is above the catalogue (top 363 kV). Give the switch's insulation to earth from the OS (CLI: --earth-um): ${open.join(", ")} kV.`
|
|
2863
|
+
);
|
|
2864
|
+
}
|
|
2100
2865
|
if (!Number.isFinite(umKv) || umKv > 363) {
|
|
2101
2866
|
return fail(
|
|
2102
2867
|
"\u7535\u538B\u8D85\u51FA\u76EE\u5F55\uFF1A\u5F00\u5173\u6700\u9AD8 Um 363 kV\u3002",
|
|
@@ -2104,23 +2869,50 @@ function deriveDuty(spec) {
|
|
|
2104
2869
|
);
|
|
2105
2870
|
}
|
|
2106
2871
|
if (umRule === "neutral_full" && umAssumed) {
|
|
2107
|
-
cautionsZh.push("35 kV \u7EA7\u4E2D\u6027\u70B9\u5148\u6309 Um 40.5 \u9009\uFF1B\u4E0D\u5C11\
|
|
2108
|
-
cautionsEn.push("35 kV-class neutral sized at Um 40.5; many
|
|
2872
|
+
cautionsZh.push("35 kV \u7EA7\u4E2D\u6027\u70B9\u5148\u6309 Um 40.5 kV \u9009\uFF1B\u4E0D\u5C11\u9879\u76EE\u8981\u6C42 72.5\uFF0C\u4EE5\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u4E3A\u51C6\u3002CM/CM2/SHZV \u6700\u4F4E\u5C31\u662F 72.5\u3002");
|
|
2873
|
+
cautionsEn.push("35 kV-class neutral sized at Um 40.5 kV; many projects specify 72.5; the order specification (OS) decides. CM/CM2/SHZV start at 72.5.");
|
|
2109
2874
|
}
|
|
2110
2875
|
if (umRule === "neutral_assumed") {
|
|
2111
|
-
|
|
2112
|
-
|
|
2876
|
+
if (neutralMarket === "IT") {
|
|
2877
|
+
cautionsZh.push(`\u610F\u5927\u5229\u4E2D\u6027\u70B9\u5148\u6309\u7EBF\u7AEF\u7B49\u7EA7 Um ${umKv} kV \u9009\uFF08\u90E8\u5206\u9879\u76EE\u7528 72.5\uFF09\uFF0C\u4EE5\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u4E3A\u51C6\u3002`);
|
|
2878
|
+
cautionsEn.push(`Italy: neutral sized at the line class, Um ${umKv} kV (some projects use 72.5); the order specification (OS) decides.`);
|
|
2879
|
+
} else if (neutralMarket === "TR") {
|
|
2880
|
+
cautionsZh.push(`\u571F\u8033\u5176 220 kV \u7EA7\u53CA\u4EE5\u4E0A\u4E2D\u6027\u70B9\u5148\u6309 Um ${umKv} kV \u9009\uFF08\u901A\u5E38 126 \u6216 170\uFF0C\u4E0D\u7528 72.5\uFF09\uFF0C\u4EE5\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u4E3A\u51C6\u3002`);
|
|
2881
|
+
cautionsEn.push(`Turkey: 220 kV-class and above neutral sized at Um ${umKv} kV (126 or 170 is usual, not 72.5); the order specification (OS) decides.`);
|
|
2882
|
+
} else if (umKv === NEUTRAL_400KV_UM) {
|
|
2883
|
+
cautionsZh.push(`400 kV \u7EA7\u7ED5\u7EC4\u4E2D\u6027\u70B9\u5148\u6309 Um ${umKv} kV \u9009\uFF08\u571F\u8033\u5176\u3001\u8461\u8404\u7259\u5E38\u7528 126\uFF1B\u5DF4\u897F 440/500 kV \u5E38\u7528 72.5\uFF09\uFF0C\u4EE5\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u4E3A\u51C6\u3002`);
|
|
2884
|
+
cautionsEn.push(`Neutral of a 400 kV-class winding sized at Um ${umKv} kV (126 is usual in Turkey and Portugal; 72.5 in Brazil at 440/500 kV); the order specification (OS) decides.`);
|
|
2885
|
+
} else {
|
|
2886
|
+
cautionsZh.push(`\u4E2D\u6027\u70B9\u7EDD\u7F18\u672A\u7ED9\uFF0C\u5148\u6309 Um ${umKv} kV \u9009\uFF0C\u4EE5\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u4E3A\u51C6\u3002`);
|
|
2887
|
+
cautionsEn.push(`Neutral insulation not given: sized at Um ${umKv} kV; the order specification (OS) decides.`);
|
|
2888
|
+
}
|
|
2889
|
+
}
|
|
2890
|
+
const highWinding = !auto && catalogueUmFromRatedKv(spec.tapKv) >= 252;
|
|
2891
|
+
if (highWinding) {
|
|
2892
|
+
cautionsZh.push("220 kV \u7EA7\u53CA\u4EE5\u4E0A\u8C03\u538B\u7ED5\u7EC4\u53EA\u7528\u7EC4\u5408\u5F0F\u3002");
|
|
2893
|
+
cautionsEn.push("220 kV-class tapped winding: combined types only.");
|
|
2113
2894
|
}
|
|
2114
2895
|
if (auto) {
|
|
2115
2896
|
if (spec.tapPoint === "auto_mv_line" && umRule === "auto_hv") {
|
|
2116
|
-
|
|
2117
|
-
|
|
2118
|
-
|
|
2119
|
-
|
|
2120
|
-
|
|
2897
|
+
if (umKv === 170) {
|
|
2898
|
+
cautionsZh.push("230/121 kV \u81EA\u8026\u53D8\u4E2D\u538B\u51FA\u7EBF\u901A\u5E38\u7528 Um 170 kV\uFF0C\u8BF7\u6309\u5382\u5BB6\u6570\u636E\u6838\u5BF9\u3002");
|
|
2899
|
+
cautionsEn.push("230/121 kV autotransformer MV line lead: Um 170 kV is usual; check the maker's data.");
|
|
2900
|
+
} else {
|
|
2901
|
+
cautionsZh.push(`\u4E2D\u538B\u51FA\u7EBF\u5148\u6309\u4E2D\u538B\u7B49\u7EA7 Um ${umKv} kV \u9009\uFF0C\u4EE5\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u4E3A\u51C6\u3002`);
|
|
2902
|
+
cautionsEn.push(`MV line lead sized at the MV class, Um ${umKv} kV; the order specification (OS) decides.`);
|
|
2903
|
+
}
|
|
2904
|
+
} else if (spec.tapPoint === "auto_junction" && umRule === "auto_hv") {
|
|
2905
|
+
cautionsZh.push(`\u81EA\u8026\u53D8\u4E32\u8054-\u516C\u5171\u8FDE\u63A5\u70B9\u5148\u6309\u9AD8\u538B\u7B49\u7EA7 Um ${umKv} kV \u9009\uFF0C\u4EE5\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u4E3A\u51C6\u3002`);
|
|
2906
|
+
cautionsEn.push(`Autotransformer junction sized at the HV class, Um ${umKv} kV; the order specification (OS) decides.`);
|
|
2121
2907
|
}
|
|
2122
|
-
cautionsZh.push("\
|
|
2908
|
+
cautionsZh.push("\u81EA\u8026\u53D8\u53EA\u7528\u7EC4\u5408\u5F0F\uFF08\u590D\u5408\u5F0F\u8DE8\u8C03\u538B\u7ED5\u7EC4\u51B2\u51FB\u4E0A\u9650 200 kV\uFF09\u3002");
|
|
2909
|
+
cautionsEn.push("Autotransformer: combined types only (compound types stop at 200 kV across the tap winding).");
|
|
2910
|
+
cautionsZh.push("\u8FD8\u6CA1\u6838\uFF1A\u8C03\u538B\u7ED5\u7EC4\u4E24\u7AEF\u7684\u51B2\u51FB\u7535\u538B\uFF08a \u503C\uFF09\uFF0C\u4EE5\u53CA\u8981\u4E0D\u8981\u52A0\u7535\u4F4D\u7535\u963B\u3002");
|
|
2123
2911
|
cautionsEn.push("Not checked: impulse across the tap winding (a), tie-in resistor.");
|
|
2912
|
+
if (!(statedStepV > 0 && statedStepV >= (derivedStepV ?? 0) - 0.5)) {
|
|
2913
|
+
cautionsZh.push("\u53D8\u78C1\u901A\uFF1A\u5404\u6863 Ust \u548C\u7535\u6D41\u4E0D\u540C\uFF0C\u6781\u9650\u6863 Ust \u672A\u6821\u9A8C\u3002\u8BF7\u5411\u5382\u5BB6\u8981\u5206\u63A5\u8868\u3002");
|
|
2914
|
+
cautionsEn.push("Variable flux: Ust and current differ per tap; Ust at the extreme tap is not checked. Get the maker's per-tap table.");
|
|
2915
|
+
}
|
|
2124
2916
|
}
|
|
2125
2917
|
return {
|
|
2126
2918
|
ok: true,
|
|
@@ -2129,18 +2921,1003 @@ function deriveDuty(spec) {
|
|
|
2129
2921
|
actualUmKv: iecUmFromRatedKv(umSystemKv),
|
|
2130
2922
|
umKv,
|
|
2131
2923
|
umRule,
|
|
2924
|
+
...ruleUmKv != null ? { ruleUmKv } : {},
|
|
2132
2925
|
umAssumed,
|
|
2133
2926
|
ratedA,
|
|
2134
2927
|
maxA,
|
|
2928
|
+
maxRule,
|
|
2135
2929
|
dutyA: maxA * k,
|
|
2136
2930
|
currentKv,
|
|
2137
2931
|
currentDivisor,
|
|
2138
2932
|
stepV,
|
|
2139
|
-
combinedOnly: auto,
|
|
2933
|
+
combinedOnly: auto || highWinding,
|
|
2140
2934
|
cautionsZh,
|
|
2141
2935
|
cautionsEn
|
|
2142
2936
|
};
|
|
2143
2937
|
}
|
|
2938
|
+
function umChoices(d, spec) {
|
|
2939
|
+
if (!d.ok || d.umRule === "explicit") return [];
|
|
2940
|
+
const ladder = [40.5, 72.5, 126, 170, 252, 300, 363];
|
|
2941
|
+
if (d.umRule === "neutral_assumed" || d.umRule === "neutral_full" && d.umAssumed) {
|
|
2942
|
+
const top = Math.max(catalogueUmFromRatedKv(spec.tapKv), NEUTRAL_DEFAULT_UM);
|
|
2943
|
+
const low = Math.min(d.umKv, NEUTRAL_DEFAULT_UM);
|
|
2944
|
+
return ladder.filter((u) => u >= low - 0.01 && u <= top + 0.01);
|
|
2945
|
+
}
|
|
2946
|
+
if (d.umRule === "auto_hv") {
|
|
2947
|
+
if (spec.tapPoint === "auto_mv_line") {
|
|
2948
|
+
const hv = catalogueUmFromRatedKv(spec.hvKv);
|
|
2949
|
+
const mv = catalogueUmFromRatedKv(spec.mvKv);
|
|
2950
|
+
return ladder.filter((u) => u >= mv - 0.01 && u <= Math.min(hv, 363) + 0.01);
|
|
2951
|
+
}
|
|
2952
|
+
const floor = catalogueUmFromRatedKv(spec.mvKv);
|
|
2953
|
+
return ladder.filter((u) => u >= floor - 0.01 && u <= d.umKv + 0.01);
|
|
2954
|
+
}
|
|
2955
|
+
return [];
|
|
2956
|
+
}
|
|
2957
|
+
function fmtA(a) {
|
|
2958
|
+
return (Math.round(a * 10) / 10).toFixed(1);
|
|
2959
|
+
}
|
|
2960
|
+
|
|
2961
|
+
// lib/nameplate.ts
|
|
2962
|
+
var NOTE_EN = {
|
|
2963
|
+
auto_needs_mv: "autotransformer needs HV and MV kV",
|
|
2964
|
+
auto_tertiary: "range is on the tertiary of an autotransformer",
|
|
2965
|
+
zigzag: "zigzag tapped winding: confirm the tap point",
|
|
2966
|
+
tiny_mva: "power reads {mva} MVA: check the figure",
|
|
2967
|
+
single_phase: "single-phase: {mva} MVA read as one unit, sized as 3 \xD7 {mva} MVA on a single-phase switch",
|
|
2968
|
+
tap_ladder: "{chain} kV read as tap voltages; rated {kv} kV",
|
|
2969
|
+
auto_vg: "text says autotransformer but vector group {vg} has HV and MV in different connections",
|
|
2970
|
+
delta_text: "text mentions delta: confirm which winding is tapped",
|
|
2971
|
+
percent: "{pct} read as +{plus}/\u2212{minus} \xD7 {step} %",
|
|
2972
|
+
percent_positions: "{pos} positions do not match +{plus}/\u2212{minus}",
|
|
2973
|
+
percent_small: "{pct} gives no step count: range not read",
|
|
2974
|
+
zero_range: "range \xB10 ignored",
|
|
2975
|
+
second_range: "{kv} kV {range} is a second tapped winding: used for off-circuit duty",
|
|
2976
|
+
largest_mva: "several ratings: sized on the largest, {mva} MVA",
|
|
2977
|
+
mid_winding: "tap in the middle of the winding: sized as line end; take the insulation to earth from the OS",
|
|
2978
|
+
quantity: "3 \xD7 {mva} MVA read as three three-phase units of {mva} MVA: confirm it is not a single-phase bank",
|
|
2979
|
+
earth_li: "insulation to earth LI {li} kV is not used: set the Um to earth from it",
|
|
2980
|
+
off_circuit_line: "the line names only an off-circuit tap changer: sized as off-circuit (OCTC)"
|
|
2981
|
+
};
|
|
2982
|
+
function lineNoteEn(n) {
|
|
2983
|
+
let s = NOTE_EN[n.key];
|
|
2984
|
+
for (const [k, v] of Object.entries(n.vars ?? {})) s = s.replaceAll(`{${k}}`, String(v));
|
|
2985
|
+
return s;
|
|
2986
|
+
}
|
|
2987
|
+
var NUM = String.raw`\d+(?:\.\d+)?`;
|
|
2988
|
+
function normalizeTenderText(raw) {
|
|
2989
|
+
return raw.replace(
|
|
2990
|
+
/[\uFF01-\uFF5E]/g,
|
|
2991
|
+
(c) => "\uFF0C\uFF1A\uFF1B".includes(c) ? c : String.fromCharCode(c.charCodeAt(0) - 65248)
|
|
2992
|
+
).replace(/\u3000/g, " ").replace(
|
|
2993
|
+
/\+\s*(\d{1,2})\s*[x×*]\s*(\d+(?:[.,]\d+)?)\s*%\s*[-−–]\s*(\d{1,2})\s*[x×*]\s*\2\s*%/g,
|
|
2994
|
+
(_m, a, st, b) => a === b ? `\xB1${a}x${st}%` : `+${a}/-${b}x${st}%`
|
|
2995
|
+
).replace(
|
|
2996
|
+
/(?<![\d./])([1-9])\s*\/\s*([2-9]|1[0-6])\s*%/g,
|
|
2997
|
+
(_m, a, b) => `${Math.round(Number(a) / Number(b) * 1e4) / 1e4}%`
|
|
2998
|
+
).replace(/(?<![А-Яа-яЁё])[мМ][вВ][аА](?![А-Яа-яЁё])/g, "MVA").replace(/(?<![А-Яа-яЁё])[кК][вВ][аА](?![А-Яа-яЁё])/g, "kVA").replace(/(?<![А-Яа-яЁё])[кК][вВ](?![А-Яа-яЁё])/g, "kV").replace(
|
|
2999
|
+
new RegExp("(?<![\\p{L}\\d])[\u0423Y\u0414]\u041D?(?:\\s*\\/\\s*[\u0423Y\u0414]\u041D?)+(?:\\s*-\\s*[\u0414\u0423Y\u041D\\d]{1,2})*(?!\\p{L})", "gu"),
|
|
3000
|
+
(m) => m.replace(/У/g, "Y").replace(/Д/g, "D").replace(/Н/g, "N")
|
|
3001
|
+
).replace(/[×✕✖*]/g, "x").replace(/(?<=\d\s*)[хХ](?=\s*\d)/g, "x").replace(/(\d)\s*X\s*(?=\d)/g, "$1 x ").replace(
|
|
3002
|
+
/\b[1-9]\d{0,2}(?:\.\d{3})+(?=\s*(?:\/\s*[1-9]\d{0,2}(?:\.\d{3})+\s*)*kVA)/gi,
|
|
3003
|
+
(m) => m.replace(/\./g, "")
|
|
3004
|
+
).replace(
|
|
3005
|
+
/(\b(?:rated|power|rating|capacity|S[rn])\b[^\d;]{0,20}kVA\s*\)?\s*[:=,]?\s*)(\d{1,3}(?:[, '’]\d{3})+)(?!\d)/gi,
|
|
3006
|
+
(_m, lead, n) => lead + n.replace(/[, '’]/g, "")
|
|
3007
|
+
).replace(
|
|
3008
|
+
/\b\d{1,3}(?:[, \u00A0\u202F'’]\d{3})+(?=\s*(?:\/\s*\d{1,3}(?:[, \u00A0\u202F'’]\d{3})+\s*)*kVA)/gi,
|
|
3009
|
+
(m, offset, s) => {
|
|
3010
|
+
const before = s.slice(Math.max(0, offset - 12), offset);
|
|
3011
|
+
const list = /\d[, \u00A0\u202F'’]\d{3}\s*\/\s*$/.test(before);
|
|
3012
|
+
if (!list && /\d[/.]?\s?$/.test(before) && !/[A-Za-z]\d{1,2}\s$/.test(before)) return m;
|
|
3013
|
+
return m.replace(/[, \u00A0\u202F'’]/g, "");
|
|
3014
|
+
}
|
|
3015
|
+
).replace(
|
|
3016
|
+
/\b(\d{1,3})[, \u00A0\u202F](\d{3})(?![\d.,])(?=\s*(?:±\s*\d{1,2}(?:\s*x\s*[\d.,]+\s*%)?)?(?:\s*\/\s*\d[\d, \u00A0\u202F.]*?\s*(?:±\s*\d{1,2}(?:\s*x\s*[\d.,]+\s*%)?)?)*\s*V\b)/g,
|
|
3017
|
+
"$1$2"
|
|
3018
|
+
).replace(/(?<![DdYyNnaZz]\d{0,2})(\d),(\d)/g, "$1.$2").replace(/,/g, ",").replace(/%/g, "%").replace(/[–—-−]/g, "-").replace(/(\d+(?:\.\d+)?)-\1(?=\s*(?:kV|\/))/gi, "$1").replace(
|
|
3019
|
+
/(?<![\w.])(\d+(?:\.\d+)?)\s*[:\-]\s*(\d+(?:\.\d+)?)(?=\s*kV)/gi,
|
|
3020
|
+
(m, a, b) => Number(a) / Number(b) >= 1.5 ? `${a}/${b}` : m
|
|
3021
|
+
).replace(/\+\s*\/\s*-|\+\s*-(?=\s*\d+(?:\.\d+)?\s*(?:x|steps?\b|taps?\b|positions?\b|%))/g, "\xB1").replace(new RegExp(String.raw`([+\-±])\s*%\s*(${NUM})`, "g"), "$1$2%").replace(new RegExp(String.raw`x\s*%\s*(${NUM})`, "gi"), "x $1%").replace(new RegExp(String.raw`\+\s*(${NUM})\s*%\s*(?:,|\band\b|&)\s*-\s*(${NUM})\s*%`, "gi"), "+$1%/-$2%").replace(new RegExp(String.raw`\bplus\s*(${NUM})\s*%\s*,?\s*(?:and\s+)?minus\s*(${NUM})\s*%`, "gi"), "+$1%/-$2%").replace(
|
|
3022
|
+
new RegExp(String.raw`(?<![\w.%/])-\s*(${NUM})\s*(%?)\s*(?:\/|\bto\b|\.\.\.|…)\s*\+\s*(${NUM})\s*(%?)`, "gi"),
|
|
3023
|
+
// "-5/+10%": a % on either side makes both percent.
|
|
3024
|
+
(m, minus, p1, plus, p2, offset, s) => {
|
|
3025
|
+
const pct = p1 || p2;
|
|
3026
|
+
if (!pct && !/^\s*x\s*\d/i.test(s.slice(offset + m.length, offset + m.length + 12))) return m;
|
|
3027
|
+
return `+${plus}${pct}/-${minus}${pct}`;
|
|
3028
|
+
}
|
|
3029
|
+
).replace(new RegExp(String.raw`\+\s*(${NUM})\s*%\s*to\s*-`, "gi"), "+$1%/-").replace(
|
|
3030
|
+
new RegExp(String.raw`\+\s*(\d{1,2})\s*x\s*(${NUM})\s*%\s*\/\s*-\s*(\d{1,2})\s*x\s*\2\s*%`, "g"),
|
|
3031
|
+
"+$1/-$3 x $2%"
|
|
3032
|
+
).replace(
|
|
3033
|
+
new RegExp(String.raw`(?<![\d.+\-±])0(?![\d.])\s*%?\s*(?:\bto\b|\/)\s*-\s*(${NUM})\s*%`, "gi"),
|
|
3034
|
+
"+0%/-$1%"
|
|
3035
|
+
).replace(new RegExp(String.raw`(?<![\w.%/])-\s*(${NUM})\s*%\s*(?:\bto\b|\/)\s*\+?\s*0(?![\d.])\s*%?`, "gi"), "+0%/-$1%").replace(
|
|
3036
|
+
new RegExp(String.raw`(?<![\w.%/])-\s*(\d{1,2})\s*x\s*(${NUM})\s*%\s*\/\s*\+\s*(\d{1,2})\s*x\s*\2\s*%`, "g"),
|
|
3037
|
+
"+$3/-$1 x $2%"
|
|
3038
|
+
).replace(
|
|
3039
|
+
new RegExp(String.raw`\+\s*(\d{1,2})\s*x\s*(${NUM})\s*%\s*\/\s*-\s*0(?![\d.])(?:\s*x\s*\2\s*%)?`, "g"),
|
|
3040
|
+
"+$1/-0 x $2%"
|
|
3041
|
+
).replace(
|
|
3042
|
+
new RegExp(String.raw`\+\s*0(?![\d.])(?:\s*x\s*${NUM}\s*%)?\s*\/\s*-\s*(\d{1,2})\s*x\s*(${NUM})\s*%`, "g"),
|
|
3043
|
+
"+0/-$1 x $2%"
|
|
3044
|
+
).replace(/\(\s*([±+][^()]{1,30}%)\s*\)/g, " $1 ").replace(/\(\s*(\d+(?:\.\d+)?\s*±[^()]*%)\s*\)/g, "$1").replace(/\s*\/\s*(?:√|sqrt\s*|v)\s*3\b/gi, "").replace(/\s+/g, " ").trim();
|
|
3045
|
+
}
|
|
3046
|
+
function parseVectorGroup(raw) {
|
|
3047
|
+
const text = raw.replace(
|
|
3048
|
+
/\b(?:YN|Yn|Y|D|ZN|Z)(?:(?:yn|y|d|zn|z|a)[0-9Oo]{0,2}){1,3}(?![A-Za-z0-9])/g,
|
|
3049
|
+
(g) => g.replace(/(?<=(?:yn|y|d|zn|z|a)\d?)[Oo]/g, "0")
|
|
3050
|
+
).replace(/(?<![A-Za-z])Y[oO0](?![A-Za-z0-9])/g, "YN").replace(/[Δ△]/g, "D").replace(/\b(YN|Yn|Y|D|ZN|Z)\s*-\s*(?=(?:yn|y|d|zn|z|YN|Yn|Y|D)\s*\d)/g, "$1").replace(
|
|
3051
|
+
/\b(YN|Y|D|ZN|Z)\s*\/\s*(YN|Y|D|ZN|Z)(?:\s*-\s*(\d{1,2}))?\b/g,
|
|
3052
|
+
(m2, h, l, c) => h + l.toLowerCase() + (c ?? "")
|
|
3053
|
+
).replace(/\bYn(?=(?:yn|y|d|zn|z|a)\d)/g, "YN").replace(/\b(YN|Y|D|ZN|Z)[,\s/]+(?=(?:yn|y|d|zn|z|a)\d)/g, "$1").replace(/((?:YN|Y|D|ZN|Z)(?:(?:yn|y|d|zn|z|a)\d{1,2})+)[,/]\s*(?=(?:yn|y|d|zn|z|a)\d)/g, "$1").replace(/\b(YN|D|Y|ZN|Z)((?:YN|Yn|Y|D|ZN|Zn|Z|A)\s?\d{1,2})+\b/g, (m2, h) => h + m2.slice(h.length).toLowerCase());
|
|
3054
|
+
const all = [...text.matchAll(/(?:^|[^A-Za-z])((?:YN|Y|D|ZN|Z)(?:(?:yn|y|d|zn|z|a|auto)\d{0,2}){1,3})(?![A-Za-z])/g)];
|
|
3055
|
+
const m = all.find((x) => /\d|n/i.test(x[1].slice(1))) ?? all.find((x) => !/a/.test(x[1].slice(1)));
|
|
3056
|
+
if (!m) {
|
|
3057
|
+
const one = text.match(/(?<![A-Za-z])I([ai])(\d{1,2})(?:i\d{1,2})?(?![A-Za-z\d])/);
|
|
3058
|
+
if (!one) return null;
|
|
3059
|
+
return { group: one[0], windings: one[1] === "a" ? ["a"] : [] };
|
|
3060
|
+
}
|
|
3061
|
+
const group = m[1];
|
|
3062
|
+
const windings = [];
|
|
3063
|
+
const re = /(YN|Y|D|ZN|Z|yn|y|d|zn|z|auto|a)\d{0,2}/g;
|
|
3064
|
+
let t;
|
|
3065
|
+
while (t = re.exec(group)) {
|
|
3066
|
+
const w = t[1].toLowerCase();
|
|
3067
|
+
windings.push(w.startsWith("a") ? "a" : w.startsWith("y") ? "Y" : w.startsWith("d") ? "D" : "Z");
|
|
3068
|
+
}
|
|
3069
|
+
return { group, windings };
|
|
3070
|
+
}
|
|
3071
|
+
var THREE_PHASE = /\bthree[\s-]?phase|\b3[\s-]?ph(?:ase)?\b(?!\s*\d+\s*V\b)|三相/i;
|
|
3072
|
+
var CN_MODEL = /\b(O?[SD][A-Z]*Z[A-Z0-9]*)-(\d{3,7})\/(\d{2,3})\b/;
|
|
3073
|
+
var RU_MODEL = /(?<![А-Яа-яЁёA-Za-z])(А?[ОТ][А-ЯЁ]*)-(\d{3,6})\/(\d{2,3})(?!\d)/u;
|
|
3074
|
+
var THREE_X = new RegExp(String.raw`\b3\s*x\s*(${NUM})\s*MVA`, "i");
|
|
3075
|
+
function parseMva(text, threeUnit = true) {
|
|
3076
|
+
const none = { differ: false, unit: false, bank: false };
|
|
3077
|
+
const grouped = /(?<![\d.])[1-9]\d{0,2}\.\d{3}(?![\d.])(?=\s*kVA)/gi;
|
|
3078
|
+
let misread = false;
|
|
3079
|
+
if (grouped.test(text)) {
|
|
3080
|
+
text = text.replace(grouped, (m) => m.replace(".", ""));
|
|
3081
|
+
misread = true;
|
|
3082
|
+
}
|
|
3083
|
+
const unit = text.match(THREE_X);
|
|
3084
|
+
if (threeUnit && unit && !THREE_PHASE.test(text)) return { ...none, mva: Number(unit[1]), unit: true };
|
|
3085
|
+
const notRating = (i) => {
|
|
3086
|
+
const head = text.slice(Math.max(0, i - 30), i);
|
|
3087
|
+
if (/(?:fault|short[\s-]?circuit|\bs?s\.?c\b)[^;,]{0,30}$/i.test(head)) return true;
|
|
3088
|
+
if (/(?:tertiary|stabili\w*|earthing|auxiliary|\baux\b\.?|station\s+service|feeder|losses?\s+at|\bbase)[^;,]{0,25}$/i.test(head)) {
|
|
3089
|
+
return true;
|
|
3090
|
+
}
|
|
3091
|
+
const g = head.match(/(?:network|system|grid)([^;,\d]{0,30})$/i);
|
|
3092
|
+
return g != null && !/transformer|trafo|\bunit\b/i.test(g[1]);
|
|
3093
|
+
};
|
|
3094
|
+
const read = (unitRe, scale) => [...text.matchAll(new RegExp(String.raw`(${NUM})(?:\s*/\s*${NUM})*\s*${unitRe}`, "gi"))].filter((m) => !notRating(m.index ?? 0)).map((m) => (m[0].match(/\d+(?:\.\d+)?/g) ?? []).map((x) => Number(x) / scale)).filter((g) => g.length && g.every((n) => Number.isFinite(n) && n > 0));
|
|
3095
|
+
const first = [
|
|
3096
|
+
...text.matchAll(
|
|
3097
|
+
new RegExp(
|
|
3098
|
+
String.raw`\b(?:rated(?:\s+(?:power|rating|capacity))?|power(?:\s+rating)?|rating|capacity|S[rn])\s*(?:\(\s*([Mk])VA\s*\)|,?\s*([Mk])VA)\s*[:=,]?\s*(${NUM}(?:\s*/\s*${NUM})*)(?![\d.])(?!\s*(?:kV|[±+/]\s*\d|±))`,
|
|
3099
|
+
"gi"
|
|
3100
|
+
)
|
|
3101
|
+
)
|
|
3102
|
+
].map((m) => m[3].split("/").map((x) => Number(x) / (/k/i.test(m[1] ?? m[2] ?? "") ? 1e3 : 1))).filter((g) => g.every((n) => Number.isFinite(n) && n > 0));
|
|
3103
|
+
let all = [...first, ...read(String.raw`MVA(?![a-z])(?!\s*base)`, 1)];
|
|
3104
|
+
if (!all.length) all = read(String.raw`kVA(?![a-z])`, 1e3);
|
|
3105
|
+
if (all.length) {
|
|
3106
|
+
const figs = all.flat();
|
|
3107
|
+
return {
|
|
3108
|
+
mva: Math.max(...figs),
|
|
3109
|
+
differ: new Set(figs).size > 1,
|
|
3110
|
+
unit: false,
|
|
3111
|
+
bank: new RegExp(String.raw`${NUM}\s*[Mk]VA\s*\(?\s*bank\b`, "i").test(text),
|
|
3112
|
+
...misread ? { misread } : {}
|
|
3113
|
+
};
|
|
3114
|
+
}
|
|
3115
|
+
const cn = text.match(CN_MODEL) ?? text.match(RU_MODEL);
|
|
3116
|
+
if (cn) return { ...none, mva: Number(cn[2]) / 1e3 };
|
|
3117
|
+
return { ...none, mva: null };
|
|
3118
|
+
}
|
|
3119
|
+
var POSITIONS = /(?<![±\d.]\s?)(\d{1,2})\s*(?:positions|pos\b|taps|tappings|kademe|posisi)/i;
|
|
3120
|
+
function nearTolerance(text, index) {
|
|
3121
|
+
return /(?:\bu[kz]\b|\bimpedance|\btoler|偏差|阻抗)/i.test(text.slice(Math.max(0, index - 30), index));
|
|
3122
|
+
}
|
|
3123
|
+
function splitPercentRange(plusPct, minusPct, total) {
|
|
3124
|
+
const a = Math.round(plusPct * 1e3);
|
|
3125
|
+
const b = Math.round(minusPct * 1e3);
|
|
3126
|
+
const span = a + b;
|
|
3127
|
+
if (!(span > 0)) return null;
|
|
3128
|
+
const tries = total ? [total] : Array.from({ length: 19 }, (_, i) => 16 + i);
|
|
3129
|
+
for (const n of tries) {
|
|
3130
|
+
if (span % n) continue;
|
|
3131
|
+
const s = span / n;
|
|
3132
|
+
if (a % s || b % s) continue;
|
|
3133
|
+
return { plus: a / s, minus: b / s, stepPct: s / 1e3 };
|
|
3134
|
+
}
|
|
3135
|
+
return null;
|
|
3136
|
+
}
|
|
3137
|
+
function percentRange(text, pmCount) {
|
|
3138
|
+
const tapWord = (i) => /(?:tapp\w*|OLTC|regulat\w*|range|tap[\s-]?changer|on[\s-]?load)\W{0,4}(?:range\W{0,3})?$/i.test(
|
|
3139
|
+
text.slice(Math.max(0, i - 20), i)
|
|
3140
|
+
);
|
|
3141
|
+
const otherFigure = (i) => nearTolerance(text, i) || /(?:Hz|frequency|variation|\bu[kz]r?\b|%\s*Z\b|\bZ\b|impedance|toler)[^,;]{0,15}$/i.test(text.slice(Math.max(0, i - 15), i));
|
|
3142
|
+
const hits = [
|
|
3143
|
+
...[...text.matchAll(new RegExp(String.raw`\+\s*(${NUM})\s*%?\s*/?\s*-\s*(${NUM})\s*%`, "g"))].map(
|
|
3144
|
+
(m) => ({ m, plusPct: Number(m[1]), minusPct: Number(m[2]) })
|
|
3145
|
+
),
|
|
3146
|
+
...[...text.matchAll(new RegExp(String.raw`±\s*(${NUM})\s*%`, "g"))].map((m) => ({
|
|
3147
|
+
m,
|
|
3148
|
+
plusPct: Number(m[1]),
|
|
3149
|
+
minusPct: Number(m[1])
|
|
3150
|
+
}))
|
|
3151
|
+
].map((h) => ({ ...h, tap: tapWord(h.m.index ?? 0) })).filter((h) => h.tap || !otherFigure(h.m.index ?? 0)).filter((h) => h.plusPct + h.minusPct > 0 && h.plusPct <= 50 && h.minusPct <= 50).sort((x, y) => Number(y.tap) - Number(x.tap) || (x.m.index ?? 0) - (y.m.index ?? 0));
|
|
3152
|
+
for (let i = 0; i < hits.length; i++) {
|
|
3153
|
+
const r = percentHit(text, hits[i], pmCount);
|
|
3154
|
+
if (r?.unread && i < hits.length - 1) continue;
|
|
3155
|
+
if (r) return r;
|
|
3156
|
+
}
|
|
3157
|
+
return null;
|
|
3158
|
+
}
|
|
3159
|
+
function percentHit(text, h, pmCount) {
|
|
3160
|
+
const { plusPct, minusPct } = h;
|
|
3161
|
+
const index = h.m.index ?? 0;
|
|
3162
|
+
const end = index + h.m[0].length;
|
|
3163
|
+
const pctText = h.m[0].trim();
|
|
3164
|
+
const span = plusPct + minusPct;
|
|
3165
|
+
const nx = text.match(new RegExp(String.raw`(?<![±+\-\d.])(\d{1,2})\s*x\s*(${NUM})\s*%`));
|
|
3166
|
+
const xs = text.match(new RegExp(String.raw`x\s*(${NUM})\s*%`));
|
|
3167
|
+
const stepWord = statedStep(text);
|
|
3168
|
+
const posM = text.match(POSITIONS);
|
|
3169
|
+
const countM = text.slice(end, end + 40).match(/^\s*[,(]?\s*(?:(?:linear|coarse\W*fine|reversing)\s+)?(?:in\s*)?(\d{1,2})\s*(?:steps|级|档)/i);
|
|
3170
|
+
const positions = posM ? Number(posM[1]) : null;
|
|
3171
|
+
let step = null;
|
|
3172
|
+
let total;
|
|
3173
|
+
if (nx) {
|
|
3174
|
+
step = Number(nx[2]);
|
|
3175
|
+
total = Number(nx[1]);
|
|
3176
|
+
} else if (xs) step = Number(xs[1]);
|
|
3177
|
+
else if (stepWord != null) step = stepWord;
|
|
3178
|
+
else if (pmCount && pmCount >= 2 && h.plusPct === h.minusPct && minusPct <= 3 && COMMON_STEPS.some((c) => Math.abs(minusPct - c) <= c * 0.01)) {
|
|
3179
|
+
return { plus: pmCount, minus: pmCount, stepPct: minusPct, index, end, pct: { text: pctText, stated: true } };
|
|
3180
|
+
} else if (pmCount) step = (h.plusPct === h.minusPct ? minusPct : span / 2) / pmCount;
|
|
3181
|
+
else if (positions != null && positions > 2) step = span / (positions - 1);
|
|
3182
|
+
else if (countM) total = Number(countM[1]);
|
|
3183
|
+
let plus;
|
|
3184
|
+
let minus;
|
|
3185
|
+
let stepPct;
|
|
3186
|
+
let stated = true;
|
|
3187
|
+
if (step != null && step > 0 && step <= 10) {
|
|
3188
|
+
plus = Math.round(plusPct / step);
|
|
3189
|
+
minus = Math.round(minusPct / step);
|
|
3190
|
+
stepPct = Math.round(step * 1e4) / 1e4;
|
|
3191
|
+
} else {
|
|
3192
|
+
const split = total ? splitPercentRange(plusPct, minusPct, total) : null;
|
|
3193
|
+
if (split) ({ plus, minus, stepPct } = split);
|
|
3194
|
+
else {
|
|
3195
|
+
if (span <= 10) return { plus: 0, minus: 0, stepPct: null, index, end, unread: pctText };
|
|
3196
|
+
stated = false;
|
|
3197
|
+
const auto = splitPercentRange(plusPct, minusPct);
|
|
3198
|
+
if (auto) ({ plus, minus, stepPct } = auto);
|
|
3199
|
+
else {
|
|
3200
|
+
plus = Math.round(plusPct / 1.25);
|
|
3201
|
+
minus = Math.round(minusPct / 1.25);
|
|
3202
|
+
stepPct = 1.25;
|
|
3203
|
+
}
|
|
3204
|
+
}
|
|
3205
|
+
}
|
|
3206
|
+
if (plus + minus === 0) return null;
|
|
3207
|
+
return { plus, minus, stepPct, index, end, pct: { text: pctText, stated } };
|
|
3208
|
+
}
|
|
3209
|
+
function statedStep(text) {
|
|
3210
|
+
const res = [
|
|
3211
|
+
String.raw`(${NUM})\s*%\s*(?:per\s*step|\/\s*step|each\s+step|steps?)\b`,
|
|
3212
|
+
String.raw`\bsteps?\s+of\s+(${NUM})\s*%`,
|
|
3213
|
+
String.raw`\bstep(?:\s+voltage)?\s*[:=]?\s*(${NUM})\s*%`,
|
|
3214
|
+
String.raw`\bU\s?st\b[^;%]{0,25}?(?:=|\()\s*(${NUM})\s*%`
|
|
3215
|
+
];
|
|
3216
|
+
for (const re of res) {
|
|
3217
|
+
const m = text.match(new RegExp(re, "i"));
|
|
3218
|
+
const s = m ? Number(m[1]) : NaN;
|
|
3219
|
+
if (s > 0 && s <= 10) return s;
|
|
3220
|
+
}
|
|
3221
|
+
return null;
|
|
3222
|
+
}
|
|
3223
|
+
function countRange(text) {
|
|
3224
|
+
const pos = text.match(/(?<![±+\-\d.]\s?)\b(\d{1,2})\s*(?:positions|tap\s+positions|pos\b|kademe|posisi)/i) ?? text.match(/\bpositions?\s*(?:of\s+)?[:=]?\s*(\d{1,2})\b(?!\s*%)/i) ?? text.match(/\b(?:OLTC|tap\w*|positions?)\s*:?\s*1\s*(?:-|~|…|to)\s*(\d{1,2})\b(?![\d.]*\s*(?:%|kV))/i);
|
|
3225
|
+
const steps = text.match(/(?<![±+\-\d.x]\s?)\b(\d{1,2})\s*steps\b/i);
|
|
3226
|
+
let n = null;
|
|
3227
|
+
let m = null;
|
|
3228
|
+
if (pos && Number(pos[1]) >= 3 && (Number(pos[1]) - 1) % 2 === 0) {
|
|
3229
|
+
n = (Number(pos[1]) - 1) / 2;
|
|
3230
|
+
m = pos;
|
|
3231
|
+
} else if (steps && Number(steps[1]) >= 2 && Number(steps[1]) % 2 === 0) {
|
|
3232
|
+
n = Number(steps[1]) / 2;
|
|
3233
|
+
m = steps;
|
|
3234
|
+
}
|
|
3235
|
+
if (n == null || m == null) return null;
|
|
3236
|
+
const index = m.index ?? 0;
|
|
3237
|
+
return { plus: n, minus: n, stepPct: statedStep(text), index, end: index + m[0].length, guessed: true };
|
|
3238
|
+
}
|
|
3239
|
+
var COMMON_STEPS = [0.625, 0.833, 1, 1.25, 1.5, 1.67, 1.78, 2, 2.5, 3];
|
|
3240
|
+
var STEP_AFTER = new RegExp(
|
|
3241
|
+
String.raw`^\s*(?:(?:steps?|taps?|positions?)\s*)?(of|x|@)?\s*(\()?\s*(${NUM})\s*%\s*(per\s*step|each|steps?\b)?`,
|
|
3242
|
+
"i"
|
|
3243
|
+
);
|
|
3244
|
+
function stepHits(text) {
|
|
3245
|
+
const sym = new RegExp(String.raw`±\s*(\d{1,2})(?![\d.]*\s*%)\s*(?:x\s*(${NUM})\s*%)?`, "g");
|
|
3246
|
+
const asym = new RegExp(
|
|
3247
|
+
String.raw`\+\s*(\d{1,2})(?![\d.]*\s*%)\s*/?\s*-\s*(\d{1,2})(?![\d.]*\s*%)\s*(?:x\s*(${NUM})\s*%)?`,
|
|
3248
|
+
"g"
|
|
3249
|
+
);
|
|
3250
|
+
return [
|
|
3251
|
+
...[...text.matchAll(sym)].map((m) => ({ m, plus: Number(m[1]), minus: Number(m[1]), step: m[2] })),
|
|
3252
|
+
...[...text.matchAll(asym)].map((m) => ({ m, plus: Number(m[1]), minus: Number(m[2]), step: m[3] }))
|
|
3253
|
+
].map((h) => {
|
|
3254
|
+
const index = h.m.index ?? 0;
|
|
3255
|
+
let end = index + h.m[0].length;
|
|
3256
|
+
let stepPct = h.step ? Number(h.step) : null;
|
|
3257
|
+
const a = stepPct == null ? text.slice(end, end + 30).match(STEP_AFTER) : null;
|
|
3258
|
+
if (a) {
|
|
3259
|
+
const s = Number(a[3]);
|
|
3260
|
+
const n = Math.max(h.plus, h.minus);
|
|
3261
|
+
const total = n >= 2 && COMMON_STEPS.some((c) => Math.abs(s / n - c) <= c * 0.01);
|
|
3262
|
+
if (s > 0 && s <= 10 && (a[1] != null || a[4] != null || s <= 5 && !total)) {
|
|
3263
|
+
stepPct = s;
|
|
3264
|
+
end += a[0].length;
|
|
3265
|
+
}
|
|
3266
|
+
}
|
|
3267
|
+
return { plus: h.plus, minus: h.minus, stepPct, index, end };
|
|
3268
|
+
}).filter((h) => h.stepPct != null || !nearTolerance(text, h.index)).sort((x, y) => x.index - y.index);
|
|
3269
|
+
}
|
|
3270
|
+
function findRange(text) {
|
|
3271
|
+
const steps = stepHits(text);
|
|
3272
|
+
const s = steps.find((h) => h.plus + h.minus > 0);
|
|
3273
|
+
if (s && s.stepPct != null) return s;
|
|
3274
|
+
const p = percentRange(text, s && s.plus === s.minus ? s.plus : null);
|
|
3275
|
+
if (p) return p;
|
|
3276
|
+
if (s) return { ...s, stepPct: statedStep(text) };
|
|
3277
|
+
if (!steps.length) return countRange(text);
|
|
3278
|
+
const z = steps[0];
|
|
3279
|
+
return z ? { ...z, stepPct: z.stepPct, zero: true } : null;
|
|
3280
|
+
}
|
|
3281
|
+
var OLTC_WORD = /\bOLTC|on[\s-]?load|有载/gi;
|
|
3282
|
+
var OCTC_WORD = /\bDETC|\bOCTC|\bNLTC|off[\s-]?circuit|de-?energi[sz]ed|无载|无励磁/gi;
|
|
3283
|
+
var ON_LOAD_ANY = /\bOLTC\b|\bon[\s-]?load\b|有载|bajo\s+carga|\bcó\s+tải|\bberbeban\b|yük\s+altında/i;
|
|
3284
|
+
var DRY_TYPE = /\bdry[\s-]?type\b|\bcast[\s-]?resin\b|\bresin[\s-]?(?:cast|encapsulated|insulated)\b|干式|\btransformador(?:es)?\s+(?:tipo\s+)?seco|\bkuru\s+tip|\bmáy\s+biến\s+(?:áp|thế)\s+khô|\btrafo\s+kering|\btransformator\s+kering/i;
|
|
3285
|
+
var OFF_CIRCUIT_TAP = new RegExp(
|
|
3286
|
+
[
|
|
3287
|
+
String.raw`\b(?:DETC|OCTC|NLTC)\b`,
|
|
3288
|
+
String.raw`\b(?:off[\s-]?(?:circuit|load)|no[\s-]?load|de-?energi[sz]ed)\s+tap`,
|
|
3289
|
+
String.raw`\btap[\s-]?chang\w*\s*[(:,-]?\s*(?:off[\s-]?(?:circuit|load)|no[\s-]?load|de-?energi[sz]ed)`,
|
|
3290
|
+
String.raw`(?:conmutador|cambiador)[^,;.]{0,30}(?:sin\s+carga|desenergizad)`,
|
|
3291
|
+
String.raw`(?:chuyển|đổi)\s+nấc[^,;.]{0,20}không\s+tải`,
|
|
3292
|
+
String.raw`(?:pengubah|perubah)\s+tap[^,;.]{0,20}tanpa\s+beban`,
|
|
3293
|
+
String.raw`yüksüz\s+kademe`,
|
|
3294
|
+
"\u65E0\u8F7D",
|
|
3295
|
+
"\u65E0\u52B1\u78C1"
|
|
3296
|
+
].join("|"),
|
|
3297
|
+
"i"
|
|
3298
|
+
);
|
|
3299
|
+
function dutyTag(text, hits, i) {
|
|
3300
|
+
const h = hits[i];
|
|
3301
|
+
const prevEnd = i > 0 ? hits[i - 1].end : 0;
|
|
3302
|
+
const nextStart = i + 1 < hits.length ? hits[i + 1].index : text.length;
|
|
3303
|
+
const head = text.slice(prevEnd, h.index);
|
|
3304
|
+
const cut = Math.max(head.lastIndexOf(","), head.lastIndexOf(";"), head.lastIndexOf(")"), head.lastIndexOf("("));
|
|
3305
|
+
const before = head.slice(cut + 1);
|
|
3306
|
+
const tailAll = text.slice(h.end, nextStart);
|
|
3307
|
+
const stop = tailAll.search(/[,;)]/);
|
|
3308
|
+
const after = stop < 0 ? tailAll : tailAll.slice(0, stop + 1);
|
|
3309
|
+
let best = null;
|
|
3310
|
+
for (const [re, d] of [[OLTC_WORD, "oltc"], [OCTC_WORD, "octc"]]) {
|
|
3311
|
+
for (const m2 of before.matchAll(re)) {
|
|
3312
|
+
const dist = before.length - ((m2.index ?? 0) + m2[0].length);
|
|
3313
|
+
if (!best || dist < best.dist) best = { d, dist };
|
|
3314
|
+
}
|
|
3315
|
+
const m = after.match(new RegExp(re.source, "i"));
|
|
3316
|
+
if (m && (!best || (m.index ?? 0) < best.dist)) best = { d, dist: m.index ?? 0 };
|
|
3317
|
+
}
|
|
3318
|
+
return best?.d ?? null;
|
|
3319
|
+
}
|
|
3320
|
+
var SIDE = String.raw`(LV|MV|HV|low[\s-]voltage|high[\s-]voltage|secondary)`;
|
|
3321
|
+
function sideIndex(side, n, auto) {
|
|
3322
|
+
const s = side.toLowerCase();
|
|
3323
|
+
if (/^(?:lv|low|secondary)/.test(s)) return n - 1;
|
|
3324
|
+
if (/^mv/.test(s)) return n === 3 || auto ? 1 : null;
|
|
3325
|
+
if (/^(?:hv|high)/.test(s)) return 0;
|
|
3326
|
+
return null;
|
|
3327
|
+
}
|
|
3328
|
+
function sideAfter(text, end) {
|
|
3329
|
+
const tail = text.slice(end, end + 30);
|
|
3330
|
+
const m = tail.match(new RegExp(String.raw`^\s*\(?\s*(?:(?:on|in|at)\s+(?:the\s+)?${SIDE}\b|${SIDE}\s+tapping)`, "i"));
|
|
3331
|
+
if (m) return { side: m[1] ?? m[2] };
|
|
3332
|
+
const k = tail.match(new RegExp(String.raw`^\s*\(?\s*on\s+(?:the\s+)?(${NUM})\s*kV(?![A-Za-z])(?:\s+(?:side|winding))?`, "i"));
|
|
3333
|
+
return k ? { kv: Number(k[1]) } : null;
|
|
3334
|
+
}
|
|
3335
|
+
function sideBefore(text, index) {
|
|
3336
|
+
const head = text.slice(Math.max(0, index - 40), index);
|
|
3337
|
+
const m = head.match(
|
|
3338
|
+
// "HV/LV ±8" names both sides; the trailing LV is not the tapped one.
|
|
3339
|
+
// 2026-11-04 R4: "MV OCTC ±2x2.5%", "MV DETC ±…", "MV off-circuit taps ±…": up to two
|
|
3340
|
+
// duty or tap words between the side and the range (the range went on the HV, 65 % low).
|
|
3341
|
+
new RegExp(
|
|
3342
|
+
String.raw`(?<!\/\s*)\b${SIDE}\s*(?:side\s*)?(?:(?:OLTC|OCTC|DETC|NLTC|off[\s-]?(?:circuit|load)|on[\s-]?load|tap[\s-]?changer|taps?|tapp\w*|regulat\w*|winding)\s*){0,2}[:\-]?\s*$`,
|
|
3343
|
+
"i"
|
|
3344
|
+
)
|
|
3345
|
+
);
|
|
3346
|
+
return m ? { side: m[1] } : null;
|
|
3347
|
+
}
|
|
3348
|
+
function tapWindingFromWords(text, range, kv, auto) {
|
|
3349
|
+
if (kv.length < 2) return null;
|
|
3350
|
+
const at = (w2) => {
|
|
3351
|
+
if (!w2) return null;
|
|
3352
|
+
if (w2.kv != null) return kv.indexOf(w2.kv) >= 0 ? kv.indexOf(w2.kv) : null;
|
|
3353
|
+
return w2.side ? sideIndex(w2.side, kv.length, auto) : null;
|
|
3354
|
+
};
|
|
3355
|
+
const own = range ? at(sideAfter(text, range.end)) ?? at(sideBefore(text, range.index)) : null;
|
|
3356
|
+
if (own != null) return own;
|
|
3357
|
+
const lead = String.raw`(?:OLTC|tapp\w*|regulat\w*|tap[\s-]?changer|on[\s-]?load)[^;.,]{0,25}?`;
|
|
3358
|
+
const m = text.match(
|
|
3359
|
+
new RegExp(
|
|
3360
|
+
String.raw`${lead}\b(?:on|in|at)\s+(?:the\s+)?${SIDE}\b|\((LV|MV) tapping\)|${lead}\b(?:on|in|at)\s+(?:the\s+)?(${NUM})\s*kV(?![A-Za-z])|\btapped\s+winding\s*[:=]?\s*${SIDE}\b|\b(?:OLTC|regulat\w*)\s+(${NUM})\s*kV\s*(?=±|\+)`,
|
|
3361
|
+
"i"
|
|
3362
|
+
)
|
|
3363
|
+
);
|
|
3364
|
+
if (m) {
|
|
3365
|
+
const k = m[3] ?? m[5];
|
|
3366
|
+
return at(k != null ? { kv: Number(k) } : { side: m[1] ?? m[2] ?? m[4] });
|
|
3367
|
+
}
|
|
3368
|
+
const site = text.match(
|
|
3369
|
+
new RegExp(
|
|
3370
|
+
String.raw`\b(?:on|at|in)\s+(?:the\s+)?(${NUM})\s*kV\s+(?:line[\s-]?end|side|terminals?)\b(?!\s*(?:LI|BIL|AC|insulation|[:=]?\s*\d))` + String.raw`|\bfor\s+(${NUM})\s*kV\s+(?:voltage\s+)?variation` + String.raw`|\b(IV|intermediate[\s-]voltage)\s+(?:line[\s-]?end|side|terminals?)\b` + String.raw`|\b(?:at|on)\s+(?:the\s+)?(LV|low[\s-]voltage)\s+(?:transformer\s+)?terminals?\b`,
|
|
3371
|
+
"i"
|
|
3372
|
+
)
|
|
3373
|
+
);
|
|
3374
|
+
if (site) {
|
|
3375
|
+
const k = site[1] ?? site[2];
|
|
3376
|
+
if (k != null) return at({ kv: Number(k) });
|
|
3377
|
+
return at({ side: site[3] ? "MV" : "LV" });
|
|
3378
|
+
}
|
|
3379
|
+
const cn = text.match(/([低中高])压侧(?:有载)?(?:调压|分接)|(?:调压|分接)[^,;,;]{0,6}?([低中高])压侧/);
|
|
3380
|
+
if (!cn) return null;
|
|
3381
|
+
const w = cn[1] ?? cn[2];
|
|
3382
|
+
return w === "\u4F4E" ? kv.length - 1 : w === "\u9AD8" ? 0 : kv.length === 3 || auto ? 1 : null;
|
|
3383
|
+
}
|
|
3384
|
+
var DUTY_TAG = String.raw`(?:\s*\(\s*(OLTC|OCTC|DETC|NLTC|on[\s-]?load|off[\s-]?circuit)\s*\))?`;
|
|
3385
|
+
var RANGE_AT_START = new RegExp(
|
|
3386
|
+
String.raw`^\s*(?:±\s*(\d{1,2})|\+\s*(\d{1,2})\s*/?\s*-\s*(\d{1,2}))(?![\d.]*\s*%)\s*(?:x\s*(${NUM})\s*%)?`
|
|
3387
|
+
);
|
|
3388
|
+
var NOT_WINDING = /\b(?:BIL|LIWL|LI|SIL|AC|Um|insulation|withstand|impulse|lightning|switching|power[\s-]?frequency|test|applied|induced|highest|max(?:imum)?\.?(?:\s+system)?|equipment)\b[^\d]{0,20}$/i;
|
|
3389
|
+
var AFTER_LABEL = /^\s*(?:kV\s*)?(?:BIL|LIWL|LI|SIL|Um|impulse|lightning|power[\s-]?frequency|withstand|test)\b(?![^,;\d]{0,30}\d)/i;
|
|
3390
|
+
var UN_UM = { 11: 12, 33: 36, 66: 72.5, 110: 123, 132: 145, 150: 170, 220: 245, 230: 245 };
|
|
3391
|
+
function clauseBefore(text, at) {
|
|
3392
|
+
return text.slice(Math.max(0, at - 30), at).split(/[,;]|\)(?=\s*[A-Za-z])/).pop() ?? "";
|
|
3393
|
+
}
|
|
3394
|
+
function inInsulationList(text, at) {
|
|
3395
|
+
const clauses = text.slice(0, at).split(/[,;]/);
|
|
3396
|
+
for (let i = clauses.length - 1; i >= 0; i--) {
|
|
3397
|
+
const c = clauses[i];
|
|
3398
|
+
if (i === clauses.length - 1 && /^\s*(?:HV|MV|LV)\s*\/\s*(?:MV|LV)\b/i.test(c)) return false;
|
|
3399
|
+
if (/^\s*(?:insulation|LI\b|LIWL|BIL|AC\b|test|withstand|impulse|lightning)/i.test(c)) return true;
|
|
3400
|
+
if (!/^\s*(?:HV|MV|LV|HVN|N|neutral|tertiary|line[\s-]?end)\b/i.test(c)) return false;
|
|
3401
|
+
}
|
|
3402
|
+
return false;
|
|
3403
|
+
}
|
|
3404
|
+
function findVoltages(text, range, lone) {
|
|
3405
|
+
if (range) {
|
|
3406
|
+
const before = text.slice(0, range.index);
|
|
3407
|
+
const after = text.slice(range.end);
|
|
3408
|
+
const continues = new RegExp(String.raw`^${DUTY_TAG}\s*(?:kV)?\s*/\s*${NUM}`, "i").test(after);
|
|
3409
|
+
const own = before.match(
|
|
3410
|
+
new RegExp(continues ? String.raw`(${NUM})\s*(?:kV)?\s*$` : String.raw`(${NUM})\s*$`, "i")
|
|
3411
|
+
);
|
|
3412
|
+
if (own) {
|
|
3413
|
+
const left = [];
|
|
3414
|
+
let head = before.slice(0, own.index);
|
|
3415
|
+
for (; ; ) {
|
|
3416
|
+
const m = head.match(new RegExp(String.raw`(${NUM})\s*(?:kV)?\s*/\s*$`, "i"));
|
|
3417
|
+
if (!m) break;
|
|
3418
|
+
left.unshift(Number(m[1]));
|
|
3419
|
+
head = head.slice(0, m.index);
|
|
3420
|
+
}
|
|
3421
|
+
const right = [];
|
|
3422
|
+
const extra = [];
|
|
3423
|
+
let tail = after;
|
|
3424
|
+
for (; ; ) {
|
|
3425
|
+
const m = tail.match(new RegExp(String.raw`^${DUTY_TAG}\s*(?:kV)?\s*/\s*(${NUM})`, "i"));
|
|
3426
|
+
if (!m) break;
|
|
3427
|
+
right.push(Number(m[2]));
|
|
3428
|
+
tail = tail.slice(m[0].length);
|
|
3429
|
+
const r = tail.match(RANGE_AT_START);
|
|
3430
|
+
if (r) {
|
|
3431
|
+
const plus = Number(r[1] ?? r[2]);
|
|
3432
|
+
const minus = Number(r[1] ?? r[3]);
|
|
3433
|
+
tail = tail.slice(r[0].length);
|
|
3434
|
+
const tag = tail.match(new RegExp(String.raw`^${DUTY_TAG}`, "i"))?.[1];
|
|
3435
|
+
if (plus + minus > 0) {
|
|
3436
|
+
extra.push({
|
|
3437
|
+
at: left.length + right.length,
|
|
3438
|
+
plus,
|
|
3439
|
+
minus,
|
|
3440
|
+
stepPct: r[4] ? Number(r[4]) : null,
|
|
3441
|
+
...tag && new RegExp(OCTC_WORD.source, "i").test(tag) ? { offCircuit: true } : {}
|
|
3442
|
+
});
|
|
3443
|
+
}
|
|
3444
|
+
}
|
|
3445
|
+
}
|
|
3446
|
+
let kv2 = [...left, Number(own[1]), ...right];
|
|
3447
|
+
if (/^\s*V\b/.test(tail) && kv2.some((n) => n > 1200)) kv2 = kv2.map((n) => n / 1e3);
|
|
3448
|
+
else if (/^\s*V\b/.test(tail) && /kV/i.test(own[0]) && right.length) {
|
|
3449
|
+
kv2 = [...left, Number(own[1]), ...right.map((n) => n / 1e3)];
|
|
3450
|
+
}
|
|
3451
|
+
const standalone = !continues && left.length > 0 && /\s$/.test(own[0]);
|
|
3452
|
+
if (kv2.length >= 2) return { kv: kv2, tapIndex: standalone ? null : left.length, extra };
|
|
3453
|
+
}
|
|
3454
|
+
}
|
|
3455
|
+
const chains = [
|
|
3456
|
+
...text.matchAll(new RegExp(String.raw`(${NUM}(?:\s*(?:kV)?\s*/\s*${NUM}){1,2})\s*kV(?![Ap])`, "gi"))
|
|
3457
|
+
].filter((m) => !/[%x]\s*$/i.test(text.slice(Math.max(0, (m.index ?? 0) - 2), m.index ?? 0))).map((m) => {
|
|
3458
|
+
const head = text.slice(Math.max(0, (m.index ?? 0) - 30), m.index ?? 0);
|
|
3459
|
+
const at = m.index ?? 0;
|
|
3460
|
+
const end = at + m[0].length;
|
|
3461
|
+
const c = m[1].split("/").map((x) => Number(x.replace(/kV/i, "").trim()));
|
|
3462
|
+
const unUm = c.length === 2 && (UN_UM[c[0]] === c[1] || /^\s*\(?\s*(?:U[nr]\s*\/\s*)?Um\b(?!\s*[:=]?\s*\d)/i.test(text.slice(end, end + 12)));
|
|
3463
|
+
return {
|
|
3464
|
+
c: unUm ? [c[0]] : c,
|
|
3465
|
+
at,
|
|
3466
|
+
end,
|
|
3467
|
+
unUm,
|
|
3468
|
+
// A ratio word before it, or the range right beside it, names the ratio.
|
|
3469
|
+
// 2026-11-04 R4: "voltage 132/33 kV" after an insulation list is the ratio too.
|
|
3470
|
+
ratio: /(?:ratio|rated\s+voltage|nominal|\bU[rn]\b|(?<!(?:test|impulse|highest|max\w*|system)\s+)\bvoltages?\b)[^\d]{0,20}$/i.test(head),
|
|
3471
|
+
near: range != null && (/^\s*$/.test(text.slice(end, range.index)) || /^\s*$/.test(text.slice(range.end, at)))
|
|
3472
|
+
};
|
|
3473
|
+
}).filter(
|
|
3474
|
+
(x) => x.unUm || !NOT_WINDING.test(clauseBefore(text, x.at)) && !AFTER_LABEL.test(text.slice(x.end, x.end + 50)) && !inInsulationList(text, x.at)
|
|
3475
|
+
).filter((x) => x.c.every((n) => n > 0.2 && n < 1200));
|
|
3476
|
+
if (chains.length) {
|
|
3477
|
+
chains.sort(
|
|
3478
|
+
(a, b) => Number(b.ratio) - Number(a.ratio) || Number(b.near) - Number(a.near) || b.c.length - a.c.length || a.at - b.at
|
|
3479
|
+
);
|
|
3480
|
+
return { kv: chains[0].c, tapIndex: null, extra: [] };
|
|
3481
|
+
}
|
|
3482
|
+
const cn = text.match(CN_MODEL) ?? text.match(RU_MODEL);
|
|
3483
|
+
if (cn) return { kv: [Number(cn[3])], tapIndex: null, extra: [] };
|
|
3484
|
+
if (!lone) return { kv: [], tapIndex: null, extra: [] };
|
|
3485
|
+
const hits = [...text.matchAll(new RegExp(String.raw`(?<![A-Za-z/\d.])(${NUM})\s*(?:±[^,;/]{0,25}?%\s*)?kV(?![Ap])`, "gi"))].map((m) => ({ kv: Number(m[1]), index: m.index ?? 0, end: (m.index ?? 0) + m[0].length })).filter((h) => h.kv > 0.2 && h.kv < 1200).filter((h) => {
|
|
3486
|
+
const head = clauseBefore(text, h.index);
|
|
3487
|
+
return !NOT_WINDING.test(head) && !/\bneutral\b[^\d]{0,20}$/i.test(head) && !AFTER_LABEL.test(text.slice(h.end, h.end + 50));
|
|
3488
|
+
});
|
|
3489
|
+
const kv = [...new Set(hits.map((h) => h.kv))].sort((a, b) => b - a);
|
|
3490
|
+
if (!kv.length || kv.length > 3) return { kv: [], tapIndex: null, extra: [] };
|
|
3491
|
+
const direct = range ? hits.find(
|
|
3492
|
+
(h, i) => (
|
|
3493
|
+
// "132±10x1.25% kV": the range inside the figure is its own.
|
|
3494
|
+
h.index < range.index && h.end >= range.end || h.end <= range.index && /^\s*$/.test(text.slice(h.end, range.index)) && !(i > 0 && /^\s*\/\s*$/.test(text.slice(hits[i - 1].end, h.index)))
|
|
3495
|
+
)
|
|
3496
|
+
) : void 0;
|
|
3497
|
+
const written = [...new Set(hits.map((h) => h.kv))];
|
|
3498
|
+
const reordered = written.some((k, i) => kv[i] !== k);
|
|
3499
|
+
return { kv, tapIndex: direct ? kv.indexOf(direct.kv) : null, extra: [], ...reordered ? { reordered } : {} };
|
|
3500
|
+
}
|
|
3501
|
+
function autoText(text) {
|
|
3502
|
+
if (/\bauto[\s-]?(?:transformers?|trafo|TR)\b|\bautotrafo|自耦/i.test(text) || // 2026-11-04 R3: Spanish, French, German, Russian, Vietnamese and Turkish words.
|
|
3503
|
+
/\bautotransforma(?:dor|teur|tor)\w*|автотрансформатор|\btự\s*ngẫu|\boto[\s-]?(?:trafo|transformat)\w*/i.test(text) || /\bauto\b(?!\s*[/)]|[\s-]*(?:control|mode|operation|start|reclos|tap|voltage|changeover|transfer|reset|cooling|fan|pump|manual|AVR))(?<!(?:manual|hand|\(|AVR)\s*\/?\s*auto)/i.test(text) || // 2026-11-04 R2: PLN "IBT" and the Rosseti АТДЦТН / АОДЦТН models were two-winding.
|
|
3504
|
+
/\bIBT\b|\b[Ii]nter[\s-]?bus\s+transformer/.test(text) || /(?<![А-ЯЁа-яё])А[ОТ]Д[А-ЯЁ]*-\d/u.test(text) || /\bA[OT]D[A-Z]*-\d|\bO[SD][A-Z]*Z[A-Z0-9]*-\d/.test(text)) {
|
|
3505
|
+
return "word";
|
|
3506
|
+
}
|
|
3507
|
+
return /\bAT-?\d{1,2}\b|\bAT\s+\d+(?:\.\d+)?\s*MVA/.test(text) ? "at" : null;
|
|
3508
|
+
}
|
|
3509
|
+
var DELTA_TAP = /(?:regulat\w*|tapp\w*|OLTC)\b(?:(?!\b(?:LV|MV|secondary|tertiary|low[\s-]voltage)\b)[^;.]){0,40}\bdelta\b|\bHV\b[\s:]*(?:winding\s*)?(?:is\s*)?delta\b|\bHV\b\s*[:=]\s*D\b|\bdelta[\s-]connected\s+HV\b|\bdelta[\s/-]*star\b|(?<!\b(?:LV|MV|secondary|tertiary)\b[\s:]*)\bD[\s-]?connection\b|三角形调压|角接调压/i;
|
|
3510
|
+
var DELTA_OTHER = /\b(?:LV|MV|tertiary|secondary|stabili[sz]ing|low[\s-]voltage)\b(?:(?!\bHV\b|\bstar\b)[^;.,]){0,25}\b(?:delta|D[\s-]?connect)|\bdelta\s+(?:tertiary|stabili)|star\s*\/\s*delta/i;
|
|
3511
|
+
var STAR_TAP = /(?:regulat\w*|tapp\w*|OLTC|tap[\s-]?changer)[^;.,]{0,40}?(?<!\b(?:LV|MV|secondary|tertiary|kV)\s+)(?<!\bnot\s+(?:in|at)?\s*(?:the\s+)?)\b(?:star[\s-]?point|neutral)\b(?![\s-]*(?:point\s+)?(?:is\s+)?(?:solidly\s+)?(?:earthed|grounded))|(?<!\b(?:LV|MV|secondary|tertiary|kV)\s+)\bstar neutral\b(?![\s-]*(?:point\s+)?(?:is\s+)?(?:solidly\s+)?(?:earthed|grounded))|\bneutral[\s-]end\s+(?:tapp\w*|regulat\w*|OLTC)|(?<!\bnot\s+)\bin neutral\b|中性点调压/i;
|
|
3512
|
+
var MID_WINDING = /(?:middle|(?:electrical\s+)?cent(?:re|er))\s+of\s+(?:the\s+)?(?:(?:HV|higher|high[\s-]voltage|primary)\s+)?winding|mid[\s-]winding/i;
|
|
3513
|
+
function lineEndTap(text) {
|
|
3514
|
+
for (const m of text.matchAll(/line[\s-]?end|线端/gi)) {
|
|
3515
|
+
const at = m.index ?? 0;
|
|
3516
|
+
const head = text.slice(Math.max(0, at - 25), at);
|
|
3517
|
+
const clause = head.slice(Math.max(head.lastIndexOf(","), head.lastIndexOf(";")) + 1);
|
|
3518
|
+
const after = text.slice(at + m[0].length, at + m[0].length + 12);
|
|
3519
|
+
if (/\b(?:LI|BIL|LIWL|SIL|AC)\b|insulation|withstand|绝缘/i.test(clause)) continue;
|
|
3520
|
+
if (/^\s*(?:\/|\d|LI\b|BIL\b|AC\b|:)/i.test(after)) continue;
|
|
3521
|
+
return true;
|
|
3522
|
+
}
|
|
3523
|
+
return false;
|
|
3524
|
+
}
|
|
3525
|
+
function parseTenderLine(raw) {
|
|
3526
|
+
const text = normalizeTenderText(raw);
|
|
3527
|
+
if (!text) return null;
|
|
3528
|
+
const vg = parseVectorGroup(text);
|
|
3529
|
+
const windings = vg?.windings ?? [];
|
|
3530
|
+
const notes = [];
|
|
3531
|
+
const autoWord = autoText(text);
|
|
3532
|
+
const contradicts = vg != null && windings.length >= 2 && windings[0] !== windings[1];
|
|
3533
|
+
const auto = windings.includes("a") || autoWord != null && !contradicts;
|
|
3534
|
+
if (autoWord != null && contradicts && !windings.includes("a")) {
|
|
3535
|
+
notes.push({ key: "auto_vg", vars: { vg: vg.group } });
|
|
3536
|
+
}
|
|
3537
|
+
let range = findRange(text);
|
|
3538
|
+
let found = findVoltages(text, range?.guessed ? null : range, !auto);
|
|
3539
|
+
const apart = [];
|
|
3540
|
+
const stated = stepHits(text).filter((h) => h.plus + h.minus > 0 && h.stepPct != null).filter((h, i, a) => a.findIndex((o) => o.plus === h.plus && o.minus === h.minus && o.stepPct === h.stepPct) === i);
|
|
3541
|
+
if (!found.extra.length && stated.length >= 2 && range && range.stepPct != null && !range.pct) {
|
|
3542
|
+
const tags = stated.map((_, i) => dutyTag(text, stated, i));
|
|
3543
|
+
const on = stated.filter((_, i) => tags[i] === "oltc");
|
|
3544
|
+
const notOff = stated.filter((_, i) => tags[i] !== "octc");
|
|
3545
|
+
const pool = on.length ? on : notOff.length ? notOff : stated;
|
|
3546
|
+
const main2 = pool.reduce((x, y) => y.plus + y.minus > x.plus + x.minus ? y : x);
|
|
3547
|
+
const siteOf = (h) => {
|
|
3548
|
+
const head = text.slice(0, h.index);
|
|
3549
|
+
const k = head.match(new RegExp(String.raw`(?<![A-Za-z/\d.])(${NUM})(?:\s*kV)?\s*$`, "i"));
|
|
3550
|
+
if (k && !/\/\s*$/.test(head.slice(0, k.index))) return { kv: Number(k[1]) };
|
|
3551
|
+
const zh = head.match(/([高中低])压侧?(?:有载|无载)?(?:调压)?\s*$/);
|
|
3552
|
+
if (zh) return { side: zh[1] === "\u9AD8" ? "HV" : zh[1] === "\u4E2D" ? "MV" : "LV" };
|
|
3553
|
+
return sideAfter(text, h.end) ?? sideBefore(text, h.index);
|
|
3554
|
+
};
|
|
3555
|
+
stated.forEach((h, i) => {
|
|
3556
|
+
if (h !== main2) apart.push({ hit: h, offCircuit: tags[i] === "octc", site: siteOf(h) });
|
|
3557
|
+
});
|
|
3558
|
+
if (main2.index !== range.index) {
|
|
3559
|
+
range = main2;
|
|
3560
|
+
found = findVoltages(text, range, !auto);
|
|
3561
|
+
}
|
|
3562
|
+
}
|
|
3563
|
+
let kv = found.kv;
|
|
3564
|
+
const rangeIndex = found.tapIndex;
|
|
3565
|
+
const singleWord = [
|
|
3566
|
+
...text.matchAll(
|
|
3567
|
+
new RegExp(
|
|
3568
|
+
String.raw`single[\s-]?phase|single[\s-]?ph\b|\b1[\s-]?ph(?:ase)?\b|\b1\s*pha\b|\b(?:1|satu)\s*fasa\b|monof[aá]sic[a-z]*|monophas[a-zéè]*|einphas[a-z]*|однофазн[а-яё]*|\b1\s*[ØΦφ]|(?<=[MkМк][VВ][AА]\s*)per\s+phase\b(?!\s+(?:impedance|reactance|resistance|loss))|单相(?!电源|供电|交流)|\bbank of 3\b`,
|
|
3569
|
+
"gi"
|
|
3570
|
+
)
|
|
3571
|
+
)
|
|
3572
|
+
].some((m) => {
|
|
3573
|
+
const i = m.index ?? 0;
|
|
3574
|
+
const after = text.slice(i + m[0].length, i + m[0].length + 14);
|
|
3575
|
+
const before = text.slice(Math.max(0, i - 25), i);
|
|
3576
|
+
if (/^\W{0,3}(?:\d+\s*V\b|supply|aux|control|motor|fault|short|earth|to\b|auto[\s-]?reclos|reclos|trip)/i.test(after)) {
|
|
3577
|
+
return false;
|
|
3578
|
+
}
|
|
3579
|
+
if (/(?:aux\w*|supply|control|motor|heater|fault|short[\s-]?circuit|\d+\s*V)\W*$/i.test(before)) return false;
|
|
3580
|
+
return !/^bank/i.test(m[0]) || !THREE_PHASE.test(text);
|
|
3581
|
+
});
|
|
3582
|
+
const singleModel = /\bO?D[A-Z]*Z[A-Z0-9]*-\d{3,7}\/\d/.test(text) || /(?<![А-ЯЁа-яё])АО[А-ЯЁ]*-\d/u.test(text) || /(?<![А-ЯЁа-яё])О(?!ПН)[А-ЯЁ]*-\d{3,6}\/\d/u.test(text) || /\bAOD[A-Z]*-\d/.test(text);
|
|
3583
|
+
const rootThree = /\/\s*(?:√|sqrt\s*|v)\s*3\b/i.test(raw) && !THREE_PHASE.test(text);
|
|
3584
|
+
const singleGroup = vg != null && /^I/.test(vg.group);
|
|
3585
|
+
const singleSign = singleWord || singleModel || rootThree || singleGroup;
|
|
3586
|
+
const threeUnit = singleSign || /\bbank\b/i.test(text) || kv.length > 0 && Math.max(...kv) >= 220;
|
|
3587
|
+
const mvaRead = parseMva(text, threeUnit);
|
|
3588
|
+
let mva = mvaRead.mva;
|
|
3589
|
+
if (!kv.length && mva == null && !range && !vg) return null;
|
|
3590
|
+
const assumed = [];
|
|
3591
|
+
if (!vg && autoWord !== "word") assumed.push("kind");
|
|
3592
|
+
const mvaSign = /\d\s*[Mk]VA|[Mk]VA\W{0,6}\d/i.test(text) || CN_MODEL.test(text) || RU_MODEL.test(text);
|
|
3593
|
+
if (mva == null || mvaRead.misread || !mvaSign) assumed.push("mva");
|
|
3594
|
+
if (mvaRead.differ && mva != null) notes.push({ key: "largest_mva", vars: { mva } });
|
|
3595
|
+
const threeX = text.match(THREE_X);
|
|
3596
|
+
if (!threeUnit && threeX && !THREE_PHASE.test(text) && mva != null) notes.push({ key: "quantity", vars: { mva } });
|
|
3597
|
+
const real = range && !range.zero && !range.unread ? range : null;
|
|
3598
|
+
if (!real || real.pct && !real.pct.stated || real.guessed) assumed.push("range");
|
|
3599
|
+
if (range?.zero) notes.push({ key: "zero_range" });
|
|
3600
|
+
if (range?.unread) notes.push({ key: "percent_small", vars: { pct: range.unread } });
|
|
3601
|
+
if (real?.pct) {
|
|
3602
|
+
if (!real.pct.stated) {
|
|
3603
|
+
notes.push({
|
|
3604
|
+
key: "percent",
|
|
3605
|
+
vars: { pct: real.pct.text, plus: real.plus, minus: real.minus, step: real.stepPct ?? 1.25 }
|
|
3606
|
+
});
|
|
3607
|
+
}
|
|
3608
|
+
const pos = text.match(POSITIONS);
|
|
3609
|
+
if (pos && Number(pos[1]) !== real.plus + real.minus + 1) {
|
|
3610
|
+
notes.push({ key: "percent_positions", vars: { pos: pos[1], plus: real.plus, minus: real.minus } });
|
|
3611
|
+
}
|
|
3612
|
+
}
|
|
3613
|
+
if (!auto && kv.length === 3 && real && rangeIndex == null) {
|
|
3614
|
+
const sorted = [...kv].sort((a, b) => b - a);
|
|
3615
|
+
if (sorted[0] / sorted[2] <= 1.35) {
|
|
3616
|
+
notes.push({ key: "tap_ladder", vars: { chain: kv.join("/"), kv: sorted[1] } });
|
|
3617
|
+
kv = [sorted[1]];
|
|
3618
|
+
}
|
|
3619
|
+
}
|
|
3620
|
+
const flipped = kv.length > 1 && kv[0] < kv[kv.length - 1];
|
|
3621
|
+
const voltagesKv = flipped ? [...kv].reverse() : kv;
|
|
3622
|
+
const at = (i) => flipped ? kv.length - 1 - i : i;
|
|
3623
|
+
let tapIndex = rangeIndex != null ? at(rangeIndex) : null;
|
|
3624
|
+
if (tapIndex != null && range?.pct && voltagesKv.length > 1) {
|
|
3625
|
+
const named = tapWindingFromWords(text, range, voltagesKv, auto);
|
|
3626
|
+
if (named != null) tapIndex = named;
|
|
3627
|
+
}
|
|
3628
|
+
if (tapIndex == null && voltagesKv.length) {
|
|
3629
|
+
tapIndex = tapWindingFromWords(text, range, voltagesKv, auto);
|
|
3630
|
+
if (tapIndex == null) {
|
|
3631
|
+
tapIndex = 0;
|
|
3632
|
+
assumed.push("tap_winding");
|
|
3633
|
+
}
|
|
3634
|
+
}
|
|
3635
|
+
let main = real && tapIndex != null ? { tapIndex, plus: real.plus, minus: real.minus, stepPct: real.stepPct } : null;
|
|
3636
|
+
const others = found.extra.filter((e) => e.at < kv.length).map((e) => ({
|
|
3637
|
+
tapIndex: at(e.at),
|
|
3638
|
+
plus: e.plus,
|
|
3639
|
+
minus: e.minus,
|
|
3640
|
+
stepPct: e.stepPct,
|
|
3641
|
+
...e.offCircuit ? { offCircuit: true } : {}
|
|
3642
|
+
}));
|
|
3643
|
+
if (main && others.length) {
|
|
3644
|
+
const all = [main, ...others];
|
|
3645
|
+
const big = all.reduce((x, y) => y.plus + y.minus > x.plus + x.minus ? y : x);
|
|
3646
|
+
main = big;
|
|
3647
|
+
others.splice(0, others.length, ...all.filter((r) => r !== big));
|
|
3648
|
+
tapIndex = big.tapIndex;
|
|
3649
|
+
}
|
|
3650
|
+
if (main) {
|
|
3651
|
+
for (const a of apart) {
|
|
3652
|
+
let ti = null;
|
|
3653
|
+
if (a.site?.kv != null) ti = voltagesKv.indexOf(a.site.kv) >= 0 ? voltagesKv.indexOf(a.site.kv) : null;
|
|
3654
|
+
else if (a.site?.side) ti = sideIndex(a.site.side, voltagesKv.length, auto);
|
|
3655
|
+
others.push({
|
|
3656
|
+
tapIndex: ti ?? main.tapIndex,
|
|
3657
|
+
plus: a.hit.plus,
|
|
3658
|
+
minus: a.hit.minus,
|
|
3659
|
+
stepPct: a.hit.stepPct,
|
|
3660
|
+
offCircuit: a.offCircuit,
|
|
3661
|
+
kvAssumed: ti == null
|
|
3662
|
+
});
|
|
3663
|
+
}
|
|
3664
|
+
}
|
|
3665
|
+
const starTap = STAR_TAP.test(text);
|
|
3666
|
+
const lineEnd = !starTap && lineEndTap(text);
|
|
3667
|
+
const midWinding = !starTap && !lineEnd && MID_WINDING.test(text);
|
|
3668
|
+
const orderGuess = flipped || found.reordered === true;
|
|
3669
|
+
const pointAt = (i) => {
|
|
3670
|
+
let letter = i != null ? windings[i] : void 0;
|
|
3671
|
+
let winding = "star";
|
|
3672
|
+
let tapPoint = "neutral";
|
|
3673
|
+
let windingAssumed = false;
|
|
3674
|
+
let tapPointAssumed = false;
|
|
3675
|
+
let deltaText = false;
|
|
3676
|
+
let mid = false;
|
|
3677
|
+
if (letter == null) {
|
|
3678
|
+
if (DELTA_TAP.test(text) && !DELTA_OTHER.test(text)) letter = "D";
|
|
3679
|
+
else if (starTap) letter = "Y";
|
|
3680
|
+
else if (/\bdelta\b|三角形|角接/i.test(text)) deltaText = true;
|
|
3681
|
+
}
|
|
3682
|
+
if (letter === "D") {
|
|
3683
|
+
winding = "delta";
|
|
3684
|
+
tapPoint = "line_end";
|
|
3685
|
+
} else if (letter === "Y" || letter == null && (lineEnd || midWinding)) {
|
|
3686
|
+
if (letter == null) windingAssumed = true;
|
|
3687
|
+
if (lineEnd || midWinding) {
|
|
3688
|
+
tapPoint = "line_end";
|
|
3689
|
+
mid = midWinding;
|
|
3690
|
+
} else if (!starTap) tapPointAssumed = true;
|
|
3691
|
+
} else {
|
|
3692
|
+
windingAssumed = true;
|
|
3693
|
+
tapPointAssumed = true;
|
|
3694
|
+
}
|
|
3695
|
+
if (i != null && windings[i] != null && orderGuess) {
|
|
3696
|
+
windingAssumed = true;
|
|
3697
|
+
if (!starTap && !lineEnd && !midWinding) tapPointAssumed = true;
|
|
3698
|
+
}
|
|
3699
|
+
return { winding, tapPoint, windingAssumed, tapPointAssumed, zigzag: letter === "Z", deltaText, mid };
|
|
3700
|
+
};
|
|
3701
|
+
const otherRanges = auto ? [] : others.map((r) => {
|
|
3702
|
+
const p2 = pointAt(r.tapIndex);
|
|
3703
|
+
return {
|
|
3704
|
+
...r,
|
|
3705
|
+
kv: voltagesKv[r.tapIndex],
|
|
3706
|
+
winding: p2.winding,
|
|
3707
|
+
tapPoint: p2.tapPoint,
|
|
3708
|
+
windingAssumed: p2.windingAssumed,
|
|
3709
|
+
tapPointAssumed: p2.tapPointAssumed
|
|
3710
|
+
};
|
|
3711
|
+
});
|
|
3712
|
+
for (const r of otherRanges) {
|
|
3713
|
+
const pm = r.plus === r.minus ? `\xB1${r.plus}` : `+${r.plus}/\u2212${r.minus}`;
|
|
3714
|
+
notes.push({ key: "second_range", vars: { kv: r.kv, range: `${pm}${r.stepPct ? ` \xD7 ${r.stepPct} %` : ""}` } });
|
|
3715
|
+
}
|
|
3716
|
+
const phases = mvaRead.unit || singleSign ? "I" : null;
|
|
3717
|
+
if (phases && mvaRead.bank && mva != null) mva = Math.round(mva / 3 * 1e3) / 1e3;
|
|
3718
|
+
if (phases && mva != null) notes.push({ key: "single_phase", vars: { mva } });
|
|
3719
|
+
const topKv = voltagesKv.length ? Math.max(...voltagesKv) : 0;
|
|
3720
|
+
if (mva != null && (mva < 0.2 || mva < 1 && topKv >= 33)) notes.push({ key: "tiny_mva", vars: { mva } });
|
|
3721
|
+
const neutralBilKv = parseNeutralBil(text);
|
|
3722
|
+
const earthLi = text.match(/\bto\s+(?:earth|ground)\b[^;]{0,25}?\b(?:LI|BIL|LIWL)\s*[:=]?\s*(\d{2,4})/i);
|
|
3723
|
+
if (earthLi && neutralBilKv == null) notes.push({ key: "earth_li", vars: { li: Number(earthLi[1]) } });
|
|
3724
|
+
const regulation = /coarse[\s/-]*fine|粗细调/i.test(text) ? "coarse_fine" : /(?<!non[\s-]?)\blinear\b|线性调/i.test(text) ? "linear" : /\brevers|正反调/i.test(text) ? "reversing" : null;
|
|
3725
|
+
const allTags = stated.map((_, i) => dutyTag(text, stated, i));
|
|
3726
|
+
const offCircuitOnly = OFF_CIRCUIT_TAP.test(text) && !ON_LOAD_ANY.test(text) && (stated.length < 2 || allTags.every((d) => d === "octc"));
|
|
3727
|
+
if (offCircuitOnly) notes.push({ key: "off_circuit_line" });
|
|
3728
|
+
const dryType = DRY_TYPE.test(text);
|
|
3729
|
+
const base = {
|
|
3730
|
+
mva,
|
|
3731
|
+
voltagesKv,
|
|
3732
|
+
tapIndex,
|
|
3733
|
+
plus: main?.plus ?? null,
|
|
3734
|
+
minus: main?.minus ?? null,
|
|
3735
|
+
stepPct: main?.stepPct ?? null,
|
|
3736
|
+
vectorGroup: vg?.group ?? null,
|
|
3737
|
+
windings,
|
|
3738
|
+
neutralBilKv,
|
|
3739
|
+
phases,
|
|
3740
|
+
regulation,
|
|
3741
|
+
otherRanges,
|
|
3742
|
+
...offCircuitOnly ? { offCircuitOnly: true } : {},
|
|
3743
|
+
...dryType ? { dryType: true } : {},
|
|
3744
|
+
assumed,
|
|
3745
|
+
notes
|
|
3746
|
+
};
|
|
3747
|
+
if (auto) {
|
|
3748
|
+
const hvKv = voltagesKv[0] ?? null;
|
|
3749
|
+
const mvKv = voltagesKv[1] ?? null;
|
|
3750
|
+
if (hvKv == null || mvKv == null) notes.push({ key: "auto_needs_mv" });
|
|
3751
|
+
const tapPoint = tapIndex === 1 ? "auto_mv_line" : "auto_junction";
|
|
3752
|
+
assumed.push("tap_point");
|
|
3753
|
+
if (tapIndex != null && tapIndex > 1) notes.push({ key: "auto_tertiary" });
|
|
3754
|
+
return {
|
|
3755
|
+
...base,
|
|
3756
|
+
kind: "auto",
|
|
3757
|
+
tapPoint,
|
|
3758
|
+
winding: "star",
|
|
3759
|
+
tapKv: null,
|
|
3760
|
+
hvKv,
|
|
3761
|
+
mvKv,
|
|
3762
|
+
warnings: notes.map(lineNoteEn)
|
|
3763
|
+
};
|
|
3764
|
+
}
|
|
3765
|
+
const tapKv = tapIndex != null ? voltagesKv[tapIndex] ?? null : null;
|
|
3766
|
+
const p = pointAt(tapIndex);
|
|
3767
|
+
if (p.zigzag) notes.push({ key: "zigzag" });
|
|
3768
|
+
if (p.deltaText) notes.push({ key: "delta_text" });
|
|
3769
|
+
if (p.mid) notes.push({ key: "mid_winding" });
|
|
3770
|
+
if (p.windingAssumed) assumed.push("winding");
|
|
3771
|
+
if (p.tapPointAssumed) assumed.push("tap_point");
|
|
3772
|
+
return {
|
|
3773
|
+
...base,
|
|
3774
|
+
kind: "two_winding",
|
|
3775
|
+
tapPoint: p.tapPoint,
|
|
3776
|
+
winding: p.winding,
|
|
3777
|
+
tapKv,
|
|
3778
|
+
hvKv: null,
|
|
3779
|
+
mvKv: null,
|
|
3780
|
+
warnings: notes.map(lineNoteEn)
|
|
3781
|
+
};
|
|
3782
|
+
}
|
|
3783
|
+
function parseNeutralBil(text) {
|
|
3784
|
+
const re = /(?:neutral|中性点)([^;.]{0,30}?)(?:BIL|LI|LIWL)\s*[:=]?\s*(\d{2,4})((?:\s*\/\s*\d{2,4})*)/gi;
|
|
3785
|
+
for (const m of text.matchAll(re)) {
|
|
3786
|
+
const at = m.index ?? 0;
|
|
3787
|
+
if (/\b(?:LV|MV|tertiary|secondary)\s*$/i.test(text.slice(Math.max(0, at - 12), at))) continue;
|
|
3788
|
+
if (/\b(?:LV|MV|HV|tertiary|line[\s-]?end)\b|\//i.test(m[1])) continue;
|
|
3789
|
+
const names = text.slice(Math.max(0, at - 30), at).match(/((?:[A-Za-z][A-Za-z\s-]{0,12}\/\s*)+)$/);
|
|
3790
|
+
if (names) {
|
|
3791
|
+
const k = (names[1].match(/\//g) ?? []).length;
|
|
3792
|
+
const figs = [m[2], ...m[3].match(/\d{2,4}/g) ?? []];
|
|
3793
|
+
if (figs[k] == null) continue;
|
|
3794
|
+
return Number(figs[k]);
|
|
3795
|
+
}
|
|
3796
|
+
return Number(m[2]);
|
|
3797
|
+
}
|
|
3798
|
+
const named = /\b(?:HV\s+)?neutr(?:al|e|o)\s*[:=]?\s*(?:BIL|LI)?\s*(\d{2,4})\s*kVp?\b/gi;
|
|
3799
|
+
for (const m of text.matchAll(named)) {
|
|
3800
|
+
const at = m.index ?? 0;
|
|
3801
|
+
if (Number(m[1]) < 95) continue;
|
|
3802
|
+
const clause = text.slice(Math.max(0, at - 40), at).split(/[,;]/).pop() ?? "";
|
|
3803
|
+
if (/\b(?:LV|MV|tertiary|secondary|low[\s-]?voltage|\d+(?:\.\d+)?\s*kV)\b/i.test(clause)) continue;
|
|
3804
|
+
const after = text.slice(at + m[0].length, at + m[0].length + 8);
|
|
3805
|
+
const marked = /BIL|LI|kVp/i.test(m[0]) || /^\s*(?:BIL|LI|LIWL)\b/i.test(after);
|
|
3806
|
+
if (!marked && Number(m[1]) < 250) continue;
|
|
3807
|
+
return Number(m[1]);
|
|
3808
|
+
}
|
|
3809
|
+
const hvn = text.match(/\bHVN\b\s*[:=]?\s*(\d{2,4})((?:\s*\/\s*\d{2,4})*)/);
|
|
3810
|
+
if (hvn) return Math.max(Number(hvn[1]), ...(hvn[2].match(/\d{2,4}/g) ?? []).map(Number));
|
|
3811
|
+
return neutralFromList(text);
|
|
3812
|
+
}
|
|
3813
|
+
function neutralFromList(text) {
|
|
3814
|
+
const LBL = String.raw`(?:HV[\s-]?N|HVN|HV|MV|LV|N|neutral|line(?:[\s-]?end)?)`;
|
|
3815
|
+
const NAMES = String.raw`${LBL}(?:\s*\/\s*${LBL}){1,3}`;
|
|
3816
|
+
const FIGS = String.raw`(\d{2,4}(?:\s*\/\s*\d{2,4}){1,3})`;
|
|
3817
|
+
const list = new RegExp(
|
|
3818
|
+
String.raw`(?:\b(?:BIL|LIWL|LI|insulation)\b[^;\d]{0,12}?\(?\s*(${NAMES})\s*\)?|\b(${NAMES})\s*(?:BIL|LIWL|LI)\b)\s*[:=]?\s*${FIGS}`,
|
|
3819
|
+
"gi"
|
|
3820
|
+
);
|
|
3821
|
+
const isN = (n) => /^(?:HV[\s-]?N|HVN|N|neutral)$/i.test(n.trim());
|
|
3822
|
+
for (const m of text.matchAll(list)) {
|
|
3823
|
+
const names = (m[1] ?? m[2]).split("/").map((n) => n.trim());
|
|
3824
|
+
const figs = m[3].split("/").map((f) => Number(f.trim()));
|
|
3825
|
+
const k = names.findIndex(isN);
|
|
3826
|
+
if (k < 0 || figs[k] == null || figs[k] < 95) continue;
|
|
3827
|
+
if (/^N$/i.test(names[k]) && !(k > 0 && /^HV$/i.test(names[k - 1]))) continue;
|
|
3828
|
+
if (!/^HV[\s-]?N$|^HVN$/i.test(names[k]) && !names.some((n) => /^(?:HV|line)/i.test(n))) continue;
|
|
3829
|
+
return figs[k];
|
|
3830
|
+
}
|
|
3831
|
+
for (const m of text.matchAll(/[,;]\s*(HV[\s-]?N|HVN|N)\s*[:=]?\s*(\d{2,4})\b(?!\s*\/)/gi)) {
|
|
3832
|
+
const at = m.index ?? 0;
|
|
3833
|
+
const seg = text.slice(0, at).split(";").pop() ?? "";
|
|
3834
|
+
if (!/\b(?:BIL|LIWL|LI|insulation)\b[^;]*\bHV\s*[:=]?\s*\d/i.test(seg)) continue;
|
|
3835
|
+
if (Number(m[2]) >= 95) return Number(m[2]);
|
|
3836
|
+
}
|
|
3837
|
+
const pair = text.match(/\bneutr(?:al|e|o)\s+(BIL|LIWL|LI|AC)\s*\/\s*(BIL|LIWL|LI|AC)\s*[:=]?\s*(\d{2,4})\s*\/\s*(\d{2,4})/i);
|
|
3838
|
+
if (pair) return Number(/^AC$/i.test(pair[1]) ? pair[4] : pair[3]);
|
|
3839
|
+
const ins = text.match(/\bneutr(?:al|e|o)\s+insulation\s*[:=]?\s*(\d{2,4})\s*kV\s*(?:LI|BIL|LIWL)\b/i);
|
|
3840
|
+
return ins ? Number(ins[1]) : null;
|
|
3841
|
+
}
|
|
3842
|
+
var asPitch = (p) => p;
|
|
3843
|
+
function geometryForRange(plus, minus, reg) {
|
|
3844
|
+
const S = plus + minus;
|
|
3845
|
+
if (reg === "linear") return { positions: S + 1, mid: 0, pitch: asPitch(defaultPitch(S + 1, "linear")) };
|
|
3846
|
+
const opts = pmStepOptionsFor(reg);
|
|
3847
|
+
const want = plus === minus ? plus : Math.ceil(S / 2);
|
|
3848
|
+
const own = opts.includes(want) || plus === minus && reg === "coarse_fine" && want === 7;
|
|
3849
|
+
const n = own ? want : opts.find((o) => o >= want) ?? want;
|
|
3850
|
+
const mid = preferredMid(n, reg);
|
|
3851
|
+
const row = lookupDiagram(n, mid, reg);
|
|
3852
|
+
if (plus !== minus && row && S % 2 === 1 && n === want && row.pitch === 10) {
|
|
3853
|
+
return { positions: S + mid, mid, pitch: 10 };
|
|
3854
|
+
}
|
|
3855
|
+
return {
|
|
3856
|
+
positions: row?.positions ?? 2 * n + mid,
|
|
3857
|
+
mid,
|
|
3858
|
+
pitch: asPitch(row?.pitch ?? pitchFor(n, mid)),
|
|
3859
|
+
plusMinusSteps: n
|
|
3860
|
+
};
|
|
3861
|
+
}
|
|
3862
|
+
function defaultRegulationForRange(plus, minus) {
|
|
3863
|
+
return plus !== minus && plus + minus <= 9 ? "linear" : null;
|
|
3864
|
+
}
|
|
3865
|
+
function tenderLineSettings(tl, opts = {}) {
|
|
3866
|
+
if (tl.mva == null || !tl.voltagesKv.length) return { ok: false, reason: "no_mva_kv" };
|
|
3867
|
+
if (tl.kind === "auto" && (tl.hvKv == null || tl.mvKv == null)) return { ok: false, reason: "auto_needs_mv" };
|
|
3868
|
+
let tapKv = tl.tapKv;
|
|
3869
|
+
let tapKvStated = !tl.assumed.includes("tap_winding");
|
|
3870
|
+
let winding = tl.winding;
|
|
3871
|
+
let tapPoint = tl.tapPoint;
|
|
3872
|
+
let windingStated = !tl.assumed.includes("winding");
|
|
3873
|
+
let tapPointStated = !tl.assumed.includes("tap_point");
|
|
3874
|
+
let plus = tl.plus;
|
|
3875
|
+
let minus = tl.minus;
|
|
3876
|
+
let stepPct = tl.stepPct;
|
|
3877
|
+
let octcWinding = false;
|
|
3878
|
+
if (opts.octc && tl.kind === "two_winding" && tl.otherRanges.length) {
|
|
3879
|
+
const off = tl.otherRanges.find((x) => x.offCircuit);
|
|
3880
|
+
const r = off ?? tl.otherRanges.reduce((x, y) => y.plus + y.minus <= x.plus + x.minus ? y : x);
|
|
3881
|
+
if (off || plus == null || minus == null || r.plus + r.minus <= plus + minus) {
|
|
3882
|
+
plus = r.plus;
|
|
3883
|
+
minus = r.minus;
|
|
3884
|
+
stepPct = r.stepPct;
|
|
3885
|
+
winding = r.winding;
|
|
3886
|
+
tapPoint = r.tapPoint;
|
|
3887
|
+
tapKv = r.kv;
|
|
3888
|
+
tapKvStated = !r.kvAssumed;
|
|
3889
|
+
windingStated = !r.windingAssumed;
|
|
3890
|
+
tapPointStated = !r.tapPointAssumed;
|
|
3891
|
+
octcWinding = true;
|
|
3892
|
+
}
|
|
3893
|
+
}
|
|
3894
|
+
const uneven = plus != null && minus != null ? defaultRegulationForRange(plus, minus) : null;
|
|
3895
|
+
const earthUm = tl.neutralBilKv != null && tapPoint === "neutral" ? umForEarthInsulation(0, tl.neutralBilKv) : null;
|
|
3896
|
+
return {
|
|
3897
|
+
ok: true,
|
|
3898
|
+
s: {
|
|
3899
|
+
kind: tl.kind,
|
|
3900
|
+
kindStated: !tl.assumed.includes("kind"),
|
|
3901
|
+
mva: tl.phases === "I" ? 3 * tl.mva : tl.mva,
|
|
3902
|
+
phases: tl.phases,
|
|
3903
|
+
hvKv: tl.hvKv,
|
|
3904
|
+
mvKv: tl.mvKv,
|
|
3905
|
+
tapKv,
|
|
3906
|
+
tapKvStated,
|
|
3907
|
+
winding,
|
|
3908
|
+
windingStated,
|
|
3909
|
+
tapPoint,
|
|
3910
|
+
tapPointStated,
|
|
3911
|
+
plus,
|
|
3912
|
+
minus,
|
|
3913
|
+
stepPct,
|
|
3914
|
+
regulation: tl.regulation ?? uneven,
|
|
3915
|
+
regulationStated: tl.regulation != null,
|
|
3916
|
+
earthUm: earthUm ?? null,
|
|
3917
|
+
octcWinding
|
|
3918
|
+
}
|
|
3919
|
+
};
|
|
3920
|
+
}
|
|
2144
3921
|
|
|
2145
3922
|
// lib/cli.ts
|
|
2146
3923
|
var CliError = class extends Error {
|
|
@@ -2149,9 +3926,22 @@ var CliError = class extends Error {
|
|
|
2149
3926
|
this.name = "CliError";
|
|
2150
3927
|
}
|
|
2151
3928
|
};
|
|
2152
|
-
function num(raw, flag) {
|
|
3929
|
+
function num(raw, flag, bound = "positive") {
|
|
3930
|
+
if (bound !== "any" && /^\s*-\s*[\d.]/.test(raw)) {
|
|
3931
|
+
throw new CliError(
|
|
3932
|
+
bound === "positive" ? `${flag} must be greater than 0 (got ${raw})` : `${flag} must not be negative (got ${raw})`
|
|
3933
|
+
);
|
|
3934
|
+
}
|
|
2153
3935
|
const p = parseDecimal(raw);
|
|
2154
|
-
if (p.ok)
|
|
3936
|
+
if (p.ok) {
|
|
3937
|
+
if (bound === "positive" && !(p.value > 0)) {
|
|
3938
|
+
throw new CliError(`${flag} must be greater than 0 (got ${raw})`);
|
|
3939
|
+
}
|
|
3940
|
+
if (bound === "nonNegative" && p.value < 0) {
|
|
3941
|
+
throw new CliError(`${flag} must not be negative (got ${raw})`);
|
|
3942
|
+
}
|
|
3943
|
+
return p.value;
|
|
3944
|
+
}
|
|
2155
3945
|
if (p.reason === "ambiguous") {
|
|
2156
3946
|
throw new CliError(
|
|
2157
3947
|
`Ambiguous number for ${flag}: ${raw}. Write 1200 or 1.2 (no thousands separator).`
|
|
@@ -2159,8 +3949,112 @@ function num(raw, flag) {
|
|
|
2159
3949
|
}
|
|
2160
3950
|
throw new CliError(`Invalid number for ${flag}: ${raw}`);
|
|
2161
3951
|
}
|
|
2162
|
-
|
|
3952
|
+
var KNOWN_FLAGS = [
|
|
3953
|
+
"--help",
|
|
3954
|
+
"--version",
|
|
3955
|
+
"--json",
|
|
3956
|
+
"--lang",
|
|
3957
|
+
"--no-update-check",
|
|
3958
|
+
"--octc",
|
|
3959
|
+
"--oil",
|
|
3960
|
+
"--vacuum",
|
|
3961
|
+
"--iu",
|
|
3962
|
+
"--imax",
|
|
3963
|
+
"--os-imax",
|
|
3964
|
+
"--market",
|
|
3965
|
+
"--across-li",
|
|
3966
|
+
"--across-ac",
|
|
3967
|
+
"--mva",
|
|
3968
|
+
"--kv",
|
|
3969
|
+
"--um",
|
|
3970
|
+
"--ust",
|
|
3971
|
+
"--step-pct",
|
|
3972
|
+
"--k",
|
|
3973
|
+
"--conn",
|
|
3974
|
+
"--connection",
|
|
3975
|
+
"--kind",
|
|
3976
|
+
"--auto",
|
|
3977
|
+
"--tap",
|
|
3978
|
+
"--winding",
|
|
3979
|
+
"--hv",
|
|
3980
|
+
"--mv",
|
|
3981
|
+
"--earth-um",
|
|
3982
|
+
"--reg",
|
|
3983
|
+
"--pm",
|
|
3984
|
+
"--positions",
|
|
3985
|
+
"--pos",
|
|
3986
|
+
"--structure",
|
|
3987
|
+
"--series",
|
|
3988
|
+
"--mount",
|
|
3989
|
+
"--contact",
|
|
3990
|
+
"--phases",
|
|
3991
|
+
"--line",
|
|
3992
|
+
"--nameplate",
|
|
3993
|
+
"--minus",
|
|
3994
|
+
"--range",
|
|
3995
|
+
"--mid",
|
|
3996
|
+
"--duty"
|
|
3997
|
+
];
|
|
3998
|
+
var SWITCH_FLAGS = /* @__PURE__ */ new Set([
|
|
3999
|
+
"--help",
|
|
4000
|
+
"-h",
|
|
4001
|
+
"--version",
|
|
4002
|
+
"-v",
|
|
4003
|
+
"-V",
|
|
4004
|
+
"--json",
|
|
4005
|
+
"--no-update-check",
|
|
4006
|
+
"--octc",
|
|
4007
|
+
"--oil",
|
|
4008
|
+
"--vacuum",
|
|
4009
|
+
"--auto"
|
|
4010
|
+
]);
|
|
4011
|
+
var FLAG_ALIAS = {
|
|
4012
|
+
"--connection": "--conn",
|
|
4013
|
+
"--positions": "--pos",
|
|
4014
|
+
"--nameplate": "--line"
|
|
4015
|
+
};
|
|
4016
|
+
function editDistance(a, b) {
|
|
4017
|
+
const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
|
|
4018
|
+
for (let j = 1; j <= b.length; j++) d[0][j] = j;
|
|
4019
|
+
for (let i = 1; i <= a.length; i++) {
|
|
4020
|
+
for (let j = 1; j <= b.length; j++) {
|
|
4021
|
+
d[i][j] = Math.min(
|
|
4022
|
+
d[i - 1][j] + 1,
|
|
4023
|
+
d[i][j - 1] + 1,
|
|
4024
|
+
d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
|
|
4025
|
+
);
|
|
4026
|
+
}
|
|
4027
|
+
}
|
|
4028
|
+
return d[a.length][b.length];
|
|
4029
|
+
}
|
|
4030
|
+
function unknownFlag(a) {
|
|
4031
|
+
const name = a.replace(/=.*$/s, "");
|
|
4032
|
+
const best = KNOWN_FLAGS.map((f) => [f, editDistance(name, f)]).sort((x, y) => x[1] - y[1])[0];
|
|
4033
|
+
const hint = best && best[1] <= 2 ? ` Did you mean ${best[0]}?` : "";
|
|
4034
|
+
return new CliError(`Unknown flag: ${name}.${hint} Run oltc --help for the list.`);
|
|
4035
|
+
}
|
|
4036
|
+
function splitEquals(argv2) {
|
|
4037
|
+
const out = [];
|
|
4038
|
+
for (let i = 0; i < argv2.length; i++) {
|
|
4039
|
+
const a = argv2[i];
|
|
4040
|
+
const prev = argv2[i - 1];
|
|
4041
|
+
const m = /^(--[a-z][a-z-]*)=(.*)$/s.exec(a);
|
|
4042
|
+
if (m && SWITCH_FLAGS.has(m[1]) && prev !== "--line" && prev !== "--nameplate") {
|
|
4043
|
+
throw new CliError(`${m[1]} takes no value`);
|
|
4044
|
+
}
|
|
4045
|
+
if (prev === "--line" || prev === "--nameplate" || !m || /^--(line|nameplate|lang)$/.test(m[1])) {
|
|
4046
|
+
out.push(a);
|
|
4047
|
+
} else {
|
|
4048
|
+
out.push(m[1], m[2]);
|
|
4049
|
+
}
|
|
4050
|
+
}
|
|
4051
|
+
return out;
|
|
4052
|
+
}
|
|
4053
|
+
function parseCliArgs(rawArgv) {
|
|
4054
|
+
const argv2 = splitEquals(rawArgv);
|
|
4055
|
+
const envLang = typeof process !== "undefined" ? process.env?.OLTC_LANG?.toLowerCase() : void 0;
|
|
2163
4056
|
const out = {
|
|
4057
|
+
...envLang === "en" ? { lang: "en" } : {},
|
|
2164
4058
|
conn: "Y",
|
|
2165
4059
|
kind: "two_winding",
|
|
2166
4060
|
reg: "reversing",
|
|
@@ -2176,22 +4070,51 @@ function parseCliArgs(argv) {
|
|
|
2176
4070
|
given: /* @__PURE__ */ new Set()
|
|
2177
4071
|
};
|
|
2178
4072
|
const take = (i, flag) => {
|
|
2179
|
-
const v =
|
|
2180
|
-
if (v == null || v.startsWith("-")) {
|
|
4073
|
+
const v = argv2[i + 1];
|
|
4074
|
+
if (v == null || v.startsWith("-") && !/^-[\d.]/.test(v)) {
|
|
2181
4075
|
throw new CliError(`Missing value for ${flag}`);
|
|
2182
4076
|
}
|
|
2183
4077
|
return [v, i + 1];
|
|
2184
4078
|
};
|
|
2185
|
-
|
|
2186
|
-
|
|
4079
|
+
const seenFlags = /* @__PURE__ */ new Set();
|
|
4080
|
+
let lineRaw = null;
|
|
4081
|
+
let rangeRaw = null;
|
|
4082
|
+
for (let i = 0; i < argv2.length; i++) {
|
|
4083
|
+
const a = argv2[i];
|
|
4084
|
+
if (a.startsWith("--") && !SWITCH_FLAGS.has(a)) {
|
|
4085
|
+
const name = a.replace(/=.*$/s, "");
|
|
4086
|
+
const key = FLAG_ALIAS[name] ?? name;
|
|
4087
|
+
if (seenFlags.has(key)) throw new CliError(`${key} is given twice`);
|
|
4088
|
+
seenFlags.add(key);
|
|
4089
|
+
}
|
|
4090
|
+
const eq = a.match(/^--(line|nameplate)=(.*)$/s);
|
|
4091
|
+
if (eq) {
|
|
4092
|
+
out.given.add("line");
|
|
4093
|
+
lineRaw = eq[2];
|
|
4094
|
+
continue;
|
|
4095
|
+
}
|
|
2187
4096
|
if (a === "-h" || a === "--help") {
|
|
2188
4097
|
out.help = true;
|
|
2189
4098
|
continue;
|
|
2190
4099
|
}
|
|
4100
|
+
if (a === "--version" || a === "-v" || a === "-V") {
|
|
4101
|
+
out.version = true;
|
|
4102
|
+
continue;
|
|
4103
|
+
}
|
|
2191
4104
|
if (a === "--json") {
|
|
2192
4105
|
out.json = true;
|
|
2193
4106
|
continue;
|
|
2194
4107
|
}
|
|
4108
|
+
if (a === "--lang" || a.startsWith("--lang=")) {
|
|
4109
|
+
const v = a.includes("=") ? a.slice(7) : argv2[++i];
|
|
4110
|
+
const l = (v ?? "").toLowerCase();
|
|
4111
|
+
if (l !== "en" && l !== "zh") throw new CliError("--lang must be en or zh");
|
|
4112
|
+
out.lang = l;
|
|
4113
|
+
continue;
|
|
4114
|
+
}
|
|
4115
|
+
if (a === "--no-update-check") {
|
|
4116
|
+
continue;
|
|
4117
|
+
}
|
|
2195
4118
|
if (a === "--octc") {
|
|
2196
4119
|
out.given.add("octc");
|
|
2197
4120
|
out.octc = true;
|
|
@@ -2210,12 +4133,40 @@ function parseCliArgs(argv) {
|
|
|
2210
4133
|
continue;
|
|
2211
4134
|
}
|
|
2212
4135
|
if (a === "--iu" || a === "--imax") {
|
|
4136
|
+
if (out.given.has(a === "--iu" ? "imaxFlag" : "iuFlag")) {
|
|
4137
|
+
throw new CliError("Give --iu or --imax, not both");
|
|
4138
|
+
}
|
|
4139
|
+
if (a === "--iu") out.given.add("iuFlag");
|
|
2213
4140
|
out.given.add("iu");
|
|
4141
|
+
if (a === "--imax") out.given.add("imaxFlag");
|
|
2214
4142
|
const [v, n] = take(i, a);
|
|
2215
4143
|
out.iu = num(v, a);
|
|
2216
4144
|
i = n;
|
|
2217
4145
|
continue;
|
|
2218
4146
|
}
|
|
4147
|
+
if (a === "--os-imax") {
|
|
4148
|
+
out.given.add("osImax");
|
|
4149
|
+
const [v, n] = take(i, a);
|
|
4150
|
+
out.osImax = num(v, a);
|
|
4151
|
+
i = n;
|
|
4152
|
+
continue;
|
|
4153
|
+
}
|
|
4154
|
+
if (a === "--market") {
|
|
4155
|
+
out.given.add("market");
|
|
4156
|
+
const [v, n] = take(i, a);
|
|
4157
|
+
if (!/^[A-Za-z]{2}$/.test(v)) throw new CliError(`--market must be a 2-letter country code (IT, TR, RU\u2026)`);
|
|
4158
|
+
out.market = v.toUpperCase();
|
|
4159
|
+
i = n;
|
|
4160
|
+
continue;
|
|
4161
|
+
}
|
|
4162
|
+
if (a === "--across-li" || a === "--across-ac") {
|
|
4163
|
+
const key = a === "--across-li" ? "acrossLi" : "acrossAc";
|
|
4164
|
+
out.given.add(key);
|
|
4165
|
+
const [v, n] = take(i, a);
|
|
4166
|
+
out[key] = num(v, a, "nonNegative");
|
|
4167
|
+
i = n;
|
|
4168
|
+
continue;
|
|
4169
|
+
}
|
|
2219
4170
|
if (a === "--mva") {
|
|
2220
4171
|
out.given.add("mva");
|
|
2221
4172
|
const [v, n] = take(i, a);
|
|
@@ -2240,7 +4191,7 @@ function parseCliArgs(argv) {
|
|
|
2240
4191
|
if (a === "--ust") {
|
|
2241
4192
|
out.given.add("ust");
|
|
2242
4193
|
const [v, n] = take(i, a);
|
|
2243
|
-
out.ust = num(v, a);
|
|
4194
|
+
out.ust = num(v, a, "nonNegative");
|
|
2244
4195
|
i = n;
|
|
2245
4196
|
continue;
|
|
2246
4197
|
}
|
|
@@ -2333,13 +4284,19 @@ function parseCliArgs(argv) {
|
|
|
2333
4284
|
out.given.add("pm");
|
|
2334
4285
|
const [v, n] = take(i, a);
|
|
2335
4286
|
out.pm = num(v, a);
|
|
4287
|
+
if (!Number.isInteger(out.pm) || out.pm < 1) {
|
|
4288
|
+
throw new CliError("--pm must be a whole number of at least 1");
|
|
4289
|
+
}
|
|
2336
4290
|
i = n;
|
|
2337
4291
|
continue;
|
|
2338
4292
|
}
|
|
2339
4293
|
if (a === "--positions" || a === "--pos") {
|
|
2340
4294
|
out.given.add("positions");
|
|
2341
4295
|
const [v, n] = take(i, a);
|
|
2342
|
-
out.positions = num(v, a);
|
|
4296
|
+
out.positions = num(v, a, "nonNegative");
|
|
4297
|
+
if (!Number.isInteger(out.positions) || out.positions < 2) {
|
|
4298
|
+
throw new CliError(`${a} must be a whole number of at least 2`);
|
|
4299
|
+
}
|
|
2343
4300
|
i = n;
|
|
2344
4301
|
continue;
|
|
2345
4302
|
}
|
|
@@ -2386,13 +4343,17 @@ function parseCliArgs(argv) {
|
|
|
2386
4343
|
if (m === "in-tank" || m === "intank") out.mount = "in_tank";
|
|
2387
4344
|
else if (m === "on-tank" || m === "ontank") out.mount = "on_tank";
|
|
2388
4345
|
else if (m === "dry" || m === "dry-type") out.mount = "dry_type";
|
|
2389
|
-
else
|
|
4346
|
+
else if (m === "reactor") out.mount = "reactor";
|
|
4347
|
+
else throw new CliError(`--mount must be in-tank|on-tank|dry|reactor`);
|
|
2390
4348
|
i = n;
|
|
2391
4349
|
continue;
|
|
2392
4350
|
}
|
|
2393
4351
|
if (a === "--contact") {
|
|
2394
4352
|
out.given.add("contact");
|
|
2395
4353
|
const [v, n] = take(i, a);
|
|
4354
|
+
if (!/^\d+\s*[xX×*✕]\s*\d+[A-Ea-e]?$/.test(v.trim())) {
|
|
4355
|
+
throw new CliError("--contact must look like 6x5 or 12x11D");
|
|
4356
|
+
}
|
|
2396
4357
|
out.contact = v;
|
|
2397
4358
|
i = n;
|
|
2398
4359
|
continue;
|
|
@@ -2408,6 +4369,37 @@ function parseCliArgs(argv) {
|
|
|
2408
4369
|
i = n;
|
|
2409
4370
|
continue;
|
|
2410
4371
|
}
|
|
4372
|
+
if (a === "--line" || a === "--nameplate") {
|
|
4373
|
+
out.given.add("line");
|
|
4374
|
+
const v = argv2[i + 1];
|
|
4375
|
+
if (v == null) throw new CliError(`Missing value for ${a}`);
|
|
4376
|
+
lineRaw = v;
|
|
4377
|
+
i += 1;
|
|
4378
|
+
continue;
|
|
4379
|
+
}
|
|
4380
|
+
if (a === "--minus") {
|
|
4381
|
+
out.given.add("minus");
|
|
4382
|
+
const [v, n] = take(i, a);
|
|
4383
|
+
const m = num(v, a, "nonNegative");
|
|
4384
|
+
if (!(m >= 0) || !Number.isInteger(m)) throw new CliError(`--minus must be a whole number of steps`);
|
|
4385
|
+
out.minus = m;
|
|
4386
|
+
i = n;
|
|
4387
|
+
continue;
|
|
4388
|
+
}
|
|
4389
|
+
if (a === "--range") {
|
|
4390
|
+
const [v, n] = take(i, a);
|
|
4391
|
+
rangeRaw = v;
|
|
4392
|
+
i = n;
|
|
4393
|
+
continue;
|
|
4394
|
+
}
|
|
4395
|
+
if (a === "--mid") {
|
|
4396
|
+
out.given.add("mid");
|
|
4397
|
+
const [v, n] = take(i, a);
|
|
4398
|
+
if (v !== "1" && v !== "3") throw new CliError(`--mid must be 1 or 3`);
|
|
4399
|
+
out.mid = v === "1" ? 1 : 3;
|
|
4400
|
+
i = n;
|
|
4401
|
+
continue;
|
|
4402
|
+
}
|
|
2411
4403
|
if (a === "--duty") {
|
|
2412
4404
|
out.given.add("octc");
|
|
2413
4405
|
const [v, n] = take(i, a);
|
|
@@ -2418,10 +4410,106 @@ function parseCliArgs(argv) {
|
|
|
2418
4410
|
i = n;
|
|
2419
4411
|
continue;
|
|
2420
4412
|
}
|
|
2421
|
-
throw
|
|
4413
|
+
throw unknownFlag(a);
|
|
4414
|
+
}
|
|
4415
|
+
out.typed = seenFlags;
|
|
4416
|
+
if (rangeRaw != null) {
|
|
4417
|
+
const r = parseTapRange(rangeRaw);
|
|
4418
|
+
if (!r) throw new CliError(`--range must look like +4/-12 or +4/-12x1.25%`);
|
|
4419
|
+
if (r.stepPercent != null && !out.given.has("stepPct")) {
|
|
4420
|
+
out.stepPct = Math.round(r.stepPercent * 1e6) / 1e4;
|
|
4421
|
+
out.given.add("stepPct");
|
|
4422
|
+
}
|
|
4423
|
+
applyRange(out, r.plus, r.minus);
|
|
4424
|
+
}
|
|
4425
|
+
if (lineRaw != null) applyTenderLine(out, lineRaw);
|
|
4426
|
+
if (out.given.has("imaxFlag") && out.mva != null && out.osImax == null) {
|
|
4427
|
+
out.osImax = out.iu;
|
|
4428
|
+
out.iu = void 0;
|
|
4429
|
+
out.given.delete("iu");
|
|
4430
|
+
out.given.add("osImax");
|
|
2422
4431
|
}
|
|
2423
4432
|
return out;
|
|
2424
4433
|
}
|
|
4434
|
+
function applyRange(out, plus, minus) {
|
|
4435
|
+
if (out.given.has("range")) return;
|
|
4436
|
+
out.given.add("range");
|
|
4437
|
+
out.range = { plus, minus };
|
|
4438
|
+
if (plus !== minus && !out.given.has("minus")) out.minus = minus;
|
|
4439
|
+
if (!out.given.has("reg") && defaultRegulationForRange(plus, minus)) out.reg = "linear";
|
|
4440
|
+
if (out.given.has("pm") || out.given.has("positions")) return;
|
|
4441
|
+
if (plus === minus) {
|
|
4442
|
+
out.pm = plus;
|
|
4443
|
+
out.given.add("pm");
|
|
4444
|
+
return;
|
|
4445
|
+
}
|
|
4446
|
+
if (out.octc || out.reg === "linear") {
|
|
4447
|
+
out.positions = plus + minus + 1;
|
|
4448
|
+
out.given.add("positions");
|
|
4449
|
+
return;
|
|
4450
|
+
}
|
|
4451
|
+
const g = geometryForRange(plus, minus, out.reg);
|
|
4452
|
+
if (g.plusMinusSteps != null) {
|
|
4453
|
+
out.pm = g.plusMinusSteps;
|
|
4454
|
+
out.given.add("pm");
|
|
4455
|
+
} else {
|
|
4456
|
+
out.positions = g.positions;
|
|
4457
|
+
out.given.add("positions");
|
|
4458
|
+
}
|
|
4459
|
+
if (out.mid != null && (g.mid === 1 || g.mid === 3) && out.mid !== g.mid) {
|
|
4460
|
+
throw new CliError(
|
|
4461
|
+
`--mid ${out.mid} does not fit +${plus}/-${minus}: the Fig. 3-3 row has mid ${g.mid}.`
|
|
4462
|
+
);
|
|
4463
|
+
}
|
|
4464
|
+
if (out.mid == null && (g.mid === 1 || g.mid === 3)) out.mid = g.mid;
|
|
4465
|
+
}
|
|
4466
|
+
function applyTenderLine(out, raw) {
|
|
4467
|
+
const t = parseTenderLine(raw);
|
|
4468
|
+
if (t?.offCircuitOnly && !out.given.has("octc")) out.octc = true;
|
|
4469
|
+
if (t?.dryType && !out.given.has("mount")) out.mount = "dry_type";
|
|
4470
|
+
const r = t ? tenderLineSettings(t, { octc: out.octc }) : null;
|
|
4471
|
+
if (r && !r.ok && r.reason === "auto_needs_mv") {
|
|
4472
|
+
throw new CliError(
|
|
4473
|
+
`--line reads an autotransformer without both HV and MV kV: ${raw}. Give --hv and --mv.`
|
|
4474
|
+
);
|
|
4475
|
+
}
|
|
4476
|
+
if (!t || !r || !r.ok) {
|
|
4477
|
+
const text = normalizeTenderText(raw);
|
|
4478
|
+
const hasMva = /\d\s*(?:MVA|kVA)/i.test(text);
|
|
4479
|
+
const hasKv = /\d\s*kV(?!A)/i.test(text);
|
|
4480
|
+
const what = !hasMva && !hasKv ? "MVA and kV" : !hasMva ? "the MVA rating" : !hasKv ? "the kV ratio" : "the kV ratio and range";
|
|
4481
|
+
throw new CliError(
|
|
4482
|
+
`Could not read ${what} from --line: ${raw}. Write it like "25MVA 110\xB18x1.25%/10.5kV YNd11", or give --mva/--kv (or --hv/--mv) instead.`
|
|
4483
|
+
);
|
|
4484
|
+
}
|
|
4485
|
+
const s = r.s;
|
|
4486
|
+
out.line = t;
|
|
4487
|
+
const fill = (key, apply, sure = true) => {
|
|
4488
|
+
if (out.given.has(key)) return;
|
|
4489
|
+
apply();
|
|
4490
|
+
if (sure) out.given.add(key);
|
|
4491
|
+
};
|
|
4492
|
+
fill("kind", () => out.kind = s.kind, s.kindStated);
|
|
4493
|
+
fill("mva", () => out.mva = s.mva, !t.assumed.includes("mva"));
|
|
4494
|
+
if (s.phases) fill("phases", () => out.phases = s.phases);
|
|
4495
|
+
if (s.kind === "auto") {
|
|
4496
|
+
if (s.hvKv != null) fill("hv", () => out.hv = s.hvKv);
|
|
4497
|
+
if (s.mvKv != null) fill("mv", () => out.mv = s.mvKv);
|
|
4498
|
+
} else if (s.tapKv != null) {
|
|
4499
|
+
fill("kv", () => out.kv = s.tapKv, s.tapKvStated);
|
|
4500
|
+
fill("winding", () => out.winding = s.winding, s.windingStated);
|
|
4501
|
+
}
|
|
4502
|
+
fill("tap", () => out.tap = s.tapPoint, s.tapPointStated);
|
|
4503
|
+
if (s.octcWinding && s.tapKv != null) out.lineOctcKv = s.tapKv;
|
|
4504
|
+
if (s.regulation) fill("reg", () => out.reg = s.regulation, s.regulationStated);
|
|
4505
|
+
if (s.plus != null && s.minus != null) {
|
|
4506
|
+
const typed = out.given.has("range") || out.given.has("pm") || out.given.has("positions");
|
|
4507
|
+
applyRange(out, s.plus, s.minus);
|
|
4508
|
+
if (!typed && !s.octcWinding && t.assumed.includes("range")) out.lineRangeAssumed = true;
|
|
4509
|
+
}
|
|
4510
|
+
if (s.stepPct != null) fill("stepPct", () => out.stepPct = s.stepPct);
|
|
4511
|
+
if (s.earthUm != null) fill("earthUm", () => out.earthUm = s.earthUm, false);
|
|
4512
|
+
}
|
|
2425
4513
|
var CLI_HELP = `oltc \u2014 OLTC/OCTC type selection (package: oltc-selector, no prices)
|
|
2426
4514
|
|
|
2427
4515
|
Usage:
|
|
@@ -2429,12 +4517,24 @@ Usage:
|
|
|
2429
4517
|
oltc --mva 25 --kv 110 --tap neutral --reg W --pm 8
|
|
2430
4518
|
oltc --mva 16 --kv 22 --tap line --winding star
|
|
2431
4519
|
oltc --mva 125 --kind auto --hv 225 --mv 115 --tap junction
|
|
4520
|
+
oltc --line "125MVA 225\xB18x1,25%/115/35kV YNa0d11"
|
|
2432
4521
|
oltc --octc --iu 800 --um 72.5 --conn D --series II --contact 6x5
|
|
2433
4522
|
oltc --iu 600 --um 72.5 --conn Y --reg W --pm 8 --structure combined
|
|
2434
4523
|
|
|
2435
4524
|
Flags:
|
|
2436
4525
|
--iu, --imax A Max through-current (Imax). No safety factor.
|
|
4526
|
+
Beside --mva, --imax means --os-imax.
|
|
4527
|
+
--os-imax A Capacity path: the OS / maker Imax at the lowest tap.
|
|
4528
|
+
Replaces the full-range current, floored at rated I.
|
|
4529
|
+
--line "text" (also --nameplate) Tender line: MVA, kV ratio with \xB1N\xD7x%, vector group.
|
|
4530
|
+
Reads autotransformer from YNa0 / auto / OSFPSZ, delta
|
|
4531
|
+
line end from D, star neutral from Y (asked in \u5047\u5B9A).
|
|
4532
|
+
Percent ranges (+0/-30%), single-phase, coarse/fine and
|
|
4533
|
+
linear words are read. Flags given beside it win.
|
|
4534
|
+
--line="\u2026" keeps a line that starts with a dash.
|
|
2437
4535
|
--mva MVA --kv kV Capacity path: Imax from rated I, minus steps, --step-pct, --k
|
|
4536
|
+
With --iu, --kv alone gives the winding voltage (220 kV
|
|
4537
|
+
combined-only, 330 kV grade, --market) and Um if omitted.
|
|
2438
4538
|
--kind two|auto Transformer kind (--auto = --kind auto). Default two-winding.
|
|
2439
4539
|
--tap P Where the OLTC sits: neutral|line (two-winding),
|
|
2440
4540
|
junction|mv-line (autotransformer, series/common junction
|
|
@@ -2445,24 +4545,46 @@ Flags:
|
|
|
2445
4545
|
--earth-um kV OLTC insulation to earth from the OS or maker (catalogue
|
|
2446
4546
|
class). Overrides the rule: line end = winding system,
|
|
2447
4547
|
neutral \u226472.5 full else 72.5 assumed, autotransformer = HV.
|
|
2448
|
-
--
|
|
2449
|
-
|
|
4548
|
+
--market CC Buyer's country for a neutral's assumed Um: IT (line
|
|
4549
|
+
class up to 252), TR (126 on 220 kV class and above).
|
|
4550
|
+
Needs --kv (or --mva/--kv).
|
|
4551
|
+
--um kV Equipment Um (OLTC). With --kv, derived if omitted.
|
|
4552
|
+
--ust V Step voltage. With --mva/--kv/--step-pct, derived if omitted;
|
|
4553
|
+
given, it is the OS figure and a floor (never lowers Ust).
|
|
4554
|
+
--across-li kV --across-ac kV
|
|
4555
|
+
Stated across-tap-winding LI / AC withstand: sets the
|
|
4556
|
+
selector grade (B/C/D/DE).
|
|
2450
4557
|
--step-pct % Step as percent (1.25 means 1.25%). Capacity path only.
|
|
2451
4558
|
--k n Safety factor on capacity path only (default 1.0, same as the web app).
|
|
2452
4559
|
--conn Y|D Switch connection (star point / line end). Default Y.
|
|
2453
4560
|
On the capacity path, legacy: Y = star neutral, D = delta line end.
|
|
2454
4561
|
--reg W|G|0 Reversing / coarse-fine / linear. Default W.
|
|
2455
4562
|
--pm N \xB1 steps. Default 8.
|
|
4563
|
+
--range +a/-b[xs%] Uneven range, e.g. +4/-12x1.25%. W/G takes the Fig. 3-3
|
|
4564
|
+
row the maker sells (+4/-12 \u2192 10193W); the lowest tap uses \u2212b.
|
|
4565
|
+
--minus N Minus steps for the lowest-tap current (beside --pm/--pos).
|
|
4566
|
+
--mid 1|3 Mid positions of the W/G diagram, when Fig. 3-3 has the pair.
|
|
2456
4567
|
--pos, --positions Linear / OCTC positions.
|
|
2457
|
-
--octc Off-circuit (\u65E0\u8F7D). Default on-load.
|
|
4568
|
+
--octc Off-circuit (\u65E0\u8F7D). Default on-load. (--duty octc|oltc is the same.)
|
|
2458
4569
|
--structure auto|combined|compound|cage|drum (\u7EC4\u5408\u5F0F/\u590D\u5408\u5F0F/\u7B3C\u5F0F/\u9F13\u5F0F)
|
|
2459
4570
|
--series II|IV|V|VI|VII|VIII OCTC wiring. Default auto is linear IV (Y and D).
|
|
2460
|
-
--mount in-tank|on-tank|dry. Default in-tank.
|
|
4571
|
+
--mount in-tank|on-tank|dry|reactor. Default in-tank. Reactor is oil (HWDK).
|
|
2461
4572
|
--oil / --vacuum Switching medium. Default vacuum (on-load).
|
|
2462
4573
|
--contact OCTC contact e.g. 6x5.
|
|
2463
4574
|
--phases I|II|III. Default III.
|
|
2464
|
-
--json Machine-readable result (still no prices).
|
|
2465
|
-
|
|
4575
|
+
--json Machine-readable result (still no prices). Keys: ok, version,
|
|
4576
|
+
model, why, alts, cautions, resolved (the duty as numbers),
|
|
4577
|
+
line, basis, umChoices, assumptions, errors. Errors are JSON too.
|
|
4578
|
+
--lang en|zh Output language (default zh; OLTC_LANG=en also works).
|
|
4579
|
+
--version, -v Print the version.
|
|
4580
|
+
--no-update-check Skip the daily check for a newer version. The check only
|
|
4581
|
+
prints a notice on stderr; it never installs anything.
|
|
4582
|
+
OLTC_NO_UPDATE_CHECK=1 or CI=1 also turn it off.
|
|
4583
|
+
-h, --help This text. Also shown when no flag is given.
|
|
4584
|
+
|
|
4585
|
+
Every flag with a value also takes --flag=value. A flag that cannot take effect (--series
|
|
4586
|
+
without --octc, --conn D with --tap neutral, a flag given twice) is an error.
|
|
4587
|
+
Exit code: 0 a type was found, 1 no type or bad input.
|
|
2466
4588
|
|
|
2467
4589
|
Defaults match the web first paint: on-load, in-tank vacuum, structure auto,
|
|
2468
4590
|
\xB18 mid-3 reversing. Omitting --octc and --structure auto is minimum-adequate.
|
|
@@ -2481,17 +4603,20 @@ function cliConnection(args) {
|
|
|
2481
4603
|
}
|
|
2482
4604
|
var pmGiven = (args) => args.given.has("pm") && args.pm != null && args.pm > 0;
|
|
2483
4605
|
function cliPlusMinus(args) {
|
|
2484
|
-
if (pmGiven(args)) return { n: args.pm, mid: 3 };
|
|
4606
|
+
if (pmGiven(args)) return { n: args.pm, mid: args.mid ?? 3 };
|
|
2485
4607
|
if (args.positions != null) {
|
|
4608
|
+
const own = args.mid ? lookupByPositions(args.positions, args.mid, args.reg) : null;
|
|
4609
|
+
if (own) return { n: own.plusMinus, mid: args.mid };
|
|
2486
4610
|
const n = plusMinusFromPositions(args.positions, args.reg);
|
|
2487
4611
|
if (n == null) return null;
|
|
2488
4612
|
const mid = lookupByPositions(args.positions, 3, args.reg) ? 3 : 1;
|
|
2489
4613
|
return { n, mid };
|
|
2490
4614
|
}
|
|
2491
4615
|
if (args.given.has("pm")) return null;
|
|
2492
|
-
return args.pm != null && args.pm > 0 ? { n: args.pm, mid: 3 } : null;
|
|
4616
|
+
return args.pm != null && args.pm > 0 ? { n: args.pm, mid: args.mid ?? 3 } : null;
|
|
2493
4617
|
}
|
|
2494
4618
|
function cliMinusSteps(args) {
|
|
4619
|
+
if (args.minus != null && args.minus >= 0) return args.minus;
|
|
2495
4620
|
const fromPositions = args.positions != null && args.positions > 1 ? Math.ceil((args.positions - 1) / 2) : null;
|
|
2496
4621
|
if (args.octc || args.reg === "linear") {
|
|
2497
4622
|
if (fromPositions != null) return fromPositions;
|
|
@@ -2507,8 +4632,22 @@ function cliLinearPositions(args) {
|
|
|
2507
4632
|
if (pmGiven(args)) return Math.round(2 * args.pm + 1);
|
|
2508
4633
|
return void 0;
|
|
2509
4634
|
}
|
|
4635
|
+
function iuHasVoltage(args) {
|
|
4636
|
+
if (args.mva != null) return false;
|
|
4637
|
+
if (args.kind === "auto") {
|
|
4638
|
+
return args.hv != null && args.hv > 0 && args.mv != null && args.mv > 0;
|
|
4639
|
+
}
|
|
4640
|
+
return args.kv != null && args.kv > 0;
|
|
4641
|
+
}
|
|
4642
|
+
var dutyCache = /* @__PURE__ */ new WeakMap();
|
|
2510
4643
|
function cliDuty(args) {
|
|
2511
|
-
if (args
|
|
4644
|
+
if (dutyCache.has(args)) return dutyCache.get(args);
|
|
4645
|
+
const d = computeCliDuty(args);
|
|
4646
|
+
dutyCache.set(args, d);
|
|
4647
|
+
return d;
|
|
4648
|
+
}
|
|
4649
|
+
function computeCliDuty(args) {
|
|
4650
|
+
if (args.mva == null && !iuHasVoltage(args)) return null;
|
|
2512
4651
|
const auto = args.kind === "auto";
|
|
2513
4652
|
if (auto) {
|
|
2514
4653
|
if (!(args.hv != null && args.hv > 0 && args.mv != null && args.mv > 0)) {
|
|
@@ -2525,26 +4664,77 @@ function cliDuty(args) {
|
|
|
2525
4664
|
kind: args.kind,
|
|
2526
4665
|
tapPoint: tap,
|
|
2527
4666
|
winding,
|
|
2528
|
-
mva: args.mva,
|
|
4667
|
+
mva: args.mva ?? 0,
|
|
2529
4668
|
tapKv: args.kv ?? 0,
|
|
2530
4669
|
hvKv: args.hv ?? 0,
|
|
2531
4670
|
mvKv: args.mv ?? 0,
|
|
2532
4671
|
minusSteps: cliMinusSteps(args),
|
|
2533
4672
|
stepFraction: pct,
|
|
4673
|
+
// 2026-11-04 final ENGINE-12: a defaulted 1.25 % yields to the step --ust implies.
|
|
4674
|
+
stepFractionStated: args.given.has("stepPct"),
|
|
2534
4675
|
// 与网页版首屏一致:容量路径默认不额外加安全系数
|
|
2535
4676
|
safetyK: args.k != null && args.k > 0 ? args.k : 1,
|
|
2536
|
-
...earth != null ? { earthUmKv: earth } : {}
|
|
4677
|
+
...earth != null ? { earthUmKv: earth } : {},
|
|
4678
|
+
...args.osImax != null && args.osImax > 0 ? { statedMaxA: args.osImax } : {},
|
|
4679
|
+
// --ust used to replace Ust after deriveDuty: basis.stepV disagreed (D3).
|
|
4680
|
+
...args.ust != null && args.ust > 0 ? { statedStepV: args.ust } : {},
|
|
4681
|
+
...args.market ? { market: args.market } : {}
|
|
2537
4682
|
});
|
|
2538
4683
|
}
|
|
4684
|
+
function checkConflicts(args) {
|
|
4685
|
+
const g = (k) => args.given.has(k);
|
|
4686
|
+
if (!args.octc) {
|
|
4687
|
+
if (g("series")) throw new CliError("--series is off-circuit wiring: add --octc");
|
|
4688
|
+
if (g("contact")) throw new CliError("--contact is an off-circuit contact: add --octc");
|
|
4689
|
+
if (args.structure === "cage" || args.structure === "drum") {
|
|
4690
|
+
throw new CliError(
|
|
4691
|
+
`--structure ${args.structure} is off-circuit: add --octc (on-load takes combined or compound)`
|
|
4692
|
+
);
|
|
4693
|
+
}
|
|
4694
|
+
} else {
|
|
4695
|
+
if (args.structure === "combined" || args.structure === "compound") {
|
|
4696
|
+
throw new CliError(
|
|
4697
|
+
`--structure ${args.structure} is on-load only: with --octc use cage or drum`
|
|
4698
|
+
);
|
|
4699
|
+
}
|
|
4700
|
+
if (g("medium") && args.vacuum) {
|
|
4701
|
+
throw new CliError("--vacuum does not apply with --octc (off-circuit switches do not break current)");
|
|
4702
|
+
}
|
|
4703
|
+
}
|
|
4704
|
+
if (g("medium") && args.oil && args.mount === "dry_type") {
|
|
4705
|
+
throw new CliError("--oil does not apply with --mount dry");
|
|
4706
|
+
}
|
|
4707
|
+
if (g("medium") && args.vacuum && args.mount === "reactor") {
|
|
4708
|
+
throw new CliError("--vacuum does not apply with --mount reactor (the reactor switch is oil)");
|
|
4709
|
+
}
|
|
4710
|
+
if (args.typed?.has("--conn") && args.typed.has("--tap") && args.conn === "D" && args.tap === "neutral") {
|
|
4711
|
+
throw new CliError("--conn D conflicts with --tap neutral: a neutral tap point is star (Y). Drop one.");
|
|
4712
|
+
}
|
|
4713
|
+
if (g("pm") && g("positions") && args.pm != null && args.positions != null) {
|
|
4714
|
+
const wg = () => plusMinusFromPositions(args.positions, args.reg) === args.pm || [1, 3].some(
|
|
4715
|
+
(mid) => resolveTapFields({ regulation: args.reg, plusMinusSteps: args.pm, midPositions: mid }).positions === args.positions
|
|
4716
|
+
);
|
|
4717
|
+
const fromPm = args.octc || args.reg === "linear" ? args.positions === 2 * args.pm + 1 : wg();
|
|
4718
|
+
if (!fromPm) {
|
|
4719
|
+
throw new CliError(
|
|
4720
|
+
`--pm ${args.pm} and --pos ${args.positions} disagree. Give one of them.`
|
|
4721
|
+
);
|
|
4722
|
+
}
|
|
4723
|
+
}
|
|
4724
|
+
}
|
|
2539
4725
|
function cliToSelectInput(args) {
|
|
4726
|
+
checkConflicts(args);
|
|
2540
4727
|
const dutyKind = args.octc ? "octc" : "oltc";
|
|
2541
|
-
const oil = args.octc || args.oil || !args.vacuum;
|
|
4728
|
+
const oil = args.octc || args.oil || !args.vacuum || args.mount === "reactor";
|
|
2542
4729
|
const medium = args.mount === "dry_type" ? "dry" : oil ? "oil" : "oil_vacuum";
|
|
2543
4730
|
let iu = args.iu;
|
|
2544
4731
|
let um = args.um;
|
|
2545
4732
|
let ust = args.ust ?? 0;
|
|
2546
4733
|
if (args.iu != null && args.mva != null) {
|
|
2547
|
-
throw new CliError("Give --iu or --mva/--kv, not both");
|
|
4734
|
+
throw new CliError("Give --iu or --mva/--kv, not both (the OS Imax beside --mva is --os-imax)");
|
|
4735
|
+
}
|
|
4736
|
+
if (args.osImax != null && args.mva == null) {
|
|
4737
|
+
throw new CliError("--os-imax needs --mva/--kv; on the --iu path give the current as --iu");
|
|
2548
4738
|
}
|
|
2549
4739
|
if (args.k != null && args.mva == null) {
|
|
2550
4740
|
throw new CliError("--k applies only on the --mva path (--iu has no safety factor)");
|
|
@@ -2555,16 +4745,27 @@ function cliToSelectInput(args) {
|
|
|
2555
4745
|
if (args.stepPct != null && args.mva == null) {
|
|
2556
4746
|
throw new CliError("--step-pct needs --mva/--kv; give --ust on the --iu path");
|
|
2557
4747
|
}
|
|
4748
|
+
if (args.market && args.mva == null && !iuHasVoltage(args)) {
|
|
4749
|
+
throw new CliError("--market needs the winding voltage: add --kv (or --mva/--kv)");
|
|
4750
|
+
}
|
|
2558
4751
|
const duty = cliDuty(args);
|
|
2559
4752
|
let conn = args.conn;
|
|
2560
|
-
if (duty) {
|
|
2561
|
-
if (!duty.ok) throw new CliError(duty.errorZh ?? duty.errorEn ?? "Bad transformer data");
|
|
4753
|
+
if (duty && args.mva != null) {
|
|
4754
|
+
if (!duty.ok) throw new CliError((args.lang === "en" ? duty.errorEn : duty.errorZh) ?? duty.errorEn ?? "Bad transformer data");
|
|
2562
4755
|
iu = duty.dutyA;
|
|
2563
4756
|
if (um == null || !(um > 0)) um = duty.umKv;
|
|
2564
|
-
if (
|
|
4757
|
+
if (duty.stepV != null) ust = duty.stepV;
|
|
2565
4758
|
conn = duty.connection;
|
|
2566
4759
|
} else {
|
|
4760
|
+
if (duty && !duty.ok) throw new CliError((args.lang === "en" ? duty.errorEn : duty.errorZh) ?? duty.errorEn ?? "Bad transformer data");
|
|
4761
|
+
if (duty && (um == null || !(um > 0))) um = duty.umKv;
|
|
2567
4762
|
conn = cliConnection(args);
|
|
4763
|
+
if (!duty && args.earthUm != null && args.earthUm > 0) {
|
|
4764
|
+
if (um != null && um > 0 && Math.abs(um - args.earthUm) > 0.01) {
|
|
4765
|
+
throw new CliError("Give --um or --earth-um, not both, when no winding voltage (--kv) is given");
|
|
4766
|
+
}
|
|
4767
|
+
um = args.earthUm;
|
|
4768
|
+
}
|
|
2568
4769
|
}
|
|
2569
4770
|
if (iu == null || !(iu > 0)) {
|
|
2570
4771
|
throw new CliError("Need --iu (Imax) or --mva plus --kv");
|
|
@@ -2580,11 +4781,17 @@ function cliToSelectInput(args) {
|
|
|
2580
4781
|
phases: args.phases,
|
|
2581
4782
|
connection: conn,
|
|
2582
4783
|
...args.kind === "auto" ? { transformerKind: "auto" } : {},
|
|
4784
|
+
...duty?.combinedOnly ? { combinedOnly: true } : {},
|
|
4785
|
+
...duty?.ok && args.kind !== "auto" ? { tapWindingKv: duty.umSystemKv } : {},
|
|
4786
|
+
// 2026-11-04 r3 ORDERS-11: buyer practice on the grade (TR 72.5C neutrals).
|
|
4787
|
+
...args.market ? { market: args.market } : {},
|
|
2583
4788
|
throughCurrentA: iu,
|
|
2584
4789
|
umKv: um,
|
|
2585
4790
|
stepVoltageV: ust,
|
|
2586
4791
|
regulation: args.octc ? "linear" : args.reg,
|
|
2587
4792
|
selectorSize: "auto",
|
|
4793
|
+
...args.acrossLi != null && args.acrossLi > 0 ? { acrossTapBilKv: args.acrossLi } : {},
|
|
4794
|
+
...args.acrossAc != null && args.acrossAc > 0 ? { acrossTapPfKv: args.acrossAc } : {},
|
|
2588
4795
|
preferStructure: args.structure,
|
|
2589
4796
|
mdu: "none"
|
|
2590
4797
|
};
|
|
@@ -2605,6 +4812,7 @@ function cliToSelectInput(args) {
|
|
|
2605
4812
|
input.midPositions = pm.mid;
|
|
2606
4813
|
}
|
|
2607
4814
|
if (args.positions != null) input.positions = args.positions;
|
|
4815
|
+
if (args.mid && input.plusMinusSteps == null) input.midPositions = args.mid;
|
|
2608
4816
|
}
|
|
2609
4817
|
return input;
|
|
2610
4818
|
}
|
|
@@ -2612,7 +4820,7 @@ var MOUNT_ZH = {
|
|
|
2612
4820
|
in_tank: "\u7BB1\u5185",
|
|
2613
4821
|
on_tank: "\u7BB1\u9876",
|
|
2614
4822
|
dry_type: "\u5E72\u5F0F",
|
|
2615
|
-
// CLI
|
|
4823
|
+
// CLI 不接收外置隔室,列上只为 Record 完整性
|
|
2616
4824
|
external_compartment: "\u5916\u7F6E\u9694\u5BA4",
|
|
2617
4825
|
reactor: "\u7535\u6297\u5668"
|
|
2618
4826
|
};
|
|
@@ -2625,17 +4833,23 @@ function assumptionsFromArgs(args, family) {
|
|
|
2625
4833
|
auto_junction: "\u4E32\u8054/\u516C\u5171\u7ED5\u7EC4\u8FDE\u63A5\u70B9",
|
|
2626
4834
|
auto_mv_line: "\u4E2D\u538B\u51FA\u7EBF"
|
|
2627
4835
|
};
|
|
2628
|
-
const tapGiven = args.given.has("tap") || args.given.has("conn") || args.winding === "delta";
|
|
4836
|
+
const tapGiven = args.given.has("tap") || args.given.has("conn") || args.winding === "delta" && (args.line == null || args.given.has("winding"));
|
|
2629
4837
|
if (args.mva != null) {
|
|
2630
4838
|
const duty = cliDuty(args);
|
|
2631
4839
|
const tap = cliTapPoint(args);
|
|
2632
4840
|
items.push(`${args.kind === "auto" ? "\u81EA\u8026\u53D8" : "\u53CC\u7ED5\u7EC4"}${mark("kind")}`);
|
|
4841
|
+
if (!args.given.has("mva")) items.push(`\u5BB9\u91CF ${args.mva} MVA\uFF08\u9ED8\u8BA4\uFF09`);
|
|
2633
4842
|
items.push(`\u5F00\u5173\u5728${tapZh[tap]}${tapGiven ? "" : "\uFF08\u9ED8\u8BA4\uFF09"}`);
|
|
2634
4843
|
if (args.kind !== "auto") {
|
|
2635
4844
|
const w = args.winding ?? (tap === "neutral" || args.conn === "Y" ? "star" : "delta");
|
|
2636
4845
|
items.push(`${w === "star" ? "\u661F\u5F62" : "\u89D2\u5F62"}\u7ED5\u7EC4${args.given.has("winding") ? "" : "\uFF08\u9ED8\u8BA4\uFF09"}`);
|
|
4846
|
+
if (args.kv != null && !args.given.has("kv")) items.push(`\u8C03\u538B\u7ED5\u7EC4 ${args.kv} kV\uFF08\u9ED8\u8BA4\uFF09`);
|
|
4847
|
+
}
|
|
4848
|
+
if (args.earthUm != null && !args.given.has("earthUm") && args.line?.neutralBilKv != null) {
|
|
4849
|
+
items.push(`\u5BF9\u5730 Um ${args.earthUm}\uFF08\u62DB\u6807\u884C\u4E2D\u6027\u70B9 BIL ${args.line.neutralBilKv} kV\uFF09`);
|
|
2637
4850
|
}
|
|
2638
4851
|
if (duty?.umAssumed) items.push(`\u5BF9\u5730 Um ${duty.umKv}\uFF08\u672A\u6307\u5B9A\uFF09`);
|
|
4852
|
+
if (args.market) items.push(`\u5E02\u573A=${args.market}`);
|
|
2639
4853
|
} else {
|
|
2640
4854
|
const conn = cliConnection(args);
|
|
2641
4855
|
const derived = tapSetsConnection(args);
|
|
@@ -2654,6 +4868,23 @@ function assumptionsFromArgs(args, family) {
|
|
|
2654
4868
|
items.push(
|
|
2655
4869
|
args.given.has("stepPct") ? `step=${args.stepPct}%` : "step=1.25%\uFF08\u9ED8\u8BA4\uFF09"
|
|
2656
4870
|
);
|
|
4871
|
+
if (!args.given.has("minus") && !args.given.has("range")) {
|
|
4872
|
+
items.push(`\u6700\u4F4E\u6863\u6309 \u2212${cliMinusSteps(args)} \u7B97\uFF08\u2212\u6863\u672A\u6307\u5B9A\uFF0C+a/\u2212b \u7528 --range \u6216 --minus\uFF09`);
|
|
4873
|
+
}
|
|
4874
|
+
if (args.lineRangeAssumed && args.range) {
|
|
4875
|
+
const { plus, minus } = args.range;
|
|
4876
|
+
items.push(`\u8C03\u538B\u8303\u56F4 ${plus === minus ? `\xB1${plus}` : `+${plus}/\u2212${minus}`}\uFF08\u9ED8\u8BA4\uFF0C\u62DB\u6807\u884C\u672A\u5199\u5168\uFF09`);
|
|
4877
|
+
}
|
|
4878
|
+
if (args.lineOctcKv != null) {
|
|
4879
|
+
const guess = args.given.has("kv") ? "" : "\u9ED8\u8BA4\uFF0C";
|
|
4880
|
+
items.push(`\u65E0\u8F7D\u5F00\u5173\u53D6 ${args.lineOctcKv} kV \u7ED5\u7EC4\u7684\u8303\u56F4\uFF08${guess}\u62DB\u6807\u884C\u6709\u4E24\u4E2A\u8C03\u538B\u8303\u56F4\uFF09`);
|
|
4881
|
+
}
|
|
4882
|
+
}
|
|
4883
|
+
if (args.given.has("acrossLi") || args.given.has("acrossAc")) {
|
|
4884
|
+
const li = args.acrossLi != null && args.acrossLi > 0 ? `LI ${args.acrossLi}` : "LI \u672A\u6307\u5B9A";
|
|
4885
|
+
const ac = args.acrossAc != null && args.acrossAc > 0 ? `AC ${args.acrossAc}` : "AC \u672A\u6307\u5B9A";
|
|
4886
|
+
const half = li.includes("\u672A\u6307\u5B9A") !== ac.includes("\u672A\u6307\u5B9A");
|
|
4887
|
+
items.push(`\u8C03\u538B\u7ED5\u7EC4\u95F4 ${li} / ${ac} kV${half ? "\uFF08\u53EA\u7ED9\u4E00\u9879\uFF1A\u7B49\u7EA7\u4E0D\u4F4E\u4E8E Um \u9ED8\u8BA4\uFF09" : ""}`);
|
|
2657
4888
|
}
|
|
2658
4889
|
const phases = `\u76F8\u6570=${args.phases}${mark("phases")}`;
|
|
2659
4890
|
if (args.octc) {
|
|
@@ -2675,9 +4906,15 @@ function assumptionsFromArgs(args, family) {
|
|
|
2675
4906
|
items.push(
|
|
2676
4907
|
`reg=${args.reg === "reversing" ? "W \u6B63\u53CD\u8C03" : args.reg === "coarse_fine" ? "G \u7C97\u7EC6\u8C03" : "0 \u7EBF\u6027\u8C03"}${mark("reg")}`
|
|
2677
4908
|
);
|
|
4909
|
+
const uneven = args.range && args.range.plus !== args.range.minus ? `+${args.range.plus}/\u2212${args.range.minus}` : null;
|
|
2678
4910
|
if (args.reg === "linear") {
|
|
2679
4911
|
items.push(
|
|
2680
|
-
args.positions != null ? `${args.positions} \u6863${mark("positions")}` : pmGiven(args) ? `${cliLinearPositions(args)} \u6863\uFF08\u7531 \xB1${args.pm} \u63A8\uFF09` : "\u6863\u6570\u672A\u6307\u5B9A"
|
|
4912
|
+
args.positions != null ? `${args.positions} \u6863${uneven ? `\uFF08${uneven}\uFF09` : mark("positions")}` : pmGiven(args) ? `${cliLinearPositions(args)} \u6863\uFF08\u7531 \xB1${args.pm} \u63A8\uFF09` : "\u6863\u6570\u672A\u6307\u5B9A"
|
|
4913
|
+
);
|
|
4914
|
+
} else if (uneven) {
|
|
4915
|
+
const pm = cliPlusMinus(args);
|
|
4916
|
+
items.push(
|
|
4917
|
+
`${uneven} \u6863 \u2192 ${args.positions != null && !pmGiven(args) ? `${args.positions} \u6863` : `\xB1${pm?.n ?? args.pm}`}\uFF08\u6700\u4F4E\u6863\u6309 \u2212${cliMinusSteps(args)}\uFF09`
|
|
2681
4918
|
);
|
|
2682
4919
|
} else if (args.positions != null && !args.given.has("pm")) {
|
|
2683
4920
|
const pm = cliPlusMinus(args);
|
|
@@ -2688,7 +4925,9 @@ function assumptionsFromArgs(args, family) {
|
|
|
2688
4925
|
if (!args.given.has("ust") && args.mva == null) {
|
|
2689
4926
|
items.push("Ust \u672A\u6307\u5B9A\uFF08\u7EA7\u7535\u538B\u3001\u7EA7\u5BB9\u91CF\u672A\u6821\u9A8C\uFF09");
|
|
2690
4927
|
}
|
|
2691
|
-
items.push(
|
|
4928
|
+
items.push(
|
|
4929
|
+
`${args.oil || !args.vacuum || args.mount === "reactor" ? "\u6CB9\u6D78" : "\u771F\u7A7A"}${mark("medium")}`
|
|
4930
|
+
);
|
|
2692
4931
|
items.push(`${MOUNT_ZH[args.mount]}${mark("mount")}`);
|
|
2693
4932
|
items.push(phases);
|
|
2694
4933
|
return items;
|
|
@@ -2701,16 +4940,121 @@ function assumptionsLine(args, family) {
|
|
|
2701
4940
|
return `\u5047\u5B9A\uFF1A${items.join(" \xB7 ")}`;
|
|
2702
4941
|
}
|
|
2703
4942
|
var round1 = (n) => Math.round(n * 10) / 10;
|
|
4943
|
+
var ASSUMPTION_EN = [
|
|
4944
|
+
["\uFF08\u9ED8\u8BA4\uFF0C\u62DB\u6807\u884C\u672A\u5199\u5168\uFF09", " (default; the line does not give it all)"],
|
|
4945
|
+
["\uFF08\u9ED8\u8BA4\uFF09", " (default)"],
|
|
4946
|
+
["\uFF08\u672A\u6307\u5B9A\uFF09", " (not stated)"],
|
|
4947
|
+
["\uFF08\u5F85 OS \u6838\u5BF9\uFF09", " (check the OS)"],
|
|
4948
|
+
[/(只给一项:等级不低于 Um 默认)/, " (one value only: grade not below the Um default)"],
|
|
4949
|
+
[/^最低档按 −(\d+) 算(−档未指定,\+a\/−b 用 --range 或 --minus)$/, "lowest tap at \u2212$1 (minus not stated; give +a/\u2212b with --range or --minus)"],
|
|
4950
|
+
[/^无载开关取 ([\d.]+) kV 绕组的范围((默认,)?招标行有两个调压范围)$/, "off-circuit range from the $1 kV winding (two ranges on the line)"],
|
|
4951
|
+
[/^对地 Um ([\d.]+)(招标行中性点 BIL ([\d.]+) kV)$/, "Um to earth $1 (line neutral BIL $2 kV)"],
|
|
4952
|
+
["Ust \u672A\u6307\u5B9A\uFF08\u7EA7\u7535\u538B\u3001\u7EA7\u5BB9\u91CF\u672A\u6821\u9A8C\uFF09", "Ust not stated (step voltage and capacity not checked)"],
|
|
4953
|
+
["\u4E32\u8054/\u516C\u5171\u7ED5\u7EC4\u8FDE\u63A5\u70B9", "series/common junction"],
|
|
4954
|
+
["\u4E2D\u538B\u51FA\u7EBF", "MV line lead"],
|
|
4955
|
+
["\u5F00\u5173\u5728\u4E2D\u6027\u70B9", "tap at neutral"],
|
|
4956
|
+
["\u5F00\u5173\u5728\u7EBF\u7AEF", "tap at line end"],
|
|
4957
|
+
["\u5F00\u5173\u5728", "tap at "],
|
|
4958
|
+
["\u81EA\u8026\u53D8", "autotransformer"],
|
|
4959
|
+
["\u53CC\u7ED5\u7EC4", "two-winding"],
|
|
4960
|
+
[/^容量 /, "power "],
|
|
4961
|
+
["\u661F\u5F62\u7ED5\u7EC4", "star winding"],
|
|
4962
|
+
["\u89D2\u5F62\u7ED5\u7EC4", "delta winding"],
|
|
4963
|
+
[/^调压绕组间 /, "across tap winding "],
|
|
4964
|
+
[/^调压绕组 /, "tapped winding "],
|
|
4965
|
+
[/^调压范围 /, "range "],
|
|
4966
|
+
["\u5BF9\u5730 Um", "Um to earth"],
|
|
4967
|
+
["\u5E02\u573A=", "market="],
|
|
4968
|
+
["\u661F\u70B9", "star point"],
|
|
4969
|
+
["\u7EBF\u7AEF", "line end"],
|
|
4970
|
+
["\u4E2D\u6027\u70B9", "neutral"],
|
|
4971
|
+
["\u76F8\u6570=", "phases="],
|
|
4972
|
+
["\u63A5\u7EBF=\u81EA\u52A8", "wiring=auto"],
|
|
4973
|
+
["\u63A5\u7EBF=", "wiring="],
|
|
4974
|
+
[/(由 ±([\d.]+) 推)/, " (from \xB1$1)"],
|
|
4975
|
+
[/(最低档按 −(\d+))/, " (lowest tap at \u2212$1)"],
|
|
4976
|
+
["\u6863\u6570\u672A\u6307\u5B9A", "positions not stated"],
|
|
4977
|
+
[/^±([\d.]+) 档/, "\xB1$1 steps"],
|
|
4978
|
+
[/ 档/g, " positions"],
|
|
4979
|
+
["W \u6B63\u53CD\u8C03", "W reversing"],
|
|
4980
|
+
["G \u7C97\u7EC6\u8C03", "G coarse/fine"],
|
|
4981
|
+
["0 \u7EBF\u6027\u8C03", "0 linear"],
|
|
4982
|
+
["\u6CB9\u6D78", "oil"],
|
|
4983
|
+
["\u771F\u7A7A", "vacuum"],
|
|
4984
|
+
["\u7BB1\u5185", "in tank"],
|
|
4985
|
+
["\u7BB1\u9876", "on tank"],
|
|
4986
|
+
["\u5E72\u5F0F", "dry-type"],
|
|
4987
|
+
["\u5916\u7F6E\u9694\u5BA4", "external compartment"],
|
|
4988
|
+
["\u7535\u6297\u5668", "reactor"],
|
|
4989
|
+
["\u672A\u6307\u5B9A", "not stated"],
|
|
4990
|
+
["\uFF08", " ("],
|
|
4991
|
+
["\uFF09", ")"],
|
|
4992
|
+
["\uFF0C", ", "]
|
|
4993
|
+
];
|
|
4994
|
+
function assumptionEn(item) {
|
|
4995
|
+
let s = item;
|
|
4996
|
+
for (const [from, to] of ASSUMPTION_EN) s = typeof from === "string" ? s.split(from).join(to) : s.replace(from, to);
|
|
4997
|
+
return s;
|
|
4998
|
+
}
|
|
4999
|
+
function basisLineEn(d) {
|
|
5000
|
+
const div = d.currentDivisor === "three" ? "3" : "\u221A3";
|
|
5001
|
+
const um = d.umRule === "explicit" ? `Um to earth ${d.umKv} (stated)` : d.umRule === "neutral_assumed" || d.umRule === "neutral_full" ? `neutral Um ${d.umKv}${d.umAssumed ? " (check the OS)" : ""}` : `${d.umSystemKv} kV system Um ${d.actualUmKv} \u2192 class ${d.umKv}`;
|
|
5002
|
+
const ust = d.stepV == null ? "" : ` \xB7 Ust ${round1(d.stepV)} V`;
|
|
5003
|
+
const max = d.maxRule === "stated" ? "OS Imax" : "lowest tap";
|
|
5004
|
+
if (!(d.ratedA > 0)) return `Imax as given \xB7 ${um}`;
|
|
5005
|
+
return `I = S/(${div}\xD7${d.currentKv} kV) = ${round1(d.ratedA)} A, ${max} ${round1(d.maxA)} A${ust} \xB7 ${um}`;
|
|
5006
|
+
}
|
|
2704
5007
|
function basisLineZh(d) {
|
|
2705
5008
|
const div = d.currentDivisor === "three" ? "3" : "\u221A3";
|
|
2706
5009
|
const um = d.umRule === "explicit" ? `\u5BF9\u5730 Um ${d.umKv}\uFF08\u6307\u5B9A\uFF09` : d.umRule === "neutral_assumed" || d.umRule === "neutral_full" ? `\u4E2D\u6027\u70B9 Um ${d.umKv}${d.umAssumed ? "\uFF08\u5F85 OS \u6838\u5BF9\uFF09" : ""}` : `${d.umSystemKv} kV \u7CFB\u7EDF Um ${d.actualUmKv} \u2192 ${d.umKv} \u7EA7`;
|
|
2707
5010
|
const ust = d.stepV == null ? "" : ` \xB7 Ust ${round1(d.stepV)} V`;
|
|
2708
|
-
|
|
5011
|
+
const max = d.maxRule === "stated" ? "OS Imax" : "\u6700\u4F4E\u6863";
|
|
5012
|
+
if (!(d.ratedA > 0)) return `Imax \u6309\u7ED9\u5B9A\u503C \xB7 ${um}`;
|
|
5013
|
+
return `I = S/(${div}\xD7${d.currentKv} kV) = ${round1(d.ratedA)} A\uFF0C${max} ${round1(d.maxA)} A${ust} \xB7 ${um}`;
|
|
5014
|
+
}
|
|
5015
|
+
function cliNotes(args, input, primaryUmKv, en, engineNotes = []) {
|
|
5016
|
+
if (!args) return [];
|
|
5017
|
+
const notes = [];
|
|
5018
|
+
const duty = cliDuty(args);
|
|
5019
|
+
if (duty?.ok && duty.ruleUmKv != null && duty.umKv < duty.ruleUmKv - 0.01) {
|
|
5020
|
+
const already = duty.cautionsEn.some((c) => c.startsWith("Stated Um"));
|
|
5021
|
+
if (!already) {
|
|
5022
|
+
notes.push(
|
|
5023
|
+
en ? `Stated insulation to earth, Um ${duty.umKv} kV, is below the ${duty.ruleUmKv} kV the winding voltage gives. Check the order specification (OS).` : `\u6307\u5B9A\u5BF9\u5730\u7EDD\u7F18 Um ${duty.umKv} kV \u4F4E\u4E8E\u6309\u7ED5\u7EC4\u7535\u538B\u5F97\u51FA\u7684 ${duty.ruleUmKv} kV\uFF0C\u8BF7\u6838\u5BF9\u8BA2\u8D27\u89C4\u8303\uFF08OS\uFF09\u3002`
|
|
5024
|
+
);
|
|
5025
|
+
}
|
|
5026
|
+
}
|
|
5027
|
+
const classSaid = engineNotes.some((c) => /next class|上一级|下一级/.test(c));
|
|
5028
|
+
if (primaryUmKv != null && primaryUmKv > input.umKv + 0.01 && !classSaid) {
|
|
5029
|
+
notes.push(
|
|
5030
|
+
en ? `Um ${input.umKv} kV is not a class of this type: sized at Um ${primaryUmKv} kV.` : `Um ${input.umKv} kV \u4E0D\u662F\u8BE5\u578B\u53F7\u7684\u7535\u538B\u7B49\u7EA7\uFF0C\u6309 Um ${primaryUmKv} kV \u9009\u3002`
|
|
5031
|
+
);
|
|
5032
|
+
}
|
|
5033
|
+
if (args.market && args.market !== "IT" && args.market !== "TR") {
|
|
5034
|
+
notes.push(
|
|
5035
|
+
en ? `--market ${args.market} has no rule (IT and TR only): not used.` : `--market ${args.market} \u6CA1\u6709\u5BF9\u5E94\u89C4\u5219\uFF08\u53EA\u6709 IT\u3001TR\uFF09\uFF0C\u672A\u4F7F\u7528\u3002`
|
|
5036
|
+
);
|
|
5037
|
+
}
|
|
5038
|
+
return notes;
|
|
5039
|
+
}
|
|
5040
|
+
function lineKindLabel(t, en) {
|
|
5041
|
+
if (t.kind === "auto") return en ? "autotransformer" : "\u81EA\u8026\u53D8";
|
|
5042
|
+
if (t.voltagesKv.length >= 3) return en ? "three-winding" : "\u4E09\u7ED5\u7EC4";
|
|
5043
|
+
return en ? "two-winding" : "\u53CC\u7ED5\u7EC4";
|
|
5044
|
+
}
|
|
5045
|
+
function noTypeHint(args, en) {
|
|
5046
|
+
if (!args) return null;
|
|
5047
|
+
if (args.mount === "dry_type" && !args.octc && args.reg !== "linear" && !args.given.has("mid")) {
|
|
5048
|
+
return en ? "Dry-type switches stop at 17 positions: try --mid 1 (\xB18 \u2192 17 positions) or fewer steps." : "\u5E72\u5F0F\u5F00\u5173\u6700\u591A 17 \u6863\uFF1A\u8BD5 --mid 1\uFF08\xB18 \u4E3A 17 \u6863\uFF09\u6216\u51CF\u5C11\u7EA7\u6570\u3002";
|
|
5049
|
+
}
|
|
5050
|
+
return null;
|
|
2709
5051
|
}
|
|
2710
5052
|
function formatCliText(input, args) {
|
|
2711
5053
|
const out = selectOltc(input);
|
|
5054
|
+
const en = args?.lang === "en";
|
|
2712
5055
|
if (!out.ok || !out.results.length) {
|
|
2713
|
-
const
|
|
5056
|
+
const hint = noTypeHint(args, en);
|
|
5057
|
+
const err = [...en ? out.errorsEn : [...out.errorsZh, ...out.errorsEn], ...hint ? [hint] : []].join("\n") || "No type found.";
|
|
2714
5058
|
throw new CliError(err);
|
|
2715
5059
|
}
|
|
2716
5060
|
const primary = out.results[0];
|
|
@@ -2729,22 +5073,40 @@ function formatCliText(input, args) {
|
|
|
2729
5073
|
);
|
|
2730
5074
|
const lines = [
|
|
2731
5075
|
primary.model,
|
|
2732
|
-
primary.reasonsZh[0] || primary.reasonsEn[0] || "\u6700\u4F4E\u6EE1\u8DB3"
|
|
5076
|
+
en ? primary.reasonsEn[0] || "Lowest type that meets the duty" : primary.reasonsZh[0] || primary.reasonsEn[0] || "\u6700\u4F4E\u6EE1\u8DB3"
|
|
2733
5077
|
];
|
|
2734
5078
|
const duty = args ? cliDuty(args) : null;
|
|
2735
|
-
|
|
2736
|
-
|
|
2737
|
-
for (const c of
|
|
5079
|
+
const note = en ? "Note: " : "\u6CE8\u610F\uFF1A";
|
|
5080
|
+
if (duty?.ok) lines.push(en ? `Basis: ${basisLineEn(duty)}` : `\u4F9D\u636E\uFF1A${basisLineZh(duty)}`);
|
|
5081
|
+
for (const c of en ? primary.cautionsEn : primary.cautionsZh) lines.push(`${note}${c}`);
|
|
5082
|
+
for (const c of (en ? duty?.cautionsEn : duty?.cautionsZh) ?? []) lines.push(`${note}${c}`);
|
|
5083
|
+
for (const c of cliNotes(args, input, primary.umKv, en, [...primary.cautionsEn, ...primary.cautionsZh])) {
|
|
5084
|
+
lines.push(`${note}${c}`);
|
|
5085
|
+
}
|
|
5086
|
+
const choices = args && duty?.ok ? umChoicesFor(args, input) : [];
|
|
5087
|
+
if (choices.length > 1) {
|
|
5088
|
+
const list = choices.map((c) => `Um ${c.um} \u2192 ${c.model ?? (en ? "none" : "\u65E0")}`).join(" \xB7 ");
|
|
5089
|
+
lines.push(
|
|
5090
|
+
en ? `Insulation to earth open: ${list} (take it from the tender's neutral / tap-winding insulation; use --earth-um)` : `\u5BF9\u5730\u7EDD\u7F18\u672A\u5B9A\uFF1A${list}\uFF08\u6309\u62DB\u6807\u7684\u4E2D\u6027\u70B9/\u8C03\u538B\u7ED5\u7EC4\u7EDD\u7F18\u53D6\uFF0C\u7528 --earth-um\uFF09`
|
|
5091
|
+
);
|
|
5092
|
+
}
|
|
5093
|
+
if (args?.line) {
|
|
5094
|
+
const t = args.line;
|
|
5095
|
+
const kind = lineKindLabel(t, en);
|
|
5096
|
+
const vg = t.vectorGroup ? ` \xB7 ${t.vectorGroup}` : en ? " \xB7 no vector group" : " \xB7 \u65E0\u8054\u7ED3\u7EC4";
|
|
5097
|
+
lines.push(`${en ? "Line: " : "\u62DB\u6807\u884C\uFF1A"}${kind} \xB7 ${t.mva} MVA \xB7 ${t.voltagesKv.join("/")} kV${vg}`);
|
|
5098
|
+
for (const w of t.warnings) lines.push(en ? `Note: line ${w}` : `\u6CE8\u610F\uFF1A\u62DB\u6807\u884C ${w}`);
|
|
5099
|
+
}
|
|
2738
5100
|
if (alts.length) {
|
|
2739
5101
|
lines.push("");
|
|
2740
|
-
lines.push("\u5176\u4ED6");
|
|
5102
|
+
lines.push(en ? "Other" : "\u5176\u4ED6");
|
|
2741
5103
|
for (const a of alts) lines.push(a.model);
|
|
2742
5104
|
}
|
|
2743
5105
|
if (args) {
|
|
2744
5106
|
const assumed = assumptionsLine(args, primary.seriesCode);
|
|
2745
5107
|
if (assumed) {
|
|
2746
5108
|
lines.push("");
|
|
2747
|
-
lines.push(assumed);
|
|
5109
|
+
lines.push(en ? `Assumed: ${assumptionsFromArgs(args, primary.seriesCode).map(assumptionEn).join(" \xB7 ")}` : assumed);
|
|
2748
5110
|
}
|
|
2749
5111
|
}
|
|
2750
5112
|
return lines.join("\n") + "\n";
|
|
@@ -2765,21 +5127,44 @@ function formatCliJson(input, args) {
|
|
|
2765
5127
|
acrossTapPfKv: input.acrossTapPfKv
|
|
2766
5128
|
}
|
|
2767
5129
|
).map((r) => r.model);
|
|
5130
|
+
const en = args?.lang === "en";
|
|
5131
|
+
const dutyJ = args ? cliDuty(args) : null;
|
|
5132
|
+
const hint = out.ok ? null : noTypeHint(args, en);
|
|
2768
5133
|
const payload = {
|
|
2769
|
-
ok: out.ok,
|
|
5134
|
+
ok: out.ok && primary != null,
|
|
5135
|
+
version: APP_VERSION,
|
|
2770
5136
|
model: primary?.model ?? null,
|
|
2771
|
-
why: primary?.reasonsZh[0] ?? primary?.reasonsEn[0] ?? null,
|
|
5137
|
+
why: en ? primary?.reasonsEn[0] ?? null : primary?.reasonsZh[0] ?? primary?.reasonsEn[0] ?? null,
|
|
2772
5138
|
alts,
|
|
2773
|
-
cautions: [
|
|
2774
|
-
|
|
2775
|
-
|
|
2776
|
-
|
|
5139
|
+
cautions: en ? [...primary?.cautionsEn ?? [], ...dutyJ?.cautionsEn ?? [], ...cliNotes(args, input, primary?.umKv ?? null, true, primary?.cautionsEn)] : [...primary?.cautionsZh ?? [], ...dutyJ?.cautionsZh ?? [], ...cliNotes(args, input, primary?.umKv ?? null, false, primary?.cautionsZh)],
|
|
5140
|
+
// What the engine was asked, as numbers: no prose to parse.
|
|
5141
|
+
resolved: {
|
|
5142
|
+
dutyKind: input.dutyKind,
|
|
5143
|
+
throughCurrentA: round1(input.throughCurrentA),
|
|
5144
|
+
umKv: input.umKv,
|
|
5145
|
+
stepVoltageV: round1(input.stepVoltageV),
|
|
5146
|
+
connection: input.connection,
|
|
5147
|
+
phases: input.phases,
|
|
5148
|
+
regulation: input.regulation,
|
|
5149
|
+
plusMinusSteps: input.plusMinusSteps ?? null,
|
|
5150
|
+
positions: input.positions ?? null,
|
|
5151
|
+
mounting: input.mounting,
|
|
5152
|
+
medium: input.medium
|
|
5153
|
+
},
|
|
5154
|
+
line: args?.line ? {
|
|
5155
|
+
kind: lineKindLabel(args.line, true),
|
|
5156
|
+
mva: args.line.mva,
|
|
5157
|
+
voltagesKv: args.line.voltagesKv,
|
|
5158
|
+
vectorGroup: args.line.vectorGroup ?? null,
|
|
5159
|
+
warnings: args.line.warnings
|
|
5160
|
+
} : null,
|
|
2777
5161
|
basis: (() => {
|
|
2778
|
-
const d =
|
|
5162
|
+
const d = dutyJ;
|
|
2779
5163
|
return d?.ok ? {
|
|
2780
5164
|
connection: d.connection,
|
|
2781
|
-
ratedA: round1(d.ratedA),
|
|
2782
|
-
maxA: round1(d.maxA),
|
|
5165
|
+
ratedA: d.ratedA > 0 ? round1(d.ratedA) : null,
|
|
5166
|
+
maxA: d.maxA > 0 ? round1(d.maxA) : null,
|
|
5167
|
+
maxRule: d.maxRule,
|
|
2783
5168
|
stepV: d.stepV == null ? null : round1(d.stepV),
|
|
2784
5169
|
umSystemKv: d.umSystemKv,
|
|
2785
5170
|
actualUmKv: d.actualUmKv,
|
|
@@ -2788,31 +5173,160 @@ function formatCliJson(input, args) {
|
|
|
2788
5173
|
umAssumed: d.umAssumed
|
|
2789
5174
|
} : null;
|
|
2790
5175
|
})(),
|
|
2791
|
-
|
|
2792
|
-
|
|
5176
|
+
umChoices: args ? umChoicesFor(args, input) : [],
|
|
5177
|
+
assumptions: args ? assumptionsFromArgs(args, primary?.seriesCode).map((a) => en ? assumptionEn(a) : a) : [],
|
|
5178
|
+
errors: [...en ? out.errorsEn : out.errorsZh.length ? out.errorsZh : out.errorsEn, ...hint ? [hint] : []]
|
|
2793
5179
|
};
|
|
2794
5180
|
return JSON.stringify(payload, null, 2) + "\n";
|
|
2795
5181
|
}
|
|
2796
|
-
function
|
|
5182
|
+
function umChoicesFor(args, input) {
|
|
5183
|
+
const d = cliDuty(args);
|
|
5184
|
+
if (!d?.ok) return [];
|
|
5185
|
+
const tap = cliTapPoint(args);
|
|
5186
|
+
const spec = {
|
|
5187
|
+
kind: args.kind,
|
|
5188
|
+
tapPoint: tap,
|
|
5189
|
+
winding: args.winding ?? (tap === "neutral" ? "star" : "delta"),
|
|
5190
|
+
mva: args.mva ?? 0,
|
|
5191
|
+
tapKv: args.kv ?? 0,
|
|
5192
|
+
hvKv: args.hv ?? 0,
|
|
5193
|
+
mvKv: args.mv ?? 0,
|
|
5194
|
+
minusSteps: 0,
|
|
5195
|
+
stepFraction: null,
|
|
5196
|
+
safetyK: 1
|
|
5197
|
+
};
|
|
5198
|
+
return umChoices(d, spec).map((um) => ({
|
|
5199
|
+
um,
|
|
5200
|
+
model: selectOltc({ ...input, umKv: um }).results[0]?.model ?? null
|
|
5201
|
+
}));
|
|
5202
|
+
}
|
|
5203
|
+
function runCli(argv2, io = {
|
|
2797
5204
|
stdout: (s) => process.stdout.write(s),
|
|
2798
5205
|
stderr: (s) => process.stderr.write(s)
|
|
2799
5206
|
}) {
|
|
5207
|
+
const asksHelp = argv2.some(
|
|
5208
|
+
(a, i) => (a === "-h" || a === "--help") && argv2[i - 1] !== "--line" && argv2[i - 1] !== "--nameplate"
|
|
5209
|
+
);
|
|
5210
|
+
const selecting = argv2.filter((a) => a !== "--no-update-check");
|
|
5211
|
+
if (asksHelp || selecting.length === 0) {
|
|
5212
|
+
io.stdout(CLI_HELP);
|
|
5213
|
+
return 0;
|
|
5214
|
+
}
|
|
5215
|
+
const wantsJson = argv2.includes("--json");
|
|
2800
5216
|
try {
|
|
2801
|
-
const args = parseCliArgs(
|
|
2802
|
-
if (args.
|
|
2803
|
-
io.stdout(
|
|
5217
|
+
const args = parseCliArgs(argv2);
|
|
5218
|
+
if (args.version) {
|
|
5219
|
+
io.stdout(`oltc-selector ${APP_VERSION}
|
|
5220
|
+
`);
|
|
2804
5221
|
return 0;
|
|
2805
5222
|
}
|
|
2806
5223
|
const input = cliToSelectInput(args);
|
|
2807
|
-
|
|
5224
|
+
if (args.json) {
|
|
5225
|
+
const text = formatCliJson(input, args);
|
|
5226
|
+
io.stdout(text);
|
|
5227
|
+
return JSON.parse(text).ok ? 0 : 1;
|
|
5228
|
+
}
|
|
5229
|
+
io.stdout(formatCliText(input, args));
|
|
2808
5230
|
return 0;
|
|
2809
5231
|
} catch (err) {
|
|
2810
5232
|
const msg = err instanceof Error ? err.message : String(err);
|
|
5233
|
+
if (wantsJson) {
|
|
5234
|
+
io.stdout(
|
|
5235
|
+
JSON.stringify({ ok: false, version: APP_VERSION, model: null, errors: msg.split("\n") }, null, 2) + "\n"
|
|
5236
|
+
);
|
|
5237
|
+
}
|
|
2811
5238
|
io.stderr(msg.endsWith("\n") ? msg : msg + "\n");
|
|
2812
5239
|
return 1;
|
|
2813
5240
|
}
|
|
2814
5241
|
}
|
|
2815
5242
|
|
|
5243
|
+
// lib/updateCheck.ts
|
|
5244
|
+
import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
|
|
5245
|
+
import { homedir } from "node:os";
|
|
5246
|
+
import path from "node:path";
|
|
5247
|
+
var UPDATE_TTL_MS = 24 * 60 * 60 * 1e3;
|
|
5248
|
+
var REGISTRY_LATEST = "https://registry.npmjs.org/oltc-selector/latest";
|
|
5249
|
+
function isNewer(latest, current) {
|
|
5250
|
+
const parse = (v) => {
|
|
5251
|
+
const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(v.trim());
|
|
5252
|
+
return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
|
|
5253
|
+
};
|
|
5254
|
+
const a = parse(latest);
|
|
5255
|
+
const b = parse(current);
|
|
5256
|
+
if (!a || !b) return false;
|
|
5257
|
+
for (let i = 0; i < 3; i++) {
|
|
5258
|
+
if (a[i] !== b[i]) return a[i] > b[i];
|
|
5259
|
+
}
|
|
5260
|
+
return false;
|
|
5261
|
+
}
|
|
5262
|
+
function updateNotice(latest, current) {
|
|
5263
|
+
return `
|
|
5264
|
+
\u6709\u65B0\u7248\u672C oltc-selector ${latest}\uFF08\u5F53\u524D ${current}\uFF09\uFF0C\u4E0D\u4F1A\u81EA\u52A8\u66F4\u65B0\u3002
|
|
5265
|
+
\u9700\u8981\u65F6\u8FD0\u884C\uFF1Anpm i -g oltc-selector@latest\uFF0C\u6216\u7528 npx -y oltc-selector@latest\u3002
|
|
5266
|
+
New version oltc-selector ${latest} (you have ${current}). Nothing is installed for you.
|
|
5267
|
+
To update: npm i -g oltc-selector@latest, or run npx -y oltc-selector@latest.
|
|
5268
|
+
`;
|
|
5269
|
+
}
|
|
5270
|
+
function updateCheckEnabled(argv2, env) {
|
|
5271
|
+
if (argv2.includes("--no-update-check")) return false;
|
|
5272
|
+
if (env.OLTC_NO_UPDATE_CHECK || env.NO_UPDATE_NOTIFIER || env.CI) return false;
|
|
5273
|
+
return true;
|
|
5274
|
+
}
|
|
5275
|
+
function defaultCacheFile(env) {
|
|
5276
|
+
const base = env.XDG_CACHE_HOME || path.join(homedir(), ".cache");
|
|
5277
|
+
return path.join(base, "oltc-selector", "update-check.json");
|
|
5278
|
+
}
|
|
5279
|
+
async function fetchLatest(timeoutMs) {
|
|
5280
|
+
const res = await fetch(REGISTRY_LATEST, {
|
|
5281
|
+
signal: AbortSignal.timeout(timeoutMs),
|
|
5282
|
+
headers: { accept: "application/json" }
|
|
5283
|
+
});
|
|
5284
|
+
if (!res.ok) return null;
|
|
5285
|
+
const body = await res.json();
|
|
5286
|
+
return typeof body.version === "string" ? body.version : null;
|
|
5287
|
+
}
|
|
5288
|
+
function readCache(file2) {
|
|
5289
|
+
try {
|
|
5290
|
+
const c = JSON.parse(readFileSync(file2, "utf8"));
|
|
5291
|
+
return typeof c.checkedAt === "number" ? c : null;
|
|
5292
|
+
} catch {
|
|
5293
|
+
return null;
|
|
5294
|
+
}
|
|
5295
|
+
}
|
|
5296
|
+
function writeCache(file2, c) {
|
|
5297
|
+
try {
|
|
5298
|
+
mkdirSync(path.dirname(file2), { recursive: true });
|
|
5299
|
+
writeFileSync(file2, JSON.stringify(c) + "\n");
|
|
5300
|
+
} catch {
|
|
5301
|
+
}
|
|
5302
|
+
}
|
|
5303
|
+
async function checkForUpdate(opts) {
|
|
5304
|
+
const now = opts.now ?? Date.now();
|
|
5305
|
+
try {
|
|
5306
|
+
let latest;
|
|
5307
|
+
const cached = readCache(opts.cacheFile);
|
|
5308
|
+
if (cached && now - cached.checkedAt < UPDATE_TTL_MS) {
|
|
5309
|
+
latest = cached.latest;
|
|
5310
|
+
} else {
|
|
5311
|
+
latest = await (opts.fetchLatest ?? fetchLatest)(opts.timeoutMs ?? 1500).catch(
|
|
5312
|
+
() => cached?.latest ?? null
|
|
5313
|
+
);
|
|
5314
|
+
writeCache(opts.cacheFile, { checkedAt: now, latest });
|
|
5315
|
+
}
|
|
5316
|
+
return latest && isNewer(latest, opts.current) ? updateNotice(latest, opts.current) : null;
|
|
5317
|
+
} catch {
|
|
5318
|
+
return null;
|
|
5319
|
+
}
|
|
5320
|
+
}
|
|
5321
|
+
|
|
2816
5322
|
// scripts/oltc.ts
|
|
2817
|
-
var
|
|
5323
|
+
var argv = process.argv.slice(2);
|
|
5324
|
+
var code = runCli(argv);
|
|
5325
|
+
if (updateCheckEnabled(argv, process.env)) {
|
|
5326
|
+
const notice = await checkForUpdate({
|
|
5327
|
+
current: APP_VERSION,
|
|
5328
|
+
cacheFile: defaultCacheFile(process.env)
|
|
5329
|
+
});
|
|
5330
|
+
if (notice) process.stderr.write(notice);
|
|
5331
|
+
}
|
|
2818
5332
|
process.exit(code);
|