Merge branch 'sub_laptop_2' of C:/Aislo_wt/sub_laptop_2 into main_laptop_1

This commit is contained in:
2026-11-17 09:23:36 +09:00
14 changed files with 2123 additions and 384 deletions
@@ -0,0 +1,515 @@
# -*- coding: utf-8 -*-
"""작업량 식 직접 칸 · 덤프 운반 구간 여럿(PLAN 851-1 · 요구 893) — 옛 로직 JSON 고침(한 번 돌림).
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_직접칸_851_1.py
그 뒤 `build_수식문서_802_2.py` 로 수식 문서를 다시 지음(정본 길).
- 고르기(표 값)로만 정해지는 수 = 그 중간 줄(또는 식 속 그 찾기)을 「만약(X입력 > 0, X입력, 표)」 로 —
비우거나 0 = 고르기 값 · 넣으면 그 값이 이김 · 입력 칸 자리 = 그 값을 정하는 고르기 칸 바로 아래 ·
보이는 이름 = 「○○ 직접」(변수표 이름) · 열쇠 = 「X입력」 · 범위 = 표 값이 다 1 이하인 작업효율만 [0, 1](지금 E입력 과 같음).
- 지금 「0 = 표」 직접 칸(E입력 · 싸이클입력 · K입력 · α입력 …) = 열쇠 그대로 · 보이는 이름만 「○○ 직접」.
- 덤프트럭(8-2-8) t2 = 구간 셋(구간 1 = 지금 운반거리 · 도로상태 · 구간2거리 · 구간3거리 = 0 이면 안 탐) ·
구간마다 적재 · 공차 주행속도 직접(원문 3 [주] 「주행속도를 측정하여 사용할 수 있다」) · t2 · t3 · t4 · t5 직접.
- 직접 칸을 더한 식을 입력 다 넘겨 부르는 로직(옛 엔진은 입력을 다 받음) = 새 입력 0 · 구간 도로상태 = 구간 1 값.
- 목록 276 변수 중 뺀 것(값 하나 · 이미 직접 칸이 덮음 · 글 값) = 851-1 보고 표.
- 이미 돌렸으면(덤프 V1 있음) 멈춤.
"""
from __future__ import annotations
import copy
import json
import re
import sys
from decimal import Decimal
from pathlib import Path
HERE = Path(__file__).resolve().parent
MASTER = HERE.parent
ROOT = MASTER.parents[1]
for p in (str(ROOT), str(HERE)):
if p not in sys.path:
sys.path.insert(0, p)
C08 = "로직_건설품셈_08장_건설기계.json"
F10 = "로직_산림품셈_10장_자재․장비_운반.json"
SELF = "로직_자체.json"
DUMP = "GC001155"
EFF = [
0,
1,
] # 작업효율 직접 칸 범위(지금 E입력 과 같음 · 원문 표 값이 1 넘는 효율 표(준설선 · 임목파쇄기)는 범위 없음)
# (식, 중간 줄 | 결과, 감쌀 글(None = 줄 통째), 열쇠, 보이는 이름, 자리(이 입력 아래), 단위, 범위) · 기호 = 이름 규칙
OPS: list[tuple] = [
("GC001144", "q0", None, "q0입력", "삽날용량 직접", "급수", "㎥", None),
("GC001144", "e", None, "e입력", "운반거리계수 직접", "거리구분", "", None),
("GC001144", "V1", None, "V1입력", "전진속도 직접", "전진단", "m/분", None),
("GC001144", "V2", None, "V2입력", "후진속도 직접", "후진단", "m/분", None),
("GC001146", "An", None, "An입력", "리핑 단면적 직접", "발톱수", "㎡", None),
("GC001149", "d", None, "d입력", "굴착심도계수 직접", "굴착심도", "", None),
("GC001150", "m", None, "m입력", "주행계수 직접", "기종", "sec/m", None),
(
"GC001150",
"cm",
"t1",
"t1입력",
"적재시간 직접",
"적재조건",
"sec",
None,
), # 줄 t1 = 표 한 마디(열쇠 겹침 피함)
("GC001150", "K", None, "K입력", "버킷계수 직접", "K조건", "", None),
("GC001152", "K", None, "K입력", "적재계수 직접", "토질상태", "", None),
("GC001152", "V1", None, "V1입력", "적재 주행속도 직접", "도로상태", "m/분", None),
("GC001152", "V2", None, "V2입력", "공차 주행속도 직접", "V1입력", "m/분", None),
("GC001152", "t", None, "t입력", "적토·사토·기어변속시간 직접", "푸쉬도우저", "분", None),
*[
op
for key in ("GC001153", "GC001154")
for op in (
(key, "V1", None, "V1입력", "작업속도 직접", "현장조건", "㎞/hr", None),
(key, "V2", None, "V2입력", "후진·회송속도 직접", "되돌림조건", "㎞/hr", None),
(key, "t", None, "t입력", "방향변환시간 직접", "t작업", "분", None),
)
],
("GC001154", "l", None, "l입력", "블레이드 유효길이 직접", "l작업", "m", None),
*[
op
for key in ("GC001157", "GC001158")
for op in (
(key, "W", None, "W입력", "유효다짐폭 직접", "규격", "m", None),
(key, "V", None, "V입력", "다짐속도 직접", "다짐층", "㎞/hr", None),
)
],
("GC001160", "결과", None, "Q입력", "생산능력 직접", "혼합재", "ton/hr", None),
("GC001162", "결과", None, "Q입력", "생산능력 직접", "작업조건", "ton/hr", None),
(
"GC001163",
"결과",
"찾기(CC000375, 출구간격=출구간격, 규격=규격).생산능력",
"q입력",
"생산능력 직접",
"출구간격",
"ton/hr",
None,
), # fmt: skip
("GC001163", "효율", None, "E효율입력", "효율 직접", "작업조건", "%", None),
(
"GC001164",
"결과",
"찾기(CC000383, 규격=규격, 출구간격=출구간격).생산능력",
"q입력",
"생산능력 직접",
"출구간격",
"ton/hr",
None,
), # fmt: skip
("GC001164", "E", None, "E입력", "작업효율 직접", "작업조건", "", EFF),
(
"GC001165",
"통과능력",
None,
"q통과입력",
"통과능력 직접",
"조합방법",
"ton/hr",
None,
), # fmt: skip
("GC001165", "A", None, "A입력", "택수 계수(A) 직접", "택의수", "", None),
("GC001165", "B", None, "B입력", "작은 골재량 계수(B) 직접", "B골재량", "", None),
("GC001165", "C", None, "C입력", "스크린 규격 계수(C) 직접", "C규격", "", None),
("GC001165", "D", None, "D입력", "큰 골재량 계수(D) 직접", "D골재량", "", None),
("GC001165", "E", None, "E입력", "재료 계수(E) 직접", "재료", "", None),
("GC001168", "결과", None, "Q입력", "작업량 직접", "구분", "㎡/h", None),
("GC001171", "q", None, "q입력", "실용량 직접", "슬럼프", "㎥", None),
("GC001171", "cm", None, "cm입력", "싸이클시간 직접", "싸이클", "분", None),
("GC001173", "W", None, "W입력", "적재용량 직접", "규격", "㎥", None),
("GC001174", "n", None, "n입력", "대차수 직접", "기관차", "대", None),
("GC001174", "t2", None, "t2입력", "적재적하시간 직접", "재료", "분", None),
("GC001175", "t", None, "t입력", "적재적하시간 직접", "종류", "분", None),
("GC001175", "V1", None, "V1입력", "적재시 속도 직접", "작업로", "m/분", None),
("GC001175", "V2", None, "V2입력", "공차시 속도 직접", "V1입력", "m/분", None),
("GC001176", "β", None, "β입력", "해머계수 직접", "해머", "", None),
("GC001176", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
("GC001176", "F", None, "F입력", "작업계수 직접", "현장", "", None),
("GC001176", "tw", None, "tw입력", "용접시간 직접", "관두께", "분", None),
("GC001177", "β", None, "β입력", "해머계수 직접", "해머", "", None),
("GC001177", "Te", None, "Te입력", "기타시간 직접", "β입력", "분", None),
(
"GC001177",
"Ts",
"만약(파일경 <= 300, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 250·300㎜').값, 찾기(CC000410, 항목='세우기 및 위치조정 — 콘크리트 파일 350∼500㎜').값)",
"Ts입력",
"세우기·위치조정 시간 직접",
"파일경",
"분/회",
None,
), # fmt: skip
("GC001177", "F", None, "F입력", "작업계수 직접", "현장", "", None),
("GC001178", "β", None, "β입력", "판두께계수 직접", "판두께", "", None),
("GC001178", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
("GC001179", "Ta", None, "Ta입력", "시공시간 직접", "파일경", "분/본", None),
("GC001180", "Ts", None, "Ts입력", "준비시간 직접", "작업", "분", None),
(
"GC001180",
"F",
"찾기(CC000423, 작업=작업).F0",
"F0입력",
"작업계수 F0 직접",
"Ts입력",
"",
None,
), # fmt: skip
("GC001180", "k", None, "k입력", "해머계수 직접", "파일", "", None),
("GC001180", "r1", None, "r1입력", "사질토 단위시간 직접", "사질N", "분/m", None),
("GC001180", "r2", None, "r2입력", "점질토 단위시간 직접", "점질N", "분/m", None),
("GC001181", "α", None, "α입력", "α 직접", "해머", "", None),
("GC001181", "K", None, "K입력", "K 직접", "α입력", "", None),
("GC001181", "γ", None, "γ입력", "γ 직접", "작업", "", None),
(
"GC001181",
"F",
"찾기(CC000430, 작업='항타').F0",
"F0입력",
"작업계수 F0 직접",
"γ입력",
"",
None,
), # fmt: skip
("GC001181", "F인발", "찾기(CC000430, 작업='항발').F0", "F0입력", "", "", "", None), # 같은 칸
(
"GC001186",
"E",
"찾기(CC000466, 구분=E1).E",
"E1입력",
"흙의 두께 효율 직접",
"E1",
"",
None,
), # fmt: skip
(
"GC001186",
"E",
"찾기(CC000468, 구분=E2).E",
"E2입력",
"평면형상 효율 직접",
"E2",
"",
None,
), # fmt: skip
(
"GC001186",
"E",
"찾기(CC000470, 구분=E3).E",
"E3입력",
"단면형상 효율 직접",
"E3",
"",
None,
), # fmt: skip
(
"GC001186",
"E",
"찾기(CC000472, 구분=E4).E",
"E4입력",
"해상조건 효율 직접",
"E4",
"",
None,
), # fmt: skip
(
"GC001187",
"cm",
"찾기(CC000476, 버킷용량=버킷용량).싸이클시간",
"싸이클입력",
"기준 싸이클시간 직접",
"버킷용량",
"sec",
None,
), # fmt: skip
(
"GC001187",
"E",
"찾기(CC000477, 구분=E1).E",
"E1입력",
"흙의 두께 효율 직접",
"E1",
"",
EFF,
), # fmt: skip
(
"GC001187",
"E",
"찾기(CC000479, 구분=E2).E",
"E2입력",
"해상조건 효율 직접",
"E2",
"",
EFF,
), # fmt: skip
("GC001188", "S", None, "S입력", "쇄암면적 직접", "중추중량", "㎡", None),
("GC001188", "n", None, "n입력", "낙추횟수 직접", "S입력", "회", None),
(
"GC001189",
"결과",
"찾기(CC000486, 규격=규격).K",
"K입력",
"능력계수 직접",
"규격",
"",
None,
), # fmt: skip
(
"GC001189",
"결과",
"찾기(CC000487, 스크린=스크린).S",
"S입력",
"스크린계수 직접",
"스크린",
"",
None,
), # fmt: skip
(
"GC001189",
"결과",
"찾기(CC000488, 작업조건=작업조건).E",
"E입력",
"작업효율 직접",
"작업조건",
"",
None,
), # fmt: skip
("GC001190", "q", None, "q입력", "준설량 직접", "배송거리", "㎥/hr", None),
("GC001190", "E", None, "E입력", "작업효율 직접", "유속", "", EFF),
("GF000148", "f", None, "f입력", "체적환산계수 직접", "재료", "", None),
("GF000148", "E", None, "E입력", "작업효율 직접", "f입력", "", EFF),
]
# 지금 「0 = 표」 직접 칸 — 보이는 이름만(열쇠 · 기호 그대로)
RENAME = {
"E입력": "작업효율 직접",
"싸이클입력": "싸이클시간 직접",
"K입력": "버킷계수 직접",
"α입력": "토질계수 직접",
"f입력": "체적환산계수 직접",
"k입력": "버킷계수 직접",
"하역시간입력": "하역시간 직접",
"대기시간입력": "대기시간 직접",
"배출시간입력": "배출시간 직접",
"적재시간입력": "적재시간 직접",
}
RENAME_ROW = {("GC001186", "q입력"): "준설능력 직접"}
ROAD = "찾기(CC000054, 도로상태={road}).{col}"
def _load(name: str) -> tuple[str, dict]:
text = (MASTER / name).read_text(encoding="utf-8")
return text, json.loads(text, parse_float=Decimal, parse_int=Decimal)
def _save(name: str, text: str, before: dict, after: dict) -> None:
from M01_MasterData import M01_MasterData_Store_Shape as shape
out = shape.keep_shape(text, before, after, "줄") or shape.dump(after)
assert json.loads(out, parse_float=Decimal, parse_int=Decimal) == after
(MASTER / name).write_text(out, encoding="utf-8", newline="\n")
def _guard(key: str, body: str) -> str:
return f"만약({key} > 0, {key}, {body})"
def _is_guard(row: dict, name: str) -> bool:
return any(re.search(rf"만약\({re.escape(name)} > 0, {re.escape(name)}, ", s["식"]) for s in row.get("중간") or []) # fmt: skip
def _add_input(row: dict, spec: dict, after: str) -> None:
ins = row["입력"]
at = next(i for i, x in enumerate(ins) if x["이름"] == after)
ins.insert(at + 1, spec)
if isinstance(row.get("시험입력"), dict):
row["시험입력"][spec["이름"]] = spec.pop("_시험", Decimal(0))
spec.pop("_시험", None)
def _table(row: dict, key: str, name: str, pick: bool = False) -> None:
"""변수표 — 기호 · 아래 = 이름 규칙(`master_symbol.rule` · 같은 열쇠 = 같은 기호) · 이름 = 보이는 이름."""
import master_symbol as msym
sign, sub = msym.rule(key, "변수", "고름" if pick else "")[:2]
row.setdefault("변수표", {})[key] = {"기호": sign, "아래": sub, "이름": name}
def apply_op(row: dict, op: tuple) -> None:
_, step, sub, key, name, after, unit, rng = op
target = row["결과"] if step == "결과" else next(s for s in row["중간"] if s["이름"] == step)
text = target["식"]
if sub is None:
target["식"] = _guard(key, text)
else:
assert sub in text, (row["키"], step, sub)
target["식"] = text.replace(sub, _guard(key, sub))
if not name: # 같은 칸을 둘째 줄에도
return
assert key not in {x["이름"] for x in row["입력"]} | {x["이름"] for x in row.get("중간") or []}, key # fmt: skip
spec = {
"이름": key,
"설명": f"{name.removesuffix(' 직접')} — 직접 넣을 때 · 0 이면 고르기(표) 값",
}
if unit:
spec["단위"] = unit
if rng:
spec["범위"] = [Decimal(str(x)) for x in rng]
spec["출처"] = row.get("출처") or ""
_add_input(row, spec, after)
_table(row, key, name)
def rename(row: dict, docs: dict) -> int:
"""지금 직접 칸 보이는 이름 — 기호 · 아래는 지금 수식 문서 그대로 옮겨 적음."""
n = 0
doc = docs.get(str(row["키"])) or {}
for spec in row.get("입력") or []:
key = spec["이름"]
name = RENAME_ROW.get((row["키"], key)) or RENAME.get(key)
if not name or not (_is_guard(row, key) or key == "적재시간입력"):
continue
now = next((v for v in doc.get("변수") or [] if v.get("열쇠") == key), None)
assert now, (row["키"], key)
look = row.setdefault("변수표", {}).setdefault(key, {})
look |= {"기호": now["기호"], "아래": now.get("아래") or "", "이름": name}
if now.get("위"):
look["위"] = now["위"]
n += 1
return n
def dump(row: dict) -> None:
"""덤프 t2 = 구간 셋 · 속도 직접 · t2 ~ t5 직접."""
mids = row["중간"]
names = [m["이름"] for m in mids]
assert "V1" not in names
road = next(i for i in row["입력"] if i["이름"] == "도로상태")
base_road = row["시험입력"]["도로상태"]
speeds = []
after = "도로상태"
for n in (1, 2, 3):
dist, rd = ("운반거리", "도로상태") if n == 1 else (f"구간{n}거리", f"구간{n}도로상태")
tag = "" if n == 1 else f" {n}"
if n > 1:
_add_input(row, {"이름": dist, "설명": f"운반 구간 {n} 거리(편도) — 0 이면 안 씀", "단위": "㎞", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
_table(row, dist, f"운반거리{tag}")
_add_input(row, {"이름": rd, "설명": f"운반 구간 {n} 도로 상태", "고르기": list(road["고르기"]), "출처": "건설품셈 공통 8-2-8 3", "_시험": base_road}, dist) # fmt: skip
_table(row, rd, f"도로상태{tag}", pick=True)
after = rd
for k, col, what in ((2 * n - 1, "적재", "적재속도"), (2 * n, "공차", "공차속도")):
key = f"V{k}입력"
_add_input(row, {"이름": key, "설명": f"구간 {n} {col}시 평균주행속도를 직접 넣을 때(측정값 · 3 [주]) — 0 이면 도로상태 표", "단위": "㎞/hr", "출처": "건설품셈 공통 8-2-8 3"}, after) # fmt: skip
_table(row, key, f"{what}{tag} 직접")
after = key
speeds.append({"이름": f"V{k}", "식": _guard(key, ROAD.format(road=rd, col=col)), "단위": "㎞/hr"}) # fmt: skip
row["변수표"][f"V{k}"] = {"기호": "V", "아래": str(k), "이름": f"{col}시 평균주행속도{tag}"} # fmt: skip
_add_input(row, {"이름": "t2입력", "설명": "왕복시간(t2)을 직접 넣을 때 — 0 이면 구간 거리 · 속도로 셈", "단위": "분", "출처": "건설품셈 공통 8-2-8 2"}, after) # fmt: skip
_table(row, "t2입력", "왕복시간(t2) 직접")
legs = ["운반거리 / V1 * 60 + 운반거리 / V2 * 60"] + [
f"만약(구간{n}거리 > 0, 구간{n}거리 / V{2 * n - 1} * 60 + 구간{n}거리 / V{2 * n} * 60, 0)" for n in (2, 3)
] # fmt: skip
t2 = next(m for m in mids if m["이름"] == "t2")
t2["식"] = _guard("t2입력", " + ".join(legs))
at = names.index("t2")
mids[at:at] = speeds
for step, key, name, after_ in (
("t3", "t3입력", "적하시간(t3) 직접", "적하조건"),
("t4", "t4입력", "진입시간(t4) 직접", "적재장소"),
("t5", "t5입력", "덮개시간(t5) 직접", "덮개"),
):
apply_op(row, (DUMP, step, None, key, name, after_, "분", None))
row["비고"] = (
str(row["비고"])
+ " · t2 = 구간 셋(구간 2 · 3 거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표"
)
def _call_fill(text: str, key: str, extra: str) -> str:
pat = re.compile(rf"로직\({key},([^()]*(?:\([^()]*\)[^()]*)*)\)")
return pat.sub(lambda m: f"로직({key},{m[1]}{extra})", text)
def main() -> None:
import master_doc_link as ml
docs = ml.load_all()
text, before = _load(C08)
after = copy.deepcopy(before)
rows = {str(r["키"]): r for r in after["줄"]}
if any(m["이름"] == "V1" for m in rows[DUMP]["중간"]):
print("이미 돌림 — 멈춤")
return
renamed = sum(rename(r, docs) for r in rows.values() if (r.get("부품") or {}).get("갈래") == "작업량 틀") # fmt: skip
added: dict[str, list[str]] = {}
for op in OPS:
if op[0] in rows:
apply_op(rows[op[0]], op)
if op[4]:
added.setdefault(op[0], []).append(op[3])
dump(rows[DUMP])
for k, keys in added.items():
rows[k]["비고"] = (
str(rows[k].get("비고") or "") + f" · 직접 칸 {' · '.join(keys)} 0 = 표(851-1)"
)
_save(C08, text, before, after)
print("08장 — 이름만", renamed, "· 직접 칸", sum(map(len, added.values())), "식", len(added))
text, before = _load(F10)
after = copy.deepcopy(before)
rows = {str(r["키"]): r for r in after["줄"]}
for op in OPS:
if op[0] in rows:
apply_op(rows[op[0]], op)
_save(F10, text, before, after)
print("10장 — GF000148 직접 칸 f입력 · E입력")
road = "'교차가 힘든 산간지도로 및 제방 등의 도로'"
dump_extra = (
", V1입력=0, V2입력=0, 구간2거리=0, 구간2도로상태=__R__, V3입력=0, V4입력=0, 구간3거리=0, 구간3도로상태=__R__,"
" V5입력=0, V6입력=0, t2입력=0, t3입력=0, t4입력=0, t5입력=0"
)
extra = {k: "".join(f", {x}=0" for x in keys) for k, keys in added.items()}
extra |= {"GF000148": ", f입력=0, E입력=0", DUMP: dump_extra}
for name in sorted(p.name for p in MASTER.glob("로직_*.json")):
text, before = _load(name)
raw = json.dumps(before, ensure_ascii=False, default=str)
hits = [k for k in extra if f"로직({k}," in raw or f"로직({k})" in raw]
if not hits:
continue
after = copy.deepcopy(before)
def walk(x):
if isinstance(x, dict):
for k, v in x.items():
if isinstance(v, str):
for key in hits:
first = extra[key].split("=")[0].lstrip(", ")
if f"로직({key}" in v and f"{first}=" not in v:
assert f"로직({key})" not in v, (
name,
key,
) # 입력 없는 부름 — 손으로
m = re.search(r"도로상태=('[^']*'|[^,()]+)", v)
v = _call_fill(
v, key, extra[key].replace("__R__", m[1] if m else road)
)
x[k] = v
else:
walk(v)
elif isinstance(x, list):
for v in x:
walk(v)
walk(after)
_save(name, text, before, after)
print("부름 새 입력 0 —", name, " · ".join(hits))
if __name__ == "__main__":
main()
File diff suppressed because it is too large Load Diff
@@ -683,12 +683,16 @@
"개정": [2026],
"소유": "공용",
"비고": "해석: 파쇄암·발파암의 E 는 「암석」 줄",
"입력": [{ "이름": "재료", "고르기": ["토사", "파쇄암", "발파암"] }],
"입력": [
{ "이름": "재료", "고르기": ["토사", "파쇄암", "발파암"] },
{ "이름": "f입력", "설명": "체적환산계수 — 직접 넣을 때 · 0 이면 고르기(표) 값", "출처": "산림품셈 10-11 주②" },
{ "이름": "E입력", "설명": "작업효율 — 직접 넣을 때 · 0 이면 고르기(표) 값", "범위": [0, 1], "출처": "산림품셈 10-11 주②" }
],
"중간": [
{ "이름": "q", "식": "찾기(QF000335, 구분='q0').값 * 찾기(QF000335, 구분='e').값", "출처": "산림품셈 10-11 주② 「q=3.2×e」" },
{ "이름": "f", "식": "찾기(QF000335, 구분='f', 세부=재료).식" },
{ "이름": "f", "식": "만약(f입력 > 0, f입력, 찾기(QF000335, 구분='f', 세부=재료).식)" },
{ "이름": "E세부", "식": "만약(재료 == '토사', '토사', '암석')" },
{ "이름": "E", "식": "찾기(QF000335, 구분='E', 세부=E세부).값" },
{ "이름": "E", "식": "만약(E입력 > 0, E입력, 찾기(QF000335, 구분='E', 세부=E세부).값)" },
{
"이름": "Cm",
"식": "찾기(QF000335, 구분='L').값 / 찾기(QF000335, 구분='V1').값 + 찾기(QF000335, 구분='L').값 / 찾기(QF000335, 구분='V2').값 + 찾기(QF000335, 구분='t').값",
@@ -697,7 +701,15 @@
],
"결과": { "식": "반올림(60 * q * f * E / Cm, 3)", "출처": "건설품셈 공통 8-1-4 주①" },
"끝수": "소수 3자리 사사오입(건설품셈 공통 8-1-4 주①)",
"변수표": { "f": { "이름": "체적환산계수" }, "E": { "이름": "작업효율" }, "Cm": { "이름": "1회 싸이클시간" }, "재료": { "기호": "S", "아래": "재료" }, "E세부": { "기호": "E", "아래": "세부" } }
"변수표": {
"f": { "이름": "체적환산계수" },
"E": { "이름": "작업효율" },
"Cm": { "이름": "1회 싸이클시간" },
"재료": { "기호": "S", "아래": "재료" },
"E세부": { "기호": "E", "아래": "세부" },
"f입력": { "기호": "f", "아래": "입력", "이름": "체적환산계수 직접" },
"E입력": { "기호": "E", "아래": "입력", "이름": "작업효율 직접" }
}
},
{
"키": "GF000149",
@@ -719,7 +731,7 @@
"출처": "건설품셈 공통 8-1-7 5"
}
],
"중간": [{ "이름": "작업량", "식": "로직(GF000148, 재료=재료)" }, { "이름": "보정작업", "식": "만약(재료 == '토사', '해당 없음', '암석작업(연암・보통암・경암)')", "출처": "건설품셈 공통 8-1-7 1" }],
"중간": [{ "이름": "작업량", "식": "로직(GF000148, 재료=재료, f입력=0, E입력=0)" }, { "이름": "보정작업", "식": "만약(재료 == '토사', '해당 없음', '암석작업(연암・보통암・경암)')", "출처": "건설품셈 공통 8-1-7 1" }],
"호표": [{ "종류": "로직", "요소": "로직(GC000269, 기계=기계, 지역=지역, 보정작업=보정작업)", "이름": "불도저(무한궤도)", "단위": "시간", "수량": "1 / 작업량" }],
"덧줄": [],
"끝수": null,
+1 -1
View File
@@ -61,7 +61,7 @@
{ "이름": "덤프T", "식": "만약(덤프 == '0602-0045', 4.5, 만약(덤프 == '0602-0060', 6, 만약(덤프 == '0602-0080', 8, 2.5)))", "단위": "ton" },
{
"이름": "Q2",
"식": "로직(GC001155, 적재용량=덤프T, 단위중량=쌓기무게, 체적변화율=1, f=1, 운반거리=운반거리, 도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', 적하토질='모래, 역, 호박돌', 적하조건=적하조건, 적재장소='적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때', 덮개='해당 없음', 세륜='안 함', 적재방법='적재기계', 적재싸이클=cm, 적재버킷=q, 버킷계수=K, 적재효율=E, 인력종류='석재류', 적재시간입력=0, E입력=0)",
"식": "로직(GC001155, 적재용량=덤프T, 단위중량=쌓기무게, 체적변화율=1, f=1, 운반거리=운반거리, 도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', 적하토질='모래, 역, 호박돌', 적하조건=적하조건, 적재장소='적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때', 덮개='해당 없음', 세륜='안 함', 적재방법='적재기계', 적재싸이클=cm, 적재버킷=q, 버킷계수=K, 적재효율=E, 인력종류='석재류', 적재시간입력=0, E입력=0, V1입력=0, V2입력=0, 구간2거리=0, 구간2도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', V3입력=0, V4입력=0, 구간3거리=0, 구간3도로상태='교차가 힘든 산간지도로 및 제방 등의 도로', V5입력=0, V6입력=0, t2입력=0, t3입력=0, t4입력=0, t5입력=0)",
"단위": "㎡/hr",
"출처": "건설품셈 공통 8-2-8"
}
File diff suppressed because it is too large Load Diff
@@ -611,14 +611,18 @@
"결과": "Q",
"변수": [
{"열쇠": "재료", "기호": "S", "아래": "재료", "위": "", "이름": "재료", "단위": "", "연결": {"갈래": "선택", "목록": ["토사", "파쇄암", "발파암"], "값": "토사"}},
{"열쇠": "f입력", "기호": "f", "아래": "입력", "위": "", "이름": "체적환산계수 직접", "단위": "", "설명": "체적환산계수 — 직접 넣을 때 · 0 이면 고르기(표) 값", "출처": "산림품셈 10-11 주②", "연결": {"갈래": "입력", "값": 0}},
{"열쇠": "E입력", "기호": "E", "아래": "입력", "위": "", "이름": "작업효율 직접", "단위": "", "설명": "작업효율 — 직접 넣을 때 · 0 이면 고르기(표) 값", "출처": "산림품셈 10-11 주②", "연결": {"갈래": "입력", "값": 0, "범위": [0, 1]}},
{"열쇠": "q", "기호": "q", "아래": "", "위": "", "이름": "q", "단위": "㎥", "출처": "산림품셈 10-11 주② 「q=3.2×e」", "연결": {"갈래": "식"}},
{"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'f'", "세부": "S_재료"}, "칸": "식"}},
{"열쇠": "f", "기호": "f", "아래": "", "위": "", "이름": "체적환산계수", "단위": "", "연결": {"갈래": "식"}},
{"열쇠": "E세부", "기호": "E", "아래": "세부", "위": "", "이름": "E세부", "단위": "", "연결": {"갈래": "식"}},
{"열쇠": "E", "기호": "E", "아래": "", "위": "", "이름": "작업효율", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'E'", "세부": "E_세부"}, "칸": "값"}},
{"열쇠": "E", "기호": "E", "아래": "", "위": "", "이름": "작업효율", "단위": "", "연결": {"갈래": "식"}},
{"열쇠": "Cm", "기호": "Cm", "아래": "", "위": "", "이름": "1회 싸이클시간", "단위": "분", "출처": "산림품셈 10-11 주② 「㎝=L/V1+L/V2+0.25」", "연결": {"갈래": "식"}},
{"열쇠": "결과", "기호": "Q", "아래": "", "위": "", "이름": "결과", "단위": "㎥/hr", "연결": {"갈래": "식"}},
{"열쇠": "q0^표", "기호": "q0", "아래": "", "위": "표", "이름": "불도저 운반 q0", "단위": "㎥", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'q0'"}, "칸": "값"}},
{"열쇠": "e^표", "기호": "e", "아래": "", "위": "표", "이름": "불도저 운반 e", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'e'"}, "칸": "값"}},
{"열쇠": "Q_식^표", "기호": "Q", "아래": "식", "위": "표", "이름": "불도저 운반.식", "단위": "글", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'f'", "세부": "S_재료"}, "칸": "식"}},
{"열쇠": "Q_토사^표", "기호": "Q", "아래": "토사", "위": "표", "이름": "불도저 운반 토사", "단위": "", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'E'", "세부": "E_세부"}, "칸": "값"}},
{"열쇠": "L^표", "기호": "L", "아래": "", "위": "표", "이름": "불도저 운반 L", "단위": "m", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'L'"}, "칸": "값"}},
{"열쇠": "V1^표", "기호": "V1", "아래": "", "위": "표", "이름": "불도저 운반 V1", "단위": "m/분", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'V1'"}, "칸": "값"}},
{"열쇠": "V2^표", "기호": "V2", "아래": "", "위": "표", "이름": "불도저 운반 V2", "단위": "m/분", "연결": {"갈래": "표", "표": "QF000335", "조건": {"구분": "'V2'"}, "칸": "값"}},
@@ -626,7 +630,9 @@
],
"식": [
{"기호": "q", "식": "q0^표 × e^표"},
{"기호": "f", "식": "만약(f_입력 > 0, f_입력, Q_식^표)"},
{"기호": "E_세부", "식": "만약(S_재료 == '토사', '토사', '암석')"},
{"기호": "E", "식": "만약(E_입력 > 0, E_입력, Q_토사^표)"},
{"기호": "Cm", "식": "L^표 ÷ V1^표 + L^표 ÷ V2^표 + t^표"},
{"기호": "Q", "식": "반올림(60 × q × f × E ÷ Cm, 3)"}
],
@@ -648,7 +654,7 @@
{"열쇠": "재료", "기호": "S", "아래": "재료", "위": "", "이름": "재료", "단위": "", "연결": {"갈래": "선택", "목록": ["토사", "파쇄암", "발파암"], "값": "토사"}},
{"열쇠": "기계", "기호": "S", "아래": "기계", "위": "", "이름": "기계", "단위": "", "연결": {"갈래": "선택", "목록": ["0101-0007", "0101-0010", "0101-0012", "0101-0019", "0101-0032"], "값": "0101-0007"}},
{"열쇠": "지역", "기호": "S", "아래": "지역", "위": "", "이름": "지역", "단위": "", "출처": "건설품셈 공통 8-1-7 5", "연결": {"갈래": "선택", "목록": ["전국평균", "전국", "서울", "경기", "강원", "충북", "충남", "전북", "경북", "경남", "부산", "제주", "대구", "인천", "대전", "울산", "세종", "전남광주"], "값": "전국평균"}},
{"열쇠": "작업량", "기호": "Q", "아래": "작업", "위": "", "이름": "작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GF000148", "입력": {"재료": "S_재료"}}},
{"열쇠": "작업량", "기호": "Q", "아래": "작업", "위": "", "이름": "작업량", "단위": "㎥/hr", "연결": {"갈래": "단가산출", "키": "GF000148", "입력": {"재료": "S_재료", "f입력": "0", "E입력": "0"}}},
{"열쇠": "보정작업", "기호": "S", "아래": "보정작업", "위": "", "이름": "보정작업", "단위": "", "출처": "건설품셈 공통 8-1-7 1", "연결": {"갈래": "식"}},
{"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(8-1-7 손료 보정)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000269", "입력": {"기계": "S_기계", "지역": "S_지역", "보정작업": "S_보정작업"}}}
],
@@ -29,7 +29,7 @@
{"열쇠": "cm", "기호": "cm", "아래": "", "위": "", "이름": "1회 싸이클시간", "단위": "sec", "연결": {"갈래": "표", "표": "CC000045", "조건": {"규격": "S_규격구분", "각도": "θ_선회"}, "칸": "시간"}},
{"열쇠": "Q", "기호": "Q", "아래": "", "위": "", "이름": "시간당 작업량", "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-3", "연결": {"갈래": "단가산출", "키": "GC001147", "입력": {"버킷용량": "q", "규격구분": "S_규격구분", "선회각도": "θ_선회", "버킷조건": "'버킷에 넣기 어렵고 불규칙한 공극이 생기는 것으로서 발파 또는 리퍼작업 등에 의하여 얻어진 암과 파쇄암, 호박돌, 역 등인 경우'", "현장조건": "'흐트러진 상태'", "등급": "S_등급", "토질명": "'파쇄암'", "E보정": "'해당 없음'", "협소현장": "'해당 없음'", "f": "1", "E입력": "0", "싸이클입력": "0", "K입력": "0"}}},
{"열쇠": "덤프T", "기호": "Q", "아래": "덤프T", "위": "", "이름": "덤프T", "단위": "ton", "연결": {"갈래": "식"}},
{"열쇠": "Q2", "기호": "Q", "아래": "2", "위": "", "이름": "Q2", "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "단가산출", "키": "GC001155", "입력": {"적재용량": "Q_덤프T", "단위중량": "W_쌓기", "체적변화율": "1", "f": "1", "운반거리": "L_운반", "도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "적하토질": "'모래, 역, 호박돌'", "적하조건": "S_적하조건", "적재장소": "'적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때'", "덮개": "'해당 없음'", "세륜": "'안 함'", "적재방법": "'적재기계'", "적재싸이클": "cm", "적재버킷": "q", "버킷계수": "K", "적재효율": "E", "인력종류": "'석재류'", "적재시간입력": "0", "E입력": "0"}}},
{"열쇠": "Q2", "기호": "Q", "아래": "2", "위": "", "이름": "Q2", "단위": "㎡/hr", "출처": "건설품셈 공통 8-2-8", "연결": {"갈래": "단가산출", "키": "GC001155", "입력": {"적재용량": "Q_덤프T", "단위중량": "W_쌓기", "체적변화율": "1", "f": "1", "운반거리": "L_운반", "도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "적하토질": "'모래, 역, 호박돌'", "적하조건": "S_적하조건", "적재장소": "'적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때'", "덮개": "'해당 없음'", "세륜": "'안 함'", "적재방법": "'적재기계'", "적재싸이클": "cm", "적재버킷": "q", "버킷계수": "K", "적재효율": "E", "인력종류": "'석재류'", "적재시간입력": "0", "E입력": "0", "V1입력": "0", "V2입력": "0", "구간2거리": "0", "구간2도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "V3입력": "0", "V4입력": "0", "구간3거리": "0", "구간3도로상태": "'교차가 힘든 산간지도로 및 제방 등의 도로'", "V5입력": "0", "V6입력": "0", "t2입력": "0", "t3입력": "0", "t4입력": "0", "t5입력": "0"}}},
{"열쇠": "P_굴착기무한궤", "기호": "P", "아래": "굴착기무한궤", "위": "", "이름": "굴착기(무한궤도) 시간당 기계경비", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000267", "입력": {"기계": "S_굴착기", "지역": "S_지역", "보정작업": "S_보정작업"}}},
{"열쇠": "P_기계시간당", "기호": "P", "아래": "기계시간당", "위": "", "이름": "기계 시간당 기계경비(8-1-7 손료 보정)", "단위": "원/시간", "연결": {"갈래": "단가산출", "키": "GC000269", "입력": {"기계": "S_덤프", "지역": "S_지역", "보정작업": "S_보정작업"}}}
],
+30 -2
View File
@@ -94,6 +94,13 @@ BASE_DUMP = {
"인력종류": "토사류",
"적재시간입력": 0,
"E입력": 0,
# 851-1 — 구간 2 · 3(거리 0 = 안 씀) · 속도 · t2 ~ t5 직접 칸 0 = 표(옛 엔진은 입력을 다 받음)
**{f"V{n}입력": 0 for n in range(1, 7)},
**{f"t{n}입력": 0 for n in range(2, 6)},
"구간2거리": 0,
"구간2도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
"구간3거리": 0,
"구간3도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
}
@@ -178,10 +185,24 @@ def test_롤러_임목파쇄_브레이커(whole):
"E기계": "불도저",
"현장조건": "보통",
"E입력": 0,
"W입력": 0, # 851-1 직접 칸 0 = 표
"V입력": 0,
}
assert mf.run(whole, ROLL_A, roll)["결과"] == D("2280.000") # 북부청임도 단산27
assert (
mf.run(whole, CHIP, {"규격": "93.25㎾", "스크린": "75㎜", "작업조건": "보통"})["결과"] == 6
mf.run(
whole,
CHIP,
{
"규격": "93.25㎾",
"스크린": "75㎜",
"작업조건": "보통",
"K입력": 0,
"S입력": 0,
"E입력": 0,
},
)["결과"]
== 6
) # 동부청영월 111
# 북부청임도 단산75~78 — 엑셀 Q = 구조물 헐기 표 범위 평균치(적용방법 ②)
rows = {r["구분"]: r for r in whole.get("CC000065")["줄"]}
@@ -241,8 +262,15 @@ def test_가드_칸_자동값(whole):
value = got.get("결과", got.get("계"))
assert value >= 0, row["키"]
spec = {i["이름"]: i for i in row["입력"]}
direct = {
k
for k, v in (row.get("변수표") or {}).items()
if str(v.get("이름") or "").endswith(" 직접")
}
for name in GUARD.findall(" ".join(ma._texts(row))):
if "범위" in spec.get(name, {}):
if (
"범위" in spec.get(name, {}) or name in direct
): # 851-1 「○○ 직접」 = 표 밖 값도 받는 칸 · 견본 = 표
assert auto[name] == 0, (row["키"], name)
elif name in spec:
loose.add(name)
+6 -2
View File
@@ -132,8 +132,12 @@ def test_왼쪽_제어_구역_방식_변수_칸(gc88):
assert not any(t.strip().startswith("버킷용량") for t in day) # 일당 = 변수 칸 없음
assert "버킷용량 q=[1]㎥" in [t.strip() for t in hour]
assert "체적환산계수 f=[0.7]" in [t.strip() for t in hour]
e = next(t.strip() for t in hour if t.strip().startswith("E입력"))
assert e.startswith("E입력=[0.8]원래 값") # 고친 칸 = [원래 값] 단추(848-3 「고침」 글 → 테두리)
e = next(
t.strip() for t in hour if t.strip().startswith("작업효율 직접")
) # 851-1 E입력 보이는 이름
assert e.startswith(
"작업효율 직접=[0.8]원래 값"
) # 고친 칸 = [원래 값] 단추(848-3 「고침」 글 → 테두리)
@pytest.fixture(scope="module")
+256
View File
@@ -0,0 +1,256 @@
# -*- coding: utf-8 -*-
"""PLAN 851-1(요구 893) — 작업량 식 「○○ 직접」 칸 · 덤프트럭 운반 구간 여럿.
① 직접 칸 전수 — 작업량 틀 문서의 「직접」 칸마다: 고르기(표) 값과 같은 수를 넣으면 결과 같음 ·
다른 수를 넣으면 그 자리에 그 수를 박아 넣은 식과 같은 결과(그 수만큼) · 비우면(0) 지금 값
② 덤프트럭 8-2-8 손셈(원문 식) — 구간 하나(봉화 109 견본 Q 26.209) · 둘 · 셋(속도 직접) · t2 · t3 ~ t5 직접
③ 덤프 문서 화면 셈(TS) = 서버 셈 — 구간 셋 · 속도 직접
④ 지금 직접 칸(E입력 · 싸이클입력 · K입력 …) — 열쇠 그대로 · 보이는 이름 「○○ 직접」
"""
from __future__ import annotations
import copy
from decimal import ROUND_HALF_UP
from decimal import Decimal as D
import pytest
from M01_MasterData import M01_MasterData_Store as m01
from resources.tester import test_802_1_formula_doc as t1
md = t1.md
mc = t1.mc
ml = t1.ml
DUMP = "GC001155"
ROAD_HARD = "교차가 힘든 산간지도로 및 제방 등의 도로" # 원문 3 표 적재 10 · 공차 15
ROAD_WORK = "2차로 이상의 공사용도로" # 30 · 35
ROAD_EASY = "교차가 가능한 산간지도로 및 제방도로, 미포장도로" # 15 · 20
@pytest.fixture(scope="module")
def world():
docs = ml.load_all()
return docs, ml.Links(m01.loaded()[1], docs)
def _q(links, doc, given=None):
got = mc.calc(doc, links, given or {})
assert got["셈됨"], [m["글"] for m in got["표지"]]
return got
def _guard(doc: dict, xid: str) -> tuple[int, str, str]:
"""식 줄에서 「만약(X > 0, X, 안)」 → (줄 차례, 통째 글, 안 글)."""
head = f"만약({xid} > 0, {xid}, "
for i, line in enumerate(doc.get("식") or []):
text = str(line["식"])
at = text.find(head)
if at < 0:
continue
depth, end = 0, None
for j in range(at + len("만약"), len(text)):
depth += {"(": 1, ")": -1}.get(text[j], 0)
if depth == 0:
end = j
break
return i, text[at : end + 1], text[at + len(head) : end]
raise AssertionError(f"{doc['키']} {xid} 막이 없음")
def _directs(docs: dict) -> list[tuple[str, dict]]:
return [
(k, v)
for k, d in sorted(docs.items())
if (d.get("부품") or {}).get("갈래") == "작업량 틀"
for v in d.get("변수") or []
if str(v.get("이름") or "").endswith(" 직접")
and (v.get("연결") or {}).get("갈래") == "입력"
]
def _plain(v: D) -> str:
return mc.plain_text(v)
# ① 직접 칸 전수 ─────────────────────────────────────────────────────────
def test_직접칸_전수(world):
docs, links = world
rows = _directs(docs)
assert len({k for k, _ in rows}) >= 40 and len(rows) >= 120, len(rows)
moved, still = 0, []
for key, var in rows:
doc = docs[key]
xid = md.var_id(var)
assert (var["연결"].get("값") or 0) == 0, (key, xid) # 비운 기본 = 고르기 값
base = _q(links, doc)
q0 = base["결과"]
if var["열쇠"] == "적재시간입력": # 덤프 t1 — 적재방법 「직접 입력」 갈래(막이 아님)
t1_ = base["값"]["t_1"]
assert _q(links, doc, {"적재방법": "직접 입력", "적재시간입력": t1_})["결과"] == q0
moved += 1
continue
at, whole, inner = _guard(doc, xid)
line = doc["식"][at]
probe = copy.deepcopy(doc) # 고르기 값 = 그 줄을 막이 안 글로만 셈한 값
probe["식"][at]["식"] = inner
v0 = mc.calc(probe, links)["값"].get(line["기호"])
assert isinstance(v0, D), (key, xid, v0)
if v0 > 0:
assert _q(links, doc, {var["열쇠"]: v0})["결과"] == q0, (key, xid)
high = D(str((var["연결"].get("범위") or [0, None])[1] or 0))
v1 = v0 * D("1.25") if v0 > 0 else D(1)
if high and v1 > high:
v1 = v0 * D("0.8")
pinned = copy.deepcopy(doc)
pinned["식"][at]["식"] = str(line["식"]).replace(whole, f"({_plain(v1)})")
want = _q(links, pinned)["결과"]
got = _q(links, doc, {var["열쇠"]: v1})["결과"]
assert got == want, (key, xid, v1, got, want)
if got != q0:
moved += 1
else:
still.append(f"{key} {var['열쇠']}")
# 결과가 안 움직이는 것 = 기본 값에서 그 갈래를 안 탐(그레이더 왕복 작업 = 후진 속도 안 씀 · 덤프 구간 2 · 3 거리 0)
gated = {"GC001153 V2입력", "GC001154 V2입력", *(f"{DUMP} V{n}입력" for n in (3, 4, 5, 6))}
assert set(still) <= gated and moved == len(rows) - len(still), still
def test_직접칸_범위_밖_멈춤(world):
docs, links = world
got = mc.calc(docs["GC001164"], links, {"E입력": D("1.5")})
assert not got["셈됨"] and any("범위" in m["글"] for m in got["표지"])
# ② 덤프트럭 손셈 ─────────────────────────────────────────────────────────
def _r(v: D, n: int) -> D:
return v.quantize(D(1).scaleb(-n), rounding=ROUND_HALF_UP)
def _hand(legs, t3, t4, t5=D(0), t6=D(0), t2=None, *, T=D(15), rt=D("1.7"), L=D("1.175"), f=D("0.85"),
cms=D(20), qs=D("0.7"), k=D("0.7"), es=D("0.5"), E=D("0.9")): # fmt: skip
"""원문 8-2-8 — q = T/γt·L · n = q/(q·k) · t1 = cms·n/(60·Es) · t2 = Σ 거리/속도 × 60 · Q = 60·q·f·E/cm."""
q = T / rt * L
n = _r(q / (qs * k), 2)
t1 = cms * n / (60 * es)
if t2 is None:
t2 = sum((d / v1 * 60 + d / v2 * 60 for d, v1, v2 in legs), D(0))
cm = _r(t1 + t2 + t3 + t4 + t5 + t6, 3)
return _r(60 * q * f * E / cm, 3)
BONGHWA = { # STC 봉화 109 덤프 15톤(조사 889b B4 · 848-7 견본 Q 26.209)
"적재용량": D(15),
"단위중량": D("1.7"),
"체적변화율": D("1.175"),
"f": D("0.85"),
"운반거리": D("0.185"),
"도로상태": ROAD_HARD,
"적하토질": "점질토, 점토",
"적하조건": "불량",
"적재장소": "적재장소가 좁아서 목적장소에 진입하는데 불편을 느낄 때",
"덮개": "해당 없음",
"세륜": "안 함",
"적재방법": "적재기계",
"적재싸이클": D(20),
"적재버킷": D("0.7"),
"버킷계수": D("0.7"),
"적재효율": D("0.5"),
"E입력": D("0.9"),
}
CASES = [
("구간 하나", {}, dict(legs=[(D("0.185"), D(10), D(15))], t3=D("1.5"), t4=D("0.7"))),
(
"구간 둘",
{"구간2거리": D("0.5"), "구간2도로상태": ROAD_WORK},
dict(legs=[(D("0.185"), D(10), D(15)), (D("0.5"), D(30), D(35))], t3=D("1.5"), t4=D("0.7")),
),
(
"구간 셋 · 셋째 속도 직접",
{
"구간2거리": D("0.5"),
"구간2도로상태": ROAD_WORK,
"구간3거리": D("1.2"),
"구간3도로상태": ROAD_EASY,
"V5입력": D(22),
"V6입력": D(28),
},
dict(
legs=[(D("0.185"), D(10), D(15)), (D("0.5"), D(30), D(35)), (D("1.2"), D(22), D(28))],
t3=D("1.5"),
t4=D("0.7"),
),
), # fmt: skip
(
"구간 하나 속도 직접 · 둘째 도로상태",
{
"V1입력": D(12),
"V2입력": D(18),
"구간2거리": D("0.3"),
"구간2도로상태": ROAD_EASY,
"V4입력": D(25),
},
dict(legs=[(D("0.185"), D(12), D(18)), (D("0.3"), D(15), D(25))], t3=D("1.5"), t4=D("0.7")),
), # fmt: skip
("t2 직접", {"t2입력": D("3.35")}, dict(legs=[], t2=D("3.35"), t3=D("1.5"), t4=D("0.7"))),
(
"t3 · t4 · t5 직접(표 밖 0.9)",
{"t3입력": D("0.95"), "t4입력": D("0.9"), "t5입력": D("0.5")},
dict(legs=[(D("0.185"), D(10), D(15))], t3=D("0.95"), t4=D("0.9"), t5=D("0.5")),
),
]
@pytest.mark.parametrize(("label", "more", "hand"), CASES, ids=[c[0] for c in CASES])
def test_덤프_손셈(world, label, more, hand):
docs, links = world
got = _q(links, docs[DUMP], {**BONGHWA, **more})["결과"]
assert got == _hand(**hand), (label, got, _hand(**hand))
if label == "구간 하나":
assert got == D("26.209")
def test_덤프_구간_거리0_안탐(world):
"""구간 2 · 3 거리 0 = 그 구간 도로상태 · 속도 직접을 바꿔도 결과 같음(구간 하나 = 지금 값)."""
docs, links = world
one = _q(links, docs[DUMP], BONGHWA)["결과"]
other = {"구간2도로상태": ROAD_WORK, "V3입력": D(5), "구간3도로상태": ROAD_EASY, "V6입력": D(3)}
assert _q(links, docs[DUMP], {**BONGHWA, **other})["결과"] == one
# ③ 화면 셈(TS) = 서버 셈 ─────────────────────────────────────────────────
def test_덤프_TS_거울(world):
docs, links = world
rec = t1.Rec(links)
py, payload = {}, {}
for label, more, _ in CASES:
doc = copy.deepcopy(docs[DUMP])
given = {**BONGHWA, **more}
for v in doc["변수"]:
if v["열쇠"] in given:
v["연결"]["값"] = given[v["열쇠"]]
doc["키"] = f"{DUMP}:{label}"
py[doc["키"]] = mc.calc(doc, rec)["결과"]
payload[doc["키"]] = doc
out = t1._ts({"문서들": payload, "대상": list(payload), "기록": rec.log})
for k, want in py.items():
assert float(out["답"][k]["결과"]) == pytest.approx(float(want), abs=1e-9), k
# ④ 지금 직접 칸 — 열쇠 그대로 · 이름만 ─────────────────────────────────────
@pytest.mark.parametrize(
("key", "field", "name"),
[
("GC001147", "E입력", "작업효율 직접"),
("GC001147", "싸이클입력", "싸이클시간 직접"),
("GC001147", "K입력", "버킷계수 직접"),
("GC001176", "α입력", "토질계수 직접"),
("GC001187", "f입력", "체적환산계수 직접"),
("GC001186", "q입력", "준설능력 직접"),
("GC001155", "적재시간입력", "적재시간 직접"),
],
)
def test_지금_직접칸_이름(world, key, field, name):
docs, _ = world
var = next(v for v in docs[key]["변수"] if v["열쇠"] == field)
assert var["이름"] == name
@@ -0,0 +1,119 @@
# -*- coding: utf-8 -*-
"""PLAN 851-2(요구 893) — 가져온 값 층을 851-1 직접 칸으로 넓힘.
경쟁사 블록마다: 실은 값 = 경쟁사 식에 적힌 수 · 켜기 전(방식 없음) 금액 그대로 · 「시간당 식」 을 켜면
우리 식 Q = 경쟁사 Q(경쟁사 끝자리 안).
① 덤프 구간 둘 · 셋(봉화 118 · main 1442) · 같은 속도 왕복 × 2 꼴(임도용역 45 = 표 밖 속도 → 속도 직접) ·
t2 를 수로 적음(임도용역 50 = 왕복시간 직접)
② 불도저 · 로더 · 롤러(토량 · 면적) · 콘크리트 믹서
"""
from __future__ import annotations
import importlib
from decimal import Decimal as D
import pytest
from resources.tester import test_848_7_import_carry as t7
dim, car = t7.dim, t7.car
mw = importlib.import_module("master_doc_work")
def _carry(kind, tag, no):
sk, doc, ours = t7._block(kind, tag, no)
got, why = car.carried(doc)
return sk, doc, ours, got, why
def _on_q(doc, sk, got) -> dict:
"""시간당 식을 켠 줄마다 (우리 Q, 경쟁사 Q)."""
comp = {z[mw.WORK]["기호"]: z[mw.WORK]["값"] for z in dim.run(doc, sk)["줄"] if z.get(mw.WORK)}
on = {**doc, "기계덮음": {k: {mw.WORK: {"방식": "시간당"}} for k in got}}
out = {}
for z in dim.run(on, sk, upper=got)["줄"]:
w = z.get(mw.WORK) or {}
if w.get("기호") in got and not w.get(mw.FOLLOW):
assert w["꼴"] == "시간당", w
out[w["기호"]] = (w["값"], comp[w["기호"]])
return out
CASES = [
# (원천, 파일, 블록, 기호, 우리 식, 실린 값 일부)
(
"STC",
"봉화",
118,
"P_덤프트럭",
"GC001155",
{
"운반거리": 36.1,
"구간2거리": 1.7,
"구간2도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
},
), # fmt: skip
(
"EST",
"main",
1442,
"P_덤프트럭",
"GC001155",
{
"운반거리": 0.3,
"구간2거리": 16.7,
"구간3거리": 1.0,
"구간3도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
},
), # fmt: skip
(
"EST",
"임도용역",
45,
"P_덤프트럭",
"GC001155",
{"운반거리": 29.5, "V1입력": 30.0, "V2입력": 30.0},
), # fmt: skip
("EST", "임도용역", 50, "P_덤프트럭", "GC001155", {}),
("EST", "main", 46, "P_로우더", "GC001150", {}),
("EST", "main", 193, "P_진동로울러", "GC001157", {}),
(
"EST",
"main",
266,
"P_진동로울러",
"GC001158",
{"V입력": 1.0, "W입력": 0.8, "E입력": 0.6, "다짐횟수": 4.0},
), # fmt: skip
("EST", "main", 463, "P_콘크리트믹서", "GC001170", {}),
("STC", "동부청영월", 2032, "P_불도저", "GC001144", {}),
]
@pytest.mark.parametrize(("kind", "tag", "no", "sym", "form", "vals"), CASES, ids=[f"{c[1]}{c[2]}-{c[4]}" for c in CASES]) # fmt: skip
def test_실음_켜기전_그대로_켜면_Q_같음(kind, tag, no, sym, form, vals):
sk, doc, ours, got, why = _carry(kind, tag, no)
assert sym in got, why.get(sym)
w = got[sym][mw.WORK]
assert "방식" not in w and w["식"] == form
assert {k: w["변수"].get(k) for k in vals} == vals
for s in (sk, ours): # 방식 없는 위 층 = 금액 그대로
assert t7._money(dim.run(doc, s, upper=got)) == t7._money(dim.run(doc, s))
for k, (q, want) in _on_q(doc, sk, got).items():
assert abs(q - want) <= D("0.01"), (k, q, want)
def test_구간0_칸_안_채움_t2수_왕복시간_직접():
_, _, _, got, _ = _carry("EST", "임도용역", 45)
v = got["P_덤프트럭"][mw.WORK]["변수"]
assert not {"구간2거리", "구간3거리", "V3입력", "V5입력"} & set(v) # 거리 0 구간 = 칸 안 채움
_, _, _, got, _ = _carry("EST", "임도용역", 50)
v = got["P_덤프트럭"][mw.WORK]["변수"]
assert v.get("t2입력", 0) > 0 and "운반거리" not in v # t2 를 수로 적음 = 왕복시간 직접
def test_못_실음_끝수_까닭():
"""경쟁사 Cm 을 2 자리로 끊은 불도저 = 우리 식(3 자리) Q 끝자리 넘음 — 안 실음 · 까닭 남김."""
_, _, _, got, why = _carry("EST", "main", 62)
assert "P_불도우저" not in got and why["P_불도우저"].startswith("우리 식 Q")
+3 -1
View File
@@ -196,7 +196,9 @@ def test_굴착기_부착용_집게(whole):
def test_불도저_운반_작업량(whole):
"""10-11 — q=3.2×0.96 · ㎝=20/55+20/70+0.25 · Q=60×q×(1/1.30)×0.55/㎝."""
got = mf.run(whole, "GF000148", {"재료": "토사"})
got = mf.run(
whole, "GF000148", {"재료": "토사", "f입력": 0, "E입력": 0}
) # 851-1 직접 칸 0 = 표
assert got["결과"] == Decimal("86.709")