"""Static FEA of a wall cantilever bracket: CadQuery -> STEP -> gmsh (C3D10) -> CalculiX -> pyvista stress map.
Hand check: Euler-Bernoulli cantilever  sigma(x) = 6 F (L-x) / (b h^2),  delta = F L^3 / (3 E I).
"""
import os, sys, json, math, subprocess, re
import numpy as np
import cadquery as cq
import gmsh

HERE = os.path.dirname(os.path.abspath(__file__)); os.chdir(HERE)
ENV = r"C:\rclone\cad_probe_20261108\storm\fcenv"
CCX = os.path.join(ENV, "Library", "bin", "ccx.exe")

# ---- geometry (mm, N, MPa) ----
PT, PW, PH = 8.0, 50.0, 80.0      # wall plate thickness (x), width (y), height (z)
L, B, HH = 120.0, 8.0, 20.0       # arm length from wall face, section width b, height h
FIL = 4.0                          # root fillet
F = 500.0                          # tip load, N, -Z
E, NU, SY = 210000.0, 0.3, 235.0   # steel S235

plate = cq.Workplane("YZ").rect(PW, PH).extrude(PT)
plate = plate.faces("<X").workplane().pushPoints([(0, 28), (0, -28)]).hole(9.0)
arm = cq.Workplane("YZ").workplane(offset=PT).rect(B, HH).extrude(L)
part = plate.union(arm)
part = part.edges(cq.selectors.BoxSelector((PT - 0.1, -B, -HH), (PT + 0.1, B, HH))).fillet(FIL)
cq.exporters.export(part, "bracket.step"); cq.exporters.export(part, "bracket.stl", tolerance=0.02)

# ---- mesh ----
gmsh.initialize(); gmsh.option.setNumber("General.Terminal", 0)
gmsh.model.occ.importShapes("bracket.step"); gmsh.model.occ.synchronize()
vols = gmsh.model.getEntities(3)
fix, load = [], []
for dim, tag in gmsh.model.getEntities(2):
    x0, y0, z0, x1, y1, z1 = gmsh.model.getBoundingBox(dim, tag)
    if abs(x0) < 1e-3 and abs(x1) < 1e-3: fix.append(tag)            # back face of plate (on wall)
    if abs(x0 - (PT + L)) < 1e-3 and abs(x1 - (PT + L)) < 1e-3: load.append(tag)  # arm end face
assert fix and load, (fix, load)
gmsh.model.addPhysicalGroup(3, [t for _, t in vols], name="SOLID")
pf = gmsh.model.addPhysicalGroup(2, fix, name="FIX"); pl = gmsh.model.addPhysicalGroup(2, load, name="LOAD")
gmsh.option.setNumber("Mesh.MeshSizeMax", 2.2); gmsh.option.setNumber("Mesh.MeshSizeMin", 0.6)
gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 12)
gmsh.option.setNumber("Mesh.ElementOrder", 2); gmsh.option.setNumber("Mesh.SecondOrderLinear", 0)
gmsh.model.mesh.generate(3)
ntags, ncoords, _ = gmsh.model.mesh.getNodes()
X = ncoords.reshape(-1, 3)
etags, enodes = gmsh.model.mesh.getElementsByType(11)  # 10-node tet
enodes = enodes.reshape(-1, 10)[:, [0, 1, 2, 3, 4, 5, 6, 7, 9, 8]]  # gmsh -> abaqus/ccx edge order
fixn = gmsh.model.mesh.getNodesForPhysicalGroup(2, pf)[0]
loadn = gmsh.model.mesh.getNodesForPhysicalGroup(2, pl)[0]
gmsh.finalize()
print(f"mesh: {len(ntags)} nodes, {len(etags)} C3D10 elements")

with open("bracket.inp", "w") as f:
    f.write("*NODE, NSET=NALL\n")
    for t, (x, y, z) in zip(ntags, X): f.write(f"{int(t)},{x:.6f},{y:.6f},{z:.6f}\n")
    f.write("*ELEMENT, TYPE=C3D10, ELSET=EALL\n")
    for i, (t, row) in enumerate(zip(etags, enodes)):
        f.write(f"{i+1}," + ",".join(str(int(n)) for n in row) + "\n")
    f.write("*NSET, NSET=FIX\n" + "\n".join(str(int(n)) for n in fixn) + "\n")
    f.write("*MATERIAL, NAME=S235\n*ELASTIC\n" + f"{E},{NU}\n")
    f.write("*SOLID SECTION, ELSET=EALL, MATERIAL=S235\n")
    f.write("*STEP\n*STATIC\n*BOUNDARY\nFIX,1,3,0.0\n*CLOAD\n")
    per = -F / len(loadn)
    for n in loadn: f.write(f"{int(n)},3,{per:.8f}\n")
    f.write("*NODE FILE\nU\n*EL FILE\nS\n*END STEP\n")

env = dict(os.environ); env["PATH"] = ";".join([os.path.join(ENV, "Library", "mingw-w64", "bin"), os.path.join(ENV, "Library", "bin"), ENV, env["PATH"]])
env["OMP_NUM_THREADS"] = "4"
r = subprocess.run([CCX, "-i", "bracket"], capture_output=True, text=True, env=env)
open("ccx_log.txt", "w").write(r.stdout + r.stderr)
print("ccx rc", r.returncode, r.stdout[-400:])

# ---- parse .frd ----
def read_frd(path):
    blocks, cur, name = {}, None, None
    for line in open(path):
        if line.startswith(" -4"):
            name = line.split()[1]; cur = {}; blocks[name] = cur
        elif line.startswith(" -1") and cur is not None:
            nid = int(line[3:13]); vals = [float(line[13 + 12 * k: 25 + 12 * k]) for k in range((len(line.rstrip()) - 13) // 12)]
            cur[nid] = vals
        elif line.startswith(" -3"):
            cur = None
    return blocks
b = read_frd("bracket.frd")
idx = {int(t): i for i, t in enumerate(ntags)}
U = np.zeros((len(ntags), 3)); S = np.zeros((len(ntags), 6))
for nid, v in b["DISP"].items(): U[idx[nid]] = v[:3]
for nid, v in b["STRESS"].items(): S[idx[nid]] = v[:6]
sxx, syy, szz, sxy, syz, szx = S.T
vm = np.sqrt(0.5 * ((sxx - syy) ** 2 + (syy - szz) ** 2 + (szz - sxx) ** 2) + 3 * (sxy ** 2 + syz ** 2 + szx ** 2))

# ---- hand calc ----
I = B * HH ** 3 / 12; W = B * HH ** 2 / 6
sig_root = F * L / W
delta = F * L ** 3 / (3 * E * I)
xs = 40.0  # check section 40 mm from wall face
sig_x = F * (L - xs) / W
# FEA at check section: top fibre nodes near x=PT+xs, z=+HH/2
m = (np.abs(X[:, 0] - (PT + xs)) < 1.2) & (np.abs(X[:, 2] - HH / 2) < 0.05)
fea_sx = float(np.mean(sxx[m])) if m.any() else float("nan")
tip = np.abs(X[:, 0] - (PT + L)) < 1e-3
fea_tip = float(np.mean(U[tip, 2]))
res = dict(nodes=len(ntags), elements=len(etags), F_N=F, L_mm=L, b_mm=B, h_mm=HH,
           hand_sigma_root_MPa=round(sig_root, 2), hand_sigma_at_40mm_MPa=round(sig_x, 2),
           fea_sigma_xx_top_at_40mm_MPa=round(fea_sx, 2),
           fea_vm_max_MPa=round(float(vm.max()), 2), fea_vm_max_at=[round(float(c), 2) for c in X[np.argmax(vm)]],
           hand_tip_deflection_mm=round(delta, 4), fea_tip_deflection_mm=round(-fea_tip, 4),
           safety_factor_yield_vm=round(SY / float(vm.max()), 2), safety_factor_hand_root=round(SY / sig_root, 2))
json.dump(res, open("fea_result.json", "w"), indent=1); print(json.dumps(res, indent=1))

# ---- render ----
import pyvista as pv
pv.OFF_SCREEN = True
cells = np.hstack([np.full((len(enodes), 1), 10), np.vectorize(idx.get)(enodes)]).astype(np.int64)
grid = pv.UnstructuredGrid(cells.ravel(), np.full(len(enodes), pv.CellType.QUADRATIC_TETRA, dtype=np.uint8), X)
grid["von Mises, MPa"] = vm; grid["U"] = U
grid.save("bracket_result.vtu")
surf = grid.extract_surface(nonlinear_subdivision=2)
warp = surf.warp_by_vector("U", factor=60)
def shot(mesh, path, pos, zoom=1.0, edges=False, clim=None):
    p = pv.Plotter(off_screen=True, window_size=(1600, 1000))
    p.set_background("#10151f", top="#1d2636")
    p.add_mesh(mesh, scalars="von Mises, MPa", cmap="turbo", clim=clim, smooth_shading=True,
               show_edges=edges, edge_color="#20303f", line_width=0.3, specular=0.3,
               scalar_bar_args=dict(title="von Mises, MPa", color="white", title_font_size=18, label_font_size=15,
                                    n_labels=6, fmt="%.0f", position_x=0.83, position_y=0.12, width=0.08, height=0.75, vertical=True))
    p.add_mesh(surf.outline(), color="#5d6b80") if False else None
    p.enable_anti_aliasing("ssaa"); p.camera_position = pos; p.camera.zoom(zoom); p.screenshot(path); p.close()
clim = [0, float(np.percentile(vm, 99.9))]
shot(warp, "fea_1_vonmises_iso.png", [(170, -190, 120), (60, 0, 0), (0, 0, 1)], zoom=1.25, clim=clim)
shot(surf, "fea_2_mesh_root.png", [(40, -55, 35), (10, 0, 4), (0, 0, 1)], zoom=1.1, edges=True, clim=clim)
shot(warp, "fea_3_side.png", [(70, -260, 0), (70, 0, 0), (0, 0, 1)], zoom=1.4, clim=clim)
print("render ok")
