465 lines
18 KiB
Python
465 lines
18 KiB
Python
"""E06 절리 정본 꼴 · 검사 · 측점 해석 묶음 (요구 345 · 351 · PLAN 536-1).
|
||
|
||
정본 = `E06_StabRock/joints.json` · 초기값 = `initial_snapshot/E06_StabRock/joints.json`
|
||
(절리 없음 + 기본 설정 · 처음 GET 때 한 번). 절리군 한 줄 = 구간(from_m ~ to_m) · 경사방향 · 경사 ·
|
||
φj · cj · 지속성(선택). 측점 = 복사본 암 측점(리핑암 · 발파암)의 깎기 쪽만.
|
||
|
||
사면 = 측점 frame 방향 + 깎기 쪽(경사방향 = 노면 쪽) · 경사 = 깎기(암) 경사비 · 높이 = E03 과 같은
|
||
`side_cases` 높이 · 윗면 = 비탈 끝 바깥 원지반 경사. 물성 · 지진 · 기준안전율 = E02 지반 조건.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import copy
|
||
import hashlib
|
||
import math
|
||
from functools import lru_cache
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
import numpy as np
|
||
|
||
from common_util.common_util_station_key import chainage_key
|
||
from E01_StabRegister import E01_StabRegister_Source as src
|
||
from E02_StabGround import E02_StabGround_Model as ground_model
|
||
from E03_StabSection.E03_StabSection_Engine_Model import ground_from_cross, side_cases
|
||
from E06_StabRock import E06_StabRock_Engine as engine
|
||
from E06_StabRock.E06_StabRock_Stereonet import PROJECTIONS, stereonet
|
||
|
||
STAGE_DIR = "E06_StabRock"
|
||
JOINTS_NAME = "joints.json"
|
||
VERSION = 1
|
||
ENGINE_FILES = ("E06_StabRock_Engine.py", "E06_StabRock_Stereonet.py", "E06_StabRock_Model.py")
|
||
DEFAULT_GAMMA_R = 25.0 # 암 단위중량 — E02 암 물성이 없을 때(지식DB 07 Hoek & Bray 25~27)
|
||
MIN_HEIGHT_M = 1.0 # 이보다 낮은 깎기는 암반 블록 검토 안 함
|
||
CRACK_MODES = ("none", "critical", "depth")
|
||
CONDITIONS = ("dry", "wet", "seismic")
|
||
|
||
DEFAULT_SETTINGS: dict[str, Any] = {
|
||
"projection": "equal_angle",
|
||
"lateral_planar_deg": engine.LATERAL_PLANAR_DEG,
|
||
"lateral_toppling_deg": engine.LATERAL_TOPPLING_DEG,
|
||
"gamma_r": None, # None = E02 측점 암 물성 γt
|
||
"min_block_m3": 0.1, # 이보다 작은 블록은 판정에서 뺌(SWedge 최소 쐐기 크기 · 소규모 = 낙석 관리)
|
||
"water_fill_wet": 0.5, # 우기 = 균열 깊이 · 활동면 높이 ½(KDS 11 70 05 표 4.3-3 암반)
|
||
"crack": {"mode": "none", "z": None},
|
||
"bolt": {"force": 0.0, "plunge": 15.0},
|
||
}
|
||
|
||
# 칸 범위 — 화면 입력 · 서버 검사 같은 값
|
||
LIMITS: dict[str, list[float]] = {
|
||
"chainage_m": [0.0, 100000.0],
|
||
"dip_direction": [0.0, 360.0],
|
||
"dip": [0.0, 90.0],
|
||
"phi": [0.0, 60.0],
|
||
"c": [0.0, 1000.0],
|
||
"persistence_m": [0.0, 1000.0],
|
||
"lateral_deg": [5.0, 45.0],
|
||
"gamma_r": [15.0, 35.0],
|
||
"water_fill_wet": [0.0, 1.0],
|
||
"min_block_m3": [0.0, 1000.0],
|
||
"crack_z": [0.1, 100.0],
|
||
"bolt_force": [0.0, 5000.0],
|
||
"bolt_plunge": [-30.0, 60.0],
|
||
}
|
||
|
||
# 기본 절리면 값(새 줄) — 지식DB 07 표 7: cj 0~30 · φj 25~35(Barton 기본마찰각) 보수 쪽
|
||
NEW_SET = {"phi": 30.0, "c": 0.0}
|
||
|
||
|
||
def joints_path(project_root: Path) -> Path:
|
||
return Path(project_root) / STAGE_DIR / JOINTS_NAME
|
||
|
||
|
||
def initial_path(project_root: Path) -> Path:
|
||
return Path(project_root) / "initial_snapshot" / STAGE_DIR / JOINTS_NAME
|
||
|
||
|
||
def build_initial() -> dict[str, Any]:
|
||
return {"version": VERSION, "sets": [], "settings": copy.deepcopy(DEFAULT_SETTINGS)}
|
||
|
||
|
||
def upgrade(doc: dict[str, Any]) -> dict[str, Any]:
|
||
"""빠진 설정 칸만 기본값으로 채운 사본."""
|
||
out = copy.deepcopy(doc)
|
||
settings = out.setdefault("settings", {})
|
||
for key, value in DEFAULT_SETTINGS.items():
|
||
settings.setdefault(key, copy.deepcopy(value))
|
||
out.setdefault("sets", [])
|
||
return out
|
||
|
||
|
||
# ---- 검사 ----------------------------------------------------------------------
|
||
def _num(value: Any) -> bool:
|
||
return isinstance(value, int | float) and not isinstance(value, bool) and math.isfinite(value)
|
||
|
||
|
||
def _in(value: Any, key: str) -> bool:
|
||
lo, hi = LIMITS[key]
|
||
return _num(value) and lo <= value <= hi
|
||
|
||
|
||
def check_joints(doc: dict[str, Any]) -> list[dict[str, str]]:
|
||
"""틀린 칸 [{path, code}] — code = range · order · name · id_dup · enum · type."""
|
||
errors: list[dict[str, str]] = []
|
||
|
||
def bad(path: str, code: str = "range") -> None:
|
||
errors.append({"path": path, "code": code})
|
||
|
||
sets = doc.get("sets")
|
||
if not isinstance(sets, list):
|
||
return [{"path": "sets", "code": "type"}]
|
||
seen: set[str] = set()
|
||
for k, row in enumerate(sets):
|
||
base = f"sets.{k}"
|
||
if not isinstance(row, dict):
|
||
bad(base, "type")
|
||
continue
|
||
ident = str(row.get("id") or "")
|
||
if not ident or ident in seen:
|
||
bad(f"{base}.id", "id_dup")
|
||
seen.add(ident)
|
||
if not str(row.get("name") or "").strip():
|
||
bad(f"{base}.name", "name")
|
||
for key, limit in (
|
||
("from_m", "chainage_m"),
|
||
("to_m", "chainage_m"),
|
||
("dip_direction", "dip_direction"),
|
||
("dip", "dip"),
|
||
("phi", "phi"),
|
||
("c", "c"),
|
||
):
|
||
if not _in(row.get(key), limit):
|
||
bad(f"{base}.{key}")
|
||
if _num(row.get("from_m")) and _num(row.get("to_m")) and row["to_m"] < row["from_m"]:
|
||
bad(f"{base}.to_m", "order")
|
||
if row.get("persistence_m") is not None and not _in(row["persistence_m"], "persistence_m"):
|
||
bad(f"{base}.persistence_m")
|
||
settings = doc.get("settings")
|
||
if not isinstance(settings, dict):
|
||
return errors + [{"path": "settings", "code": "type"}]
|
||
if settings.get("projection") not in PROJECTIONS:
|
||
bad("settings.projection", "enum")
|
||
for key in ("lateral_planar_deg", "lateral_toppling_deg"):
|
||
if not _in(settings.get(key), "lateral_deg"):
|
||
bad(f"settings.{key}")
|
||
if settings.get("gamma_r") is not None and not _in(settings["gamma_r"], "gamma_r"):
|
||
bad("settings.gamma_r")
|
||
if not _in(settings.get("water_fill_wet"), "water_fill_wet"):
|
||
bad("settings.water_fill_wet")
|
||
if not _in(settings.get("min_block_m3"), "min_block_m3"):
|
||
bad("settings.min_block_m3")
|
||
crack = settings.get("crack") if isinstance(settings.get("crack"), dict) else {}
|
||
if crack.get("mode") not in CRACK_MODES:
|
||
bad("settings.crack.mode", "enum")
|
||
elif crack["mode"] == "depth" and not _in(crack.get("z"), "crack_z"):
|
||
bad("settings.crack.z")
|
||
bolt = settings.get("bolt") if isinstance(settings.get("bolt"), dict) else {}
|
||
if not _in(bolt.get("force"), "bolt_force"):
|
||
bad("settings.bolt.force")
|
||
if not _in(bolt.get("plunge"), "bolt_plunge"):
|
||
bad("settings.bolt.plunge")
|
||
return errors
|
||
|
||
|
||
def clean(doc: dict[str, Any]) -> dict[str, Any]:
|
||
"""정본 칸만 · 숫자는 float."""
|
||
sets = []
|
||
for row in doc["sets"]:
|
||
item = {
|
||
"id": str(row["id"]),
|
||
"name": str(row["name"]).strip(),
|
||
**{
|
||
key: float(row[key])
|
||
for key in ("from_m", "to_m", "dip_direction", "dip", "phi", "c")
|
||
},
|
||
"persistence_m": None
|
||
if row.get("persistence_m") is None
|
||
else float(row["persistence_m"]),
|
||
}
|
||
item["dip_direction"] %= 360.0
|
||
sets.append(item)
|
||
s = doc["settings"]
|
||
crack = s["crack"]
|
||
return {
|
||
"version": VERSION,
|
||
"sets": sets,
|
||
"settings": {
|
||
"projection": s["projection"],
|
||
"lateral_planar_deg": float(s["lateral_planar_deg"]),
|
||
"lateral_toppling_deg": float(s["lateral_toppling_deg"]),
|
||
"gamma_r": None if s.get("gamma_r") is None else float(s["gamma_r"]),
|
||
"water_fill_wet": float(s["water_fill_wet"]),
|
||
"min_block_m3": float(s["min_block_m3"]),
|
||
"crack": {
|
||
"mode": crack["mode"],
|
||
"z": float(crack["z"]) if crack["mode"] == "depth" else None,
|
||
},
|
||
"bolt": {"force": float(s["bolt"]["force"]), "plunge": float(s["bolt"]["plunge"])},
|
||
},
|
||
}
|
||
|
||
|
||
# ---- 측점 사면 ------------------------------------------------------------------
|
||
def rock_stations(source: Path) -> list[dict[str, Any]]:
|
||
"""암 측점(리핑암 · 발파암)."""
|
||
return [s for s in src.stations(source) if s.get("ground_type") in ground_model.ROCK_LABELS]
|
||
|
||
|
||
def _upper_dip(ground: list, start: float, sign: float, H: float, face_dip: float) -> float:
|
||
"""비탈 끝 바깥 max(H, 5 m) 원지반 평균 경사(오르막만 · 사면 경사 − 1° 아래)."""
|
||
gx = np.array([p[0] for p in ground])
|
||
gz = np.array([p[1] for p in ground])
|
||
end = start + sign * max(H, 5.0)
|
||
end = min(max(end, gx[0]), gx[-1])
|
||
run = abs(end - start)
|
||
if run < 0.5:
|
||
return 0.0
|
||
rise = float(np.interp(end, gx, gz) - np.interp(start, gx, gz))
|
||
return float(min(max(0.0, math.degrees(math.atan2(rise, run))), face_dip - 1.0))
|
||
|
||
|
||
def station_slopes(cross: dict, design: dict) -> list[dict[str, Any]]:
|
||
"""측점의 깎기 쪽마다 사면 — {side, dip_direction, dip, height_m, upper_dip}."""
|
||
ground = ground_from_cross(cross)
|
||
line = sorted(
|
||
(float(p["offset_m"]), float(p["elevation_m"])) for p in design.get("design_line") or []
|
||
)
|
||
ratio = design.get("cut_slope_ratio")
|
||
if len(ground) < 2 or len(line) < 2 or not ratio:
|
||
return []
|
||
face_dip = math.degrees(math.atan2(1.0, float(ratio)))
|
||
left = np.array([float(v) for v in cross["frame"]["left_xy"]])
|
||
out = []
|
||
for case in side_cases(design, ground, line):
|
||
if case["role"] != "cut" or case["height_m"] < MIN_HEIGHT_M:
|
||
continue
|
||
side = case["side"]
|
||
sign = 1.0 if side == "left" else -1.0
|
||
# 비탈 끝 = 탐색 끝에서 되짚음(side_cases: reach = 비탈 끝 + sign · max(5, 2H))
|
||
day = case["limits"][1 if sign > 0 else 0] - sign * max(5.0, 2.0 * case["height_m"])
|
||
face = -sign * left # 노면 쪽으로 기움
|
||
dip_dir = math.degrees(math.atan2(face[0], face[1])) % 360.0
|
||
out.append(
|
||
{
|
||
"side": side,
|
||
"dip_direction": round(dip_dir, 2),
|
||
"dip": round(face_dip, 2),
|
||
"height_m": round(case["height_m"], 3),
|
||
"upper_dip": round(_upper_dip(ground, day, sign, case["height_m"], face_dip), 2),
|
||
}
|
||
)
|
||
return out
|
||
|
||
|
||
# ---- 해석 ----------------------------------------------------------------------
|
||
@lru_cache(maxsize=1)
|
||
def engine_hash() -> str:
|
||
digest = hashlib.sha1()
|
||
for name in ENGINE_FILES:
|
||
digest.update((Path(__file__).parent / name).read_bytes())
|
||
return digest.hexdigest()[:12]
|
||
|
||
|
||
def _ground_inputs(ground: dict[str, Any]) -> dict[str, Any]:
|
||
"""E02 에서 E06 이 쓰는 칸 — 지문에도 이것만."""
|
||
return {
|
||
k: ground.get(k)
|
||
for k in ("materials", "label_map", "stations", "zones", "safety_factors", "seismic")
|
||
}
|
||
|
||
|
||
def _gamma_for(resolved: dict | None, materials: dict, override: float | None) -> float:
|
||
if override:
|
||
return float(override)
|
||
mat = materials.get((resolved or {}).get("lower") or (resolved or {}).get("upper"))
|
||
return float(mat["gamma_t"]) if mat else DEFAULT_GAMMA_R
|
||
|
||
|
||
def _fmt(value: float | None) -> float | None:
|
||
if value is None or not math.isfinite(value):
|
||
return None
|
||
return round(value, 4) + 0.0 # -0.0 → 0.0(들림 · 볼트 없음)
|
||
|
||
|
||
def _cases_for(slope: dict, joints: list[dict], kin: dict, settings: dict, gamma: float, conds):
|
||
"""위험 모드만 안전율 — 조건 = [(이름, 수위 비, kh)]."""
|
||
upper = {"dip_direction": slope["dip_direction"], "dip": slope["upper_dip"]}
|
||
by_id = {j["id"]: j for j in joints}
|
||
bolt = settings["bolt"]
|
||
min_block = settings["min_block_m3"]
|
||
crack = settings["crack"] if settings["crack"]["mode"] != "none" else None
|
||
out = []
|
||
for jid in kin["planar"]:
|
||
j = by_id[jid]
|
||
for name, fill, kh in conds:
|
||
r = engine.plane_fs(
|
||
H=slope["height_m"],
|
||
slope_dip=slope["dip"],
|
||
plane_dip=j["dip"],
|
||
c=j["c"],
|
||
phi=j["phi"],
|
||
gamma=gamma,
|
||
upper_dip=slope["upper_dip"],
|
||
crack=crack,
|
||
water_fill=fill,
|
||
kh=kh,
|
||
bolt_t=bolt["force"],
|
||
bolt_plunge=bolt["plunge"],
|
||
)
|
||
short = (
|
||
r is not None and j.get("persistence_m") is not None and j["persistence_m"] < r["A"]
|
||
)
|
||
volume = r["W"] / gamma if r else None # 평면 = 폭 1 m 당 면적(m²) → m³
|
||
out.append(
|
||
{
|
||
"mode": "planar",
|
||
"ids": [jid],
|
||
"condition": name,
|
||
"F": _fmt(r["F"]) if r else None,
|
||
"formed": r is not None,
|
||
"persistence_short": short,
|
||
"volume": _fmt(volume),
|
||
"small": volume is not None and volume < min_block,
|
||
"W": _fmt(r["W"]) if r else None,
|
||
"A": _fmt(r["A"]) if r else None,
|
||
"z": _fmt(r["z"]) if r else None,
|
||
}
|
||
)
|
||
for item in kin["wedge"]:
|
||
a, b = (by_id[k] for k in item["ids"])
|
||
for name, fill, kh in conds:
|
||
r = engine.wedge_fs(
|
||
j1=a,
|
||
j2=b,
|
||
slope=slope,
|
||
upper=upper,
|
||
H=slope["height_m"],
|
||
gamma=gamma,
|
||
water={"fill": fill},
|
||
kh=kh,
|
||
bolt={
|
||
"force": bolt["force"],
|
||
"trend": (slope["dip_direction"] + 180.0) % 360.0,
|
||
"plunge": bolt["plunge"],
|
||
},
|
||
)
|
||
length = r["line_length"] if r else None
|
||
short = any(
|
||
j.get("persistence_m") is not None
|
||
and length is not None
|
||
and j["persistence_m"] < length
|
||
for j in (a, b)
|
||
)
|
||
out.append(
|
||
{
|
||
"mode": "wedge",
|
||
"ids": list(item["ids"]),
|
||
"condition": name,
|
||
"F": _fmt(r["F"]) if r else None,
|
||
"formed": r is not None,
|
||
"persistence_short": short,
|
||
"sliding": r["mode"] if r else None,
|
||
"W": _fmt(r["W"]) if r else None,
|
||
"volume": _fmt(r["volume"]) if r else None,
|
||
"small": r is not None and r["volume"] < min_block,
|
||
}
|
||
)
|
||
return out
|
||
|
||
|
||
def analyze(source: Path, joints_doc: dict, ground: dict) -> list[dict[str, Any]]:
|
||
"""암 측점 × 깎기 쪽 — 사면 · 절리 · Markland · 안전율 · 판정."""
|
||
settings = joints_doc["settings"]
|
||
sets = joints_doc["sets"]
|
||
materials = {m["id"]: m for m in ground.get("materials") or []}
|
||
resolved = {chainage_key(r["chainage_m"]): r for r in ground_model.resolve_stations(ground)}
|
||
seismic = ground.get("seismic") or {}
|
||
factors = ground.get("safety_factors") or {}
|
||
conds = [("dry", 0.0, 0.0), ("wet", float(settings["water_fill_wet"]), 0.0)]
|
||
if seismic.get("enabled") and seismic.get("kh"):
|
||
conds.append(("seismic", 0.0, float(seismic["kh"])))
|
||
out = []
|
||
for station in rock_stations(source):
|
||
ch = float(station["chainage_m"])
|
||
key = chainage_key(ch)
|
||
joints = [j for j in sets if j["from_m"] <= ch <= j["to_m"]]
|
||
cross = src.cross_section(source, ch)
|
||
gamma = _gamma_for(resolved.get(key), materials, settings.get("gamma_r"))
|
||
for slope in station_slopes(cross, cross["design"]):
|
||
kin = engine.kinematic(
|
||
slope, joints, settings["lateral_planar_deg"], settings["lateral_toppling_deg"]
|
||
)
|
||
cases = _cases_for(slope, joints, kin, settings, gamma, conds)
|
||
for case in cases:
|
||
need = (factors.get(case["condition"]) or {}).get("cut")
|
||
case["required"] = need
|
||
case["ok"] = (
|
||
None
|
||
if case["F"] is None or need is None or case["small"]
|
||
else case["F"] >= need
|
||
)
|
||
out.append(
|
||
{
|
||
"key": key,
|
||
"chainage_m": ch,
|
||
"label": station.get("label"),
|
||
"ground_type": station.get("ground_type"),
|
||
"slope": slope,
|
||
"gamma_r": gamma,
|
||
"joints": [
|
||
{k: j[k] for k in ("id", "name", "dip_direction", "dip", "phi", "c")}
|
||
for j in joints
|
||
],
|
||
"kinematic": kin,
|
||
"cases": cases,
|
||
**_verdict(kin, cases),
|
||
}
|
||
)
|
||
return out
|
||
|
||
|
||
def _verdict(kin: dict, cases: list[dict]) -> dict[str, Any]:
|
||
"""판정 — NG(기준 미달 하나라도) · check(전도만 · 블록 안 생김) · OK · none(위험 모드 없음 ·
|
||
블록이 모두 소규모). 소규모 블록(최소 블록 크기 미만)은 판정 · 최소 Fs 에서 뺌."""
|
||
judged = [c for c in cases if not c["small"]]
|
||
values = [c["F"] for c in judged if c["F"] is not None]
|
||
min_f = min(values) if values else None
|
||
if any(c["ok"] is False for c in judged):
|
||
verdict = "NG"
|
||
elif kin["toppling"] or (judged and not values):
|
||
verdict = "check"
|
||
elif judged:
|
||
verdict = "OK"
|
||
else:
|
||
verdict = "none"
|
||
small = {(c["mode"], tuple(c["ids"])) for c in cases if c["small"]}
|
||
return {
|
||
"small_blocks": len(small),
|
||
"counts": {
|
||
"planar": len(kin["planar"]),
|
||
"wedge": len(kin["wedge"]),
|
||
"toppling": len(kin["toppling"]),
|
||
},
|
||
"min_F": min_f,
|
||
"verdict": verdict,
|
||
}
|
||
|
||
|
||
def station_net(entry: dict, settings: dict) -> dict[str, Any]:
|
||
"""한 측점 쪽 스테레오넷(해석 때 절리 그대로) — 두 투영 모두(화면이 고름)."""
|
||
joints = entry["joints"]
|
||
phi = min((j["phi"] for j in joints), default=NEW_SET["phi"])
|
||
nets = {
|
||
kind: stereonet(
|
||
entry["slope"],
|
||
joints,
|
||
phi,
|
||
kind,
|
||
settings["lateral_planar_deg"],
|
||
settings["lateral_toppling_deg"],
|
||
)
|
||
for kind in PROJECTIONS
|
||
}
|
||
return {**nets, "phi": phi}
|