eomsangdon/Aislo
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

feat(782-3): 건설 공통 8-1-4 · 8-2 시공능력 기초 — 계수 표 146 · 로직 48 · 기계설비 13-2-7 로직 1

Browse Source 
- 계수_건설품셈_08장_건설기계.json 덧(CC000349~494): 8-2-2 ~ 8-2-33 절마다 원문 md 표 전부 + 표 밖 글 속 상수(산정식 상수) — 기존 표 글자 그대로 · 절 차례 자리에 끼움 · 범위 값 = [아래, 위] · 로직이 가운데를 집는 표(죠 크러셔 · 콘크리트 운반 상수)는 아래 · 위 두 칸
- 로직_건설품셈_08장_건설기계.json 덧(GC001143~1190): 8-1-4 기본식 · 8-2 시간당 작업량 · 1본당 시공시간 40 · 수중펌프 설치 해체 품 1 · 작업량당 기계경비 6(시간당 경비 × 1/Q — 굴착기 · 불도저 · 로더 · 덤프트럭 · 롤러 · 대형브레이커)
- 로직_건설품셈_13장_플랜트설비공사.json 덧(GC001191): 13-2-7 아세틸렌량의 환산
- 정함: 원문 범위 값 = 0 이면 가운데 기본 · 입력으로 바꿈 · 조건 = 고르기 · 짐작 값 없음 · 기존 브레이커 능력 표(CC000065 · 067)는 범위 한 칸이라 가운데 자동 안 됨 — 작업능력 입력
- 새 빌더 build_로직_건설품셈_08장_건설기계.py(+ _건설기계_읽기 · 표 · 표2 · 표3 · 로직 · 로직2 · 로직3 · 로직_플랜트 · 로직_준설 · 로직_경비) · 키 = master_keys.issue(adopt 는 로직을 받지 않음)
- 지킴 시험 test_782_3_capacity_82.py — 실무 엑셀 Q 재현 굴착기 12 · 덤프트럭 4 · 롤러 · 임목파쇄 0.5% 안 · 영덕계류 셋 = 엑셀이 0.6∼0.8㎥ 줄 싸이클 씀 · check_master
- check_master 전후 같음(틀 · 본문 · 로직 · 조합 0 · 단위 27 · 배 7) · 계산전부 1464 → 1513 멈춤 0 · 기존 로직 1464 셈 값 전후 같음

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
eomsangdon
2026-11-04 19:57:27 +09:00
co-authored by Claude Opus 5.5
parent 928bcecd49
commit d389bca29b
16 changed files with 20609 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
resources/master_data/_키대장.json
+196 -1
View File
@@ -1,5 +1,5 @@
{
"다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 335, "CC": 349, "GC": 1143, "QC": 2060, "GX": 4, "UA": 38},
"다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 335, "CC": 495, "GC": 1192, "QC": 2060, "GX": 4, "UA": 38},
"폐기": {"MT000001": "자재품목 휘발유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000002": "자재품목 경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000003": "자재품목 선박용경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000004": "자재품목 중유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000005": "자재품목 등유 — 값이 비고 글뿐 · 유가 테이블로 감", "LB000399": "이름 「〃」 — 직종이 아니라 되풀이 기호 · 소요량 13-6-9 에서 윗줄 직종으로 바로잡음", "MN": "재료_나라장터자재 — old 로 옮김 · 로직은 자재품목·품셈재료로 갈아 끼움", "LB000372": "미확보 고급기능사 — 측량노임 항공사진고급기능사 옛이름으로 옮김", "LB000393": "미확보 리베팅공 — 건설노임 철골공 옛이름으로 옮김(2010 통합표 연번10)", "LB000405": "미확보 Belt Conveyor 설치공 — 품셈 13-10-1 주② 배분으로 다섯 직종에 나눔", "MT000006": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "MT000007": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "LB000368": "미확보 기술사 — 기술사(건설) 옛이름으로 옮김", "LB000369": "미확보 특급기술자 — 특급기술자(건설) 옛이름으로 옮김", "LB000370": "미확보 고급기술자 — 고급기술자(건설) 옛이름으로 옮김", "LB000361": "미확보 중급기술자 — 중급기술자(건설) 옛이름으로 옮김", "LB000364": "미확보 초급기술자 — 초급기술자(건설) 옛이름으로 옮김", "LB000365": "미확보 고급숙련기술자 — 고급숙련기술자(건설) 옛이름으로 옮김", "LB000366": "미확보 중급숙련기술자 — 중급숙련기술자(건설) 옛이름으로 옮김", "LB000367": "미확보 초급숙련기술자 — 초급숙련기술자(건설) 옛이름으로 옮김", "LB000389": "미확보 기계기사 — 초급기술자(기계·설비) 옛이름으로 옮김", "LB000388": "미확보 기계산업기사 — 초급숙련기술자(기계·설비) 옛이름으로 옮김", "MO000055": {"원문번호": "주택용저압:기본_200이하", "파일": "재료_유가전력.json"}, "MO000056": {"원문번호": "주택용저압:기본_201~400", "파일": "재료_유가전력.json"}, "MO000057": {"원문번호": "주택용저압:기본_400초과", "파일": "재료_유가전력.json"}, "MO000059": {"원문번호": "주택용저압:전력량_다음200", "파일": "재료_유가전력.json"}, "MO000060": {"원문번호": "주택용저압:전력량_400초과", "파일": "재료_유가전력.json"}, "MO000061": {"원문번호": "주택용저압:월간최저요금", "파일": "재료_유가전력.json"}, "MO000062": {"원문번호": "일반용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000063": {"원문번호": "일반용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000064": {"원문번호": "일반용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000065": {"원문번호": "일반용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000066": {"원문번호": "산업용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000067": {"원문번호": "산업용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000068": {"원문번호": "산업용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000069": {"원문번호": "산업용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000070": {"원문번호": "임시전력갑:기본요금적용", "파일": "재료_유가전력.json"}, "MO000071": {"원문번호": "임시전력갑:전력량요금적용", "파일": "재료_유가전력.json"}, "MO000072": {"원문번호": "임시전력갑:월간최저요금", "파일": "재료_유가전력.json"}},
"키": {
"CC000001": {"원문번호": "공통 1-3-1 콘크리트 및 포장용 재료", "파일": "계수_건설품셈_01장_적용기준.json"},
@@ -350,6 +350,152 @@
"CC000346": {"원문번호": "공통 1-2-7 인력운반(기계설비) 준비작업시간", "파일": "계수_건설품셈_01장_적용기준.json"},
"CC000347": {"원문번호": "공통 1-2-7 경사지 운반 환산계수", "파일": "계수_건설품셈_01장_적용기준.json"},
"CC000348": {"원문번호": "공통 1-2-7 화물자동차 적재량", "파일": "계수_건설품셈_01장_적용기준.json"},
"CC000349": {"원문번호": "공통 8-2-2 An", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000350": {"원문번호": "공통 8-2-2 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000351": {"원문번호": "공통 8-2-2 탄성파", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000352": {"원문번호": "공통 8-2-2 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000353": {"원문번호": "공통 8-2-4 d", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000354": {"원문번호": "공통 8-2-4 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000355": {"원문번호": "공통 8-2-4 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000356": {"원문번호": "공통 8-2-6 K", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000357": {"원문번호": "공통 8-2-6 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000358": {"원문번호": "공통 8-2-6 V", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000359": {"원문번호": "공통 8-2-6 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000360": {"원문번호": "공통 8-2-7 V", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000361": {"원문번호": "공통 8-2-7 t", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000362": {"원문번호": "공통 8-2-7 l", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000363": {"원문번호": "공통 8-2-7 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000364": {"원문번호": "공통 8-2-10 생산능력", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000365": {"원문번호": "공통 8-2-10 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000366": {"원문번호": "공통 8-2-11 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000367": {"원문번호": "공통 8-2-11 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000368": {"원문번호": "공통 8-2-12 벨트", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000369": {"원문번호": "공통 8-2-12 피더", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000370": {"원문번호": "공통 8-2-12 죠", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000371": {"원문번호": "공통 8-2-12 별표1", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000372": {"원문번호": "공통 8-2-12 별표2", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000373": {"원문번호": "공통 8-2-12 별표3", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000374": {"원문번호": "공통 8-2-12 롤규격", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000375": {"원문번호": "공통 8-2-12 롤", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000376": {"원문번호": "공통 8-2-12 롤효율", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000377": {"원문번호": "공통 8-2-12 스크린", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000378": {"원문번호": "공통 8-2-12 계수A", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000379": {"원문번호": "공통 8-2-12 계수B", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000380": {"원문번호": "공통 8-2-12 계수C", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000381": {"원문번호": "공통 8-2-12 계수D", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000382": {"원문번호": "공통 8-2-12 계수E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000383": {"원문번호": "공통 8-2-12 이동식", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000384": {"원문번호": "공통 8-2-12 이동식규격", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000385": {"원문번호": "공통 8-2-12 이동식효율", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000386": {"원문번호": "공통 8-2-14 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000387": {"원문번호": "공통 8-2-16 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000388": {"원문번호": "공통 8-2-17 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000389": {"원문번호": "공통 8-2-18 q", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000390": {"원문번호": "공통 8-2-18 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000391": {"원문번호": "공통 8-2-18 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000392": {"원문번호": "공통 8-2-19 W", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000393": {"원문번호": "공통 8-2-19 주행", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000394": {"원문번호": "공통 8-2-19 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000395": {"원문번호": "공통 8-2-20 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000396": {"원문번호": "공통 8-2-22 α", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000397": {"원문번호": "공통 8-2-22 β강관", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000398": {"원문번호": "공통 8-2-22 N치", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000399": {"원문번호": "공통 8-2-22 Te강관", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000400": {"원문번호": "공통 8-2-22 F", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000401": {"원문번호": "공통 8-2-22 용접반자동", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000402": {"원문번호": "공통 8-2-22 용접수동", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000403": {"원문번호": "공통 8-2-22 용접기", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000404": {"원문번호": "공통 8-2-22 용접봉", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000405": {"원문번호": "공통 8-2-22 용접전력", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000406": {"원문번호": "공통 8-2-22 β콘크리트", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000407": {"원문번호": "공통 8-2-22 Te콘크리트", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000408": {"원문번호": "공통 8-2-22 크레인", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000409": {"원문번호": "공통 8-2-22 배치인원", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000410": {"원문번호": "공통 8-2-22 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000411": {"원문번호": "공통 8-2-23 α강관", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000412": {"원문번호": "공통 8-2-23 β", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000413": {"원문번호": "공통 8-2-23 Ta강관", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000414": {"원문번호": "공통 8-2-23 α콘크리트", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000415": {"원문번호": "공통 8-2-23 Ta콘크리트", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000416": {"원문번호": "공통 8-2-23 크레인", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000417": {"원문번호": "공통 8-2-23 배치인원", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000418": {"원문번호": "공통 8-2-23 제잡비율", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000419": {"원문번호": "공통 8-2-23 장비", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000420": {"원문번호": "공통 8-2-24 Ts", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000421": {"원문번호": "공통 8-2-24 r", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000422": {"원문번호": "공통 8-2-24 k", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000423": {"원문번호": "공통 8-2-24 F0", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000424": {"원문번호": "공통 8-2-24 f", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000425": {"원문번호": "공통 8-2-24 조합", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000426": {"원문번호": "공통 8-2-24 선정", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000427": {"원문번호": "공통 8-2-24 배치인원", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000428": {"원문번호": "공통 8-2-24 αK", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000429": {"원문번호": "공통 8-2-24 γ", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000430": {"원문번호": "공통 8-2-24 F0널", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000431": {"원문번호": "공통 8-2-24 f널", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000432": {"원문번호": "공통 8-2-24 조합널", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000433": {"원문번호": "공통 8-2-24 선정전동", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000434": {"원문번호": "공통 8-2-24 선정유압", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000435": {"원문번호": "공통 8-2-24 선정인발", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000436": {"원문번호": "공통 8-2-24 배치인원널", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000437": {"원문번호": "공통 8-2-24 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000438": {"원문번호": "공통 8-2-25 α", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000439": {"원문번호": "공통 8-2-25 F0", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000440": {"원문번호": "공통 8-2-25 f", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000441": {"원문번호": "공통 8-2-25 선정", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000442": {"원문번호": "공통 8-2-25 펌프", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000443": {"원문번호": "공통 8-2-25 조합", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000444": {"원문번호": "공통 8-2-25 수조", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000445": {"원문번호": "공통 8-2-25 배치인원", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000446": {"원문번호": "공통 8-2-25 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000447": {"원문번호": "공통 8-2-26 k", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000448": {"원문번호": "공통 8-2-26 f", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000449": {"원문번호": "공통 8-2-26 조합", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000450": {"원문번호": "공통 8-2-26 선정", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000451": {"원문번호": "공통 8-2-26 배치인원", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000452": {"원문번호": "공통 8-2-26 설치", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000453": {"원문번호": "공통 8-2-26 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000454": {"원문번호": "공통 8-2-27 선정", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000455": {"원문번호": "공통 8-2-27 운전공", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000456": {"원문번호": "공통 8-2-27 잡재료", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000457": {"원문번호": "공통 8-2-27 설치", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000458": {"원문번호": "공통 8-2-27 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000459": {"원문번호": "공통 8-2-28 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000460": {"원문번호": "공통 8-2-28 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000461": {"원문번호": "공통 8-2-29 q", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000462": {"원문번호": "공통 8-2-29 계제선", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000463": {"원문번호": "공통 8-2-29 한계", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000464": {"원문번호": "공통 8-2-29 산정예", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000465": {"원문번호": "공통 8-2-29 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000466": {"원문번호": "공통 8-2-29 E1", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000467": {"원문번호": "공통 8-2-29 E1해설", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000468": {"원문번호": "공통 8-2-29 E2", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000469": {"원문번호": "공통 8-2-29 E2해설", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000470": {"원문번호": "공통 8-2-29 E3", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000471": {"원문번호": "공통 8-2-29 E3해설", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000472": {"원문번호": "공통 8-2-29 E4", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000473": {"원문번호": "공통 8-2-29 E4해설", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000474": {"원문번호": "공통 8-2-30 f", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000475": {"원문번호": "공통 8-2-30 k", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000476": {"원문번호": "공통 8-2-30 cm", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000477": {"원문번호": "공통 8-2-30 E1", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000478": {"원문번호": "공통 8-2-30 E1해설", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000479": {"원문번호": "공통 8-2-30 E2", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000480": {"원문번호": "공통 8-2-30 E2해설", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000481": {"원문번호": "공통 8-2-30 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000482": {"원문번호": "공통 8-2-31 S", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000483": {"원문번호": "공통 8-2-31 n", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000484": {"원문번호": "공통 8-2-31 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000485": {"원문번호": "공통 8-2-32 소모93", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000486": {"원문번호": "공통 8-2-32 K", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000487": {"원문번호": "공통 8-2-32 S", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000488": {"원문번호": "공통 8-2-32 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000489": {"원문번호": "공통 8-2-32 소모354", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000490": {"원문번호": "공통 8-2-32 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000491": {"원문번호": "공통 8-2-33 q", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000492": {"원문번호": "공통 8-2-33 E", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000493": {"원문번호": "공통 8-2-33 배사관", "파일": "계수_건설품셈_08장_건설기계.json"},
"CC000494": {"원문번호": "공통 8-2-33 상수", "파일": "계수_건설품셈_08장_건설기계.json"},
"CF000001": {"원문번호": "1-1-3 일일 작업시간", "파일": "계수_산림품셈_01장_적용기준.json"},
"CF000002": {"원문번호": "1-2-1 소수 처리", "파일": "계수_산림품셈_01장_적용기준.json"},
"CF000003": {"원문번호": "1-2-1 총축적 계산 기준", "파일": "계수_산림품셈_01장_적용기준.json"},
@@ -2309,6 +2455,55 @@
"GC001140": {"원문번호": "공통 1-2-7 인력운반(지게)", "파일": "로직_건설품셈_01장_적용기준.json"},
"GC001141": {"원문번호": "공통 1-2-7 인력운반(기계설비)", "파일": "로직_건설품셈_01장_적용기준.json"},
"GC001142": {"원문번호": "공통 1-2-7 벽돌운반", "파일": "로직_건설품셈_01장_적용기준.json"},
"GC001143": {"원문번호": "공통 8-1-4 기본식", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001144": {"원문번호": "공통 8-2-1 불도저", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001145": {"원문번호": "공통 8-2-1 불도저경비", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001146": {"원문번호": "공통 8-2-2 리퍼", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001147": {"원문번호": "공통 8-2-3 굴착기", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001148": {"원문번호": "공통 8-2-3 굴착기경비", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001149": {"원문번호": "공통 8-2-4 트랜처", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001150": {"원문번호": "공통 8-2-5 로더", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001151": {"원문번호": "공통 8-2-5 로더경비", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001152": {"원문번호": "공통 8-2-6 스크레이퍼", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001153": {"원문번호": "공통 8-2-7 그레이더면적", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001154": {"원문번호": "공통 8-2-7 그레이더토량", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001155": {"원문번호": "공통 8-2-8 덤프트럭", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001156": {"원문번호": "공통 8-2-8 덤프트럭경비", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001157": {"원문번호": "공통 8-2-9 롤러토량", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001158": {"원문번호": "공통 8-2-9 롤러면적", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001159": {"원문번호": "공통 8-2-9 롤러경비", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001160": {"원문번호": "공통 8-2-10 아스팔트플랜트", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001161": {"원문번호": "공통 8-2-11 스테이빌라이저", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001162": {"원문번호": "공통 8-2-12 죠", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001163": {"원문번호": "공통 8-2-12 롤", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001164": {"원문번호": "공통 8-2-12 이동식", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001165": {"원문번호": "공통 8-2-12 스크린", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001166": {"원문번호": "공통 8-2-13 브레이커경비", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001167": {"원문번호": "공통 8-2-14 압쇄기", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001168": {"원문번호": "공통 8-2-15 법면다짐기", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001169": {"원문번호": "공통 8-2-16 골재세척", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001170": {"원문번호": "공통 8-2-17 믹서", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001171": {"원문번호": "공통 8-2-18 배치플랜트", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001172": {"원문번호": "공통 8-2-19 믹서트럭", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001173": {"원문번호": "공통 8-2-19 덤프", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001174": {"원문번호": "공통 8-2-20 기관차", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001175": {"원문번호": "공통 8-2-21 경운기", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001176": {"원문번호": "공통 8-2-22 강관", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001177": {"원문번호": "공통 8-2-22 콘크리트", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001178": {"원문번호": "공통 8-2-23 강관", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001179": {"원문번호": "공통 8-2-23 콘크리트", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001180": {"원문번호": "공통 8-2-24 H파일", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001181": {"원문번호": "공통 8-2-24 강널말뚝", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001182": {"원문번호": "공통 8-2-25 워터제트", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001183": {"원문번호": "공통 8-2-26 압입인발", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001184": {"원문번호": "공통 8-2-27 설치", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001185": {"원문번호": "공통 8-2-28 TBM", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001186": {"원문번호": "공통 8-2-29 펌프준설", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001187": {"원문번호": "공통 8-2-30 그래브", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001188": {"원문번호": "공통 8-2-31 쇄암선", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001189": {"원문번호": "공통 8-2-32 임목파쇄기", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001190": {"원문번호": "공통 8-2-33 골재채취선", "파일": "로직_건설품셈_08장_건설기계.json"},
"GC001191": {"원문번호": "기계설비 13-2-7 아세틸렌량의 환산", "파일": "로직_건설품셈_13장_플랜트설비공사.json"},
"GF000001": {"원문번호": "3-1 경계표시", "파일": "로직_산림품셈_03장_작업장_관리.json"},
"GF000002": {"원문번호": "3-3 작업로 설치", "파일": "로직_산림품셈_03장_작업장_관리.json"},
"GF000003": {"원문번호": "3-4-2 임산물 운반로 신설 작업량", "파일": "로직_산림품셈_03장_작업장_관리.json"},
resources/master_data/scripts/_건설기계_로직.py
+479
View File
@@ -0,0 +1,479 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-1-4 · 8-2-1 ~ 8-2-21 시공능력 로직 — 결과 = 시간당 작업량(원문 단위 그대로).
`build_로직_건설품셈_08장_건설기계.py` 가 부름. 식의 `{T:<절> <짧은 이름>}` = 새 계수 표 키 ·
`{L:<열쇠>}` = 새 로직 키 · `CC0000xx` = 이미 있는 8-2 계수 표. `C(표, 칸)` = 그 표 칸 값 목록(고르기).
정함(브레인) — 원문 범위 값은 가운데를 기본(0 = 자동) · 조건은 고르기 · 원문에 없는 짐작 값 없음.
"""
from __future__ import annotations
from decimal import Decimal as D
from _건설기계_읽기 import HEAD
LEVEL = ["양호", "보통", "불량"]
CUT = {"대상": "결과", "자리": 3, "방법": "반올림", "출처": "건설품셈 공통 8-1-4 주①"}
def inp(name, desc, unit=None, pick=None, src=None):
d = {"이름": name, "설명": desc}
if unit:
d["단위"] = unit
if pick is not None:
d["고르기"] = pick
if src:
d["출처"] = src
return d
def st(name, f, unit=None):
return {"이름": name, "식": f, **({"단위": unit} if unit else {})}
def look(t, field, **conds):
"""찾기 글 — 조건 값은 식 글 그대로(이름 · 「'글'」 · 수)."""
where = "".join(f", {k}={v}" for k, v in conds.items())
ref = t if t.startswith("CC") else "{T:" + t + "}"
return f"찾기({ref}{where}).{field}"
def c(t, item):
"""상수 표 값 — `c('8-2-4', '전진속도(V1)')`."""
return look(f"{t} 상수", "값", 항목=f"'{item}'")
def mid(t, item):
"""상수 표 범위 가운데 — (아래 + 위) / 2."""
return f"({look(f'{t} 상수', '아래', 항목=repr(item))} + {look(f'{t} 상수', '위', 항목=repr(item))}) / 2"
def e_in(no, desc="작업효율을 직접 넣을 때 — 0 이면 원문 표 값"):
return inp("E입력", desc, src=f"건설품셈 공통 {no}")
def auto(name, expr):
"""「0 = 자동」 수 입력 — 넣은 값이 이김."""
return f"만약({name} > 0, {name}, {expr})"
def logic(no, short, name, unit, inputs, steps, result, test, memo=None, cut=True, src=None):
row = {
"열쇠": f"공통 {no} {short}",
"원문번호": no,
**HEAD,
"이름": f"{name} — 건설 공통 {no}",
"결과단위": unit,
"출처": src or f"건설품셈 공통 {no}",
"소유": "공용",
}
if memo:
row["비고"] = memo
row["시험입력"] = test
row["입력"] = inputs
row["중간"] = steps
row["결과"] = {"식": result, "출처": src or f"건설품셈 공통 {no}"}
row["끝수"] = CUT if cut else None
return row
def soil_e(t, adj):
"""흙 작업 E — 자연상태 · 흐트러진 상태 × 양호 · 보통 · 불량 × 토질 표 − 보정(터파기 등)."""
base = look(t, "E", 현장조건="현장조건", 등급="등급", 토질명="토질명")
return base, f"만약(E보정 == '해당 없음', 0, {look(adj, '보정값', 항목='E보정')})"
def soil_inputs(no, C, t, adj, src):
return [
inp("현장조건", "흙 상태", pick=C(t, "현장조건"), src=f"건설품셈 공통 {no} {src}"),
inp("등급", "작업 조건 등급", pick=LEVEL, src=f"건설품셈 공통 {no} {src}"),
inp("토질명", "토질", pick=C(t, "토질명"), src=f"건설품셈 공통 {no} {src}"),
inp(
"E보정",
"작업효율에서 뺄 경우",
pick=["해당 없음", *C(adj, "항목")],
src=f"건설품셈 공통 {no} {src} 주",
),
]
F_IN = inp("f", "체적환산계수 — 토질 · 상태 변화율(건설 공통 1-2-3)", src="건설품셈 공통 8-1-4")
def part1(C) -> list[dict]:
out = []
# 8-1-4 기본식
out.append(
logic(
"8-1-4",
"기본식",
"시공능력 산정 기본식 Q = n·q·f·E",
"㎥/hr",
[
inp("싸이클시간", "1회 작업싸이클 시간(cm)", src="건설품셈 공통 8-1-4 주⑤"),
inp(
"시간단위", "싸이클시간 단위", pick=["분", "초"], src="건설품셈 공통 8-1-4 주⑤"
),
inp("작업량", "1회 작업싸이클당 표준작업량(q)", "㎥", src="건설품셈 공통 8-1-4"),
F_IN,
inp("E", "작업효율", src="건설품셈 공통 8-1-4 주⑥"),
],
[
st(
"n",
"반올림(만약(시간단위 == '분', 60, 3600) / 반올림(싸이클시간, 3), 2)",
"회/hr",
)
],
"n * 작업량 * f * E",
{"싸이클시간": 21, "시간단위": "초", "작업량": D("0.9"), "f": D("0.7"), "E": D("0.75")},
memo="n = 60/cm(분) 또는 3,600/cm(초) · 끝수 Q 3자리 · n 2자리 · cm 3자리(주①) · 단위는 원문대로 ㎥/hr 또는 ton/hr",
)
)
# 8-2-1 불도저
no = "8-2-1"
base, adj = soil_e("CC000037", "CC000038")
out.append(
logic(
no,
"불도저",
"불도저 시간당 작업량",
"㎥/hr",
[
inp(
"종별",
"불도저 종별",
pick=C("CC000035", "종별"),
src=f"건설품셈 공통 {no} 1 가",
),
inp(
"급수",
"불도저 급수(ton)",
pick=C("CC000035", "급수"),
src=f"건설품셈 공통 {no} 1 가",
),
inp("운반거리", "운반거리(L)", "m", src=f"건설품셈 공통 {no} 2"),
inp(
"거리구분",
"운반거리계수(e) 표의 거리 칸",
pick=C("CC000036", "운반거리"),
src=f"건설품셈 공통 {no} 1 나",
),
*soil_inputs(no, C, "CC000037", "CC000038", "1 다"),
inp("전진단", "전진 기어 단", pick=[1, 2, 3, 4], src=f"건설품셈 공통 {no} 2 주"),
inp("후진단", "후진 기어 단", pick=[1, 2, 3], src=f"건설품셈 공통 {no} 2 주"),
F_IN,
e_in(no),
],
[
st("q0", look("CC000035", "'q°'", 급수="급수", 종별="종별"), "㎥"),
st("e", look("CC000036", "e", 운반거리="거리구분")),
st("q", "q0 * e", "㎥"),
st("보정", adj),
st("E", auto("E입력", f"{base} - 보정")),
st("타이어규격", "만약(급수 == '15', 15, 만약(급수 == '28', 28, 33))", "ton"),
st(
"V1",
f"만약(종별 == '무한궤도', {look('CC000040', '속도', 규격='급수', 방향="'전진'", 단='전진단')}, "
f"{look('CC000041', '속도', 규격='타이어규격', 방향="'전진'", 단='전진단')})",
"m/분",
),
st(
"V2",
f"만약(종별 == '무한궤도', {look('CC000040', '속도', 규격='급수', 방향="'후진'", 단='후진단')}, "
f"{look('CC000041', '속도', 규격='타이어규격', 방향="'후진'", 단='후진단')})",
"m/분",
),
st("t", look("CC000039", "값", 항목="'기어 변속시간(t)'"), "분"),
st("cm", "반올림(운반거리 / V1 + 운반거리 / V2 + t, 3)", "분"),
],
"60 * q * f * E / cm",
{
"종별": "무한궤도",
"급수": "19",
"운반거리": 30,
"거리구분": "30",
"현장조건": "자연상태",
"등급": "보통",
"토질명": "모래, 사질토",
"E보정": "해당 없음",
"전진단": 1,
"후진단": 1,
"f": 1,
"E입력": 0,
},
memo="q = q° × e · cm = L/V1 + L/V2 + t · 타이어형 속도 표는 규격이 수(15 · 28 · 33)",
)
)
# 8-2-2 리퍼
no = "8-2-2"
out.append(
logic(
no,
"리퍼",
"리퍼(유압식) 시간당 파쇄량",
"㎥/hr",
[
inp(
"규격",
"트랙터 규격(ton)",
pick=C(f"{no} An", "규격"),
src=f"건설품셈 공통 {no} 1",
),
inp(
"발톱수",
"리퍼 발톱수",
pick=C(f"{no} An", "발톱수"),
src=f"건설품셈 공통 {no} 1",
),
inp("작업거리", "1회의 작업거리(ℓ)", "m", src=f"건설품셈 공통 {no}"),
inp("암질", "암질", pick=C(f"{no} E", "암질"), src=f"건설품셈 공통 {no} 2"),
inp(
"탄성파속도",
"탄성파속도 — 작업효율 표의 칸 값",
"m/sec",
src=f"건설품셈 공통 {no} 2",
),
F_IN,
e_in(no),
],
[
st("An", look(f"{no} An", "An", 규격="규격", 발톱수="발톱수"), "㎡"),
st(
"E",
auto(
"E입력",
look(f"{no} E", "E", 암질="암질", 규격="규격", 탄성파속도="탄성파속도"),
),
),
st(
"cm",
f"반올림({c(no, 'cm 작업거리 계수')} * 작업거리 + {c(no, 'cm 기본시간')}, 3)",
"분",
),
],
"60 * An * 작업거리 * f * E / cm",
{
"규격": 20,
"발톱수": "3본",
"작업거리": 30,
"암질": "연질",
"탄성파속도": 500,
"f": 1,
"E입력": 0,
},
memo="cm = 0.05ℓ + 0.25(원문 산정식) · 탄성파속도는 작업효율 표에 있는 값(규격별)",
)
)
# 8-2-3 굴착기
no = "8-2-3"
base, adj = soil_e("CC000043", "CC000046")
narrow = look("CC000044", "E", 등급="등급", 토질명="토질명")
out.append(
logic(
no,
"굴착기",
"굴착기 시간당 작업량",
"㎥/hr",
excavator_inputs(no, C),
[
st("K", look("CC000042", "K", 현장조건="버킷조건")),
st("보정", adj),
st("E", auto("E입력", f"만약(협소현장 == '해당 없음', {base}, {narrow}) - 보정")),
st(
"cm",
auto("싸이클입력", look("CC000045", "시간", 규격="규격구분", 각도="선회각도")),
"초",
),
],
"3600 * 버킷용량 * K * f * E / cm",
EXCAVATOR_TEST,
memo="Q = 3,600·q·K·f·E/cm · 협소현장 = 주⑦ 상하수도관로부설 등 별도 E 표 · 싸이클입력 0 = 표(규격 · 선회각도)",
)
)
# 8-2-4 트랜처
no = "8-2-4"
out.append(
logic(
no,
"트랜처",
"트랜처 시간당 작업량",
"m/hr",
[
inp("작업거리", "1열 실작업거리(L · 편도)", "m", src=f"건설품셈 공통 {no} 2"),
inp(
"전진거리",
"1열 전진거리(L1) — 0 이면 실작업거리",
"m",
src=f"건설품셈 공통 {no} 2 다",
),
inp(
"후진거리",
"1열 후진거리(L2) — 0 이면 실작업거리",
"m",
src=f"건설품셈 공통 {no} 2 다",
),
inp(
"굴착심도",
"굴착심도",
"m",
C(f"{no} d", "굴착심도"),
f"건설품셈 공통 {no} 2 가",
),
inp("토질", "토질", pick=C(f"{no} E", "토질"), src=f"건설품셈 공통 {no} 2 나"),
inp("작업조건", "작업 조건", pick=LEVEL, src=f"건설품셈 공통 {no} 2 나"),
e_in(no),
],
[
st("d", look(f"{no} d", "d", 굴착심도="굴착심도")),
st("E", auto("E입력", look(f"{no} E", "E", 토질="토질", 작업조건="작업조건"))),
st("전진", auto("전진거리", "작업거리"), "m"),
st("후진", auto("후진거리", "작업거리"), "m"),
st(
"cm",
f"반올림({c(no, '흡수관 삽입 및 수평조절시간(t1)')} + 전진 / {c(no, '전진속도(V1)')} + 후진 / "
f"{c(no, '후진속도(V2)')} + {c(no, '회전 및 기어 변속 · 흡수관 끝봉합 시간(t3)')}, 3)",
"분",
),
],
"60 * 작업거리 * d * E / cm",
{
"작업거리": 100,
"전진거리": 0,
"후진거리": 0,
"굴착심도": D("0.7"),
"토질": "사질토",
"작업조건": "보통",
"E입력": 0,
},
memo="cm = t1 + (L1/V1 + L2/V2) + t3 · 작업보조인부 4인 1조(주①)",
)
)
# 8-2-5 로더
no = "8-2-5"
base, adj = soil_e("CC000050", "CC000053")
k_all = C("CC000048", "현장조건") + C("CC000049", "현장조건")
out.append(
logic(
no,
"로더",
"로더 운전시간당 작업량",
"㎥/hr",
loader_inputs(no, C, k_all),
[
st(
"t1",
look("CC000047", "t1", 기종="기종", 작업방법="작업방법", 현장조건="적재조건"),
"초",
),
st(
"K",
f"만약(K표 == '산적상태 적재', {look('CC000048', '계수', 현장조건='K조건')}, "
f"{look('CC000049', '계수', 현장조건='K조건')})",
),
st("m", look("CC000051", "m", 기종="기종"), "초/m"),
st("l", auto("주행거리", look("CC000052", "값", 항목="'편도주행거리(표준)'")), "m"),
st("t2", look("CC000052", "값", 항목="'기본시간(t2, 기어변화 등)'"), "초"),
st("cm", "m * l + t1 + t2", "초"),
st("보정", adj),
st("E", auto("E입력", f"{base} - 보정")),
],
"3600 * 버킷용량 * K * f * E / cm",
LOADER_TEST,
memo="cm = m·ℓ + t1 + t2 · K 표 둘(산적상태 적재 · 자연상태·기타 적재) · 주행거리 0 = 표준 8m",
)
)
return out
def excavator_inputs(no, C):
return [
inp("버킷용량", "버킷용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
inp(
"규격구분",
"싸이클시간 표의 규격 칸",
"㎥",
C("CC000045", "규격"),
f"건설품셈 공통 {no} 3",
),
inp("선회각도", "선회 각도", "도", C("CC000045", "각도"), f"건설품셈 공통 {no} 3"),
inp(
"버킷조건",
"버킷계수(K) 현장조건",
pick=C("CC000042", "현장조건"),
src=f"건설품셈 공통 {no} 1",
),
*soil_inputs(no, C, "CC000043", "CC000046", "2"),
inp(
"협소현장",
"주택가 상하수도관로부설 등 협소현장(주⑦)",
pick=["해당 없음", "상하수도관로부설 등 협소현장"],
src=f"건설품셈 공통 {no} 2 주⑦",
),
F_IN,
e_in(no),
inp(
"싸이클입력",
"1회 싸이클시간을 직접 넣을 때 — 0 이면 표",
"초",
src=f"건설품셈 공통 {no} 3",
),
]
EXCAVATOR_TEST = {
"버킷용량": 1,
"규격구분": "1.0∼1.2",
"선회각도": 135,
"버킷조건": "위의 토질보다 약간 단단한 토질로서 버킷에 거의 가득 채울 수 있는 모래, 보통토 및 조건이 좋은 점토인 경우",
"현장조건": "흐트러진 상태",
"등급": "보통",
"토질명": "모래, 사질토",
"E보정": "해당 없음",
"협소현장": "해당 없음",
"f": D("0.7"),
"E입력": 0,
"싸이클입력": 0,
}
def loader_inputs(no, C, k_all):
return [
inp("기종", "로더 기종", pick=C("CC000047", "기종"), src=f"건설품셈 공통 {no} 1"),
inp("버킷용량", "버킷용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
inp(
"작업방법",
"버킷에 담는 방법",
pick=C("CC000047", "작업방법"),
src=f"건설품셈 공통 {no} 1",
),
inp("적재조건", "t1 현장조건", pick=C("CC000047", "현장조건"), src=f"건설품셈 공통 {no} 1"),
inp(
"K표",
"버킷계수 표 갈래",
pick=["산적상태 적재", "자연상태·기타 적재"],
src=f"건설품셈 공통 {no} 2",
),
inp("K조건", "버킷계수 현장조건(고른 표의 줄)", pick=k_all, src=f"건설품셈 공통 {no} 2"),
inp("주행거리", "편도주행거리(ℓ) — 0 이면 표준 8m", "m", src=f"건설품셈 공통 {no}"),
*soil_inputs(no, C, "CC000050", "CC000053", "3"),
F_IN,
e_in(no),
]
LOADER_TEST = {
"기종": "타이어식",
"버킷용량": D("1.34"),
"작업방법": "산적상태에서 담을 때",
"적재조건": "보통인 경우",
"K표": "산적상태 적재",
"K조건": "굴착기계로 깎거나 쌓아모은 산적상태에서 적재하는 것으로 굴착력을 필요로 하지 않고 쉽게 버킷에 산적할 수 있는 것, 즉 조건이 좋은 모래, 보통토 등",
"주행거리": 0,
"현장조건": "흐트러진 상태",
"등급": "양호",
"토질명": "모래, 사질토",
"E보정": "해당 없음",
"f": 1,
"E입력": 0,
}
resources/master_data/scripts/_건설기계_로직2.py
+378
View File
@@ -0,0 +1,378 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-2-6 ~ 8-2-21 시공능력 로직 — `_건설기계_로직.py` 와 같은 꼴."""
from __future__ import annotations
from decimal import Decimal as D
from _건설기계_로직 import F_IN, LEVEL, auto, c, e_in, inp, logic, look, st
from _건설기계_로직_플랜트 import part2b
def part2(C) -> list[dict]:
out = []
# 8-2-6 모터 스크레이퍼
no = "8-2-6"
out.append(
logic(
no,
"스크레이퍼",
"모터 스크레이퍼 시간당 작업량",
"㎥/hr",
[
inp("적재함용적", "적재함 용적", "㎥", src=f"건설품셈 공통 {no}"),
inp(
"토질상태",
"적재계수(K) 토질상태",
pick=C(f"{no} K", "토질상태"),
src=f"건설품셈 공통 {no} 1",
),
inp(
"작업현장",
"작업효율(E) 현장조건",
pick=C(f"{no} E", "현장조건"),
src=f"건설품셈 공통 {no} 2",
),
inp(
"도로상태",
"주행 도로상태",
pick=C(f"{no} V", "도로상태"),
src=f"건설품셈 공통 {no} 4",
),
inp("적재주행거리", "적재시의 주행거리(L1)", "m", src=f"건설품셈 공통 {no} 3"),
inp("공차주행거리", "공차시의 주행거리(L2)", "m", src=f"건설품셈 공통 {no} 3"),
inp(
"푸쉬도우저",
"푸쉬도우저 사용",
pick=["사용", "사용 안 함"],
src=f"건설품셈 공통 {no} 3",
),
F_IN,
e_in(no),
],
[
st("K", look(f"{no} K", "K", 토질상태="토질상태")),
st("q", "적재함용적 * K", "㎥"),
st("E", auto("E입력", look(f"{no} E", "E", 현장조건="작업현장"))),
st("V1", look(f"{no} V", "적재시", 도로상태="도로상태"), "m/분"),
st("V2", look(f"{no} V", "공차시", 도로상태="도로상태"), "m/분"),
st(
"t",
f"만약(푸쉬도우저 == '사용', {c(no, '적토·사토·기어변속시간(t) — 푸쉬도우저 사용')}, "
f"{c(no, '적토·사토·기어변속시간(t) — 푸쉬도우저 사용 안 함')})",
"분",
),
st("cm", "반올림(적재주행거리 / V1 + 공차주행거리 / V2 + t, 3)", "분"),
],
"60 * q * f * E / cm",
{
"적재함용적": 10,
"적재주행거리": 300,
"공차주행거리": 300,
"푸쉬도우저": "사용",
"f": 1,
"E입력": 0,
},
memo="q = 적재함용적 × K · cm = L1/V1 + L2/V2 + t",
)
)
# 8-2-7 모터 그레이더 — 면적(A) · 토량(Q)
no = "8-2-7"
common = [
inp("작업거리", "1회의 작업거리(D · 편도)", "m", src=f"건설품셈 공통 {no}"),
inp(
"작업종류",
"속도 표의 작업종류",
pick=C(f"{no} V", "작업종류"),
src=f"건설품셈 공통 {no} 1",
),
inp("현장조건", "작업 현장조건", pick=LEVEL, src=f"건설품셈 공통 {no} 1 주①"),
inp(
"작업방식",
"cm 산출 갈래",
pick=["방향변환 또는 블레이드 선회 왕복작업", "전진 작업 후 후진·회송"],
src=f"건설품셈 공통 {no} 1 가·나",
),
inp(
"되돌림",
"되돌아 오는 방법(작업방식 「전진 작업 후 후진·회송」 때)",
pick=["후진", "회송"],
src=f"건설품셈 공통 {no} 1 나",
),
inp("되돌림조건", "후진 · 회송 현장조건", pick=LEVEL, src=f"건설품셈 공통 {no} 1 주②"),
inp("t작업", "t 표의 작업종류", pick=C(f"{no} t", "작업종류"), src=f"건설품셈 공통 {no} 1"),
inp(
"E작업",
"작업효율 표의 작업종류",
pick=C(f"{no} E", "작업종류"),
src=f"건설품셈 공통 {no} 3",
),
inp(
"작업횟수",
"작업장 전체의 폭을 그 속도로 행하는 작업횟수(P)",
"회",
src=f"건설품셈 공통 {no}",
),
e_in(no),
]
steps = [
st(
"V1",
look(f"{no} V", "속도", 작업종류="작업종류", 구분="'작업'", 현장조건="현장조건"),
"㎞/hr",
),
st(
"V2",
look(f"{no} V", "속도", 작업종류="작업종류", 구분="되돌림", 현장조건="되돌림조건"),
"㎞/hr",
),
st("t", look(f"{no} t", "t", 작업종류="t작업"), "분"),
st(
"cm",
"반올림(만약(작업방식 == '방향변환 또는 블레이드 선회 왕복작업', 0.06 * 작업거리 / V1 + t, "
"0.06 * (작업거리 / V1 + 작업거리 / V2) + 2 * t), 3)",
"분",
),
st("E", auto("E입력", look(f"{no} E", "E", 작업종류="E작업", 현장조건="현장조건"))),
]
test = {
"작업거리": 100,
"작업종류": "토사도보수",
"현장조건": "보통",
"작업방식": "방향변환 또는 블레이드 선회 왕복작업",
"되돌림": "후진",
"되돌림조건": "보통",
"t작업": "도로보수",
"E작업": "토사도의 보수 및 정지 등",
"작업횟수": 2,
"E입력": 0,
}
memo = "cm 가 = 0.06×D/V1 + t · 나 = 0.06×(D/V1 + D/V2) + 2t · 속도가 여럿이면(P1·Cm1 + P2·Cm2 …) 설계자가 나눠 셈"
out.append(
logic(
no,
"그레이더면적",
"모터 그레이더 1시간당 작업면적",
"㎡/hr",
[*common, inp("작업폭", "작업장 전체의 폭(W)", "m", src=f"건설품셈 공통 {no}")],
steps,
"60 * 작업거리 * 작업폭 * E / (작업횟수 * cm)",
{**test, "작업폭": 6},
memo=memo,
)
)
out.append(
logic(
no,
"그레이더토량",
"모터 그레이더 1시간당 작업토량",
"㎥/hr",
[
*common,
inp(
"l작업",
"블레이드 유효길이 표의 작업종류",
pick=C(f"{no} l", "작업종류"),
src=f"건설품셈 공통 {no} 2",
),
inp("두께", "굴착 깊이 또는 흙고르기 두께(H)", "m", src=f"건설품셈 공통 {no}"),
F_IN,
],
[*steps, st("l", look(f"{no} l", "유효길이", 작업종류="l작업"), "m")],
"60 * l * 작업거리 * 두께 * f * E / (작업횟수 * cm)",
{**test, "l작업": "부드러운 토질에서의 깎기", "두께": D("0.1"), "f": 1},
memo=memo,
)
)
# 8-2-8 덤프트럭
no = "8-2-8"
out.append(
logic(
no,
"덤프트럭",
"덤프트럭 1시간당 작업량",
"㎥/hr",
dump_inputs(no, C),
dump_steps(no),
"60 * q * f * E / cm",
DUMP_TEST,
memo="q = T/γt × L · cm = t1 + … + t6 · 적재기계 t1 = cms·n/(60·Es) · n = q/(qs·k)(2자리) · 인력 t1 = 적재시간(분/㎥) × q · t2 = 거리/속도 × 60(분)",
)
)
# 8-2-9 롤러 — 다짐토량(Q) · 다짐면적(A)
no = "8-2-9"
roll_in = [
inp("다짐기계", "다짐기계", pick=C("CC000062", "다짐기계"), src=f"건설품셈 공통 {no} 1"),
inp("규격", "다짐기계 규격(ton)", pick=C("CC000062", "규격"), src=f"건설품셈 공통 {no} 1"),
inp(
"다짐층",
"표준다짐속도 칸",
pick=["노체, 축제, 노상", "보조기층, 기층", "표층"],
src=f"건설품셈 공통 {no} 1",
),
inp("다짐횟수", "소요다짐횟수(N)", "회", src=f"건설품셈 공통 {no} 2"),
inp("E공종", "작업효율 표의 공종", pick=C("CC000064", "공종"), src=f"건설품셈 공통 {no} 3"),
inp(
"E기계",
"작업효율 표의 다짐기계",
pick=C("CC000064", "다짐기계"),
src=f"건설품셈 공통 {no} 3",
),
inp("현장조건", "작업 조건", pick=LEVEL, src=f"건설품셈 공통 {no} 3"),
e_in(no),
]
w = lambda f: look("CC000062", f, 다짐기계="다짐기계", 규격="규격") # noqa: E731
e = lambda f: look("CC000064", f, 공종="E공종", 다짐기계="E기계") # noqa: E731
roll_steps = [
st("W", w("유효다짐폭"), "m"),
st(
"V",
f"만약(다짐층 == '노체, 축제, 노상', {w(chr(39) + '속도_노체축제노상' + chr(39))}, "
f"만약(다짐층 == '보조기층, 기층', {w(chr(39) + '속도_보조기층기층' + chr(39))}, {w(chr(39) + '속도_표층' + chr(39))}))",
"㎞/hr",
),
st(
"E",
auto(
"E입력",
f"만약(현장조건 == '양호', {e('양호')}, 만약(현장조건 == '보통', {e('보통')}, {e('불량')}))",
),
),
]
roll_test = {
"다짐기계": "타이어롤러",
"규격": "8∼15",
"다짐층": "노체, 축제, 노상",
"다짐횟수": 4,
"E공종": "노체, 축제, 노상",
"E기계": "불도저",
"현장조건": "보통",
"E입력": 0,
}
out.append(
logic(
no,
"롤러토량",
"롤러 시간당 다짐토량",
"㎥/hr",
[
*roll_in,
inp(
"두께", "펴는 흙의 두께(D · 다져진 상태)", "m", src=f"건설품셈 공통 {no} 2 주②"
),
F_IN,
],
roll_steps,
"1000 * V * W * 두께 * E * f / 다짐횟수",
{**roll_test, "두께": D("0.3"), "f": 1},
memo="Q = 1,000·V·W·D·E·f/N · 소요다짐횟수 · 두께는 2 표(CC000063) 참고 입력",
)
)
out.append(
logic(
no,
"롤러면적",
"롤러 시간당 다짐면적",
"㎡/hr",
roll_in,
roll_steps,
"1000 * V * W * E / 다짐횟수",
roll_test,
memo="A = 1,000·V·W·E·1/N",
)
)
out += part2b(C)
return out
def dump_inputs(no, C):
s = f"건설품셈 공통 {no}"
return [
inp("적재용량", "덤프트럭의 적재용량(T)", "ton", src=s),
inp("단위중량", "자연상태 토석의 단위중량(γt · 습윤밀도)", "t/㎥", src=s),
inp("체적변화율", "체적환산계수에서의 체적변화율(L = 흐트러진/자연)", src=s),
inp("f", "체적환산계수", src=s),
inp("운반거리", "운반거리(편도)", "㎞", src=f"{s} 2"),
inp("도로상태", "운반도로 상태", pick=C("CC000054", "도로상태"), src=f"{s} 3"),
inp("적하토질", "적하시간 표의 토질", pick=C("CC000055", "토질"), src=f"{s} 4"),
inp("적하조건", "적하 작업조건", pick=LEVEL, src=f"{s} 4"),
inp("적재장소", "적재장소 진입 조건(t4)", pick=C("CC000056", "적재장소조건"), src=f"{s} 5"),
inp(
"덮개",
"적재함 덮개 설치 · 해체(t5)",
pick=["해당 없음", *C("CC000057", "구분")],
src=f"{s} 6",
),
inp("세륜", "세륜기 통과(t6)", pick=["안 함", "함"], src=f"{s} 7"),
inp(
"적재방법",
"적재시간(t1) 산출 갈래",
pick=["적재기계", "인력", "직접 입력"],
src=f"{s} 1 · 8 · 9",
),
inp("적재싸이클", "적재기계의 1회 싸이클시간(cms)", "초", src=f"{s} 8"),
inp("적재버킷", "적재기계의 버킷용량(q)", "㎥", src=f"{s} 8"),
inp("버킷계수", "적재기계의 버킷계수(k)", src=f"{s} 8"),
inp("적재효율", "적재기계의 작업효율(Es)", src=f"{s} 8"),
inp("인력종류", "인력 적재 종류", pick=C("CC000059", "종류"), src=f"{s} 9"),
inp(
"적재시간입력",
"적재시간(t1)을 직접 넣을 때(적재방법 「직접 입력」)",
"분",
src=f"{s} 1",
),
e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.9"),
]
def dump_steps(no):
one = "반올림(q / (적재버킷 * 버킷계수), 2)"
return [
st("q", "적재용량 / 단위중량 * 체적변화율", "㎥"),
st("n", f"만약(적재방법 == '적재기계', {one}, 0)", "회"),
st(
"t1",
f"만약(적재방법 == '적재기계', 적재싸이클 * n / (60 * 적재효율), "
f"만약(적재방법 == '인력', {look('CC000059', '적재시간', 종류='인력종류')} * q, 적재시간입력))",
"분",
),
st(
"t2",
f"운반거리 / {look('CC000054', '적재', 도로상태='도로상태')} * 60 + "
f"운반거리 / {look('CC000054', '공차', 도로상태='도로상태')} * 60",
"분",
),
st("t3", look("CC000055", "시간", 토질="적하토질", 작업조건="적하조건"), "분"),
st("t4", look("CC000056", "시간", 적재장소조건="적재장소"), "분"),
st("t5", f"만약(덮개 == '해당 없음', 0, {look('CC000057', '시간', 구분='덮개')})", "분"),
st(
"t6",
f"만약(세륜 == '함', {look('CC000058', '시간', 구분=chr(39) + '세륜시간' + chr(39))}, 0)",
"분",
),
st("cm", "반올림(t1 + t2 + t3 + t4 + t5 + t6, 3)", "분"),
st("E", auto("E입력", look("CC000060", "값", 항목="'작업효율(E)'"))),
]
DUMP_TEST = {
"적재용량": 15,
"단위중량": D("1.8"),
"체적변화율": D("1.25"),
"f": D("0.7"),
"운반거리": D("0.08"),
"도로상태": "교차가 힘든 산간지도로 및 제방 등의 도로",
"적하토질": "모래, 역, 호박돌",
"적하조건": "불량",
"적재장소": "적재장소가 넓지는 않으나 목적장소에 불편없이 진입할 수 있을 때",
"덮개": "해당 없음",
"세륜": "안 함",
"적재방법": "적재기계",
"적재싸이클": 21,
"적재버킷": 1,
"버킷계수": D("0.9"),
"적재효율": D("0.75"),
"인력종류": "토사류",
"적재시간입력": 0,
"E입력": 0,
}
resources/master_data/scripts/_건설기계_로직3.py
+421
View File
@@ -0,0 +1,421 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-2-22 ~ 8-2-26 로직(파일 해머 · 압입 인발기) — `_건설기계_로직.py` 와 같은 꼴 · 27 ~ 33 은 `_건설기계_로직_준설.py`."""
from __future__ import annotations
from decimal import Decimal as D
from _건설기계_로직 import auto, c, inp, logic, look, st
from _건설기계_로직_준설 import marine
FIX = [D("-0.05"), D("0"), D("0.05")]
def fixes(no, n, src):
return [
inp(
f"f{i}",
f"작업조건 보정계수 f_{i}(보정 표에서 고른 보정치)",
pick=FIX,
src=f"건설품셈 공통 {no} {src}",
)
for i in range(1, n + 1)
]
def fsum(n):
return " + ".join(f"f{i}" for i in range(1, n + 1))
def part3(C) -> list[dict]:
out = []
# 8-2-22 디젤 파일 해머 — 강관 · 콘크리트
no, s = "8-2-22", "건설품셈 공통 8-2-22"
soil = [
inp("토질", "토질계수(α) 표의 토질", pick=C(f"{no} α", "토질"), src=f"{s} 1 가 (1)"),
inp(
"α입력",
"토질계수를 직접 넣을 때(2종 이상 토층 가중평균) — 0 이면 표",
src=f"{s} 1 가 (1) 주",
),
]
common = [
inp("관입길이", "파일 끝이 들어가는 전층의 길이(L)", "m", src=f"{s} 1 가"),
inp("평균N", "평균 N치(1이하는 1)", src=f"{s} 1 가 (3)"),
inp("세우기횟수", "파일세우기 횟수(Ns)", "회", src=f"{s} 1 나"),
inp("평탄성", "작업계수 평탄성", pick=C(f"{no} F", "평탄성"), src=f"{s} 1 마"),
inp("현장", "작업 현장의 넓이와 상태", pick=C(f"{no} F", "현장"), src=f"{s} 1 마"),
]
base = [
st("α", auto("α입력", look(f"{no} α", "α", 토질="토질"))),
st("N", f"최대(평균N, {c(no, '평균 N치 아래끝(1이하는 1)')})"),
st("F", look(f"{no} F", "F", 평탄성="평탄성", 현장="현장")),
]
out.append(
logic(
no,
"강관",
"디젤 파일 해머 파일 1본당 시공시간 — 강관파일",
"분/본",
[
*soil,
inp("파일경", "파일경", "㎜", C(f"{no} β강관", "파일경"), f"{s} 1 가 (2)"),
inp(
"해머", "파일해머의 램중량", pick=C(f"{no} β강관", "해머"), src=f"{s} 1 가 (2)"
),
*common,
inp("평균간격", "파일의 평균간격(a)", "m", src=f"{s} 1 다"),
inp("블록간거리", "블록간의 거리(LS)", "m", src=f"{s} 1 다"),
inp("블록수", "블록수(S)", src=f"{s} 1 다"),
inp("시공본수", "파일의 전 시공 본수(n)", "본", src=f"{s} 1 다"),
inp("용접방법", "이음 용접", pick=["해당 없음", "반자동", "수동"], src=f"{s} 1 바"),
inp(
"관두께",
"관두께(박판 기준)",
"㎜",
C(f"{no} 용접반자동", "관두께"),
f"{s} 1 바",
),
inp("이음수", "파일 1본당 이음수(Nw)", "개소", src=f"{s} 1 바"),
],
[
*base,
st("β", look(f"{no} β강관", "β", 파일경="파일경", 해머="해머")),
st("Tb", f"{c(no, '타격시간 계수 — 강관파일')} * α * β * 관입길이 * (N + 2)", "분"),
st(
"tw",
f"만약(용접방법 == '해당 없음', 0, 만약(용접방법 == '반자동', "
f"{look(f'{no} 용접반자동', '시간', 파일경='파일경', 관두께='관두께')}, "
f"{look(f'{no} 용접수동', '시간', 파일경='파일경', 관두께='관두께')}))",
"분",
),
st("Tw", "tw * 이음수", "분"),
st("Ts", f"{c(no, '세우기 및 위치조정 — 강관파일')} * 세우기횟수", "분"),
st(
"Tt",
f"(평균간격 + 블록간거리 * (블록수 - 1) / 시공본수) / {c(no, '크롤러식 항타기 자주 표준주행속도(V)')}",
"분",
),
st("Te", look(f"{no} Te강관", "Te", 해머="해머"), "분"),
],
"(Tb + Tw + Ts + Tt + Te) / F",
{
"토질": "실트･로움･모래",
"α입력": 0,
"파일경": 500,
"해머": "2.2t 급",
"관입길이": 12,
"평균N": 10,
"세우기횟수": 1,
"평탄성": "양호",
"현장": "현장이 넓으며 작업에 장애물이 없는 경우",
"평균간격": 2,
"블록간거리": 20,
"블록수": 2,
"시공본수": 50,
"용접방법": "반자동",
"관두께": 12,
"이음수": 1,
},
cut=False,
memo="Tc = (Tb+Tw+Ts+Tt+Te)/F · Tb = 0.05·α·β·L(N+2) — 원문 강관 식 글에 β 글자가 빠져 있으나 기호 풀이(β 해머 계수) · 표 · 콘크리트 식대로 β 곱함",
)
)
out.append(
logic(
no,
"콘크리트",
"디젤 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC)",
"분/본",
[
*soil,
inp("파일경", "파일경", "㎜", C(f"{no} β콘크리트", "파일경"), f"{s} 2 가"),
inp("해머", "파일해머 규격", pick=C(f"{no} β콘크리트", "해머"), src=f"{s} 2 가"),
*common,
],
[
*base,
st("β", look(f"{no} β콘크리트", "β", 해머="해머", 파일경="파일경")),
st(
"Tb",
f"{c(no, '타격시간 계수 — 콘크리트 파일')} * α * β * 관입길이 * (N + 2)",
"분",
),
st(
"Ts",
f"만약(파일경 <= 300, {c(no, '세우기 및 위치조정 — 콘크리트 파일 250·300㎜')}, "
f"{c(no, '세우기 및 위치조정 — 콘크리트 파일 350∼500㎜')}) * 세우기횟수",
"분",
),
st("Tt", c(no, "이동 및 준비시간 — 콘크리트 파일"), "분"),
st(
"Te",
f"만약(해머 == '1.5ton 급', {look(f'{no} Te콘크리트', 'Te', 해머=chr(39) + '1.5톤 급' + chr(39))}, "
f"{look(f'{no} Te콘크리트', 'Te', 해머=chr(39) + '2.2톤 급' + chr(39))})",
"분",
),
],
"(Tb + Ts + Tt + Te) / F",
{
"토질": "실트･로움･모래",
"α입력": 0,
"파일경": 400,
"해머": "2.2ton 급",
"관입길이": 12,
"평균N": 10,
"세우기횟수": 1,
"평탄성": "양호",
"현장": "현장이 넓으며 작업에 장애물이 없는 경우",
},
cut=False,
memo="Tc = (Tb+Ts+Tt+Te)/F · Tb = 0.08α·β·L(N+2) · 용접 없음",
)
)
# 8-2-23 유압 파일 해머 — 강관 · 콘크리트
no, s = "8-2-23", "건설품셈 공통 8-2-23"
n_in = inp("평균N", "타입층의 평균 N치", src=f"{s} 1 가 (1)")
out.append(
logic(
no,
"강관",
"유압 파일 해머 파일 1본당 시공시간 — 강관파일",
"분/본",
[
n_in,
inp("항타길이", "항타길이", "m", C(f"{no} β", "항타길이"), f"{s} 1 가 (2)"),
inp("판두께", "판두께", "㎜", C(f"{no} β", "판두께"), f"{s} 1 가 (2)"),
inp("파일경", "파일경", "㎜", C(f"{no} Ta강관", "파일경"), f"{s} 1 가 (3)"),
],
[
st(
"α",
f"만약(평균N < 20, {look(f'{no} α강관', 'α', N치=chr(39) + '20 미만' + chr(39))}, "
f"{look(f'{no} α강관', 'α', N치=chr(39) + '20 이상' + chr(39))})",
),
st("β", look(f"{no} β", "β", 항타길이="항타길이", 판두께="판두께")),
st("Ta", look(f"{no} Ta강관", "Ta", 항타길이="항타길이", 파일경="파일경"), "분/본"),
],
"α * β * Ta",
{"평균N": 15, "항타길이": "17∼32", "판두께": "12", "파일경": "500∼800"},
cut=False,
memo="Tc = α·β·Ta · 용접시간 포함(주④)",
)
)
out.append(
logic(
no,
"콘크리트",
"유압 파일 해머 파일 1본당 시공시간 — 콘크리트 파일(PC · RC · PHC)",
"분/본",
[
n_in,
inp(
"항타길이", "항타길이", "m", C(f"{no} Ta콘크리트", "항타길이"), f"{s} 1 나 (2)"
),
inp("파일경", "파일경", "㎜", C(f"{no} Ta콘크리트", "파일경"), f"{s} 1 나 (2)"),
],
[
st(
"α",
f"만약(평균N < 20, {look(f'{no} α콘크리트', 'α', N치=chr(39) + '20 미만' + chr(39))}, "
f"{look(f'{no} α콘크리트', 'α', N치=chr(39) + '20 이상' + chr(39))})",
),
st(
"Ta",
look(f"{no} Ta콘크리트", "Ta", 항타길이="항타길이", 파일경="파일경"),
"분/본",
),
],
"α * Ta",
{"평균N": 25, "항타길이": "16∼22", "파일경": "300∼600"},
cut=False,
memo="Tc = α·Ta",
)
)
out += vibro(C)
out += marine(C)
return out
def vibro(C) -> list[dict]:
out = []
no, s = "8-2-24", "건설품셈 공통 8-2-24"
r = lambda soil, f: look(f"{no} r", f, 공종="'항타'", 토질=repr(soil)) # noqa: E731
pull = lambda soil: look(f"{no} r", "r", 공종="'항발'", 토질=repr(soil)) # noqa: E731
sand, clay = "사질토, 역질토(r_1)", "점질토(r_2)"
out.append(
logic(
no,
"H파일",
"진동파일 해머 파일 1본당 시공시간 — H파일",
"분/본",
[
inp("작업", "항타 · 항발", pick=["항타", "항발"], src=f"{s} 1"),
inp("파일", "파일크기", pick=C(f"{no} k", "파일"), src=f"{s} 1 나 (2)"),
inp("사질층길이", "사질토 · 역질토 층 길이(ℓ1)", "m", src=f"{s} 1 나 (1)"),
inp("사질N", "사질토 · 역질토 N치(N1)", src=f"{s} 1 나 (1)"),
inp("점질층길이", "점질토 층 길이(ℓ2)", "m", src=f"{s} 1 나 (1)"),
inp("점질N", "점질토 N치(N2)", src=f"{s} 1 나 (1)"),
*fixes(no, 4, "1 다 (2)"),
],
[
st("Ts", look(f"{no} Ts", "Ts", 작업="작업"), "분"),
st(
"r1",
f"만약(작업 == '항타', {r(sand, '기울기')} * 사질N + {r(sand, '절편')}, {pull(sand)})",
"분/m",
),
st(
"r2",
f"만약(작업 == '항타', {r(clay, '기울기')} * 점질N + {r(clay, '절편')}, {pull(clay)})",
"분/m",
),
st("길이", "사질층길이 + 점질층길이", "m"),
st("r", "(r1 * 사질층길이 + r2 * 점질층길이) / 길이", "분/m"),
st("k", look(f"{no} k", "k", 작업="작업", 파일="파일")),
st("Tb", "r * 길이 * k", "분"),
st("F", f"{look(f'{no} F0', 'F0', 작업='작업')} + {fsum(4)}"),
],
"(Ts + Tb) / F",
{
"작업": "항타",
"파일": "H300",
"사질층길이": 6,
"사질N": 10,
"점질층길이": 4,
"점질N": 5,
"f1": 0,
"f2": 0,
"f3": 0,
"f4": 0,
},
cut=False,
memo="Tc = (Ts+Tb)/F · Tb = r×ℓ×k · r = (r1ℓ1 + r2ℓ2)/(ℓ1+ℓ2) · F = F0 + (f1+f2+f3+f4)",
)
)
out.append(
logic(
no,
"강널말뚝",
"진동파일 해머 파일 1본당 시공시간 — 강널말뚝",
"분/본",
[
inp("종류", "강널말뚝 종류", pick=C(f"{no} αK", "종류"), src=f"{s} 2 나 (1)"),
inp("작업", "항타 · 인발", pick=["항타", "인발"], src=f"{s} 2 나"),
inp(
"해머",
"진동파일해머 규격(162 = 유압식)",
"㎾",
C(f"{no} αK", "해머"),
f"{s} 2 나 (1)",
),
inp("근입길이", "강널말뚝 길이(ℓ)", "m", src=f"{s} 2 나"),
inp("Nmax", "최대 N치", src=f"{s} 2 나"),
*fixes(no, 3, "2 나 (2)"),
],
[
st("α", look(f"{no} αK", "α", 종류="종류", 작업="작업", 해머="해머")),
st("K", look(f"{no} αK", "K", 종류="종류", 작업="'항타'", 해머="해머")),
st("γ", look(f"{no} γ", "γ", 작업="작업")),
st("F", f"{look(f'{no} F0널', 'F0', 작업=chr(39) + '항타' + chr(39))} + {fsum(3)}"),
st(
"F인발",
f"{look(f'{no} F0널', 'F0', 작업=chr(39) + '항발' + chr(39))} + {fsum(3)}",
),
],
f"(({c(no, '강널말뚝 시공시간 상수')} + γ * Nmax) * 근입길이 + α) * K / 만약(작업 == '항타', F, F인발)",
{
"종류": "III-Type (400×150×13)",
"작업": "항타",
"해머": 45,
"근입길이": 10,
"Nmax": 20,
"f1": 0,
"f2": 0,
"f3": 0,
},
cut=False,
memo="Tc = {(0.75+γ·Nmax)·ℓ+α}·K/F · K = 원문 항타 · 인발 두 줄에 걸친 한 칸(항타 줄 값) · 인발 F0 = 원문 「항발」 칸",
)
)
no, s = "8-2-25", "건설품셈 공통 8-2-25"
out.append(
logic(
no,
"워터제트",
"진동파일해머(워터제트 병용 압입공) 파일 1본당 시공시간",
"분/본",
[
inp("근입길이", "근입길이(L)", "m", src=f"{s} 2 가"),
inp("평균N", "근입길이의 가중평균 N치", src=f"{s} 2 가"),
inp("토질", "토질계수 표의 토질", pick=C(f"{no} α", "토질"), src=f"{s} 2 나"),
inp(
"α입력",
"토질계수를 직접 넣을 때(여러 토질 가중평균) — 0 이면 표",
src=f"{s} 2 나",
),
*fixes(no, 4, "2 다 (2)"),
],
[
st(
"To",
f"{c(no, '기본시공시간 계수')} * 근입길이 * (평균N + {c(no, '기본시공시간 N 가산')}) + "
f"{c(no, '기본시공시간 상수')}",
"분",
),
st("α", auto("α입력", look(f"{no} α", "α", 토질="토질"))),
st(
"F",
f"{look(f'{no} F0', 'F0', 구분=chr(39) + '강널말뚝' + chr(39))} + {fsum(4)}",
),
],
"To * α / F",
{
"근입길이": 12,
"평균N": 40,
"토질": "점성토",
"α입력": 0,
"f1": 0,
"f2": 0,
"f3": 0,
"f4": 0,
},
cut=False,
memo="Tc = To×α/F · To = 0.05L(N+42.5)+9.6 · F = F0 + (f1+f2+f3+f4)",
)
)
no, s = "8-2-26", "건설품셈 공통 8-2-26"
out.append(
logic(
no,
"압입인발",
"유압식 압입 인발기 강널말뚝 1본당 시공시간",
"분/본",
[
inp("작업", "압입 · 인발", pick=["압입", "인발"], src=f"{s} 2"),
inp("파일길이", "파일길이(L)", "m", src=f"{s} 2 가"),
inp("압입길이", "압입 · 인발 길이(ℓ)", "m", src=f"{s} 2 나"),
inp("Nmax", "압입길이에 따른 최대 N치", src=f"{s} 2 나 (1)"),
inp("규격", "압입 인발기 규격", pick=C(f"{no} k", "규격"), src=f"{s} 2 나 (2)"),
*fixes(no, 3, "2 다"),
],
[
st(
"Ts",
f"{c(no, '준비시간 계수(L당)')} * 파일길이 + {c(no, '준비시간 상수')}",
"분",
),
st(
"γ",
f"{c(no, '압입 단위 작업시간 계수(Nmax당)')} * Nmax + {c(no, '압입 단위 작업시간 상수')}",
),
st("Tb", f"γ * 압입길이 * {look(f'{no} k', 'k', 규격='규격')}", "분"),
st("F", f"{c(no, '작업계수 기본값')} + {fsum(3)}"),
],
f"만약(작업 == '압입', (Ts + Tb) / F, ({c(no, '인발 시간 계수(ℓ당)')} * 압입길이 + {c(no, '인발 시간 상수')}) / F)",
{"작업": "압입", "파일길이": 12, "압입길이": 10, "Nmax": 20, "f1": 0, "f2": 0, "f3": 0},
cut=False,
memo="압입 Tc = (Ts+Tb)/F · 인발 Tc = (1.10ℓ+4.76)/F",
)
)
return out
resources/master_data/scripts/_건설기계_로직_경비.py
+121
View File
@@ -0,0 +1,121 @@
# -*- coding: utf-8 -*-
"""작업량당 기계경비 로직(굴착기 · 불도저 · 로더 · 덤프트럭 · 롤러 · 대형브레이커) · 기계설비 13-2-7 아세틸렌량의 환산."""
from __future__ import annotations
from decimal import Decimal as D
from _건설기계_로직 import inp, st
# ── 작업량당 기계경비 — 시간당 기계경비 로직 × 1/Q (원문 8-1-4 Q 를 품으로 · 산림 GF000089 꼴) ──
COSTS = [ # (Q 로직 열쇠, 짧은 이름, 기계 이름, 시간당 경비 로직, 기계 상세구분)
("공통 8-2-3 굴착기", "굴착기경비", "굴착기(무한궤도)", "GC000267", ("굴착기",)),
("공통 8-2-1 불도저", "불도저경비", "불도저", "GC000269", ("불도저",)),
("공통 8-2-5 로더", "로더경비", "로더", "GC000269", ("로더",)),
("공통 8-2-8 덤프트럭", "덤프트럭경비", "덤프트럭", "GC000268", ("덤프트럭",)),
(
"공통 8-2-9 롤러토량",
"롤러경비",
"롤러",
"GC000268",
("머캐덤 롤러", "탠덤롤러", "진동롤러", "타이어 롤러", "양족식 롤러"),
),
]
def costs(q_rows: dict, hourly: dict, machines: dict) -> list[dict]:
"""`q_rows` = 열쇠 → Q 로직 · `hourly` = 키 → 시간당 경비 로직 · `machines` = 상세구분 → 분류번호 목록."""
out = []
for qkey, short, label, ref, kinds in COSTS:
q = q_rows[qkey]
base = {i["이름"]: i for i in hourly[ref]["입력"]}
allowed = set(base["기계"]["고르기"])
pick = [m for k in kinds for m in machines.get(k, []) if m in allowed]
extra = [i for n, i in base.items() if n != "기계"]
names = [i["이름"] for i in q["입력"]]
call = ", ".join(f"{n}={n}" for n in names)
sub = ", ".join(f"{i['이름']}={i['이름']}" for i in hourly[ref]["입력"])
row = {
"열쇠": f"{qkey.rsplit(' ', 1)[0]} {short}",
"원문번호": q["원문번호"],
"구분": q["구분"],
"상세구분": q["상세구분"],
"이름": f"{label} 작업량당 기계경비 — 건설 공통 {q['원문번호']}",
"결과단위": "원/" + q["결과단위"].split("/")[0],
"출처": f"{q['출처']} · 건설품셈 공통 8-1-4",
"소유": "공용",
"비고": f"시간당 기계경비({ref}) × 1/Q — Q = {qkey.split(' ', 1)[1]} 시간당 작업량 로직",
"시험입력": {**q["시험입력"], "기계": pick[0]},
"입력": [*q["입력"], {"이름": "기계", "설명": f"{label} 규격", "고르기": pick}, *extra],
"중간": [st("작업량", f"로직({{L:{qkey}}}, {call})", q["결과단위"])],
"호표": [
{
"종류": "로직",
"요소": f"로직({ref}, {sub})",
"이름": label,
"단위": "시간",
"수량": "1 / 작업량",
"출처": "건설품셈 공통 8-1-4",
}
],
"덧줄": [],
"끝수": None,
}
out.append(row)
return out
def breaker(hourly: dict) -> dict:
"""대형브레이커 — 작업능력(표 범위 · 설계자 입력) → 굴착기+대형브레이커 시간당 경비 × 1/Q."""
ins = hourly["GC000271"]["입력"]
sub = ", ".join(f"{i['이름']}={i['이름']}" for i in ins)
no, s = "8-2-13", "건설품셈 공통 8-2-13"
return {
"열쇠": f"공통 {no} 브레이커경비",
"원문번호": no,
"구분": "건설품셈 공통",
"상세구분": "08장 건설기계",
"이름": f"대형브레이커 작업량당 기계경비 — 건설 공통 {no}",
"결과단위": "원/㎥",
"출처": f"{s} 2",
"소유": "공용",
"비고": "작업능력 = 구조물 헐기(CC000065) · 굴착(CC000067) 표 범위 안에서 — 적용방법 다: 넓고 장해물 없음 상한치 · 약간 지장 평균치 · 협소 하한치 · 굴착기 0.4㎥ 조합 하한치(주⑤) · 보통인부 1인 · 치즐은 따로",
"시험입력": {"작업능력": D("3.3"), "기계": "0201-0070", "브레이커": "0230-0007"},
"입력": [
inp("작업능력", "대형브레이커 작업능력(Q · 표 범위 안 값)", "㎥/hr", src=f"{s} 2"),
*ins,
],
"중간": [],
"호표": [
{
"종류": "로직",
"요소": f"로직(GC000271, {sub})",
"이름": "굴착기+대형브레이커",
"단위": "시간",
"수량": "1 / 작업능력",
"출처": f"{s} 2",
}
],
"덧줄": [],
"끝수": None,
}
def acetylene() -> dict:
s = "건설품셈 기계설비 13-2-7"
return {
"열쇠": "기계설비 13-2-7 아세틸렌량의 환산",
"원문번호": "13-2-7",
"구분": "건설품셈 기계설비",
"상세구분": "13장 플랜트설비공사",
"이름": "아세틸렌량의 환산(ℓ → ㎏)",
"결과단위": "㎏",
"출처": s,
"소유": "공용",
"비고": "아세틸렌(㎏) = 아세틸렌(ℓ) × 26g/22.4ℓ ÷ 1,000 · 26g = 1mol당 분자량 · 22.4ℓ = 표준상태 1mol당량",
"시험입력": {"아세틸렌부피": 1000},
"입력": [inp("아세틸렌부피", "아세틸렌 부피", "ℓ", src=s)],
"중간": [],
"결과": {"식": "아세틸렌부피 * 26 / 22.4 / 1000", "출처": s},
"끝수": None,
}
resources/master_data/scripts/_건설기계_로직_준설.py
+307
View File
@@ -0,0 +1,307 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-2-27 ~ 8-2-33 로직(수중펌프 · TBM · 준설선 · 쇄암선 · 임목파쇄기 · 골재채취선) — `_건설기계_로직.py` 와 같은 꼴."""
from __future__ import annotations
from decimal import Decimal as D
from _건설기계_로직 import LEVEL, auto, c, e_in, inp, logic, look, st
def marine(C) -> list[dict]:
out = []
no, s = "8-2-27", "건설품셈 공통 8-2-27"
crew = lambda n: look(f"{no} 설치", "수량", 명칭=repr(n)) # noqa: E731
row = logic(
no,
"설치",
"수중펌프 설치 및 해체(1개소당)",
"원/개소",
[],
[],
"",
{},
cut=False,
src=f"{s} 5",
)
row.pop("결과")
row.pop("시험입력")
row["호표"] = [
{
"종류": "인력",
"요소": "LB000001",
"이름": "작업반장",
"단위": "인",
"수량": crew("작업반장"),
"비목": "노무비",
"출처": f"{s} 5",
},
{
"종류": "인력",
"요소": "LB000002",
"이름": "보통인부",
"단위": "인",
"수량": crew("보통인부"),
"비목": "노무비",
"출처": f"{s} 5",
},
]
row["덧줄"] = []
out.append(row)
no, s = "8-2-28", "건설품셈 공통 8-2-28"
out.append(
logic(
no,
"TBM",
"터널전단면 굴착기(TBM) 1시간당 작업량",
"㎥/hr",
[
inp("굴착직경", "굴착직경(D)", "m", src=f"{s} 1"),
inp("작업거리", "1회의 작업거리(ℓ · 장비 성능 · ø4.5m 때 1.2m)", "m", src=f"{s} 2"),
inp("회전속도", "굴착면의 분당 회전속도(R)", "회/분", src=f"{s} 4"),
inp("투과깊이", "굴착면 1회전당 컷터의 투과깊이(Pe)", "㎝/회", src=f"{s} 4"),
inp("현장조건", "현장조건", pick=LEVEL, src=f"{s} 3"),
e_in(no),
],
[
st("A", "3.14159265358979 * 굴착직경 * 굴착직경 / 4", "㎡"),
st("T1", "작업거리 / (회전속도 * 투과깊이) * 100", "분"),
st("cm", f"반올림(T1 + {c(no, '정치시간(T2)')}, 3)", "분"),
st(
"E", auto("E입력", look(f"{no} E", "E", 구분="'작업효율'", 현장조건="현장조건"))
),
],
"60 * A * 작업거리 * E / cm",
{
"굴착직경": D("4.5"),
"작업거리": D("1.2"),
"회전속도": 8,
"투과깊이": D("0.5"),
"현장조건": "보통",
"E입력": 0,
},
memo="A = πD²/4 · cm = T1 + T2 · T1 = ℓ/(R×Pe)×100",
)
)
no, s = "8-2-29", "건설품셈 공통 8-2-29"
es = [
inp(f"E{i}", name, pick=C(f"{no} E{i}", "구분"), src=f"{s} 4")
for i, name in ((1, "흙의 두께"), (2, "평면형상"), (3, "단면형상"), (4, "해상조건"))
]
out.append(
logic(
no,
"펌프준설",
"펌프식 준설선 1시간당 준설능력",
"㎥/hr",
[
inp("토질", "토질 분류", pick=C(f"{no} q", "토질"), src=f"{s} 2"),
inp("N값", "기준 N값", pick=C(f"{no} q", "N값"), src=f"{s} 2"),
inp("배송거리", "배송거리", "m", C(f"{no} q", "배송거리"), f"{s} 2"),
inp(
"q입력",
"746㎾당 준설능력을 직접 넣을 때(단거리 능력 (q1+q2)/2 등) — 0 이면 표",
"㎥/hr",
src=f"{s} 3",
),
inp("전동환산출력", "펌프준설선의 전동환산 출력(bo)", "㎾", src=f"{s} 2"),
*es,
],
[
st(
"q",
auto(
"q입력", look(f"{no} q", "q", 토질="토질", N값="N값", 배송거리="배송거리")
),
"㎥/hr",
),
st("E", " * ".join(look(f"{no} E{i}", "E", 구분=f"E{i}") for i in range(1, 5))),
],
f"q * 전동환산출력 * E / {c(no, '전동환산 기준 출력')}",
{
"토질": "사질토",
"N값": 10,
"배송거리": 3000,
"q입력": 0,
"전동환산출력": 3581,
"E1": "적당",
"E2": "적당",
"E3": "적당",
"E4": "보통",
},
memo="Q = q·bo·E/746 · E = E1×E2×E3×E4 · bo = 디젤 공칭 × 0.8 · 터빈 × 0.9",
)
)
out += grab(C)
return out
def grab(C) -> list[dict]:
out = []
no, s = "8-2-30", "건설품셈 공통 8-2-30"
out.append(
logic(
no,
"그래브",
"그래브 준설선 1시간당 준설량",
"㎥/hr",
[
inp("버킷용량", "버킷용량(q)", "㎥", C(f"{no} cm", "버킷용량"), f"{s} 3"),
inp("f분류", "체적환산계수 표 토질 구분", pick=C(f"{no} f", "분류"), src=f"{s} 1"),
inp("f상태", "체적환산계수 표 상태", pick=C(f"{no} f", "상태"), src=f"{s} 1"),
inp(
"fN값",
"체적환산계수 표 N의 값(칸이 빈 줄 = 해당 없음)",
pick=["해당 없음", *C(f"{no} f", "N값")],
src=f"{s} 1",
),
inp("f입력", "체적환산계수를 직접 넣을 때 — 0 이면 표", src=f"{s} 1"),
inp("k분류", "버킷계수 표 토질 분류", pick=C(f"{no} k", "분류"), src=f"{s} 2"),
inp("k상태", "버킷계수 표 상태", pick=C(f"{no} k", "상태"), src=f"{s} 2"),
inp(
"kN값",
"버킷계수 표 N의 값(칸이 빈 줄 = 해당 없음)",
pick=["해당 없음", *C(f"{no} k", "N값")],
src=f"{s} 2",
),
inp("k입력", "버킷계수를 직접 넣을 때 — 0 이면 표", src=f"{s} 2"),
inp("평균수심", "평균수심", "m", src=f"{s} 3"),
inp("E1", "흙의 두께", pick=C(f"{no} E1", "구분"), src=f"{s} 4 가"),
inp("E2", "해상조건", pick=C(f"{no} E2", "구분"), src=f"{s} 4 나"),
],
[
st(
"f", auto("f입력", look(f"{no} f", "f", 분류="f분류", 상태="f상태", N값="fN값"))
),
st(
"k",
auto(
"k입력",
look(
f"{no} k",
"k",
분류="k분류",
상태="k상태",
N값="kN값",
버킷용량="버킷용량",
),
),
),
st(
"cm",
f"{look(f'{no} cm', '싸이클시간', 버킷용량='버킷용량')} + (평균수심 - {c(no, '기준 수심')}) * "
f"{c(no, '수심 1m 증감당 싸이클시간 증감')}",
"초",
),
st("E", f"{look(f'{no} E1', 'E', 구분='E1')} * {look(f'{no} E2', 'E', 구분='E2')}"),
],
"3600 * 버킷용량 * k * f * E / cm",
{
"버킷용량": D("3.0"),
"f분류": "모래질토사",
"f상태": "보통질",
"fN값": "10∼20",
"f입력": 0,
"k분류": "모래질 토사",
"k상태": "보통질",
"kN값": "10∼20",
"k입력": 0,
"평균수심": 10,
"E1": "적당",
"E2": "보통",
},
memo="Q = 3,600·q·k·f·E/cm · E = E1×E2 · 수심 10m 기준 1m 증감마다 2초 증감 · 표의 괄호 값 = 쇄암 · 발파후 준설",
)
)
no, s = "8-2-31", "건설품셈 공통 8-2-31"
out.append(
logic(
no,
"쇄암선",
"쇄암선(중추식) 시간당 작업능력",
"㎥/hr",
[
inp("분류", "토질분류", pick=C(f"{no} S", "분류"), src=f"{s} 1"),
inp("상태", "상태", pick=C(f"{no} S", "상태"), src=f"{s} 1"),
inp("중추중량", "중추중량", "ton", C(f"{no} S", "중추중량"), f"{s} 1"),
inp("E", "작업효율(원문 값 없음 — 설계자 입력)", src=f"{s} 3"),
],
[
st("S", look(f"{no} S", "S", 분류="분류", 상태="상태", 중추중량="중추중량"), "㎡"),
st("n", look(f"{no} n", "n", 분류="분류", 상태="상태", 중추중량="중추중량"), "회"),
],
f"60 * {c(no, '1층 쇄암 깊이(d)')} * S * E / ({c(no, '쇄암위치 이동 소요시간(t)')} + n / {c(no, '중추의 1분당 낙추횟수(P)')})",
{"분류": "암반", "상태": "연질", "중추중량": 30, "E": D("0.7")},
memo="Q = 60·d·S·E/(t + n/p)",
)
)
no, s = "8-2-32", "건설품셈 공통 8-2-32"
out.append(
logic(
no,
"임목파쇄기",
"이동식 임목파쇄기 시간당 파쇄능력",
"㎥/hr",
[
inp(
"규격",
"임목파쇄기 규격",
pick=["93.25㎾", *C(f"{no} K", "규격")],
src=f"{s} 1 · 2",
),
inp(
"스크린",
"스크린 규격(354.35㎾ 이상)",
pick=C(f"{no} S", "스크린"),
src=f"{s} 2 라",
),
inp(
"작업조건",
"작업효율(354.35㎾ 이상)",
pick=C(f"{no} E", "작업조건"),
src=f"{s} 2 마",
),
],
[],
f"만약(규격 == '93.25㎾', {c(no, '93.25㎾ 작업량(Q)')}, {c(no, '354.35㎾ 시간당 표준파쇄량(q)')} * "
f"{look(f'{no} K', 'K', 규격='규격')} * {look(f'{no} S', 'S', 스크린='스크린')} * {look(f'{no} E', 'E', 작업조건='작업조건')})",
{"규격": "354.35㎾", "스크린": "75㎜", "작업조건": "보통"},
memo="93.25㎾ Q = 6.0 · 354.35∼402.84㎾ Q = q·K·S·E",
)
)
no, s = "8-2-33", "건설품셈 공통 8-2-33"
out.append(
logic(
no,
"골재채취선",
"하천골재채취선 시간당 준설량",
"㎥/hr",
[
inp("분류", "구분", pick=C(f"{no} q", "분류"), src=f"{s} 2"),
inp("상태", "상태", pick=C(f"{no} q", "상태"), src=f"{s} 2"),
inp("배송거리", "배송거리", "m", C(f"{no} q", "배송거리"), f"{s} 2"),
inp("출력", "하천골재채취선의 출력(b)", "㎾", src=f"{s} 1"),
inp("조건", "천후, 평면형상, 위치 등", pick=C(f"{no} E", "조건"), src=f"{s} 3"),
inp("유속", "유속", pick=C(f"{no} E", "유속"), src=f"{s} 3"),
],
[
st(
"q",
look(f"{no} q", "q", 분류="분류", 상태="상태", 배송거리="배송거리"),
"㎥/hr",
),
st("E", look(f"{no} E", "E", 조건="조건", 유속="유속")),
],
f"q * 출력 * E / {c(no, '기준 출력')}",
{
"분류": "모래질토사",
"상태": "연질",
"배송거리": 300,
"출력": 746,
"조건": "보통",
"유속": "보통",
},
memo="Q = q·b·E/746",
)
)
return out
resources/master_data/scripts/_건설기계_로직_플랜트.py
+509
View File
@@ -0,0 +1,509 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-2-10 ~ 8-2-21 로직(아스팔트 플랜트 · 크러셔 · 콘크리트 · 기관차 · 경운기) — `_건설기계_로직.py` 와 같은 꼴."""
from __future__ import annotations
from decimal import Decimal as D
from _건설기계_로직 import F_IN, LEVEL, auto, c, e_in, inp, logic, look, mid, st
def part2b(C) -> list[dict]:
out = []
# 8-2-10 아스팔트 플랜트
no = "8-2-10"
out.append(
logic(
no,
"아스팔트플랜트",
"아스팔트 플랜트 시간당 생산능력",
"ton/hr",
[
inp(
"플랜트규격",
"플랜트 규격(ton)",
pick=C(f"{no} 생산능력", "플랜트규격"),
src=f"건설품셈 공통 {no} 1",
),
inp(
"혼합재",
"혼합재의 종류(A 밀 조립식 안정처리 · B 아스팔트 · C 소일아스팔트 · D 샌드 아스팔트)",
pick=C(f"{no} 생산능력", "혼합재"),
src=f"건설품셈 공통 {no} 1 주②",
),
],
[],
look(f"{no} 생산능력", "생산능력", 플랜트규격="플랜트규격", 혼합재="혼합재"),
{"플랜트규격": 60, "혼합재": "B"},
memo="기계효율 80% 반영값 · 작업효율 적용 안 함 · 일생산 6시간(2)",
)
)
# 8-2-11 스테이빌라이저
no = "8-2-11"
out.append(
logic(
no,
"스테이빌라이저",
"스테이빌라이저(노상안정기) 시간당 작업량",
"㎡/hr",
[
inp("로터폭", "Rotor 폭", "m", src=f"건설품셈 공통 {no} 1"),
inp(
"작업조건",
"작업 조건",
pick=C(f"{no} E", "작업조건"),
src=f"건설품셈 공통 {no} 2",
),
inp("혼합횟수", "혼합횟수(P) — 0 이면 평균 3회", "회", src=f"건설품셈 공통 {no} 3"),
e_in(no),
],
[
st("W", f"로터폭 - {c(no, '유효혼합폭 — Rotor 폭에서 뺌')}", "m"),
st("V", c(no, "작업속도(V)"), "m/hr"),
st("P", auto("혼합횟수", c(no, "혼합횟수(평균)")), "회"),
st("E", auto("E입력", look(f"{no} E", "E", 작업조건="작업조건"))),
],
"W * V * E / P",
{"로터폭": D("2.4"), "작업조건": "보통의 경우", "혼합횟수": 0, "E입력": 0},
memo="A = W·V·E/P · W = Rotor 폭 − 0.4m",
)
)
out += crusher(C)
# 8-2-14 압쇄기 · 8-2-16 골재세척설비 — Q = q × E
for no, short, name, q in (
("8-2-14", "압쇄기", "압쇄기(콘크리트 소할용) 시간당 작업량", "작업능력(q)"),
("8-2-16", "골재세척", "골재세척설비 시간당 작업량", "시간당 표준작업량(q)"),
):
out.append(
logic(
no,
short,
name,
"㎥/hr",
[
inp(
"q입력",
"작업능력을 직접 넣을 때 — 0 이면 원문 값",
"㎥/hr",
src=f"건설품셈 공통 {no}",
),
e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 값"),
],
[
st("q", auto("q입력", c(no, q)), "㎥/hr"),
st("E", auto("E입력", c(no, "작업효율(E)"))),
],
"q * E",
{"q입력": 0, "E입력": 0},
memo="Q = q × E",
)
)
# 8-2-15 법면다짐기
no = "8-2-15"
out.append(
logic(
no,
"법면다짐기",
"법면다짐기 시간당 작업량",
"㎡/hr",
[inp("구분", "장비", pick=C("CC000070", "구분"), src=f"건설품셈 공통 {no} 2")],
[],
look("CC000070", "작업량", 구분="구분"),
{"구분": "유압식 진동콤팩터"},
memo="유압식 진동콤팩터 + 굴착기 0.7㎥ · 법면다짐판 + 굴착기 1.0㎥(1)",
)
)
# 8-2-17 콘크리트 믹서
no = "8-2-17"
out.append(
logic(
no,
"믹서",
"콘크리트 믹서 시간당 생산량",
"㎥/hr",
[
inp("믹서용량", "콘크리트 믹서용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.8"),
],
[st("E", auto("E입력", c(no, "작업효율(E)")))],
f"60 / {c(no, '재료투입 혼합배출 등 작업시간')} * 믹서용량 * E",
{"믹서용량": D("0.5"), "E입력": 0},
memo="Q = 60/4 · q · E",
)
)
# 8-2-18 콘크리트 배치플랜트
no = "8-2-18"
out.append(
logic(
no,
"배치플랜트",
"콘크리트 배치플랜트(강제 혼합식) 시간당 작업량",
"㎥/hr",
[
inp(
"규격",
"배치플랜트 규격",
pick=C(f"{no} q", "규격"),
src=f"건설품셈 공통 {no} 1",
),
inp("슬럼프", "슬럼프", pick=C(f"{no} q", "슬럼프"), src=f"건설품셈 공통 {no} 1"),
inp("공종", "공종", pick=C(f"{no} E", "공종"), src=f"건설품셈 공통 {no} 2"),
inp(
"현장조건",
"현장조건",
pick=C(f"{no} E", "현장조건"),
src=f"건설품셈 공통 {no} 2",
),
inp(
"싸이클",
"1회 싸이클시간 갈래",
pick=["표준", "터널 숏크리트 강섬유 혼합"],
src=f"건설품셈 공통 {no} 주",
),
e_in(no),
],
[
st("q", look(f"{no} q", "실용량", 규격="규격", 슬럼프="슬럼프"), "㎥"),
st(
"cm",
f"만약(싸이클 == '표준', {c(no, '1회 싸이클시간(cm)')}, {c(no, '1회 싸이클시간 — 터널 숏크리트 강섬유 혼합')})",
"분",
),
st("E", auto("E입력", look(f"{no} E", "E", 현장조건="현장조건", 공종="공종"))),
],
"60 * q * E / cm",
{
"규격": "60㎥/h (96㎾)",
"슬럼프": "5㎝이상",
"공종": "사방",
"현장조건": "보통",
"싸이클": "표준",
"E입력": 0,
},
memo="Q = 60·q·E/cm · 터널 숏크리트 매우 불량은 E입력 0.40(주②)",
)
)
out += concrete_haul(C)
# 8-2-20 기관차
no = "8-2-20"
out.append(
logic(
no,
"기관차",
"기관차 시간당 작업량",
"㎥/hr",
[
inp("기관차", "기관차 규격", pick=["5t", "7t"], src=f"건설품셈 공통 {no}"),
inp("대차용량", "대차의 용량(q)", "㎥", src=f"건설품셈 공통 {no}"),
inp("운반거리", "평균 운반편도(L)", "m", src=f"건설품셈 공통 {no}"),
inp("재료", "적재 적하 재료", pick=["토사류", "석재류"], src=f"건설품셈 공통 {no}"),
F_IN,
inp("E", "작업효율(원문 값 없음 — 설계자 입력)", src=f"건설품셈 공통 {no}"),
],
[
st(
"n",
f"만약(기관차 == '5t', {c(no, '1회 운반시 대차수(n) — 5t')}, {c(no, '1회 운반시 대차수(n) — 7t')})",
"대",
),
st("C", "n * 대차용량", "㎥"),
st(
"t2",
f"만약(재료 == '토사류', {c(no, '적재 적하 소요시간(t2) — 토사류')}, {c(no, '적재 적하 소요시간(t2) — 석재류')})",
"분",
),
st(
"N",
f"반올림(60 / ({c(no, '입환소요시간(t1)')} + 운반거리 / {c(no, '적재시 주행속도(V1)')} + "
f"운반거리 / {c(no, '공차시 주행속도(V2)')} + t2), 2)",
"회/hr",
),
],
"C * N * f * E",
{
"기관차": "5t",
"대차용량": D("1.5"),
"운반거리": 500,
"재료": "토사류",
"f": 1,
"E": D("0.8"),
},
memo="Q = C·N·f·E · N = 60/(t1 + L/V1 + L/V2 + t2) · C = n × q",
)
)
# 8-2-21 경운기
no = "8-2-21"
out.append(
logic(
no,
"경운기",
"경운기 시간당 작업량",
"㎥/hr",
[
inp("적재량", "흐트러진 상태의 1회 적재량(q)", "㎥", src=f"건설품셈 공통 {no}"),
inp("거리", "운반거리(L)", "m", src=f"건설품셈 공통 {no} 1"),
inp("종류", "재료 종류", pick=C("CC000071", "종류"), src=f"건설품셈 공통 {no} 2"),
inp("작업로", "작업로 상태", pick=LEVEL, src=f"건설품셈 공통 {no} 2 주④"),
F_IN,
e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.9"),
],
[
st("t", look("CC000071", "시간", 종류="종류"), "분"),
st(
"V1",
look("CC000072", "속도", 종류="종류", 구분="'적재'", 현장조건="작업로"),
"m/분",
),
st(
"V2",
look("CC000072", "속도", 종류="종류", 구분="'적하'", 현장조건="작업로"),
"m/분",
),
st("cm", "반올림(거리 / V1 + 거리 / V2 + t, 3)", "분"),
st("E", auto("E입력", look("CC000073", "값", 항목="'작업효율(E)'"))),
],
"60 * 적재량 * f * E / cm",
{
"적재량": D("0.5"),
"거리": 100,
"종류": "토사류",
"작업로": "보통",
"f": 1,
"E입력": 0,
},
memo="cm = L/V1 + L/V2 + t · 공차 속도 = 원문 「적하」 칸",
)
)
return out
def crusher(C) -> list[dict]:
no, s = "8-2-12", "건설품셈 공통 8-2-12"
jaw = lambda f: look(f"{no} 죠", f, 출구간격="출구간격", 규격="규격") # noqa: E731
pick3 = inp("작업조건", "작업 조건", pick=LEVEL, src=f"{s} 1 다 주④")
return [
logic(
no,
"죠",
"죠 크러셔 시간당 생산능력",
"ton/hr",
[
inp("규격", "죠 크러셔 규격", pick=C(f"{no} 죠", "규격"), src=f"{s} 1 다"),
inp("출구간격", "출구간격", "㎜", C(f"{no} 죠", "출구간격"), f"{s} 1 다"),
pick3,
],
[],
f"만약(작업조건 == '양호', {jaw('위')}, 만약(작업조건 == '보통', ({jaw('아래')} + {jaw('위')}) / 2, {jaw('아래')}))",
{"규격": "025060", "출구간격": 40, "작업조건": "보통"},
memo="양호 = 최대치 · 보통 = 평균치 · 불량 = 최소치(주④) · 단위용적중량 1.6ton/㎥ 기준",
),
logic(
no,
"롤",
"롤 크러셔 시간당 생산능력",
"ton/hr",
[
inp("규격", "롤 크러셔 규격", pick=C(f"{no} 롤", "규격"), src=f"{s} 1 라"),
inp("출구간격", "출구간격", "㎜", C(f"{no} 롤", "출구간격"), f"{s} 1 라"),
inp("작업조건", "작업 조건", pick=LEVEL, src=f"{s} 1 라 주③"),
],
[st("효율", look(f"{no} 롤효율", "효율", 작업조건="작업조건"), "%")],
f"{look(f'{no} 롤', '생산능력', 출구간격='출구간격', 규격='규격')} * 효율 / 100",
{"규격": "076063", "출구간격": 25, "작업조건": "보통"},
memo="효율 양호 65% · 보통 50% · 불량 35%(주③)",
),
logic(
no,
"이동식",
"이동식 크러셔 시간당 생산능력",
"ton/hr",
[
inp(
"규격", "이동식 크러셔 규격(ton)", pick=C(f"{no} 이동식", "규격"), src=f"{s} 2"
),
inp("출구간격", "출구간격", "㎜", C(f"{no} 이동식", "출구간격"), f"{s} 2"),
inp("작업조건", "작업 조건(강자갈 = 양호)", pick=LEVEL, src=f"{s} 2 주③④"),
],
[st("E", look(f"{no} 이동식효율", "E", 작업조건="작업조건"))],
f"{look(f'{no} 이동식', '생산능력', 규격='규격', 출구간격='출구간격')} * E",
{"규격": 100, "출구간격": 25, "작업조건": "보통"},
memo="괄호 값도 원문 칸 그대로 씀",
),
logic(
no,
"스크린",
"스크린 전체 통과량",
"ton/hr",
[
inp("체규격", "체의 규격", "㎜", C(f"{no} 스크린", "체규격"), f"{s} 1 마"),
inp(
"조합방법",
"크러셔의 조합방법(롤 크러셔 = 1회통과식)",
pick=C(f"{no} 스크린", "조합방법"),
src=f"{s} 1 마",
),
inp(
"택의수",
"스크린택의 수",
pick=C(f"{no} 계수A", "택의 수"),
src=f"{s} 1 마 별표4",
),
inp(
"B골재량",
"스크린규격 1/2보다 작은 골재의 양",
"%",
C(f"{no} 계수B", "골재량"),
f"{s} 1 마 별표4",
),
inp(
"C규격",
"돌을 직접 분사할 때 스크린의 규격",
"㎜",
C(f"{no} 계수C", "스크린규격"),
f"{s} 1 마 별표4",
),
inp(
"D골재량",
"스크린 규격보다 큰 골재의 양",
"%",
C(f"{no} 계수D", "골재량"),
f"{s} 1 마 별표4",
),
inp(
"재료", "재료의 종류", pick=C(f"{no} 계수E", "재료분석"), src=f"{s} 1 마 별표4"
),
inp("체면적", "체적면적", "㎠", src=f"{s} 1 마 주⑤"),
],
[
st(
"통과능력",
look(f"{no} 스크린", "통과능력", 체규격="체규격", 조합방법="조합방법"),
"ton/hr",
),
st("A", look(f"{no} 계수A", "계수", **{"'택의 수'": "택의수"})),
st("B", look(f"{no} 계수B", "계수", 골재량="B골재량")),
st("C", look(f"{no} 계수C", "계수", 스크린규격="C규격")),
st("D", look(f"{no} 계수D", "계수", 골재량="D골재량")),
st("E", look(f"{no} 계수E", "계수", 재료분석="재료")),
],
"통과능력 * A * B * C * D * E * 체면적 / 930",
{
"체규격": 25,
"조합방법": "1회통과식",
"택의수": 1,
"B골재량": 40,
"C규격": D("28.0"),
"D골재량": 30,
"체면적": 930,
},
memo="통과량 = 930㎠당 통과능력 × A×B×C×D×E × 체적면적 × 1/930(주⑤ 예시)",
),
]
def concrete_haul(C) -> list[dict]:
no, s = "8-2-19", "건설품셈 공통 8-2-19"
plant = [
inp("플랜트실용량", "콘크리트플랜트 믹서 실용량(q)", "㎥", src="건설품셈 공통 8-2-18 1"),
inp(
"플랜트싸이클",
"콘크리트플랜트 싸이클시간(cmc) — 0 이면 1.5분",
"분",
src="건설품셈 공통 8-2-18",
),
]
cmc = auto("플랜트싸이클", c("8-2-18", "1회 싸이클시간(cm)"))
e = e_in(no, "작업효율을 직접 넣을 때 — 0 이면 원문 0.95")
e_step = st("E", auto("E입력", look(f"{no} 상수", "아래", 항목="'작업효율(E)'")))
return [
logic(
no,
"믹서트럭",
"콘크리트 믹서트럭 시간당 운반량",
"㎥/hr",
[
inp("적재용량", "믹서트럭 적재용량(W)", "㎥", src=f"{s} 1"),
*plant,
inp("운반거리", "운반거리(편도)", "㎞", src=f"{s} 1"),
inp("적재속도", "적재시 평균주행속도", "㎞/hr", src=f"{s} 1"),
inp("공차속도", "공차시 평균주행속도", "㎞/hr", src=f"{s} 1"),
inp("슬럼프", "슬럼프", pick=["4㎝ 이하", "5㎝ 이상"], src=f"{s} 1"),
inp("펌프조합", "콘크리트 펌프와 조합작업", pick=["아니오", "예"], src=f"{s} 1"),
inp("배출시간입력", "배출시간(t3) — 0 이면 원문 범위 가운데", "분", src=f"{s} 1"),
inp("대기시간입력", "대기시간(t4) — 0 이면 원문 범위 가운데", "분", src=f"{s} 1"),
e,
],
[
st("cmc", cmc, "분"),
st("t1", "적재용량 / 플랜트실용량 * cmc", "분"),
st("t2", "(운반거리 / 적재속도 + 운반거리 / 공차속도) * 60", "분"),
st(
"t3",
f"{auto('배출시간입력', f'만약(슬럼프 == {chr(39)}4㎝ 이하{chr(39)}, {mid(no, "믹서트럭 배출시간 — 슬럼프 4㎝ 이하")}, {mid(no, "믹서트럭 배출시간 — 슬럼프 5㎝ 이상")})')}"
f" + 만약(펌프조합 == '예', {look(f'{no} 상수', '아래', 항목=chr(39) + '믹서트럭 배출시간 — 콘크리트 펌프 조합 가산' + chr(39))}, 0)",
"분",
),
st("t4", auto("대기시간입력", mid(no, "믹서트럭 대기시간(t4)")), "분"),
st("cm", "반올림(t1 + t2 + t3 + t4, 3)", "분"),
e_step,
],
"60 * 적재용량 * E / cm",
{
"적재용량": 6,
"플랜트실용량": 1,
"플랜트싸이클": 0,
"운반거리": 5,
"적재속도": 30,
"공차속도": 35,
"슬럼프": "5㎝ 이상",
"펌프조합": "아니오",
"배출시간입력": 0,
"대기시간입력": 0,
"E입력": 0,
},
memo="cm = t1 + t2 + t3 + t4 · t1 = w/q·cmc · t2 = 거리/속도 × 60(분) · 범위(배출 2∼3 · 3∼4 · 대기 5∼10)는 가운데 기본",
),
logic(
no,
"덤프",
"콘크리트 덤프트럭 시간당 운반량",
"㎥/hr",
[
inp("규격", "덤프트럭 규격(톤)", pick=C(f"{no} W", "규격"), src=f"{s} 2 가"),
*plant,
inp("운반거리", "편도운반거리(L · 15㎞까지)", "㎞", src=f"{s} 2 나"),
inp("하역시간입력", "하역시간(t1) — 0 이면 원문 범위 가운데", "분", src=f"{s} 2"),
inp("대기시간입력", "대기시간(t2) — 0 이면 원문 범위 가운데", "분", src=f"{s} 2"),
e,
],
[
st("W", look(f"{no} W", "W", 규격="규격"), "㎥"),
st("cmc", cmc, "분"),
st(
"cm1",
f"{look(f'{no} 주행', '기울기', 구분=chr(39) + '표준치' + chr(39))} * 운반거리 + "
f"{look(f'{no} 주행', '절편', 구분=chr(39) + '표준치' + chr(39))}",
"분",
),
st(
"cm2",
f"W / 플랜트실용량 * cmc + {auto('하역시간입력', mid(no, '덤프트럭 하역시간(t1)'))} + "
f"{auto('대기시간입력', mid(no, '덤프트럭 대기시간(t2)'))}",
"분",
),
st("cm", "반올림(cm1 + cm2, 3)", "분"),
e_step,
],
"60 * W * E / cm",
{
"규격": D("10.5"),
"플랜트실용량": 1,
"플랜트싸이클": 0,
"운반거리": 5,
"하역시간입력": 0,
"대기시간입력": 0,
"E입력": 0,
},
memo="cm = cm1 + cm2 · cm1 = 3L + 5(±5) · cm2 = w/q·cmc + t1 + t2",
),
]
resources/master_data/scripts/_건설기계_읽기.py
+233
View File
@@ -0,0 +1,233 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8장 건설기계 본문 md 읽기 · 표 모양 도우미 — `build_로직_건설품셈_08장_건설기계.py` 가 씀.
- 절 = 본문 `8-02-NN_*.md` 한 파일(머리 ~ 다음 같은 · 윗 단계 머리 앞 · 요구 630).
- 칸 값 = 원문 글자 그대로의 수(`N`) · 「a∼b」 = [아래, 위] · 괄호 · 동그라미 번호 · 단위 붙은 수 = 수 + `<칸>원문`.
"""
from __future__ import annotations
import re
from pathlib import Path
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[2]
DIR = (
ROOT
/ "resources/knowledge/original/원가계산/건설공사_표준품셈/본문/01_공통부문/제08장_건설기계"
)
NUM = r"-?\d[\d,]*(?:\.\d+)?"
HEAD = {"구분": "건설품셈 공통", "상세구분": "08장 건설기계"}
class N(str):
"""원문 그대로의 수 글자."""
def section(no: str) -> list[str]:
"""`8-2-12` → 그 절 md 줄(머리 뒤 · 글자층 밖 표시 뗌)."""
a, b, c = no.split("-")
path = next(DIR.glob(f"{a}-{int(b):02d}-{int(c):02d}_*.md"))
text = re.sub(r"<!-- /?글자층 밖 -->", "", path.read_text(encoding="utf-8"))
lines = text.split("\n")
at = next(i for i, x in enumerate(lines) if x.startswith(f"### {no}"))
return lines[at:]
def _cell(c: str) -> str:
c = re.sub(r"\s*<br>\s*", " ", c.strip())
return re.sub(r"\s*∼\s*", "∼", c)
def tables(lines: list[str]) -> list[tuple[list[list[str]], list[str]]]:
"""md 표마다 (줄 칸 목록, 바로 뒤 [주] 줄) — 구분줄은 뺌."""
out, i = [], 0
while i < len(lines):
if not lines[i].startswith("|"):
i += 1
continue
rows = []
while i < len(lines) and lines[i].startswith("|"):
cells = [_cell(c) for c in lines[i].strip().strip("|").split("|")]
if not all(re.fullmatch(r":?-+:?", c) for c in cells):
rows.append(cells)
i += 1
note, j = [], i
while j < len(lines) and not lines[j].strip():
j += 1
if j < len(lines) and lines[j].strip().startswith("[주]"):
first = lines[j].strip().removeprefix("[주]").strip()
note = [first] if first else []
for x in lines[j + 1 :]:
if not x.strip() or x.startswith(("|", "#", "<!--")):
break
note.append(x.strip())
out.append((rows, note))
return out
def text_lines(lines: list[str], *starts: str) -> list[str]:
"""글 줄 가운데 `starts` 로 시작하는 줄(표 밖 원문 글 그대로)."""
return [x.strip() for x in lines if x.strip().startswith(starts)]
def lab(x: str):
"""조건 칸 글 — 수만 있으면 수."""
x = x.strip()
return N(x.replace(",", "")) if re.fullmatch(NUM, x) else x
def val(c: str):
"""값 칸 → (값, 원문) · 빈 칸 · 「-」 = (None, None)."""
c = c.strip()
if c in ("", "-", "―", "〃"):
return None, None
if re.fullmatch(NUM, c):
return N(c.replace(",", "")), None
m = re.fullmatch(rf"({NUM})∼({NUM})", c)
if m:
return [N(m[1].replace(",", "")), N(m[2].replace(",", ""))], None
m = re.fullmatch(rf"[(（]?[①-⑩]?\(?({NUM})\)?[㎥㎾분개/hrm]*", c)
if m and m[1] != c:
return N(m[1].replace(",", "")), c
return c, None
def put(row: dict, col: str, c: str) -> bool:
v, o = val(c)
if v is None:
return False
row[col] = v
if o is not None:
row[col + "원문"] = o
return True
def grid(
rows, keys: list[str], heads: list[dict], name: str, fill: int | None = None
) -> list[dict]:
"""줄 머리(`keys` · 앞 `fill` 칸은 빈 칸이면 윗줄) × 열 머리(`heads` · 칸마다 조건 묶음) → 긴 줄."""
out, last = [], [""] * len(keys)
fill = len(keys) if fill is None else fill
for r in rows:
labels = [
last[i] if x in ("", "〃") and i < fill else x for i, x in enumerate(r[: len(keys)])
]
last = labels
for head, c in zip(heads, r[len(keys) :]):
row = {k: lab(v) for k, v in zip(keys, labels) if v}
row.update(head)
if put(row, name, c):
out.append(row)
return out
def plain(rows, cols: list[str], fill: int = 1, keys: int | None = None) -> list[dict]:
"""줄마다 열 이름대로 · 앞 `keys` 칸은 조건 글(앞 `fill` 칸은 빈 칸이면 윗줄) · 값 없는 줄은 뺌."""
out, last = [], [""] * len(cols)
keys = fill if keys is None else keys
for r in rows:
row, got = {}, False
for i, (col, c) in enumerate(zip(cols, r)):
if i < keys:
c = last[i] if c in ("", "〃") and i < fill else c
last[i] = c
if c:
row[col] = lab(c)
elif col:
got = put(row, col, c) or got
if got:
out.append(row)
return out
def heads(*axes: tuple[str, list]) -> list[dict]:
"""열 머리 조건 묶음 — 축(이름, 값 목록)들의 곱(앞 축이 바깥)."""
out = [{}]
for name, values in axes:
out = [{**h, name: lab(str(v)) if isinstance(v, str) else v} for h in out for v in values]
return out
def table(label, name, src, cond, cols, rows, *, note=(), base="", memo=None, rule=None):
t = {"열쇠": label, "이름": name, "기준": base, "출처": src}
if memo:
t["비고"] = memo
t["용도"] = None # 빌더가 채움
t["조건"] = cond
if rule:
t["범위규칙"] = rule
t["값칸"] = cols
t["줄"] = rows
t["주"] = list(note)
return t
def conds(rows: list[dict], names: list[str]) -> dict:
"""조건 종류 — 모두 수면 「수」 · 아니면 「고르기」(수도 글로 바꿈)."""
out = {}
for n in names:
vals = [r[n] for r in rows if n in r]
if vals and all(isinstance(v, N) for v in vals):
out[n] = "수"
else:
out[n] = "고르기"
for r in rows:
if n in r and isinstance(r[n], N):
r[n] = str(r[n])
return out
# ── 쓰기 — 8장 계수 파일 글 모양(머리 넷 한 줄 · 조건 · 값칸 · 줄은 펼침) ──
def atom(v) -> str:
import json
if isinstance(v, N):
return str(v)
if isinstance(v, bool) or v is None:
return json.dumps(v)
if isinstance(v, int):
return str(v)
if isinstance(v, list):
return "[" + ", ".join(atom(x) for x in v) + "]"
if isinstance(v, dict):
return (
"{"
+ ", ".join(f"{json.dumps(k, ensure_ascii=False)}: {atom(x)}" for k, x in v.items())
+ "}"
)
return json.dumps(v, ensure_ascii=False)
def _block(d: dict, pad: str) -> str:
import json
if not d:
return "{}"
body = ",\n".join(
f"{pad} {json.dumps(k, ensure_ascii=False)}: {atom(v)}" for k, v in d.items()
)
return "{\n" + body + "\n" + pad + "}"
def emit(t: dict) -> str:
import json
head = ", ".join(f'"{k}": {atom(t[k])}' for k in ("키", "원문번호", "구분", "상세구분"))
out = [" {", f" {head},"]
for k in ("이름", "기준", "출처", "비고", "용도"):
if k in t:
out.append(f" {json.dumps(k, ensure_ascii=False)}: {atom(t[k])},")
out.append(f' "조건": {_block(t["조건"], " ")},')
if "범위규칙" in t:
out.append(f' "범위규칙": {atom(t["범위규칙"])},')
out.append(f' "값칸": {_block(t["값칸"], " ")},')
rows = ",\n".join(" " + _block(r, " ") for r in t["줄"])
out.append(' "줄": [\n' + rows + "\n ],")
if t["주"]:
notes = ",\n".join(" " + atom(x) for x in t["주"])
out.append(' "주": [\n' + notes + "\n ]")
else:
out.append(' "주": []')
out.append(" }")
return "\n".join(out)
resources/master_data/scripts/_건설기계_표.py
+653
View File
@@ -0,0 +1,653 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-2 시공능력 — 계수 표(절마다 원문 md 표 전부 + 표 밖 글 속 상수) · 8-2-2 ~ 8-2-21.
`build_로직_건설품셈_08장_건설기계.py` 가 부름 · 8-2-22 ~ 8-2-33 은 `_건설기계_표2.py`.
표 열쇠 = 「공통 <절> <짧은 이름>」 — 로직 식의 `{T:<절> <짧은 이름>}` 가 키로 바뀜.
"""
from __future__ import annotations
import re
from _건설기계_읽기 import N, conds, grid, heads, lab, plain, put, section, table, tables
LEVEL = ["양호", "보통", "불량"]
def tb(no, short, name, src, keys, cols, rows, **kw):
"""표 하나 — 조건 종류는 줄에서 셈 · 출처 = 「건설품셈 공통 <절> <항>」."""
t = table(
f"공통 {no} {short}",
name,
f"건설품셈 공통 {no} {src}".strip(),
conds(rows, keys),
cols,
rows,
**kw,
)
t["원문번호"] = no
return t
def const(no, lines, items, name="산정식 상수", src="", note=(), memo=None):
"""표 밖 글 속 상수 — (항목, 값 글, 단위[, 위 값 글]) · 값은 원문 글에 있어야 함."""
text = "\n".join(lines)
rows = []
for item in items:
what, low, unit, *high = item
for v in (low, *high):
assert re.search(rf"(?<![\d.]){re.escape(v)}(?![\d])", text.replace(",", "")), (no, v)
row = {"항목": what}
if high:
row["아래"], row["위"] = N(low), N(high[0])
else:
row["값"] = N(low)
row["단위"] = unit
rows.append(row)
cols = {"아래": "수", "위": "수"} if any("아래" in r for r in rows) else {}
if any("값" in r for r in rows):
cols = {"값": "수", **cols}
return tb(no, "상수", name, src, ["항목"], cols, rows, note=note, memo=memo)
def pick(t, i, j):
return t[i][0][j] if isinstance(j, int) else t[i][0]
# ── 8-2-2 리퍼 ──────────────────────────────────────────────────────
def s2():
no, S = "8-2-2", section("8-2-2")
T = tables(S)
an, e, rock = T[0][0], T[1][0], T[2][0]
rows_e, last = [], ["", ""]
for r in e[2:]:
last = [r[0] or last[0], r[1] or last[1]]
for size, (v, x) in (("20", (r[2], r[3])), ("30", (r[4], r[5]))):
rows_e.append(
{
"암질": last[0],
"발톱수": last[1],
"규격": N(size),
"탄성파속도": lab(v),
"E": N(x),
}
)
return [
tb(
no,
"An",
"1회 리핑단면적(An)",
"1",
["규격", "발톱수"],
{"An": "㎡"},
grid(an[2:], ["규격"], heads(("발톱수", ["1본", "2본", "3본"])), "An"),
note=T[0][1],
),
tb(
no,
"E",
"작업효율(E)",
"2",
["암질", "발톱수", "규격", "탄성파속도"],
{"E": ""},
rows_e,
memo="규격 = 트랙터 ton 급 · 탄성파속도 = m/sec",
),
tb(
no,
"탄성파",
"암질과 탄성파속도와의 관계",
"2 주",
["암의 종류", "암질"],
{"탄성파속도": "m/sec"},
grid(rock[2:], ["암의 종류"], heads(("암질", ["연질", "중질", "경질"])), "탄성파속도"),
),
const(
no,
S,
[("cm 작업거리 계수", "0.05", "분/m"), ("cm 기본시간", "0.25", "분")],
memo="cm = 0.05ℓ + 0.25 (원문 산정식)",
),
]
# ── 8-2-4 트랜처 ────────────────────────────────────────────────────
def s4():
no, S = "8-2-4", section("8-2-4")
T = tables(S)
d = [
{"굴착심도": N(h.removesuffix("m")), "d": N(v)}
for h, v in zip(T[0][0][0][1:7], T[0][0][1][1:7])
]
notes = [x.strip() for x in S if re.match(r"^[①-⑤] ", x.strip())]
return [
tb(no, "d", "굴착심도 계수(d)", "2 가", ["굴착심도"], {"d": ""}, d, base="굴착심도 m"),
tb(
no,
"E",
"작업효율(E)",
"2 나",
["토질", "작업조건"],
{"E": ""},
grid(T[1][0][1:], ["토질"], heads(("작업조건", LEVEL)), "E"),
),
const(
no,
S,
[
("흡수관 삽입 및 수평조절시간(t1)", "2.33", "분/열"),
("전진속도(V1)", "5.3", "m/분"),
("후진속도(V2)", "15.6", "m/분"),
("회전 및 기어 변속 · 흡수관 끝봉합 시간(t3)", "2.5", "분/열"),
],
src="2 다",
note=notes,
memo="V1 = d 0.7m 일 때 기준",
),
]
# ── 8-2-6 모터 스크레이퍼 ──────────────────────────────────────────
def s6():
no, S = "8-2-6", section("8-2-6")
T = tables(S)
return [
tb(
no,
"K",
"적재계수(K)",
"1",
["토질상태"],
{"K": ""},
plain(T[0][0][1:], ["토질상태", "K"]),
note=T[0][1],
),
tb(
no,
"E",
"작업효율(E)",
"2",
["현장조건"],
{"E": ""},
plain(T[1][0][1:], ["현장조건", "E"]),
),
tb(
no,
"V",
"적재시·공차시 주행속도(V1 · V2)",
"4",
["도로상태"],
{"적재시": "m/분", "공차시": "m/분"},
plain(T[2][0][2:], ["도로상태", "적재시", "공차시"]),
),
const(
no,
S,
[
("적토·사토·기어변속시간(t) — 푸쉬도우저 사용", "1.6", "분"),
("적토·사토·기어변속시간(t) — 푸쉬도우저 사용 안 함", "2.8", "분"),
],
src="3",
),
]
# ── 8-2-7 모터 그레이더 ────────────────────────────────────────────
def s7():
no, S = "8-2-7", section("8-2-7")
T = tables(S)
v = grid(
T[0][0][2:],
["작업종류"],
heads(("구분", ["작업", "후진", "회송"]), ("현장조건", LEVEL)),
"속도",
)
return [
tb(
no,
"V",
"작업·후진·회송 속도(V1 · V2)",
"1",
["작업종류", "구분", "현장조건"],
{"속도": "㎞/hr"},
v,
note=T[0][1],
),
tb(
no,
"t",
"방향 변환·블레이드 선회 기어변속 시간(t)",
"1",
["작업종류"],
{"t": "분"},
plain(T[1][0][1:], ["작업종류", "t"]),
),
tb(
no,
"l",
"블레이드 유효길이(ℓ)",
"2",
["작업종류"],
{"작업각도": "", "유효길이": "m(블레이드의 길이 3.6m)"},
plain(T[2][0][1:], ["작업종류", "작업각도", "유효길이"]),
),
tb(
no,
"E",
"작업효율(E)",
"3",
["작업종류", "현장조건"],
{"E": ""},
grid(T[3][0][2:], ["작업종류"], heads(("현장조건", LEVEL)), "E"),
note=T[3][1],
),
]
# ── 8-2-10 아스팔트 플랜트 ─────────────────────────────────────────
def s10():
no, S = "8-2-10", section("8-2-10")
T = tables(S)
rows = grid(T[0][0][2:], ["플랜트규격"], heads(("혼합재", ["A", "B", "C", "D"])), "생산능력")
return [
tb(
no,
"생산능력",
"시간당 생산능력 표준",
"1",
["플랜트규격", "혼합재"],
{"생산능력": "ton/hr"},
rows,
note=T[0][1],
base="플랜트규격 ton",
),
const(
no,
S,
[
("기계효율", "80", "%"),
("일생산시간", "6", "시간"),
("준비예열 및 끝맺음시간", "1", "시간"),
],
name="기계효율 · 실작업시간",
src="2",
),
]
# ── 8-2-11 스테이빌라이저 ──────────────────────────────────────────
def s11():
no, S = "8-2-11", section("8-2-11")
e = []
for line in S:
m = re.match(r"^(용이한 경우|보통의 경우|곤란한 경우) ([\d.]+)$", line.strip())
if m:
e.append({"작업조건": m[1], "E": N(m[2])})
assert len(e) == 3
notes = [x.strip() for x in S if re.match(r"^[①②] ", x.strip())]
return [
tb(no, "E", "작업효율(E)", "2", ["작업조건"], {"E": ""}, e),
const(
no,
S,
[
("유효혼합폭 — Rotor 폭에서 뺌", "0.4", "m"),
("작업속도(V)", "1000", "m/hr"),
("혼합횟수(평균)", "3", "회"),
],
note=notes,
),
]
# ── 8-2-12 크러셔 ───────────────────────────────────────────────────
def s12():
no, S = "8-2-12", section("8-2-12")
T = tables(S)
belt = []
for r in T[0][0][1:]:
for w, c in ((r[0], r[1]), (r[2], r[3])):
if w:
belt.append({"폭": lab(w), "운반능력": N(c)})
apron = grid(T[1][0][2:], ["속도"], [{"폭": lab(x)} for x in T[1][0][0][1:]], "운반능력")
jaw = []
for row in grid(T[2][0][2:], ["출구간격"], [{"규격": x} for x in T[2][0][0][1:]], "생산능력"):
low, high = row.pop("생산능력")
jaw.append({**row, "아래": low, "위": high})
def ratio(t):
return grid(t[2:], ["골재크기"], [{"출구간격": lab(x)} for x in t[1][1:]], "비율")
roll_t = T[6][0]
specs = roll_t[0][2:]
roll_spec = [
{"규격": s, "최대출구간격": N(a), "상용출구간격": N(b)}
for s, a, b in zip(specs, roll_t[1][2:], roll_t[2][2:])
]
roll = []
for r in roll_t[3:]:
for s, c in zip(specs, r[2:]):
row = {"출구간격": lab(r[0]), "규격": s}
if put(row, "생산능력", c):
roll.append(row)
screen = grid(
T[7][0][2:], ["체규격"], heads(("조합방법", ["1회통과식", "재투입식"])), "통과능력"
)
eff = T[8][0][3:]
a = [{"택의 수": lab(r[0]), "계수": N(r[1])} for r in eff if r[0]]
b = [{"골재량": lab(r[2]), "계수": N(r[3])} for r in eff if r[2]]
c = [{"스크린규격": lab(r[4]), "계수": N(r[5])} for r in eff if r[4]]
d = [{"골재량": lab(r[6]), "계수": N(r[7])} for r in eff if r[6]]
kinds = [x.strip() for x in re.split(r"(?=\d\. )", eff[0][8]) if x.strip()]
e = [{"재료분석": k, "계수": N(v)} for k, v in zip(kinds, eff[0][9].split())]
assert len(e) == 4
mob_t = T[9][0]
outs = mob_t[1][2:10]
mob, mob_spec = [], []
for r in mob_t[2:]:
mob_spec.append(
{"규격": lab(r[0]), "입구간격": re.sub(r"×\s*", "×", r[1]), "출력": N(r[10])}
)
for o, cval in zip(outs, r[2:10]):
row = {"규격": lab(r[0]), "출구간격": lab(o)}
if put(row, "생산능력", cval):
mob.append(row)
mob_e = [{"작업조건": k, "E": N(v)} for k, v in zip(T[10][0][0], T[10][0][1])]
roll_note = T[6][1]
roll_e = []
for k in LEVEL:
m = next(re.search(rf"{k} : 효율 (\d+)%", x) for x in S if re.search(rf"{k} : 효율", x))
roll_e.append({"작업조건": k, "효율": N(m[1])})
s = "1 마 별표4"
return [
tb(
no,
"벨트",
"벨트컨베이어 운반능력",
"1 가",
["폭"],
{"운반능력": "ton/hr"},
belt,
note=T[0][1],
base="폭 ㎜",
),
tb(
no,
"피더",
"에이프런 피더 운반능력",
"1 나",
["속도", "폭"],
{"운반능력": "ton/hr"},
apron,
note=T[1][1],
base="속도 m/min · 폭 ㎜",
),
tb(
no,
"죠",
"죠 크러셔 생산능력",
"1 다",
["출구간격", "규격"],
{"아래": "ton/hr", "위": "ton/hr"},
jaw,
note=T[2][1],
base="출구간격 ㎜",
memo="원문 범위 「a∼b」 를 아래 · 위 두 칸으로 폄(주④ 양호 = 최대치 · 보통 = 평균치 · 불량 = 최소치)",
),
tb(
no,
"별표1",
"1회 통과시 크러셔의 골재크기에 따르는 생산량 비율",
"1 다 별표1",
["골재크기", "출구간격"],
{"비율": "%"},
ratio(T[3][0]),
base="골재크기 · 출구간격 ㎜",
),
tb(
no,
"별표2",
"재투입식 죠 크러셔의 골재크기에 따르는 생산량 비율",
"1 다 별표2",
["골재크기", "출구간격"],
{"비율": "%"},
ratio(T[4][0]),
base="골재크기 · 출구간격 ㎜",
),
tb(
no,
"별표3",
"롤 크러셔의 골재크기에 따르는 생산량 비율",
"1 라 별표3",
["골재크기", "출구간격"],
{"비율": "%"},
ratio(T[5][0]),
base="골재크기 · 출구간격 ㎜",
),
tb(
no,
"롤규격",
"롤 크러셔 규격별 출구간격",
"1 라",
["규격"],
{"최대출구간격": "㎝", "상용출구간격": "㎝"},
roll_spec,
),
tb(
no,
"롤",
"롤 크러셔의 생산능력",
"1 라",
["출구간격", "규격"],
{"생산능력": "ton/hr"},
roll,
note=roll_note,
base="출구간격 ㎜",
),
tb(no, "롤효율", "롤 크러셔 작업효율", "1 라 주③", ["작업조건"], {"효율": "%"}, roll_e),
tb(
no,
"스크린",
"스크린 통과능력",
"1 마",
["체규격", "조합방법"],
{"통과능력": "ton/hr"},
screen,
note=T[7][1],
base="930㎠당 · 체의 규격 ㎜",
),
tb(no, "계수A", "스크린의 효율 — 계수 A(스크린택의 수)", s, ["택의 수"], {"계수": ""}, a),
tb(
no,
"계수B",
"스크린의 효율 — 계수 B(스크린규격 1/2보다 작은 골재의 양)",
s,
["골재량"],
{"계수": ""},
b,
base="골재량 %",
),
tb(
no,
"계수C",
"스크린의 효율 — 계수 C(돌을 직접 분사할 때 스크린의 규격)",
s,
["스크린규격"],
{"계수": ""},
c,
base="스크린규격 ㎜",
),
tb(
no,
"계수D",
"스크린의 효율 — 계수 D(스크린 규격보다 큰 골재의 양)",
s,
["골재량"],
{"계수": ""},
d,
base="골재량 %",
),
tb(no, "계수E", "스크린의 효율 — 계수 E(재료의 종류)", s, ["재료분석"], {"계수": ""}, e),
tb(
no,
"이동식",
"이동식 크러셔 생산능력",
"2",
["규격", "출구간격"],
{"생산능력": "ton/hr"},
mob,
base="규격 ton · 출구간격 ㎜",
memo="괄호 값은 원문 칸(「(57)」 등)",
),
tb(
no,
"이동식규격",
"이동식 크러셔 입구간격 · 출력",
"2",
["규격"],
{"입구간격": "㎜", "출력": "㎾"},
mob_spec,
),
tb(
no,
"이동식효율",
"이동식 크러셔 작업효율",
"2 주③",
["작업조건"],
{"E": ""},
mob_e,
note=T[9][1],
),
]
# ── 8-2-14 · 16 · 17 · 20 · 11 처럼 글 속 상수만 ────────────────────
def s14():
S = section("8-2-14")
return [
const("8-2-14", S, [("작업능력(q)", "3.26", "㎥/hr"), ("작업효율(E)", "0.95", "")], src="2")
]
def s16():
S = section("8-2-16")
return [
const(
"8-2-16",
S,
[("시간당 표준작업량(q)", "62.5", "㎥/hr"), ("작업효율(E)", "0.8", "")],
src="2",
)
]
def s17():
S = section("8-2-17")
return [
const(
"8-2-17", S, [("재료투입 혼합배출 등 작업시간", "4", "분"), ("작업효율(E)", "0.8", "")]
)
]
def s20():
S = section("8-2-20")
return [
const(
"8-2-20",
S,
[
("입환소요시간(t1)", "5", "분"),
("적재 적하 소요시간(t2) — 토사류", "17", "분"),
("적재 적하 소요시간(t2) — 석재류", "20", "분"),
("적재시 주행속도(V1)", "140", "m/분"),
("공차시 주행속도(V2)", "200", "m/분"),
("1회 운반시 대차수(n) — 5t", "12", "대"),
("1회 운반시 대차수(n) — 7t", "15", "대"),
],
)
]
# ── 8-2-18 콘크리트 배치플랜트 · 8-2-19 콘크리트 운반 ───────────────
def s18():
no, S = "8-2-18", section("8-2-18")
T = tables(S)
q = []
for r in T[0][0][1:]:
for spec, c in zip(T[0][0][0][2:], r[2:]):
row = {"규격": spec, "슬럼프": r[1]}
if put(row, "실용량", c):
q.append(row)
return [
tb(no, "q", "믹서의 실용량(q)", "1", ["규격", "슬럼프"], {"실용량": "㎥"}, q),
tb(
no,
"E",
"작업효율(E)",
"2",
["현장조건", "공종"],
{"E": ""},
grid(
T[1][0][2:],
["현장조건"],
heads(("공종", ["도로포장", "교량", "터널", "사방"])),
"E",
),
note=T[1][1],
),
const(
no,
S,
[
("1회 싸이클시간(cm)", "1.5", "분"),
("1회 싸이클시간 — 터널 숏크리트 강섬유 혼합", "2.5", "분"),
("작업효율 — 터널 숏크리트 현장조건 매우 불량", "0.40", ""),
],
),
]
def s19():
no, S = "8-2-19", section("8-2-19")
T = tables(S)
w = [
{"규격": N(h.removesuffix(" 톤")), "W": N(v)}
for h, v in zip(T[0][0][0][1:], T[0][0][1][1:])
]
run = [
{"구분": "표준치", "식": "cm1=3L+5", "기울기": N("3"), "절편": N("5")},
{"구분": "범위", "식": "±5", "비고": T[1][0][1][2]},
{"구분": "적용 거리", "비고": T[1][0][2][2], "최대거리": N("15")},
]
assert T[1][0][0][1] == "cm1=3L+5" and T[1][0][1][1] == "±5"
return [
tb(no, "W", "덤프트럭 적재량(W)", "2 가", ["규격"], {"W": "㎥"}, w, base="규격 톤"),
tb(
no,
"주행",
"덤프트럭 주행시간(cm1)",
"2 나",
["구분"],
{"식": "", "기울기": "분/km", "절편": "분", "비고": "", "최대거리": "km"},
run,
memo="cm1 = 3L + 5 (L = 편도운반거리 km · 15km까지)",
),
const(
no,
S,
[
("믹서트럭 배출시간 — 슬럼프 4㎝ 이하", "3", "분", "4"),
("믹서트럭 배출시간 — 슬럼프 5㎝ 이상", "2", "분", "3"),
("믹서트럭 배출시간 — 콘크리트 펌프 조합 가산", "10", "분", "10"),
("믹서트럭 대기시간(t4)", "5", "분", "10"),
("덤프트럭 하역시간(t1)", "1", "분", "2"),
("덤프트럭 대기시간(t2)", "5", "분", "10"),
("작업효율(E)", "0.95", "", "0.95"),
],
memo="원문 범위 「a∼b」 = 아래 · 위 · 한 값은 두 칸이 같음",
),
]
SECTIONS = [s2, s4, s6, s7, s10, s11, s12, s14, s16, s17, s18, s19, s20]
resources/master_data/scripts/_건설기계_표2.py
+626
View File
@@ -0,0 +1,626 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-2 시공능력 — 계수 표 · 8-2-22 ~ 8-2-33(파일 해머 · 준설선 등).
`_건설기계_표.py` 와 같은 꼴 · `build_로직_건설품셈_08장_건설기계.py` 가 부름.
"""
from __future__ import annotations
import re
from _건설기계_읽기 import N, grid, heads, lab, plain, put, section, tables
from _건설기계_표 import LEVEL, const, tb
CREW = {"인원": "인/일"}
def crew(no, t, src):
"""배치인원 (인/일) 한 줄 표 → 직종마다 줄."""
rows = []
for k, v in zip(t[0][0], t[0][1]):
row = {"직종": k}
put(row, "인원", v)
rows.append(row)
return tb(no, "배치인원", "배치인원", src, ["직종"], CREW, rows, note=t[1])
def pair(no, short, name, src, t, key, col, unit="", **kw):
"""머리 줄(이름들) · 값 줄 둘(또는 「계수」 줄 낀 셋)로 된 표 → 이름마다 줄."""
names, values = t[0][0][1:], t[0][-1][1:]
rows = []
for k, v in zip(names, values):
row = {key: lab(k)}
if put(row, col, v):
rows.append(row)
kw.setdefault("base", t[0][-1][0]) # 값 줄 머리(「α」 · 「E_1」 · 「Te(분)」)
return tb(no, short, name, src, [key], {col: unit}, rows, note=t[1], **kw)
def wide(t):
"""머리 칸 없는 두 줄 표(「| 항타 | 항발 |」 · 「| 10 | 6 |」) → `pair` 꼴."""
return [[""] + t[0][0], [""] + t[0][1]], t[1]
def fix(no, short, src, t, n):
"""작업조건에 따른 보정계수 f_1 ~ f_n — 보정치(-0.05 · 0 · +0.05)마다 상태 · 적요."""
rows = []
for r in t[0][2 : 2 + n]:
for level, c in zip(("-0.05", "0", "0.05"), r[2:5]):
if c not in ("", "-"):
rows.append({"보정": r[0], "조건": r[1], "보정치": N(level), "상태": c})
if r[5]:
rows.append({"보정": r[0], "조건": r[1], "적요": r[5]})
return tb(
no,
short,
"작업조건에 따른 보정계수(f)",
src,
["보정", "조건", "보정치"],
{"상태": "", "적요": ""},
rows,
note=t[1],
memo="보정치 = 작업계수 F 에 더함(+0.05 = 0.05)",
)
# ── 8-2-22 디젤 파일 해머 ──────────────────────────────────────────
def s22():
no, S = "8-2-22", section("8-2-22")
T = tables(S)
weld = lambda t: grid(t[0][2:], ["파일경"], [{"관두께": lab(x)} for x in t[0][1][1:]], "시간") # noqa: E731
rows_weld_rod = grid(
T[8][0][2:], ["파일경"], [{"관두께": lab(x)} for x in T[8][0][1][1:]], "소요량"
)
rows_power = grid(T[9][0][2:], ["파일경"], [{"관두께": lab(x)} for x in T[9][0][1][1:]], "전력")
return [
pair(no, "α", "토질계수(α)", "1 가 (1)", T[0], "토질", "α"),
tb(
no,
"β강관",
"해머 계수(β) — 강관파일",
"1 가 (2)",
["파일경", "해머"],
{"β": ""},
grid(T[1][0][2:], ["파일경"], [{"해머": x} for x in T[1][0][1][1:]], "β"),
base="파일경 ㎜",
),
tb(
no,
"N치",
"토질별 N치",
"1 가 (3) 주",
["구분", "상태"],
{"N치": ""},
plain(T[2][0][2:], ["구분", "상태", "N치"], keys=2),
),
pair(
no, "Te강관", "급유 점검 등의 기타시간(Te) — 강관파일", "1 라", T[3], "해머", "Te", "분"
),
tb(
no,
"F",
"작업계수(F)",
"1 마",
["평탄성", "현장"],
{"F": ""},
plain(T[4][0][2:], ["평탄성", "현장", "F"], keys=2),
note=T[4][1],
),
tb(
no,
"용접반자동",
"반자동 아크 용접기 용접이음 개소당 용접시간",
"1 바 (1)",
["파일경", "관두께"],
{"시간": "분"},
weld(T[5]),
note=T[5][1],
base="파일경 · 관두께 ㎜",
),
tb(
no,
"용접수동",
"수동아크용접기 용접이음 1개소당 용접시간",
"1 바 (2)",
["파일경", "관두께"],
{"시간": "분"},
weld(T[6]),
note=T[6][1],
base="파일경 · 관두께 ㎜",
),
tb(
no,
"용접기",
"파일해머와 용접기의 조합",
"1 바 (3)",
["기계명"],
{"규격": "", "대수": "", "비고": ""},
plain(T[7][0][1:], ["기계명", "규격", "대수", "비고"]),
),
tb(
no,
"용접봉",
"수동아크 용접기 용접이음 1개소당 용접봉 소요량",
"1 바 (4)",
["파일경", "관두께"],
{"소요량": "㎏"},
rows_weld_rod,
base="파일경 · 관두께 ㎜",
),
tb(
no,
"용접전력",
"용접이음 1개소당 전력 소비량",
"1 바 (5)",
["파일경", "관두께"],
{"전력": "㎾/h"},
rows_power,
base="파일경 · 관두께 ㎜",
),
tb(
no,
"β콘크리트",
"해머의 계수(β) — 콘크리트 파일",
"2 가",
["해머", "파일경"],
{"β": ""},
grid(T[10][0][2:], ["해머"], [{"파일경": lab(x)} for x in T[10][0][0][1:]], "β"),
base="파일경 ㎜",
),
pair(
no,
"Te콘크리트",
"점검 및 급유 등 기타 시간(Te) — 콘크리트 파일",
"2 라",
T[11],
"해머",
"Te",
"분",
),
pair(no, "크레인", "파일해머와 크레인의 조합", "3", T[12], "해머", "크레인규격"),
crew(no, T[13], "4"),
const(
no,
S,
[
("타격시간 계수 — 강관파일", "0.05", ""),
("타격시간 계수 — 콘크리트 파일", "0.08", ""),
("세우기 및 위치조정 — 강관파일", "7", "분/회"),
("세우기 및 위치조정 — 콘크리트 파일 250·300㎜", "3", "분/회"),
("세우기 및 위치조정 — 콘크리트 파일 350∼500㎜", "5", "분/회"),
("크롤러식 항타기 자주 표준주행속도(V)", "2.5", "m/min"),
("이동 및 준비시간 — 콘크리트 파일", "3", "분"),
("평균 N치 아래끝(1이하는 1)", "1", ""),
],
memo="Tb = 계수 × α × β × L × (N + 2) · Ts = 분/회 × Ns · Tt = (a + LS(S−1)/n) / V",
),
]
# ── 8-2-23 유압 파일 해머 ──────────────────────────────────────────
def s23():
no, S = "8-2-23", section("8-2-23")
T = tables(S)
def two(t, key, cols, name):
return grid(t[0][2:], [key], [{cols: x} for x in t[0][1][1:]], name)
return [
pair(no, "α강관", "토질계수(α) — 강관파일", "1 가 (1)", T[0], "N치", "α"),
tb(
no,
"β",
"판두께계수(β)",
"1 가 (2)",
["항타길이", "판두께"],
{"β": ""},
two(T[1], "항타길이", "판두께", "β"),
base="항타길이 m · 판두께 ㎜",
),
tb(
no,
"Ta강관",
"파일규격에 따른 시공시간(Ta) — 강관파일",
"1 가 (3)",
["항타길이", "파일경"],
{"Ta": "분/본"},
two(T[2], "항타길이", "파일경", "Ta"),
note=T[2][1],
base="항타길이 m · 파일경 ㎜",
),
pair(no, "α콘크리트", "토질계수(α) — 콘크리트 파일", "1 나 (1)", T[3], "N치", "α"),
tb(
no,
"Ta콘크리트",
"파일규격에 따른 시공시간(Ta) — 콘크리트 파일",
"1 나 (2)",
["항타길이", "파일경"],
{"Ta": "분/본"},
two(T[4], "항타길이", "파일경", "Ta"),
note=T[4][1],
base="항타길이 m · 파일경 ㎜",
),
pair(no, "크레인", "파일해머와 크레인의 조합", "3", T[5], "해머", "크레인규격"),
crew(no, T[6], "4"),
pair(
no,
"제잡비율",
"잡재료 등 손료 — 직접노무비 대비 상한 비율",
"5",
T[7],
"구분",
"제잡비율",
"%",
),
tb(
no,
"장비",
"장비조합",
"6",
["장비"],
{"규격": "", "수량": "대", "작업시간": "", "비고": ""},
plain(T[8][0][1:], ["장비", "규격", "수량", "작업시간", "비고"]),
),
]
# ── 8-2-24 진동파일 해머 ───────────────────────────────────────────
def s24():
no, S = "8-2-24", section("8-2-24")
T = tables(S)
r_t = T[1][0]
r = []
for soil, slope in zip(r_t[0][1:], r_t[2][1:]):
m = re.fullmatch(r"([\d.]+)N_\d\+([\d.]+)", slope)
r.append({"공종": "항타", "토질": soil, "식": slope, "기울기": N(m[1]), "절편": N(m[2])})
for soil, v in zip(r_t[0][1:], r_t[3][1:]):
r.append({"공종": "항발", "토질": soil, "r": N(v)})
sheet = T[8][0]
ak, gamma, kind = [], [], ""
for row in sheet[3:]:
kind = row[0] or kind
if kind == "γ":
gamma.append({"작업": row[1], "γ": N(row[3])})
continue
for i, kw in enumerate(("30", "45", "60", "162")):
out = {"종류": kind, "작업": row[1], "해머": N(kw)}
got = put(out, "α", row[2 + 2 * i])
got = put(out, "K", row[3 + 2 * i]) or got
if got:
ak.append(out)
combo = T[11][0]
return [
pair(no, "Ts", "파일 1본당 준비시간(Ts) — H파일", "1 가", wide(T[0]), "작업", "Ts", "분"),
tb(
no,
"r",
"토질별 항타 또는 항발시간(r)",
"1 나 (1)",
["공종", "토질"],
{"식": "", "기울기": "분/m", "절편": "분/m", "r": "분/m"},
r,
memo="항타 r = 기울기 × N + 절편(원문 식 칸 그대로)",
),
tb(
no,
"k",
"해머계수(k) — H파일",
"1 나 (2)",
["작업", "파일"],
{"k": ""},
grid(T[2][0][2:], ["작업"], heads(("파일", T[2][0][0][1:])), "k"),
),
pair(no, "F0", "작업계수 F_0 — H파일", "1 다 (1)", wide(T[3]), "작업", "F0"),
fix(no, "f", "1 다 (2)", T[4], 4),
tb(
no,
"조합",
"진동해머 · 크레인(무한궤도) · 발전기의 조합 — H파일",
"1 라",
["해머"],
{"크레인": "톤", "전력": "KVA", "발전기": "", "비고": ""},
plain(T[5][0][2:], ["해머", "크레인", "전력", "발전기", "비고"]),
note=T[5][1],
base="진동파일해머 ㎾",
),
tb(
no,
"선정",
"진동파일해머 선정 — H파일",
"1 마",
["규격"],
{"항타": "", "항발": ""},
plain(T[6][0][1:], ["규격", "항타", "항발"]),
),
crew(no, T[7], "1 바"),
tb(
no,
"αK",
"강널말뚝 정수 α · 계수 K",
"2 나 (1)",
["종류", "작업", "해머"],
{"α": "", "K": ""},
ak,
base="해머 = 진동파일해머 ㎾(162 = 유압식)",
),
tb(no, "γ", "강널말뚝 계수 γ", "2 나 (1)", ["작업"], {"γ": ""}, gamma),
pair(no, "F0널", "작업계수 F_0 — 강널말뚝", "2 나 (2)", T[9], "작업", "F0"),
fix(no, "f널", "2 나 (2)", T[10], 3),
tb(
no,
"조합널",
"진동해머 · 크레인 · 발전기의 조합 — 강널말뚝",
"2 다",
["기종", "해머"],
{"규격": ""},
grid(
combo[2:],
["기종"],
[{"해머": lab(x.removesuffix("㎾"))} for x in combo[1][1:]],
"규격",
),
base="해머 ㎾",
),
tb(
no,
"선정전동",
"진동 파일 해머 선정 — 항타 전동식",
"2 라 (1) (가)",
["토질", "규격"],
{"항타": "", "비고": ""},
plain(T[12][0][1:], ["토질", "규격", "항타", "비고"], keys=2),
),
tb(
no,
"선정유압",
"진동 파일 해머 선정 — 항타 유압식",
"2 라 (1) (나)",
["토질", "규격"],
{"항타": "", "비고": ""},
plain(T[13][0][1:], ["토질", "규격", "항타", "비고"], keys=2),
),
tb(
no,
"선정인발",
"진동 파일 해머 선정 — 항발시",
"2 라 (2)",
["종류"],
{"전동 인발길이": "", "전동 규격": "㎾", "유압 인발길이": "", "유압 규격": "㎾"},
plain(
T[14][0][2:], ["종류", "전동 인발길이", "전동 규격", "유압 인발길이", "유압 규격"]
),
),
crew(no, T[15], "2 마") | {"열쇠": f"공통 {no} 배치인원널", "이름": "배치인원 — 강널말뚝"},
const(
no,
S,
[("강널말뚝 시공시간 상수", "0.75", "")],
memo="Tc = {(0.75 + γ × Nmax) × ℓ + α} × K / F",
),
]
# ── 8-2-25 진동파일해머(워터제트 병용 압입공) ─────────────────────
def s25():
no, S = "8-2-25", section("8-2-25")
T = tables(S)
combo = []
for r in T[5][0][2:]:
hammer = lab(r[1].replace(" ", "").removesuffix("㎾"))
for length, c in ((T[5][0][1][2], r[2]), (T[5][0][1][3], r[3])):
combo.append({"해머": hammer, "길이": length, "크레인": N(c)})
row = {"해머": hammer}
put(row, "발전기", r[4])
put(row, "전기용접기", r[5])
combo.append(row)
return [
tb(no, "α", "토질계수(α)", "2 나", ["토질"], {"α": ""}, plain(T[0][0][1:], ["토질", "α"])),
pair(no, "F0", "작업계수 F_0", "2 다 (1)", T[1], "구분", "F0"),
fix(no, "f", "2 다 (2)", T[2], 4),
tb(
no,
"선정",
"진동파일해머 선정",
"3 가",
["토질", "규격"],
{"파일연장": "m", "최대N치": "", "비고": ""},
plain(T[3][0][1:], ["토질", "규격", "파일연장", "최대N치", "비고"], keys=2),
),
tb(
no,
"펌프",
"워터젯트 펌프선정",
"3 나",
["토질", "규격"],
{"대상토질": "", "비고": ""},
plain(T[4][0][1:], ["토질", "규격", "대상토질", "비고"], keys=2),
),
tb(
no,
"조합",
"진동해머 · 크레인(무한궤도) · 발전기의 조합",
"3 다",
["해머", "길이"],
{"크레인": "톤", "발전기": "", "전기용접기": ""},
combo,
base="해머 ㎾ · 길이 = 파일 L(m)",
),
tb(
no,
"수조",
"수중 펌프 및 수조선정",
"3 라",
["워터젯트", "대수"],
{"수중펌프": "", "수조": "㎥", "비고": ""},
plain(T[6][0][1:], ["워터젯트", "대수", "수중펌프", "수조", "비고"], keys=2),
),
crew(no, T[7], "4"),
const(
no,
S,
[
("기본시공시간 계수", "0.05", ""),
("기본시공시간 N 가산", "42.5", ""),
("기본시공시간 상수", "9.6", "분"),
("배관계 부재 손료 — 항타기 대비", "9", "%"),
],
memo="To = 0.05 × L × (N + 42.5) + 9.6",
),
]
# ── 8-2-26 유압식 압입 인발기 ──────────────────────────────────────
def s26():
no, S = "8-2-26", section("8-2-26")
T = tables(S)
return [
tb(
no,
"k",
"기종 · 규격에 의한 계수(k)",
"2 나 (2)",
["규격"],
{"k": ""},
plain(T[0][0][1:], ["규격", "k"]),
),
fix(no, "f", "2 다", T[1], 3),
tb(
no,
"조합",
"압입 인발기 · 발전기의 조합",
"3",
["기종"],
{"규격": ""},
plain(T[2][0][1:], ["기종", "규격"]),
),
tb(
no,
"선정",
"압입 인발기 선정",
"4",
["규격"],
{"압입": "", "인발": ""},
plain(T[3][0][1:], ["규격", "압입", "인발"]),
),
crew(no, T[4], "5"),
tb(
no,
"설치",
"유압식 말뚝 압입 인발기 설치 · 해체",
"6 나",
["작업", "항목", "조건"],
{
"설치해체시간": "시간",
"압입항타기": "시간",
"트럭크레인": "시간",
"발동발전기": "시간",
},
plain(
T[5][0][2:],
["작업", "항목", "조건", "설치해체시간", "압입항타기", "트럭크레인", "발동발전기"],
fill=2,
keys=3,
),
base="대당 · 회당",
),
const(
no,
S,
[
("준비시간 계수(L당)", "0.52", "분/m"),
("준비시간 상수", "5.12", "분"),
("압입 단위 작업시간 계수(Nmax당)", "0.035", ""),
("압입 단위 작업시간 상수", "1.02", ""),
("인발 시간 계수(ℓ당)", "1.10", "분/m"),
("인발 시간 상수", "4.76", "분"),
("작업계수 기본값", "1.0", ""),
],
memo="압입 Tc = (Ts + Tb)/F · Ts = 0.52L + 5.12 · Tb = γ × ℓ × k · γ = 0.035Nmax + 1.02 · 인발 Tc = (1.10ℓ + 4.76)/F · F = 1.0 + (f1+f2+f3)",
),
]
# ── 8-2-27 수중펌프 ─────────────────────────────────────────────────
def s27():
no, S = "8-2-27", section("8-2-27")
T = tables(S)
op = grid(
T[1][0][2:],
["펌프"],
heads(("배수방법", ["작업시배수", "상시배수"]), ("전원", ["상용전원", "발전기"])),
"운전공",
)
mat = [
{**h, "비율": N(v)}
for h, v in zip(
heads(("배수방법", ["작업시배수", "상시배수"]), ("전원", ["상용전원", "발전기"])),
T[2][0][2],
)
]
return [
tb(
no,
"선정",
"펌프의 선정",
"1",
["기종", "구경"],
{"양정": "m", "전동기출력": ""},
plain(T[0][0][2:], ["기종", "구경", "양정", "전동기출력"], keys=2),
base="구경 ㎜",
),
tb(
no,
"운전공",
"펌프 운전공",
"2",
["펌프", "배수방법", "전원"],
{"운전공": "인/1개소･일"},
op,
),
tb(
no,
"잡재료",
"잡재료 비율",
"4",
["배수방법", "전원"],
{"비율": "%"},
mat,
memo="잡재료비 = 노무비, 기계손료 및 운전경비의 합 × 잡재료비율",
),
tb(
no,
"설치",
"펌프설치 및 해체(1개소당)",
"5",
["명칭"],
{"수량": "인"},
plain(T[3][0][1:], ["명칭", "단위", "수량"]),
),
const(
no,
S,
[("전력소비 — 작업시 배수", "8", "시간"), ("전력소비 — 상시배수", "24", "시간")],
src="3",
),
]
# ── 8-2-28 TBM ──────────────────────────────────────────────────────
def s28():
no, S = "8-2-28", section("8-2-28")
T = tables(S)
return [
tb(
no,
"E",
"작업효율(E)",
"3",
["구분", "현장조건"],
{"E": ""},
grid(T[0][0][1:], ["구분"], heads(("현장조건", LEVEL)), "E"),
),
const(no, S, [("1회의 작업거리(ℓ) — ø4.5m", "1.2", "m"), ("정치시간(T2)", "10", "분")]),
]
SECTIONS = [s22, s23, s24, s25, s26, s27, s28]
resources/master_data/scripts/_건설기계_표3.py
+308
View File
@@ -0,0 +1,308 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-2 시공능력 — 계수 표 · 8-2-29 ~ 8-2-33(준설선 · 쇄암선 · 임목파쇄기 · 골재채취선).
`_건설기계_표.py` 와 같은 꼴 · `build_로직_건설품셈_08장_건설기계.py` 가 부름.
"""
from __future__ import annotations
from _건설기계_읽기 import N, grid, heads, lab, plain, section, tables
from _건설기계_표 import const, tb
from _건설기계_표2 import pair
# ── 8-2-29 펌프식 준설선 ───────────────────────────────────────────
def s29():
no, S = "8-2-29", section("8-2-29")
T = tables(S)
q = []
for t, _ in T[:8]:
q += grid(t[2:], ["토질", "N값"], [{"배송거리": lab(x)} for x in t[1][2:]], "q", fill=1)
limit = grid(
T[9][0][2:],
["토질", "N값"],
[{"출력": lab(x.removesuffix("㎾"))} for x in T[9][0][1][2:]],
"거리",
fill=1,
)
ex = T[10][0]
sample = [{"산정조건": ex[1][0], "q_1": ex[1][1], "q_2": ex[1][2], "q": ex[1][3]}]
out = [
tb(
no,
"q",
"전동환산 746㎾의 1시간당 준설능력(q)",
"2",
["토질", "N값", "배송거리"],
{"q": "㎥/hr"},
q,
base="배송거리 m",
memo="원문 동그라미 번호(계제선 ①∼⑥ 자리)는 q원문 칸",
),
tb(
no,
"계제선",
"계제선 적용표",
"2",
["공칭출력"],
{"전동환산출력": "㎾", "계제선": "", "비고": ""},
plain(T[8][0][2:], ["공칭출력", "전동환산출력", "계제선", "비고"]),
base="주기출력 ㎾",
),
tb(
no,
"한계",
"규격별 보정한계거리",
"3",
["토질", "N값", "출력"],
{"거리": "m"},
limit,
base="출력 = 전동환산 ㎾",
),
tb(
no,
"산정예",
"단거리 능력의 산정 예",
"3",
["산정조건"],
{"q_1": "", "q_2": "", "q": ""},
sample,
),
const(
no,
S,
[
("전동환산 기준 출력", "746", "㎾"),
("전동환산 — 디젤 공칭주기 출력 곱", "0.8", ""),
("전동환산 — 터빈 공칭주기 출력 곱", "0.9", ""),
],
memo="Q = q × bo × E / 746 · 단거리 q = (q1 + q2)/2",
),
]
names = {
11: ("E1", "흙의 두께에 따른 효율(E_1)", "4 가"),
13: ("E2", "평면형상에 따른 효율(E_2)", "4 나"),
15: ("E3", "단면형상에 따른 효율(E_3)", "4 다"),
17: ("E4", "해상조건에 따른 효율(E_4)", "4 라"),
}
for i, (short, name, src) in names.items():
out.append(pair(no, short, name, src, T[i], "구분", "E"))
out.append(
tb(
no,
short + "해설",
name.split("(")[0] + " 해설",
src,
["구분"],
{"적용 사항": ""},
plain(T[i + 1][0][1:], ["구분", "적용 사항"]),
)
)
return out
# ── 8-2-30 그래브 준설선 ───────────────────────────────────────────
def s30():
no, S = "8-2-30", section("8-2-30")
T = tables(S)
k = grid(
T[1][0][2:],
["분류", "상태", "N값"],
[{"버킷용량": lab(x.removesuffix("㎥"))} for x in T[1][0][1][3:]],
"k",
fill=1,
)
cm = [{"버킷용량": lab(b), "싸이클시간": N(v)} for b, v in zip(T[2][0][1][1:], T[2][0][2][1:])]
return [
tb(
no,
"f",
"체적환산계수(f)",
"1",
["분류", "상태", "N값"],
{"f": ""},
plain(T[0][0][2:], ["분류", "상태", "N값", "f"], keys=3),
note=T[0][1],
memo="괄호 값 = 쇄암 또는 발파후의 준설(f원문 칸)",
),
tb(
no,
"k",
"버킷계수(k)",
"2",
["분류", "상태", "N값", "버킷용량"],
{"k": ""},
k,
base="버킷용량 ㎥",
memo="원문 표 셋째 묶음 「점토질 토사」 연질 30이하 · 경질 30이상 은 원문 글 그대로(N값으로 갈림)",
),
tb(
no,
"cm",
"1회 싸이클시간(cm)",
"3",
["버킷용량"],
{"싸이클시간": "초"},
cm,
note=T[2][1],
),
pair(no, "E1", "흙의 두께에 따른 효율(E_1)", "4 가", T[3], "구분", "E"),
tb(
no,
"E1해설",
"흙의 두께 해설",
"4 가",
["구분"],
{"적용 사항": ""},
plain(T[4][0][1:], ["구분", "적용 사항"]),
),
pair(no, "E2", "해상조건에 따른 효율(E_2)", "4 나", T[5], "구분", "E"),
tb(
no,
"E2해설",
"해상조건 해설",
"4 나",
["구분"],
{"적용 사항": ""},
plain(T[6][0][1:], ["구분", "적용 사항"]),
),
const(
no,
S,
[("기준 수심", "10", "m"), ("수심 1m 증감당 싸이클시간 증감", "2", "초")],
src="3",
),
]
# ── 8-2-31 쇄암선 ───────────────────────────────────────────────────
def s31():
no, S = "8-2-31", section("8-2-31")
T = tables(S)
s_rows = grid(
T[0][0][2:], ["분류", "상태"], [{"중추중량": lab(x)} for x in T[0][0][1][2:]], "S", fill=1
)
n_rows = grid(
T[1][0][2:],
["분류", "상태", "쇄암장"],
[{"중추중량": lab(x)} for x in T[1][0][1][3:]],
"n",
fill=1,
)
return [
tb(
no,
"S",
"1본당 쇄암면적(S)",
"1",
["분류", "상태", "중추중량"],
{"S": "㎡"},
s_rows,
base="중추중량 ton",
),
tb(
no,
"n",
"1층 쇄암하는데 필요한 낙추횟수(n)",
"2",
["분류", "상태", "쇄암장", "중추중량"],
{"n": "회"},
n_rows,
base="쇄암장 m · 중추중량 ton",
),
const(
no,
S,
[
("1층 쇄암 깊이(d)", "1", "m"),
("쇄암위치 이동 소요시간(t)", "1", "분"),
("중추의 1분당 낙추횟수(P)", "2", "회/min"),
],
),
]
# ── 8-2-32 이동식 임목파쇄기 ────────────────────────────────────────
def s32():
no, S = "8-2-32", section("8-2-32")
T = tables(S)
return [
tb(
no,
"소모93",
"소모품 소모량 — 93.25㎾",
"1 나",
["소모품"],
{"소모율": "개/hr", "비고": ""},
plain(T[0][0][1:], ["소모품", "소모율", "비고"]),
),
pair(no, "K", "규격별 능력계수(K)", "2 다", T[1], "규격", "K"),
pair(no, "S", "스크린계수(S)", "2 라", T[2], "스크린", "S"),
pair(no, "E", "작업효율(E)", "2 마", T[3], "작업조건", "E"),
tb(
no,
"소모354",
"소모품 소모량 — 354.35 ∼ 402.84㎾",
"2 바",
["소모품"],
{"규격": "", "소모율": "개/hr", "비고": ""},
plain(T[4][0][1:], ["소모품", "규격", "소모율", "비고"]),
),
const(
no,
S,
[
("93.25㎾ 작업량(Q)", "6.0", "㎥/hr"),
("354.35㎾ 시간당 표준파쇄량(q)", "26", "㎥/hr"),
],
),
]
# ── 8-2-33 하천골재채취선 ───────────────────────────────────────────
def s33():
no, S = "8-2-33", section("8-2-33")
T = tables(S)
q = grid(
T[0][0][1:],
["분류", "상태", "N치"],
[{"배송거리": lab(x)} for x in T[0][0][0][3:]],
"q",
fill=1,
)
return [
tb(
no,
"q",
"하천골재채취선 746㎾의 시간당 준설량(q)",
"2",
["분류", "상태", "N치", "배송거리"],
{"q": "㎥/hr"},
q,
base="배송거리 m",
),
tb(
no,
"E",
"작업효율(E)",
"3",
["조건", "유속"],
{"E": ""},
grid(T[1][0][2:], ["조건"], heads(("유속", ["느림", "보통", "빠름"])), "E"),
memo="조건 = 천후, 평면형상, 위치 등",
),
tb(
no,
"배사관",
"배사관 소모율(시간당)",
"4",
["분류", "자갈함유량"],
{"단위": "", "소모율": ""},
plain(T[2][0][1:], ["분류", "자갈함유량", "단위", "소모율"], keys=2),
note=T[2][1],
),
const(no, S, [("기준 출력", "746", "㎾")], memo="Q = q × b × E / 746"),
]
SECTIONS = [s29, s30, s31, s32, s33]
resources/master_data/scripts/build_로직_건설품셈_08장_건설기계.py
+211
View File
@@ -0,0 +1,211 @@
# -*- coding: utf-8 -*-
"""건설품셈 공통 8-1-4 · 8-2 시공능력 + 기계설비 13-2-7 — 계수 표 덧 · 로직 덧(782-3).
돌리기: ./venv/Scripts/python.exe resources/master_data/scripts/build_로직_건설품셈_08장_건설기계.py
- 원문 = 공통 `제08장_건설기계/8-02-NN_*.md` 절마다(머리 ~ 다음 같은 · 윗 머리 앞 · 요구 630) · 13-2-7 = 기계설비 13장.
- 계수 표(`_건설기계_표.py` · `_건설기계_표2.py`) = 절의 원문 md 표 전부 + 표 밖 글 속 상수 → `계수_건설품셈_08장_건설기계.json`
에 덧(기존 표 글자 그대로 · 절 차례 자리에 끼움).
- 로직(`_건설기계_로직*.py`) = 시간당 작업량 Q(원문 단위) · 주요 기계 작업량당 기계경비(시간당 경비 × 1/Q)
→ `로직_건설품셈_08장_건설기계.json` 끝에 덧 · 13-2-7 → `로직_건설품셈_13장_플랜트설비공사.json` 끝에 덧.
- 키 = `_키대장.json` 다음 번호(`master_keys.issue` — `adopt` 는 로직을 받지 않음) · 이미 넣었으면 멈춤(한 번 돌림).
"""
from __future__ import annotations
import json
import re
import sys
from decimal import Decimal
from pathlib import Path
HERE = Path(__file__).resolve().parent
MASTER = HERE.parent
sys.path.insert(0, str(HERE))
import _건설기계_로직 as L1 # noqa: E402
import _건설기계_로직2 as L2 # noqa: E402
import _건설기계_로직3 as L3 # noqa: E402
import _건설기계_로직_경비 as LC # noqa: E402
import _건설기계_읽기 as rd # noqa: E402
import _건설기계_표 as T1 # noqa: E402
import _건설기계_표2 as T2 # noqa: E402
import _건설기계_표3 as T3 # noqa: E402
import master_keys as mk # noqa: E402
COEF = "계수_건설품셈_08장_건설기계.json"
LOGIC = "로직_건설품셈_08장_건설기계.json"
LOGIC13 = "로직_건설품셈_13장_플랜트설비공사.json"
_REF = re.compile(r"\{([TL]):([^{}]+)\}")
def _sec(no: str) -> tuple[int, ...]:
return tuple(int(x) for x in no.split("-"))
def _load(name: str) -> dict:
return json.loads(
(MASTER / name).read_text(encoding="utf-8"), parse_float=Decimal, parse_int=Decimal
)
def _title(no: str) -> str:
head = rd.section(no)[0].removeprefix(f"### {no} ")
return re.sub(r"\(['‘]\d\d.*\)$", "", head).strip()
def chooser(made: list[dict], old: dict):
"""C(표, 칸) — 새 표는 「<절> <짧은 이름>」 · 있던 표는 키 · 값 차례대로 한 번씩(수는 Decimal)."""
def C(ref: str, col: str) -> list:
table = old.get(ref) or next(t for t in made if t["열쇠"] == f"공통 {ref}")
seen = []
for row in table["줄"]:
v = row.get(col)
if v is None:
continue
v = Decimal(v) if isinstance(v, rd.N) else v
if v not in seen:
seen.append(v)
return seen
return C
def fill(v, keys: dict):
"""식 글의 `{T:…}` · `{L:…}` → 키."""
if isinstance(v, str):
return _REF.sub(lambda m: keys[(m[1], m[2])], v)
if isinstance(v, list):
return [fill(x, keys) for x in v]
if isinstance(v, dict):
return {k: fill(x, keys) for k, x in v.items()}
return v
def order(row: dict) -> dict:
head = [
"키",
"원문번호",
"구분",
"상세구분",
"이름",
"결과단위",
"출처",
"소유",
"비고",
"시험입력",
"입력",
"중간",
"호표",
"덧줄",
"결과",
"끝수",
]
return {k: row[k] for k in head if k in row}
def rows_text(rows: list[dict]) -> str:
"""줄 목록만 로직 파일 글 모양으로 — 통째 dump 의 「줄」 칸 안쪽."""
whole = mk._store().dump({"줄": rows})
a = whole.index('"줄": [\n') + len('"줄": [\n')
return whole[a : whole.rindex("\n ]\n}")]
def append_rows(name: str, rows: list[dict]) -> None:
path = MASTER / name
text = path.read_text(encoding="utf-8")
at = text.rindex("\n ]\n}")
new = text[:at] + ",\n" + rows_text(rows) + text[at:]
old, got = json.loads(text), json.loads(new)
assert got["줄"][: len(old["줄"])] == old["줄"] and {
k: v for k, v in got.items() if k != "줄"
} == {k: v for k, v in old.items() if k != "줄"}
path.write_text(new, encoding="utf-8", newline="\n")
def insert_tables(text: str, made: list[dict]) -> str:
"""새 표 글을 절 차례 자리에 — 처음으로 절 번호가 더 큰 기존 표 앞(없으면 끝)."""
starts = [
(m.start(), m[1])
for m in re.finditer(r' \{\n "키": "CC\d+", "원문번호": "([^"]+)"', text)
]
pieces, last = [], 0
for at, no in starts:
due = [t for t in made if not t.get("_done") and _sec(t["원문번호"]) < _sec(no)]
if due and _sec(no) > (8, 1, 7):
pieces.append(text[last:at])
pieces.append("".join(rd.emit(t) + ",\n" for t in due))
for t in due:
t["_done"] = True
last = at
rest = [t for t in made if not t.get("_done")]
tail = text.rindex("\n ]\n}")
pieces.append(text[last:tail])
if rest:
pieces.append(",\n" + ",\n".join(rd.emit(t) for t in rest))
pieces.append(text[tail:])
for t in made:
t.pop("_done", None)
return "".join(pieces)
def main() -> None:
coef_text = (MASTER / COEF).read_text(encoding="utf-8")
if '"원문번호": "8-2-2"' in coef_text:
raise SystemExit("이미 넣음 — 멈춤")
book = mk.load_book()
made = [t for mod in (T1, T2, T3) for f in mod.SECTIONS for t in f()]
made.sort(key=lambda t: _sec(t["원문번호"])) # 같은 절은 만든 차례 그대로(안정 정렬)
keys = {}
for t in made:
t["키"] = mk.issue(book, "CC", t["열쇠"], COEF)
keys[("T", t["열쇠"].removeprefix("공통 "))] = t["키"]
t.update(rd.HEAD)
old_coef = {t["키"]: t for t in _load(COEF)["표"]}
C = chooser(made, old_coef)
rows = L1.part1(C) + L2.part2(C) + L3.part3(C)
q_rows = {r["열쇠"]: r for r in rows}
hourly = {r["키"]: r for r in _load(LOGIC)["줄"]}
machines: dict[str, list] = {}
for m in _load("기계.json")["줄"]:
machines.setdefault(m.get("상세구분"), []).append(m["원문번호"])
rows += LC.costs(q_rows, hourly, machines) + [LC.breaker(hourly)]
rows.sort(key=lambda r: _sec(r["원문번호"]))
for r in rows:
r["키"] = mk.issue(book, "GC", r["열쇠"], LOGIC)
keys[("L", r["열쇠"])] = r["키"]
rows = [order(fill({k: v for k, v in r.items() if k != "열쇠"}, keys)) for r in rows]
ace = LC.acetylene()
ace["키"] = mk.issue(book, "GC", ace.pop("열쇠"), LOGIC13)
for t in made: # 용도 — 그 표를 부르는 새 로직
uses = [r["키"] for r in rows if t["키"] in json.dumps(r, ensure_ascii=False, default=str)]
t["용도"] = {"공종": _title(t["원문번호"]), "대상": ["작업량 조건"], "로직키": uses}
t.pop("열쇠")
new_coef = insert_tables(coef_text, made)
data = json.loads(new_coef, parse_float=Decimal, parse_int=Decimal)
assert len(data["표"]) == len(old_coef) + len(made)
assert [t for t in data["표"] if t["키"] in old_coef] == list(_load(COEF)["표"])
(MASTER / COEF).write_text(new_coef, encoding="utf-8", newline="\n")
append_rows(LOGIC, rows)
append_rows(LOGIC13, [order(ace)])
mk.save_book(mk.finish(book))
print(
"계수",
made[0]["키"],
"~",
made[-1]["키"],
len(made),
"· 로직",
rows[0]["키"],
"~",
rows[-1]["키"],
len(rows),
"· 13-2-7",
ace["키"],
)
if __name__ == "__main__":
sys.stdout.reconfigure(encoding="utf-8")
main()
resources/master_data/계수_건설품셈_08장_건설기계.json
+14031
View File
File diff suppressed because it is too large Load Diff
resources/master_data/로직_건설품셈_08장_건설기계.json
+1884
View File
File diff suppressed because it is too large Load Diff
resources/master_data/로직_건설품셈_13장_플랜트설비공사.json
+16
View File
@@ -16544,6 +16544,22 @@
],
"덧줄": [],
"끝수": null
},
{
"키": "GC001191",
"원문번호": "13-2-7",
"구분": "건설품셈 기계설비",
"상세구분": "13장 플랜트설비공사",
"이름": "아세틸렌량의 환산(ℓ → ㎏)",
"결과단위": "㎏",
"출처": "건설품셈 기계설비 13-2-7",
"소유": "공용",
"비고": "아세틸렌(㎏) = 아세틸렌(ℓ) × 26g/22.4ℓ ÷ 1,000 · 26g = 1mol당 분자량 · 22.4ℓ = 표준상태 1mol당량",
"시험입력": { "아세틸렌부피": 1000 },
"입력": [{ "이름": "아세틸렌부피", "설명": "아세틸렌 부피", "단위": "ℓ", "출처": "건설품셈 기계설비 13-2-7" }],
"중간": [],
"결과": { "식": "아세틸렌부피 * 26 / 22.4 / 1000", "출처": "건설품셈 기계설비 13-2-7" },
"끝수": null
}
]
}