designix 0.5.27 → 0.5.29

package/dist/index.js

@@ -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) {
@@ -3025,6 +3098,7 @@ 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));
     }
@@ -3072,13 +3146,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;
+            })
+          ]
         }
       ]
     };
@@ -3435,8 +3527,9 @@ import {
   designParam as designParam4,
   checkGeom as checkGeom4,
   prefixLog as prefixLog4,
-  contour as contour10,
   contourCircle as contourCircle8,
+  ctrRectangle as ctrRectangle2,
+  ctrRectRot,
   figure as figure9,
   radToDeg as radToDeg7,
   ffix as ffix11,
@@ -3482,10 +3575,17 @@ 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"),
+    pSectionSeparator8("stoppers"),
     pNumber9("S1", "mm", 100, 1, 300, 1),
     pNumber9("S2", "mm", 2e3, 1, 8e3, 1),
-    pNumber9("E7", "mm", 5, 1, 80, 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)
   ],
   paramSvg: {
     D1: "rake_face.svg",
@@ -3518,7 +3618,13 @@ var pDef9 = {
     R9: "rake_door.svg",
     S1: "rake_side_stopper.svg",
     S2: "rake_top_stopper.svg",
-    E7: "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"
   },
   sim: {
     tMax: 180,
@@ -3529,7 +3635,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 +3650,65 @@ function pGeom9(t, param, suffix = "") {
   const figStopperFaceTH = figure9();
   const figStopperFaceB = figure9();
   const figStopperFaceBH = figure9();
+  const figLowStopperHolderPre = figure9();
+  const figLowStopperHolder = 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 stopper2H = param.H1 + param.H2 - param.H4 + param.D4 / 2;
+    const stopper3H = param.H1 + param.L8 - param.S1;
+    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 - param.S1 / 2;
+    const lowSPosY = stopper1H - S1r;
+    const lowSHPosZ = stopper1H - param.JH1;
+    const JR1 = param.JD1 / 2;
+    const JR1H = JR1 - param.JE1;
+    const lowSHL = R1 + param.JS2;
     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}`;
+    }
+    rGeome.logstr += `cone-height: ${ffix11(H1H2)} mm
+`;
+    rGeome.logstr += `cone-height total: ${ffix11(H1H5)} mm
+`;
+    figLowStopperHolderPre.addSecond(ctrRectangle2(-L5h, lowSPosY, param.L5, param.S1));
+    figLowStopperHolderPre.addSecond(ctrRectangle2(-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);
@@ -3608,6 +3742,7 @@ function pGeom9(t, param, suffix = "") {
     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,31 +3750,31 @@ 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(ctrRectangle2(lowStopperTopPosX, -L5h, param.S1, param.L5));
+    figStopperTop.addMain(ctrRectangle2(lowStopperTopPosX + param.E7, -L5h, S1h, param.L5));
+    figStopperTop.addMain(ctrRectangle2(param.S2 - param.S1, -L5h, param.S1, param.L5));
+    figStopperTop.addMain(ctrRectangle2(param.S2 - param.E7 - S1h, -L5h, S1h, param.L5));
+    figStopperTop.addMain(ctrRectangle2(0, -L5h, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle2(0, -L5h + param.E7, S2s, S1h));
+    figStopperTop.addMain(ctrRectangle2(0, L5h - param.S1, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle2(0, L5h - param.S1 + param.E7, S2s, S1h));
+    figStopperTop.addMain(ctrRectangle2(0, -R1 - param.S1, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle2(0, -R1 - param.S1 + param.E7, S2s, S1h));
+    figStopperTop.addMain(ctrRectangle2(0, R1, S2s, param.S1));
+    figStopperTop.addMain(ctrRectangle2(0, R1 + param.E7, S2s, S1h));
+    figStopperTop.addSecond(ctrRectangle2(-lowSHL, -param.JL1 / 2 - JR1, lowSHL, 2 * JR1));
+    figStopperTop.addSecond(ctrRectangle2(-lowSHL, -param.JL1 / 2 - JR1H, lowSHL, 2 * JR1H));
+    figStopperTop.addSecond(ctrRectangle2(-lowSHL, param.JL1 / 2 - JR1, lowSHL, 2 * JR1));
+    figStopperTop.addSecond(ctrRectangle2(-lowSHL, param.JL1 / 2 - JR1H, lowSHL, 2 * JR1H));
     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(-R1 - param.JS1, stopper1H, S1r));
+    figStopperSide.addMain(contourCircle8(-R1 - param.JS1, stopper1H, 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));
+    figStopperSide.addSecond(ctrRectangle2(0, stopper2H, S2s, param.S1));
+    figStopperSide.addSecond(ctrRectangle2(0, stopper2H + param.E7, S2s, S1h));
     const stopper3Ly = stopper2H + param.S1 / 2 - stopper3H;
     const stopper3L = Math.sqrt(S2s ** 2 + stopper3Ly ** 2);
     const stopper3A = Math.atan2(stopper3Ly, S2s);
@@ -3650,36 +3785,46 @@ function pGeom9(t, param, suffix = "") {
     const stp3posdX = S1r * Math.sin(stopper3A);
     const stp3posdY = S1r * Math.cos(stopper3A);
     const stp3posY = stopper3H - stp3posdY;
-    figStopperSide.addSecond(ctrRect(stopper3L, param.S1, stp3posdX, stp3posY, stopper3A));
+    figStopperSide.addSecond(ctrRectRot(stp3posdX, stp3posY, stopper3L, param.S1, stopper3A));
     const stp3posdX2 = S1hr * Math.sin(stopper3A);
     const stp3posdY2 = S1hr * Math.cos(stopper3A);
     const stp3posY2 = stopper3H - stp3posdY2;
-    figStopperSide.addSecond(ctrRect(stopper3L, S1h, stp3posdX2, stp3posY2, stopper3A));
+    figStopperSide.addSecond(ctrRectRot(stp3posdX2, stp3posY2, stopper3L, S1h, stopper3A));
+    figStopperSide.addSecond(ctrRectangle2(-lowSHL, lowSHPosZ - JR1, lowSHL, 2 * JR1));
+    figStopperSide.addSecond(ctrRectangle2(-lowSHL, lowSHPosZ - JR1H, lowSHL, 2 * JR1H));
     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(-R1 - param.JS1, stopper1H, S1r));
+    figStopperSideH.addMain(contourCircle8(-R1 - param.JS1, stopper1H, S1hr));
     figStopperSideH.addSecond(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1r));
     figStopperSideH.addMain(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1hr));
+    figStopperSideH.addSecond(ctrRectangle2(-lowSHL, lowSHPosZ - JR1, lowSHL, 2 * JR1));
+    figStopperSideH.addSecond(ctrRectangle2(-lowSHL, lowSHPosZ - JR1H, lowSHL, 2 * JR1H));
     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);
     rGeome.fig = {
       faceCone: figCone,
       faceBeam: figBeam,
@@ -3695,7 +3840,8 @@ function pGeom9(t, param, suffix = "") {
       faceStopperFaceT: figStopperFaceT,
       faceStopperFaceTH: figStopperFaceTH,
       faceStopperFaceB: figStopperFaceB,
-      faceStopperFaceBH: figStopperFaceBH
+      faceStopperFaceBH: figStopperFaceBH,
+      faceLowStopperHolder: figLowStopperHolder
     };
     const designName = rGeome.partName;
     rGeome.vol = {
@@ -4085,7 +4231,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 +4318,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 +4337,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 +4444,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 +4498,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 +4577,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 +4649,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 +4673,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 +4744,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 +4830,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 +4884,11 @@ var ringGuidanceDef = {
 // src/heliostat/vaxis_guidance.ts
 import {
   contourCircle as contourCircle13,
-  ctrRectangle as ctrRectangle2,
+  ctrRectangle as ctrRectangle3,
   figure as figure15,
   ffix as ffix17,
   pNumber as pNumber15,
+  pDropdown as pDropdown2,
   pSectionSeparator as pSectionSeparator14,
   initGeom as initGeom15,
   EExtrude as EExtrude12,
@@ -4759,18 +4906,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 +4936,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 +4986,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(ctrRectangle3(R6, 0, w1, param.T1));
+    figSection.addMain(ctrRectangle3(-R6 - w1, 0, w1, param.T1));
+    figSection.addSecond(ctrRectangle3(R1 - R3, 0, 2 * R3, param.T1));
+    figSection.addSecond(ctrRectangle3(-R1 - R3, 0, 2 * R3, param.T1));
     rGeome.fig = {
       faceTop: figTop,
       faceSection: figSection
@@ -4876,37 +5030,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 ctrRectangle4,
   figure as figure16,
+  degToRad as degToRad6,
   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 + degToRad6(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(ctrRectangle4(0, -R8plus, param.L4, R8 + R8plus));
+    figSide.addSecond(ctrRectangle4(0, -R8, param.L4, 2 * R8));
+    figSide.addSecond(ctrRectangle4(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 +5240,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 +5306,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 +5314,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 +5323,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 +5340,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 +5416,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 +5446,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 +5498,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 +5581,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 +5606,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 +5614,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 +5622,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 +5634,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 +5646,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 +5658,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 +5670,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 +5682,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 +5694,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 +5706,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 +5718,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 +5726,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 +5735,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 +5745,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 +5755,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 +5774,7 @@ function pGeom17(t, param, suffix = "") {
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume17.eSubstraction,
+          boolMethod: EBVolume18.eSubstraction,
           inList: [`ipax_${designName}_plus`, `ipax_${designName}_rodHollow`]
         }
       ]
@@ -5481,54 +5791,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 +5873,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 +5925,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 +6007,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 +6058,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 +6069,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 +6089,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 degToRad7, 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 +6114,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 * degToRad7(param.angle) + t * Math.PI / 2 / pDef20.sim.tMax)
       );
     }
     rGeome.fig = { one: figOne };
@@ -5830,18 +6140,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 +6163,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 +6190,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 +6222,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 +6246,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 degToRad8, 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 +6278,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(degToRad8(param.p2a), param.p2l);
+    const p3 = p1.rotateOrig(degToRad8(param.rotateOrig));
     const p4 = p1.scaleOrig(param.scaleOrig);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
@@ -5994,23 +6304,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 +6338,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 +6366,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 +6398,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 +6438,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 degToRad9, 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 +6474,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, degToRad9(param.l1ca + t));
+    const l2 = line2(param.l2cx, param.l2cy, degToRad9(param.l2ca));
     figOne.addLine(l1);
     figOne.addLine(l2);
     figOne.addPoint(l1.intersection(l2));
@@ -6188,7 +6498,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 +6512,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 +6544,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 +6572,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 degToRad10, 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 +6608,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(degToRad10(param.v1a), param.v1l, p1);
+    const v2 = vector(degToRad10(param.v2a), param.v2l, p1);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addVector(v1);
@@ -6328,22 +6638,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 +6670,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 +6695,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 +6716,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 degToRad11, 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 +6744,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 +6791,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(degToRad11(ata), true).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad11(ata), false).addSegStrokeR(20, 0).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad11(ata), true).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad11(ata), false).addSegStrokeR(0, 20).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad11(ata), true).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad11(ata), false).addSegStrokeR(-20, 0).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad11(ata), true).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad11(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(degToRad11(ata), true).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad11(ata), false).addSegStrokeR(20, 20).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad11(ata), true).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad11(ata), false).addSegStrokeR(-20, 20).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad11(ata), true).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad11(ata), false).addSegStrokeR(-20, -20).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad11(ata), true).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad11(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 = degToRad11(adir);
+      ctr5.addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad11(adir + at1), degToRad11(180 + adir - at2)).addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad11(adir - at1), degToRad11(180 + adir + at2)).addSegStrokeRP(adirRad, 20);
     }
     ctr5.check();
     figOne.addMain(ctr5);
@@ -6507,22 +6817,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 degToRad12, 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 +6849,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 +6868,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(degToRad12(angle), l2).addCornerRounded(r2).addSegStrokeRP(degToRad12(angle - 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad12(angle + 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad12(angle), l2).addCornerRounded(r2);
     }
     rGeome.logstr += ctr2.check();
     figOne.addMain(ctr2);
@@ -6658,19 +6968,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 +6994,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 +7046,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 +7084,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 +7107,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 +7116,7 @@ function pGeom32(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume19.eIdentity,
+          boolMethod: EBVolume20.eIdentity,
           inList: [`subpax_${designName}_one`]
         }
       ]
@@ -6822,14 +7132,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,