designix 0.5.28 → 0.5.30

package/dist/index.js

@@ -1432,7 +1432,7 @@ import {
   checkGeom as checkGeom3,
   prefixLog as prefixLog3,
   figure as figure8,
-  degToRad as degToRad4,
+  degToRad as degToRad5,
   radToDeg as radToDeg6,
   ffix as ffix10,
   pNumber as pNumber8,
@@ -1557,72 +1557,124 @@ function ctrGuidanceOuter(param) {
   }
   return [rLog, rCtr, stepA1];
 }
+function ctrSpring(param, startOuter) {
+  let rLog = "";
+  const SR2 = param.SD2 / 2;
+  const SR2l = SR2 + param.SE1;
+  const SD2l = 2 * SR2l;
+  let ticCCW = false;
+  let ticR = -SR2;
+  let tocR = -SR2l;
+  if (startOuter) {
+    ticCCW = true;
+    ticR = SR2l;
+    tocR = SR2;
+  }
+  if (param.SL2 < SR2l) {
+    throw `err421: SL2 ${param.SL2} is too small compare to SD2 ${param.SD2} and SE1 ${param.SE1}`;
+  }
+  rLog += `info309: spring height: ${ffix4(param.SL1 + SD2l)} length: ${ffix4(param.SN1 * 2 * (param.SD2 + param.SE1))}
+`;
+  const rCtr = contour4(0, 0);
+  for (let i = 0; i < param.SN1; i++) {
+    rCtr.addSegStrokeR(0, -param.SL1).addPointR(2 * ticR, 0).addSegArc(Math.abs(ticR), false, ticCCW);
+    if (i < param.SN1 - 1) {
+      rCtr.addSegStrokeR(0, param.SL1).addPointR(2 * tocR, 0).addSegArc(Math.abs(tocR), false, !ticCCW);
+    } else if (param.Send === 1) {
+      rCtr.addSegStrokeR(0, param.SL2);
+    } else {
+      rCtr.addSegStrokeR(0, param.SL2 - SR2l).addPointR(2 * tocR, 0).addSegArc(Math.abs(tocR), false, !ticCCW);
+    }
+  }
+  if (param.Send === 1) {
+    rCtr.addSegStrokeR(-param.SE1, 0);
+  } else {
+    rCtr.addSegStrokeR(param.SE1, 0);
+  }
+  for (let i = 0; i < param.SN1; i++) {
+    if (i > 0) {
+      rCtr.addPointR(-2 * ticR, 0).addSegArc(Math.abs(ticR), false, ticCCW).addSegStrokeR(0, -param.SL1);
+    } else if (param.Send === 1) {
+      rCtr.addSegStrokeR(0, -param.SL2);
+    } else {
+      rCtr.addPointR(-2 * ticR, 0).addSegArc(Math.abs(ticR), false, ticCCW).addSegStrokeR(0, -param.SL2 + SR2l);
+    }
+    rCtr.addPointR(-2 * tocR, 0).addSegArc(Math.abs(tocR), false, !ticCCW).addSegStrokeR(0, param.SL1);
+  }
+  return [rLog, rCtr];
+}
 function ctrGuidanceInner(param) {
-  const rLog = "";
+  let rLog = "";
   const R6 = param.D6 / 2;
   const stepA2 = 2 * Math.PI / param.N2;
   const E22 = param.E2 / 2;
   const aE2 = 2 * Math.asin(E22 / R6);
   const iarcA2 = (stepA2 - aE2) / 2;
-  const a1Plus = param.N2 < 3 ? 0 : Math.PI / (2 * param.N2);
-  const a1 = Math.PI / 2 + a1Plus + degToRad2(param.a1);
+  const a1Plus = param.N2 < 3 ? 0 : Math.PI / param.N2;
+  const ar1 = a1Plus + degToRad2(param.SA1);
+  const ab1 = Math.PI / 2 - ar1;
+  const ab2 = -Math.PI / 2 + ar1;
+  const SR1 = param.SD1 / 2;
   if (iarcA2 < 0) {
     throw `err564: N2 ${param.N2} is too large compare to D6 ${param.D6}, E2 ${param.E2}`;
   }
-  const rCtr = contour4(R6, 0);
+  if (param.orientation === 2 && param.N2 % 2 === 1) {
+    throw `err565: N2 ${param.N2} is odd and orientation is alt`;
+  }
+  const [spring1Log, spring1Ctr] = ctrSpring(param, false);
+  const [, spring2Ctr] = ctrSpring(param, true);
+  rLog += spring1Log;
   const pF = point3(0, -R6);
   const pO = point3(0, 0);
-  const pG = pF.rotate(pO, -aE2);
-  const pH = pF.translatePolar(a1, param.L2);
-  const pI = pH.translatePolar(a1 + Math.PI / 2, param.E1);
-  const pH2 = pF.translatePolar(a1, param.L2 + param.L4);
-  const pI2 = pH2.translatePolar(a1 + Math.PI / 2, param.E1);
-  const ctrSpring = contour4(pG.cx, pG.cy).addSegStrokeA(pI.cx, pI.cy);
-  if (param.N3 > 0) {
-    let pK1 = pI;
-    const W12 = param.W1 / 2;
-    const E1W12 = param.E1 + W12;
-    for (let i = 0; i < param.N3; i++) {
-      const pK1b = pK1.translatePolar(a1 - Math.PI / 2, E1W12);
-      const pK2 = pK1b.translatePolar(a1, E1W12);
-      const pK3 = pK1.translatePolar(a1 - Math.PI / 2, 2 * E1W12);
-      const pK4 = pK3.translatePolar(a1 + Math.PI, param.L3);
-      const pK4b = pK4.translatePolar(a1 - Math.PI / 2, W12);
-      const pK5 = pK4b.translatePolar(a1 + Math.PI, W12);
-      const pK6 = pK4.translatePolar(a1 - Math.PI / 2, 2 * W12);
-      let L4end = 0;
-      if (i === param.N3 - 1) {
-        L4end = param.L4;
-      }
-      const pK7 = pK6.translatePolar(a1, param.L3 + L4end);
-      ctrSpring.addPointA(pK2.cx, pK2.cy).addPointA(pK3.cx, pK3.cy).addSegArc2().addSegStrokeA(pK4.cx, pK4.cy).addPointA(pK5.cx, pK5.cy).addPointA(pK6.cx, pK6.cy).addSegArc2().addSegStrokeA(pK7.cx, pK7.cy);
-      pK1 = pK7;
-    }
-    const pK8 = pK1.translatePolar(a1 - Math.PI / 2, param.E1);
-    ctrSpring.addSegStrokeA(pK8.cx, pK8.cy);
-    pK1 = pK8;
-    for (let i = 0; i < param.N3; i++) {
-      let L4end = 0;
-      if (i === 0) {
-        L4end = param.L4;
-      }
-      const pK2 = pK1.translatePolar(a1 + Math.PI, param.L3 + L4end);
-      const pK2b = pK2.translatePolar(a1 + Math.PI / 2, E1W12);
-      const pK3 = pK2b.translatePolar(a1 + Math.PI, E1W12);
-      const pK4 = pK2.translatePolar(a1 + Math.PI / 2, 2 * E1W12);
-      const pK5 = pK4.translatePolar(a1, param.L3);
-      const pK5b = pK5.translatePolar(a1 + Math.PI / 2, W12);
-      const pK6 = pK5b.translatePolar(a1, W12);
-      const pK7 = pK5.translatePolar(a1 + Math.PI / 2, 2 * W12);
-      ctrSpring.addSegStrokeA(pK2.cx, pK2.cy).addPointA(pK3.cx, pK3.cy).addPointA(pK4.cx, pK4.cy).addSegArc2().addSegStrokeA(pK5.cx, pK5.cy).addPointA(pK6.cx, pK6.cy).addPointA(pK7.cx, pK7.cy).addSegArc2();
-      pK1 = pK7;
+  const pG = pF.rotate(pO, aE2);
+  const pH = pF.translate(0, param.L2);
+  const pIc = pH.translate(-SR1, 0);
+  const pJ = pIc.translate(0, SR1);
+  const pM = pIc.translate(0, SR1 + param.SE1);
+  const pL = pM.rotate(pIc, ab1);
+  const pN = pH.translate(0, SR1 + param.SE1).translate(param.SE1, 0);
+  const pG2 = pF.rotate(pO, -aE2);
+  const pIc2 = pH.translate(SR1, 0);
+  const pJ2 = pIc2.translate(0, SR1);
+  const pK2 = pJ2.rotate(pIc2, ab2);
+  const pM2 = pIc2.translate(0, SR1 + param.SE1);
+  const pN2 = pH.translate(0, SR1 + param.SE1).translate(-param.SE1, 0);
+  const ctrSpringBase1 = contour4(pG.cx, pG.cy).addSegStrokeA(pN.cx, pN.cy).addSegStrokeA(pM.cx, pM.cy);
+  const ctrSpringBase1b = contour4(pM.cx, pM.cy).addPointA(pL.cx, pL.cy).addSegArc(SR1 + param.SE1, false, true);
+  ctrSpringBase1b.addPartial(spring1Ctr.rotate(0, 0, -ar1).translate(pL.cx, pL.cy));
+  ctrSpringBase1b.addPointA(pJ.cx, pJ.cy).addPointA(pH.cx, pH.cy).addSegArc2().addSegStrokeA(pF.cx, pF.cy);
+  ctrSpringBase1.addPartial(ctrSpringBase1b);
+  const ctrSpringBase2a = contour4(pF.cx, pF.cy).addSegStrokeA(pH.cx, pH.cy).addPointA(pJ2.cx, pJ2.cy).addPointA(pK2.cx, pK2.cy).addSegArc2();
+  ctrSpringBase2a.addPartial(spring2Ctr.rotate(0, 0, ar1).translate(pK2.cx, pK2.cy));
+  ctrSpringBase2a.addPointA(pM2.cx, pM2.cy).addSegArc(SR1 + param.SE1, false, true);
+  const ctrSpringBase2b = contour4(pM2.cx, pM2.cy).addSegStrokeA(pN2.cx, pN2.cy).addSegStrokeA(pG2.cx, pG2.cy);
+  const ctrSpringBase2 = contour4(pF.cx, pF.cy).addPartial(ctrSpringBase2a).addPartial(ctrSpringBase2b);
+  const rCtr = contour4(R6, 0);
+  if (param.orientation === 2) {
+    for (let i = 0; i < param.N2 / 2; i++) {
+      rCtr.addPointAP(-2 * i * stepA2 - 2 * iarcA2, R6).addPointAP(-2 * i * stepA2 - 4 * iarcA2, R6).addSegArc2();
+      rCtr.addCornerRounded(param.R7);
+      const ar1b = Math.PI / 2 - (2 * i + 2) * stepA2;
+      const ar2a = ar1b + 2 * aE2;
+      rCtr.addPartial(ctrSpringBase2a.rotate(0, 0, ar2a));
+      const ctrSB1 = ctrSpringBase1b.rotate(0, 0, ar1b);
+      const pt1 = ctrSB1.getFirstPoint();
+      rCtr.addCornerRounded(param.R7);
+      rCtr.addSegStrokeA(pt1.cx, pt1.cy);
+      rCtr.addCornerRounded(param.R7);
+      rCtr.addPartial(ctrSB1);
+      rCtr.addCornerRounded(param.R7);
     }
   } else {
-    ctrSpring.addSegStrokeA(pI2.cx, pI2.cy).addSegStrokeA(pH2.cx, pH2.cy);
-  }
-  ctrSpring.addSegStrokeA(pF.cx, pF.cy);
-  for (let i = 0; i < param.N2; i++) {
-    rCtr.addPointAP(i * stepA2 + iarcA2, R6).addPointAP(i * stepA2 + 2 * iarcA2, R6).addSegArc2().addCornerRounded(param.R7).addPartial(ctrSpring.rotate(0, 0, Math.PI / 2 + (i + 1) * stepA2)).addCornerRounded(param.R7);
+    for (let i = 0; i < param.N2; i++) {
+      rCtr.addPointAP(-i * stepA2 - iarcA2, R6).addPointAP(-i * stepA2 - 2 * iarcA2, R6).addSegArc2().addCornerRounded(param.R7);
+      if (param.orientation === 0) {
+        rCtr.addPartial(ctrSpringBase2.rotate(0, 0, Math.PI / 2 - (i + 1) * stepA2 + aE2));
+      } else if (param.orientation === 1) {
+        rCtr.addPartial(ctrSpringBase1.rotate(0, 0, Math.PI / 2 - (i + 1) * stepA2));
+      }
+      rCtr.addCornerRounded(param.R7);
+    }
   }
   return [rLog, rCtr];
 }
@@ -2066,6 +2118,7 @@ function pGeom4(t, param, suffix = "") {
     const designName = rGeome.partName;
     const inheritList = [];
     const inheritNames = [];
+    let subDesignObj = {};
     if (param.holders) {
       const vaxisHolderB2Param = designParam2(vaxisHolderDef.pDef, "B2");
       vaxisHolderB2Param.setVal("PHD1", param.PHD1B);
@@ -2175,6 +2228,26 @@ function pGeom4(t, param, suffix = "") {
       };
       inheritList.push(inheritHa);
       inheritNames.push(`inpax_${designName}_hA`);
+      subDesignObj = {
+        vaxis_holder_B2: {
+          partName: vaxisHolderB2Param.getPartName(),
+          dparam: vaxisHolderB2Param.getDesignParamList(),
+          orientation: [0, 0, 0],
+          position: [0, 0, hb2PosH]
+        },
+        vaxis_holder_B1: {
+          partName: vaxisHolderB1Param.getPartName(),
+          dparam: vaxisHolderB1Param.getDesignParamList(),
+          orientation: [0, 0, 0],
+          position: [0, 0, hb1PosH]
+        },
+        vaxis_holder_A: {
+          partName: vaxisHolderAParam.getPartName(),
+          dparam: vaxisHolderAParam.getDesignParamList(),
+          orientation: [0, 0, 0],
+          position: [0, 0, haPosH]
+        }
+      };
     }
     rGeome.fig = {
       poleCut: figCut,
@@ -2256,7 +2329,7 @@ function pGeom4(t, param, suffix = "") {
         }
       ]
     };
-    rGeome.sub = {};
+    rGeome.sub = subDesignObj;
     rGeome.logstr += "pole_static drawn successfully!\n";
     rGeome.calcErr = false;
   } catch (emsg) {
@@ -2276,7 +2349,10 @@ var poleStaticDef = {
 import {
   contour as contour7,
   contourCircle as contourCircle5,
+  ctrRectangle,
+  ctrRectRot,
   figure as figure5,
+  degToRad as degToRad4,
   radToDeg as radToDeg4,
   ffix as ffix7,
   pNumber as pNumber5,
@@ -2320,7 +2396,8 @@ var pDef5 = {
     pNumber5("H6", "mm", 100, 1, 1e3, 10),
     pNumber5("H7", "mm", 600, 10, 2e3, 10),
     pNumber5("L9", "mm", 300, 1, 1e3, 10),
-    pNumber5("R9", "mm", 50, 0, 300, 1)
+    pNumber5("R9", "mm", 50, 0, 300, 1),
+    pNumber5("doorOrientation", "degree", 0, -180, 180, 1)
   ],
   paramSvg: {
     D1: "rake_face.svg",
@@ -2350,7 +2427,8 @@ var pDef5 = {
     H6: "rake_door.svg",
     H7: "rake_door.svg",
     L9: "rake_door.svg",
-    R9: "rake_door.svg"
+    R9: "rake_door.svg",
+    doorOrientation: "rake_door.svg"
   },
   sim: {
     tMax: 180,
@@ -2361,10 +2439,8 @@ var pDef5 = {
 };
 function pGeom5(t, param, suffix = "") {
   const rGeome = initGeom5(pDef5.partName + suffix);
-  let ctrCone;
-  let ctrConePlus;
-  let ctrRect;
   const figCone = figure5();
+  const figConeHollow = figure5();
   const figBeam = figure5();
   const figBeamHollow = figure5();
   const figDisc = figure5();
@@ -2385,28 +2461,6 @@ function pGeom5(t, param, suffix = "") {
     const R8 = param.D8 / 2;
     const H1H2 = param.H1 + param.H2;
     const H1H5 = H1H2 - param.H4 + param.H5;
-    rGeome.logstr += `cone-height: ${ffix7(H1H2)} mm
-`;
-    rGeome.logstr += `cone-height total: ${ffix7(H1H5)} mm
-`;
-    if (param.D2 > param.D1) {
-      throw `err110: D2 ${param.D2} is larger than D1 ${param.D1}`;
-    }
-    if (param.D3 + param.E1 > param.D1) {
-      throw `err113: D3 ${param.D3} is too large compare to D1 ${param.D1} and E1 ${param.E1}`;
-    }
-    if (param.H3 + param.E3 > param.H1) {
-      throw `err116: H3 ${param.H3} is too large compare to H1 ${param.H1} and E3 ${param.E3}`;
-    }
-    if (param.H4 + R4 > param.H2) {
-      throw `err119: H4 ${param.H4} is too large compare to H2 ${param.H2} and D4 ${param.D4}`;
-    }
-    if (param.E4 > R4) {
-      throw `err122: E4 ${param.E4} is too large compare to D4 ${param.D4}`;
-    }
-    if (param.D8 <= param.D5) {
-      throw `err146: D8 ${param.D8} is too small compare to D5 ${param.D5}`;
-    }
     const beamL = 4 * param.L4 + param.L5 + 2 * param.L6;
     const beamH = param.H1 + param.H2 - param.H4;
     const handLowX = R4 * Math.cos(Math.PI / 6);
@@ -2417,17 +2471,10 @@ function pGeom5(t, param, suffix = "") {
     const handHighYext = R8 * Math.sin(Math.PI / 6);
     const handPos = [-beamL / 2, -param.L5 / 2 - param.L4, param.L5 / 2, beamL / 2 - param.L4];
     const wingLy = param.H2 - param.L8 - param.H4 - R4;
-    if (wingLy < 0) {
-      throw `err140: H2 ${param.H2} too small compare to L8 ${param.L8}, H4 ${param.H4} and D4 ${param.D4}`;
-    }
     const coneAngle = Math.atan2(R1 - R2, param.H2);
-    rGeome.logstr += `cone-angle: ${ffix7(radToDeg4(coneAngle))} degree
-`;
     const wingLx = beamL / 2 - param.L7 - R1 + param.L8 * Math.tan(coneAngle);
     const wingL = Math.sqrt(wingLx ** 2 + wingLy ** 2);
     const wingAngle = Math.atan2(wingLx, wingLy);
-    rGeome.logstr += `wing-angle: ${ffix7(radToDeg4(wingAngle))} degree
-`;
     const wingLPre = param.E1 / Math.sin(wingAngle + coneAngle);
     const wingL2 = wingL + param.E4 / Math.cos(wingAngle) + wingLPre;
     const wingPosX = R1 - param.L8 * Math.tan(coneAngle) - wingLPre * Math.sin(wingAngle);
@@ -2440,49 +2487,75 @@ function pGeom5(t, param, suffix = "") {
     const wingAngleC = Math.PI / 2 - wingAngle;
     const doorLowX = param.L9 / 2;
     const doorHighX = doorLowX - param.H7 * Math.tan(coneAngle);
+    if (param.D2 > param.D1) {
+      throw `err110: D2 ${param.D2} is larger than D1 ${param.D1}`;
+    }
+    if (param.D3 + param.E1 > param.D1) {
+      throw `err113: D3 ${param.D3} is too large compare to D1 ${param.D1} and E1 ${param.E1}`;
+    }
+    if (param.H3 + param.E3 > param.H1) {
+      throw `err116: H3 ${param.H3} is too large compare to H1 ${param.H1} and E3 ${param.E3}`;
+    }
+    if (param.H4 + R4 > param.H2) {
+      throw `err119: H4 ${param.H4} is too large compare to H2 ${param.H2} and D4 ${param.D4}`;
+    }
+    if (param.E4 > R4) {
+      throw `err122: E4 ${param.E4} is too large compare to D4 ${param.D4}`;
+    }
+    if (param.D8 <= param.D5) {
+      throw `err146: D8 ${param.D8} is too small compare to D5 ${param.D5}`;
+    }
+    if (wingLy < 0) {
+      throw `err140: H2 ${param.H2} too small compare to L8 ${param.L8}, H4 ${param.H4} and D4 ${param.D4}`;
+    }
     if (doorHighX < param.R9) {
       throw `err177: R9 ${param.R9} too large compare to doorHighX ${doorHighX} and L9 ${param.L9}`;
     }
     if (param.L9 > param.D1) {
       throw `err180: L9 ${param.L9} too large compare to D1 ${param.D1}`;
     }
+    rGeome.logstr += `cone-height: ${ffix7(H1H2)} mm
+`;
+    rGeome.logstr += `cone-height total: ${ffix7(H1H5)} mm
+`;
+    rGeome.logstr += `cone-angle: ${ffix7(radToDeg4(coneAngle))} degree
+`;
+    rGeome.logstr += `wing-angle: ${ffix7(radToDeg4(wingAngle))} degree
+`;
     const coneSlopeX = param.E1 * Math.cos(coneAngle);
     const coneSlopeY = param.E1 * Math.sin(coneAngle);
     const coneFC = param.E1 * Math.tan(coneAngle / 2);
-    ctrCone = function(orient) {
+    const ctrCone = function(orient) {
       const rCtr = contour7(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, H1H2).addSegStrokeA(orient * (R2 - coneSlopeX), H1H2 - coneSlopeY).addSegStrokeA(orient * (R1 - param.E1), param.H1 - coneFC).addSegStrokeA(orient * (R1 - param.E1), 0).closeSegStroke();
       return rCtr;
     };
-    ctrConePlus = function(orient) {
+    const ctrConePlus = function(orient) {
       const rCtr = contour7(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, H1H2).addSegStrokeA(orient * (R2 - coneSlopeX), H1H2 - coneSlopeY).addSegStrokeA(orient * (R1 - param.E1), param.H1 - coneFC).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.H3).addSegStrokeA(orient * R3, param.H1 - param.H3).addSegStrokeA(orient * R3, param.H1 - param.H3 - param.E3).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.H3 - param.E3).addSegStrokeA(orient * (R1 - param.E1), 0).closeSegStroke();
       return rCtr;
     };
-    ctrRect = function(width, height, xpos, ypos, angle) {
-      const xWidth = width * Math.cos(angle);
-      const yWidth = width * Math.sin(angle);
-      const xHeight = -height * Math.sin(angle);
-      const yHeight = height * Math.cos(angle);
-      const rCtr = contour7(xpos, ypos).addSegStrokeA(xpos + xWidth, ypos + yWidth).addSegStrokeA(xpos + xWidth + xHeight, ypos + yWidth + yHeight).addSegStrokeA(xpos + xHeight, ypos + yHeight).closeSegStroke();
-      return rCtr;
-    };
+    const coneHollowHeight2 = beamH - R4 - (param.H1 - coneFC);
+    const coneHollowR2 = R1 - param.E1 - Math.tan(coneAngle) * coneHollowHeight2;
+    const ctrConeHollow = contour7(0, beamH - R4).addSegStrokeA(coneHollowR2, beamH - R4).addSegStrokeA(R1 - param.E1, param.H1 - coneFC).addSegStrokeA(R1 - param.E1, param.H1 - param.H3).addSegStrokeA(0, param.H1 - param.H3).closeSegStroke();
     const ctrDoor = contour7(doorLowX, param.H1 + param.H6).addCornerRounded(param.R9).addSegStrokeA(doorHighX, param.H1 + param.H6 + param.H7).addCornerRounded(param.R9).addSegStrokeA(-doorHighX, param.H1 + param.H6 + param.H7).addCornerRounded(param.R9).addSegStrokeA(-doorLowX, param.H1 + param.H6).addCornerRounded(param.R9).closeSegStroke();
     figCone.addMain(ctrCone(1));
     figCone.addSecond(ctrConePlus(1));
     figCone.addSecond(ctrConePlus(-1));
-    figCone.addSecond(ctrRect(beamL, param.D4, -beamL / 2, beamH - R4, 0));
+    figCone.addSecond(ctrRectangle(-beamL / 2, beamH - R4, beamL, param.D4));
     figCone.addSecond(
-      ctrRect(beamL, param.D4 - 2 * param.E4, -beamL / 2, beamH - R4 + param.E4, 0)
+      ctrRectangle(-beamL / 2, beamH - R4 + param.E4, beamL, param.D4 - 2 * param.E4)
     );
     for (const posX of handPos) {
       figCone.addSecond(
-        ctrRect(param.L4, param.H5 - handLowY - handHighYint, posX, beamH + handLowY, 0)
+        ctrRectangle(posX, beamH + handLowY, param.L4, param.H5 - handLowY - handHighYint)
       );
     }
-    figCone.addSecond(ctrRect(wingL2, 2 * R6, wingPosX, wingPosY, wingAngleC));
-    figCone.addSecond(ctrRect(wingL2, 2 * wingHR, wingHPosX, wingHPosY, wingAngleC));
-    figCone.addSecond(ctrRect(2 * R6, wingL2, -wingPosX, wingPosY, wingAngle));
-    figCone.addSecond(ctrRect(2 * wingHR, wingL2, -wingHPosX, wingHPosY, wingAngle));
+    figCone.addSecond(ctrRectRot(wingPosX, wingPosY, wingL2, 2 * R6, wingAngleC));
+    figCone.addSecond(ctrRectRot(wingHPosX, wingHPosY, wingL2, 2 * wingHR, wingAngleC));
+    figCone.addSecond(ctrRectRot(-wingPosX, wingPosY, 2 * R6, wingL2, wingAngle));
+    figCone.addSecond(ctrRectRot(-wingHPosX, wingHPosY, 2 * wingHR, wingL2, wingAngle));
     figCone.addSecond(ctrDoor);
+    figConeHollow.mergeFigure(figCone, true);
+    figConeHollow.addMain(ctrConeHollow);
     const ctrHand = contour7(handLowX, beamH + handLowY).addSegStrokeA(handHighXext, beamH + param.H5 - handHighYext).addSegStrokeA(handHighXint, beamH + param.H5 - handHighYint).addPointA(-handHighXint, beamH + param.H5 - handHighYint).addSegArc(R5, false, false).addSegStrokeA(-handHighXext, beamH + param.H5 - handHighYext).addSegStrokeA(-handLowX, beamH + handLowY).closeSegArc(R4, false, false);
     figBeam.addMain(contourCircle5(0, beamH, R4));
     figBeam.addMain(contourCircle5(0, beamH, R4 - param.E4));
@@ -2490,8 +2563,8 @@ function pGeom5(t, param, suffix = "") {
     figBeam.addSecond(ctrConePlus(-1));
     figBeam.addSecond(ctrHand);
     figBeam.addSecond(contourCircle5(0, beamH + param.H5, R5));
-    figBeam.addSecond(ctrRect(2 * R6, wingLy, -R6, param.H1 + param.L8, 0));
-    figBeam.addSecond(ctrRect(2 * wingHR, wingLy, -wingHR, param.H1 + param.L8, 0));
+    figBeam.addSecond(ctrRectangle(-R6, param.H1 + param.L8, 2 * R6, wingLy));
+    figBeam.addSecond(ctrRectangle(-wingHR, param.H1 + param.L8, 2 * wingHR, wingLy));
     figBeam.addSecond(ctrDoor);
     figBeamHollow.addMain(contourCircle5(0, beamH, R4 - param.E4));
     figBeamHollow.addSecond(contourCircle5(0, beamH, R4));
@@ -2507,22 +2580,22 @@ function pGeom5(t, param, suffix = "") {
     }
     figDisc.addSecond(contourCircle5(0, 0, R1 - param.E1));
     figDisc.addSecond(contourCircle5(0, 0, R2));
-    figDisc.addSecond(ctrRect(param.D4, beamL, -R4, -beamL / 2, 0));
-    figDisc.addSecond(ctrRect(param.D4 - 2 * param.E4, beamL, -R4 + param.E4, -beamL / 2, 0));
+    figDisc.addSecond(ctrRectangle(-R4, -beamL / 2, param.D4, beamL));
+    figDisc.addSecond(ctrRectangle(-R4 + param.E4, -beamL / 2, param.D4 - 2 * param.E4, beamL));
     for (const posX of handPos) {
-      figDisc.addSecond(ctrRect(2 * handLowX, param.L4, -handLowX, posX, 0));
-      figDisc.addSecond(ctrRect(2 * handHighXint, param.L4, -handHighXint, posX, 0));
-      figDisc.addSecond(ctrRect(2 * handHighXext, param.L4, -handHighXext, posX, 0));
+      figDisc.addSecond(ctrRectangle(-handLowX, posX, 2 * handLowX, param.L4));
+      figDisc.addSecond(ctrRectangle(-handHighXint, posX, 2 * handHighXint, param.L4));
+      figDisc.addSecond(ctrRectangle(-handHighXext, posX, 2 * handHighXext, param.L4));
     }
-    figDisc.addSecond(ctrRect(2 * R6, wingLx, -R6, R1 - param.L8 * Math.tan(coneAngle), 0));
+    figDisc.addSecond(ctrRectangle(-R6, R1 - param.L8 * Math.tan(coneAngle), 2 * R6, wingLx));
     figDisc.addSecond(
-      ctrRect(2 * wingHR, wingLx, -wingHR, R1 - param.L8 * Math.tan(coneAngle), 0)
+      ctrRectangle(-wingHR, R1 - param.L8 * Math.tan(coneAngle), 2 * wingHR, wingLx)
     );
     figDisc.addSecond(
-      ctrRect(2 * R6, wingLx, -R6, -R1 + param.L8 * Math.tan(coneAngle) - wingLx, 0)
+      ctrRectangle(-R6, -R1 + param.L8 * Math.tan(coneAngle) - wingLx, 2 * R6, wingLx)
     );
     figDisc.addSecond(
-      ctrRect(2 * wingHR, wingLx, -wingHR, -R1 + param.L8 * Math.tan(coneAngle) - wingLx, 0)
+      ctrRectangle(-wingHR, -R1 + param.L8 * Math.tan(coneAngle) - wingLx, 2 * wingHR, wingLx)
     );
     figHand.addMain(ctrHand);
     figHand.addSecond(contourCircle5(0, beamH, R4));
@@ -2535,21 +2608,22 @@ function pGeom5(t, param, suffix = "") {
     figDoor.addMain(ctrDoor);
     figDoor.addSecond(ctrConePlus(1));
     figDoor.addSecond(ctrConePlus(-1));
-    figDoor.addSecond(ctrRect(beamL, param.D4, -beamL / 2, beamH - R4, 0));
+    figDoor.addSecond(ctrRectangle(-beamL / 2, beamH - R4, beamL, param.D4));
     figDoor.addSecond(
-      ctrRect(beamL, param.D4 - 2 * param.E4, -beamL / 2, beamH - R4 + param.E4, 0)
+      ctrRectangle(-beamL / 2, beamH - R4 + param.E4, beamL, param.D4 - 2 * param.E4)
     );
     for (const posX of handPos) {
       figDoor.addSecond(
-        ctrRect(param.L4, param.H5 - handLowY - handHighYint, posX, beamH + handLowY, 0)
+        ctrRectangle(posX, beamH + handLowY, param.L4, param.H5 - handLowY - handHighYint)
       );
     }
-    figDoor.addSecond(ctrRect(wingL2, 2 * R6, wingPosX, wingPosY, wingAngleC));
-    figDoor.addSecond(ctrRect(wingL2, 2 * wingHR, wingHPosX, wingHPosY, wingAngleC));
-    figDoor.addSecond(ctrRect(2 * R6, wingL2, -wingPosX, wingPosY, wingAngle));
-    figDoor.addSecond(ctrRect(2 * wingHR, wingL2, -wingHPosX, wingHPosY, wingAngle));
+    figDoor.addSecond(ctrRectRot(wingPosX, wingPosY, wingL2, 2 * R6, wingAngleC));
+    figDoor.addSecond(ctrRectRot(wingHPosX, wingHPosY, wingL2, 2 * wingHR, wingAngleC));
+    figDoor.addSecond(ctrRectRot(-wingPosX, wingPosY, 2 * R6, wingL2, wingAngle));
+    figDoor.addSecond(ctrRectRot(-wingHPosX, wingHPosY, 2 * wingHR, wingL2, wingAngle));
     rGeome.fig = {
       faceCone: figCone,
+      faceConeHollow: figConeHollow,
       faceBeam: figBeam,
       faceBeamHollow: figBeamHollow,
       faceDisc: figDisc,
@@ -2579,6 +2653,13 @@ function pGeom5(t, param, suffix = "") {
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
         },
+        {
+          outName: `subpax_${designName}_coneHollow`,
+          face: `${designName}_faceConeHollow`,
+          extrudeMethod: EExtrude4.eRotate,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        },
         {
           outName: `subpax_${designName}_beam`,
           face: `${designName}_faceBeam`,
@@ -2640,7 +2721,7 @@ function pGeom5(t, param, suffix = "") {
           face: `${designName}_faceDoor`,
           extrudeMethod: EExtrude4.eLinearOrtho,
           length: param.D1,
-          rotate: [Math.PI / 2, 0, Math.PI / 2],
+          rotate: [Math.PI / 2, 0, -Math.PI / 2 + degToRad4(param.doorOrientation)],
           translate: [0, 0, 0]
         },
         ...preExtrude
@@ -2665,6 +2746,7 @@ function pGeom5(t, param, suffix = "") {
           outName: `ipax_${designName}_hollow`,
           boolMethod: EBVolume5.eUnion,
           inList: [
+            `subpax_${designName}_coneHollow`,
             `subpax_${designName}_beamHollow`,
             `subpax_${designName}_wing_hollow_right`,
             `subpax_${designName}_wing_hollow_left`,
@@ -2889,7 +2971,7 @@ import {
   point as point5,
   contour as contour9,
   contourCircle as contourCircle7,
-  ctrRectangle,
+  ctrRectangle as ctrRectangle2,
   figure as figure7,
   ffix as ffix9,
   pNumber as pNumber7,
@@ -2973,9 +3055,9 @@ function pGeom7(t, param, suffix = "") {
     figSide.addMain(contourCircle7(0, 0, R1 - param.E1));
     const sidePx = [-param.L2 / 2, -param.L3 - param.H2, param.L3, param.L2 / 2 - param.H2];
     for (const px of sidePx) {
-      figSide.addMain(ctrRectangle(px, R1 - param.H4, param.H2, param.H4));
+      figSide.addMain(ctrRectangle2(px, R1 - param.H4, param.H2, param.H4));
       figSide.addMain(
-        ctrRectangle(
+        ctrRectangle2(
           px + param.E2,
           R1 - param.H4 + param.E2,
           param.H2 - 2 * param.E2,
@@ -2983,7 +3065,7 @@ function pGeom7(t, param, suffix = "") {
         )
       );
     }
-    figSide.addSecond(ctrRectangle(-param.L2 / 2, R1, param.L2, param.H3));
+    figSide.addSecond(ctrRectangle2(-param.L2 / 2, R1, param.L2, param.H3));
     const facePx = [];
     facePx.push(-param.L1 / 2);
     facePx.push(param.L1 / 2 - param.H1);
@@ -2998,9 +3080,9 @@ function pGeom7(t, param, suffix = "") {
       }
     }
     for (const px of facePx) {
-      figFace.addMain(ctrRectangle(px, R1, param.H1, param.H3));
+      figFace.addMain(ctrRectangle2(px, R1, param.H1, param.H3));
       figFace.addMain(
-        ctrRectangle(
+        ctrRectangle2(
           px + param.E3,
           R1 + param.E3,
           param.H1 - 2 * param.E3,
@@ -3008,15 +3090,15 @@ function pGeom7(t, param, suffix = "") {
         )
       );
     }
-    figFace.addSecond(ctrRectangle(-param.L1 / 2, -R1, param.L1, param.D1));
-    figFace.addSecond(ctrRectangle(-param.L1 / 2, R1 - param.H4, param.L1, param.H4));
+    figFace.addSecond(ctrRectangle2(-param.L1 / 2, -R1, param.L1, param.D1));
+    figFace.addSecond(ctrRectangle2(-param.L1 / 2, R1 - param.H4, param.L1, param.H4));
     for (const px of facePx) {
-      figTop.addSecond(ctrRectangle(px, -param.L2 / 2, param.H1, param.L2));
+      figTop.addSecond(ctrRectangle2(px, -param.L2 / 2, param.H1, param.L2));
     }
     for (const py of sidePx) {
-      figTop.addSecond(ctrRectangle(-param.L1 / 2, py, param.L1, param.H2));
+      figTop.addSecond(ctrRectangle2(-param.L1 / 2, py, param.L1, param.H2));
     }
-    figTop.addSecond(ctrRectangle(-param.L1 / 2, -R1, param.L1, param.D1));
+    figTop.addSecond(ctrRectangle2(-param.L1 / 2, -R1, param.L1, param.D1));
     const aBAC = Math.atan2(param.S1, R1);
     const aDAB = 2 * aBAC;
     const pA = point5(0, 0);
@@ -3025,13 +3107,14 @@ function pGeom7(t, param, suffix = "") {
     const ctrButtress = contour9(-param.L3, R1).addSegStrokeA(-param.S1, R1).addCornerRounded(param.R2).addSegStrokeA(pD.cx, pD.cy).addPointA(0, -R1).addPointA(-pD.cx, pD.cy).addSegArc2().addSegStrokeA(param.S1, R1).addCornerRounded(param.R2).addSegStrokeA(param.L3, R1).addSegStrokeA(param.L3, R1 + param.E3).addSegStrokeA(-param.L3, R1 + param.E3).closeSegStroke();
     figButtress.addMain(ctrButtress);
     figButtress.addMain(contourCircle7(0, 0, R1 - param.E1));
+    figSide.addSecond(ctrButtress);
     for (const px of facePx) {
-      figTopWithRod.addMain(ctrRectangle(px, -param.L2 / 2, param.H1, param.L2));
+      figTopWithRod.addMain(ctrRectangle2(px, -param.L2 / 2, param.H1, param.L2));
     }
     for (const py of sidePx) {
-      figTopWithRod.addMain(ctrRectangle(-param.L1 / 2, py, param.L1, param.H2));
+      figTopWithRod.addMain(ctrRectangle2(-param.L1 / 2, py, param.L1, param.H2));
     }
-    figTopWithRod.addMain(ctrRectangle(-param.L1 / 2, -R1, param.L1, param.D1));
+    figTopWithRod.addMain(ctrRectangle2(-param.L1 / 2, -R1, param.L1, param.D1));
     const rodPx0 = -((param.rod1 - 1) * param.rod2 + param.rod3) / 2;
     const rodOffset = (param.rod3 - param.rod4) / 2;
     const rodPlateH = param.rod3 / 2;
@@ -3040,10 +3123,10 @@ function pGeom7(t, param, suffix = "") {
     const rodPy0 = -rodLength / 2;
     for (let i = 0; i < param.rod1; i++) {
       const px = rodPx0 + i * param.rod2;
-      figTopWithRod.addSecond(ctrRectangle(px + rodOffset, rodPy0, param.rod4, rodLength));
+      figTopWithRod.addSecond(ctrRectangle2(px + rodOffset, rodPy0, param.rod4, rodLength));
       for (let j = 0; j < 4; j++) {
         figTopWithRod.addSecond(
-          ctrRectangle(px, rodPy0 + j * rodPyStep, param.rod3, rodPlateH, rodPlateH / 4)
+          ctrRectangle2(px, rodPy0 + j * rodPyStep, param.rod3, rodPlateH, rodPlateH / 4)
         );
       }
     }
@@ -3072,13 +3155,31 @@ function pGeom7(t, param, suffix = "") {
           length: param.L2,
           rotate: [0, Math.PI / 2, 0],
           translate: [-param.L2 / 2, 0, 0]
-        }
+        },
+        ...facePx.map((pz, idx) => {
+          const rElem = {
+            outName: `subpax_${designName}_buttress_${idx}`,
+            face: `${designName}_faceButtress`,
+            extrudeMethod: EExtrude6.eLinearOrtho,
+            length: param.H1,
+            rotate: [0, 0, 0],
+            translate: [0, 0, pz]
+          };
+          return rElem;
+        })
       ],
       volumes: [
         {
           outName: `pax_${designName}`,
           boolMethod: EBVolume7.eUnion,
-          inList: [`subpax_${designName}_side`, `subpax_${designName}_face`]
+          inList: [
+            `subpax_${designName}_side`,
+            `subpax_${designName}_face`,
+            ...facePx.map((pz, idx) => {
+              const subElem = `subpax_${designName}_buttress_${idx}`;
+              return subElem;
+            })
+          ]
         }
       ]
     };
@@ -3196,7 +3297,7 @@ function pGeom8(t, param, suffix = "") {
 `;
     const posAngleMid = (param.al - param.ar) / 2;
     const posAngleDegree = posAngleMid - Math.sin(2 * Math.PI * t / pDef8.sim.tMax) * (param.al + param.ar) / 2;
-    const posAngle = degToRad4(posAngleDegree);
+    const posAngle = degToRad5(posAngleDegree);
     rGeome.logstr += `swing position angle: ${ffix10(radToDeg6(posAngle))} degree
 `;
     const rakePosY = param.H1 + param.H2 - param.H3;
@@ -3421,7 +3522,7 @@ import {
   checkGeom as checkGeom5,
   prefixLog as prefixLog5,
   figure as figure10,
-  degToRad as degToRad5,
+  degToRad as degToRad6,
   radToDeg as radToDeg8,
   ffix as ffix12,
   pNumber as pNumber10,
@@ -3435,8 +3536,9 @@ import {
   designParam as designParam4,
   checkGeom as checkGeom4,
   prefixLog as prefixLog4,
-  contour as contour10,
   contourCircle as contourCircle8,
+  ctrRectangle as ctrRectangle3,
+  ctrRectRot as ctrRectRot2,
   figure as figure9,
   radToDeg as radToDeg7,
   ffix as ffix11,
@@ -3482,10 +3584,26 @@ var pDef9 = {
     pNumber9("H7", "mm", 600, 1, 2e3, 1),
     pNumber9("L9", "mm", 300, 1, 1e3, 1),
     pNumber9("R9", "mm", 50, 0, 300, 1),
-    pSectionSeparator8("stopper"),
+    pNumber9("doorOrientation", "degree", 0, -180, 180, 1),
+    pSectionSeparator8("stoppers"),
     pNumber9("S1", "mm", 100, 1, 300, 1),
     pNumber9("S2", "mm", 2e3, 1, 8e3, 1),
-    pNumber9("E7", "mm", 5, 1, 80, 1)
+    pNumber9("S3", "mm", 100, 0, 8e3, 1),
+    pNumber9("E7", "mm", 5, 1, 80, 1),
+    pSectionSeparator8("low stopper"),
+    pNumber9("JD1", "mm", 200, 1, 500, 1),
+    pNumber9("JE1", "mm", 5, 1, 80, 1),
+    pNumber9("JL1", "mm", 260, 1, 2e3, 1),
+    pNumber9("JH1", "mm", 20, -500, 500, 1),
+    pNumber9("JS1", "mm", 100, 1, 500, 1),
+    pNumber9("JS2", "mm", 200, 1, 500, 1),
+    pSectionSeparator8("high stopper"),
+    pNumber9("JD3", "mm", 200, 1, 500, 1),
+    pNumber9("JE3", "mm", 5, 1, 80, 1),
+    pNumber9("JS3", "mm", 120, 1, 500, 1),
+    pNumber9("JD4", "mm", 200, 1, 500, 1),
+    pNumber9("JE4", "mm", 5, 1, 80, 1),
+    pNumber9("JS4", "mm", 120, 1, 500, 1)
   ],
   paramSvg: {
     D1: "rake_face.svg",
@@ -3516,9 +3634,23 @@ var pDef9 = {
     H7: "rake_door.svg",
     L9: "rake_door.svg",
     R9: "rake_door.svg",
+    doorOrientation: "rake_door.svg",
     S1: "rake_side_stopper.svg",
     S2: "rake_top_stopper.svg",
-    E7: "rake_side_stopper.svg"
+    S3: "rake_side_stopper.svg",
+    E7: "rake_side_stopper.svg",
+    JD1: "rake_low_stopper_holder.svg",
+    JE1: "rake_low_stopper_holder.svg",
+    JL1: "rake_low_stopper_holder.svg",
+    JH1: "rake_low_stopper_holder.svg",
+    JS1: "rake_side_stopper.svg",
+    JS2: "rake_top_stopper.svg",
+    JD3: "rake_side_stopper.svg",
+    JE3: "rake_side_stopper.svg",
+    JS3: "rake_top_stopper.svg",
+    JD4: "rake_top_stopper.svg",
+    JE4: "rake_top_stopper.svg",
+    JS4: "rake_side_stopper.svg"
   },
   sim: {
     tMax: 180,
@@ -3529,7 +3661,6 @@ var pDef9 = {
 };
 function pGeom9(t, param, suffix = "") {
   const rGeome = initGeom9(pDef9.partName + suffix);
-  let ctrRect;
   const figCone = figure9();
   const figBeam = figure9();
   const figBeamHollow = figure9();
@@ -3545,36 +3676,80 @@ function pGeom9(t, param, suffix = "") {
   const figStopperFaceTH = figure9();
   const figStopperFaceB = figure9();
   const figStopperFaceBH = figure9();
+  const figLowStopperHolderPre = figure9();
+  const figLowStopperHolder = figure9();
+  const figHi1StopperHolder = figure9();
+  const figHi2StopperHolder = figure9();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const R1 = param.D1 / 2;
     const H1H2 = param.H1 + param.H2;
     const H1H5 = H1H2 - param.H4 + param.H5;
-    rGeome.logstr += `cone-height: ${ffix11(H1H2)} mm
-`;
-    rGeome.logstr += `cone-height total: ${ffix11(H1H5)} mm
-`;
+    const stopper1H = H1H5 - param.S2;
+    const Hi2SHpz = param.H1 + param.H2 - param.H4;
+    const stopper2H = Hi2SHpz + param.D4 / 2;
+    const stopper3H = param.H1 + param.S3;
+    const L5h = param.L5 / 2;
+    const S1r = param.S1 / 2;
+    const S1h = param.S1 - 2 * param.E7;
+    const S1hr = S1h / 2;
+    const lowStopperTopPosX = -R1 - param.S1 / 2 - param.JS1;
+    const S2s = param.S2 - S1r;
+    const lowSPosY = stopper1H - S1r;
+    const lowSHPosZ = stopper1H - param.JH1;
+    const JR1 = param.JD1 / 2;
+    const JR1H = JR1 - param.JE1;
+    const lowSHL = R1 + param.JS2;
+    const JR3 = param.JD3 / 2;
+    const JR4 = param.JD4 / 2;
+    const Hi2SHpy = L5h - S1r;
     if (2 * param.E7 >= param.S1) {
       throw `err135: E7 ${param.E7} too large compare to S1 ${param.S1}`;
     }
     if (param.L5 < param.D2) {
       throw `err138: L5 ${param.L5} too small compare to D2 ${param.D2}`;
     }
-    const stopper1H = H1H5 - param.S2;
-    if (stopper1H < 0) {
+    if (stopper1H - param.JH1 - param.JD1 / 2 < 0) {
       throw `err143: S2 ${param.S2} too large compare to H1H5 ${ffix11(H1H5)}`;
     }
-    const stopper2H = param.H1 + param.H2 - param.H4 + param.D4 / 2;
-    const stopper3H = param.H1 + param.L8 - param.S1;
-    ctrRect = function(width, height, xpos, ypos, angle) {
-      const xWidth = width * Math.cos(angle);
-      const yWidth = width * Math.sin(angle);
-      const xHeight = -height * Math.sin(angle);
-      const yHeight = height * Math.cos(angle);
-      const rCtr = contour10(xpos, ypos).addSegStrokeA(xpos + xWidth, ypos + yWidth).addSegStrokeA(xpos + xWidth + xHeight, ypos + yWidth + yHeight).addSegStrokeA(xpos + xHeight, ypos + yHeight).closeSegStroke();
-      return rCtr;
-    };
+    if (param.JS1 < param.S1 / 2) {
+      throw `err144: JS1 ${param.JS1} too small compare to S1 ${param.S1}`;
+    }
+    if (param.JE1 > param.JD1 / 2) {
+      throw `err145: JE1 ${param.JE1} too large compare to JD1 ${param.JD1}`;
+    }
+    if (param.JL1 > param.D1) {
+      throw `err146: JL1 ${param.JL1} too large compare to D1 ${param.D1}`;
+    }
+    if (param.JL1 < param.JD1) {
+      throw `err147: JL1 ${param.JL1} too small compare to JD1 ${param.JD1}`;
+    }
+    if (Math.abs(param.JH1) > param.JD1 / 2 + S1r) {
+      throw `err148: JH1 ${param.JH1} too large compare to JD1 ${param.JD1} and S1 ${param.S1}`;
+    }
+    if (param.JS2 < param.JS1 - S1r) {
+      throw `err149: JS2 ${param.JS2} too small compare to JS1 ${param.JS1} and S1 ${param.S1}`;
+    }
+    if (param.S3 > param.H2 - param.H4) {
+      throw `err150: S3 ${param.S3} too large compare to H2 ${param.H2} and H4 ${param.H4}`;
+    }
+    if (param.JE3 > param.JD3 / 2) {
+      throw `err151: JE3 ${param.JE3} too large compare to JD3 ${param.JD3}`;
+    }
+    if (param.JE4 > param.JD4 / 2) {
+      throw `err152: JE4 ${param.JE4} too large compare to JD4 ${param.JD4}`;
+    }
+    rGeome.logstr += `cone-height: ${ffix11(H1H2)} mm
+`;
+    rGeome.logstr += `cone-height total: ${ffix11(H1H5)} mm
+`;
+    figLowStopperHolderPre.addSecond(ctrRectangle3(-L5h, lowSPosY, param.L5, param.S1));
+    figLowStopperHolderPre.addSecond(ctrRectangle3(-L5h, lowSPosY + param.E7, param.L5, S1h));
+    figLowStopperHolderPre.addMain(contourCircle8(-param.JL1 / 2, lowSHPosZ, JR1));
+    figLowStopperHolderPre.addMain(contourCircle8(-param.JL1 / 2, lowSHPosZ, JR1H));
+    figLowStopperHolderPre.addMain(contourCircle8(param.JL1 / 2, lowSHPosZ, JR1));
+    figLowStopperHolderPre.addMain(contourCircle8(param.JL1 / 2, lowSHPosZ, JR1H));
     const rakeParam = designParam4(rakeDef.pDef);
     rakeParam.setVal("D1", param.D1);
     rakeParam.setVal("D2", param.D2);
@@ -3604,10 +3779,12 @@ function pGeom9(t, param, suffix = "") {
     rakeParam.setVal("H7", param.H7);
     rakeParam.setVal("L9", param.L9);
     rakeParam.setVal("R9", param.R9);
+    rakeParam.setVal("doorOrientation", param.doorOrientation);
     const rakeGeom = rakeDef.pGeom(0, rakeParam.getParamVal(), rakeParam.getSuffix());
     checkGeom4(rakeGeom);
     rGeome.logstr += prefixLog4(rakeGeom.logstr, rakeParam.getPartNameSuffix());
     figCone.mergeFigure(rakeGeom.fig.faceCone);
+    figCone.mergeFigure(figLowStopperHolderPre, true);
     figBeam.mergeFigure(rakeGeom.fig.faceBeam);
     figBeamHollow.mergeFigure(rakeGeom.fig.faceBeamHollow);
     figDisc.mergeFigure(rakeGeom.fig.faceDisc);
@@ -3615,71 +3792,106 @@ function pGeom9(t, param, suffix = "") {
     figWing.mergeFigure(rakeGeom.fig.faceWing);
     figWingHollow.mergeFigure(rakeGeom.fig.faceWingHollow);
     figDoor.mergeFigure(rakeGeom.fig.faceDoor);
+    figDoor.mergeFigure(figLowStopperHolderPre, true);
     figStopperTop.mergeFigure(rakeGeom.fig.faceDisc, true);
-    const L5h = param.L5 / 2;
-    const S1r = param.S1 / 2;
-    const S1h = param.S1 - 2 * param.E7;
-    const S1hr = S1h / 2;
-    figStopperTop.addMain(ctrRect(param.S1, param.L5, -R1 - param.S1, -L5h, 0));
-    figStopperTop.addMain(ctrRect(S1h, param.L5, -R1 - param.E7 - S1h, -L5h, 0));
-    figStopperTop.addMain(ctrRect(param.S1, param.L5, param.S2 - param.S1, -L5h, 0));
-    figStopperTop.addMain(ctrRect(S1h, param.L5, param.S2 - param.E7 - S1h, -L5h, 0));
-    const S2s = param.S2 - param.S1 / 2;
-    figStopperTop.addMain(ctrRect(S2s, param.S1, 0, -L5h, 0));
-    figStopperTop.addMain(ctrRect(S2s, S1h, 0, -L5h + param.E7, 0));
-    figStopperTop.addMain(ctrRect(S2s, param.S1, 0, L5h - param.S1, 0));
-    figStopperTop.addMain(ctrRect(S2s, S1h, 0, L5h - param.S1 + param.E7, 0));
-    figStopperTop.addMain(ctrRect(S2s, param.S1, 0, -R1 - param.S1, 0));
-    figStopperTop.addMain(ctrRect(S2s, S1h, 0, -R1 - param.S1 + param.E7, 0));
-    figStopperTop.addMain(ctrRect(S2s, param.S1, 0, R1, 0));
-    figStopperTop.addMain(ctrRect(S2s, S1h, 0, R1 + param.E7, 0));
+    figStopperTop.addMain(ctrRectangle3(lowStopperTopPosX, -L5h, param.S1, param.L5));
+    figStopperTop.addMain(ctrRectangle3(lowStopperTopPosX + param.E7, -L5h, S1h, param.L5));
+    figStopperTop.addMain(ctrRectangle3(param.S2 - param.S1, -L5h, param.S1, param.L5));
+    figStopperTop.addMain(ctrRectangle3(param.S2 - param.E7 - S1h, -L5h, S1h, param.L5));
+    figStopperTop.addMain(ctrRectangle3(0, -L5h, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle3(0, -L5h + param.E7, S2s, S1h));
+    figStopperTop.addMain(ctrRectangle3(0, L5h - param.S1, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle3(0, L5h - param.S1 + param.E7, S2s, S1h));
+    figStopperTop.addMain(ctrRectangle3(0, -R1 - param.S1, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle3(0, -R1 - param.S1 + param.E7, S2s, S1h));
+    figStopperTop.addMain(ctrRectangle3(0, R1, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle3(0, R1 + param.E7, S2s, S1h));
+    figStopperTop.addSecond(ctrRectangle3(-lowSHL, -param.JL1 / 2 - JR1, lowSHL, 2 * JR1));
+    figStopperTop.addSecond(ctrRectangle3(-lowSHL, -param.JL1 / 2 - JR1H, lowSHL, 2 * JR1H));
+    figStopperTop.addSecond(ctrRectangle3(-lowSHL, param.JL1 / 2 - JR1, lowSHL, 2 * JR1));
+    figStopperTop.addSecond(ctrRectangle3(-lowSHL, param.JL1 / 2 - JR1H, lowSHL, 2 * JR1H));
+    const Hi1SHL = R1 + param.JS3;
+    const Hi1SHW = param.JD3 - 2 * param.JE3;
+    figStopperTop.addSecond(ctrRectangle3(-param.JD3 / 2, -Hi1SHL, param.JD3, Hi1SHL));
+    figStopperTop.addSecond(ctrRectangle3(-param.JD3 / 2 + param.JE3, -Hi1SHL, Hi1SHW, Hi1SHL));
+    figStopperTop.addSecond(ctrRectangle3(-param.JD3 / 2, 0, param.JD3, Hi1SHL));
+    figStopperTop.addSecond(ctrRectangle3(-param.JD3 / 2 + param.JE3, 0, Hi1SHW, Hi1SHL));
     figStopperSide.mergeFigure(rakeGeom.fig.faceBeam, true);
-    figStopperSide.addMain(contourCircle8(-R1 - S1r, stopper1H + S1r, S1r));
-    figStopperSide.addMain(contourCircle8(-R1 - S1r, stopper1H + S1r, S1hr));
-    figStopperSide.addMain(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1r));
-    figStopperSide.addMain(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1hr));
-    figStopperSide.addSecond(ctrRect(S2s, param.S1, 0, stopper2H, 0));
-    figStopperSide.addSecond(ctrRect(S2s, S1h, 0, stopper2H + param.E7, 0));
-    const stopper3Ly = stopper2H + param.S1 / 2 - stopper3H;
-    const stopper3L = Math.sqrt(S2s ** 2 + stopper3Ly ** 2);
-    const stopper3A = Math.atan2(stopper3Ly, S2s);
-    rGeome.logstr += `stopper-rod: L ${ffix11(stopper3L)} mm, A ${ffix11(
-      radToDeg7(stopper3A)
-    )} degree
+    figStopperSide.addMain(contourCircle8(-R1 - param.JS1, stopper1H, S1r));
+    figStopperSide.addMain(contourCircle8(-R1 - param.JS1, stopper1H, S1hr));
+    figStopperSide.addMain(contourCircle8(S2s, stopper2H + S1r, S1r));
+    figStopperSide.addMain(contourCircle8(S2s, stopper2H + S1r, S1hr));
+    figStopperSide.addSecond(ctrRectangle3(0, stopper2H, S2s, param.S1));
+    figStopperSide.addSecond(ctrRectangle3(0, stopper2H + param.E7, S2s, S1h));
+    const stopper3Ly = stopper2H + S1r - stopper3H;
+    const stp3L = Math.sqrt(S2s ** 2 + stopper3Ly ** 2);
+    const stp3A = Math.atan2(stopper3Ly, S2s);
+    rGeome.logstr += `stopper-rod: L ${ffix11(stp3L)} mm, A ${ffix11(radToDeg7(stp3A))} degree
 `;
-    const stp3posdX = S1r * Math.sin(stopper3A);
-    const stp3posdY = S1r * Math.cos(stopper3A);
+    const stp3posdX = S1r * Math.sin(stp3A);
+    const stp3posdY = S1r * Math.cos(stp3A);
     const stp3posY = stopper3H - stp3posdY;
-    figStopperSide.addSecond(ctrRect(stopper3L, param.S1, stp3posdX, stp3posY, stopper3A));
-    const stp3posdX2 = S1hr * Math.sin(stopper3A);
-    const stp3posdY2 = S1hr * Math.cos(stopper3A);
+    figStopperSide.addSecond(ctrRectRot2(stp3posdX, stp3posY, stp3L, param.S1, stp3A));
+    const stp3posdX2 = S1hr * Math.sin(stp3A);
+    const stp3posdY2 = S1hr * Math.cos(stp3A);
     const stp3posY2 = stopper3H - stp3posdY2;
-    figStopperSide.addSecond(ctrRect(stopper3L, S1h, stp3posdX2, stp3posY2, stopper3A));
-    figStopperSideH.mergeFigure(rakeGeom.fig.faceBeam, true);
-    figStopperSideH.addSecond(contourCircle8(-R1 - S1r, stopper1H + S1r, S1r));
-    figStopperSideH.addMain(contourCircle8(-R1 - S1r, stopper1H + S1r, S1hr));
-    figStopperSideH.addSecond(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1r));
+    figStopperSide.addSecond(ctrRectRot2(stp3posdX2, stp3posY2, stp3L, S1h, stp3A));
+    figStopperSide.addSecond(ctrRectangle3(-lowSHL, lowSHPosZ - JR1, lowSHL, 2 * JR1));
+    figStopperSide.addSecond(ctrRectangle3(-lowSHL, lowSHPosZ - JR1H, lowSHL, 2 * JR1H));
+    figStopperSide.addSecond(contourCircle8(0, stopper3H, param.JD3 / 2));
+    figStopperSide.addSecond(contourCircle8(0, stopper3H, param.JD3 / 2 - param.JE3));
+    const Hi2SHL = param.D4 / 2 + param.JS4;
+    const Hi2SHW2 = param.JD4 / 2 - param.JE4;
+    figStopperSide.addSecond(ctrRectangle3(-param.JD4 / 2, Hi2SHpz, param.JD4, Hi2SHL));
+    figStopperSide.addSecond(ctrRectangle3(-Hi2SHW2, Hi2SHpz, 2 * Hi2SHW2, Hi2SHL));
+    figStopperSideH.mergeFigure(figStopperSide, true);
+    figStopperSideH.addMain(contourCircle8(-R1 - param.JS1, stopper1H, S1hr));
     figStopperSideH.addMain(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1hr));
     figStopperFaceT.mergeFigure(rakeGeom.fig.faceCone, true);
+    figStopperFaceT.mergeFigure(figLowStopperHolderPre, true);
     figStopperFaceT.addMain(contourCircle8(-param.L5 / 2 + S1r, stopper2H + S1r, S1r));
     figStopperFaceT.addMain(contourCircle8(-param.L5 / 2 + S1r, stopper2H + S1r, S1hr));
     figStopperFaceT.addMain(contourCircle8(param.L5 / 2 - S1r, stopper2H + S1r, S1r));
     figStopperFaceT.addMain(contourCircle8(param.L5 / 2 - S1r, stopper2H + S1r, S1hr));
     figStopperFaceTH.mergeFigure(rakeGeom.fig.faceCone, true);
+    figStopperFaceTH.mergeFigure(figLowStopperHolderPre, true);
     figStopperFaceTH.addSecond(contourCircle8(-param.L5 / 2 + S1r, stopper2H + S1r, S1r));
     figStopperFaceTH.addMain(contourCircle8(-param.L5 / 2 + S1r, stopper2H + S1r, S1hr));
     figStopperFaceTH.addSecond(contourCircle8(param.L5 / 2 - S1r, stopper2H + S1r, S1r));
     figStopperFaceTH.addMain(contourCircle8(param.L5 / 2 - S1r, stopper2H + S1r, S1hr));
     figStopperFaceB.mergeFigure(rakeGeom.fig.faceCone, true);
+    figStopperFaceB.mergeFigure(figLowStopperHolderPre, true);
     figStopperFaceB.addMain(contourCircle8(-R1 - S1r, 0, S1r));
     figStopperFaceB.addMain(contourCircle8(-R1 - S1r, 0, S1hr));
     figStopperFaceB.addMain(contourCircle8(R1 + S1r, 0, S1r));
     figStopperFaceB.addMain(contourCircle8(R1 + S1r, 0, S1hr));
     figStopperFaceBH.mergeFigure(rakeGeom.fig.faceCone, true);
+    figStopperFaceBH.mergeFigure(figLowStopperHolderPre, true);
     figStopperFaceBH.addSecond(contourCircle8(-R1 - S1r, 0, S1r));
     figStopperFaceBH.addMain(contourCircle8(-R1 - S1r, 0, S1hr));
     figStopperFaceBH.addSecond(contourCircle8(R1 + S1r, 0, S1r));
     figStopperFaceBH.addMain(contourCircle8(R1 + S1r, 0, S1hr));
+    figLowStopperHolder.mergeFigure(rakeGeom.fig.faceCone, true);
+    figLowStopperHolder.mergeFigure(figLowStopperHolderPre);
+    const px8 = -Hi2SHpy - Hi2SHW2;
+    const px9 = Hi2SHpy - Hi2SHW2;
+    const py10 = stopper3H - Hi1SHW / 2;
+    figLowStopperHolder.addSecond(ctrRectangle3(-Hi2SHpy - JR4, Hi2SHpz, param.JD4, Hi2SHL));
+    figLowStopperHolder.addSecond(ctrRectangle3(px8, Hi2SHpz, 2 * Hi2SHW2, Hi2SHL));
+    figLowStopperHolder.addSecond(ctrRectangle3(Hi2SHpy - JR4, Hi2SHpz, param.JD4, Hi2SHL));
+    figLowStopperHolder.addSecond(ctrRectangle3(px9, Hi2SHpz, 2 * Hi2SHW2, Hi2SHL));
+    figLowStopperHolder.addSecond(ctrRectangle3(-Hi1SHL, stopper3H - JR3, Hi1SHL, param.JD3));
+    figLowStopperHolder.addSecond(ctrRectangle3(-Hi1SHL, py10, Hi1SHL, Hi1SHW));
+    figLowStopperHolder.addSecond(ctrRectangle3(0, stopper3H - JR3, Hi1SHL, param.JD3));
+    figLowStopperHolder.addSecond(ctrRectangle3(0, stopper3H - Hi1SHW / 2, Hi1SHL, Hi1SHW));
+    figHi1StopperHolder.mergeFigure(figStopperSide, true);
+    figHi1StopperHolder.addMain(contourCircle8(0, stopper3H, param.JD3 / 2));
+    figHi1StopperHolder.addMain(contourCircle8(0, stopper3H, param.JD3 / 2 - param.JE3));
+    figHi2StopperHolder.mergeFigure(figStopperTop, true);
+    figHi2StopperHolder.addMain(contourCircle8(0, -Hi2SHpy, JR4));
+    figHi2StopperHolder.addMain(contourCircle8(0, -Hi2SHpy, JR4 - param.JE4));
+    figHi2StopperHolder.addMain(contourCircle8(0, Hi2SHpy, JR4));
+    figHi2StopperHolder.addMain(contourCircle8(0, Hi2SHpy, JR4 - param.JE4));
     rGeome.fig = {
       faceCone: figCone,
       faceBeam: figBeam,
@@ -3695,7 +3907,10 @@ function pGeom9(t, param, suffix = "") {
       faceStopperFaceT: figStopperFaceT,
       faceStopperFaceTH: figStopperFaceTH,
       faceStopperFaceB: figStopperFaceB,
-      faceStopperFaceBH: figStopperFaceBH
+      faceStopperFaceBH: figStopperFaceBH,
+      faceLowStopperHolder: figLowStopperHolder,
+      faceHi1StopperHolder: figHi1StopperHolder,
+      faceHi2StopperHolder: figHi2StopperHolder
     };
     const designName = rGeome.partName;
     rGeome.vol = {
@@ -3706,6 +3921,20 @@ function pGeom9(t, param, suffix = "") {
           subgeom: rakeGeom,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
+        },
+        {
+          outName: `inpax_${designName}_coneHollow`,
+          subdesign: "subpax_rake_coneHollow",
+          subgeom: rakeGeom,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `inpax_${designName}_beamHollow`,
+          subdesign: "subpax_rake_beamHollow",
+          subgeom: rakeGeom,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
         }
       ],
       extrudes: [
@@ -3745,17 +3974,49 @@ function pGeom9(t, param, suffix = "") {
           outName: `subpax_${designName}_stpFaceB`,
           face: `${designName}_faceStopperFaceB`,
           extrudeMethod: EExtrude7.eLinearOrtho,
-          length: stopper3L,
-          rotate: [Math.PI / 2 - stopper3A, 0, Math.PI / 2],
+          length: stp3L,
+          rotate: [Math.PI / 2 - stp3A, 0, Math.PI / 2],
           translate: [0, 0, stopper3H]
         },
         {
           outName: `subpax_${designName}_stpFaceBH`,
           face: `${designName}_faceStopperFaceBH`,
           extrudeMethod: EExtrude7.eLinearOrtho,
-          length: stopper3L,
-          rotate: [Math.PI / 2 - stopper3A, 0, Math.PI / 2],
+          length: stp3L,
+          rotate: [Math.PI / 2 - stp3A, 0, Math.PI / 2],
           translate: [0, 0, stopper3H]
+        },
+        {
+          outName: `subpax_${designName}_lowSH`,
+          face: `${designName}_faceLowStopperHolder`,
+          extrudeMethod: EExtrude7.eLinearOrtho,
+          length: lowSHL,
+          rotate: [Math.PI / 2, 0, -Math.PI / 2],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_Hi1SH1`,
+          face: `${designName}_faceHi1StopperHolder`,
+          extrudeMethod: EExtrude7.eLinearOrtho,
+          length: Hi1SHL,
+          rotate: [Math.PI / 2, 0, 0],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_Hi1SH2`,
+          face: `${designName}_faceHi1StopperHolder`,
+          extrudeMethod: EExtrude7.eLinearOrtho,
+          length: Hi1SHL,
+          rotate: [Math.PI / 2, 0, Math.PI],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_Hi2SH`,
+          face: `${designName}_faceHi2StopperHolder`,
+          extrudeMethod: EExtrude7.eLinearOrtho,
+          length: Hi2SHL,
+          rotate: [0, 0, 0],
+          translate: [0, 0, Hi2SHpz]
         }
       ],
       volumes: [
@@ -3765,13 +4026,19 @@ function pGeom9(t, param, suffix = "") {
           inList: [
             `subpax_${designName}_stpSide`,
             `subpax_${designName}_stpFaceT`,
-            `subpax_${designName}_stpFaceB`
+            `subpax_${designName}_stpFaceB`,
+            `subpax_${designName}_lowSH`,
+            `subpax_${designName}_Hi1SH1`,
+            `subpax_${designName}_Hi1SH2`,
+            `subpax_${designName}_Hi2SH`
           ]
         },
         {
           outName: `ipax_${designName}_hollow`,
           boolMethod: EBVolume9.eUnion,
           inList: [
+            `inpax_${designName}_coneHollow`,
+            `inpax_${designName}_beamHollow`,
             `subpax_${designName}_stpSideH`,
             `subpax_${designName}_stpFaceTH`,
             `subpax_${designName}_stpFaceBH`
@@ -3893,7 +4160,7 @@ function pGeom10(t, param, suffix = "") {
     rGeome.logstr += `heliostat-swing-length: ${ffix12(param.L1)}, width ${ffix12(param.L2)} m
 `;
     const posAngleDegree = param.al * t / pDef10.sim.tMax;
-    const posAngle = degToRad5(posAngleDegree);
+    const posAngle = degToRad6(posAngleDegree);
     rGeome.logstr += `swing position angle: ${ffix12(radToDeg8(posAngle))} degree
 `;
     const rakePosY = param.H1 + param.H2 - param.H3;
@@ -4085,7 +4352,7 @@ var heliostat_2Def = {
 
 // src/heliostat/base.ts
 import {
-  contour as contour11,
+  contour as contour10,
   contourCircle as contourCircle9,
   figure as figure11,
   ffix as ffix13,
@@ -4172,11 +4439,11 @@ function pGeom11(t, param, suffix = "") {
     rGeome.logstr += `inter-hollow: ${ffix13(interHollow)} mm
 `;
     ctrBaseCut1 = function(orient) {
-      const rBaseCut1 = contour11(orient * R2, 0).addSegStrokeA(orient * R2, param.E3).addSegStrokeA(orient * R1, param.E3).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * (R1 - param.E2), param.H1).addSegStrokeA(orient * (R1 - param.E2), param.E3).addSegStrokeA(orient * R4, param.E3).addSegStrokeA(orient * R4, 0).closeSegStroke();
+      const rBaseCut1 = contour10(orient * R2, 0).addSegStrokeA(orient * R2, param.E3).addSegStrokeA(orient * R1, param.E3).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * (R1 - param.E2), param.H1).addSegStrokeA(orient * (R1 - param.E2), param.E3).addSegStrokeA(orient * R4, param.E3).addSegStrokeA(orient * R4, 0).closeSegStroke();
       return rBaseCut1;
     };
     ctrBaseCut2 = function(orient) {
-      const rBaseCut2 = contour11(orient * R2, 0).addSegStrokeA(orient * R2, param.E3).addSegStrokeA(orient * R1, param.E3).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R3, param.H1).addSegStrokeA(orient * R3, param.H1 - param.E1).addSegStrokeA(orient * (R1 - param.E2), param.H1 - param.E1).addSegStrokeA(orient * (R1 - param.E2), param.E3).addSegStrokeA(orient * R4, param.E3).addSegStrokeA(orient * R4, 0).closeSegStroke();
+      const rBaseCut2 = contour10(orient * R2, 0).addSegStrokeA(orient * R2, param.E3).addSegStrokeA(orient * R1, param.E3).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R3, param.H1).addSegStrokeA(orient * R3, param.H1 - param.E1).addSegStrokeA(orient * (R1 - param.E2), param.H1 - param.E1).addSegStrokeA(orient * (R1 - param.E2), param.E3).addSegStrokeA(orient * R4, param.E3).addSegStrokeA(orient * R4, 0).closeSegStroke();
       return rBaseCut2;
     };
     if (param.H1 < param.E3 + param.H2 + param.H3 + param.E1) {
@@ -4191,7 +4458,7 @@ function pGeom11(t, param, suffix = "") {
     }
     const hollowH = param.E3 + param.H2 + RL2;
     ctrHollow = function(orient) {
-      const rHollow = contour11(orient * RL2, hollowH).addSegStrokeA(orient * RL2, hollowH + param.H3 - param.L2).addPointA(-orient * RL2, hollowH + param.H3 - param.L2).addSegArc(RL2, false, true).addSegStrokeA(-orient * RL2, hollowH).closeSegArc(RL2, false, true);
+      const rHollow = contour10(orient * RL2, hollowH).addSegStrokeA(orient * RL2, hollowH + param.H3 - param.L2).addPointA(-orient * RL2, hollowH + param.H3 - param.L2).addSegArc(RL2, false, true).addSegStrokeA(-orient * RL2, hollowH).closeSegArc(RL2, false, true);
       return rHollow;
     };
     figCut.addMain(ctrBaseCut1(1));
@@ -4298,7 +4565,7 @@ var baseDef = {
 
 // src/heliostat/vaxis.ts
 import {
-  contour as contour12,
+  contour as contour11,
   contourCircle as contourCircle10,
   figure as figure12,
   ffix as ffix14,
@@ -4352,10 +4619,10 @@ function pGeom12(t, param, suffix = "") {
     const R3 = param.D3 / 2;
     rGeome.logstr += `vaxis-height: ${ffix14(param.H1)} mm
 `;
-    const ctrCylinder = contour12(R1, 0).addSegStrokeA(R1, param.H1).addSegStrokeA(R1 - param.E1, param.H1).addSegStrokeA(R1 - param.E1, 0).closeSegStroke();
+    const ctrCylinder = contour11(R1, 0).addSegStrokeA(R1, param.H1).addSegStrokeA(R1 - param.E1, param.H1).addSegStrokeA(R1 - param.E1, 0).closeSegStroke();
     figCut.addMain(ctrCylinder);
     ctrPoleProfile = function(orient) {
-      const rPoleProfile = contour12(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, param.H1).addSegStrokeA(orient * R2, param.H1 - param.E2).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.E2).addSegStrokeA(orient * (R1 - param.E1), param.E2).addSegStrokeA(orient * R2, param.E2).addSegStrokeA(orient * R2, 0).closeSegStroke();
+      const rPoleProfile = contour11(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, param.H1).addSegStrokeA(orient * R2, param.H1 - param.E2).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.E2).addSegStrokeA(orient * (R1 - param.E1), param.E2).addSegStrokeA(orient * R2, param.E2).addSegStrokeA(orient * R2, 0).closeSegStroke();
       return rPoleProfile;
     };
     figCut.addSecond(ctrPoleProfile(1));
@@ -4431,7 +4698,7 @@ var vaxisDef = {
 
 // src/heliostat/ring.ts
 import {
-  contour as contour13,
+  contour as contour12,
   contourCircle as contourCircle11,
   figure as figure13,
   ffix as ffix15,
@@ -4503,7 +4770,7 @@ function pGeom13(t, param, suffix = "") {
     const tR1 = R3 - param.L2;
     const tR2 = tR1 - param.L3;
     const tA = 2 * Math.PI / (2 * param.N1);
-    const ctrTeeth = contour13(tR1, 0);
+    const ctrTeeth = contour12(tR1, 0);
     for (let i = 0; i < param.N1; i++) {
       const ti1 = 2 * i + 1;
       const ti2 = 2 * i + 2;
@@ -4527,17 +4794,17 @@ function pGeom13(t, param, suffix = "") {
     figRingTeeth.addMain(contourCircle11(0, 0, R3));
     figRingTeeth.addMain(ctrTeeth);
     figRingTeeth.addSecond(contourCircle11(0, 0, R1));
-    const ctrInner = contour13(R1, 0).addSegStrokeA(-R1, 0).addSegStrokeA(-R1, -param.H1).addSegStrokeA(R1, -param.H1).closeSegStroke();
+    const ctrInner = contour12(R1, 0).addSegStrokeA(-R1, 0).addSegStrokeA(-R1, -param.H1).addSegStrokeA(R1, -param.H1).closeSegStroke();
     const ctrScrewHole = function(rnl) {
-      const rCtr = contour13(rnl * (R1 + param.L1) + R2, 0).addSegStrokeR(-2 * R2, 0).addSegStrokeR(0, -param.H1).addSegStrokeR(2 * R2, 0).closeSegStroke();
+      const rCtr = contour12(rnl * (R1 + param.L1) + R2, 0).addSegStrokeR(-2 * R2, 0).addSegStrokeR(0, -param.H1).addSegStrokeR(2 * R2, 0).closeSegStroke();
       return rCtr;
     };
     const ctrGearTeeth = function(rnl) {
-      const rCtr = contour13(rnl * (R3 - param.L2), -param.H1).addSegStrokeR(-rnl * param.L3, 0).addSegStrokeR(0, -param.H2).addSegStrokeR(rnl * param.L3, 0).closeSegStroke();
+      const rCtr = contour12(rnl * (R3 - param.L2), -param.H1).addSegStrokeR(-rnl * param.L3, 0).addSegStrokeR(0, -param.H2).addSegStrokeR(rnl * param.L3, 0).closeSegStroke();
       return rCtr;
     };
     const ctrL = function(rnl) {
-      const rCtr = contour13(rnl * R3, 0).addSegStrokeR(-rnl * (R3 - R1), 0).addSegStrokeR(0, -param.H1).addSegStrokeR(rnl * (R3 - param.L2 - param.L3 - R1), 0).addSegStrokeR(0, -param.H2).addSegStrokeR(rnl * (param.L2 + param.L3), 0).closeSegStroke();
+      const rCtr = contour12(rnl * R3, 0).addSegStrokeR(-rnl * (R3 - R1), 0).addSegStrokeR(0, -param.H1).addSegStrokeR(rnl * (R3 - param.L2 - param.L3 - R1), 0).addSegStrokeR(0, -param.H2).addSegStrokeR(rnl * (param.L2 + param.L3), 0).closeSegStroke();
       return rCtr;
     };
     figSection.addSecond(ctrInner);
@@ -4598,7 +4865,7 @@ var ringDef = {
 
 // src/heliostat/ring_guidance.ts
 import {
-  contour as contour14,
+  contour as contour13,
   contourCircle as contourCircle12,
   figure as figure14,
   ffix as ffix16,
@@ -4684,7 +4951,7 @@ function pGeom14(t, param, suffix = "") {
       figTop.addMain(contourCircle12(R1, 0, R3).rotate(0, 0, i * stepA1));
     }
     const rect = function(xbl, ybl, width, height) {
-      const rCtr = contour14(xbl, ybl).addSegStrokeR(width, 0).addSegStrokeR(0, height).addSegStrokeR(-width, 0).closeSegStroke();
+      const rCtr = contour13(xbl, ybl).addSegStrokeR(width, 0).addSegStrokeR(0, height).addSegStrokeR(-width, 0).closeSegStroke();
       return rCtr;
     };
     const w1 = R1 - R6 + R4;
@@ -4738,10 +5005,11 @@ var ringGuidanceDef = {
 // src/heliostat/vaxis_guidance.ts
 import {
   contourCircle as contourCircle13,
-  ctrRectangle as ctrRectangle2,
+  ctrRectangle as ctrRectangle4,
   figure as figure15,
   ffix as ffix17,
   pNumber as pNumber15,
+  pDropdown as pDropdown2,
   pSectionSeparator as pSectionSeparator14,
   initGeom as initGeom15,
   EExtrude as EExtrude12,
@@ -4759,18 +5027,22 @@ var pDef15 = {
     pNumber15("D4", "mm", 50, 1, 200, 1),
     pNumber15("L1", "mm", 90, 1, 900, 1),
     pNumber15("R5", "mm", 20, 0, 500, 1),
-    pSectionSeparator14("inner spring"),
+    pSectionSeparator14("inner"),
     pNumber15("D6", "mm", 540, 1, 1e3, 1),
     pNumber15("N2", "springs", 6, 1, 24, 1),
+    pDropdown2("orientation", ["ccw", "cw", "alt"]),
     pNumber15("R7", "mm", 10, 0, 100, 1),
-    pNumber15("a1", "degree", 0, -45, 45, 1),
-    pNumber15("E2", "mm", 50, 1, 200, 1),
-    pNumber15("E1", "mm", 10, 1, 200, 1),
-    pNumber15("W1", "mm", 20, 1, 200, 1),
     pNumber15("L2", "mm", 100, 1, 900, 1),
-    pNumber15("L3", "mm", 40, 1, 900, 1),
-    pNumber15("N3", "loops", 2, 0, 8, 1),
-    pNumber15("L4", "mm", 40, 0, 900, 1),
+    pNumber15("E2", "mm", 20, 1, 200, 1),
+    pSectionSeparator14("spring"),
+    pNumber15("SA1", "degree", 0, -45, 45, 1),
+    pNumber15("SE1", "mm", 10, 1, 200, 1),
+    pNumber15("SD1", "mm", 20, 1, 200, 1),
+    pNumber15("SD2", "mm", 10, 1, 200, 1),
+    pNumber15("SN1", "loops", 2, 0, 8, 1),
+    pNumber15("SL1", "mm", 40, 1, 900, 1),
+    pNumber15("SL2", "mm", 70, 0, 900, 1),
+    pDropdown2("Send", ["round", "pike"]),
     pSectionSeparator14("thickness"),
     pNumber15("T1", "mm", 10, 1, 200, 1),
     pNumber15("Dvaxis", "mm", 260, 5, 1e3, 1)
@@ -4785,15 +5057,18 @@ var pDef15 = {
     R5: "vaxis_guidance_top.svg",
     D6: "vaxis_guidance_top.svg",
     N2: "vaxis_guidance_top.svg",
+    orientation: "vaxis_guidance_top.svg",
     R7: "vaxis_guidance_top.svg",
-    a1: "vaxis_guidance_spring.svg",
-    E2: "vaxis_guidance_top.svg",
-    E1: "vaxis_guidance_spring.svg",
-    W1: "vaxis_guidance_spring.svg",
     L2: "vaxis_guidance_spring.svg",
-    L3: "vaxis_guidance_spring.svg",
-    N3: "vaxis_guidance_spring.svg",
-    L4: "vaxis_guidance_spring.svg",
+    E2: "vaxis_guidance_spring.svg",
+    SA1: "vaxis_guidance_spring.svg",
+    SE1: "vaxis_guidance_spring.svg",
+    SD1: "vaxis_guidance_spring.svg",
+    SD2: "vaxis_guidance_spring.svg",
+    SN1: "vaxis_guidance_spring.svg",
+    SL1: "vaxis_guidance_spring.svg",
+    SL2: "vaxis_guidance_spring.svg",
+    Send: "vaxis_guidance_spring.svg",
     T1: "vaxis_guidance_top.svg",
     Dvaxis: "vaxis_guidance_top.svg"
   },
@@ -4832,10 +5107,10 @@ function pGeom15(t, param, suffix = "") {
     figTop.addMain(innerCtr);
     figTop.addSecond(contourCircle13(0, 0, param.Dvaxis / 2));
     const w1 = R1 - R6 + R4;
-    figSection.addMain(ctrRectangle2(R6, 0, w1, param.T1));
-    figSection.addMain(ctrRectangle2(-R6 - w1, 0, w1, param.T1));
-    figSection.addSecond(ctrRectangle2(R1 - R3, 0, 2 * R3, param.T1));
-    figSection.addSecond(ctrRectangle2(-R1 - R3, 0, 2 * R3, param.T1));
+    figSection.addMain(ctrRectangle4(R6, 0, w1, param.T1));
+    figSection.addMain(ctrRectangle4(-R6 - w1, 0, w1, param.T1));
+    figSection.addSecond(ctrRectangle4(R1 - R3, 0, 2 * R3, param.T1));
+    figSection.addSecond(ctrRectangle4(-R1 - R3, 0, 2 * R3, param.T1));
     rGeome.fig = {
       faceTop: figTop,
       faceSection: figSection
@@ -4876,37 +5151,193 @@ var vaxisGuidanceDef = {
   pGeom: pGeom15
 };
 
-// src/heliostat/rod.ts
+// src/heliostat/haxis_guidance.ts
 import {
-  contour as contour15,
+  point as point6,
+  contour as contour14,
   contourCircle as contourCircle14,
+  ctrRectangle as ctrRectangle5,
   figure as figure16,
+  degToRad as degToRad7,
   ffix as ffix18,
   pNumber as pNumber16,
+  pDropdown as pDropdown3,
   pSectionSeparator as pSectionSeparator15,
   initGeom as initGeom16,
   EExtrude as EExtrude13,
   EBVolume as EBVolume16
 } from "geometrix";
 var pDef16 = {
+  partName: "haxis_guidance",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber16("D5", "mm", 600, 1, 2e3, 1),
+    pNumber16("D8", "mm", 1e3, 1, 2e3, 1),
+    pSectionSeparator15("outer details"),
+    pNumber16("E5", "mm", 1, 0, 200, 1),
+    pNumber16("E8", "mm", 20, 1, 200, 1),
+    pNumber16("L5", "mm", 20, 1, 200, 1),
+    pNumber16("R9", "mm", 20, 0, 500, 1),
+    pSectionSeparator15("inner spring"),
+    pNumber16("SA1", "degree", 0, -45, 45, 1),
+    pNumber16("SE1", "mm", 2, 0.1, 100, 0.1),
+    pNumber16("SD1", "mm", 20, 1, 200, 1),
+    pNumber16("SD2", "mm", 10, 1, 200, 1),
+    pNumber16("SN1", "springs", 7, 1, 24, 1),
+    pNumber16("SL1", "mm", 60, 0, 500, 1),
+    pNumber16("SL2", "mm", 100, 0, 500, 1),
+    pDropdown3("Send", ["round", "pike"]),
+    pSectionSeparator15("thickness"),
+    pNumber16("L4", "mm", 400, 1, 2e3, 1)
+  ],
+  paramSvg: {
+    D5: "haxis_guidance_outer.svg",
+    D8: "haxis_guidance_outer.svg",
+    E5: "haxis_guidance_outer.svg",
+    E8: "haxis_guidance_outer.svg",
+    L5: "haxis_guidance_outer.svg",
+    R9: "haxis_guidance_outer.svg",
+    SA1: "haxis_guidance_spring.svg",
+    SE1: "haxis_guidance_spring.svg",
+    SD1: "haxis_guidance_spring.svg",
+    SD2: "haxis_guidance_spring.svg",
+    SN1: "haxis_guidance_spring.svg",
+    SL1: "haxis_guidance_spring.svg",
+    SL2: "haxis_guidance_spring.svg",
+    Send: "haxis_guidance_spring.svg",
+    L4: "haxis_guidance_outer.svg"
+  },
+  sim: {
+    tMax: 100,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom16(t, param, suffix = "") {
+  const rGeome = initGeom16(pDef16.partName + suffix);
+  const figProfile = figure16();
+  const figSide = figure16();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const R5 = param.D5 / 2;
+    const R8 = param.D8 / 2;
+    const SR1 = param.SD1 / 2;
+    const Rinner = R5 + param.E5;
+    const Rinner2 = R8 - param.E8;
+    const aLeg = 2 * Math.asin(param.L5 / (2 * Rinner));
+    const sA0 = Math.PI / 12 + degToRad7(param.SA1);
+    const sA = Math.PI / 2 + aLeg - sA0;
+    const sA1 = Math.PI - sA0;
+    const sA2 = Math.PI / 2 - Math.PI / 6 + sA0;
+    if (Rinner + SR1 + param.SE1 > Rinner2) {
+      throw `err411: D8 ${param.D8} is too small compare to D5 ${param.D5}, E5 ${param.D5}, E8 ${param.E8}`;
+    }
+    if (2 * Math.PI / 3 - 2 * aLeg < param.R9 / Rinner2) {
+      throw `err412: L5 ${param.L5} is too large compare to R9 ${param.R9}`;
+    }
+    rGeome.logstr += `haxis_guidance: Dinner ${ffix18(2 * Rinner)} mm
+`;
+    figProfile.addSecond(contourCircle14(0, 0, R5));
+    figProfile.addSecond(contourCircle14(0, 0, R8));
+    const [spring1Log, spring1Ctr] = ctrSpring(param, false);
+    const [, spring2Ctr] = ctrSpring(param, true);
+    rGeome.logstr += spring1Log;
+    const Ai1 = Math.PI / 2 - aLeg;
+    const Ai2 = -Math.PI / 6 + aLeg;
+    const p0 = point6(0, 0);
+    const p11 = p0.translatePolar(Ai1, Rinner + param.SE1 + SR1);
+    const p12c = p11.translatePolar(Ai1 - Math.PI / 2, SR1);
+    const p13 = p12c.translatePolar(Ai1 + Math.PI, SR1 + param.SE1);
+    const p14 = p12c.translatePolar(Ai1 + Math.PI, SR1);
+    const p15 = p13.rotate(p12c, sA);
+    const p21 = p0.translatePolar(Ai2, Rinner + param.SE1 + SR1);
+    const p22c = p21.translatePolar(Ai2 + Math.PI / 2, SR1);
+    const p23 = p22c.translatePolar(Ai2 + Math.PI, SR1 + param.SE1);
+    const p24 = p22c.translatePolar(Ai2 + Math.PI, SR1);
+    const p26 = p24.rotate(p22c, -sA);
+    const ctrProfile = contour14(0, Rinner).addSegStrokeA(p13.cx, p13.cy).addPointA(p15.cx, p15.cy).addSegArc(SR1 + param.SE1, false, true);
+    ctrProfile.addPartial(spring1Ctr.rotate(0, 0, sA1).translate(p15.cx, p15.cy));
+    ctrProfile.addPointA(p14.cx, p14.cy).addPointA(p11.cx, p11.cy).addSegArc2().addSegStrokeAP(Ai1, Rinner2).addCornerRounded(param.R9).addPointAP(Ai2, Rinner2).addSegArc(Rinner2, false, false).addCornerRounded(param.R9).addSegStrokeA(p21.cx, p21.cy).addPointA(p24.cx, p24.cy).addPointA(p26.cx, p26.cy).addSegArc2();
+    ctrProfile.addPartial(spring2Ctr.rotate(0, 0, sA2).translate(p26.cx, p26.cy));
+    ctrProfile.addPointA(p23.cx, p23.cy).addSegArc(SR1 + param.SE1, false, true).addSegStrokeAP(-Math.PI / 6, Rinner).addSegStrokeAP(-Math.PI / 6, R8).addPointAP(Math.PI / 2, R8).addSegArc(R8, false, true).closeSegStroke();
+    figProfile.addMain(ctrProfile);
+    const R8plus = R8 * Math.sin(Math.PI / 6);
+    figSide.addMain(ctrRectangle5(0, -R8plus, param.L4, R8 + R8plus));
+    figSide.addSecond(ctrRectangle5(0, -R8, param.L4, 2 * R8));
+    figSide.addSecond(ctrRectangle5(0, -R5, param.L4, 2 * R5));
+    rGeome.fig = {
+      faceProfile: figProfile,
+      faceSide: figSide
+    };
+    const designName = rGeome.partName;
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_profile`,
+          face: `${designName}_faceProfile`,
+          extrudeMethod: EExtrude13.eLinearOrtho,
+          length: param.L4,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        }
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume16.eIdentity,
+          inList: [`subpax_${designName}_profile`]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "haxis_guidance drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var haxisGuidanceDef = {
+  pTitle: "Haxis-guidance",
+  pDescription: "The guidance of the H-Axis for the heliostat inclination",
+  pDef: pDef16,
+  pGeom: pGeom16
+};
+
+// src/heliostat/rod.ts
+import {
+  contour as contour15,
+  contourCircle as contourCircle15,
+  figure as figure17,
+  ffix as ffix19,
+  pNumber as pNumber17,
+  pSectionSeparator as pSectionSeparator16,
+  initGeom as initGeom17,
+  EExtrude as EExtrude14,
+  EBVolume as EBVolume17
+} from "geometrix";
+var pDef17 = {
   partName: "rod",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber16("L1", "mm", 1e4, 100, 4e4, 10),
-    pNumber16("L2", "mm", 100, 2, 400, 1),
-    pNumber16("L3", "mm", 400, 10, 1e3, 1),
-    pNumber16("L4", "mm", 600, 10, 1e3, 1),
-    pNumber16("N1", "", 10, 2, 50, 1),
-    pSectionSeparator15("section"),
-    pNumber16("H1", "mm", 200, 5, 4e3, 1),
-    pNumber16("E1", "mm", 2, 1, 80, 1),
-    pNumber16("E2", "mm", 10, 1, 80, 1),
-    pSectionSeparator15("pad"),
-    pNumber16("N3", "", 2, 1, 20, 1),
-    pNumber16("N4", "", 4, 1, 20, 1),
-    pNumber16("R3", "mm", 100, 1, 500, 1),
-    pNumber16("D2", "mm", 10, 1, 100, 1),
-    pNumber16("L7", "mm", 10, 1, 300, 1)
+    pNumber17("L1", "mm", 1e4, 100, 4e4, 10),
+    pNumber17("L2", "mm", 100, 2, 400, 1),
+    pNumber17("L3", "mm", 400, 10, 1e3, 1),
+    pNumber17("L4", "mm", 600, 10, 1e3, 1),
+    pNumber17("N1", "", 10, 2, 50, 1),
+    pSectionSeparator16("section"),
+    pNumber17("H1", "mm", 200, 5, 4e3, 1),
+    pNumber17("E1", "mm", 2, 1, 80, 1),
+    pNumber17("E2", "mm", 10, 1, 80, 1),
+    pSectionSeparator16("pad"),
+    pNumber17("N3", "", 2, 1, 20, 1),
+    pNumber17("N4", "", 4, 1, 20, 1),
+    pNumber17("R3", "mm", 100, 1, 500, 1),
+    pNumber17("D2", "mm", 10, 1, 100, 1),
+    pNumber17("L7", "mm", 10, 1, 300, 1)
   ],
   paramSvg: {
     L1: "rod_top.svg",
@@ -4930,36 +5361,36 @@ var pDef16 = {
     // every 0.5 second
   }
 };
-function pGeom16(t, param, suffix = "") {
-  const rGeome = initGeom16(pDef16.partName + suffix);
+function pGeom17(t, param, suffix = "") {
+  const rGeome = initGeom17(pDef17.partName + suffix);
   let ctrPlate;
   let ctrRod;
-  const figCut = figure16();
-  const figPlate = figure16();
-  const figTop = figure16();
+  const figCut = figure17();
+  const figPlate = figure17();
+  const figTop = figure17();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const R2 = param.D2 / 2;
     const n3step = param.L3 / (param.N3 + 1);
     const n4step = param.L4 / (param.N4 + 1);
-    rGeome.logstr += `rod-length: ${ffix18(param.L1)} mm
+    rGeome.logstr += `rod-length: ${ffix19(param.L1)} mm
 `;
     const space_length = (param.L1 - param.L3) / (param.N1 - 1);
-    rGeome.logstr += `space-length: ${ffix18(space_length)} mm
+    rGeome.logstr += `space-length: ${ffix19(space_length)} mm
 `;
     ctrPlate = function(py) {
       const rPlate = [];
       const plateExt = contour15(param.L4 / 2, py).addCornerRounded(param.R3).addSegStrokeA(param.L4 / 2, py + param.L3).addCornerRounded(param.R3).addSegStrokeA(-param.L4 / 2, py + param.L3).addCornerRounded(param.R3).addSegStrokeA(-param.L4 / 2, py).addCornerRounded(param.R3).closeSegStroke();
       rPlate.push(plateExt);
       for (let i = 1; i < param.N3 + 1; i++) {
-        rPlate.push(contourCircle14(param.L4 / 2 - param.L7, py + i * n3step, R2));
-        rPlate.push(contourCircle14(-param.L4 / 2 + param.L7, py + i * n3step, R2));
+        rPlate.push(contourCircle15(param.L4 / 2 - param.L7, py + i * n3step, R2));
+        rPlate.push(contourCircle15(-param.L4 / 2 + param.L7, py + i * n3step, R2));
       }
       for (let i = 1; i < param.N4 + 1; i++) {
-        rPlate.push(contourCircle14(-param.L4 / 2 + i * n4step, py + param.L7, R2));
+        rPlate.push(contourCircle15(-param.L4 / 2 + i * n4step, py + param.L7, R2));
         rPlate.push(
-          contourCircle14(-param.L4 / 2 + i * n4step, py + param.L3 - param.L7, R2)
+          contourCircle15(-param.L4 / 2 + i * n4step, py + param.L3 - param.L7, R2)
         );
       }
       return rPlate;
@@ -4996,7 +5427,7 @@ function pGeom16(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod`,
           face: `${designName}_faceCut`,
-          extrudeMethod: EExtrude13.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: param.L1,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -5004,7 +5435,7 @@ function pGeom16(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_plates`,
           face: `${designName}_faceTop`,
-          extrudeMethod: EExtrude13.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: param.E2,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, param.E2 + param.H1, 0]
@@ -5013,7 +5444,7 @@ function pGeom16(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume16.eUnion,
+          boolMethod: EBVolume17.eUnion,
           inList: [`subpax_${designName}_rod`, `subpax_${designName}_plates`]
         }
       ]
@@ -5030,51 +5461,51 @@ function pGeom16(t, param, suffix = "") {
 var rodDef = {
   pTitle: "Heliostat rod",
   pDescription: "The rod of an heliostat-surface",
-  pDef: pDef16,
-  pGeom: pGeom16
+  pDef: pDef17,
+  pGeom: pGeom17
 };
 
 // src/heliostat/trapeze.ts
 import {
   contour as contour16,
-  contourCircle as contourCircle15,
-  figure as figure17,
+  contourCircle as contourCircle16,
+  figure as figure18,
   radToDeg as radToDeg9,
-  ffix as ffix19,
-  pNumber as pNumber17,
-  pSectionSeparator as pSectionSeparator16,
-  initGeom as initGeom17,
-  EExtrude as EExtrude14,
-  EBVolume as EBVolume17
+  ffix as ffix20,
+  pNumber as pNumber18,
+  pSectionSeparator as pSectionSeparator17,
+  initGeom as initGeom18,
+  EExtrude as EExtrude15,
+  EBVolume as EBVolume18
 } from "geometrix";
-var pDef17 = {
+var pDef18 = {
   partName: "trapeze",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber17("L1", "mm", 1600, 10, 4e3, 1),
-    pNumber17("L2", "mm", 1e3, 10, 4e3, 1),
-    pNumber17("L3", "mm", 400, 5, 800, 1),
-    pNumber17("L4", "mm", 300, 5, 800, 1),
-    pSectionSeparator16("outer frame"),
-    pNumber17("N1", "", 7, 1, 20, 1),
-    pNumber17("N2", "", 4, 1, 20, 1),
-    pNumber17("D1", "mm", 10, 1, 40, 1),
-    pNumber17("L5", "mm", 100, 1, 400, 1),
-    pNumber17("L6", "mm", 20, 1, 400, 1),
-    pNumber17("R1", "mm", 60, 1, 400, 1),
-    pNumber17("R2", "mm", 20, 1, 400, 1),
-    pSectionSeparator16("inner pad"),
-    pNumber17("N3", "", 2, 1, 20, 1),
-    pNumber17("N4", "", 2, 1, 20, 1),
-    pNumber17("D2", "mm", 10, 1, 40, 1),
-    pNumber17("L7", "mm", 20, 1, 400, 1),
-    pNumber17("R3", "mm", 20, 1, 400, 1),
-    pSectionSeparator16("diagonal shaft"),
-    pNumber17("D3", "mm", 30, 1, 100, 1),
-    pNumber17("D4", "mm", 26, 1, 100, 1),
-    pNumber17("H1", "mm", 300, 0.5, 800, 0.5),
-    pNumber17("H2", "mm", 2, 0.5, 800, 0.5),
-    pNumber17("H3", "mm", 5, 0.5, 800, 0.5)
+    pNumber18("L1", "mm", 1600, 10, 4e3, 1),
+    pNumber18("L2", "mm", 1e3, 10, 4e3, 1),
+    pNumber18("L3", "mm", 400, 5, 800, 1),
+    pNumber18("L4", "mm", 300, 5, 800, 1),
+    pSectionSeparator17("outer frame"),
+    pNumber18("N1", "", 7, 1, 20, 1),
+    pNumber18("N2", "", 4, 1, 20, 1),
+    pNumber18("D1", "mm", 10, 1, 40, 1),
+    pNumber18("L5", "mm", 100, 1, 400, 1),
+    pNumber18("L6", "mm", 20, 1, 400, 1),
+    pNumber18("R1", "mm", 60, 1, 400, 1),
+    pNumber18("R2", "mm", 20, 1, 400, 1),
+    pSectionSeparator17("inner pad"),
+    pNumber18("N3", "", 2, 1, 20, 1),
+    pNumber18("N4", "", 2, 1, 20, 1),
+    pNumber18("D2", "mm", 10, 1, 40, 1),
+    pNumber18("L7", "mm", 20, 1, 400, 1),
+    pNumber18("R3", "mm", 20, 1, 400, 1),
+    pSectionSeparator17("diagonal shaft"),
+    pNumber18("D3", "mm", 30, 1, 100, 1),
+    pNumber18("D4", "mm", 26, 1, 100, 1),
+    pNumber18("H1", "mm", 300, 0.5, 800, 0.5),
+    pNumber18("H2", "mm", 2, 0.5, 800, 0.5),
+    pNumber18("H3", "mm", 5, 0.5, 800, 0.5)
   ],
   paramSvg: {
     L1: "trapeze_top.svg",
@@ -5106,15 +5537,15 @@ var pDef17 = {
     // every 0.5 second
   }
 };
-function pGeom17(t, param, suffix = "") {
-  const rGeome = initGeom17(pDef17.partName + suffix);
+function pGeom18(t, param, suffix = "") {
+  const rGeome = initGeom18(pDef18.partName + suffix);
   let ctrRodFootprint;
   let ctrRod;
-  const figFrame = figure17();
-  const figPlate = figure17();
-  const figRod = figure17();
-  const figRodHollow = figure17();
-  const figCutRod = figure17();
+  const figFrame = figure18();
+  const figPlate = figure18();
+  const figRod = figure18();
+  const figRodHollow = figure18();
+  const figCutRod = figure18();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
@@ -5136,14 +5567,14 @@ function pGeom17(t, param, suffix = "") {
     const rod_slope_length = Math.sqrt(rod_xy ** 2 + rod_z ** 2);
     const rod_slope_angle = Math.atan2(rod_z, rod_xy);
     const rod_xy_angle = Math.atan2(rod_y, rod_x);
-    rGeome.logstr += `rod-slope:  length: ${ffix19(rod_slope_length)} mm,  angle: ${ffix19(
+    rGeome.logstr += `rod-slope:  length: ${ffix20(rod_slope_length)} mm,  angle: ${ffix20(
       radToDeg9(rod_slope_angle)
     )} degree
 `;
-    rGeome.logstr += `rod-xy-angle: ${ffix19(radToDeg9(rod_xy_angle))} degree
+    rGeome.logstr += `rod-xy-angle: ${ffix20(radToDeg9(rod_xy_angle))} degree
 `;
     const rodFootprintLength = param.D3 / Math.cos(Math.PI / 2 - rod_slope_angle);
-    rGeome.logstr += `rod-footprint-length: ${ffix19(rodFootprintLength)} mm
+    rGeome.logstr += `rod-footprint-length: ${ffix20(rodFootprintLength)} mm
 `;
     const rodFPl = Math.sqrt((rodFootprintLength / 2) ** 2 + (param.D3 / 2) ** 2);
     const rodFPa = Math.atan2(param.D3, rodFootprintLength);
@@ -5188,35 +5619,35 @@ function pGeom17(t, param, suffix = "") {
     const lFrameHole = [];
     for (let i = 1; i < param.N1 + 1; i++) {
       lFrameHole.push(
-        contourCircle15(param.L2 / 2 - param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
+        contourCircle16(param.L2 / 2 - param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
       );
       lFrameHole.push(
-        contourCircle15(-param.L2 / 2 + param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
+        contourCircle16(-param.L2 / 2 + param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
       );
     }
     for (let i = 1; i < param.N2 + 1; i++) {
       lFrameHole.push(
-        contourCircle15(-param.L2 / 2 + i * step2, param.L1 / 2 - param.L6, param.D1 / 2)
+        contourCircle16(-param.L2 / 2 + i * step2, param.L1 / 2 - param.L6, param.D1 / 2)
       );
       lFrameHole.push(
-        contourCircle15(-param.L2 / 2 + i * step2, -param.L1 / 2 + param.L6, param.D1 / 2)
+        contourCircle16(-param.L2 / 2 + i * step2, -param.L1 / 2 + param.L6, param.D1 / 2)
       );
     }
     const lPlateHole = [];
     for (let i = 1; i < param.N3 + 1; i++) {
       lPlateHole.push(
-        contourCircle15(param.L4 / 2 - param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
+        contourCircle16(param.L4 / 2 - param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
       );
       lPlateHole.push(
-        contourCircle15(-param.L4 / 2 + param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
+        contourCircle16(-param.L4 / 2 + param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
       );
     }
     for (let i = 1; i < param.N4 + 1; i++) {
       lPlateHole.push(
-        contourCircle15(-param.L4 / 2 + i * step4, param.L3 / 2 - param.L7, param.D2 / 2)
+        contourCircle16(-param.L4 / 2 + i * step4, param.L3 / 2 - param.L7, param.D2 / 2)
       );
       lPlateHole.push(
-        contourCircle15(-param.L4 / 2 + i * step4, -param.L3 / 2 + param.L7, param.D2 / 2)
+        contourCircle16(-param.L4 / 2 + i * step4, -param.L3 / 2 + param.L7, param.D2 / 2)
       );
     }
     lFrameHole.forEach((ctr) => {
@@ -5271,10 +5702,10 @@ function pGeom17(t, param, suffix = "") {
     if (param.D4 >= param.D3) {
       throw `err218: D4 ${param.D4} larger than D3 ${param.D3}`;
     }
-    figRod.addMain(contourCircle15(0, 0, param.D3 / 2));
-    figRod.addSecond(contourCircle15(0, 0, param.D4 / 2));
-    figRodHollow.addMain(contourCircle15(0, 0, param.D4 / 2));
-    figRodHollow.addSecond(contourCircle15(0, 0, param.D3 / 2));
+    figRod.addMain(contourCircle16(0, 0, param.D3 / 2));
+    figRod.addSecond(contourCircle16(0, 0, param.D4 / 2));
+    figRodHollow.addMain(contourCircle16(0, 0, param.D4 / 2));
+    figRodHollow.addSecond(contourCircle16(0, 0, param.D3 / 2));
     const rodFootprintHeight = param.D3 * Math.cos(rod_slope_angle);
     const rodFootprintBack = rodFootprintHeight / Math.tan(rod_slope_angle);
     const pad3x = pad3 + (rodFootprintLength / 2 + rodFootprintBack) * Math.cos(rod_xy_angle);
@@ -5296,7 +5727,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_frame`,
           face: `${designName}_faceFrame`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: param.H2,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1 - param.H2]
@@ -5304,7 +5735,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_plate`,
           face: `${designName}_facePlate`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: param.H3,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -5312,7 +5743,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod1`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, rod_xy_angle],
           translate: [
@@ -5324,7 +5755,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod2`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI - rod_xy_angle],
           translate: [
@@ -5336,7 +5767,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod3`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI + rod_xy_angle],
           translate: [
@@ -5348,7 +5779,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod4`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, -rod_xy_angle],
           translate: [
@@ -5360,7 +5791,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH1`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, rod_xy_angle],
           translate: [
@@ -5372,7 +5803,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH2`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI - rod_xy_angle],
           translate: [
@@ -5384,7 +5815,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH3`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI + rod_xy_angle],
           translate: [
@@ -5396,7 +5827,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH4`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, -rod_xy_angle],
           translate: [
@@ -5408,7 +5839,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cut1`,
           face: `${designName}_faceCutRod`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: cutL,
           rotate: [0, 0, 0],
           translate: [0, 0, -cutL]
@@ -5416,7 +5847,7 @@ function pGeom17(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cut2`,
           face: `${designName}_faceCutRod`,
-          extrudeMethod: EExtrude14.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: cutL,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1]
@@ -5425,7 +5856,7 @@ function pGeom17(t, param, suffix = "") {
       volumes: [
         {
           outName: `ipax_${designName}_rawRod`,
-          boolMethod: EBVolume17.eUnion,
+          boolMethod: EBVolume18.eUnion,
           inList: [
             `subpax_${designName}_rod1`,
             `subpax_${designName}_rod2`,
@@ -5435,7 +5866,7 @@ function pGeom17(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_rodHollow`,
-          boolMethod: EBVolume17.eUnion,
+          boolMethod: EBVolume18.eUnion,
           inList: [
             `subpax_${designName}_rodH1`,
             `subpax_${designName}_rodH2`,
@@ -5445,17 +5876,17 @@ function pGeom17(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_halfRods`,
-          boolMethod: EBVolume17.eSubstraction,
+          boolMethod: EBVolume18.eSubstraction,
           inList: [`ipax_${designName}_rawRod`, `subpax_${designName}_cut1`]
         },
         {
           outName: `ipax_${designName}_rods`,
-          boolMethod: EBVolume17.eSubstraction,
+          boolMethod: EBVolume18.eSubstraction,
           inList: [`ipax_${designName}_halfRods`, `subpax_${designName}_cut2`]
         },
         {
           outName: `ipax_${designName}_plus`,
-          boolMethod: EBVolume17.eUnion,
+          boolMethod: EBVolume18.eUnion,
           inList: [
             `subpax_${designName}_frame`,
             `subpax_${designName}_plate`,
@@ -5464,7 +5895,7 @@ function pGeom17(t, param, suffix = "") {
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume17.eSubstraction,
+          boolMethod: EBVolume18.eSubstraction,
           inList: [`ipax_${designName}_plus`, `ipax_${designName}_rodHollow`]
         }
       ]
@@ -5481,54 +5912,54 @@ function pGeom17(t, param, suffix = "") {
 var trapezeDef = {
   pTitle: "Heliostat trapeze",
   pDescription: "The support of one solar panel. Made out of aluminium for lightness and cooling",
-  pDef: pDef17,
-  pGeom: pGeom17
+  pDef: pDef18,
+  pGeom: pGeom18
 };
 
 // src/heliostat/surface.ts
 import {
   contour as contour17,
-  figure as figure18,
-  ffix as ffix20,
-  pNumber as pNumber18,
+  figure as figure19,
+  ffix as ffix21,
+  pNumber as pNumber19,
   pCheckbox as pCheckbox4,
-  pDropdown as pDropdown2,
-  pSectionSeparator as pSectionSeparator17,
-  initGeom as initGeom18,
-  EExtrude as EExtrude15,
-  EBVolume as EBVolume18
+  pDropdown as pDropdown4,
+  pSectionSeparator as pSectionSeparator18,
+  initGeom as initGeom19,
+  EExtrude as EExtrude16,
+  EBVolume as EBVolume19
 } from "geometrix";
-var pDef18 = {
+var pDef19 = {
   partName: "surface",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber18("LH", "mm", 1600, 10, 4e3, 1),
-    pNumber18("LV", "mm", 1e3, 10, 4e3, 1),
-    pNumber18("LZ", "mm", 40, 0, 100, 1),
-    pNumber18("nx", "", 9, 1, 40, 1),
-    pNumber18("ny", "", 9, 1, 40, 1),
-    pSectionSeparator17("main fantasia"),
-    pDropdown2("main_direction", ["horizontal", "vertical"]),
+    pNumber19("LH", "mm", 1600, 10, 4e3, 1),
+    pNumber19("LV", "mm", 1e3, 10, 4e3, 1),
+    pNumber19("LZ", "mm", 40, 0, 100, 1),
+    pNumber19("nx", "", 9, 1, 40, 1),
+    pNumber19("ny", "", 9, 1, 40, 1),
+    pSectionSeparator18("main fantasia"),
+    pDropdown4("main_direction", ["horizontal", "vertical"]),
     pCheckbox4("crenel", false),
-    pNumber18("first_row", "", 9, 1, 40, 1),
-    pNumber18("second_row", "", 9, 1, 40, 1),
-    pSectionSeparator17("horizontal spacing"),
-    pNumber18("EH", "mm", 10, 0, 1e3, 1),
+    pNumber19("first_row", "", 9, 1, 40, 1),
+    pNumber19("second_row", "", 9, 1, 40, 1),
+    pSectionSeparator18("horizontal spacing"),
+    pNumber19("EH", "mm", 10, 0, 1e3, 1),
     pCheckbox4("EH_gradient", false),
-    pNumber18("EH_sup", "mm", 500, 0, 1e3, 1),
-    pNumber18("EH_cycle", "", 1, 0, 3, 0.05),
-    pNumber18("EH_start", "", 0, 0, 1, 0.05),
-    pDropdown2("EH_shape", ["sinusoid", "triangle", "sawUp", "sawDown"]),
-    pSectionSeparator17("vertical spacing"),
-    pNumber18("EV", "mm", 10, 0, 1e3, 1),
+    pNumber19("EH_sup", "mm", 500, 0, 1e3, 1),
+    pNumber19("EH_cycle", "", 1, 0, 3, 0.05),
+    pNumber19("EH_start", "", 0, 0, 1, 0.05),
+    pDropdown4("EH_shape", ["sinusoid", "triangle", "sawUp", "sawDown"]),
+    pSectionSeparator18("vertical spacing"),
+    pNumber19("EV", "mm", 10, 0, 1e3, 1),
     pCheckbox4("EV_gradient", false),
-    pNumber18("EV_sup", "mm", 500, 0, 1e3, 1),
-    pNumber18("EV_cycle", "", 1, 0, 3, 0.05),
-    pNumber18("EV_start", "", 0, 0, 1, 0.05),
-    pDropdown2("EV_shape", ["sinusoid", "triangle", "sawUp", "sawDown"]),
-    pSectionSeparator17("solar power"),
-    pNumber18("power_efficiency", "%", 16, 0, 100, 0.1),
-    pNumber18("solar_power", "W/m2", 816, 100, 2e3, 1)
+    pNumber19("EV_sup", "mm", 500, 0, 1e3, 1),
+    pNumber19("EV_cycle", "", 1, 0, 3, 0.05),
+    pNumber19("EV_start", "", 0, 0, 1, 0.05),
+    pDropdown4("EV_shape", ["sinusoid", "triangle", "sawUp", "sawDown"]),
+    pSectionSeparator18("solar power"),
+    pNumber19("power_efficiency", "%", 16, 0, 100, 0.1),
+    pNumber19("solar_power", "W/m2", 816, 100, 2e3, 1)
     // 1361*0.6=816 W/m2
   ],
   paramSvg: {
@@ -5563,26 +5994,26 @@ var pDef18 = {
     // every 0.5 second
   }
 };
-function pGeom18(t, param, suffix = "") {
-  const rGeome = initGeom18(pDef18.partName + suffix);
+function pGeom19(t, param, suffix = "") {
+  const rGeome = initGeom19(pDef19.partName + suffix);
   let ctrPanelProfile;
-  const figSurface = figure18();
-  const figOnePanel = figure18();
+  const figSurface = figure19();
+  const figOnePanel = figure19();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const panel_surface = param.LH * param.LV / 10 ** 6;
     const panel_power = param.solar_power * panel_surface * param.power_efficiency / 100;
-    rGeome.logstr += `panel surface: ${ffix20(panel_surface)} m2
+    rGeome.logstr += `panel surface: ${ffix21(panel_surface)} m2
 `;
-    rGeome.logstr += `panel power: ${ffix20(panel_power)} W
+    rGeome.logstr += `panel power: ${ffix21(panel_power)} W
 `;
     const max_panel_nb = param.nx * param.ny;
     rGeome.logstr += `max panel number: ${max_panel_nb}
 `;
-    rGeome.logstr += `max panel surface: ${ffix20(max_panel_nb * panel_surface)} m2
+    rGeome.logstr += `max panel surface: ${ffix21(max_panel_nb * panel_surface)} m2
 `;
-    rGeome.logstr += `max panel power: ${ffix20(max_panel_nb * panel_power)} W
+    rGeome.logstr += `max panel power: ${ffix21(max_panel_nb * panel_power)} W
 `;
     const lenMain = param.main_direction === 1 ? param.ny : param.nx;
     const lenLateral = param.main_direction === 1 ? param.nx : param.ny;
@@ -5615,13 +6046,13 @@ function pGeom18(t, param, suffix = "") {
     lenRow.forEach((oneRow) => {
       panelNb += oneRow;
     });
-    rGeome.logstr += `actual panel number: ${panelNb} (${ffix20(
+    rGeome.logstr += `actual panel number: ${panelNb} (${ffix21(
       100 * panelNb / max_panel_nb
     )} %)
 `;
-    rGeome.logstr += `actual panel surface: ${ffix20(panelNb * panel_surface)} m2
+    rGeome.logstr += `actual panel surface: ${ffix21(panelNb * panel_surface)} m2
 `;
-    rGeome.logstr += `actual panel power: ${ffix20(panelNb * panel_power)} W
+    rGeome.logstr += `actual panel power: ${ffix21(panelNb * panel_power)} W
 `;
     const eMain = [];
     for (let i = 0; i < lenMain - 1; i++) {
@@ -5697,13 +6128,13 @@ function pGeom18(t, param, suffix = "") {
       gLenVertical = lenMain * param.LV + eMainTotal;
     }
     const gArea = gLenHorizontal * gLenVertical / 10 ** 6;
-    rGeome.logstr += `global horizontal width: ${ffix20(gLenHorizontal / 1e3)} m
+    rGeome.logstr += `global horizontal width: ${ffix21(gLenHorizontal / 1e3)} m
 `;
-    rGeome.logstr += `global vertical height: ${ffix20(gLenVertical / 1e3)} m
+    rGeome.logstr += `global vertical height: ${ffix21(gLenVertical / 1e3)} m
 `;
-    rGeome.logstr += `global area: ${ffix20(gArea)} m2
+    rGeome.logstr += `global area: ${ffix21(gArea)} m2
 `;
-    rGeome.logstr += `area efficiency: ${ffix20(100 * panelNb * panel_surface / gArea)} %
+    rGeome.logstr += `area efficiency: ${ffix21(100 * panelNb * panel_surface / gArea)} %
 `;
     const ox = -gLenHorizontal / 2;
     const oy = -gLenVertical / 2;
@@ -5748,7 +6179,7 @@ function pGeom18(t, param, suffix = "") {
         const rElem = {
           outName: `subpax_${designName}_panel_${idx}`,
           face: `${designName}_faceOnePanel`,
-          extrudeMethod: EExtrude15.eLinearOrtho,
+          extrudeMethod: EExtrude16.eLinearOrtho,
           length: param.LZ,
           rotate: [0, 0, 0],
           translate: [elem[0], elem[1], 0]
@@ -5759,7 +6190,7 @@ function pGeom18(t, param, suffix = "") {
         {
           outName: `pax_${designName}`,
           //boolMethod: EBVolume.eIdentity,
-          boolMethod: EBVolume18.eUnion,
+          boolMethod: EBVolume19.eUnion,
           inList: panelPositions.map((elem, idx) => {
             const subElem = `subpax_${designName}_panel_${idx}`;
             return subElem;
@@ -5779,19 +6210,19 @@ function pGeom18(t, param, suffix = "") {
 var surfaceDef = {
   pTitle: "Heliostat panel-surface",
   pDescription: "The surface collecting the solar power",
-  pDef: pDef18,
-  pGeom: pGeom18
+  pDef: pDef19,
+  pGeom: pGeom19
 };
 
 // src/dummy/circles.ts
-import { degToRad as degToRad6, point as point6, figure as figure19, pNumber as pNumber19, initGeom as initGeom19 } from "geometrix";
-var pDef19 = {
+import { degToRad as degToRad8, point as point7, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
+var pDef20 = {
   partName: "circles",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber19("angle", "degree", 15, 5, 45, 1),
-    pNumber19("amplitude-offset", "mm", 1, 0.5, 4, 0.1),
-    pNumber19("amplitude-scale", "scalar", 0.2, 0.1, 0.5, 0.01)
+    pNumber20("angle", "degree", 15, 5, 45, 1),
+    pNumber20("amplitude-offset", "mm", 1, 0.5, 4, 0.1),
+    pNumber20("amplitude-scale", "scalar", 0.2, 0.1, 0.5, 0.01)
   ],
   paramSvg: {
     angle: "circles_angle.svg",
@@ -5804,18 +6235,18 @@ var pDef19 = {
     tUpdate: 500
   }
 };
-function pGeom19(t, param, suffix = "") {
-  const rGeome = initGeom19(pDef19.partName + suffix);
+function pGeom20(t, param, suffix = "") {
+  const rGeome = initGeom20(pDef20.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure19();
-    const p1 = point6(10, 10);
-    const p2 = point6(10, 30);
+    const figOne = figure20();
+    const p1 = point7(10, 10);
+    const p2 = point7(10, 30);
     figOne.addPoint(p2);
     for (let i = 0; i < 20; i++) {
       figOne.addPoint(
-        p1.scale(p2, param["amplitude-offset"] + param["amplitude-scale"] * i).rotate(p2, i * degToRad6(param.angle) + t * Math.PI / 2 / pDef19.sim.tMax)
+        p1.scale(p2, param["amplitude-offset"] + param["amplitude-scale"] * i).rotate(p2, i * degToRad8(param.angle) + t * Math.PI / 2 / pDef20.sim.tMax)
       );
     }
     rGeome.fig = { one: figOne };
@@ -5830,18 +6261,18 @@ function pGeom19(t, param, suffix = "") {
 var circlesDef = {
   pTitle: "Circles",
   pDescription: "A spiral made by points.",
-  pDef: pDef19,
-  pGeom: pGeom19
+  pDef: pDef20,
+  pGeom: pGeom20
 };
 
 // src/dummy/rectangle.ts
-import { point as point7, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
-var pDef20 = {
+import { point as point8, figure as figure21, pNumber as pNumber21, initGeom as initGeom21 } from "geometrix";
+var pDef21 = {
   partName: "rectangle",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber20("width", "mm", 15, 3, 40, 0.5),
-    pNumber20("height", "mm", 10, 3, 40, 0.5)
+    pNumber21("width", "mm", 15, 3, 40, 0.5),
+    pNumber21("height", "mm", 10, 3, 40, 0.5)
   ],
   paramSvg: {
     width: "rectangle_width.svg",
@@ -5853,16 +6284,16 @@ var pDef20 = {
     tUpdate: 500
   }
 };
-function pGeom20(t, param, suffix = "") {
-  const rGeome = initGeom20(pDef20.partName + suffix);
+function pGeom21(t, param, suffix = "") {
+  const rGeome = initGeom21(pDef21.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure20();
-    const p1 = point7(10, 10);
-    const p2 = point7(10 + param.width, 10);
-    const p3 = point7(10 + param.width, 10 + param.height);
-    const p4 = point7(10, 10 + param.height);
+    const figOne = figure21();
+    const p1 = point8(10, 10);
+    const p2 = point8(10 + param.width, 10);
+    const p3 = point8(10 + param.width, 10 + param.height);
+    const p4 = point8(10, 10 + param.height);
     const angle = t * Math.PI / 180;
     figOne.addPoint(p1);
     figOne.addPoint(p2.rotate(p1, angle));
@@ -5880,25 +6311,25 @@ function pGeom20(t, param, suffix = "") {
 var rectangleDef = {
   pTitle: "Rectangle",
   pDescription: "Just a rectangle.",
-  pDef: pDef20,
-  pGeom: pGeom20
+  pDef: pDef21,
+  pGeom: pGeom21
 };
 
 // src/dummy/pole_static.ts
 import {
   contour as contour18,
-  contourCircle as contourCircle16,
-  figure as figure21,
-  pNumber as pNumber21,
-  initGeom as initGeom21
+  contourCircle as contourCircle17,
+  figure as figure22,
+  pNumber as pNumber22,
+  initGeom as initGeom22
 } from "geometrix";
-var pDef21 = {
+var pDef22 = {
   partName: "pole_static",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber21("H1", "mm", 4e3, 100, 4e4, 10),
-    pNumber21("H2", "mm", 5e3, 100, 4e4, 10),
-    pNumber21("radius", "mm", 1e3, 100, 4e4, 10)
+    pNumber22("H1", "mm", 4e3, 100, 4e4, 10),
+    pNumber22("H2", "mm", 5e3, 100, 4e4, 10),
+    pNumber22("radius", "mm", 1e3, 100, 4e4, 10)
   ],
   paramSvg: {
     H1: "dummy_pole_static_face.svg",
@@ -5912,15 +6343,15 @@ var pDef21 = {
     // every 0.5 second
   }
 };
-function pGeom21(t, param, suffix = "") {
-  const rGeome = initGeom21(pDef21.partName + suffix);
-  const figFace = figure21();
+function pGeom22(t, param, suffix = "") {
+  const rGeome = initGeom22(pDef22.partName + suffix);
+  const figFace = figure22();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const ctrPoleFace = contour18(-param.H1 / 2, -param.H2 / 2).addSegStrokeA(param.H1 / 2, -param.H2 / 2).addSegStrokeA(param.H1 / 2, param.H2 / 2).addSegStrokeA(-param.H1 / 2, param.H2 / 2).closeSegStroke();
     figFace.addMain(ctrPoleFace);
-    figFace.addMain(contourCircle16(0, 0, param.radius));
+    figFace.addMain(contourCircle17(0, 0, param.radius));
     rGeome.fig = {
       poleFace: figFace
     };
@@ -5936,22 +6367,22 @@ function pGeom21(t, param, suffix = "") {
 var dummyPoleStaticDef = {
   pTitle: "Dummy pole static",
   pDescription: "Testing two design with identical name",
-  pDef: pDef21,
-  pGeom: pGeom21
+  pDef: pDef22,
+  pGeom: pGeom22
 };
 
 // src/geometrix_verification/verify_point.ts
-import { degToRad as degToRad7, point as point8, figure as figure22, pNumber as pNumber22, initGeom as initGeom22 } from "geometrix";
-var pDef22 = {
+import { degToRad as degToRad9, point as point9, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
+var pDef23 = {
   partName: "verify_point",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber22("p1x", "mm", 30, -200, 200, 1),
-    pNumber22("p1y", "mm", 50, -200, 200, 1),
-    pNumber22("p2a", "degree", 30, -200, 200, 1),
-    pNumber22("p2l", "mm", 60, 0, 200, 1),
-    pNumber22("rotateOrig", "degree", 45, -200, 200, 1),
-    pNumber22("scaleOrig", "scalar", 1.5, 0.1, 2, 0.1)
+    pNumber23("p1x", "mm", 30, -200, 200, 1),
+    pNumber23("p1y", "mm", 50, -200, 200, 1),
+    pNumber23("p2a", "degree", 30, -200, 200, 1),
+    pNumber23("p2l", "mm", 60, 0, 200, 1),
+    pNumber23("rotateOrig", "degree", 45, -200, 200, 1),
+    pNumber23("scaleOrig", "scalar", 1.5, 0.1, 2, 0.1)
   ],
   paramSvg: {
     p1x: "verify_point_p1x.svg",
@@ -5968,15 +6399,15 @@ var pDef22 = {
     // every 0.5 second
   }
 };
-function pGeom22(t, param, suffix = "") {
-  const rGeome = initGeom22(pDef22.partName + suffix);
+function pGeom23(t, param, suffix = "") {
+  const rGeome = initGeom23(pDef23.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure22();
-    const p1 = point8(param.p1x, param.p1y + t);
-    const p2 = point8(0, 0).setPolar(degToRad7(param.p2a), param.p2l);
-    const p3 = p1.rotateOrig(degToRad7(param.rotateOrig));
+    const figOne = figure23();
+    const p1 = point9(param.p1x, param.p1y + t);
+    const p2 = point9(0, 0).setPolar(degToRad9(param.p2a), param.p2l);
+    const p3 = p1.rotateOrig(degToRad9(param.rotateOrig));
     const p4 = p1.scaleOrig(param.scaleOrig);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
@@ -5994,23 +6425,23 @@ function pGeom22(t, param, suffix = "") {
 var verifyPoint1Def = {
   pTitle: "Verify point",
   pDescription: "Debugging point.ts",
-  pDef: pDef22,
-  pGeom: pGeom22
+  pDef: pDef23,
+  pGeom: pGeom23
 };
 
 // src/geometrix_verification/verify_point_2.ts
-import { point as point9, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
-var pDef23 = {
+import { point as point10, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
+var pDef24 = {
   partName: "verify_point_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber23("p1x", "mm", 30, -200, 200, 1),
-    pNumber23("p1y", "mm", 50, -200, 200, 1),
-    pNumber23("p2x", "mm", -10, -200, 200, 1),
-    pNumber23("p2y", "mm", 60, -200, 200, 1),
-    pNumber23("p3x", "mm", 70, -200, 200, 1),
-    pNumber23("p3y", "mm", -20, -200, 200, 1),
-    pNumber23("dist", "mm", 50, 0, 200, 1)
+    pNumber24("p1x", "mm", 30, -200, 200, 1),
+    pNumber24("p1y", "mm", 50, -200, 200, 1),
+    pNumber24("p2x", "mm", -10, -200, 200, 1),
+    pNumber24("p2y", "mm", 60, -200, 200, 1),
+    pNumber24("p3x", "mm", 70, -200, 200, 1),
+    pNumber24("p3y", "mm", -20, -200, 200, 1),
+    pNumber24("dist", "mm", 50, 0, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -6028,15 +6459,15 @@ var pDef23 = {
     // every 0.5 second
   }
 };
-function pGeom23(t, param, suffix = "") {
-  const rGeome = initGeom23(pDef23.partName + suffix);
+function pGeom24(t, param, suffix = "") {
+  const rGeome = initGeom24(pDef24.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure23();
-    const p1 = point9(param.p1x, param.p1y + t);
-    const p2 = point9(param.p2x, param.p2y);
-    const p3 = point9(param.p3x, param.p3y);
+    const figOne = figure24();
+    const p1 = point10(param.p1x, param.p1y + t);
+    const p2 = point10(param.p2x, param.p2y);
+    const p3 = point10(param.p3x, param.p3y);
     const mp1p2 = p1.middlePoint(p2);
     const ep1p2 = p1.equidistantPoint(p2, param.dist, p3);
     figOne.addPoint(p1);
@@ -6056,22 +6487,22 @@ function pGeom23(t, param, suffix = "") {
 var verifyPoint2Def = {
   pTitle: "Verify point 2",
   pDescription: "Debugging more point.ts",
-  pDef: pDef23,
-  pGeom: pGeom23
+  pDef: pDef24,
+  pGeom: pGeom24
 };
 
 // src/geometrix_verification/verify_line.ts
-import { point as point10, line, linePP, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
-var pDef24 = {
+import { point as point11, line, linePP, figure as figure25, pNumber as pNumber25, initGeom as initGeom25 } from "geometrix";
+var pDef25 = {
   partName: "verify_line",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber24("p1x", "mm", 30, -200, 200, 1),
-    pNumber24("p1y", "mm", 50, -200, 200, 1),
-    pNumber24("p2x", "mm", 40, -200, 200, 1),
-    pNumber24("p2y", "mm", -20, -200, 200, 1),
-    pNumber24("p3x", "mm", -30, -200, 200, 1),
-    pNumber24("p3y", "mm", 30, -200, 200, 1)
+    pNumber25("p1x", "mm", 30, -200, 200, 1),
+    pNumber25("p1y", "mm", 50, -200, 200, 1),
+    pNumber25("p2x", "mm", 40, -200, 200, 1),
+    pNumber25("p2y", "mm", -20, -200, 200, 1),
+    pNumber25("p3x", "mm", -30, -200, 200, 1),
+    pNumber25("p3y", "mm", 30, -200, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -6088,25 +6519,25 @@ var pDef24 = {
     // every 0.5 second
   }
 };
-function pGeom24(t, param, suffix = "") {
-  const rGeome = initGeom24(pDef24.partName + suffix);
+function pGeom25(t, param, suffix = "") {
+  const rGeome = initGeom25(pDef25.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure24();
-    const p1 = point10(param.p1x, param.p1y + t);
-    const p2 = point10(param.p2x, param.p2y);
-    const p3 = point10(param.p3x, param.p3y);
+    const figOne = figure25();
+    const p1 = point11(param.p1x, param.p1y + t);
+    const p2 = point11(param.p2x, param.p2y);
+    const p3 = point11(param.p3x, param.p3y);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
     const l1 = line(0, 0, 0).setFromPoints(p1, p2);
     figOne.addLine(l1);
-    figOne.addPoint(point10(l1.getAxisXIntersection(), 0));
-    figOne.addPoint(point10(0, l1.getAxisYIntersection()));
+    figOne.addPoint(point11(l1.getAxisXIntersection(), 0));
+    figOne.addPoint(point11(0, l1.getAxisYIntersection()));
     const p4 = l1.projectOrig();
     figOne.addPoint(p4);
-    const p0 = point10(0, 0);
+    const p0 = point11(0, 0);
     if (!p0.isEqual(p4)) {
       const l2 = linePP(p0, p4);
       figOne.addLine(l2);
@@ -6128,24 +6559,24 @@ function pGeom24(t, param, suffix = "") {
 var verifyLine1Def = {
   pTitle: "Verify line",
   pDescription: "Debugging line.ts",
-  pDef: pDef24,
-  pGeom: pGeom24
+  pDef: pDef25,
+  pGeom: pGeom25
 };
 
 // src/geometrix_verification/verify_line_2.ts
-import { degToRad as degToRad8, point as point11, line as line2, figure as figure25, pNumber as pNumber25, initGeom as initGeom25 } from "geometrix";
-var pDef25 = {
+import { degToRad as degToRad10, point as point12, line as line2, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
+var pDef26 = {
   partName: "verify_line_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber25("l1cx", "mm", 10, -200, 200, 1),
-    pNumber25("l1cy", "mm", 20, -200, 200, 1),
-    pNumber25("l1ca", "degree", 15, -200, 200, 1),
-    pNumber25("l2cx", "mm", 30, -200, 200, 1),
-    pNumber25("l2cy", "mm", 50, -200, 200, 1),
-    pNumber25("l2ca", "degree", 35, -200, 200, 1),
-    pNumber25("p3x", "mm", -30, -200, 200, 1),
-    pNumber25("p3y", "mm", 30, -200, 200, 1)
+    pNumber26("l1cx", "mm", 10, -200, 200, 1),
+    pNumber26("l1cy", "mm", 20, -200, 200, 1),
+    pNumber26("l1ca", "degree", 15, -200, 200, 1),
+    pNumber26("l2cx", "mm", 30, -200, 200, 1),
+    pNumber26("l2cy", "mm", 50, -200, 200, 1),
+    pNumber26("l2ca", "degree", 35, -200, 200, 1),
+    pNumber26("p3x", "mm", -30, -200, 200, 1),
+    pNumber26("p3y", "mm", 30, -200, 200, 1)
   ],
   paramSvg: {
     l1cx: "verify_line_2_l1cx.svg",
@@ -6164,20 +6595,20 @@ var pDef25 = {
     // every 0.5 second
   }
 };
-function pGeom25(t, param, suffix = "") {
-  const rGeome = initGeom25(pDef25.partName + suffix);
+function pGeom26(t, param, suffix = "") {
+  const rGeome = initGeom26(pDef26.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure25();
-    const p1 = point11(param.l1cx, param.l1cy);
-    const p2 = point11(param.l2cx, param.l2cy);
-    const p3 = point11(param.p3x, param.p3y);
+    const figOne = figure26();
+    const p1 = point12(param.l1cx, param.l1cy);
+    const p2 = point12(param.l2cx, param.l2cy);
+    const p3 = point12(param.p3x, param.p3y);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
-    const l1 = line2(param.l1cx, param.l1cy, degToRad8(param.l1ca + t));
-    const l2 = line2(param.l2cx, param.l2cy, degToRad8(param.l2ca));
+    const l1 = line2(param.l1cx, param.l1cy, degToRad10(param.l1ca + t));
+    const l2 = line2(param.l2cx, param.l2cy, degToRad10(param.l2ca));
     figOne.addLine(l1);
     figOne.addLine(l2);
     figOne.addPoint(l1.intersection(l2));
@@ -6188,7 +6619,7 @@ function pGeom25(t, param, suffix = "") {
     rGeome.logstr += `dist(l2, p3) = ${l2.distanceToPoint(p3)}
 `;
     const bisector2 = l1.bisector(l2, p3);
-    const pBisec = point11(bisector2.cx, bisector2.cy).translatePolar(bisector2.ca, 30);
+    const pBisec = point12(bisector2.cx, bisector2.cy).translatePolar(bisector2.ca, 30);
     figOne.addPoint(pBisec);
     rGeome.fig = { one: figOne };
     rGeome.logstr += "verify_line_2 drawn successfully!\n";
@@ -6202,22 +6633,22 @@ function pGeom25(t, param, suffix = "") {
 var verifyLine2Def = {
   pTitle: "Verify line 2",
   pDescription: "Debugging more line.ts",
-  pDef: pDef25,
-  pGeom: pGeom25
+  pDef: pDef26,
+  pGeom: pGeom26
 };
 
 // src/geometrix_verification/verify_line_3.ts
-import { point as point12, bisector, circleCenter, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
-var pDef26 = {
+import { point as point13, bisector, circleCenter, figure as figure27, pNumber as pNumber27, initGeom as initGeom27 } from "geometrix";
+var pDef27 = {
   partName: "verify_line_3",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber26("p1x", "mm", 30, -200, 200, 1),
-    pNumber26("p1y", "mm", 50, -200, 200, 1),
-    pNumber26("p2x", "mm", 40, -200, 200, 1),
-    pNumber26("p2y", "mm", -20, -200, 200, 1),
-    pNumber26("p3x", "mm", -30, -200, 200, 1),
-    pNumber26("p3y", "mm", 30, -200, 200, 1)
+    pNumber27("p1x", "mm", 30, -200, 200, 1),
+    pNumber27("p1y", "mm", 50, -200, 200, 1),
+    pNumber27("p2x", "mm", 40, -200, 200, 1),
+    pNumber27("p2y", "mm", -20, -200, 200, 1),
+    pNumber27("p3x", "mm", -30, -200, 200, 1),
+    pNumber27("p3y", "mm", 30, -200, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -6234,15 +6665,15 @@ var pDef26 = {
     // every 0.5 second
   }
 };
-function pGeom26(t, param, suffix = "") {
-  const rGeome = initGeom26(pDef26.partName + suffix);
+function pGeom27(t, param, suffix = "") {
+  const rGeome = initGeom27(pDef27.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure26();
-    const p1 = point12(param.p1x, param.p1y + t);
-    const p2 = point12(param.p2x, param.p2y);
-    const p3 = point12(param.p3x, param.p3y);
+    const figOne = figure27();
+    const p1 = point13(param.p1x, param.p1y + t);
+    const p2 = point13(param.p2x, param.p2y);
+    const p3 = point13(param.p3x, param.p3y);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
@@ -6262,24 +6693,24 @@ function pGeom26(t, param, suffix = "") {
 var verifyLine3Def = {
   pTitle: "Verify line 3",
   pDescription: "Debugging more more line.ts",
-  pDef: pDef26,
-  pGeom: pGeom26
+  pDef: pDef27,
+  pGeom: pGeom27
 };
 
 // src/geometrix_verification/verify_vector.ts
-import { degToRad as degToRad9, point as point13, vector, figure as figure27, pNumber as pNumber27, initGeom as initGeom27 } from "geometrix";
-var pDef27 = {
+import { degToRad as degToRad11, point as point14, vector, figure as figure28, pNumber as pNumber28, initGeom as initGeom28 } from "geometrix";
+var pDef28 = {
   partName: "verify_vector",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber27("p1x", "mm", 30, -200, 200, 1),
-    pNumber27("p1y", "mm", 50, -200, 200, 1),
-    pNumber27("p2x", "mm", 80, -200, 200, 1),
-    pNumber27("p2y", "mm", -30, -200, 200, 1),
-    pNumber27("v1a", "degree", 30, -200, 200, 1),
-    pNumber27("v1l", "mm", 60, 0, 200, 1),
-    pNumber27("v2a", "degree", 30, -200, 200, 1),
-    pNumber27("v2l", "mm", 60, 0, 200, 1)
+    pNumber28("p1x", "mm", 30, -200, 200, 1),
+    pNumber28("p1y", "mm", 50, -200, 200, 1),
+    pNumber28("p2x", "mm", 80, -200, 200, 1),
+    pNumber28("p2y", "mm", -30, -200, 200, 1),
+    pNumber28("v1a", "degree", 30, -200, 200, 1),
+    pNumber28("v1l", "mm", 60, 0, 200, 1),
+    pNumber28("v2a", "degree", 30, -200, 200, 1),
+    pNumber28("v2l", "mm", 60, 0, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_vector_p1x.svg",
@@ -6298,16 +6729,16 @@ var pDef27 = {
     // every 0.5 second
   }
 };
-function pGeom27(t, param, suffix = "") {
-  const rGeome = initGeom27(pDef27.partName + suffix);
+function pGeom28(t, param, suffix = "") {
+  const rGeome = initGeom28(pDef28.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure27();
-    const p1 = point13(param.p1x, param.p1y + t);
-    const p2 = point13(param.p2x, param.p2y);
-    const v1 = vector(degToRad9(param.v1a), param.v1l, p1);
-    const v2 = vector(degToRad9(param.v2a), param.v2l, p1);
+    const figOne = figure28();
+    const p1 = point14(param.p1x, param.p1y + t);
+    const p2 = point14(param.p2x, param.p2y);
+    const v1 = vector(degToRad11(param.v1a), param.v1l, p1);
+    const v2 = vector(degToRad11(param.v2a), param.v2l, p1);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addVector(v1);
@@ -6328,22 +6759,22 @@ function pGeom27(t, param, suffix = "") {
 var verifyVector1Def = {
   pTitle: "Verify vector",
   pDescription: "Debugging vector.ts",
-  pDef: pDef27,
-  pGeom: pGeom27
+  pDef: pDef28,
+  pGeom: pGeom28
 };
 
 // src/geometrix_verification/verify_contour_1.ts
-import { contour as contour19, contourCircle as contourCircle17, figure as figure28, pNumber as pNumber28, initGeom as initGeom28 } from "geometrix";
-var pDef28 = {
+import { contour as contour19, contourCircle as contourCircle18, figure as figure29, pNumber as pNumber29, initGeom as initGeom29 } from "geometrix";
+var pDef29 = {
   partName: "verify_contour_1",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber28("r1", "mm", 30, 10, 200, 1),
-    pNumber28("d1", "mm", 20, 10, 200, 1),
-    pNumber28("w1", "mm", 100, 10, 200, 1),
-    pNumber28("r2", "mm", 60, 10, 200, 1),
-    pNumber28("l1", "mm", 10, 5, 200, 1),
-    pNumber28("l2", "mm", 30, 5, 200, 1)
+    pNumber29("r1", "mm", 30, 10, 200, 1),
+    pNumber29("d1", "mm", 20, 10, 200, 1),
+    pNumber29("w1", "mm", 100, 10, 200, 1),
+    pNumber29("r2", "mm", 60, 10, 200, 1),
+    pNumber29("l1", "mm", 10, 5, 200, 1),
+    pNumber29("l2", "mm", 30, 5, 200, 1)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -6360,12 +6791,12 @@ var pDef28 = {
     // every 0.5 second
   }
 };
-function pGeom28(t, param, suffix = "") {
-  const rGeome = initGeom28(pDef28.partName + suffix);
+function pGeom29(t, param, suffix = "") {
+  const rGeome = initGeom29(pDef29.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure28();
+    const figOne = figure29();
     const r1 = param.r1;
     const d1 = param.d1;
     const w1 = param.w1;
@@ -6385,10 +6816,10 @@ function pGeom28(t, param, suffix = "") {
     ctr1.closeSegStroke();
     ctr1.check();
     figOne.addMain(ctr1);
-    figOne.addMain(contourCircle17(w12, c1, r1));
-    figOne.addMain(contourCircle17(w12, c2, r1 + t));
-    figOne.addMain(contourCircle17(w12, c3, r1));
-    const ctr2 = contourCircle17(w1 + r2, 3 * c1, r2);
+    figOne.addMain(contourCircle18(w12, c1, r1));
+    figOne.addMain(contourCircle18(w12, c2, r1 + t));
+    figOne.addMain(contourCircle18(w12, c3, r1));
+    const ctr2 = contourCircle18(w1 + r2, 3 * c1, r2);
     ctr2.check();
     figOne.addSecond(ctr2);
     const ctr3 = contour19(200 + l1, 200).addSegStrokeA(200 + l1 + l2, 200).addSegStrokeR(0, l1).addSegStrokeRP(0, l1).addSegStrokeRP(Math.PI / 2, l2).addSegStrokeAP(Math.PI / 4, Math.sqrt(2) * (200 + l1 + l2)).addSegStrokeA(200 + l1 + l2, 200 + 2 * l1 + l2).addSegStrokeR(-l2, 0).addSegStrokeR(0, -l1).addSegStrokeR(-l1, 0).addSegStrokeRP(-Math.PI / 2, l2).addSegStrokeR(l1, 0).closeSegStroke();
@@ -6406,20 +6837,20 @@ function pGeom28(t, param, suffix = "") {
 var verifyContour1Def = {
   pTitle: "Verify contour 1",
   pDescription: "Debugging contour.ts",
-  pDef: pDef28,
-  pGeom: pGeom28
+  pDef: pDef29,
+  pGeom: pGeom29
 };
 
 // src/geometrix_verification/verify_contour_2.ts
-import { degToRad as degToRad10, contour as contour20, figure as figure29, pNumber as pNumber29, initGeom as initGeom29 } from "geometrix";
-var pDef29 = {
+import { degToRad as degToRad12, contour as contour20, figure as figure30, pNumber as pNumber30, initGeom as initGeom30 } from "geometrix";
+var pDef30 = {
   partName: "verify_contour_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber29("r1", "mm", 20, 5, 200, 1),
-    pNumber29("a1", "deg", 30, -200, 200, 1),
-    pNumber29("at1", "deg", 30, -200, 200, 1),
-    pNumber29("at2", "deg", 50, -200, 200, 1)
+    pNumber30("r1", "mm", 20, 5, 200, 1),
+    pNumber30("a1", "deg", 30, -200, 200, 1),
+    pNumber30("at1", "deg", 30, -200, 200, 1),
+    pNumber30("at2", "deg", 50, -200, 200, 1)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -6434,12 +6865,12 @@ var pDef29 = {
     // every 0.5 second
   }
 };
-function pGeom29(t, param, suffix = "") {
-  const rGeome = initGeom29(pDef29.partName + suffix);
+function pGeom30(t, param, suffix = "") {
+  const rGeome = initGeom30(pDef30.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure29();
+    const figOne = figure30();
     const r1 = param.r1 + t;
     const ata = param.a1 + t;
     const at1 = param.at1 + t;
@@ -6481,17 +6912,17 @@ function pGeom29(t, param, suffix = "") {
     ctr2.addSegStrokeR(20, 20).addPointR(20, 20).addSegArc(r1, false, false).addPointRP(Math.PI / 4, 28).addSegArc(r1, false, true).addPointRP(Math.PI / 4, 28).addSegArc(r1, true, true).addPointRP(Math.PI / 4, 28).addSegArc(r1, true, false).addSegStrokeRP(Math.PI / 4, 20).addSegStrokeRP(-Math.PI / 4, 20).addPointR(10, -9).addPointR(20, -20).addSegArc2().addPointR(20, -9).addPointR(20, -20).addSegArc2().addPointR(9, -6).addPointR(20, -20).addSegArc2().addPointR(9, -14).addPointR(20, -20).addSegArc2().addPointR(9, 0).addPointR(20, -20).addSegArc2().addSegStrokeR(20, -20).addSegStrokeR(20, 20).addPointR(9, 20).addPointR(20, 20).addSegArc2().addPointR(20, 10).addPointR(20, 20).addSegArc2().addPointR(9, 6).addPointR(20, 20).addSegArc2().addPointR(9, 14).addPointR(20, 20).addSegArc2().addPointR(9, 0).addPointR(20, 20).addSegArc2().addSegStrokeR(20, 20).addSegStrokeR(0, 20).addPointR(15, 8).addPointR(0, 20).addSegArc2().addPointR(-15, 8).addPointR(0, 20).addSegArc2().addPointR(5, 8).addPointR(0, 20).addSegArc2().addPointR(-5, 8).addPointR(0, 20).addSegArc2().addSegStrokeR(0, 20).addSegStrokeR(20, 0).addPointR(8, 15).addPointR(20, 0).addSegArc2().addPointR(8, -15).addPointR(20, 0).addSegArc2().addPointR(8, 5).addPointR(20, 0).addSegArc2().addPointR(8, -5).addPointR(20, 0).addSegArc2().addSegStrokeR(20, 0).addSegStrokeR(0, -20).addPointR(15, -8).addPointR(0, -20).addSegArc2().addPointR(-15, -8).addPointR(0, -20).addSegArc2().addPointR(5, -8).addPointR(0, -20).addSegArc2().addPointR(-5, -8).addPointR(0, -20).addSegArc2().addSegStrokeR(0, -20).addSegStrokeR(-20, 0).addPointR(-8, 15).addPointR(-20, 0).addSegArc2().addPointR(-8, -15).addPointR(-20, 0).addSegArc2().addPointR(-8, 5).addPointR(-20, 0).addSegArc2().addPointR(-8, -5).addPointR(-20, 0).addSegArc2().addSegStrokeR(-20, 0).closeSegStroke();
     ctr2.check();
     figOne.addMain(ctr2);
-    const ctr3 = contour20(200, 200).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad10(ata), true).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad10(ata), false).addSegStrokeR(20, 0).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad10(ata), true).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad10(ata), false).addSegStrokeR(0, 20).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad10(ata), true).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad10(ata), false).addSegStrokeR(-20, 0).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad10(ata), true).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad10(ata), false).addSegStrokeR(0, -20);
+    const ctr3 = contour20(200, 200).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad12(ata), true).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad12(ata), false).addSegStrokeR(20, 0).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad12(ata), true).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad12(ata), false).addSegStrokeR(0, 20).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad12(ata), true).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad12(ata), false).addSegStrokeR(-20, 0).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad12(ata), true).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad12(ata), false).addSegStrokeR(0, -20);
     ctr3.check();
     figOne.addMain(ctr3);
-    const ctr4 = contour20(600, 200).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad10(ata), true).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad10(ata), false).addSegStrokeR(20, 20).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad10(ata), true).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad10(ata), false).addSegStrokeR(-20, 20).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad10(ata), true).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad10(ata), false).addSegStrokeR(-20, -20).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad10(ata), true).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad10(ata), false).addSegStrokeR(20, -20);
+    const ctr4 = contour20(600, 200).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad12(ata), true).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad12(ata), false).addSegStrokeR(20, 20).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad12(ata), true).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad12(ata), false).addSegStrokeR(-20, 20).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad12(ata), true).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad12(ata), false).addSegStrokeR(-20, -20).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad12(ata), true).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad12(ata), false).addSegStrokeR(20, -20);
     ctr4.check();
     figOne.addMain(ctr4);
     const ctr5 = contour20(100, 500);
     for (let i = 0; i < 8; i++) {
       const adir = i * 45;
-      const adirRad = degToRad10(adir);
-      ctr5.addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad10(adir + at1), degToRad10(180 + adir - at2)).addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad10(adir - at1), degToRad10(180 + adir + at2)).addSegStrokeRP(adirRad, 20);
+      const adirRad = degToRad12(adir);
+      ctr5.addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad12(adir + at1), degToRad12(180 + adir - at2)).addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad12(adir - at1), degToRad12(180 + adir + at2)).addSegStrokeRP(adirRad, 20);
     }
     ctr5.check();
     figOne.addMain(ctr5);
@@ -6507,22 +6938,22 @@ function pGeom29(t, param, suffix = "") {
 var verifyContour2Def = {
   pTitle: "Verify contour 2",
   pDescription: "Debugging more contour.ts",
-  pDef: pDef29,
-  pGeom: pGeom29
+  pDef: pDef30,
+  pGeom: pGeom30
 };
 
 // src/geometrix_verification/verify_contour_3.ts
-import { degToRad as degToRad11, contour as contour21, figure as figure30, pNumber as pNumber30, initGeom as initGeom30 } from "geometrix";
-var pDef30 = {
+import { degToRad as degToRad13, contour as contour21, figure as figure31, pNumber as pNumber31, initGeom as initGeom31 } from "geometrix";
+var pDef31 = {
   partName: "verify_contour_3",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber30("r1", "mm", 10, 0, 200, 1),
-    pNumber30("r2", "mm", 10, 0, 200, 1),
-    pNumber30("r3", "mm", 10, 0, 200, 1),
-    pNumber30("r4", "mm", 10, 0, 200, 1),
-    pNumber30("r5", "mm", 10, 0, 200, 1),
-    pNumber30("r6", "mm", 5, 0, 200, 1)
+    pNumber31("r1", "mm", 10, 0, 200, 1),
+    pNumber31("r2", "mm", 10, 0, 200, 1),
+    pNumber31("r3", "mm", 10, 0, 200, 1),
+    pNumber31("r4", "mm", 10, 0, 200, 1),
+    pNumber31("r5", "mm", 10, 0, 200, 1),
+    pNumber31("r6", "mm", 5, 0, 200, 1)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -6539,12 +6970,12 @@ var pDef30 = {
     // every 0.5 second
   }
 };
-function pGeom30(t, param, suffix = "") {
-  const rGeome = initGeom30(pDef30.partName + suffix);
+function pGeom31(t, param, suffix = "") {
+  const rGeome = initGeom31(pDef31.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure30();
+    const figOne = figure31();
     const r1 = param.r1 + t;
     const r2 = param.r2 + t;
     const r3 = param.r3 + t;
@@ -6558,7 +6989,7 @@ function pGeom30(t, param, suffix = "") {
     const ctr2 = contour21(300, 0);
     for (let i = 0; i < 4; i++) {
       const angle = 90 * (1 - i);
-      ctr2.addSegStrokeRP(degToRad11(angle), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle - 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle + 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle), l2).addCornerRounded(r2);
+      ctr2.addSegStrokeRP(degToRad13(angle), l2).addCornerRounded(r2).addSegStrokeRP(degToRad13(angle - 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad13(angle + 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad13(angle), l2).addCornerRounded(r2);
     }
     rGeome.logstr += ctr2.check();
     figOne.addMain(ctr2);
@@ -6658,19 +7089,19 @@ function pGeom30(t, param, suffix = "") {
 var verifyContour3Def = {
   pTitle: "Verify contour 3",
   pDescription: "Debugging contour.ts for rounded corners and widened corners",
-  pDef: pDef30,
-  pGeom: pGeom30
+  pDef: pDef31,
+  pGeom: pGeom31
 };
 
 // src/geometrix_verification/verify_contour_4.ts
-import { contour as contour22, figure as figure31, pNumber as pNumber31, initGeom as initGeom31 } from "geometrix";
-var pDef31 = {
+import { contour as contour22, figure as figure32, pNumber as pNumber32, initGeom as initGeom32 } from "geometrix";
+var pDef32 = {
   partName: "verify_contour_4",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber31("n1", "scalar", 16, 1, 50, 1),
-    pNumber31("n2", "scalar", 6, 3, 50, 1),
-    pNumber31("r1", "mm", 5, 0, 20, 1)
+    pNumber32("n1", "scalar", 16, 1, 50, 1),
+    pNumber32("n2", "scalar", 6, 3, 50, 1),
+    pNumber32("r1", "mm", 5, 0, 20, 1)
   ],
   paramSvg: {
     n1: "verify_contour_1_r1.svg",
@@ -6684,12 +7115,12 @@ var pDef31 = {
     // every 0.5 second
   }
 };
-function pGeom31(t, param, suffix = "") {
-  const rGeome = initGeom31(pDef31.partName + suffix);
+function pGeom32(t, param, suffix = "") {
+  const rGeome = initGeom32(pDef32.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure31();
+    const figOne = figure32();
     const n1 = param.n1;
     const n2 = param.n2;
     const r1 = param.r1;
@@ -6736,29 +7167,29 @@ function pGeom31(t, param, suffix = "") {
 var verifyContour4Def = {
   pTitle: "Verify contour 4",
   pDescription: "Debugging contour.ts for addPartial",
-  pDef: pDef31,
-  pGeom: pGeom31
+  pDef: pDef32,
+  pGeom: pGeom32
 };
 
 // src/geometrix_verification/verify_exports_1.ts
 import {
   contour as contour23,
-  contourCircle as contourCircle18,
-  figure as figure32,
-  pNumber as pNumber32,
+  contourCircle as contourCircle19,
+  figure as figure33,
+  pNumber as pNumber33,
   pCheckbox as pCheckbox5,
-  initGeom as initGeom32,
-  EExtrude as EExtrude16,
-  EBVolume as EBVolume19
+  initGeom as initGeom33,
+  EExtrude as EExtrude17,
+  EBVolume as EBVolume20
 } from "geometrix";
-var pDef32 = {
+var pDef33 = {
   partName: "verify_exports_1",
   params: [
     //pNumber(name, unit, init, min, max, step)
     pCheckbox5("circle", true),
-    pNumber32("circle-size", "mm", 100, 1, 1e3, 1),
+    pNumber33("circle-size", "mm", 100, 1, 1e3, 1),
     pCheckbox5("contour", true),
-    pNumber32("contour-size", "mm", 30, 1, 1e3, 1),
+    pNumber33("contour-size", "mm", 30, 1, 1e3, 1),
     pCheckbox5("contour-arc-large", false)
   ],
   paramSvg: {
@@ -6774,14 +7205,14 @@ var pDef32 = {
     tUpdate: 500
   }
 };
-function pGeom32(t, param, suffix = "") {
-  const rGeome = initGeom32(pDef32.partName + suffix);
+function pGeom33(t, param, suffix = "") {
+  const rGeome = initGeom33(pDef33.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure32();
+    const figOne = figure33();
     if (param.circle === 1) {
-      const theCircle = contourCircle18(0, 0, param["circle-size"]);
+      const theCircle = contourCircle19(0, 0, param["circle-size"]);
       figOne.addMain(theCircle);
     }
     if (param.contour === 1) {
@@ -6797,7 +7228,7 @@ function pGeom32(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_one`,
           face: `${designName}_one`,
-          extrudeMethod: EExtrude16.eLinearOrtho,
+          extrudeMethod: EExtrude17.eLinearOrtho,
           length: 10,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -6806,7 +7237,7 @@ function pGeom32(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume19.eIdentity,
+          boolMethod: EBVolume20.eIdentity,
           inList: [`subpax_${designName}_one`]
         }
       ]
@@ -6822,14 +7253,15 @@ function pGeom32(t, param, suffix = "") {
 var verifyExports1Def = {
   pTitle: "Verify exports 1",
   pDescription: "For dev & debug of Openscad export",
-  pDef: pDef32,
-  pGeom: pGeom32
+  pDef: pDef33,
+  pGeom: pGeom33
 };
 export {
   baseDef,
   circlesDef,
   dummyPoleStaticDef,
   gearWheelWheelDef,
+  haxisGuidanceDef,
   heliostatDef,
   heliostat_2Def,
   poleStaticDef,