From b6f9707a254f7349a87f10957c1568ff5befca4c Mon Sep 17 00:00:00 2001 From: umsangdon Date: Thu, 8 Oct 2026 19:42:14 +0900 Subject: [PATCH] =?UTF-8?q?feat(B08):=20=EC=95=94=20=ED=99=98=EC=82=B0?= =?UTF-8?q?=EA=B3=84=EC=88=98=20C=20=3D=20=EC=97=B0=EC=95=94=20=C2=B7=20?= =?UTF-8?q?=EA=B2=BD=EC=95=94=20=EB=B9=84=EC=9C=A8=20=EA=B0=80=EC=A4=91(?= =?UTF-8?q?=EC=97=B0=EC=95=94=20=EB=A6=AC=ED=95=91=20=C2=B7=20=EA=B2=BD?= =?UTF-8?q?=EC=95=94=20=EB=B0=9C=ED=8C=8C=20=EA=B3=A0=EC=A0=95)=20?= =?UTF-8?q?=E2=80=94=20=ED=86=A0=EC=A0=81=ED=91=9C=20=EC=A1=B0=EC=9E=91=20?= =?UTF-8?q?=EC=A4=91=20=EB=B0=94=EB=A1=9C=20=C2=B7=20B06=20=EC=9C=A0?= =?UTF-8?q?=ED=86=A0=EA=B3=A1=EC=84=A0=20=EB=8B=A4=EC=9D=8C=20=EC=84=9C?= =?UTF-8?q?=EB=B2=84=20=EA=B3=84=EC=82=B0=20=EB=95=8C(125-1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01BVPp2o6Mh2FZJr72yW3ofZ --- B08_Quantity/B08_Quantity_Options_Calc.ts | 69 ++++++++++++++++ B08_Quantity/B08_Quantity_Router_Earthwork.py | 9 ++- B08_Quantity/B08_Quantity_UI_Earthwork.ts | 30 +++++-- common_util/common_util_project_settings.py | 36 +++++---- .../tester/test_122_b08_options_mirror.py | 72 ++++++++++++++++- resources/tester/test_125_rock_c.py | 78 +++++++++++++++++++ .../tester/test_rock_mixed_conversion.py | 11 +-- 7 files changed, 274 insertions(+), 31 deletions(-) create mode 100644 resources/tester/test_125_rock_c.py diff --git a/B08_Quantity/B08_Quantity_Options_Calc.ts b/B08_Quantity/B08_Quantity_Options_Calc.ts index b4f33256c..9f878382e 100644 --- a/B08_Quantity/B08_Quantity_Options_Calc.ts +++ b/B08_Quantity/B08_Quantity_Options_Calc.ts @@ -7,6 +7,10 @@ * rockSplit · splitRockColumns · splitRockSummary * ↔ `B08_Quantity_Engine_Earthwork_Summary.py` rock_split · * split_rock_columns · summary_rows(연암 · 경암 네 줄) + * mixedRockC ↔ `common_util_project_settings.py` mixed_rock_c(125-1) + * recountRockC · recountAdjustedSummary + * ↔ `B08_Quantity_Engine_Earthwork.py` build_rows · totals · + * summary_rows(보정량계 · 유용토 · 잔토처리 줄) * [저장] 뒤에는 서버가 정본으로 다시 셈 — 여기 값을 받아 적지 않음. * import 없음 — 시험이 이 파일만 옮겨 돌림. * ========================================================================== */ @@ -106,3 +110,68 @@ export function splitRockSummary (typeof value === "number" ? value : 0); +const RECOUNT_TOTALS = [ + "cut_rock_adjusted_m3", + "ditch_rock_adjusted_m3", + "adjusted_total_m3", + "diverted_m3", + "balance_m3", +] as const; + +/** 토적표를 새 암 C 로 — 암 보정량 · 보정량계 · 유용토 · 차인 · 누가 · 합계(줄 · 합계 덮어씀). */ +export function recountRockC( + rows: Array>, + totals: Record, + c: number, +): void { + let cumulative = 0; + for (const row of rows) { + const cutRock = num(row.cut_rock_volume_m3) * c; + const adjusted = num(row.cut_soil_adjusted_m3) + cutRock; + const fill = num(row.fill_volume_m3); + cumulative += adjusted - fill; + Object.assign(row, { + cut_rock_adjusted_m3: cutRock, + ditch_rock_adjusted_m3: num(row.ditch_rock_volume_m3) * c, + adjusted_total_m3: adjusted, + diverted_m3: Math.min(adjusted, fill), + balance_m3: adjusted - fill, + cumulative_m3: cumulative, + }); + } + const sum = (key: string, picked = rows): number => + picked.reduce((total, row) => total + num(row[key]), 0); + for (const key of RECOUNT_TOTALS) totals[key] = sum(key); + for (const kind of ["ripping_rock", "blasting_rock"]) + totals[`cut_${kind}_adjusted_m3`] = sum( + "cut_rock_adjusted_m3", + rows.filter((row) => row.cut_rock_kind === kind), + ); +} + +/** 엑셀 ROUND(정수) — 반은 0 에서 먼 쪽. */ +const excelRound = (value: number): number => Math.sign(value) * Math.round(Math.abs(value)); + +/** 토공집계표 보정량계 · 유용토 소계 · 횡방향유용토 · 잔토처리 줄 — 합계에서 다시(종방향 무대 Q 는 그대로). */ +export function recountAdjustedSummary( + rows: readonly R[], + totals: Record, + freeQ: number, +): R[] { + const diverted = totals.diverted_m3 ?? 0; + const values: Record = { + 보정량계: excelRound(totals.adjusted_total_m3 ?? 0), + "유용토 소계": diverted + freeQ, + 횡방향유용토: diverted, + 잔토처리: excelRound(totals.balance_m3 ?? 0), + }; + return rows.map((row) => (row.group in values ? { ...row, value: values[row.group] } : row)); +} diff --git a/B08_Quantity/B08_Quantity_Router_Earthwork.py b/B08_Quantity/B08_Quantity_Router_Earthwork.py index 9d249fe22..3e8f81555 100644 --- a/B08_Quantity/B08_Quantity_Router_Earthwork.py +++ b/B08_Quantity/B08_Quantity_Router_Earthwork.py @@ -6,7 +6,8 @@ 운반 Q · L = 종단 레코드에 저장된 유토곡선 배분(`mass_haul.haul_plan`) — B07 토적도와 같은 정본. 단면적 = B06 횡단 설계 저장값(`cross_sections.data.design`) · 노선 = 확정 노선(없으면 최신 노선) · -토량환산계수 = 유토곡선과 같은 `mixed_conversion_factors(quantity_settings)`. +토량환산계수 = 유토곡선과 같은 `mixed_conversion_factors(quantity_settings)` · 암 = 연암 · 경암 비율 가중 C · +`rock_c` = 가중 전 리핑암 · 발파암 C(조작 중 브라우저가 다시 가중 · 125-1). 암 → 연암 · 경암 = 암 × 연암 %(`rock_ratios_pct` · 기본 90 · PLAN 122) — 토적표 줄 · 합계 · 토공집계표. """ @@ -32,6 +33,7 @@ from B08_Quantity.B08_Quantity_Engine_Earthwork_Summary import ( ) from B08_Quantity.B08_Quantity_Router_Hydro import _project_root from common_util.common_util_project_settings import ( + earthwork_conversion_factors, mixed_conversion_factors, quantity_settings, soft_rock_pct, @@ -65,6 +67,11 @@ async def earthwork_table(project_id: UUID) -> dict[str, Any]: **table, "summary": summary_rows(table["totals"], haul, soft), "rock_ratios_pct": {"연암": soft, "경암": 100.0 - soft}, + "rock_c": { + kind: entry["compacted"] + for kind, entry in earthwork_conversion_factors(settings).items() + if kind != "soil" + }, "haul": haul, "haul_saved": bool(mass_haul.get("haul_plan")), "route_id": route_id, diff --git a/B08_Quantity/B08_Quantity_UI_Earthwork.ts b/B08_Quantity/B08_Quantity_UI_Earthwork.ts index 53049fa37..4345422f6 100644 --- a/B08_Quantity/B08_Quantity_UI_Earthwork.ts +++ b/B08_Quantity/B08_Quantity_UI_Earthwork.ts @@ -7,7 +7,8 @@ * 보정량 · 보정량계 · 성토 · 유용토 · 차인토량 · 누가토량 · 면고르기 · 지장목제거 · 제근 · 노면정리 각 * 거리 · 면적) · 맨 아래 합계 줄. 첫 측점은 앞이 없어 입적 · 면적이 빈 값(—). * 표 = 공용 많은 자료 표(`ui_template_data_table` · PLAN 70) · 카드 안 · 나머지 셋은 `…_Earthwork_Sheets`. - * 절토 연암 · 경암 = 암 × 좌측 패널 비율 — 조작 중 같은 식으로 바로 다시 셈(`…_Options_Calc` · PLAN 122). + * 절토 연암 · 경암 = 암 × 좌측 패널 비율 · 암 C = 비율 가중 — 조작 중 같은 식으로 바로 다시 셈 + * (`…_Options_Calc` · PLAN 122 · 125-1). * ========================================================================== */ import { API_BASE_URL } from "@config/config_frontend"; @@ -20,7 +21,13 @@ import { renderFreeHaul, renderHaulDistance, } from "./B08_Quantity_UI_Earthwork_Sheets"; -import { splitRockColumns, splitRockSummary } from "./B08_Quantity_Options_Calc"; +import { + mixedRockC, + recountAdjustedSummary, + recountRockC, + splitRockColumns, + splitRockSummary, +} from "./B08_Quantity_Options_Calc"; import { liveSoftRock, onOptionsChange } from "./B08_Quantity_UI_Options"; type Face = { length_m: number | null; area_m2: number | null }; @@ -85,6 +92,8 @@ export interface EarthworkTable { haul_saved: boolean; /** 저장된 연암 · 경암 %(암 전체 기준) */ rock_ratios_pct: { 연암: number; 경암: number }; + /** 가중 전 리핑암(연암) · 발파암(경암) C — 비율로 다시 가중(125-1) */ + rock_c: { ripping_rock: number; blasting_rock: number }; } /** 칸 묶음 — [머리 묶음, 키 앞머리, 풍선 글] · 단면적 · 입적 · 보정량 셋 · 머리 글자는 사용자 견본대로 */ @@ -212,8 +221,9 @@ function renderSheet(host: HTMLElement, table: EarthworkTable, interval: number) const info = [ note( `평균단면적법 · 노선 ${table.route_id}${table.confirmed ? "(확정)" : "(확정 전 최신 노선)"} · ` + - `측점 ${table.station_count} · 다짐 환산계수 토사 ${c("soil")} · 리핑암 ${c("ripping_rock")} · ` + - `발파암 ${c("blasting_rock")} · 보정량계 = 절토 보정량 · 면 거리 = B07 횡단도 수량 · ` + + `측점 ${table.station_count} · 다짐 환산계수 토사 ${c("soil")} · 암 ` + + `${table.conversion_factors.ripping_rock?.compacted.toFixed(3) ?? ""}(연암 리핑 ` + + `${table.rock_c.ripping_rock} · 경암 발파 ${table.rock_c.blasting_rock} 비율 가중) · 보정량계 = 절토 보정량 · 면 거리 = B07 횡단도 수량 · ` + `단위 m · ㎡ · ㎥`, ), ...(flagged.length ? [note(`* ${flagged[0].notes[0]} — ${flagged.length}곳`)] : []), @@ -260,13 +270,21 @@ export async function renderEarthwork(host: HTMLElement, projectId: string): Pro return; } - // 연암 · 경암 칸 · 집계표 줄 = 암 × 지금 비율(캐시 → 저장본) + // 연암 · 경암 칸 · 집계표 줄 = 암 × 지금 비율 · 암 C = 비율 가중(캐시 → 저장본 · 125-1) const summary = table.summary; const applyRock = (): void => { const soft = liveSoftRock(projectId, table.rock_ratios_pct?.연암 ?? 90); + const c = mixedRockC(soft, table.rock_c.ripping_rock, table.rock_c.blasting_rock); + for (const kind of ["ripping_rock", "blasting_rock"]) + table.conversion_factors[kind].compacted = c; + recountRockC(table.rows as unknown as Array>, table.totals, c); for (const record of [...table.rows, table.totals]) splitRockColumns(record as unknown as Record, soft); - table.summary = splitRockSummary(summary, table.totals, soft); + table.summary = recountAdjustedSummary( + splitRockSummary(summary, table.totals, soft), + table.totals, + table.haul.free_haul.q, + ); }; applyRock(); diff --git a/common_util/common_util_project_settings.py b/common_util/common_util_project_settings.py index 0546856c9..4975baa94 100644 --- a/common_util/common_util_project_settings.py +++ b/common_util/common_util_project_settings.py @@ -345,27 +345,29 @@ def earthwork_conversion_factors(settings: dict[str, Any]) -> dict[str, dict[str ROCK_METHOD_KINDS = {ROCK_METHOD_RIPPING: "ripping_rock", ROCK_METHOD_BLASTING: "blasting_rock"} -def mixed_conversion_factors(settings: dict[str, Any]) -> dict[str, dict[str, float]]: - """토적표·유토곡선·운반표가 **계산에** 쓸 계수 — 암은 구성비 가중 C (㉱ (나) · 2026-09-14). +def mixed_rock_c(soft_pct: float, ripping_c: float, blasting_c: float) -> float: + """암 C = 연암 % × 리핑암 C + 경암 % × 발파암 C(0~100 자름 · 125-1). - B06 의 암은 한 종류 **자리표시**(`ripping_rock` · 옛 자료 `blasting_rock`)이고 암질은 설계내역에서 - 구성비로 정함(8-1 사용자 확정). 그래서 구성비와 갈래별 시공법이 **다 서면** 암 두 칸을 - Σ몫 × C(시공법)로 갈음 — 몫은 흙깎기와 같은 안분(준 비율끼리 · 합이 100 이 아니어도 안분). - ⚠ 구성비가 비거나 시공법이 빠진 갈래가 있으면 **종전 값** — 인계가 막힘 사유를 내고, 지어낸 계수를 안 씀. + 짝 — `B08_Quantity_Options_Calc.ts` `mixedRockC`(거울 시험 `test_122_b08_options_mirror`). + """ + soft = min(max(soft_pct, 0.0), 100.0) / 100.0 + return soft * ripping_c + (1.0 - soft) * blasting_c + + +def mixed_conversion_factors(settings: dict[str, Any]) -> dict[str, dict[str, float]]: + """토적표·유토곡선·운반표가 **계산에** 쓸 계수 — 암은 연암 · 경암 비율 가중 C (125-1). + + B06 의 암은 한 종류 **자리표시**(`ripping_rock` · 옛 자료 `blasting_rock`)라 암 두 칸을 + `mixed_rock_c(연암 %, 리핑암 C, 발파암 C)` 하나로 갈음 — 비율 = `soft_rock_pct`(기본 90 : 10 · 122). + 시공법은 연암 = 리핑암 · 경암 = 발파암 고정(브레인 정함) — `rock_methods` 를 안 읽음. ⚠ 화면 「무엇을 골랐나」(`earthwork_conversion_choices`)는 갈래별 값 그대로 — 여기 값을 보이면 안 됨. """ resolved = earthwork_conversion_factors(settings) - ratios = settings.get("rock_ratios_pct") or {} - shares = { - name: float(ratios.get(name) or 0) - for name in rock_classes(settings) - if name != "토사" and float(ratios.get(name) or 0) > 0 - } - kinds = {name: ROCK_METHOD_KINDS.get(rock_method(settings, name) or "") for name in shares} - if not shares or not all(kinds.values()): - return resolved - total = sum(shares.values()) - mixed = sum(shares[name] / total * resolved[kind]["compacted"] for name, kind in kinds.items()) + mixed = mixed_rock_c( + soft_rock_pct(settings), + resolved["ripping_rock"]["compacted"], + resolved["blasting_rock"]["compacted"], + ) for kind in ROCK_METHOD_KINDS.values(): resolved[kind]["compacted"] = mixed return resolved diff --git a/resources/tester/test_122_b08_options_mirror.py b/resources/tester/test_122_b08_options_mirror.py index a24139945..c4ad4a4fa 100644 --- a/resources/tester/test_122_b08_options_mirror.py +++ b/resources/tester/test_122_b08_options_mirror.py @@ -14,6 +14,7 @@ from pathlib import Path import pytest +from B08_Quantity.B08_Quantity_Engine_Earthwork import StationArea, build_table from B08_Quantity.B08_Quantity_Engine_Earthwork_Summary import ( haul_lists, rock_split, @@ -21,6 +22,7 @@ from B08_Quantity.B08_Quantity_Engine_Earthwork_Summary import ( summary_rows, ) from B08_Quantity.B08_Quantity_Router_Summary import couplings +from common_util.common_util_project_settings import mixed_conversion_factors, mixed_rock_c ROOT = Path(__file__).resolve().parents[2] TSC = ROOT / "config" / "node_modules" / "typescript" / "bin" / "tsc" @@ -85,7 +87,7 @@ writeFileSync(process.argv[2], JSON.stringify(out)); """ -def _ts(tmp_path: Path, payload: dict) -> dict: +def _ts(tmp_path: Path, payload: dict, runner: str = _RUNNER) -> dict: out = tmp_path / "js" subprocess.run( # noqa: S603 — 고정 실행 파일 [ @@ -106,7 +108,7 @@ def _ts(tmp_path: Path, payload: dict) -> dict: check=True, capture_output=True, ) - (out / "runner.mjs").write_text(_RUNNER, encoding="utf-8") + (out / "runner.mjs").write_text(runner, encoding="utf-8") result = tmp_path / "out.json" subprocess.run( # noqa: S603 ["node", str(out / "runner.mjs"), str(result), json.dumps(payload)], @@ -162,6 +164,68 @@ def test_두_쪽이_같은_값을_낸다(tmp_path: Path) -> None: assert got == _py_recount(one), one +# 125-1 — 암 C = 비율 가중 · 토적표(90 : 10 으로 선 서버 값)를 새 비율로 다시 센 TS = 서버가 그 비율로 센 값 +STATIONS = [ + StationArea(0.0, cut_soil_area_m2=1.5, cut_rock_area_m2=2.0, fill_area_m2=0.5), + StationArea(20.0, cut_soil_area_m2=0.7, cut_rock_area_m2=3.3, ditch_area_m2=0.4), + StationArea(40.0, cut_rock_area_m2=1.1, fill_area_m2=9.0, cut_rock_kind="blasting_rock"), + StationArea(52.5, cut_soil_area_m2=2.2, fill_area_m2=1.3), +] +HAUL_PLAN = { + "blocks": [{"bands": [{"equipment": "free_haul", "volume_m3": 12.5, "haul_distance_m": 8}]}] +} + +_RUNNER_C = """ +import { writeFileSync } from "node:fs"; +import * as calc from "./B08_Quantity_Options_Calc.js"; +const input = JSON.parse(process.argv[3]); +const out = { + c: input.pcts.map((p) => calc.mixedRockC(p, 1.15, 1.3)), + tables: input.pcts.map((p) => { + const t = structuredClone(input.table); + calc.recountRockC(t.rows, t.totals, calc.mixedRockC(p, 1.15, 1.3)); + for (const r of [...t.rows, t.totals]) calc.splitRockColumns(r, p); + const summary = calc.recountAdjustedSummary( + calc.splitRockSummary(t.summary, t.totals, p), t.totals, input.freeQ); + return { rows: t.rows, totals: t.totals, summary }; + }), +}; +writeFileSync(process.argv[2], JSON.stringify(out)); +""" + + +def _py_table(pct: float) -> dict: + """서버 길(`Router_Earthwork`) 그대로 — 가중 C 로 표 · 연암 · 경암 칸 · 집계표.""" + table = build_table(STATIONS, mixed_conversion_factors({"rock_ratios_pct": {"연암": pct}})) + for record in [*table["rows"], table["totals"]]: + split_rock_columns(record, pct) + summary = summary_rows(table["totals"], haul_lists(HAUL_PLAN), pct) + return {"rows": table["rows"], "totals": table["totals"], "summary": summary} + + +@pytest.mark.skipif(not TSC.is_file(), reason="프론트엔드 의존성 미설치") +def test_암_C_가중_두_쪽이_같은_값을_낸다(tmp_path: Path) -> None: + pcts = [0, 10, 33.3, 50, 90, 100, 130, -5] + ts = _ts( + tmp_path, + {"pcts": pcts, "table": _py_table(90), "freeQ": haul_lists(HAUL_PLAN)["free_haul"]["q"]}, + _RUNNER_C, + ) + assert ts["c"] == [mixed_rock_c(p, 1.15, 1.3) for p in pcts] + for pct, got in zip(pcts, ts["tables"]): + want = json.loads(json.dumps(_py_table(pct))) + assert got["rows"] == want["rows"] and got["summary"] == want["summary"], pct + # 합계 — 파이썬 3.12 sum() 은 보정 합산이라 끝자리(1 ulp)만 다를 수 있음 + assert got["totals"] == pytest.approx(want["totals"], rel=1e-12), pct + + +def test_50_50_이면_보정량이_바뀜() -> None: + ninety, half = _py_table(90)["totals"], _py_table(50)["totals"] + assert half["cut_rock_volume_m3"] == ninety["cut_rock_volume_m3"] + assert half["cut_rock_adjusted_m3"] == pytest.approx(ninety["cut_rock_volume_m3"] * 1.225) + assert half["adjusted_total_m3"] > ninety["adjusted_total_m3"] + + def test_1본_6_m_면_커플링이_바뀜(tmp_path: Path) -> None: six, eight = _py_recount(6), _py_recount(8) assert six["total"]["pipe:cp|800"] == 2 + 1 + 2 and eight["total"]["pipe:cp|800"] == 2 + 1 + 1 @@ -174,4 +238,8 @@ def test_식_모양이_두_쪽_같다() -> None: assert "Math.max(Math.ceil(lengthM / oneM - 1e-9) - 1, 0)" in ts assert "const soft = (value * Math.min(Math.max(softPct, 0), 100)) / 100;" in ts assert "soft = value * min(max(soft_pct, 0.0), 100.0) / 100.0" in py + assert "return soft * rippingC + (1 - soft) * blastingC;" in ts + assert "return soft * ripping_c + (1.0 - soft) * blasting_c" in ( + ROOT / "common_util" / "common_util_project_settings.py" + ).read_text("utf-8") assert not re.search(r"^import ", ts, re.M) # 시험이 이 파일만 옮겨 돌림 diff --git a/resources/tester/test_125_rock_c.py b/resources/tester/test_125_rock_c.py new file mode 100644 index 000000000..3c17eb8d8 --- /dev/null +++ b/resources/tester/test_125_rock_c.py @@ -0,0 +1,78 @@ +"""125-1 연암 · 경암 비율 → 암 환산계수 C 가중(연암 = 리핑암 · 경암 = 발파암 고정). + +C = 연암 % × 리핑암 C + 경암 % × 발파암 C · 비율 = 122 `rock_ratios_pct`(기본 90 : 10) · +B08 토적표 보정량 · B06 유토곡선이 같은 `mixed_conversion_factors` 를 씀. +""" + +from __future__ import annotations + +import asyncio +import json +from pathlib import Path + +import pytest + +from B06_Section import B06_Section_Server_Calc_Prebuild as prebuild +from B08_Quantity.B08_Quantity_Engine_Earthwork import StationArea, build_table +from common_util.common_util_project_settings import ( + mixed_conversion_factors, + quantity_settings, + settings_path, +) + +RIP, BLAST = 1.15, 1.30 # 품셈 토량환산계수 기본(config) — 표 그대로 + + +def _c(settings: dict) -> float: + factors = mixed_conversion_factors(settings) + assert factors["ripping_rock"]["compacted"] == factors["blasting_rock"]["compacted"] + return factors["ripping_rock"]["compacted"] + + +def test_기본_90_10_이면_가중_C() -> None: + assert _c({}) == pytest.approx(0.9 * RIP + 0.1 * BLAST) # 1.165 + assert _c({"rock_ratios_pct": {"연암": 90.0, "경암": 10.0}}) == pytest.approx(1.165) + + +def test_50_50_이면_C_가_바뀜() -> None: + assert _c({"rock_ratios_pct": {"연암": 50.0, "경암": 50.0}}) == pytest.approx(1.225) + assert _c({"rock_ratios_pct": {"연암": 100.0}}) == pytest.approx(RIP) + assert _c({"rock_ratios_pct": {"연암": 0.0}}) == pytest.approx(BLAST) + + +def test_시공법_칸은_안_읽음() -> None: + ratios = {"rock_ratios_pct": {"연암": 50.0}} + assert _c({**ratios, "rock_methods": {"연암": "blasting", "경암": "ripping"}}) == _c(ratios) + + +def test_토사_C_는_그대로() -> None: + assert mixed_conversion_factors({"rock_ratios_pct": {"연암": 50.0}})["soil"]["compacted"] == 0.9 + + +def test_B08_토적표_보정량이_가중_C_로() -> None: + stations = [ + StationArea(chainage_m=0.0, cut_rock_area_m2=2.0), + StationArea(chainage_m=20.0, cut_rock_area_m2=4.0, cut_rock_kind="blasting_rock"), + ] + for pct, c in ((90.0, 1.165), (50.0, 1.225)): + settings = {"rock_ratios_pct": {"연암": pct}} + table = build_table(stations, mixed_conversion_factors(settings)) + assert table["totals"]["cut_rock_volume_m3"] == pytest.approx(60.0) + assert table["totals"]["cut_rock_adjusted_m3"] == pytest.approx(60.0 * c) + + +def test_B06_유토곡선이_같은_C(tmp_path: Path, monkeypatch) -> None: + settings_path(tmp_path).write_text( + json.dumps({"quantity": {"rock_ratios_pct": {"연암": 50.0, "경암": 50.0}}}), "utf-8" + ) + + async def fake_run(_fn, _project_id): + return "x" + + monkeypatch.setattr(prebuild, "run_with_connection", fake_run) + monkeypatch.setattr(prebuild, "resolve_stored_project_path", lambda _p: tmp_path) + factors = asyncio.run(prebuild.conversion_factors_for("p")) + assert factors["ripping_rock"]["compacted"] == pytest.approx(1.225) + assert factors == mixed_conversion_factors(quantity_settings(tmp_path)) + context = prebuild._mass_haul_context(None, factors) + assert context["earthwork_conversion"]["ripping_rock"]["compacted"] == pytest.approx(1.225) diff --git a/resources/tester/test_rock_mixed_conversion.py b/resources/tester/test_rock_mixed_conversion.py index ca72dbbf4..65a21426c 100644 --- a/resources/tester/test_rock_mixed_conversion.py +++ b/resources/tester/test_rock_mixed_conversion.py @@ -44,14 +44,15 @@ def test_고른_계수_위에서_가중() -> None: @pytest.mark.parametrize( - "settings", + ("settings", "soft"), [ - {"rock_class_set": "geochang5"}, - {**MIX, "rock_methods": {"연암": "ripping"}}, + ({"rock_class_set": "geochang5"}, 0.9), # 비율 비면 기본 90 : 10(122) + ({**MIX, "rock_methods": {"연암": "ripping"}}, 0.6), # 시공법 안 봄(125-1) ], ) -def test_구성비나_시공법이_비면_종전_값(settings: dict) -> None: - assert mixed_conversion_factors(settings) == earthwork_conversion_factors(settings) +def test_비율이_비면_기본_시공법은_연암_리핑_경암_발파_고정(settings: dict, soft: float) -> None: + mixed = mixed_conversion_factors(settings)["ripping_rock"]["compacted"] + assert mixed == pytest.approx(soft * 1.15 + (1 - soft) * 1.30) def test_화면_고른_값_표시는_갈래별_그대로() -> None: